类和对象（下）

1.构造函数剩余知识点：

*之前实现构造函数时，初始化成员变量时采用的是函数体内赋值，构造函数初始化还有一种方式，就是初始化列表，以一个冒号开始然后逗号分隔的数据成员列表。每个成员变量后面跟一个原来本该放在括号中的初始值或表达式。

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

cpp 复制代码

#include <iostream>
using namespace std;
//再探构造函数：
class Date
{
public:
	Date(int year, int month, int day)//每个成员定义的地方
		:_year(year)//只能初始化一次 
		//, _ptr(malloc())//可以跟一个表达式
		, _month(month)
		, _day(day)
	{}
	void Print()const
	{
		cout << _year << "-" << _month << "-" << _day << endl;
	}
private:
	//整体声明：
	int _year;
	int _month;
	int _day;
};

int main()
{
	//对象定义：
	Date d1(2024,7,24);
	d1.Print();
}

*引用成员变量、const成员变量、没有默认构造的类类型变量，必须放在初始化列表位置进行初始化，否则会报错,因为这三个都是得在定义的时候初始化。

*C++11支持在成员变量声明的位置给缺省值，这个缺省值主要是给没有显示初始化列表位置进行初始化，否则会编译报错。如果给了缺省值之后没有在main函数中写构造，编译器就会调用这个缺省值去初始化。

cpp 复制代码

#include <iostream>
using namespace std;
//再探构造函数：
class Date
{
public:
	void Print()const
	{
		cout << _year << "-" << _month << "-" << _day << endl;
	}
private:
	//整体声明：
	int _year = 1;//缺省值，没有开辟空间，还是定义。
	int _month = 1;//给初始化列表用的
	int _day = 1;
	//const int _n;//必须在初始化列表完成初始化
};

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

	//const int x;//只有一次初始化的机会就是定义的时候，后续没有改变的机会
	//x = 1;
}

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

*总结一下就是：每个成员都要走初始化列表。

（1）在初始化列表初始化成员。

（2）没有初始化列表的成员：

a、声明的地方有缺省值就用缺省值。

b、没有缺省值：

x、内置类型：不确定得看编译器，但大概率是随机值。

y、自定义类型：调用默认构造，没有默认构造会编译报错。

（3）引用、const没有默认构造自定义，必须在初始化列表初始化。

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

cpp 复制代码

class A
{
public:
	A(int a)
		:_a1(a)
		,_a2(_a1)
	{}
	void Pint()
	{
		cout << _a1 << " " << _a2 << endl;
	}
private:
	int _a2 = 2;
	int _a1 = 2;
};

int main()
{
	A aa(1);
	aa.Pint();

	return 0;
}

上述结果是打印出了1和随机值。由于_a2是先声明的，所以在构造函数里面_a2是先初始化的，用_a1去初始化_a2，此时_a1是随机值，所以最后_a2就是随机值，然后再去初始化_a1，结果是1。

2.类型转换：

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

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

cpp 复制代码

class A
{
public:
	A(int a)
		:_a1(a)
		, _a2(_a1)//先去初始化，_a1是随机值
	{}
	void Pint()
	{
		cout << _a1 << " " << _a2 << endl;
	}
private:
	int _a2 = 2;//先声明的
	int _a1 = 2;
};

int main()
{
	A aa1(1);
	A aa2 = 2;//类型转换
	//先用2构造一个临时对象，再用这个临时对象去拷贝构造aa2。
	aa2.Pint();

	A& raa1 = aa2;
	//A& raa2 = 2;//类型转换生成临时变量具有常性，给引用权限放大
	const A& raa2 = 2;

	return 0;
}

意义：更方便、更简单

假设有一个类A，和一个栈Stack，这时候要用先实例化类A然后放到栈里，就要先调用A的构造函数再去传用A实例化后的变量。

cpp 复制代码

class A
{
public:
	A(int a)
		:_a1(a)
		, _a2(_a1)//先去初始化，_a1是随机值
	{}
	void Pint()
	{
		cout << _a1 << " " << _a2 << endl;
	}
private:
	int _a2 = 2;//先声明的
	int _a1 = 2;
};
class Stack
{
public :
	void Push(const A& a)
	{
		//...
	}
private:
	A _arr[10];
	int _top;
};

int main()
{
	Stack st;

	A aa3(3);//先实例化去调用构造
	st.Push(aa3);//再传A去放入栈中


	return 0;
}

但是呢这下面一步可以利用隐式类型转换改写，比如我要构造的值是3，那么就可以：

cpp 复制代码

	st.Push(3);

上面是单参数的，多参数的如下：

cpp 复制代码

//多参数的转换：C++11支持
A aa4 = { 1,1 };
//也意味着支持：
const A& raa5 = { 2,2 };
//插入操作：
st.Push(aa4);
//也就意味着：
st.Push({ 2,2 });

3传过去就会产生一个临时对象。

3.static成员：

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

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

cpp 复制代码

class A
{
public:
	A()
	{
		_scount++;
	}
	A(const A& a)
	{
		_scount++;
	}
	~A()
	{
		_scount--;
	}
private:
	//类里面声明：
	static int _scount;
};

//类外面初始化：
int A::_scount = 0;

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

	return 0;
}

输出的结果是A类的大小，可以看出A类的大小是1，没有包含_scount的值。

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

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

cpp 复制代码

class A
{
public:
	A()
	{
		_scount++;
	}
	A(const A& a)
	{
		_scount++;
	}
	~A()
	{
		_scount--;
	}
	static int GetACount()//用于访问私有静态成员变量，没有this指针
	{
		_a++;//不能操作访问非静态成员，因为要this指针
		return _scount;
	}
private:
	//类里面声明：
	static int _scount;
	int _a;//非静态成员
};

下面利用静态成员变量来记录对象的创建。

cpp 复制代码

class A
{
public:
	A()
	{
		_scount++;
	}
	A(const A& a)
	{
		_scount++;
	}
	~A()
	{
		_scount--;
	}
	static int GetACount()//用于访问私有静态成员变量，没有this指针
	{
		return _scount;
	}
private:
	//类里面声明：
	static int _scount;
};

//类外面初始化：
int A::_scount = 0;

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

	//利用_scount来记录对象：
	cout << A::GetACount() << endl;//此时没有对象，_scount为0
	A a1, a2;
	A a3(a1);
	cout << A::GetACount() << endl;//构造两次，拷贝构造一次，为3
	return 0;
}

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

cpp 复制代码

static int GetACount()//用于访问私有静态成员变量，没有this指针
{
	_a++;//不能操作访问非静态成员，因为要this指针
	return _scount;
}
//非静态的可随便访问静态的
void  Func()
{
	cout << _scount << endl;
	cout << GetACount() << endl;
}

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

4.友元：

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

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

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

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

cpp 复制代码

class A
{
	//友元声明：
	friend void Func(const A&& aa, const B&& b);
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 << aa._a2 << endl;
	cout << bb._b1 << bb._b2 << endl;
}

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

cpp 复制代码

class A
{
	//友元声明：
	friend class B;//这样子B类中的成员函数就都可以访问A类的私有成员了。
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;
};

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

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

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

5.内部类：

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

cpp 复制代码

class A
{
private:
	static int _k;
	int _h = 1;
public:
	class B//B默认是A的友元
	{
	public:
		void foo(const A& a)
		{
			//cout << _k << endl;
			//cout << a._h << endl;
		}
	private:
		int _b = 1;
	};
};

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

代码的运行结果是4，也就是说类A里面包含的只有_h而没有_b，_b是独立出来的。

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

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

6.匿名对象：用类型（实参）定义出来的对象叫做匿名对象。之前定义的叫做有名对象。匿名对象生命周期中只在当前一行，一般临时定义一个对象当前用一下即可，就可以定义匿名对象。

cpp 复制代码

class A
{
private:
	static int _k;
	int _h = 1;
public:
	class B//B默认是A的友元
	{
	public:
		void foo(const A& a)
		{
			//cout << _k << endl;
			//cout << a._h << endl;
		}
	private:
		int _b = 1;
	};
};

int main()
{
	A aa1;

	A aa2();
	//不能这么定义对象，因为编译器不知道是函数声明还是定义对象。
	cout << sizeof(A) << endl;

	A();//匿名对象
	A(1);
}

7.对象拷贝时的编译器优化：(了解就好了）

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

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

cpp 复制代码

class A
{
public:
	A(int a = 10)
		:_a1(0)
	{
		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->" << _a1 << endl;
	}
	A& operator++()
	{
		++_a1;
	}
private:
	int _a1 = 1;
};

A f2()
{
	A aa(1);//构造
	++aa;
	return aa;//拷贝构造
}//析构
int main()//但是aa会被优化掉，直接消失。
{
	f2().Print();//用临时对象调用Print
	cout << endl;//临时对象析构
	cout << "**********" << endl;
}