【C++】4：类和对象(下)-优快云博客

一、再探构造函数

之前我们实现构造函数时，初始化成员变量主要使用函数体内赋值，构造函数初始化还有⼀种方式，就是初始化列表，初始化列表的使用方式是以⼀个冒号开始，接着是⼀个以逗号分隔的数据成员列表，每个"成员变量"后面跟⼀个放在括号中的初始值或表达式。

class A {
pubic:
	A() :_a1(1),_a2(2),_a3(3)
	{}
private:
	int _a1;
	int _a2;
	int _a3;
};
以上代码就是使用初始化列表给成员变量赋值的例子，当我们使用A类型来创建对象时，成员变量自动初始化为_a1=1,_a2=2,_a3=3;

也可以用传入的参数实现初始化列表，如下所示：
#include<iostream>
using namespace std;
class A {
public:
	A(int a1,int a2,int a3) :_a1(a1),_a2(a2),_a3(a3)
	{}
	void Print() {
		cout << _a1 << endl;
		cout << _a2 << endl;
		cout << _a3 << endl;
	}
private:
	int _a1;
	int _a2;
	int _a3;
};
int main() {
	A a(5, 6, 7);
	a.Print();
	return 0;
}
上面的例子如果不传参数创建对象会出现错误，这是因为没有合适的默认构造函数，有时，我们想在创建对象的时候，不想传入参数，在构造函数的时候也可以使用默认参数，如下所示：
#include<iostream>
using namespace std;
class A {
public:
	A(int a1=1, int a2=2, int a3=3) :_a1(a1), _a2(a2), _a3(a3)
	{
	}
	void Print() {
		cout << _a1 << endl;
		cout << _a2 << endl;
		cout << _a3 << endl;
	}
private:
	int _a1;
	int _a2;
	int _a3;
};
int main() {
	A a;
	a.Print();
	return 0;
}
输出为：

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

代码如下所示：
#include<iostream>
using namespace std;
class A {
public:
	A() :_a1(1), _a2(1), _a1(3)
	{}
private:
	int _a1;
	int _a2;
};
运行之后，会报一个已经被初始化的错误，如下所示：

虽然我们不能在初始化列表中写两次，但是我们可以在这个构造函数的函数体里面重新修改_a1的值，如下所示：
#include<iostream>
using namespace std;
class A {
public:
	A(int a1=1,int a2=2) :_a1(a1), _a2(a2)
	{
		_a1 = 3;
	}
		void Print() {
			cout << _a1 << endl;
			cout << _a2 << endl;
		}
private:
	int _a1;
	int _a2;
};
int main() {
	A a;
	a.Print();
	return 0;
}

引用成员变量，const成员变量，没有默认构造的类类型变量，必须放在初始化列表位置进行初始化，否则会编译报错。

在C++中，我们可以在构造函数内部给成员变量赋值，为什么还要使用初始化列表呢？这是因为在构造函数内部给成员变量赋值，并不算成员变量初始化，只有使用初始化列表才是给成员变量初始化，但是C++语言中有的变量必须初始化，如引用成员变量，const成员变量和没有默认构造的类类型变量，如果类里面有这三类成员变量并且没有使用初始化列表初始化，就会报错。代码如下所示：
#include<iostream>
using namespace std;
class Time {
public:
	Time(int hour):_hour(hour)
	{}
private:
	int _hour;
};
class Date {
public:
	Date(int year, int month, int day, int& x)
		:_year(year)
		, _month(month)
		, _day(day)
		, t(13)
		,_x(x)
		,_a1(1)
	{}
private:
	int _year;
	int _month;
	int _day;
	Time t;
	int& _x;
	const int _a1;
};
int main() {
	int x = 0;
	Date d1(2025, 9, 16, x);
	return 0;
}
如果我们将初始化列表的后三个给注释，就会发生错误，如下所示：

C++11支持持在成员变量声明的位置给缺省值，这个缺省值主要是给没有显示在初始化列表初始化的成员使用的。

C++支持在成员变量声明的位置给缺省值，但是这个并不是成员变量的初始化，而是在没有显示在初始化列表初始化的成员使用的，代码如下所示:
#include<iostream>
using namespace std;
class A {
public:
	A():_a1(100),_a2(200) 
	{}
	void Print() {
		cout << "_a1=" << _a1 << endl;
		cout << "_a2=" << _a2 << endl;
		cout << "_a3=" << _a3 << endl;
	}
private:
	int _a1 = 1;
	int _a2 = 2;
	int _a3 = 3;
};
int main() {
	A a;
	a.Print();
	return 0;
}
输出如下所示：

在初始化列表中，我们给_a1,_a2这两个成员初始化了，就不会使用缺省值，但是我们没有给_a3这个成员初始化，所有这个变量就会使用在变量声明时写的默认值，

尽量使用初始化列表初始化，因为那些你不在初始化列表初始化的成员也会走初始化列表，如果这个成员在声明位置给了缺省值，初始化列表会用这个缺省值初始化。如果你没有给缺省值，对于没有显示在初始化列表初始化的内置类型成员是否初始化取决于编译器，C++并没有规定。对于没有显示在初始化列表初始化的自定义类型成员会调用这个成员类型的默认构造函数，如果没有默认构造会编译错误。
初始化列表中按照成员变量在类中声明顺序进行初始化，跟成员在初始化列表出现的的先后顺序无关。建议声明顺序和初始化列表顺序保持一致。

让我们来看一下这个题目;

下⾯程序的运⾏结果是什么（）

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();
}
这个题的正确答案是：D

这是为什么呢？

这是因为初始化列表中按照成员变量在类中声明顺序进行初始化，跟成员在初始化列表出现的的先后顺序无关。在声明成员变量时，先声明的_a2,再声明的_a1,所以初始化列表里面也会先初始化_a2，再初始化_a1，我们使用_a1初始化_a2的时候，_a1的是不确定的数值，取决于编译器，所以_a2是随机值。然后再初始化_a1.

初始化列表总结：

无论是否显示写初始化列表，每个构造函数都有初始化列表；

无论是否在初始化列表显示初始化成员变量，每个成员变量都要走初始化列表初始化；

二、类型转化

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

构造函数前面加explicit就不再支持隐式类型转换。
类类型的对象之间也可以隐式转换，需要相应的构造函数支持。

我们现在写一个类，代码如下:

class A
{
public:
	A(int a1)
		:_a1(a1)
	{
	}
	A(int a1, int a2)
		:_a1(a1)
		, _a2(a2)
	{}
	void Print()
	{
		cout << _a1 << " " << _a2 << endl;
	}
private:
	int _a1 = 1;
	int _a2 = 2;
};

根据上面代码，我们在main函数内部能写这样的代码吗？

int main(){
    A aa1 = 1;
    aa1.Print();
}

答案是可以的，这是因为，我们将1赋值给aa1，会构造一个A的临时对象，在用这个临时对象拷贝构造aa1编译器遇到连续构造+拷贝构造->优化为直接构造。

构造函数explicit就不再支持隐式类型转换：explicit A(int a1)

一般我们不会像上面这样用，常用的用法是，我们写一个栈，我们想要在栈里面存上述A类型的数据，我们可以直接push(1),编译器可以自动的创建一个A类型的临时变量。然后把这个临时变量给push。就不用这么写了：A aa1(1);push(aa1);

三、static成员

用static修饰的成员变量，称之为静态成员变量，静态成员变量⼀定要在类外进行初始化。
静态成员变量为所有类对象所共享，不属于某个具体的对象，不存在对象中，存放在静态区。
⽤static修饰的成员函数，称之为静态成员函数，静态成员函数没有this指针。
静态成员函数中可以访问其他的静态成员，但是不能访问非静态的，因为没有this指针。
⾮静态的成员函数，可以访问任意的静态成员变量和静态成员函数。
突破类域就可以访问静态成员，可以通过类名::静态成员或者对象.静态成员来访问静态成员变量和静态成员函数。
静态成员也是类的成员，受public、protected、private 访问限定符的限制。
静态成员变量不能在声明位置给缺省值初始化，因为缺省值是个构造函数初始化列表的，静态成员变量不属于某个对象，不走构造函数初始化列表。

我们使用static来计算一个类实例化出来了多少对象。

代码如下：


// 实现⼀个类，计算程序中创建出了多少个类对象？
#include<iostream>
using namespace std;
class A
{
public:
	A()
	{
		++_scount;
	}
	A(const A& t)
	{
		++_scount;
	}
	~A()
	{
		--_scount;
	}
	static int GetACount()
	{
		return _scount;
	}
private:
	// 类⾥⾯声明
	static int _scount;
};
// 类外⾯初始化
int A::_scount = 0;
int main()
{
	cout << A::GetACount() << endl;
	A a1, a2;
	A a3(a1);
	cout << A::GetACount() << endl;
	cout << a1.GetACount() << endl;
	// 编译报错：error C2248: “A::_scount”: ⽆法访问 private 成员(在“A”类中声明)
	//cout << A::_scount << endl;
	return 0;
}

四、友元

友元提供了⼀种突破类访问限定符封装的方式，友元分为：友元函数和友元类，在函数声明或者类声明的前面加friend，并且把友元声明放到⼀个类的里面。
外部友元函数可访问类的私有和保护成员，友元函数仅仅是⼀种声明，他不是类的成员函数。
友元函数可以在类定义的任何地方声明，不受类访问限定符限制。
⼀个函数可以是多个类的友元函数。
友元类中的成员函数都可以是另⼀个类的友元函数，都可以访问另⼀个类中的私有和保护成员。
友元类的关系是单向的，不具有交换性，比如A类是B类的友元，但是B类不是A类的友元。
友元类关系不能传递，如果A是B的友元， B是C的友元，但是A不是C的友元。
有时提供了便利。但是友元会增加耦合度，破坏了封装，所以友元不宜多用。

一个函数做一个类友元的情况，这个函数可以访问这个类里面的私有成员。代码如下：
#include<iostream>
using namespace std;
class B;//前置声明
class A {
	friend int Func(const A& a, const B& b);
public:
	A(int a1=1) :_a1(a1)
	{}
private:
	int _a1;
};
class B {
	friend int Func(const A& a, const B& b);
public:
	B(int b1=3) :_b1(b1)
	{
	}
private:
	int _b1;
};

int Func(const A& a,const B& b) {
	return a._a1 + b._b1;
}
int main() {
	A aa;
	B bb;
	Func(aa, bb);
	return 0;
}
如果不在A类和B类里面增加一个友元声明，这个函数就访问不了私有成员。

一个类做一个类友元的情况，这个类里面的所有函数第可以访问这个类里面的私有成员。代码如下：

#include<iostream>
using namespace std;
class B;
class A {
	friend class B;
public:
	A(int a1=1,int a2=2):_a1(a1),_a2(a2)
	{}
	void Print() {
		cout << "_a1=" << _a1 << endl;
		cout << "_a2=" << _a2 << endl;

	}
private:
	int _a1;
	int _a2;
};
class B {
public:
	void func1(A& aa) {
		aa._a1 += 10;
	}
	void func2(A& aa) {
		aa._a2 += 100;
	}
};
int main() {
	A a;
	B b;
	a.Print();
	b.func1(a);
	b.func2(a);
	a.Print();

	return 0;
}

五、内部类

如果⼀个类定义在另⼀个类的内部，这个内部类就叫做内部类。内部类是⼀个独立的类，跟定义在全局相比，他只是受外部类类域限制和访问限定符限制，所以外部类定义的对象中不包含内部类
内部类默认是外部类的友元类。
内部类本质也是⼀种封装，当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
		}
		int _b1;
	};
};
int A::_k = 1;
int main()
{
	cout << sizeof(A) << endl;
	A::B b;
	A aa;
	b.foo(aa);
	return 0;
}