C++ 类和对象（静态的static、友元、内部类、匿名对象、explicit）知识点+完整思维导图+实操图+深入细节通俗易懂建议收藏网站首页 其他

C++ 类和对象（静态的static、友元、内部类、匿名对象、explicit）知识点+完整思维导图+实操图+深入细节通俗易懂建议收藏

溟洵 2024-06-21 12:01:02

简介C++ 类和对象（静态的static、友元、内部类、匿名对象、explicit）知识点+完整思维导图+实操图+深入细节通俗易懂建议收藏

绪论

时间的步伐有三种：未来姗姗来迟，现在像箭一样飞逝，过往永远静立不动。本章是类和对象的一个收尾篇，相信通过这三篇类和对象的学习，应该你已经更加清楚了解了C++的类和对象。

话不多说安全带系好，发车啦（建议电脑观看）。

附：红色，部分为重点部分；蓝颜色为需要记忆的部分（不是死记硬背哈，多敲）；黑色加粗或者其余颜色为次重点；黑色为描述需要

思维导图：

要XMind思维导图的话可以私信哈

1.再谈构造函数

知识点：

前面我们已经学习过来构造函数，他是用来给对我们的成员进行初始化的。如：
	Date(int year = 1970, int month = 1, int day = 1)
	{
		_year = year;
		_month = month;
		_day = day;
	}
而因为在一些特殊的情况下，构造函数无法完成一些活动，所以不能只使用构造函数

因此C++又提出了一个新概念：

1.1初始化列表

知识点：

如像：引用、const变量（他们都是需要在定义的时候进行初始化，否则就无法正常的使用）、以及自定义类型（当没有默认构造函数的时）他们都不能直接通过构造函数来完成

在一个对象定义的时候其成员变量是在初始化列表中进行定义的

语法：

基本和构造函数差不多，在其中间插入初始化列表

Date(...)

        ：成员变量（初始值/变量）

        ,  成员变量（.....）

        ....

        ,成员变量（.....）

{

......

}

并且对于成员变量来说，其在c++11打的补丁，可以给成员缺省值，实际上就是把这个个缺省值给初始化列表
实例如下：
class B {
public:
	/*B()
	{
		_a = 1;
	}*/

	B(int a)
		:_a(a)
	{
		_a = a;
	}
private:
	int _a;
};

class A
{
public:
	A(int& a, int i)
		//而对于成员的初始化是在初始化列表处完成的
		:_a(a)
		, _i(1)
		,bb(10)//此时因为没有默认构造，所以我们只能去调用构造函数，所以需要我们使用初始化列表来进行传参
		,a()//内置类型
	{
	}
private:
	//对于引用和常变量来说他们必须在定义的时候进行初始化，否则就无法使用
	int& _a;
	const int _i;
	//而对于自定义结构来说，也是通过初始化列表来进行初始化的
	B bb;

	//内置类型的缺省值，其实就是给初始化列表的
	int a = 1;
};

int main()
{
	int n = 0;
	A(n,10);
	return 0;
}

细节：

对于初始化列表，当你不写时，操作系统也会默认的生成一个，并且肯定会走初始化列表过一下
对于构造函数来说，初始化列表固然很强能解决大部分初始化时的定义问题，但不能完全解决是有问题
对于自定义结构来说也是同理他会自动去通过初始化列表来进行调用自身的构造函数，但是如果是内置类型当不给缺省值/不在构造函数内赋值的话，他并不会自动的初始化
成员变量是通过声明的顺序进行初始化的和初始化列表的顺序无关
对于4来说，我们就建议声明的顺序和定义的顺序保持一致

练习：

通过初始化列表让没有默认构造的自定义类型可以进行初始化（此时有的是非默认构造的构造函数）。

1.2：explicit

在对于下面这种代码来说，是存在隐式类型转换的
A a = 3;

const A& a = 3;
并且在编译器下会把构造+构造这种在一行的多次构造的情况优化成只进行一次构造

假如是分开行就不行了

假如我们不想让其可以进行隐式类型转换的话，就可以在构造函数全面加上explicit

使用后就会标红

2.static

知识点：

概念：声明为static的类成员称为类的静态成员，用static修饰的成员变量，称之为静态成员变量；用static修饰的成员函数，称之为静态成员函数。静态成员变量一定要在类外进行初始化，此处他并不是每个类对象的成员变量，而是每个对象共享的一个变量

语法：在变量/函数前面加上static

初始化需要再类外面进行，具体如下：
class A
{
public:
	A(int a)//并且不能在构造中初始化
	{
	}
private:
	int _a;
	static int _b;//声明
};
int A::_b = 0;//初始化

int main()
{
	return 0;
}
不能在类内部定义

细节：

为了防止我们可以随意的更改_b , 所以一般会把_b放到私有里面。

此时就只能通过在类里面创建一个获取函数/创建友元函数来获取里面的_b了

对于获取函数来说，我们也一般习惯写成静态的，当把函数也写成静态的时候，此时这个函数时没有this指针的，就只能通过通类静态成员即可用类名::静态成员或者对象.静态成员来访问
。
	static int GetB()//一般我们会把这个定义成静态的函数，此时是没有this指针的，指定类域和访问限定符就能进行访问该函数
	{
		return _b;
	}

//访问：
	//cout << a.GetB() << endl;
    cout << A::GetB() << endl;
注意，因为在静态函数中没有this指针，所以不能去调用成员变量/成员函数，而在成员函数中却可以去调用静态的函数，如果一定需要去使用成员函数，则需要传进来，并且需要在参数部分接收

类静态成员即可用类名::静态成员或者对象.静态成员来访问
静态成员也是类的成员，受public、protected、private 访问限定符的限制

练习：

设计一个类，在类外面只能在栈上创建对象

设计一个类，在类外面只能在堆上创建对象

class A {
public:
	static A GetStack()
	{
		A a;
		return a;//返回创建的对象
	}
	static A* GetHeap()
	{
		return new A;//new一个空间给A
	}

private:
	A()
	{}

private:
	int _a = 0;
	int _b = 1;
};

int main()
{
	//此时没有别的办法就只能用静态函数
	//因为构造函数也属于私有的,所以我们不能直接定义一个对象
	A::GetStack();
	A::GetHeap();
	return 0;
}

3.友元

知识点：

友元提供了一种突破封装的方式，有时提供了便利。但是友元会增加耦合度（关联性），破坏了封装，所以友元不宜多用。
友元分为：友元函数和友元类

细节：

3.1友元函数

在前面的 operator <<、operator >> 处我们已经使用过了，是用来让函数可以使用一个类中的成员变量

语法：friend 函数声明

友元函数可以访问类的私有成员，它是定义在类外部的普通函数，不属于任何类，但需要在类的内部声明，声明时需要加friend关键字。
友元函数不能用const修饰（因为其没有this指针）
友元函数可以在类定义的任何地方声明，不受类访问限定符限制
一个函数可以是多个类的友元函数

3.2友元类

友元类的所有成员函数都可以是另一个类的友元函数，都可以访问另一个类中的非公有成员
（和友元函数一样，当我们在一个类中定义了另外一个友元的类对象，此时在另外的那个类中就能去使用声明的类中的成员变量）

具体写法：friend class 类名

练习使用：

class B {
friend class A;


private:
	int _b = 10;
};

class A {
public:

	A()
	{}

	void Print()
	{	
		//此时创建一个B类的对象就能去访问其类内的私有
		cout <<  _i._b << endl;
	}

private:
	int _a = 0;
	B _i;
};

int main()
{
	A a;
	a.Print();
	return 0;
}

4.内部类

知识点：

一个类定义在另一个类的内部，这个内部类就叫做内部类

细节：

内部类是外部类的友元类，所以说在内部类可以使用外部类的成员变量，但是外部类却不能使用内部类的成员变量，所以说我们可以直接把，内部类的成员变量写在外部，这样就能一起使用了。
内部类同样是受public、protected、private访问限定符的限制，当写成私有时类外面也无法直接使用

练习使用：

还有写许细节已经进行了注释

class A {
public:

	class B {//此时的B就是A的一个内部类，并且内部类时外部类的友元，可以使用外部类的变量
	public:
		B()
		{}
		void Print(const A& a)//注意也并不是直接就能使用其成员变量，还是需要先实例化一个对象的
		{
			cout << a._a << a._b << endl;
		}
	private:

	};

private:
	int _a = 0;
	int _b = 10;

};

int main()
{
	A a;
	A::B b;//当是public 时就能在外部定义了
	return 0;
}

class A {
public:

	class B {//此时的B就是A的一个内部类，并且内部类时外部类的友元，可以使用外部类的变量
	public:
		B()
		{
		}
		void Print()
		{
			cout << _a <<_b << endl;//此处对于静态成员来说直接通过A::xxx 就能访问，所以对在A类内的B就能直接使用静态的
		}
	private:

	};

private:
	static int _a;
	static int _b;
};

int main()
{
	A a;
	A::B b;//当是public 时就能在外部定义了
	return 0;
}

5.匿名对象

知识点：

匿名对象，其是就是创建一个没有对象名的对象，并且此时匿名对象在创建行构造，到下一行时就会析构。

匿名对象的创建方法：类名 ()；

匿名对象的使用方法：类名() . 调用的函数；

细节：

匿名对象和临时变量一样都具有常性，所以要引用这个对象的话需要加上const来修饰
如const A& ra = A();
并且对于被引用的匿名对象来说，他的生命周期也会因为被引用而延长到该局部函数结束时
附：在创建对象的时候不能写成如 Date d(); 因为此时编译器无法分清这是函数的声明还是你对象的构造，所以对于不传参的情况不用加上括号

具体练习：

class A
{
public:
	A(int a = 0)
		:_a(a)
	{
		cout << "A(int a)" << endl;
	}
	~A()
	{
		cout << "~A()" << endl;
	}
private:
	int _a;
};
class Solution {
public:
	int Sum_Solution(int n) {
		//...
		return n;
	}
};
int main()
{
	A aa1;//正常的构造
	A();//匿名对象，生命周期在本行

	A aa2(2);//正常的构造
	Solution().Sum_Solution(10);//匿名对象调用其函数，并且此处并不会调用构造函数

	const A& ra = A();//注意匿名对象具有常性，所以需要在引用前面+const
	A aa3(3);//正常的构造
	
	return 0;
}