对象是否可以被更早的销毁，以使其存储内存可以被后续对象重用？

Question

C++：对象可以被更早地销毁，以使其存储内存被后续对象重用吗？

在C++代码一个段，在所述第一半部分，一个对象，使用B; 在下半部分，创建和使用对象c，d。

由于物体A，B占用大量的内存，我想手动销毁对象A，B上半年部分结束的时候。

我知道我可以使用新的，删除去实现它。

但是，如果我不使用新的，但还是要销毁对象较早（这意味着，范围的结束时间之前），我可以手动调用析构函数摧毁它？所以这部分内存可以重用于对象c和d。 （我不需要来释放内存，因为重用是罚款

下面是一个伪代码：。

monsterClass a, b; 
dragonClass c, d; 
int i,j,k,l; 

a = monsterClass(1000, 2000); 
b = monsterClass(2000, 3000); 
i = processMethod1(a, b); 
j = ...; 
k = ...; 
l = ...; 


// here, I want to destroy a, b, since they are not used any more, while occupy memory. 
// The above half part and the below half part use many common variables. 
// So it seems scope {} method makes it inconvenient, 
// since I don't want to create a function with too many parameters. 
// I don't want to use new or delete here. I hope it looks simple and not prone to error 
// So can I use: ~a, ~b here? 

c = dragonClass(400, 3000); 
d = dragonClass(500, 4000); 
processMethod2(c, d, i); 
j = ...; 
k = ...; 
l = ...; 

[更新1]所以，大多数人建议使用范围，这是一个很好的方式 我还是很好奇，我可以使用〜a和〜b吗？ 我觉得这似乎是一种可行和方便的方式。

[Update 2]我想到了另一种情况，在这种情况下，不同变量的作用域是交织在一起的！就像这样：a的范围有b的作用域的重叠，但它们不包括关系。它是部分重叠的关系。 在这种情况下，这是否意味着使用范围是不可能的？ 最后的手段是使用新的和删除，对吧？

Answer 1

通过使用大括号可以手动控制堆栈中对象的生存期。

void foo() 
{ 
    int x = 5; 
    int y = 2; 

    {   // This introduces a new scope 
    int z = 3; 
    }   // After this brace, z is now out of scope 

    int a = x + y; 
} 

但是请注意，一旦变量超出范围，当再次使用此内存时未指定。仅仅因为我宣布了名为a的另一个int，并不意味着它将被分配到以前的地址z。

Answer 2

使用布局新和手动调用析构函数：

{ 
    char memory[std::max(sizeof(A),sizeof(B))]; 

    A* pA = new (memory) A(); 
    // use `pA` 
    pA->~A(); // destruct A 

    B* pB = new (memory) B(); 
    // use `pB` 
    pB->~B(); // destruct B 
} // `memory` goes out of scope 

我建议阅读的新运营商这个优秀的资源：http://en.cppreference.com/w/cpp/language/new

Answer 3

你可以把它分解成更小的功能：

void part1() { 
    monsterClass a, b; 
    a = monsterClass(1000, 2000); 
    b = monsterClass(2000, 3000); 

    processMethod1(a, b); 
} 

或块内的较大函数

{ 
    monsterClass a, b; 
    // and so on 
} 
{ 
    dragonClass c, d; 
    // and so on 
} 

或使用的临时

processMethod1(
    monsterClass(1000, 2000); 
    monsterClass(2000, 3000); 
); 

如果你正在做的事情很复杂，这些都不是合适的，你可以用工会，或放置新陷入混乱;细节会很烦琐，具体取决于你奇怪的要求是什么。

Answer 4

由于您的代码段，你可以写为

int i,j,k,l; 

{ 
    monsterClass a(1000, 2000); 
    monsterClass b(2000, 3000); 
    i = processMethod1(a, b); 
    j = ...; 
    k = ...; 
    l = ...; 
} 

// here, you want to destroy a, b, since they are not used any more, while occupy memory. 

dragonClass c(400, 3000); 
dragonClass d(500, 4000); 
processMethod2(c, d, i); 
j = ...; 
k = ...; 
l = ...; 

// you could use the same technique if there are still e, f or so