类和对象（下）

1. 再探构造函数

(1)初始化列表

• 之前我们实现构造函数时，初始化成员变量主要使用函数体内赋值，构造函数初始化还有一种方

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

• 每个成员变量在初始化列表中只能出现一次 ，语法理解上 初始化列表可以认为是每个成员变量定义初始化的地方 。

• 由于引用 / const类型的成员变量 / 类类型变量都只能在定义的时候初始化，后续不能改值，所以 引用成员变量 / const成员变量 / 没有默认构造的类类型变量，必须放在初始化列表位置进行初始化 ，否则会编译报错。

class Date
{
public:
	//初始化列表
	//是每个成员变量定义初始化的地方
	Date(int xx, int year, int month, int day)
		:_year(year)
		, _month(month)
		, _day(day)

		//引用和const类型必须在定义时初始化
		//const类型的变量必须在初始化列表初始化
		, _n(1)
		//引用也必须在初始化列表初始化
		, _ref(xx)
		//Time类里如果有默认构造，自定义类型成员可以不在这里初始化
		//反之，只能在初始化列表初始化
		, _t(xx)
		,_ptr((int*)malloc(12))
	{
		if (_ptr == nullptr)
		{//判断一下
			perror("malloc fail!");
		}
		else
		{//再初始化
			memset(_ptr, 0, 12);
		}
		//这三种成员变量如果不在初始化列表初始化，会报以下错
		// error C2512: “Time”: 没有合适的默认构造函数可⽤
		// error C2530 : “Date::_ref” : 必须初始化引⽤
		// error C2789 : “Date::_n” : 必须初始化常量限定类型的对象}
	}
	void Print()
	{
		cout << _year << "/" << _month << "/" << _day << endl;
	}
private:
	//成员声明，缺省值—>初始化列表用
	int _year = 1;
	int _month = 1;
	int _day = 1;
	int* _ptr = (int*)malloc(1);

	const int _n;
	int& _ref;
	Time _t = 1;
};

int main()
{
	int x = 0;
	//对象定义
	Date d1(x, 2024, 4, 4);
	d1.Print();

	//引用
	//int& ret(x);

	return 0;
}

• C++11支持在成员变量声明的位置给缺省值（不一定只是个值，也可以是一个表达式），这个缺省值主要是给没有显示在初始化列表初始化的成员使用的。 【 当没有显示实现初始化列表，我们无参定义对象时，系统会调用默认构造，并用上成员变量声明位置给的缺省值】

class Date
{
public:
	//初始化列表
	Date(int xx, int year, int month, int day)
		:_year(year)
		, _month(month)
		, _day(day)
        //...
private:
	//成员声明，缺省值—>初始化列表用
	int _year = 1;
	int _month = 1;
	int _day = 1;
	int* _ptr = (int*)malloc(1);
	Time _t = 1;
};

• 尽量使用初始化列表初始化 ，因为那些你 不在初始化列表初始化的成员也会走初始化列表，如果这个成员在声明位置给了缺省值，初始化列表会用这个缺省值初始化。如果你没有给缺省值，对于没有显示在初始化列表初始化的内置类型成员是否初始化取决于编译器 ，C++并没有规定。 对于没有显示在初始化列表初始化的自定义类型成员会调用这个成员类型的默认构造函数 ，如果没有默认构 造会编译错误。

• 初始化列表中按照 成员变量在类中声明顺序（也是在内存中的存放顺序） 进行初始化，跟成员在初始化列表出现的的先后顺序无 关。建议声明顺序和初始化列表顺序保持一致。

下列程序运行结果是：（D）

A. 输出 1 1

B. 输出 2 2

C. 编译报错

D. 输出 1 随机值

E. 输出 1 2

F. 输出 2 1

#include<iostream>
using namespace std;
class A
{
public:
	A(int a)
		:_a1(a)
		,_a2(_a1)
	{}
	void Print() {
		cout << _a1 << " " << _a2 << endl;
	}
private:
	int _a2 = 2;
	int _a1 = 2;
};
int main()
{
	A aa(1);
	aa.Print();
}

解析：由于初始化列表中按照成员变量在类中声明顺序进行初始化，所以先初始化_a2，但_a2是由_a1初始化的，此时_a1还未初始化，所以此时_a1是随机值，那么_a2也就是随机值；然后用a对_a1初始化，结果是1。

• 初始化列表和函数体是可以结合使用的， 比如我们在Date类里多定义一个指针，那么在初始化列表就可以直接开辟好空间，并初始化了

Date(int year, int month, int day)
	:_year(year)
	, _month(month)
	, _day(day)
	,_ptr((int*)malloc(12))//指针
{
	if (_ptr == nullptr)
	{//判断一下
		perror("malloc fail!");
	}
	else
	{//再初始化
		memset(_ptr, 0, 12);
	}
	
}

• 在函数参数的位置给缺省值，是用于在定义对象时是否显示传参，如果显示传参就用显示的参数，如果不显示传参，就用此时函数参数位置上的缺省值，但是否用初始化该参数，就得看初始化列表里有没有该参数了。

class Date
{
public:
	//初始化列表
	//是每个成员变量定义初始化的地方
	Date(int year = 1, int month = 1, int day = 1)
		:_year(year)
		, _month(month)
	{}
	void Print()
	{
		cout << _year << "/" << _month << "/" << _day << endl;
	}
private:
	//成员声明，缺省值—>初始化列表用
	int _year = 1;
	int _month;
	int _day;
};

int main()
{
	//对象定义
	Date d1(2024);
	d1.Print();

	return 0;
}

(2)总结整理

2.类型转换

(1)隐式类型转换

• C++支持 内置类型隐式类型转换为类类型对象 ，需要有相关 内置类型为参数的构造函数

#include<iostream>
using namespace std;
class A
{
public:
	A(int a)
		:_a1(a)
	{}
	void Print() {
		cout << _a1 << endl;
	}
private:
	int _a1 = 2;
};
int main()
{
	A aa(1);
	aa.Print();

	//隐式类型转换
	A aa1 = 2;
	// 2构造⼀个A的临时对象，再⽤这个临时对象拷贝构造aa1
	// 编译器遇到连续构造+拷贝构造->优化为直接构造
	aa1.Print();

	A& aa2 = aa1;
	//这里aa2不能直接引用2，说明不是直接构造
	//而是产生了临时对象，而临时对象具有常性，
	//会编译报错，所以要用const修饰
	const A& aa3 = 3; 
}

上述代码存在一个隐式类型转换，A aa1 = 2的过程是2构造出一个A的临时变量，再用这个临时对象拷贝构造aa1，编译器遇到连续构造+拷贝构造->优化为直接构造。

但人就会认为这个直接构造，但实际上是两个过程，只是被编译器优化了，怎么证明出这一点：

A& aa2 = aa1;
// A& aa3 = 3; //报错
const A& aa3 = 3;

这里aa2不能直接引用2，说明不是直接构造，而是产生了临时对象，而临时对象具有常性，会编译报错，所以要用const修饰

隐式类型转换真正适用的地方，示例：

但要注意的是，Push函数的参变量要加上const，因为临时变量具有常性。

#include<iostream>
using namespace std;

class Stack
{
public:
	void Push(const A& aa)
	{
		//...
	}
private:
	A _arr[10];
	int _top;
};

class A
{
public:
	A(int a = 1)
		:_a1(a)
	{}
	void Print() {
		cout << _a1 << endl;
	}
private:
	int _a1 = 2;
};
int main()
{
	Stack st;
	A aa4 = 2;
	st.Push(aa4);
	//这里可以直接用隐式类型转换，不用新定义新对象
	st.Push(3);
}

只有单参数的的函数才能这样用，多参数的默认是不支持的。多参数要用大括号来实现（C++11支持）

	A aa5 = { 2,2 };
	const A& aa6 = { 2,2 };

	Stack st;
	st.Push(aa5);
	st.Push({ 2,2 });

(2) explicit

• 构造函数前面加explicit就不再支持隐式类型转换

3.static成员

(1) 性质

• 用static修饰的成员变量，称之为 静态成员变量 ，静态成员变量一定要 在类外进行初始化 。

• 静态成员变量 为所有类对象所共享 ， 不属于某个具体的对象，不存在对象中，存放在静态区 。

• 用static修饰的成员函数，称之为静态成员函数， 静态成员函数没有this指针 。

• 静态成员函数中可以访问其他的静态成员，但是不能访问非静态的，因为没有this指针。

• 非静态的成员函数，可以访问任意的静态成员变量和静态成员函数。

• 突破类域就可以访问静态成员，可以通过 类名::静态成员 或者 对象.静态成员 来访问静态成员变量和静态成员函数。

• 静态成员也是类的成员，受public、protected、private 访问限定符的限制。

• 静态成员变量 不能在声明位置给缺省值初始化 ，因为缺省值是个构造函数初始化列表的，静态成员变量不属于某个对象，不走构造函数初始化列表。

#include<iostream>
using namespace std;
class A
{
public:
	A()
	{
		++_scount;
	}
	A(const A& t)
	{
		++_scount;
	}
	~A()
	{
		--_scount;
	}
	//静态成员函数可以调用静态的成员变量
	static int GetACount()
	{
		//++_a; //静态成员不能访问非静态的
		return _scount;
	}
	//非静态成员函数可以访问静态成员变量
	void func()
	{
		cout << _scount << endl;
		cout << GetACount() << endl;
	}
private:
	// 类里面声明
	static int _scount;
	int _a;
};
// 类外面初始化，制定类域
int A::_scount = 0;

int main()
{
	cout << sizeof(A) << endl;

	//指定类域访问静态成员
	cout << A::GetACount() << endl;
	A a1, a2;
	//代码块的局部域
	{
		A a3(a1);//拷贝构造
		cout << A::GetACount() << endl;
	}
	//通过对象访问静态成员
	cout << a1.GetACount()<< endl;
	cout << A::GetACount() << endl;
	
	return 0;
}

(2)练习题1

class Sum
{
public:
    Sum()
    {
        _ret += _i;
        ++_i;
    }
    static int GetRet()
    {//静态成员函数返回结果
        return _ret;
    }
private:
    static int _i;
    static int _ret;
};
int Sum:: _i = 1;
int Sum:: _ret = 0;

class Solution {
public:
    int Sum_Solution(int n) {
        Sum a[n];//要调用n次构造，变长数组
        return Sum::GetRet();
    }
};

(3)练习题2

设已经有A,B,C,D 4个类的定义，程序中A,B,C,D构造函数调用顺序为？（E）

设已经有A,B,C,D 4个类的定义，程序中A,B,C,D析构函数调用顺序为？（B）

A：D B A C D：A B D C

B：B A D C E：C A B D

C：C D B A F：C D A B

C c;
int main()
{
A a;
B b;
static D d;
return 0；
}

• 全局变量c在main函数之前就创建好了，排除ABD

• 局部变量，a先创建，所以a比b先调用构造函数

• d是局部的静态变量，是在第一次程序运行到该行的时候才会初始化

• 先构造的后析构，所以b比a先析构，排除DEF

• 局部变量比全局变量先析构

• 静态成员函数的生命周期是全局的，作用域在函数体内，所以比c先析构

4.友元

(1)友元函数

• 友元提供了一种 突破类访问限定符封装的方式 ，友元分为： 友元函数和友元类 ， 在函数声明或者类声明的前面加friend，并且把友元声明放到一个类的里面。

• 外部友元函数可访问类的私有和保护成员 ，友元函数仅仅是一种 声明，他 不是类的成员函数。

• 友元函数可以 在类定义的任何地方声明，不受类访问限定符限制。

• 一个函数可以是多个类的友元函数。

#include<iostream>
using namespace std;
// 前置声明，A类中用到了B类型变量
class B;

class A
{
	// 友元声明
	friend void func(const A& aa, const B& bb);
private:
	int _a1 = 1;
	int _a2 = 2;
};
class B
{
	// 友元声明
	friend void func(const A& aa, const B& bb);
private:
	int _b1 = 3;
	int _b2 = 4;
};
//一个函数可以是多个类的友元函数
void func(const A& aa, const B& bb)
{
	cout << aa._a1 << endl;
	cout << bb._b1 << endl;
}
int main()
{
	A aa;
	B bb;
	func(aa, bb);
	return 0;
}

(2)友元类

• 友元类中的成员函数都可以是另一个类的友元函数 ，都可以访问另一个类中的私有和保护成员。

• 友元类的关系是 单向的，不具有交换性 ，比如A类是B类的友元，但是B类不是A类的友元。

• 友元类关系 不能传递 ，如果A是B的友元， B是C的友元，但是A不是C的友元。

• 有时提供了便利。但是友元会增加耦合度，破坏了封装，所以友元不宜多用。

#include<iostream>
using namespace std;

class A
{
	// 友元类
	// B可以访问A类中的私有和保护成员
	friend class B;
private:
	int _a1 = 1;
	int _a2 = 2;
};
class B
{
public:
	void func1(const A& aa)
	{
		cout << aa._a1 << endl;
		cout << _b1 << endl;
	}
	void func2(const A& aa)
	{
		cout << aa._a2 << endl;
		cout << _b2 << endl;
	}
private:
	int _b1 = 3;
	int _b2 = 4;
};
int main()
{
	A aa;
	B bb;
	bb.func1(aa);
	bb.func1(aa);
	return 0;
}

5.内部类

• 如果一个类定义在另一个类的内部，这个内部的类就叫做内部类。 【 内部类是一个独立的类，跟定义在全局相比，他只是受外部类类域限制和访问限定符限制，所以外部类定义的对象中不包含内部类】

• 内部类 默认是外部类的友元类 。

• 内部类本质也是一种封装，当A类跟B类紧密关联， A类实现出来主要就是给B类使用 ，那么可以考 虑把A类设计为B的内部类， 如果放到private/protected位置，那么A类就是B类的专属内部类，其他地方都用不了。

#include<iostream>
using namespace std;
class A
{
private:
	static int _k;
	int _h = 1;
public:
	class B //B默认就是A的友元
	{
	public:
		void foo(const A & a)
		{
			cout << _k << endl; //OK
			cout << a._h << endl; //OK
		}
	private:
		int _b = 1;
	};
};
int A::_k = 1;
int main()
{
	//内部类是一个独立的类,只是受外部类类域限制和访问限定符限制，
	//所以外部类定义的对象中不包含内部类
	cout << sizeof(A) << endl;//4
	//受外部类类域限制
	A::B b;
	A aa;
	//受访问限定符限制
	b.foo(aa);
	return 0;
}

对于刚刚的练习题，还可以用到内部类解决：

#include <climits>
class Solution {
private:
    static int _i;
    static int _ret;
    //内部类
    //默认Sum是Solution的友元
    class Sum 
    {
    public:
        Sum()
        {//访问另一个类中的私有和保护成员
            _ret += _i;
            ++_i;
        }
    };
    
public: 
    int Sum_Solution(int n)
    {
        Sum a[n];//变长数组
        return _ret;
    }
};
int Solution::_i = 1;
int Solution::_ret = 0;

6.匿名对象

• 用类型(实参) 定义出来的对象叫做匿名对象，相比之前我们定义的类型对象名(实参) 定义出来的 叫有名对象

• 匿名对象生命周期只在当前一行，一般临时定义一个对象当前用一下即可，就可以定义匿名对象。

#include<iostream>
using namespace std;

class A
{
public:
	A(int a = 0)
		:_a(a)
	{
		cout << "A(int a)" << endl;
	}
	~A()
	{
		cout << "~A()" << endl;
	}
private:
	int _a;
};
class Solution {
public:
	int Sum_Solution(int n) {
		//...
		return n;
	}
};
int main()
{
	A aa1;
	// 不能这么定义对象，因为编译器无法识别下面是一个函数声明，还是对象定义
	//A aa1();
	
	// 但是我们可以这么定义匿名对象，匿名对象的特点不用取名字，
	// 但是他的生命周期只有这一行，我们可以看到下一行他就会自动调用析构函数
	A();
	A(1); 
	A aa2(2);

	//定义普通对象
	Solution st;
	cout << st.Sum_Solution(10) << endl;

	// 匿名对象在这样场景下就很好用，当然还有一些其他使用场景，以后遇到了再说
	Solution().Sum_Solution(10);
	return 0;
}

7.对象拷贝时的编译器优化

• 现代编译器会为了尽可能提高程序的效率，在不影响正确性的情况下会 尽可能减少一些传参和传返回值的过程中可以省略的拷贝。

• 如何优化C++标准并没有严格规定，各个编译器会根据情况自行处理。当前主流的相对新一点的编 译器对于连续一个表达式步骤中的连续拷贝会进行合并优化，有些更新更"激进"的编译还会进行跨行 跨表达式的合并优化。

#include<iostream>
using namespace std;

class A
{
public:
	//构造
	A(int a = 0)
		:_a1(a)
	{
		cout << "A(int a)" << endl;
	}
	//拷贝构造
	A(const A& aa)
		:_a1(aa._a1)
	{
		cout << "A(const A& aa)" << endl;
	}
	//赋值重载
	A& operator=(const A& aa)
	{
		cout << "A& operator=(const A& aa)" << endl;
		if (this != &aa)
		{
			_a1 = aa._a1;
		}
		return *this;
	}
	~A()
	{
		cout << "~A()" << endl;
	}
	void Print()
	{
		cout << "A::Print()" << endl;
	}
private:
	int _a1 = 1;
};

void f1(A aa)//如果用引用传参，会减少拷贝
{}

A f2()
{
	A aa;
	return aa;
}
void Test1()
{
	//const A& aa2 = 1;//引用的是构造的临时对象
	A aa1 = 1;//构造 + 拷贝构造 -> 优化成直接构造
	f1(aa1);
	cout << endl;

	//匿名对象
	//优化
	f1(A(1));
	cout << endl;

	//类型转换中间会产生临时对象
	//隐式类型，优化
	f1(1);
	cout << endl;
}

void Test2()
{
	传值返回，会产生临时对象
	f2();//构造 + 拷贝构造 
	cout << endl;
	//本质上是，1生成临时对象，构造+拷贝构造，临时对象出作用域销毁，返回的是aa的拷贝
	//编译器优化直接将1生成的临时对象作为返回值

	//利用返回值，调用类的Print函数(本行用完就析构了)
	f2().Print();
	cout << "********" << endl;
	 
	//优化
	A ret = f2();
	ret.Print();
	cout << endl;

	//一个表达式中，连续拷贝构造+赋值重载->无法优化
	A tmp;
	tmp = f2();//赋值
	tmp.Print();
	cout << endl;
}
int main()
{
	Test2();
	return 0;
}