🌈欢迎来到C++专栏 ~~ 类和对象（下）

---

• (꒪ꇴ꒪(꒪ꇴ꒪ )🐣,我是Scort🎓
• 🌍博客主页：张小姐的猫~江湖背景
• 快上车🚘，握好方向盘跟我有一起打天下嘞！
• 送给自己的一句鸡汤🤔：
• 🔥真正的大师永远怀着一颗学徒的心
• 作者水平很有限，如果发现错误，可在评论区指正，感谢🙏
• 🎉🎉欢迎持续关注！
  

一、再谈构造函数

🎨构造函数体赋值

以前构造函数，我们是在函数体内赋值的

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

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

在函数体内初始化相当于先初始化再赋值

但对于像const成员变量，必须在定义的时候同时初始化，如果在函数体内初始化就会报错 ——

为此我们引入了初始化列表，就是给成员变量找到一个依次定义处理的地方

🎨初始化列表

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

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()
{
	Date d1(2022, 2, 22); 
	return 0;
}

【注意】
每个成员变量在初始化列表中只能出现一次(初始化只能初始化一次)

🔥 1.类中包含以下成员，必须放在初始化列表进行初始化。注意，初始化列表就是成员变量定义的地方！理解的关键

• const成员变量

  因为const成员变量必须在定义的时候同时初始化

• 引用成员变量

  引用必须在定义的时候初始化，因为初始化列表就是成员变量定义的地方

举例：

class Date
{
public:
	Date(int year, int month, int x)
		: _N(10)
		, _ref(x)
	{
		_year = year;
		_ref++;
	}
private :
	const int _N;//声明
	int& _ref;

	int _year;
	int _month;
	int _day;
};

int main()
{
	int x = 0;
	Date d1(2022, 2, x);
	return 0;
}

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

没有默认构造函数，编译器调不动，需要在定义的时候自己显式的传参去调

• 哪什么情况下没有？比如我们自己写了一个构造函数，还是带参的，编译器不再自动生成的 —— 举例如下

class Time
{
public: 
    Time(int hour)
    {
        _hour = hour;
    }
private:
	int _hour;
};
class Date
{
public: 
    //要初始化_t 对象，只能通过初始化列表
    Date(int year, int hour)
	    :_t(hour)
    {
       _year =year;
    }
private: 
    int _year;
    Time _t;
};

int main()
{
    Date d(2022,1)
    return 0;
}

牢记！！！！很重要
ps：所有成员都会在初始化列表进行初始化，在进入花括号{}之前都会先去调用初始化列表

• 初始化列表：成员变量定义的地方
• main函数里：对象整体定义的地方
• 私有域：成员变量声明的地方

🔥 2.尽量使用初始化列表初始化，提高效率。对于自定义类型变量，一定会先使用初始化列表初始化

举例来说明：

class Time
{
public:
    Time(int hour = 0)
    {
        _hour = hour;
    }
private:
    int _hour;
};
class Date
{
public:
    //要初始化_t 对象，只能通过初始化列表
    //Date(int year, int hour)
    //    :_t(hour)
    //{
    //    _year = year;
    //}

    //在函数体内赋值，但是还是会先走初始化列表调用Time的默认构造，不健康
    Date(int year, int hour)
    {
        _year = year;
        Time t(hour);
        _t = t;
    }
private:
    int _year;
    Time _t;
};

int main()
{
    Date d(2022, 1);
    return 0;
}

• 先调用了初始化列表去构造、再对Time构造Time t(hour)、再赋值_t = t —— 不高效

💚总结：内置类型成员，在函数体和在初始化列表初始化都可以；自定义类型的成员，建议在初始化列表初始化，这样更高效

🔥彩蛋：C++11为了在构造时候对内置类型不处理的情况打了补丁，即在声明的时候赋予了缺省值

缺省值最终给到了初始化列表

🔥 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, 运行结果如下

建议：变量声明顺序和初始化列表出现顺序一致，即可不出错

🎨explicit关键字

为什么一个整型能转换为日期类？

#include<iostream>
using namespace std;

class Date
{
public:
	Date(int year)
		:_year(year)
	{
		cout << "Date(int year)" << endl;
	}

	Date(const Date& dd)
	{
		_year = dd._year;
		cout << "Date(const Date& year)" << endl;
	}
private:
	int _year;

};

int main()
{
	Date d1(2002);//直接调用构造
	Date d2 = 2022;//思考？  隐式类型转化：构造 + 拷贝构造 + 优化 》直接调用构造
	return 0;
}

这其实是因为单参数的构造函数中发生了隐式类型转换

回忆之前的

	// 隐式类型转换 - 相近类型 
	double d = 1.1;
	int i = d;
	const int& i = d; 

忘记的可以去看看，点这里跳转：C++入门 里面有讲解

这里本来是用2022构造一个临时对象Date（2022）但是C++在连续的过程中，编译器会优化多个构造，合二为一，因此这里被优化为直接就是一个构造

相当于以下两句——

Date tmp(2022); //先构造
Date d2(tmp);	//再拷贝构造

但是这样的可读性就会大大降低，用explicit修饰构造函数，将会禁止单参构造函数的隐式转换 ——

💚匿名对象

Date(2022,10,26); //匿名对象————声明周期只有这一行

Solution slt;
slt.Sum_Solution(10);//有名对象调用，专门开辟了slt来调用

//匿名对象调用
Solution().Sum_Solution(10);//节省空间

二、static成员

🌍静态成员变量

声明为static的类成员称为类的静态成员，用static修饰的成员变量，称之为静态成员变量；用static修饰的成员函数，称之为静态成员函数

面试题：实现一个类，计算程序中创建出了多少个类对象

思路：如果我们要对同一个变量进行++，唯一想到的就是定义一个全局变量，但是这样如果有两个类共用一个count会有累加效应，且暴露在外面可能被人随意更改

这时候就要引入static成员

特性：

1. 静态成员为所有类对象所共享，不属于某个具体的对象，存放在静态区
2. 静态成员变量必须在类外定义，定义时不添加static关键字，类中只是声明
3. 类静态成员即可用 类名::静态成员 或者 对象.静态成员 来访问
4. 静态成员函数没有隐藏的this指针，不能访问任何非静态成员
5. 静态成员也是类的成员，受public、protected、private 访问限定符的限制

作为私有成员，怎么样在类外访问呢？只能提供一个公用的成员函数getCount。代码如下 ——

我们可以通过对象来访问成员函数getCount

#include<iostream>
using namespace std;

class A
{
public:
	A(int a = 0)
		: _a(a)
	{
		_scount++;
	}
    
	A(const A& aa)
		: _a(aa._a)
	{
		_scount++;
	}
    
	int getCount()
	{
		return _scount;
	}
private:
	int _a;
	static int _scount; //静态成员变量
};

int A::_scount = 0;	//静态成员变量必须在类外的全局定义

int main()
{
	A a1;
	A a2;
	A a3(a2);
	cout << a1.getCount() << endl; //通过对象来访问成员函数
	return 0;
}

那么有没有更好的方式，不需要定义对象就可以获取到呢？这要引入我们的静态成员函数

🌍静态成员函数

❤️ 静态成员函数没有隐藏的this指针，只能访问静态成员变量和函数。不能访问任何非静态成员

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

	A(const A& aa)
		:_a(aa._a)
	{
		_scount++;
	}
	//静态成员函数  -- 没有this指针，不能访问非静态的成员
	static int GetCount()
	{
		return _scount;
	}
private:
	int _a;
	//静态成员变量，属于整个类，存在于静态区，生命周期在整个程序运行期间
	static int _scount;
};

int A::_scount = 0;

int main()
{
	A a1;
	A a2;
	A a3(a2);

	cout << A::GetCount() << endl;//可以通过类域来找 —— 突破类域
	cout << a1.GetCount() << endl;//也可以通过对象来找
}

【问题】:

1. 静态成员函数可以调用非静态成员函数吗？ 不行❌，没有this
2. 非静态成员函数可以调用类的静态成员函数吗？ 可以，属于整个类

三.、友元

友元提供了一种突破封装的方式，有时提供了便利。但是友元就像会增加耦合度，破坏了封装，所以友元不宜多用。

查阅 Reference可知，cout和cin对于内置类型之所以能“自动识别类型”，是因为库里面已经把函数重载都写好了

运算符重载：让自定义类型对象可以用运算符，转换成调用这个重载函数
函数重载：支持函数名相同的函数同时存在
二者没有必然联系，好比张伟和大张伟不是同一个人一样

我想让Date类这样的自定义类型，怎么样像内置类型一样，直接使用流提取、流插入打印呢？

 Date d1(2022,10,12);
 cout<<d1;
 cout<<(d1+100);

我们不能往库函数里再加一个函数，我们尝试在Date类中重载

这是因为运算符有多个操作数的时候，第一个参数为左操作数，第二个参数是右操作数，那么很明显谁才是第一位：d1.operator<<(cout) d1

跑是能跑起来，但是这样合适吗？因为cout的输出流对象和隐含的this指针在抢占第一个参数的位置。this指针默认是第一个参数也就是左操作数了。但是实际使用中cout需要是第一个形参对象，才能正常使用
于是我们把它挪到类外，将operator<<重载成全局函数，摆脱隐藏的this指针约束，但是又有类外无法访问成员的问题

注：这里为了支持连续输出，重载函数需要有返回值ostream&，原理类似于连续赋值，只不过cout的结合性是从左至右:
cout<< d1<< d2

这时候就要引入友元来解决问题了

🌈友元函数

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

• 友元函数可访问类的私有和保护成员，但不是类的成员函数
• 友元函数不能用const修饰
• 友元函数可以在类定义的任何地方声明，不受类访问限定符限制（但一般在开头）
• 一个函数可以是多个类的友元函数
• 友元函数的调用与普通函数的调用原理相同

#include<iostream>
using namespace std;

class Date
{
    //友元函数 -- 这个函数内部可以使用Date对象访问私有保护成员
	friend ostream& operator << (ostream& out, const Date& d);
	friend istream& operator>>(istream& in, Date& d);
public:
	Date(int year = 2022, int month = 1, int day = 1)
	{
		_year = year;
		_month = month;
		_day = day;
	}
private:
	int _year;
	int _month;
	int _day;
};

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

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

int main()
{
	Date d1(2022, 10, 26); 
	Date d2(2022, 10, 12); 
	cout << d1 << d2;
	cin >> d1 >> d2;
	return 0;
}

ps：流提取的时候，需要写入，右操作数不能用const来修饰

🌈友元类

友元类的所有成员函数都可以是另一个类的友元函数，都可以访问另一个类中的非公有成员(私有/保护)

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

  比如上述Time类和Date类，在Time类中声明Date类为其友元类，那么可以在Date类中直接访问Time类的私有成员变量，但想在Time类中访问Date类中私有的成员变量则不行

• 友元关系不能传递

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

#include<iostream>
using namespace std;

class Date; // 前置声明
class Time
{
	// 友元：声明Date为Time类的友元类，则在Date类中就直接访问Time类中的私有成员变量
	friend class Date; 
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;
};

四、内部类

C++用的少，java用的多。谐音累不累，我累了

🌈如果一个类定义在另一个类的内部，这个类就叫做内部类。内部类天生就是就是外部类的友元类
内部类可以通过外部类的对象参数来访问外部类中的所有成员。但是外部类不是内部类的友元

特性：

1. 内部类可以定义在外部类的public、protected、private都是可以的。
2. 注意内部类可以直接访问外部类中的static成员，不需要外部类的对象/类名。

class A {
private:
	static int k;
	int h = 0;

public:
	//B定义在A的里面
	// 1、受A的类域的限制，访问限定符
	// B天生是A的友元
	class B
	{
	public:
		void foo(const A& a)
		{
			cout << k << endl;	//可以访问外部类的static
			cout << a.h << endl;//可以访问外部类的private
		}
	private:
		int _b;
	};
};

int A::k = 1;

int main()
{
	A::B b; //只是受类域的限制
	b.foo(A());
	return 0;
}

sizeof(外部类) = 外部类 ，和内部类没有任何关系

	cout << sizeof(A) << endl;

五、练习（易错）

众所周知，编译器会优化代码 ——
先抛结论：连续一个表达式步骤中，连续构造一般会优化—— 合二为一

W f3()
{
	W ret;
	return ret;
 }

int main()
{
	f3();//1次构造  1次拷贝
	cout << endl << endl;

	W w1 = f3();//本来：1次构造  2次拷贝  ——》优化：1次构造  1次拷贝 
}

那这里是怎么样优化的呢？

那么为什么可以跳过tmp，直接返回呢？这就要涉及到栈桢

问：以下代码调用了__次构造？ __次拷贝构造？

W f(W u)
{
	W v(u);
	W w = v;
	return w;
}
main()
{
	W x;
	W y = f(f(x));
}

每层循环分开来看

这个图应该只有我能看懂了，所以优化完是7次的拷贝构造，不优化是：9次

六. 再次理解类和对象

现实生活中的实体计算机并不认识，计算机只认识二进制格式的数据。如果想要让计算机认识现实生活中的实体，用户必须通过某种面向对象的语言，对实体进行描述，然后通过编写程序，创建对象后计算机才可以认识

在类和对象阶段，大家一定要体会到，类是对某一类实体(对象)来进行描述的，描述该对象具有那些属性，那些方法，描述完成后就形成了一种新的自定义类型，才用该自定义类型就可以实例化具体的对象

📢写在最后

dwg从网吧队打到世界冠军，我要是他，我比他还狂，冠军也会落寞，也印证了失败才是人生的主旋律，成功只是偶尔，加油少年