stack-allocated class 的成员在 scope end 放置 new 时会发生什么?
What happens to members of a stack-allocated class put down with placement new on scope end?
我有这个(编译)代码:
#include <iostream>
#include <vector>
class Base {
std::vector<Base*> handles_;
public:
Base(Base* handle) : handles_( {handle} ) { };
};
class A : public Base {
using Base::Base;
};
class B : public Base {
using Base::Base;
};
int main()
{
A* addr_of_A = (A*)alloca(sizeof(A));
B* addr_of_B = (B*)alloca(sizeof(B));
new (addr_of_A) A(addr_of_B);
new (addr_of_B) B(addr_of_A);
}
编译器是否处理了 A 和 B 中的向量? Afaik 要销毁像 A 和 B 这样分配的对象,我必须明确地调用析构函数。我在这里不这样做,我想知道当作用域结束时是否仍会为 A 和 B 的成员向量调用析构函数。这当然是必要的,因为他们管理堆资源。
将它们包含在一个包含结构中,如下所示:
#include <iostream>
#include <vector>
class Base {
std::vector<Base*> handles_;
public:
Base(Base* handle) : handles_( {handle} ) { };
};
class A : public Base {
using Base::Base;
};
class B : public Base {
using Base::Base;
};
int main()
{
struct C {
A a;
B b;
C() : a(&b), b(&a) {}
} c;
}
我有这个(编译)代码:
#include <iostream>
#include <vector>
class Base {
std::vector<Base*> handles_;
public:
Base(Base* handle) : handles_( {handle} ) { };
};
class A : public Base {
using Base::Base;
};
class B : public Base {
using Base::Base;
};
int main()
{
A* addr_of_A = (A*)alloca(sizeof(A));
B* addr_of_B = (B*)alloca(sizeof(B));
new (addr_of_A) A(addr_of_B);
new (addr_of_B) B(addr_of_A);
}
编译器是否处理了 A 和 B 中的向量? Afaik 要销毁像 A 和 B 这样分配的对象,我必须明确地调用析构函数。我在这里不这样做,我想知道当作用域结束时是否仍会为 A 和 B 的成员向量调用析构函数。这当然是必要的,因为他们管理堆资源。
将它们包含在一个包含结构中,如下所示:
#include <iostream>
#include <vector>
class Base {
std::vector<Base*> handles_;
public:
Base(Base* handle) : handles_( {handle} ) { };
};
class A : public Base {
using Base::Base;
};
class B : public Base {
using Base::Base;
};
int main()
{
struct C {
A a;
B b;
C() : a(&b), b(&a) {}
} c;
}