C++类与对象(下)

秒速五厘米 2024-04-18 16:32 57阅读 0赞

**目录**

###       [C++类与对象(上)][C] ###

### [C++类与对象(中)][C 1] ###

static成员

C++11 的成员初始化新方法

explicit关键字

友元

内部类

再次理解封装

--------------------

## static成员 ##

我们不妨回忆一下C中的static用法  [C语言中static用法(点击跳转)][C_static]

> 声明为static的类成员称为类的静态成员，用static修饰的成员变量，称之为静态成员变量；用static修饰的成员函数，称之为静态成员函数。静态的成员变量一定要在类外进行初始化

> **特性**  
> 1. 静态成员变量必须在类外定义，定义时不添加static关键字  
> 2. 类的静态成员即可用 类名::静态成员 或者  对象**.**静态成员  来访问  
> 3. 静态成员和类的普通成员一样，也有public、protected、private 3 种限定，也可以具有返回值，const修饰符等.  
> 4. **静态成员属于类, 不属于对象, 为一个类的所有对象所共享**,不属于某个具体的实例(对象), 不占用类空间(在全局区(静态区)存储)即这个类所实例的所有对象都可以操作静态成员(即在一个类定义好之后, 静态成员就已经在全局区存储了)  
> 5. 静态成员函数没有隐藏的this指针(因为不属于对象, 当然不会有对象的指针传进来), 所以不能像普通成员函数那样访问非静态成员, 但要如果想访问非静态变量, 穿个参数就可以, 一般传个对象的引用, 例如这样static void test(Test& a)\{ a.a=10;\}  
> 静态成员函数是为了直接操作静态成员变量的, 因为为了保证封装性, 静态成员变量一般也是私有的, 我们在不通过对象调用普通成员函数操作静态成员变量时, 就只能用静态成员函数 .
> 
> 来看个静态成员变量的运用, 就一目了然了 ,  
> 有一个类 , 计算程序中共创建出了多少个这个类的对象。

#include<iostream>
    using namespace std;
    class A {
    	static int m_s_count;
    	int m_n;
    public:
    	A() {
    		++m_s_count;
    	}
    	A(const A& t) { 
    		++m_s_count; 
    	}
    	static int GetACount() {
    		return m_s_count;
    	}
    };
    int A:: m_s_count= 0;
    void TestA() {
    	cout << "初始有" << A::GetACount() << "个对象" << endl;
    	A a1, a2;
    	A a3(a1);
    	cout << "现在有" << A::GetACount() << "个对象" << endl;
    	cout << "现在有" << a1.GetACount() << "个对象" << endl;
    }
    int main() {
    	TestA();
    	system("pause");
    	return 0;
    }

![2019090917194742.png][]

还可以统计程序中有多少个对象在运行(在栈中)

#include<iostream>
    using namespace std;
    class A {
    	static int m_s_count;
    	int m_n;
    public:
    	A() {
    		++m_s_count;
    	}
    	A(const A& t) { 
    		++m_s_count; 
    	}
    	~A() {
    		--m_s_count;
    	}
    	static int GetACount() {
    		return m_s_count;
    	}
    };
    int A:: m_s_count= 0;
    void TestA() {
    	cout << "TestA函数调用开始\n";
    	A a1, a2;
    	A a3(a1);
    	cout << "现在有" << A::GetACount() << "个对象" << endl;
    }
    int main() {
    	cout << "初始有" << A::GetACount() << "个对象" << endl;
    	A a1, a2;
    	cout << "未调用TesTA之前有" << A::GetACount() << "个对象" << endl;
    	TestA();
    	cout << "TestA函数调用结束\n";
    	cout << "现在有" << A::GetACount() << "个对象" << endl;
    	system("pause");
    	return 0;
    }

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQxMDcxMDY4_size_16_color_FFFFFF_t_70][]

**问题**  
1. 静态成员函数可以调用非静态成员函数吗？  
 答 : 大多数时候不可以, 但当静态成员函数参数有本类对象或是本类对象的引用(或指针)时, 也可以调用,但这眼科意义上来说并不是静态成员函数调用的  
2. 非静态成员函数可以调用类的静态成员函数吗？  
 答: 可以, 静态成员属于类不属于对象, 静态成员在类内部相当于一个局部的全局变量

--------------------

## C++11 的成员初始化新方法 ##

> C++11支持非静态成员变量在声明时，直接初始化。

#include<iostream>
    using namespace std;
    class B {
    public:
    	int m_c;
    	B(int c = 0) :m_c(c) { 
    	
    	}
    };
    class A {
    	int m_a = 10;
    	B m_b = 20;
    	int* m_p = (int*)malloc(4);
    	static int m_s_n;
    public:
    	void PrintA();
    };
    int A::m_s_n = 0;
    void A::PrintA() {
    	cout << m_a << endl;
    	cout << m_b.m_c << endl;
    	cout << m_p << endl;
    	cout << m_s_n << endl;
    }
    int main() {
    	A a;
    	a.PrintA();
    	system("pause");
    	return 0;
    }

![20190909224331714.png][]

我们可以看到非静态的成员在声明时就已经可以初始化, 这样方便了许多 .   
但这里我们可能会注意到, 一个类A的成员变量中有一个类B类型的成员, 但我们直接B m\_b = 20;

![20190909225507462.png][]                            ![20190909230020865.png][]

这是因为构造函数不仅可以构造与初始化对象，对于**单个参数**的构造函数，还具有**类型转换**的作用 ,什么意思呢?  
这里就要引入C++中的一个关键字explicit

### explicit关键字 ###

先来看下面的代码*.cpp*

#include<iostream>
    using namespace std;
    class A {
    	int m_a;
    public:
    	A(int a = 0) :m_a(a) {
    		cout << "调用构造函数A() :";
    		cout << "形参a的值:" << a << endl;
    	}
    	A& operator=(A&& t) {//不定义编译器会生成一个默认的运算符重载函数
    		m_a = t.m_a;
    		cout << "调用A& operator=(A&& t)\n";
    		return *this;
    	}
    	void PrintA();
    };
    void A::PrintA() {
    	cout << m_a << endl;
    }
    int main() {
    	A a;
    	a = 100;
    	cout << "打印a\n";
    	a.PrintA();
    	system("pause");
    	return 0;
    }

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQxMDcxMDY4_size_16_color_FFFFFF_t_70 1][]

我们可以看到我们只定义了一个类的对象, 结果却调用了两次构造函数, 第一次构造函数调用时形参a=0, 可以看出应该是定义对象a 时所调用, 第二次调用构造函数形参值为100, 是谁调用的呢 ? 前面我们提到"构造函数不仅可以构造与初始化对象，对于**单个参数**的构造函数，还具有**类型转换**的作用", 其实, 在a = 100;这个语句运行时编译器将int 型的100隐式转化成了自定义的A类型, 强转时调用了构造函数(这里我们要知道的是,构造函数虽然在语法层面无返回值的，但实际是有的, 我们一般也用不到 , 我们可以通过构造函数的反汇编代码看出，返回值就是\*this, 返回类型也就是对象的引用A&), 然后就会调取编译器生成的默认的赋值运算符重载函数(上面代码为了更加直观, 显示定义了这个运算符重载函数)给对象a赋值 .

这样直接用等号给对象赋值让人很别扭, 且可读性不好, 所以我们可以用C++中的关键字explicit修饰构造函数，此时将会禁止单参构造函数的隐式转换 ,我们给构造函数加上explicit再来看

#include<iostream>
    using namespace std;
    class A {
    	int m_a;
    public:
    	explicit A(int a = 0) :m_a(a) {
    	
    	}
    	void PrintA();
    };
    void A::PrintA() {
    	cout << m_a << endl;
    }
    int main() {
    	A a;
    	a = 100;
    	cout << "打印a\n";
    	a.PrintA();
    	system("pause");
    	return 0;
    }

![20190910000554989.png][]

我们可以看到, 编译时发生错误

其实关键字explicit在我们写代码时基本不会用到, 一般也不会有人会有给对象直接赋值的坏习惯, 简单了解一下就好

--------------------

## 友元 ##

> 友元分为：友元函数和友元类   
> 友元提供了一种突破封装的方式，有时提供了便利。但是友元会增加耦合度，破坏了封装，所以友元**不宜多用。**  
> 不管是友元函数或友元类, 在声明是前用关键字friend 来修饰
> 
> 友元的概念对类是相对于成员来说的, 把类比作一个家庭, 那么成员就是家人, 友元就是朋友 .

**友元函数**

> 友元函数可以直接访问类的所有成员(包括私有成员)，但它是类外部的普通函数，不属于类，但需要在类的内部声明(声明时加关键字friend), 在类内声明, 类外实现时不需要类的作用域限定(也不加friend, 这是因为本质上友元函数就是一个普普通通的函数而已 ) , 都是因为友元函数不属于类嘛

问题：我们尝试去重载operator<< , 来先试一试

#include<iostream>
    using namespace std;
    class A {
    	int m_a;
    public:
    	explicit A(int a = 0) :m_a(a) {
    	
    	}
    	void PrintA();
    	ostream& operator<<(ostream& os) {//第一个形参是隐藏的this指针
    		os << m_a << endl;
    		return os;
    	}
    	//因为成员函数第一个形参是隐藏的this指针,所以参数只能1个
    	/*ostream& operator<<(ostream& os, A& t) {
    		os << t.m_a << endl;
    		return os;
    	}*/
    };
    void A::PrintA() {
    	cout << m_a << endl;
    }
    int main() {
    	A a(10);
    	cout << "打印a\n";
    	a << cout;
    	//或者
    	a.operator<<(cout);
    	system("pause");
    	return 0;
    }

![2019091009471667.png][]![20190910094805646.png][]

我们可以看到这样重载也可以达到效果, 但用的时候也太难受了有木有, a << cout; 这不是与通常的书写习惯相反嘛,   
a.operator<<(a); 这还不如直接a.PrintA() 呢......  
这是因为**cout的输出流对象和隐含的this指针在抢占第一个参数的位置**。

![20190910100631269.png][]![20190910101106462.png][]![2019091010182798.png][]  
this指针默认是第一个参数也就是左操作数了, 但我们实际使用中需要cout是第一个形参对象，才能符合正常习惯使用。所以我们要将operator<<重载成全局函数。但是这样的话，又会导致类外没办法访问类的成员

这时候友元函数就闪亮登场啦  
来先看代码

#include<iostream>
    using namespace std;
    class A {
    	int m_a;
    public:
    	explicit A(int a = 0) :m_a(a) {
    	
    	}
    	friend ostream& operator<<(ostream& os, A& t) {
    		os << t.m_a << endl;
    		return os;
    	}
    	void PrintA();
    };
    void A::PrintA() {
    	cout << m_a << endl;
    }
    int main() {
    	A a(10);
    	cout << "打印a\n";
    	cout << a;
    	system("pause");
    	return 0;
    }

![20190910095528633.png][]

我们可以看到, 友元函数完美的解决了这个问题 .  
operator>>, 同理

#include<iostream>
    using namespace std;
    class A {
    	int m_a;
    public:
    	explicit A(int a = 0) :m_a(a) {
    	
    	}
    	friend ostream& operator<<(ostream& os, A& t);
    	friend istream& operator>>(istream& os, A& t);
    	void PrintA();
    };
    void A::PrintA() {
    	cout << m_a << endl;
    }
    ostream& operator<<(ostream& os, A& t) {
    	os << t.m_a << endl;
    	return os;
    }
    istream& operator>>(istream& os, A& t) {
    	os >> t.m_a;
    	return os;
    }
    int main() {
    	A a;
    	cout << "输入a的数据\n";
    	cin >> a;
    	cout << "打印a\n";
    	cout << a;
    	operator<<(cout, a);
    	system("pause");
    	return 0;
    }

![20190910104246229.png][]

> **补充 : **  
> 友元函数不能用const修饰  
> 友元函数可以在类定义的任何地方声明，不受类访问限定符限制  
> 一个函数可以是多个类的友元函数  
> 友元函数的调用与普通函数的调用和原理相同

**友元类**

>     #include<iostream>
>     using namespace std;
>     class Date; // 前置声明
>     class Time{
>     	int m_hour;
>     	int m_minute;
>     	int m_second;
>     	friend class Date; // 声明日期类为时间类的友元类，则在日期类中就直接访问Time类中的私有成员变量
>     public:
>     	Time(int hour = 12, int minute = 1, int second = 1)
>     		: m_hour(hour)
>     		, m_minute(minute)
>     		, m_second(second)
>     	{}
>     	void PrintTime();
>     };
>     void Time::PrintTime() {
>     	cout << m_hour << "时" << m_minute << "分" << m_second << "秒\n";
>     }
>     class Date {
>     	int m_year;
>     	int m_month;
>     	int m_day;
>     	Time m_t;
>     public:
>     	Date(int year = 1900, int month = 1, int day = 1)
>     		: m_year(year)
>     		, m_month(month)
>     		, m_day(day)
>     	{}
>     	void SetTimeOfDate(int hour, int minute, int second);
>     	void PrintDate();
>     };
>     void Date::SetTimeOfDate(int hour, int minute, int second) {
>     	// 直接访问时间类私有的成员变量
>     	m_t.m_hour = hour;
>     	m_t.m_minute = minute;
>     	m_t.m_second = second;
>     }
>     void Date::PrintDate() {
>     	cout << m_year << "年" << m_month << "月" << m_day << "日";
>     	m_t.PrintTime();
>     }
>     int main() {
>     	Date a(2019, 10, 1);
>     	a.SetTimeOfDate(11,14,50);
>     	a.PrintDate();
>     	system("pause");
>     	return 0;
>     }
> 
> ![20190910111459733.png][]
> 
> 1. 友元类的所有成员函数都**可以是**一个类的友元函数，都可以访问另一个类中的非公有成员。  
> 2. 友元关系是单向的，不具有交换性。  
> 比如上述Time类和Date类，在Time类中声明Date类为其友元类，那么可以在Date类中直接访问Time类的私有成员变量，但想在Time类中访问Date类中私有的成员变量则不行。  
> 3. 友元关系不能传递 , 如果B是A的友元，C是B的友元，则不能说明C时A的友元。
> 
> 总之友元对于类来说, 这个朋友当的......
> 
> ![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQxMDcxMDY4_size_16_color_FFFFFF_t_70 2][]

--------------------

## 内部类 ##

> 概念：如果一个类定义在另一个类的内部，这个定义在内部的类就叫做内部类。注意此时这个内部类是一个独立的类，它不属于外部类，更不能通过外部类的对象去调用内部类。外部类对内部类没有任何访问权限。
> 
> 内部类就是外部类的友元类。那么也就是说, 内部类可以访问外部类, 内部类可以通过外部类的对象参数来访问外部类中的所有成员

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

#include<iostream>
    using namespace std;
    class Time{
    	int m_hour;
    	int m_minute;
    	int m_second;
    public:
    	class Date {
    		int m_year;
    		int m_month;
    		int m_day;
    	public:
    		Date(int year = 1900, int month = 1, int day = 1)
    			: m_year(year)
    			, m_month(month)
    			, m_day(day)
    		{}
    		void SetTimeOfDate(Time& t, int hour, int minute, int second);
    		void PrintDate(const Time& t);
    	};
    	Time(int hour = 12, int minute = 1, int second = 1)
    		: m_hour(hour)
    		, m_minute(minute)
    		, m_second(second)
    	{}
    	void PrintTime(const Time& t)const;
    };
    void Time::PrintTime(const Time& t) const {
    	cout << m_hour << "时" << m_minute << "分" << m_second << "秒\n";
    }
    void Time::Date::SetTimeOfDate(Time& t, int hour, int minute, int second) {
    	// 直接访问时间类私有的成员变量
    	t.m_hour = hour;
    	t.m_minute = minute;
    	t.m_second = second;
    }
    void Time::Date::PrintDate(const Time& t) {
    	cout << m_year << "年" << m_month << "月" << m_day << "日";
    	t.PrintTime(t);
    }
    int main() {
    	Time::Date d(2019, 10, 1);
    	Time t;
    	d.SetTimeOfDate(t, 11, 11, 11);
    	d.PrintDate(t);
    	system("pause");
    	return 0;
    }

![20190910193350315.png][]

需要注意的是内部类虽然是外部类的友元类, 但并不能像上面代码中的普通友元类一样, 在友元类中创建另一个的对象, 也就是说, 不能在内部类中定义外部类的对象, 所以内部类访问外部类必须要以函数传外部类引用的方式进行 .

--------------------

## 再次理解封装 ##

> C++通过类，将一个对象的属性与行为结合在一起，使其更符合人们对于一件事物的认知，将属于该对象的所有东西打包在一起；通过访问限定符选择性的将其部分功能开放出来与其他对象或用户进行交互，而对于对象内部的一些实现细节，外部用户不需要知道，当然知道了有些情况也没用，可能反而增加了使用或者维护的难度，让整个事情复杂化。  
>

[C]: https://blog.csdn.net/qq_41071068/article/details/100605703
[C 1]: https://blog.csdn.net/qq_41071068/article/details/100620955
[C_static]: https://blog.csdn.net/qq_41071068/article/details/100710864
[2019090917194742.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/18/f234f4120dd245c5881538383e5df440.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQxMDcxMDY4_size_16_color_FFFFFF_t_70]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/18/f3b6d87c9f77442e8bba3992d387e650.png
[20190909224331714.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/18/3953029f07cb4183a3bf877346211804.png
[20190909225507462.png]: https://img-blog.csdnimg.cn/20190909225507462.png
[20190909230020865.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/18/90d4fe22ca614bd2bf8971bda51e8e3b.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQxMDcxMDY4_size_16_color_FFFFFF_t_70 1]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/18/ddd3cc43877f4be6ad78f3b8338baa80.png
[20190910000554989.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/18/efcf9d16ab5f478380a59caefcbfd5b6.png
[2019091009471667.png]: https://img-blog.csdnimg.cn/2019091009471667.png
[20190910094805646.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/18/fb25f3fa1a6e4d4b935c2c63e0f7f99d.png
[20190910100631269.png]: https://img-blog.csdnimg.cn/20190910100631269.png
[20190910101106462.png]: https://img-blog.csdnimg.cn/20190910101106462.png
[2019091010182798.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/18/88a6a2b25fef468f8c5713c6f7cf1810.png
[20190910095528633.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/18/f151e6c104434882834ef9bb3a62536e.png
[20190910104246229.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/18/a42543246c17400ea8fbb0cf6e98b122.png
[20190910111459733.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/18/a63841a881454a6b8bae9766bfc0338b.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQxMDcxMDY4_size_16_color_FFFFFF_t_70 2]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/18/4c84dd8f52ce48de925614192ad389fc.png
[20190910193350315.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/18/77d4317ee71d4ccaa768cd1a4368b24f.png