在C++98中,支持了在类声明中使用等号“=”加初始值的方式,来初始化类中静态成员常量。这种声明方式我们也称之为“就地”声明。就地声明在代码编写时非常便利,不过C++98对类中就地声明的要求却非常高。如果静态成员不满足常量性,则不可以就地声明,而且即使常量的静态成员也只能是整型或者枚举型才能就地初始化。而非静态成员变量的初始化则必须在构造函数中进行。
1.初始化列表
class A
{
public:
int a; // 初始化列表
A(int a_):a(a_){}
};
2.构造函数初始化
class A
{
public:
int a; // 初始化列表
A(int a_, bool b) { a = a_; }
};
3.声明时初始化(也称就地初始化,c++11后支持)
class A
{
public:
int a = 1; // 声明时初始化
A() {}
};
在C++98中,支持了在类声明中使用等号“=”加初始值的方式,来初始化类中静态成员常量。这种声明方式我们也称之为“就地”声明。就地声明在代码编写时非常便利,不过C++98对类中就地声明的要求却非常高。如果静态成员不满足常量性,则不可以就地声明,而且即使常量的静态成员也只能是整型或者枚举型才能就地初始化。而非静态成员变量的初始化则必须在构造函数中进行。比如,如下代码在c++98中编译
class Init
{
public:
Init(): a(0) []
Init(int d): a(d) {}
private:
int a;
const static int b = 0;
int c = 1; // member, cannot pass build
static int d = 0; // member, cannot pass build
static const double e = 1.3; // not int or enum type, cannot pass build
stati const char* const f = "e"; // not int or enum type, cannot pass build
}
这非常不方便,所以在C++11中,标准允许非静态成员变量的初始化有多种形式。具体而言,除了初始化列表外,在C++11中,标准还允许使用等号= 或者 花括号{} 进行就地的非静态成员变量初始化。
struct init {
int a = 1;
double b {1.2};
};
因此假如三种初始化方式同时存在的话,那么最后保留的成员变量值肯定是构造函数中初始化的值。
#include <iostream>
using namespace std;
class A
{
public:
int a = 1;
A(int a_) :a(2) { a = 3; }
};
int main()
{
A a;
cout << "a.a=" << a.a << endl;
return 0;
}
// a.a=3
4.如何选择初始化方式
4.1 声明时初始化的使用场景
一个优点是直观,你在声明的时候顺便给一个初始值,别人在看你代码的时候,点一下调到声明也能看到你赋予的初始值,不用再去看构造函数那里给的什么值
第二个优点更有用了,比如你要定义多个构造函数,每个构造函数都用列表初始化的方法初始化,很麻烦,我们来看一下下面这个例子:
class Group {
public:
Group() {}
Group(int a): data(a) {}
Group(Mem m): mem(m) {}
Group(int a, Mem m, string n): data(a), mem(m), name(n) {}
private:
int data = 1;
Mem mem{0};
string name{"Group"};
};
4.2 列表初始化的使用场景
4.2.1 必须使用列表始化的四种情况
- 初始化一个reference成员
- 初始化一个const成员
- 调用一个基类的构造函数,而该函数有一组参数
- 调用一个数据成员对象的构造函数,而该函数有一组参数
4.2.2 那么成员初始化列表到底做了什么呢?
- 编译器会一一操作初始化列表,以适当的顺序在构造函数之内安插初始化操作,并且在任何显示用户代码之前;
- list中的项目顺序是由类中的成员声明顺序决定的,不是由初始化列表的顺序决定的;
4.2.3 为什么用成员初始化列表会快一些?
- 下面的代码定义两个结构体,其中Test1有构造函数,拷贝构造函数及赋值运算符,为的是方便查看结果。Test2是个测试类,它以Test1的对象为成员,我们看一下Test2的构造函数是怎么样执行的。
代码1:
#include <iostream>
using namespace std;
struct Test1 {
Test1() // 无参构造函数
{
cout << "Construct Test1" << endl;
}
Test1(const Test1& t1) // 拷贝构造函数
{
cout << "Copy constructor for Test1" << endl;
this->a = t1.a;
}
Test1& operator = (const Test1& t1) // 赋值运算符
{
cout << "assignment for Test1" << endl;
this->a = t1.a;
return *this;
}
int a;
};
struct Test2 {
Test1 test1;
Test2(Test1& t1)
{
test1 = t1;
}
};
int main()
{
Test1 t1;
Test2 t2(t1);
}
//Construct Test1
//Construct Test1
//assignment for Test1
解释一下,第一行输出对应调用代码中第一行,构造一个Test1对象。第二行输出对应Test2构造函数中的代码,用默认的构造函数初始化对象test1,这就是所谓的初始化阶段。第三行输出对应Test1的赋值运算符,对test1执行赋值操作,这就是所谓的计算阶段。
代码2:
#include <iostream>
using namespace std;
struct Test1 {
Test1() // 无参构造函数
{
cout << "Construct Test1" << endl;
}
Test1(const Test1& t1) // 拷贝构造函数
{
cout << "Copy constructor for Test1" << endl;
this->a = t1.a;
}
Test1& operator = (const Test1& t1) // 赋值运算符
{
cout << "assignment for Test1" << endl;
this->a = t1.a;
return *this;
}
int a;
};
struct Test2 {
Test1 test1;
Test2(Test1& t1) :test1(t1)
{
}
};
int main()
{
Test1 t1;
Test2 t2(t1);
}
//Construct Test1
//Copy constructor for Test1
第一行输出对应 调用代码的第一行。第二行输出对应Test2的初始化列表,直接调用拷贝构造函数初始化test1,省去了调用默认构造函数的过程。所以一个好的原则是,能使用初始化列表的时候尽量使用初始化列表。
4.3 构造函数初始化的使用场景
4.3.1 派生类构造函数执行顺序
(1)虚拟基类的构造函数(多个虚拟基类则按照继承的顺序执行构造函数)。
(2)基类的构造函数(多个普通基类也按照继承的顺序执行构造函数)。
(3)类类型的成员对象的构造函数(按照初始化顺序)。
(4)派生类自己的构造函数。
4.3.2 构造函数初始化使用
(1)拷贝和赋值构造函数里(不然怎么叫赋值构造函数呢)
(2)这歌就是比较无聊的情况了,比如你想把几个成员函数都初始化成一个值,请看下面例子
class Group {
public:
Group() {data1 = data2 = data3 = 0;}
private:
int data1;
int data2;
int data3;
};
总而言之,优先就地初始化和列表初始化。