C++入门——类和对象【3】（6）

前言

本节是C++类和对象中的最后一节，学完本节内容并且能够掌握之前所学的所有内容的话，C++就可以说是入门了，那我们废话不多说，正式进入今天的学习

1. 再谈构造函数

1.1 引入

我们在栈的背景下来看

栈的代码：

​typedef int DataType;
class Stack
{
public:
	Stack(size_t capacity = 3)
	{
		_array = (DataType*)malloc(sizeof(DataType) * capacity);
		if (NULL == _array)
		{
			perror("malloc申请空间失败!!!");
			return;
		}
		_capacity = capacity;
		_size = 0;
	}
	
	void Push(DataType data)
	{
		// CheckCapacity();
		_array[_size] = data;
		_size++;
	}

	~Stack()
	{
		if (_array)
		{
			free(_array);
			_array = NULL;
			_capacity = 0;
			_size = 0;
		}
	}
private:
	DataType* _array;
	int _capacity;
	int _size;
};

我们通过之前的学习可以知道，如果我们创建一个名字为MyQueue的类，如下所示，那么MyQueue的构造函数可以省略不写

class MyQueue
{
	Stack _st1;
	Stack _st2;
}; ​

因为这里的MyQueue是一个自定义类型，编译器会自动生成MyQueue的构造函数，而在MyQueue中编译器自动生成的构造函数会自动调用MyQueue中的自定义类型Stack的默认构造函数

假设自定义类型Stack中没有提供默认构造函数呢？如下所示：

	Stack(size_t capacity)
	{
		_array = (DataType*)malloc(sizeof(DataType) * capacity);
		if (NULL == _array)
		{
			perror("malloc申请空间失败!!!");
			return;
		}
		_capacity = capacity;
		_size = 0;
	}

此时在MyQueue的里面无法调用自定义类型Stack的构造函数，我们就需要显式的去调用构造函数了，所以我们就需要用到初始化列表

1.2 构造函数体内赋值和初始化列表

我们首先需要知道，构造函数初始化可以分为两种方式：

1.其中一种方法就是我们之前学过的函数体内初始化，这种初始化是在构造函数的里面完成对成员的初始化

class Date
{
public:
	Date(int year, int month, int day)
	{
		_year = year;
		_month = month;
		_day = day;
	}

private:
	int _year;
	int _month;
	int _day;
};

虽然上述构造函数调用之后，对象中已经有了一个初始值，但是不能将其称为对对象中成员变量的初始化，构造函数体中的语句严格意义上来说只能将其称为赋初值，而不能称作初始化。因为初始化只能初始化一次，而构造函数体内可以多次赋值

2.第二种方法就是初始化列表

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

class Date
{
public:
	Date(int year, int month, int day)
		:
		_year(year)
		, _month(month)
		, _day(day)
	{}
private:
	int _year;
	int _month;
	int _day;
};

初始化列表是可以混合使用的，什么叫做混合使用呢？我们来举一个例子：

Date(int year, int month, int day)
	:
	_year(year)
	, _month(month)
{
	_day = day;
}

1.3 初始化列表的注意事项

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

1.3.2. 类中包含某些特殊成员时，必须放在初始化列表位置进行初始化：

初始化列表是每一个成员定义的地方。我们通过之前所学习过的知识可以知道：下面是每一个成员声明的地方。

private:
	int _year;
	int _month;
	int _day;

我们知道声明是不开空间的，只有实例化（整体定义）的时候才开空间。但是初始化列表是每一个成员定义的地方，定义就需要给值。

我们此时可能会存在疑问：为什么C++要设置初始化列表来定义成员变量，在整体定义的时候定义变量不就行了吗？

答案是如果不设置初始化列表的时候就会出现三个问题：

1.3.2.1. const 成员

class Date
{
public:
	Date(int year, int month, int day)
		:
		_year(year)
		, _month(month)
	{
		_day = day;
		_a = 1;
	}
private:
	int _year;
	int _month;
	int _day;
	const int _a;
};

应该要以下面的形式定义：

class A
{
public:
	A(int a)
		:_a(a)
	{}
private:
	int _a;
};

class Date
{
public:
	Date(int year, int month, int day,int& i)
		:
		_year(year)
		, _month(month)
		,_a(1)
	{
		_day = day;
	}
private:
	int _year;
	int _month;
	int _day;
	const int _a;
};

const成员需要在定义的地方初始化，const成员除了初始化的时候能够赋值以外，不能够在其他的地方赋值和修改，所以const成员只能在初始化列表的时候定义

1.3.2.2.引用

当我们在成员变量中定义一个引用，引用也必须在定义的时候初始化，所以引用也只能在初始化列表的时候定义

	Date(int year, int month, int day,int& i)
		:
		_year(year)
		, _month(month)
		,_a(1)
	{
		_day = day;
		_refi = 0;
	}

正确的定义方式应该如下所示： 

class Date
{
public:
	Date(int year, int month, int day,int& i)
		:
		_year(year)
		, _month(month)
		,_a(1)
		,_refi(i)
	{
		_day = day;
	}
	void func()
	{
		++_refi;
		++_refi;
	}
private:
	int _year;
	int _month;
	int _day;
	const int _a;
	int& _refi;
};

int main()
{
	int n = 0;
	Date d1(2024, 5, 25, n);
	d1.func();
	cout << n << endl;
	return 0;
}

1.3.2.3.没有默认构造函数的自定义类型成员

class A
{
public:
	A(int a)
		:_a(a)
	{}
private:
	int _a;
};

class Date
{
public:
	Date(int year, int month, int day,int& i)
		:
		_year(year)
		, _month(month)
		,_a(1)
		,_refi(i)
	{
		_day = day;
	}
	void func()
	{
		++_refi;
		++_refi;
	}
private:
	int _year;
	int _month;
	int _day;
	const int _a;
	int& _refi;
	A _x;
};

因为该自定义类型没有默认构造函数，所以我们必须在它初始化的时候调用它带参的构造函数

所以这串代码的正确形式应该如下所示：

class A
{
public:
	A(int a)
		:_a(a)
	{}
private:
	int _a;
};

class Date
{
public:
	Date(int year, int month, int day,int& i)
		: _year(year)
		, _month(month)
		, _a(1)
		, _refi(i)
		, _x(1)
	{
		_day = day;
	}
	void func()
	{
		++_refi;
		++_refi;
	}
private:
	int _year;
	int _month;
	int _day;
	const int _a;
	int& _refi;
	A _x;
};

有了这些知识我们就可以解决1.1引入中提到里面的问题了

class MyQueue
{
public:
	MyQueue(int capacity = 10)
		:_st1(capacity)
		,_st2(capacity)
	{}
private:
	Stack _st1;
	Stack _st2;
};

3. 尽量使用初始化列表初始化，因为不管你是否使用初始化列表，对于自定义类型成员变量，一定会先使用初始化列表初始化

到这里我们可能有一个疑问：我们知道每个成员都会在初始化列表的时候定义，然而之前代码中的_day变量并没有在初始化列表中定义，那么_day变量会定义吗？_day变量又是在哪里定义的呢？

其实_day变量是会定义的，因为_day变量是内置类型的，编译器不会对其处理，所以会给一个随机值

但是对于一个自定义类型的变量，我们如果不在初始化列表的时候定义它，编译器会自动对其处理，会调用它的默认构造函数

总的来说：不管用户写不写初始化列表的代码，每个成员都要走初始化列表，因为初始化列表是每个成员定义的地方。在构造函数的初始化列表阶段，对于内置类型会使用随机值去初始化，对于自定义类型会去调用它的默认构造函数

private:
	int _year = 1;
	int _month = 1;
	int _day = 1;

我们之前学习过：C++11中支持给缺省值，其实这个缺省值是给初始化列表用的。如果初始化列表没有显示的给值，那么就会使用我们在变量的声明后的取值；如果我们显示的给值了，那么就不会用这个缺省值

class Date
{
public:
	Date(int year, int month, int day)
		: _year(year)
		, _month(month)
	{
		_day = day;
	}

	void Print()
	{
		cout << "year = " << _year << " month = " << _month << " day = " << _day << endl;
	}
private:
	int _year = 1;
	int _month = 1;
	int _day = 1;
};

int main(void)
{
	Date d1(2,2,2);
	d1.Print();
	return 0;
}

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

我们来通过一个题目来加深对于这一点的理解：

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 随机值

答案是D

为什么会出现这样的结果呢？我们试着分析一下：

因为在定义的时候是先定义_a2再定义_a1的，所以我们在初始化列表的时候要先初始化_a2再初始化_a1。因为_a2是用_a1的取值去初始化的，而此时_a1并没有初始化，因为对于内置类型编译器在默认情况下_a2会初始化为一个随机值，所以_a2的取值就是一个随机值；而_a1是正常初始化的，所以_a1给的就是1

所以为了避免这样的问题，我们最好保持声明的顺序和初始化列表的顺序一致

总结

我们在写代码的时候，能使用初始化列表的时候就尽量只使用初始化列表，只在一些特殊的场景下将初始化列表和函数体混合使用

我们在栈的代码中需要检查malloc空间是否成功，检查的代码就不能放在初始化列表中，此时就需要混合使用

	Stack(size_t capacity)
		:_array((DataType*)malloc(sizeof(DataType) * capacity))
		,_size(0)
		,_capacity(capacity)
	{
		if (NULL == _array)
		{
			perror("malloc申请空间失败!!!");
			return;
		}
	}

1.4 explicit关键字

在正式的开始之前先讲一个与这个内容相关的小常识

我们知道，不同类型的数据之间在赋值的时候是可以进行自动转换的

int main(void)
{
	double d = 1.1;
	int i = d;
	cout << i << endl;
	return 0;
}

这种转换的本质上中间会生成一个临时变量，然后d输入进这个临时变量，临时变量将结果输出到i中，这样就完成了类型的自动转换。

这个临时变量具有常性，我们可以写一串代码来验证：

int main(void)
{
	double d = 1.1;
	int& i = d;
	cout << i << endl;
	return 0;
}

在这串代码中我们可以知道 i 是不能直接引用 d 的，并不是类型不同的原因，这里和类型的不同没有关系。因为在赋值的时候会生成一个临时变量，临时变量具有常性，所以这里是权限的放大，当我们加上const就不会出现问题

int main(void)
{
	double d = 1.1;
	const int& i = d;
	cout << i << endl;
	return 0;
}

1.4.1.单参数构造函数的隐式类型转换

C++在初始化赋值的时候有两种方式

1.常规的初始化赋值操作

class A
{
public:
	A(int i)
		:_a(i)
	{}
private:
	int _a;
};
int main(void)
{
	A aa1(1);
}

这种初始化赋值的操作我们之前学习过，所以在这里就不做过多的讲解

2.单参数构造函数的隐式类型转换初始化赋值

class A
{
public:
	A(int i)
		:_a(i)
	{}
private:
	int _a;
};
int main(void)
{
	A aa1 = 1;
}

我们在开始的时候提到了这种初始化赋值的方式在本质上就是用 1 调用 A 构造函数生成一个临时对象，再用这个对象去拷贝构造 aa2 。但是编译器一般会进行优化，优化为用2直接构造。我们可以用代码来直观的验证这一点：

class A
{
public:
	A(int i)
		:_a(i)
	{
		cout << "构造函数" << endl;
	}
	A(const A& aa)
		:_a(aa._a)
	{
		cout << "拷贝构造函数" << endl;
	}
private:
	int _a;
};
int main(void)
{
	A aa1 = 1;
}

此时我们可能会认为这种初始化方法的存在并没有什么意义，其实不是这样的

我们用之前顺序表的代码为例，假设 DataType 的类型不是 int 而是我们上面所说的 A 

如果 A 对象很大，那么我们通常采用传引用而不是直接传参，此时参数 int data 就会被我们修改为const A& data

当我们要尾插一个数据的时候，如果采用的是常规的初始化赋值方法，我们写代码的时候就会是如下的形式

Seqlist s;
A aa1(3);
s.PushBack(aa1);

这样写就会比较麻烦，如果采用单参数构造函数的隐式类型转换初始化赋值，就可以直接这样写：

Seqlist s;
s.PushBack(3);

这样就能简化代码，让代码更加精简

这种赋值方法只适用于单参数，那么如果是多参数呢？

C++11（C++98不支持）中支持多参数类型的函数的隐式类型转换，它的写法如下：

class B
{
public:
	B(int i, int j)
		:_b1(i)
		,_b2(j)
	{}
	void Print()
	{
		cout << "_b1 = " << _b1 << "   _b2 = " << _b2 << endl;
	}
private:
	int _b1;
	int _b2;
};
int main(void)
{
	B bb1(0, 0);
	bb1.Print();
	return 0;
}

                                                                使用 { } 也可以

int main(void)
{
	B bb1{ 0, 0 };
	bb1.Print();
	return 0;
}

1.4.2. explicit关键字

如果我们不想让上述代码中的隐式类型转换发生，此时我们就可以在构造函数前加上关键字explicit

class A
{
public:
	explicit A(int i)
		:_a(i)
	{
		cout << "构造函数" << endl;
	}
	A(const A& aa)
		:_a(aa._a)
	{
		cout << "拷贝构造函数" << endl;
	}
private:
	int _a;
};

1.5匿名对象

C++中是支持创建匿名对象的：

class A
{
public:
	A(int i)
		:_a(i)
	{
		cout << "构造函数" << endl;
	}
	A(const A& aa)
		:_a(aa._a)
	{
		cout << "拷贝构造函数" << endl;
	}
	~A()
	{
		cout << "析构函数" << endl;
	}
private:
	int _a;
};
//
int main(void)
{
	A aa1(0);//有名对象
	A(1);//匿名对象
	return 0;
}

有名对象的特点：生命周期在当前局部域

匿名对象的特点：生命周期在当前一行

匿名对象通常有两种使用场景：

1.用匿名对象来赋值

如果我们不使用隐式类型转换，我们在初始化赋值的时候就需要先定义一个有名的对象再进行传参，这样就需要写两行代码。此时我们可以用匿名对象来简化代码，这样就只需要写一行代码：

s.PushBack(A(8));

2.调用函数

假设我们定义一个对象的目的就是为了调用对象中的某一个函数（如打印），不需要采取赋值等操作，此时我们就可以使用匿名对象

总而言之：匿名对象并没有什么核心用法，主要是用来简化代码的

2. static成员

2.1 静态成员变量

假设我们想要统计一个名为 A 的类创建了多少个对象，并且用n来统计累计创建了多少个对象、用m来统计正在使用的还有多少个对象，我们通常可以采用下面的代码：

int n = 0;
int m = 0;
class A
{
public:
    A()
    {
        ++n;
        ++m;
    }
    A(const A& t)
    {
        ++n;
        ++m;
    }
    ~A()
    {
        --m;
    }
private:
};

我们现在来测试一下这串代码：

A Func(A aa)
{
    return aa;
}

int main(void)
{
    A aa1;
    A aa2;
    cout << n << " " << m << endl;
   
    A();
    cout << n << " " << m << endl;

    Func(aa1);
    cout << n << " " << m << endl;

    return 0;
}

出现 3 2 的原因是因为匿名对象的生命周期只在那一行，所以创建对象的次数会增加一次；

出现 5 2 的原因是因为 aa1 传给函数 Func 的时候需要执行一次拷贝构造，传值返回又需要拷贝一次，所以创建对象的次数会增加两次；若是我们采取引用返回就会少创建一次；若是采取引用传参+引用返回就会少创建两次

A& Func(A aa)

A& Func(A& aa)

但这样的写法存在一定的缺陷，C++的设计讲究封装性，假设我们在外部对m、n进行处理，这样就会对所有的结果产生影响：

int main(void)
{
    A aa1;
    A aa2;
    cout << n << " " << m << endl;
    
    ++m;
    ++n;

    A();
    cout << n << " " << m << endl;

    Func(aa1);
    cout << n << " " << m << endl;

    return 0;
}

此时我们有什么方法可以限制它们不被修改吗？如果我们把m、n直接设置为私有成员是不能的，这样做的话每个对象都有它自己的m和n，就无法统计所有对象创建对象的次数。

此时我们就需要用到static，加上static的私有变量就不会只属于某一个对象，而是属于所有对象

    static int n;
    static int m;

我们需要注意：此时的私有变量是不能够给缺省值的。因为缺省值是给初始化列表阶段使用的，而被 static 修饰过的变量是一个静态的成员，是不会走初始化列表的，所以此时不能给缺省值：

我们来思考一个问题：此时的 sizeof(A)  应该是什么？

答案是：1，此时的类 A 相当于一个空类。因为 m 和 n 被 static 修饰以后变成了一个静态的成员，静态的成员存储的位置在静态区

此时我们对于类的声明已经处理完了，现在我们就要定义这一个类了，定义方法如下：

int A::n = 0;
int A::m = 0;

此时我们就不能随意的修改m和n了：

因为static成员既属于每个类，又属于每一个对象，所以我们就可以用两种形式来访问它（m和n此时必须是公有成员）：

    cout << A::n << " " << A::m << endl;
    cout << aa1.n << " " << aa2.m << endl;

因为static修饰后的对象是一个静态的对象，所以当我们以下面的形式访问m和n的时候也不会有问题：

    A* ptr = nullptr;
    cout << ptr->n << " " << ptr->m << endl;

如果m和n是私有成员，那么以上的操作都会报错：

那么在m和n是私有成员的条件下，我们怎么样才能对m和n进行操作呢？

此时只需要在类中写两个公有的函数来获取m和n就可以了

class A
{
public:
    A()
    {
        ++n;
        ++m;
    }
    A(const A& t)
    {
        ++n;
        ++m;
    }
    ~A()
    {
        --m;
    }
    int GetN()
    {
        return n;
    }
    int GetM()
    {
        return m;
    }
    void Print()
    {
        cout << m << " " << n << endl;
    }
private:
    static int n;
    static int m;
};

2.2 静态成员函数

假设我们此时要在匿名对象处打印出m和n的值，那么此时我们会发现问题：我们不知道如何去打印。

如果对于一个正常创建的对象，我们可以很容易的打印m和n的取值：

    A aa1;
    Func(aa1);
    aa1.Print();

假设我们要在创建两次匿名对象后打印m和n的取值：

    A();
    A();

我们可能会想到运用匿名对象的成员函数调用来完成打印，如下所示：

    A();
    A();
    A().Print();

但是这种方法是不可行的，因为此时我们多创建了一个对象，此时就会对m和n的取值产生干扰

有人也可能会想到用下面这种方法来访问：

    A::Print();

但是编译器是不支持这种语法的，我们需要用一个对象去调用成员函数，因为成员函数隐藏了this指针的参数，我们需要去传this指针

为了解决这个问题，C++中有了静态成员函数的概念，此时只需要在函数前加上一个 static 就行了

    static void Print()
    {
        cout << m << " " << n << endl;
    }

我们需要留意一下静态成员函数的特点：静态成员函数没有this指针

因为静态成员函数没有this指针，所以可以直接采用刚才的写法

    A::Print();

我们来思考一下静态成员函数有什么限制？

假设我们在类中创建了一个非静态的成员变量，那么静态成员函数内部就无法访问这个成员变量，因为没有 this 指针

    static void Print()
    {
        x++;
        cout << m << " " << n << endl;
    }
private:
    static int n;
    static int m;
    int x;

2.3 有关static成员的笔试题

我们来通过一个题目来看一下静态成员的意义（来自牛客网）：

根据题目的要求，我们不能使用：

1.公式（乘除法、位运算）

2.循环（不能使用 for、while 关键字）

3.递归（递归必须要写返回条件）

因为有了这些限制，常规的方法肯定是不能使用的，此时我们来思考一下在不是用常规方法的情况下怎么完成题目所给的任务

再开始写代码之前，我们先要了解牛客网的编译器是GCC，是可以支持变长数组的语法的，我们可以尝试运用变长数组的语法来解题

1.首先我们需要想一个办法来进行 n 次处理，我们可以在 Solution 外面额外写一个名叫 Sum 的类并且写出Sum类中的构造函数。定义几个对象就会调用几次构造函数，所以我们可以定义一个用来存放对象的数组，数组中对象的个数为n，因为牛客网的编译器是支持变长数组的，我们可以通过在Solution内写 Sum a[n] 代码，来实现调用n次构造函数

class Solution 
{
public:
    int Sum_Solution(int n) 
    {
        Sum a[n];
    }
};

2.因为我们定义了n次构造函数，因为我们需要访问同一个变量，所以这个变量应该是全局的，如果我们直接在全局中定义变量，那么此时的变量就不会受到限制，可以被任意修改。为了满足全局的目的又要确保它的限制性，我们可以在Sum中定义两个私有的静态成员变量。其中一个变量用于表示当前操作数，另外一个变量用来储存运算结果

class Sum
{
public:
    Sum()
    {

    }
private:
    static int _i;
    static int _ret;
};

int Sum::_i = 1;
int Sum::_ret = 0;

3.当我们定义完这两个变量以后就很简单了，因为静态成员变量是属于所有同类对象的，我们现在只需要像下面的代码一样处理构造函数就能够完成任务了

class Sum
{
public:
    Sum()
    {
        _ret += _i;
        _i++;
    }
private:
    static int _i;
    static int _ret;
};

int Sum::_i = 1;
int Sum::_ret = 0;

4.我们此时在Sum类中定义一个静态公有成员函数GetRet，用来返回私有成员变量_ret，随后我们就能完成任务了：

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];
        return Sum::GetRet();
    }
};

我们来测试一下代码能否通过：

此时我们来思考一个问题：直接把m设置为公有成员和使用GetM函数有什么区别？

把m设置成公有成员是既可以读又可以写的，此时m可以在外界修改；而使用GetM函数时只能读不能写的，此时m不可以在外界被修改

3. 友元

3.1 友元函数

为了引入友元函数的概念，我们还是以之前所学习的日期类的代码为例：

class Date
{
public:
    Date(int year, int month, int day)
        : _year(year)
        , _month(month)
        , _day(day)
    {}
private:
    int _year;
    int _month;
    int _day;
};

int main(void)
{
    Date d1(2024, 5, 30);
    cout << d1;
    return 0;
}

假设我们像上述代码一样，不在类的里面写打印函数而在主函数中直接用cout打印d1，这样的情况是不被允许的

但是我们知道类中的内置类型的公有成员变量是支持这样打印的。

这是因为库的支持，我们此时就对库进行进一步的了解：

我们在平时用的cout函数是一个ostream的对象，而cin函数是一个istream类型的对象。内置类型可以直接使用 cout<< 来打印到屏幕上的原因是：ostream对象把内置类型作为它的成员函数全部重载了

当遇到不同类型的内置类型变量，他就会自动调用对应类型的重载函数。其实这本质上是一个函数重载加运算符重载的过程

而对于我们刚才所说的自定义类型而言，如果我们也想实现自定义类型的重载，我们是不能直接去ostream里面自己添加代码来重载运算符的，因为ostream已经被定义好了。

我们是不能修改ostream类的，我们此时就应该修改自己的Date类。因为运算符并没有规定必须要写成谁的成员函数或者谁的全局函数，只要我们满足调用的需求就行了，所以写成全局函数或者成员函数都可以被识别。

此时我们可以自己试着来写一下流插入<<的代码：

    void operator<<(ostream& out)
    {
        out << _year << "/" << _month << "/" << _day << endl;
    }

但当我们调用的时候，我们发现好像出现了问题：

我们此时仔细观察一下，其实operator<<的参数顺序是有问题的。 << 是一个双操作数，它的左操作数是cout，它是一个ostream类型的对象；他的右操作数是d1，d1是一个Date类型的对象。

所以operator<<的第一个参数应该是ostream类型的对象，第二个参数应该是Date类型的对象

而我们所写的operator<<的第一个参数是隐藏的this指针，第二个参数是ostream类型的对象，此时的顺序刚好相反。因为this指针的顺序是固定在第一位的，如果我们想要完成调用，我们必须把操作数的顺序颠倒过来：

int main(void)
{
    Date d1(2024, 5, 30);
    d1 << cout;
    return 0;
}

但是流插入的本质是对象流入到控制台中，但是按照刚才的写法的意思是控制台流入对象中，此时代码的意思就与流插入概念相违背了。虽然这个代码可以完成任务，但是它不符合我们的使用习惯和价值，所以我们需要对代码进行改进

因为我们要让顺序颠倒过来，所以此时operator<<就不能是一个成员函数，因为成员函数的第一个参数永远是this指针。我们要把operator<<写成一个全局的函数

当我们在写成全局函数的的时候遇到的最大的问题就是_year、_month、_day三个变量如果是私有变量的话就会被限制访问

我们此时有两种方法可以解决这个问题：

1.使用GetYear、GetMonth、GetDay函数

2.定义为一个友元函数

友元函数可以直接访问类的私有成员，它是定义在类外部的普通函数，不属于任何类，但需要在类的内部声明，声明时需要加friend关键字，友元声明可以声明在类中的任意一个位置

class Date
{
    friend void operator<<(ostream& out, const Date& d);
public:
    Date(int year, int month, int day)
        : _year(year)
        , _month(month)
        , _day(day)
    {}
    
private:
    int _year;
    int _month;
    int _day;
};
void operator<<(ostream& out,const Date& d)
    {
    out << d._year << "/" << d._month << "/" << d._day << endl;
    return out;
    }

int main(void)
{
    Date d1(2024, 5, 30);
    cout << d1;
    return 0;
}

此时就符合需求，能够成功打印了

当我们解决了这一个问题了以后我们又发现了新的问题：假设我们这样写代码，编译仍然不通过：

int main(void)
{
    Date d1(2024, 5, 30);
    Date d2(2024, 5, 31);
    cout << d1 << d2;
    return 0;
}

因为此时代码执行的顺序是从左往右执行的，所以这串代码率先执行cout << d1代码，而执行完这一串代码的返回类型是void，所以不能继续向下执行了，此时我们应该修改一下返回值的类型：

ostream& operator<<(ostream& out,const Date& d)
    {
    out << d._year << "/" << d._month << "/" << d._day << endl;
    return out;
    }

此时就可以顺利完成任务了

我们解决完流插入cout的代码了，对于流提取cin的代码我们也可以较为轻松的完成：

istream& operator>>(istream& in, Date& d)
    {
    in >> d._year >> d._month >> d._day;
    return in;
    }

3.1.2友元函数的注意事项

对于友元函数我们需要注意以下几点： 

1.友元函数可访问类的私有和保护成员，但不是类的成员函数

2.友元函数不能用const修饰

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

4.一个函数可以是多个类的友元函数

5.友元函数的调用与普通函数的调用原理相同

3.2 友元类

假设我们定义了两个类，其中一个类叫做Date，另外一个类叫做Time。假设我们需要经常在Date里面访问Time的私有成员，若此每次使用Time中的私有成员时都去设置友元函数的话就会比较麻烦，此时我们就可以把Date定义为Time的友元类：

class Time
{
	friend class Date;
		// 声明日期类为时间类的友元类，则在日期类中就直接访问Time类中的私有成员变量
public:
    Time(int hour = 0, int minute = 0, int second = 0)
        : _hour(hour)
        , _minute(minute)
        , _second(second)
    {}

private:
    int _hour;
    int _minute;
    int _second;
};

class Date
{
public:
    Date(int year = 1900, int month = 1, int day = 1)
        : _year(year)
        , _month(month)
        , _day(day)
    {}

    void SetTimeOfDate(int hour, int minute, int second)
    {
        // 直接访问时间类私有的成员变量
        _t._hour = hour;
        _t._minute = minute;
        _t._second = second;
    }

private:
    int _year;
    int _month;
    int _day;
    Time _t;
};

通过这样的操作，Date类中就可以任意访问Time的私有成员了。

在使用友元类的时候我们要注意：

1.友元关系是单向的，不具有交换性

Time类此时还是不能访问Date类的私有成员，因为Time并不是Date类的友元类

2.友元关系不能传递

如果B是A的友元，C是B的友元，则不能说明C时A的友元

3.友元关系不能继承

这一点在后面的内容中会提到

4. 内部类

概念：如果一个类定义在另一个类的内部，这个内部类就叫做内部类。内部类是一个独立的类，它不属于外部类，更不能通过外部类的对象去访问内部类的成员。外部类对内部类没有任何优越的访问权限

我们来举一个简单的例子：

class A
{
public:
	class B
	{
	private:
		int _b;
	};
private:
	int _a;
};

我们先来思考一个问题：sizeof(A)是多大？

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

通过打印出来的结果我们可以知道 sizeof(A) 的大小是4

其实如下两个代码所呈现出来的效果是一样的：

class A
{
public:
	class B
	{
	private:
		int _b;
	};
private:
	int _a;
};

class B
{
private:
	int _b;
};

class A
{
public:

private:
	int _a;
};

只是写成内部类的形式下B类受到A类域和访问限制符的限制，但本质上它们仍然是两个独立的类

所以我们创建一个A对象，该对象中并不存在B

写成内部类的形式我们可以定义A对象，但是不能定义B对象：

此时就要以下面这种形式来定义B对象（指定类域）：

int main(void)
{
	A aa;
	A::B bb;
	return 0;
}

假设在A类中的私有空间定义B类，此时就算指定了类域仍然无法定义B类：

class A
{
private:
	class B
	{
	private:
		int _b;
	};
	int _a;
};

如果在私有的情况下我们仍然需要定义B类，那么此时我们就只有一种方法——在A类中写一个成员函数来定义类：

class A
{
private:
	void func()
	{
		B bb;
	}
	class B
	{
	private:
		int _b;
	};
	int _a;
};

注意：内部类是外部类的友元类，参见友元类的定义，内部类可以通过外部类的对象参数来访问外部类中的所有成员。但是外部类不是内部类的友元

class A
{
private:
	class B
	{
	public:
		void FuncB()
		{
			A aa;
			aa._a = 0;
		}
	private:
		int _b;
	};
	int _a;
};

有了内部类的知识，2.3中的笔试题代码就可以有另外一种写法：

class Solution
{
public:
    class Sum
    {
    public:
        Sum()
        {
            _ret += _i;
            _i++;
        }

    };
    int Sum_Solution(int n)
    {
        Sum a[n];
        return _ret;
    }
private:
    static int _i;
    static int _ret;
};

int Solution::_i = 1;
int Solution::_ret = 0;

这样设计代码不仅可以使代码更加简洁，还能让代码更加安全（限制外部访问类Sum）

5.结尾

有关类和对象的所有内容到这里就结束了，我们下一节将会学习到动态内存管理，希望能给您带来帮助，谢谢您的浏览！！！