C++成员变量、构造函数的初始化顺序

1、C++成员变量初始化

1、普通的变量：通常不考虑啥效率的状况下 能够在构造函数中进行赋值。考虑一下效率的能够再构造函数的初始化列表中进行

二、static 静态变量(本地化数据和代码范围)：

static变量属于类全部，而不属于类的对象，所以无论类被实例化了多少个对象，该变量都只有一个。在这种性质上理解，有点相似于全局变量的惟一性。

• 函数体内static变量的做用范围时该函数体，不一样于auto变量，该变量内存只被分配一次，所以其值在下次调用时维持上次的值。
• 在模块内的static全局变量能够被模块内全部函数访问，但不能被模块外的其它函数访问。
• 在模块内的static函数只可被这一模块内的其余函数调用，这个函数的适用范围被限制在声明它的模块内。
• 在类中的static成员变量属于整个类所拥有，对类的全部对象只有一份拷贝。
• 在类中的static成员函数属于整个类所拥有，这个函数不接受this指针，于是只能访问类的static成员变量。

三、const 常量变量：

const常量须要在声明的时候即初始化。所以须要在变量建立的时候进行初始化。通常采用在构造函数的初始化列表中进行。

四、Reference 引用型变量：

引用型变量和const变量相似。须要在建立的时候即进行初始化。也是在初始化列表中进行。但须要注意用Reference类型。

四、字符串初始化

char str[10] = "HELLO";

结尾会被编译器自动加上结尾符'/0',编译的时候能够看到它最后是'',ASC码值是0;

"HELLO"只有5个字符,加上编译器自动添加的'/0',也就是会初始化数组的前6个元素,剩下有元素会被所有初始化为'/0',这个要注意哦

char str[] = "HELLO";

编译器自动为后面的字符串分配大小并加'/0'

char str[] = {'H','E','L','L','O','/0'};

编译器会根据字符串大小分配空间,但是不会自动分配'/0',因此结尾的时候要本身加上'/0'

char *str = "HELLO";

把指向字符串的指针给定义好的字符指针

1）用构造函数确保初始化

对于一个空类，编译器会自动声明4个默认函数：构造函数、拷贝构造函数、赋值函数、析构函数（若是不想使用自动生成，就应该明确拒绝），这些生成的函数都是public且inline的。

2）为何构造函数不能有返回值

3）为何构造函数不能为虚函数

虚函数调用的机制，是知道接口而不知道其准确对象类型的函数，可是建立一个对象，必须知道对象的准确类型；当一个构造函数被调用时，它作的首要事情之一就是初始化它的VPTR来指向VTABLE。

面试题：构造函数

#include <iostream>
using namespace std;

class Base 
{
private:
	int i;
public:
	Base(int x)
	{
		i = x;
	}
};

class Derived : public Base
{
private:
	int i;
public:
	Derived(int x, int y)
	{
		i = x;
	}
	void print()
	{
		cout << i + Base::i << endl;
	}
};

int main()
{
	Derived A(2,3);
	A.print();
    return 0;
}

首先，是访问权限问题，子类中直接访问Base::i是不容许的，应该将父类的改成protected或者public（最好用protected）

其次，统计父类和子类i的和，可是经过子类构造函数没有对父类变量进行初始化；此处编译会找不到构造函数，由于子类调用构造函数会先找父类构造函数，可是没有2个参数的，因此能够在初始化列表中调用父类构造函数

最后个问题，是单参数的构造函数，可能存在隐式转换的问题，由于单参数构造函数，和拷贝构造函数形式相似，调用时极可能会发生隐式转换，应加上explicit关键字

#include <iostream>
using namespace std;

class Base 
{
protected:
	int i;
public:
	explicit Base(int x)
	{
		i = x;
	}
};

class Derived : public Base
{
private:
	int i;
public:
	Derived(int x, int y):Base(x)
	{
		i = y;
	}
	void print()
	{
		cout << i + Base::i << endl;
	}
};

int main()
{
	Derived A(2,3);
	A.print();
    return 0;
}

二、初始化列表

1）使用初始化列表提升效率

class Student 
{
public:
	Student(string in_name, int in_age)
	{
		name = in_name;
		age = in_age;
	}
private :
	string name;
	int    age;
};

由于在构造函数中，是对name进行赋值，不是初始化，而string对象会先调用它的默认构造函数，再调用string类（貌似是basic_string类）的赋值构造函数；对于上例的age，由于int是内置类型，应该是赋值的时候得到了初值。

要对成员进行初始化，而不是赋值，能够采用初始化列表（member initialization list）

class Student 
{
public:
	Student(string in_name, int in_age):name(in_name),age(in_age) {}
private :
	string name;
	int    age;
};

在初始化的时候调用的是string的拷贝构造函数，而上例会调用两次构造函数，从性能上会有不小提高

有的状况下，是必须使用初始化列表进行初始化的：const对象、引用对象

2）初始化列表初始顺序

#include <iostream>
using namespace std;

class Base 
{
public:
	Base(int i) : m_j(i), m_i(m_j) {}
	Base() : m_j(0), m_i(m_j) {}
	int get_i() const
	{
		return m_i;
	}
	int get_j() const
	{
		return m_j;
	}

private:
	int m_i;
	int m_j;

};

int main()
{
	Base obj(98);
	cout << obj.get_i() << endl << obj.get_j() << endl;
    return 0;
}

输出为一个随机数和98，为何呢？由于对于初始化列表而言，对成员变量的初始化，是严格按照声明次序，而不是在初始化列表中的顺序进行初始化，若是改成赋值初始化则不会出现这个问题，固然，为了使用初始化列表，仍是严格注意声明顺序吧，好比先声明数组大小，再声明数组这样。

C++构造函数初始化按下列顺序被调用：

• 首先，任何虚拟基类的构造函数按照它们被继承的顺序构造；
• 其次，任何非虚拟基类的构造函数按照它们被继承的顺序构造；
• 最后，任何成员对象的构造函数按照它们声明的顺序调用；

#include <iostream>
using namespace std;
class OBJ1{
   public:
      OBJ1(){ cout<<"OBJ1\n"; }
};
class OBJ2{
   public:
     OBJ2(){ cout<<"OBJ2\n";}
}
class Base1{
   public:
     Base1(){ cout<<"Base1\n";}
}
class Base2{
   public:
     Base2(){ cout <<"Base2\n"; }
};
class Base3{
  public:
    Base3(){ cout <<"Base3\n"; }
};
class Base4{
  public:
    Base4(){ cout <<"Base4\n"; }
};
class Derived :public Base1, virtual public Base2,public Base3, virtual public Base4//继承顺序{
   public:
      Derived() :Base4(), Base3(), Base2(),Base1(), obj2(), obj1(){//初始化列表
        cout <<"Derived ok.\n";
    }
   protected:
     OBJ1 obj1;//声明顺序
     OBJ2 obj2;
};

int main()
{
    Derived aa;//初始化
    cout <<"This is ok.\n";
    return 0;
}
结果：
Base2 //虚拟基类按照被继承顺序初始化
Base4 //虚拟基类按照被继承的顺序 
Base1 //非虚拟基类按照被继承的顺序初始化
Base3 //非虚拟基类按照被继承的顺序 
OBJ1  //成员函数按照声明的顺序初始化
OBJ2  //成员函数按照声明的顺序 
Derived ok. 
This is ok.