避免为未默认的参数创建临时变量？

Question

这听起来可能是个疯狂的问题。

在我的 C++ 代码中，我创建了一个这样的方法

void Func(int & param_1, bool & param_2, float & param_3, double & param_4) {
   //some logic
}

所以我调用main 中的方法，如下所示：

int i_val;
bool b_val;
float f_val;
double d_val;

//invoke Func here
Func(i_val, b_val, f_val, d_val);

问题：有没有办法避免创建临时变量i_val, b_val, f_val 等等？并在调用本身的行中创建它们？

我只对创建 i_val 和 b_val 并获取它们的值感兴趣。 f_val 和 d_val 对我来说是不必要的，但在其他一些与我无关的电话中是必需的。有没有办法避免创建临时变量只是将每个参数传递给调用？

我知道我们可以将最后 2 个参数设置为默认参数，但是使用默认参数会使函数参数忽略调用者。有没有办法不将最后 2 个参数设为默认值？在调用方法的那一刻动态创建 float 和 double 变量

我知道我会收到关于您为什么不想使用默认参数而只是检查是否有可能的交叉问题:)

Answer 1

当你有 四个 参数时，就像你在这里做的那样：

void Func(int & param_1, bool & param_2, float & param_3, double & param_4);

这表明你真的想返回一个有 4 个成员的对象，比如：

std::tuple<int, bool, float, double> Func();

或：

struct X {
    int some;
    bool meaningful;
    float names;
    double here;
};

X Func();

这样，你可以写：

auto res = Func();

然后只使用您想要的字段。

---

在 C++17 中，具有结构化绑定，可以是：

auto [ival, bval, _1, _2] = Func();

没有真正明确的方式来表达您不关心第 3 和第 4 成员的概念，但这还不错。

Answer 2

C++ 经验法则： 当你做一些强制性的事情时的参考 当你做一些可选的事情时的指针。当然，该函数中的代码需要考虑可以传递的nullptr。

做起来

void Func(int* pParam_1, bool* pParam_2, float* pParam_3, double* pParam_4) {
// some logic
}

Answer 3

使用非const 引用，例如您拥有的，不。您可以考虑函数重载，返回包含这些值的 struct，甚至从 C++11 开始返回 std::tuple。 （请注意，std::tuple 在 C++14 中得到了重大升级。）

如果您引用 const^* 并依赖返回的结果值，事情会变得更好。然后，您可以在调用站点将 匿名临时对象 传递给您的函数：

/*something*/ Func(const int& param_1, const bool& param_2, /*etc*/) {
}

并使用Func(1, true) 等调用。使用const 引用，您甚至可以提供默认值：

/*something*/ Func(const int& param_1 = 1, const bool& params_2 = true, /*etc*/){

---

^* 一些编译器允许将匿名临时绑定到非const 引用作为扩展/无意的错误。但如果我是你，我不会依赖它。

Answer 4

你可以，但你必须注意，虚拟临时人员会在完整表达式结束时死亡：

template <typename T>
T& stay(T&& x = T()) {
    return x;
}

void Func(int& param_1, bool& param_2, float& param_3, double& param_4) {
   //some logic
}

int main() {
    int arg_1; float arg_3;
    Func(arg_1, stay<bool>(), arg_3, stay(42.0));
}

stay 将右值转换为左值，因此与std::move 相反。

Answer 5

在调用方法的时候动态创建浮点和双变量

为此，请使用您想要的值创建一个匿名临时。然后将其强制转换，以便您可以绑定到左值引用。

template<class T>
T& as_lvalue(T&& t={}){return t;}

void Func(int& param_1, bool& param_2, float& param_3, double& param_4) {
}

int main() {
  int a1;
  float a3;
  Func(a1, as_lvalue(false), a3, as_lvalue(3.14));
}

as_lvalue 接受一个右值（或左值！）并将其转换为相同类型的左值。然后它可以绑定到一个左值引用，并在表达式的末尾被丢弃。

如果你不在乎它们的价值是什么，你甚至可以这样做：

int main() {
  int a1;
  float a3;
  Func(a1, as_lvalue<bool>(), a3, as_lvalue<double>());
}

请注意，使用引用参数作为纯参数会有点代码味道。使用时，参考参数应该是in-out参数；它们的进出价值应该是有用的。

同时传入和取出数据的参数也很危险，因为它使推理函数的行为变得更加困难。

一种非常干净的方法是获取并返回一个结构。

struct FuncArgs {
  int param_1;
  bool param_2;
  float param_3;
  double param_4;
};
FuncArgs Func(FuncArgs) {
  //some logic
}

人们可以这样称呼它：

Func({3, true, 42.f, 3.14})

并像这样获取返回数据：

auto r = Func({3, true, 42.f, 3.14})
int param1 = r.param1;
bool param2 = r.param2;

忽略返回的param3 和param4。

在 C++17 中，他们甚至可以这样做：

auto[param1, param2, donotcare, alsodonotcare] = Func({3, true, 42.f, 3.14});

遗憾的是，无法完全跳过 donotcare 和 alsodonotcare 字段。

但是，如果您的数据是纯结果，我们只需去除 FuncArgs 参数。

现在，修改每个调用Func 的位置可能很烦人；但是由于重载的奇迹，我们可以写：

inline FuncArgs Func() {
  FuncArgs args;
  Func(args.param1, args.param2, args.param3, args.param4);
  return args;
}

或

inline FuncArgs Func(FuncArgs args) {
  Func(args.param1, args.param2, args.param3, args.param4);
  return args;
}

两人幸福地生活在一起。无需触及现有代码；新代码是。