Question

我有一个想法，或者只是关于某些用法中的临时变量替换的问题。

具有相同功能的较少代码是使代码更易于阅读的良好策略。

例如，如果有一些函数返回指针，我们需要使用结果指针几次，而不是我们需要编码：

MyType *tempVariable=myFunctionGetNewTempValue();
tempVariable->doThis();
tempVariable->doSomethingElse();
delete tempVariable;

我建议使用更易读的代码来执行相同的操作：

for_this(MyType *temp_variable, myFunctionGetNewTempValue())
{
temp_variable->doThis();
temp_variable->doSomethingElse();
delete temp_variable;
}

temp_variable当然应该保持指针功能结果。

另一个例子：

int temp_variable = 3*400*myVariable/1000.0;
myFunc1(temp_variable);
myFunc2(temp_variable/2);

更换建议：

for_this(int temp_variable, 3*400*myVariable/1000.0)
{
myFunc1(temp_variable);
myFunc2(temp_variable/2);
}

或许看起来应该是这样的：

for_this(3*400*myVariable/1000.0)
{
myFunc1(this_result);
myFunc2(this_result/2);
}

temp_variable应为计算结果数3 * 400 * myVariable / 1000.0并在}}后自动释放

我通常喜欢这样：

{
int tempVariable=3*400*myVariable/1000.0;
myFunc1(tempVariable);
myFunc2(tempVariable/2);
}

但是我认为一个接一个地阻塞看起来很混乱：

{
int tempVariable=3*400*myVariable/1000.0;
myFunc1(tempVariable);
myFunc2(tempVariable/2);
}
{
int tempVariable2=3*myVariable2/1000.0;
myFunc3(tempVariable2);
myFunc4(tempVariable2/2);
}

在阅读此代码时，我总是向自己提出问题“我错过了'其他'之间的} {？”。

当temp_variable是一些应该在使用后释放的大结构时，此方法也应该是有用的。所以我们不会忘记在这种情况下释放它。

是否有C ++方法允许做类似的事情？

Answer 1

在C ++中，我们使用＆＃34;智能指针＆＃34;例如std::unique_ptr和std::shared_ptr以自动释放资源。这项技术是＆＃34; RAII＆＃34;在C ++中普遍使用的技术（这是一件好事）。例如：

{
  std::unique_ptr<MyType> tempVariable(myFunctionGetNewTempValue());
  tempVariable->doThis();
  tempVariable->doSomethingElse();
  // tempVariable is destroyed, and so is its referent
}

至于你只想让一个整数超出一个块末尾的范围：

{
  int temp_variable = 3*400*myVariable/1000.0;
  myFunc1(temp_variable);
  myFunc2(temp_variable/2);
}

Answer 2

我不会在生产代码中这样做，但为了论证：

[](std::unique_ptr<auto> p) {
   p->doThis();
   p->doThat();
}(functionCreatesPointer());

[](auto x) {
   myFunc1(x);
   myFunc2(x);
}(3*400*myVariable/1000.);

当然，一个更简单的方法就是在John建议的范围内在自己的范围内创建一个变量，你甚至可以在过程中测试一个有效的指针，而不需要添加太多的样板：

if (std::unique_ptr<MyType> p(myFunctionGetNewTempValue())) {
    tmpVariable->doThis();
    tmpVariable->doThat();
}

优化器可能会在三种情况下生成类似的代码：local var，lambda，if（除if情况下的null-ness测试外）。但我发现John的代码和if更容易理解代码的其他维护者。

当然，语言足够灵活，它可以让你有足够的绳索来吊自己，同时也用火箭吹你的脚...（而且我真的在生产中不会这样做）：< / p>

#define for_this(X) \
   if (bool stop = false) ; else \
      for (X; !stop; stop = true)

然后你可以使用：

for_this(int temp_variable = 3*400*myVariable/1000.0) {
    myFunc1(temp_variable);
    myFunc2(temp_variable);
}

将扩展为：

if (bool stop = false) ; else \
   for (int temp_variable = 3*400*myVariable/1000.0; !stop; stop = true) {
       myFunc1(temp_variable);
       myFunc2(temp_variable);
   }

，优化器将删除条件和循环。只需传递变量名称和初始化即可进一步简化：

for_this(x = 3*400*myVariable/1000.0) { … }

唯一的区别是宏会向auto添加额外的for：

#define for_this(X) \
   if (bool stop = false) ; else \
      for (auto X; !stop; stop = true)

请不要：）

Answer 3

某些编程语言有一个“with”或“using”关键字，用于处理自动管理资源，有时甚至会更改this指针的含义。一些例子是Pascal，Python，C＃和VB6。

C ++没有这样的构造，任何创建自定义解决方案的尝试都会混淆代码并产生不必要的复杂性。相反，在C ++中我们使用了一种名为RAII的东西，你可以看到很多文章。

http://www.hackcraft.net/raii/

Answer 4

我个人不会这样做，但你可以写一个像：

这样的宏

#define with(EXPR) for (auto _ : { EXPR })

它扩展为一个循环（后面将放置一个主体），它定义了一个变量_，其中包含＆＃34;临时值＆＃34;。

然后可以像：

一样使用

with(3*400*myVariable/1000.0) {
    myFunc1(_);
    myFunc2(_/2);
}

Live demo

然而，我并没有看到真正的优势而只是说：

{
    auto _ = 3*400*myVariable/1000.0;
    myFunc1(_);
    myFunc2(_/2);
}

是否有C ++方法允许多次使用函数指针而不创建临时变量？

4 个答案: