c++ - 使用构造函数与大括号初始化列表来初始化类和结构的规则是什么?
问题描述
我已经在网上搜索了这个问题的答案,但我还没有找到满意的答案。我想知道结构和类类型对象初始化的所有规则是什么,特别是在构造函数与大括号初始化列表时。结构与类的规则也不同吗?
让我们假设我们有一个名为 的类或结构Rectangle
。
#include <iostream>
using namespace std;
class Rectangle {
public:
Rectangle() : x(5.0), y(6.0), width(7.0), height(8.0) {}
void printMe()
{
cout << "The rectangle is located at (" << x << ',' << y << ") and is " << width << " x " << height << endl;
}
double x;
double y;
double width;
double height;
};
int main()
{
Rectangle r = {0.0, 0.0, 3.0, 4.0};
r.printMe();
Rectangle s; // uninitialized!
s.printMe();
}
我尝试Rectangle r
使用普通的旧大括号初始化器列表来初始化您通常在 C 中执行的方式。但是,g++
给出以下错误:
constructor_vs_initializer_list.cpp: In function ‘int main()’:
constructor_vs_initializer_list.cpp:21:38: error: could not convert ‘{0.0, 0.0, 3.0e+0, 4.0e+0}’ from ‘<brace-enclosed initializer list>’ to ‘Rectangle’
Rectangle r = {0.0, 0.0, 3.0, 4.0};
^
嗯....乍一看,这不是很有用的错误消息。但是我认为它与构造函数有关,因为如果我删除它,代码就会编译并运行!我认为这将是一个悖论,大括号初始化列表和构造函数都在竞争初始化它看起来的数据成员。
但是,当我制作数据成员private
时,删除构造函数后,再次显示相同的错误消息!
我想知道数据成员初始化的优先级规则是什么。大括号初始值设定项列表与您自己定义的构造函数相比如何?它与 C++11 的特性相比如何:= default
构造函数和类内成员初始化器?我假设这些初始化对象数据成员的不同方式会以某种方式相互冲突。
Rectangle() = default;
...
double x = 1.0;
我并不是说将它们混合在一起一定是好的代码,只是它是代码,并且在我看来应该很好理解的代码。谢谢你。
解决方案
这是一个演示差异的示例。C++ 中的初始化非常复杂。请参阅:https ://blog.tartanllama.xyz/initialization-is-bonkers/ 。
通常最好使用默认成员初始化器或初始化列表。你在你的构造函数中做正确的事情。只需使用直接列表初始化或直接初始化调用构造函数,以避免混淆。通常,您只会使用复制列表初始化来初始化聚合,而无需用户提供的构造函数。
#include <iostream>
struct A {
int i;
};
struct B {
B() = default;
int i;
};
struct C {
C();
int i;
};
C::C() = default;
struct D {
D(){};
int i;
};
struct E : public D {
};
struct F {
F(int i = 5) {}
int i;
};
struct G {
G() = delete;
int i;
};
int main() {
// g++ (v 8.2.1) provides good warnings about uninitialized values.
// clang++ (v 7.0.1) does not.
// Technically, they are initialized to 'indeterminate values', but it is
// easier to refer to the member variables as uninitialized.
{
// All of the following are 'default initialized', meaning they are not even
// zero-initialized. Members are UNINITIALIZED (Technically, they are
// initialized to 'indeterminate' values.
// Either nothing is done, or the default constructor is called (in
// which nothing is done).
A a;
B b;
C c;
D d;
E e;
F f;
std::cout << "a: " << a.i << std::endl;
std::cout << "b: " << b.i << std::endl;
std::cout << "c: " << c.i << std::endl;
std::cout << "d: " << d.i << std::endl;
std::cout << "e: " << e.i << std::endl;
std::cout << "f: " << f.i << std::endl;
std::cout << std::endl;
} {
// This is more complex, as these are all 'list initialized'.
// Thank you, infinite wisdom of the C++ committee.
A a{};
// Direct list initialization -> aggregate initialization
// - A has no user-provided constructor and
// thus is an aggregate, and agg. init. takes place.
// This 'value initializes' all *MEMBERS* (unless a default member
// initializer exists, which it does not here).
// Value initialization of non-class types results in
// zero-initialization. (member `i` is zero-initialized)
A a2 = {};
// same thing, but via copy list initialization
A a3{{}};
// recursive, initializes `i` with {}, which zero initializes `i`.
A a4{0};
// recursive, initializes `i` 0;
// Could also do `A a4 = {0}`
A a5{a};
// direct intialization of `a5` with `a`.
// Implicit copy constructor chosen by overload resolution.
A a6{A{}};
// post C++17, direct initializes a6 with a prvalue of type A, that is
// aggregate initialized as above. NOT copy/move initialized, but
// instead initialized via the "initializer expression itself".
// I assume this means the value of a6 is directly set via as if it were
// being aggregate initialized.
B b{};
// Same as A. `B() = default;` does NOT specify a user-provided
// constructor
C c{};
// Because the first declaration of `C()` is not `C() = default;`,
// this DOES have a user-provided constructor, and 'value initializaton'
// is performed.
// NOTE: this value intializes `C`, not the *MEMBERS* of `C`.
// Because `C` is a normal class type, value initialization just calls
// the default constructor, which does nothing, and leaves all members
// uninitialized.
D d{};
// D is a class type that is list/direct initialization -> value
// inititalizaton -> default initialization -> call constructor ->
// members are left unitialized.
E e{};
// List initialization -> value initialization -> default initialization
// -> calls implicitly defined default constructor -> Calls default
// constructor of bases -> leaves E::D.i uninitialized
F f{};
// List/direct initialization -> value initialization -> calls default
// constructor with default arguments -> leaves F.i uninitialized
// G g{};
// Fails to compile.
// list initialization -> value initialization -> default initialization
// -> deleted default constructor selected by overload resolution ->
// fails to compile
std::cout << "a: " << a.i << std::endl;
std::cout << "a2: " << a2.i << std::endl;
std::cout << "a3: " << a3.i << std::endl;
std::cout << "a4: " << a4.i << std::endl;
std::cout << "a5: " << a5.i << std::endl;
std::cout << "a6: " << a6.i << std::endl;
std::cout << "b: " << b.i << std::endl;
std::cout << "c: " << c.i << std::endl;
std::cout << "d: " << d.i << std::endl;
std::cout << "e: " << e.i << std::endl;
std::cout << "f: " << f.i << std::endl;
}
}
推荐阅读
- functional-programming - Curry 中的 N 元函数和 Prolog 中的 N+1 元关系之间有什么区别吗?
- python - 如何将字典术语转换为熊猫数据框?
- c++ - 递归删除所有相邻的重复项(使用堆栈)
- javascript - react-leaflet v3 缩放监听器
- python - 计算模型中的两个损失并反向传播两次
- hibernate - 将本机查询转换器列休眠到 dto 中的复杂属性
- c++ - 在基类中声明的 C++ 结构在子类中不可访问
- angular - 使用 kendo UI 和 Angular 显示上传文件的日期
- ios - 如何隐藏/删除“来自消息”键盘建议 - Flutter IOS
- sql - Oracle SQL Developer 中如何检查另一列的值是否最高以确定多次出现的最新记录?