类和对象(下)

初始化列表

现在除了之前我们讲的构造函数来初始化对象，现在有多了一个初始化列表。

为什么要有初始化列表

初始化列表我们会认为是成员变量定义的地方
这句话很绕，慢慢往下看。

对于对象而言。成员变量定义的地方又是什么意思？

class A
{
public:

private:
//这是声明
	int _a1;
	int _a2;
};
int main()
{
//这是定义
	Date A;
	return 0;
}

但这是对对象整体的定义。每个成员什么时候定义呢？
对象整体定义，每个成员不就定义了吗？道理是这样，但是这样行不通，容易走出歪路子。

class A
{
public:

private:
//这是声明
	int _a1;
	int _a2;
	const int _x;
};
int main()
{
//这是定义
	Date A;
	return 0;
}

加了就报错，提示没有合适的构造函数可用，为什么？

const int _x;

const变量有什么区别？它必须在定义的位置初始化，因为它只有一次初始化的机会，后面就不能改了。

所以const变量必须要处理，后面就没机会了，那在什么地方处理？
1，c++11支持缺省值，在声明的地方给个缺省值就可以了。
2.c++11之前，怎么解决？
必须给每个成员变量找一个定义的位置，不然像const这样的成员不好出理。
所以构造函数就增加了初始化列表

初始化列表格式

冒号开始，逗号分割

class A
{
public:
	A()
		:_x(1)
	{
		_a1++;
	}

private:
	int _a1=1;
	int _a2=1;
	const int _x;
};
int main()
{
	A aa;
	return 0;
}

1、哪个对象调用构造函数，初始化列表是它所有成员变量定义的位置
2、不管是否显示在初始化列表写，那么编译器每个变量都会初始化列表定义初始化

用法

缺省值是没给的时候才用它
看下面的代码结果是多少。

class A
{
public:
	A()
		:_x(1)
		,_a2(2)
	{
		_a1++;
		_a2--;
	}

private:
	int _a1=1;
	int _a2=1;
	const int _x;
};
int main()
{
	A aa;
	return 0;
}

什么时候用初始化列表

c++规定有三个东西必须在初始化列表规定。

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

class B
{
public:
	B(int b)
		:_b(0)
	{
		cout << "B()" << endl;
	}
private:
	int _b;
};
class A
{
public:
		A()
			:_x(1)
			, _ref(_a1)
			, _bb(0)
		{
			_a1++;
			_a2--;
		}
	
	private:
		int _a1 = 1; // 声明
		int _a2 = 2;
		const int _x;
		int& _ref;
		B _bb;//编译器对内置类型不做处理，如果有缺省值那就有缺省值
			  //默认生成的构造函数对内置类型不做处理，对于内置类型就调用它的默认构造
			  //但是它只能调用默认构造，就是不传参数的就可以用的构造函数
	};

所有的成员能在初始化列表初始化最好就在初始化列表初始化

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

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();
}
A. 输出1  1
B.程序崩溃
C.编译不通过
D.输出1  随机

explicit关键字

class A
{
public:
	A(int a)
		:_a1(a)
	{

	}
	A(const A& a)
	{
		
	}
private:
	int _a1;
	int _a2;
};

A aa1(1)//直接调用构造函数

A aa2=1 // 隐式类型转换   构造+拷贝+优化->构造

1是整型变量怎么赋值给aa2，这里是发生了类型转换，首先用1去构造一个临时对象，然后再拷贝给aa2

如果不行让它发生类型转换，就加上关键字explicit

class A
{
public:
	explicit A(int a)
		:_a1(a)
	{

	}
	A(const A& a)
	{
		
	}
private:
	int _a1;
	int _a2;
};

static成员

实现一个类，计算程序中创建了多少个类对象

 class A
{
public:
	A(int a = 0)
	{
		
	}

	A(const A& aa)
	{
		
	}
};

void func(A a)
{}

int main()
{
	A aa1;
	A aa2(aa1);
	func(aa1);
	A aa3 = 1;
}

因为要创建类对象，就必须要调用构造函数或者拷贝构造，我们可以设定一个全局变量进行计数。

using std::cout;
using std::endl;
int count =0;
 class A
{
public:
	A(int a = 0)
	{
		count++;
	}

	A(const A& aa)
	{
		count++;
	}
};

void func(A a)
{}

int main()
{
	A aa1;
	A aa2(aa1);
	func(aa1);
	A aa3 = 1;
	cout << count << endl;
}

但是这里有一个不好的地方，count是全局变量，可以随意修改。
这里可以把count定义在类里面，并且用static修饰，表示它是静态类成员，它不属于某个类对象，它属于所有对象，它是属于整个类的。

静态成员初始化

必须在类外面。

 class A
{
public:
	A(int a = 0)
	{
		count++;
	}

	A(const A& aa)
	{
		count++;
	}
private:
	static int count;//不属于某个对象，所于所有对象，属于整个类
					 // 声明
};
int A::count=0; // 初始化

访问静态成员

 class A
{
public:
	A(int a = 0)
	{
		count++;
	}

	A(const A& aa)
	{
		count++;
	}
	int GetCount()
	{
		return count;
	}
private:
	static int count;//不属于某个对象，所于所有对象，属于整个类
					 // 声明
};
int A::count=0; // 初始化
int main()
{
	A aa1;
	cout  << aa1.GetCount() << endl;
	return 0;
}

静态成员函数

为了调用GetCount 这个函数而特意创建一个类，这也太挫了吧，static也可以修饰函数，表示静态成员函数。

 class A
{
public:
	A(int a = 0)
	{
		count++;
	}

	A(const A& aa)
	{
		count++;
	}
	static int GetCount()
	{
		return count;
	}
private:
	static int count;//不属于某个对象，所于所有对象，属于整个类
					 // 声明
};
int A::count=0; // 初始化
int main()
{
	A aa2;
	A aa3;
	cout  << A::GetCount() << endl;
	cout << aa2.count << endl;
	cout << aa3.count << endl;
	return 0;
}

静态成员函数 – 没有this指针
这也就意味着，静态成员函数不能访问非静态成员变量。

问题

A aa4[10]调用了多少次构造函数？

拷贝对象时的一些编译器优化

优化情况

void func1(A aa)
{
}
void func2(const A& aa)
{
}
int main()
{
	A aa1 = 1; // 构造+拷贝构造 -》 优化为直接构造
	func1(aa1); // 无优化
	func1(2); // 构造+拷贝构造 -》 优化为直接构造
	func1(A(3)); // 构造+拷贝构造 -》 优化为直接构造

	cout << "----------------------------------" << endl;

	func2(aa1);  // 无优化
	func2(2);    // 无优化
	func2(A(3)); // 无优化


	return 0;
}

判断下面哪种方式更加高效？


直接看结果
第一种

第二种

显而易见，第二种多了一次调用构造函数和赋值运算符重载。

总结

为什么函数返回对象时尽量返回匿名对象我就不说了，因为我的vs2022编译器它自己帮我优化了。

const

1.举个例子

A& ref=1;//报错
const A& ref=1;//编译通过

为什么第一个代码报错，而第二个代码没有报错？
首先还是回到之前讲的这里会发生类型转换，而类型转换的时候产生了临时对象，而临时对象具有常性，所以必须用const接受。

2.匿名对象

void Func4( const A& a)
{

}
int main()
{
	A aa2;
	aa2 = Func3();
	Func4(A(1));
	return 0;
}

不用const接收参数会报错，因为匿名对象也具有常性。

所以尽量使用const&传参