我想有一个类B
,它有另一个类A
的3个成员对象。 A
和B
的构造者都是constexpr
。 A
- 包含在B
内 - 是不可复制和不可移动的。此代码正确构建:
class A
{
public:
constexpr explicit A(int a) {}
A(const A&) = delete;
A(A&&) = delete;
};
class B
{
public:
constexpr B() :
a0{0},
a1{1},
a2{2}
{}
private:
A a0;
A a1;
A a2;
};
int main()
{
B b;
}
但是,我真的希望将A
类型的3个对象作为数组。如果我尝试这样简单的方法:
class A
{
public:
constexpr explicit A(int a) {}
A(const A&) = delete;
A(A&&) = delete;
};
class B
{
public:
constexpr B() :
a{A{1}, A{2}, A{3}}
{}
private:
A a[3];
};
int main()
{
B b;
}
无法构建:
$ g++ a.cpp
a.cpp: In constructor ‘constexpr B::B()’:
a.cpp:21:22: error: use of deleted function ‘A::A(A&&)’
a{A{1}, A{2}, A{3}}
^
a.cpp:13:2: note: declared here
A(A&&) = delete;
^
a.cpp:21:22: error: use of deleted function ‘A::A(A&&)’
a{A{1}, A{2}, A{3}}
^
a.cpp:13:2: note: declared here
A(A&&) = delete;
^
a.cpp:21:22: error: use of deleted function ‘A::A(A&&)’
a{A{1}, A{2}, A{3}}
^
a.cpp:13:2: note: declared here
A(A&&) = delete;
^
a.cpp:28:2: error: member ‘B::a’ must be initialized by mem-initializer in ‘constexpr’ constructor
}
^
a.cpp:32:7: note: declared here
A a[3];
^
是否可以在不使A
移动的情况下解决?
编辑:
正如@rustyx所建议的那样,我已经改变了一些代码,它适用于C ++ 11和C ++ 17(使用explicit
)。然而 - 通常情况下 - 真正的代码有点复杂。让我们说A
真的是不可移动的和不可复制的,比如它有一个析构函数。
class A
{
public:
constexpr explicit A(int a) {}
~A() {}
A(const A&) = delete;
A(A&&) = delete;
};
class B
{
public:
constexpr B() :
a{A{1}, A{2}, A{3}}
{}
private:
A a[3];
};
int main()
{
B b;
}
即使使用C ++ 17,这也会失败:
g++ a.cpp -std=c++17
a.cpp: In constructor ‘constexpr B::B()’:
a.cpp:14:22: error: use of deleted function ‘A::A(A&&)’
a{A{1}, A{2}, A{3}}
^
a.cpp:7:2: note: declared here
A(A&&) = delete;
^
a.cpp:14:22: error: non-constant array initialization
a{A{1}, A{2}, A{3}}
^
a.cpp:15:3: error: use of deleted function ‘A::A(A&&)’
{}
^
a.cpp:7:2: note: declared here
A(A&&) = delete;
^
如果A
的构造函数不是explicit
,它也会失败。如果我删除析构函数然后它可以工作,但是如果析构函数必须在那里呢?这个特定的阵列初始化问题是否有解决方案,或者我运气不好?
严格地说,从A
初始化A{1}
的实例是复制(或移动)初始化。大多数编译器都忽略了复制/移动,甚至不打扰调用复制/移动构造函数,但仅从C ++ 17开始实际上不需要复制/移动构造函数。
作为一种解决方法,您可以从explicit
s构造函数中删除A
并在原地构造A
s:
class A
{
public:
constexpr A(int a) {}
A(const A&) = delete;
A(A&&) = delete;
};
class B
{
public:
constexpr B() :
a{{1}, {2}, {3}}
{}
private:
A a[3];
};
int main()
{
B b;
}
===编辑===(回答问题编辑)
让我们说A实际上是不可移动的,不可复制的,比如它有一个析构函数。
我能想到的唯一可能的解决方法是nuclear option a.k.a. placement-new:
#include <memory>
#include <type_traits>
class A
{
public:
constexpr A(int a) {}
A(const A&) = delete;
A(A&&) = delete;
~A() {}
};
class B
{
public:
B() {
new (std::addressof(a[0])) A(1);
new (std::addressof(a[1])) A(2);
new (std::addressof(a[2])) A(3);
}
A& getA(size_t offset) { return reinterpret_cast<A*>(a)[offset]; }
private:
std::aligned_storage<sizeof(A), alignof(A)>::type a[3];
};
int main()
{
B b;
}