c++的初始化列表

初始化列表：以一个 冒号开始 ，接着是一个以 逗号分隔的数据成员列表 ，每个 " 成员变量 " 后面跟一个 放在括 号中的初始值或表达式。

【注意】

1. 每个成员变量在初始化列表中 只能出现一次 ( 初始化只能初始化一次 )

2. 类中包含以下成员，必须放在初始化列表位置进行初始化：

引用成员变量，const成员变量，自定义类型成员( 且该类没有默认构造函数时

#include<iostream>
using namespace std;

class A {
public:
	A(int a=0) {
		_a = a;
		cout << "A(int a=0)" << endl;
	}
private:
	int _a;
};
class B {
public:
	B(int b, int c,int d)
		:_b(b)
        ,_c(c)
		//,_ref(10)//有这行就是给A类的_a赋值，没有这行也会自动调用A的构造函数，
//输出A(int a=0)，因为B类有这个自定义类型的成员变量
		,_d(d)
	{}
private:
	int _b;
	int&_c;
	const int _d;
	A _ref;
};
int main() {
	B bb(1,2,3);//输出A(int a=0)
	return 0;
}

成员变量 在类中 声明次序 就是其在初始化列表中的 初始化顺序 ，与其在初始化列表中的先后次序无关

#include<iostream>
using namespace std;
class A {
public:
 A(int a)
 :_a1(a)
 ,_a2(_a1)
 {}
 
 void Print() {
 cout<<_a1<<" "<<_a2<<endl;
 }
private:
 int _a2;
 int _a1;
};
int main() {
 A aa(1);
 aa.Print();//输出1和随机值。这里声明次序就是private下成员变量的顺序，所以是先
//初始化_a2再初始化_a1
}

我们可以发现初始化列表后面还有个花括号，我们可以适当的在里面加点东西。下面的代码是可以运行的

#include<iostream>
using namespace std;
class AA
{
public:
	AA(int row = 10, int col = 5)
		:_row(row)
		,_col(col)
	{
		_aa = (int**)malloc(sizeof(int*) * row);
		for (int i = 0; i < row; i++)
		{
			_aa[i] = (int*)malloc(sizeof(int) * col);
		}
	}
private:
	int** _aa;
	int _row;
	int _col;
};
class BB
{
public:
	BB(int capacity=10)
		:_a((int*)malloc(capacity*sizeof(int)))
		,_capacity(capacity)
	{
		if (_a == nullptr) {
			perror("申请空间失败");
			exit(-1);
	    }
		memset(_a, 0, sizeof(int) * capacity);
	}
private:
	int* _a;
	int _capacity;
};
int main() {
	AA aa(20,20);
	BB bb(30);
	return 0;
}

然后看一个注意点

#include<iostream>
using namespace std;
class A
{
public:
	A(int a=0)
		:_a(a)
	{}
private:
	int _a;
};

int main() {
	A aa1(1);
	A aa2 = 2;//这里的具体过程是先构造出一个A类型的2，然后调用拷贝构造函数给aa2传参2，
	//但是编译器这里会优化为直接用2构造。也就是整形类型转换，整形转换成自定义类型
	const A& aa3 = 3;//这里是权限平移，没有const就报错了
	return 0;
}

然后看一下static的效果

#include<iostream>
using namespace std;
int _scount = 0;
class A
{
public:
	A() { ++_scount; }
	A(const A& t) { ++_scount; }
	~A() { --_scount; }
	/*static int GetACount() { return _scount; }*/
private:
	/*static int _scount;*/
};

A aa0;

void Func()
{
	static A aa2;
	cout << __LINE__ << ":" << _scount << endl;
}

int main()
{
	cout <<__LINE__<<":"<< _scount << endl;  // 1
	A aa1;
	
	Func();  // 3，形参在函数内也算一个
	Func();  // 3，static修饰的对象只会创建一次，并不会多创建一个

	return 0;
}

但是全局变量就很不好，很容易改变，最好都是封装起来，那么就可以好好使用static

#include<iostream>
using namespace std;
class A
{
public:
	A() 
	{
		++_scount;
	}

	A(const A& t) 
	{
		++_scount;
	}

	~A() 
	{ 
		--_scount;
	}


	void Func1()
	{
		// 非静态能否调用静态：可以
		GetACount();
	}

	void Func2()
	{
		++_a1;
	}

	// 没有this指针，指定类域和访问限定符就可以访问
	static int GetACount() 
	{ 
		// 静态能否调用非静态：不可以。非静态的成员函数调用需要this指针，
        //静态成员函数没有this指针
		// Func2();

		//_a1++;
		return _scount;
	}
private:
	// 成员变量 -- 属于每个一个类对象，存储对象里面
	int _a1 = 1;
	int _a2 = 2;
	// 静态成员变量 -- 属于类，属于类的每个对象共享，存储在静态区
	static int _scount;
};

//全局位置，类外面定义
int A::_scount = 0;

int main()
{
	const A aa1;
	A aa2;
	cout << aa2.Func1() << endl;
    cout<<aa2.GetACount()<<endl;
	cout<<aa1.GetACount()<<endl;//调用不了Fun1和Fun2
	return 0;
}

上面的核心：

普通成员变量 -- 属于每个一个类对象，存储对象里面

静态成员变量 -- 属于类，属于类的每个对象共享，存储在静态区

当然如果static int _scount在public中，那么可以直接在int main()用A::_scount访问这个成员。上面虽然是private却可以有一行定义打破私有保护，是因为定义是必须的，这里可以强制突破一次限制

同时注意，静态成员变量不能给缺省值，因为缺省值是给初始化列表的，这里没有。下面的代码把大部分省略了，留下了需要关注的几行，反正注意这样是会报错的。

static int _scount=1;
};
//这行不要

总结static:

静态成员：
概述：C++类中的静态成员一共有两种，静态成员变量和静态成员函数，被关键字 static 声明为静态的，称为静态成员。 不管这个类创建了多少个对象，静态成员只 有一个拷贝，这个拷贝被所有属于这个类的对象共享。

静态成员变量：
在一个类中，若将一个成员变量声明为 static，这种成员称为静态成员变量。与一 般的数据成员不同，无论建立了多少个对象，都只有一个静态数据的拷贝。静态成 员变量，属于某个类，所有对象共享。 静态变量，是在编译阶段就分配空间，对 象还没有创建时，就已经分配空间。 静态成员变量必须在类中声明，在类外定义。 静态数据成员不属于某个对象，在 为对象分配空间中不包括静态成员所占空间。 静态数据成员可以通过类名或者对 象名来引用。

静态成员函数：
在类定义中，前面有 static 说明的成员函数称为静态成员函数。静态成员函数使用 方式和静态变量一样，同样在对象没有创建前，即可通过类名调用。静态成员函数 主要为了访问静态变量，但是，不能访问普通成员变量。 静态成员函数的意义， 不在于信息共享，数据沟通，而在于管理静态数据成员，完成对静态数据成员的封 装。静态成员函数只能访问静态变量，不能访问普通成员变量 静态成员函数的使用和 静态成员变量一样 静态成员函数也有访问权限 普通成员函数可访问静态成员变量、也可以访问非静态成员变量。