我可以在不结束块的情况下终止C ++变量的范围吗？

Question

我想做类似以下模式的事情：

T* const pT = findT();
// Do some work
T* const pT2 = new T( *pT );
// Mutate the object pT2 refers to
delete pT;
// At this point, I want the scope of pT to end.
// I do not want the scope of pT2 to end

我知道我可以通过结束一个块结束范围，但它最终会像这样结束：

T* pT2 = 0;
{
    T* const pT = findT();
    // Do some work
    pT2 = new T( *pT );
    // Mutate the object pT2 refers to
    delete pT;
}

这会导致pT2失去其const限定符，因为我必须在声明之后分配它。

我想要我的蛋糕，我也想吃它，我想要明确的常量和适当的范围！

除了结束一个块之外，还有什么方法可以结束变量的范围吗？ 如果没有，有没有计划扩展标准来支持这个？

Answer 1

你可以使用lambdas：

T* const pT = []() -> T* {
    T* pT;
    // Do whatever the hell you want with pT
    return pT;
}();

Answer 2

除了结束一个块之外，还有什么方法可以结束变量的范围吗？

不可以。局部变量的范围在声明时开始，并在声明它的块的末尾结束。

如果没有，有没有计划扩展标准来支持这个？

这听起来是一个非常糟糕的主意：这会增加关于范围，名称查找和对象生存期的规则的不必要的复杂性。

Answer 3

你称之为“块”的是C ++中用于“范围”的另一个名称。 这是您在C ++中定义范围的方法。

这里的另一个选择是使用std::auto_ptr ，它在赋值时转移所有权。 旧指针不会清理，但实际上是零。

Answer 4

不过。但是你可以使用下面的习惯来美化你的例子（好吧，那是主观的，但是嘿）：

T* p1 = 0;

if (T* const p2 = findT()) {
  p1 = new T( *p2 );
  delete p2;
}

Answer 5

您可以使用std :: optional （或boost :: optional ）对对象生命周期进行细粒度控制。

这是一个例子：

std::optional< ClassA > a(std::in_place, 1); // ClassA constructor is called
std::optional< ClassB > b(std::in_place, 2); // ClassB constructor is called
a.reset(); // ClassA destructor is called
b.reset(); // ClassB destructor is called

不幸的是，变量的名称仍然存在，并且仍然分配了它的内存。

还有一个技巧来销毁一个字符串并释放它的内存（变量本身仍然存在）：

std::string my_str;
std::string{}.swap(my_str); // likely to free the memory

它是实现定义的，因此它实际上可能不会释放内存，但很可能会这样做。