【初阶与进阶C++详解】第五篇：类和对象下（构造+static+友元+内部类）

🏆个人主页：企鹅不叫的博客

​ 🌈专栏

• C语言初阶和进阶
• C项目
• Leetcode刷题
• 初阶数据结构与算法
• C++初阶和进阶
• 《深入理解计算机操作系统》
• 《高质量C/C++编程》
• Linux

⭐️ 博主码云gitee链接：代码仓库地址

⚡若有帮助可以【关注+点赞+收藏】，大家一起进步！

💙系列文章💙

---

【初阶与进阶C++详解】第一篇：C++入门知识必备

【初阶与进阶C++详解】第二篇：C&&C++互相调用（创建静态库）并保护加密源文件

【初阶与进阶C++详解】第三篇：类和对象上（类和this指针）

【初阶与进阶C++详解】第四篇：类和对象中（类的六个默认成员函数）

---

---

💎一、构造函数补充

🏆1.1构造函数体赋值

下面函数虽然有初始化变量，但是不能将其称作为类对象成员的初始化 ，构造函数体中的语句只能将其称作为赋初值，而不能称作初始化 ，初始化只能初始化一次，而构造函数体内可以多次赋值 。

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

🏆1.2初始化列表

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

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

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

2.类中包含以下成员，必须放在初始化列表位置进行初始化

​ 引用成员变量

​ const成员变量

​ 自定义类型成员(该类没有默认构造函数)

class A
{
public:
	A(int a)
		:_a(a)
	{}
private:
	int _a;
};
class B
{
public:
	B(int a, int ref, int n)
		:_aa(a)
		,_ret(ref)
		,_n(n)
{}
private:
	A _aa; // 没有默认构造函数
	int& _ret; 
	const int _n; 
};

下面size是声明，后面给0也是为了初始化列表，但是初始化列表给了-1，但是size是无符号的4294967295

class Stack
{
public:
	Stack(int capacity = 0)
	{
		_a = (int*)malloc(sizeof(int)*capacity);
		assert(_a);
		_top = 0;
		_capacity = capacity;
	}
private:
	int* _a;
	int _top;
	int _capacity;
};

class MyQueue
{
public:
	MyQueue(int size = -1)
		:_size(size)
	{}

	/*MyQueue(const MyQueue& q)
	{}*/
private:
	Stack _st1;
	Stack _st2;
	size_t _size = 0; // 缺省值
};

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

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

总结：其他变量既可以在初始化列表初始化，又可以在函数体内初始化，尽量在 初始化列表初始化。

🏆1.3 explicit关键字

下两种方式都是直接调用构造函数，构造函数不仅可以构造与初始化对象，对于单个参数的构造函数，还具有类型转换的作用

class Date{
public:
 Date(int year){}
 Dtae(const Date& d){}
};

Date d1(2022);//直接调用构造函数
Date d2 = 2022;//直接调用构造函数，不会调用拷贝构造，发生 隐式类型转换 ，中间生成临时变量(有常性)，临时变量给将存储的2022给d2，具有常性
const Date& d3 = 2022;//2022给d3的时候会产生临时变量，临时变量具有常性，不可改变

为了避免发生类型转换我们用下面这种方法

explicit修饰函数，可以禁止单构造函数发生隐式类型转换

class Date{
public:
 explitic Date(int year){}
 Dtae(const Date& d){}
};

💎二、static

🏆2.1概念

用static修饰的成员变量，称之为静态成员变量；用static修饰的成员函数，称之为静态成员函数，静态成员变量属于整个类(声明的时候不占空间)，属于类的所有对象，不属于任何一个对象，所以不在任何一个函数初始化，静态的成员变量一定要在类外进行初始化（除了const类型） ，成员函数也可以是静态的，static成员函数没有this指针，也就不能访问非静态成员。

class A{
public:
 A()
 {
     ++_count1;
 }
 //静态成员函数
 static int GetCount(){
     //_a = 0;//不可以访问，没有this指针
     return count;
 }
private:
	static int _count;//在类里面是声明，其他函数定义部分在构造函数，静态变量没有。
 int _a;
};

//在类外面定义
int A::_count = 0;

A a1;
//访问方式
cout << a1._count << endl;//直接访问某个对象
cout << A::_count << endl;//指定类域去访问
cout << a1.GetCount << endl;//静态成员函数
cout << A::GetCount1() << endl;//指定类域去访问

🏆2.2特性

1. 静态成员为所有类对象所共享，每个类访问到的都是同一个变量，不属于某个具体的实例，声明的时候不占类的内存，注意计算类的大小时不算static。
2. 静态成员变量必须在类外定义，定义时不添加static关键字
3. 类静态成员即可用类名::静态成员或者对象.静态成员来访问
4. 静态成员函数没有隐藏的this指针，不能访问任何非静态成员
5. 静态成员和类的普通成员一样，也有public、protected、private3种访问级别，也可以具有返回值
6. 静态成员函数不可以调用非静态成员函数，没有this指针
7. 公有的静态成员函数,可以通过类名或对象名来调用.而一般的非静态成员函数只能通过类名来调用，所有类共享

💎三、友元

🏆4.1友元函数

分为友元函数和友元类（一个类访问另一个类的私有成员变量），突破封装，在类外面也可以访问私有，定义在类外面的普通函数，在类里面声明时需要加上freiend关键字，增加耦合度，建议少用

class Date
{
	friend ostream& operator<<(ostream& _cout, const Date& d);
	friend istream& operator>>(istream& _cin, Date& d);
public:
	Date(int year, int month, int day)
		: _year(year)
		, _month(month)
		, _day(day)
	{}
private:
	int _year;
	int _month;
	int _day；
};
ostream& operator<<(ostream& _cout, const Date& d)
{
	_cout<<d._year<<"-"<<d._month<<"-"<<d._day;
	return _cout;
}
istream& operator>>(istream& _cin, Date& d)
{
	_cin>>d._year;
	_cin>>d._month;
	_cin>>d._day;
	return _cin;
}

友元函数可访问类的私有和保护成员，但不是类的成员函数，相当于全局函数
友元函数不能用const修饰,(不能修饰this指针指向的对象)
友元函数可以在类定义的任何地方声明，不受类访问限定符限制，一般写在public前面，友元函数不具备this指针
一个函数可以是多个类的友元函数，调用多个类的友元函数时，注意类的前置声明

class Date;

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

友元关系不能传递，C和B是友元，B是A的友元，但是C和A不是友元关系

🏆4.2友元类

友元类的所有成员函数都可以是另一个类的友元函数，都可以访问另一个类中的非公有成员

友元关系是单向的，不具有交换性。
比如上述Time类和Date类，在Time类中声明Date类为其友元类，那么可以在Date类中直接访问Time类的私有成员变量，但想在Time类中访问Date类中私有的成员变量则不行。

例如下述代码中，B是A的友元，所以在B类中可以直接访问A类的私有成员变量，但是在A类中不能访问B类中的私有成员变量

class A
{
	// 声明B是A的友元类
	friend class B;
public:
	A(int n = 0)
		:_n(n)
	{}
private:
	int _n;
};
class B
{
public:
	void Test(A& a)
	{
		// B类可以直接访问A类中的私有成员变量
		cout << a._n << endl;
	}
};

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

💎四、内部类

在A的类里面定义一个B，内部类就是外部类的友元类。注意友元类的定义，内部类可以通过外部类的对象参数来访问外部类中
的所有成员，但是外部类不是内部类的友元 ，B可以访问A，A不可以访问B

内部类可以定义在外部类的public、protected、private都是可以的。
注意内部类可以直接访问外部类中的static、枚举成员，不需要外部类的对象/类名。
sizeof(外部类)=外部类，和内部类没有任何关系

💎五、练习

剑指 Offer 64. 求1+2+…+n

思路：

利用static将数组a[n]调用n次，最后返回最后一个即为所求。

class sum{
public:
 sum(){
     _sum += _i;
     ++_i;
 }
 static int Getcount(){
     return _sum;
 }
private:
 static int _i;
 static int _sum;
};

int sum::_i = 1;
int sum::_sum = 0;

class Solution {
public:
 int sumNums(int n) {
     //调用n次构造函数
     sum a[n];
     return sum::Getcount();
 }
};

---