类和对象——补充(运算符重载，static和explicit关键字和友元，内部类)

Posted 2021-08-09 两片空白

目录

一.运算符重载

 二.static和explicit关键字

1. static成员

1.1概念

1.2特性

2.explicit关键字

三.友元

3.1 友元函数

3.2友元类

四.内部类

4.1概念

4.2特性

---

一.运算符重载

        C++为了增强代码的可读性引入了运算符重载，运算符重载是具有特殊函数名的函数，也具有器返回值类型，函数名和参数列表。

        一般运算符只能在内置类型的变量之间使用，运算符重载就是让自定义类型可以像内置类型一样使用运算符。

        函数名：由关键字opertor+需要重载的运算符符号。

        函数原型：返回值+operator操作符（参数列表）

注意：

1. 不能通过其它符号来创建新的操作符：比如operator@，@在语言中没有实际意义。
2. 重载操作符必须有一个类类型或者枚举类型的操作数。
3. 用于内置类型的操作符重载后，其含义不能改变。
4. 作为类成员的重载函数时，其形参看起来比操作数少了一个参数，其实还隐含了一个this指针，限定为第一个形参。
5. 注意有5个操作不能重载，".*","::"(域操作限定符)，"sizeof"，"?:"，"..."(逗号表达式)。

那运算符重载怎么实现呢？

#include<iostream>
#include<Windows.h>
using namespace std;
class Date{

public:
	Date(int year = 0, int month = 1, int day = 1)
		:_year(year)
		, _month(month)
		, _day(day)
	{}
	Date(Date& d){
		_year = d._year;
		_month = d._month;
		_day = d._day;
	}
//private:
	int _year;
	int _month;
	int _day;
};
//==运算符重载
bool operator==(const Date& d1,const Date& d2){
	return d1._year == d2._year&&d1._month == d2._month&&d1._day == d2._day;
}


int main(){
	Date d1(2021, 7, 11);
	Date d2(2020, 7, 11);
	cout << (d1 == d2) << endl;
	system("pause");
	return 0;
}

这里发现，如果将运算符重载函数写成全局的就需要类的成员变量是共有的(public)，私有的在类外无法访问。那么在其它函数都可以访问类的成员变量，这样类的封装性就无法保证。

这个的解决办法可以是

1.将运算符重载函数写在类里。

2.运用友元来解决，下面有解释。

我们这里使用第一种方法来解决，代码就变成了下面这样。

#include<iostream>
#include<Windows.h>
using namespace std;
class Date{

public:
	Date(int year = 0, int month = 1, int day = 1)
		:_year(year)
		, _month(month)
		, _day(day)
	{}
	Date(Date& d){
		_year = d._year;
		_month = d._month;
		_day = d._day;
	}
	bool operator==(const Date& d){
		return _year == d._year&&_month == d._month&&_day == d._day;
	}
private:
	int _year;
	int _month;
	int _day;
};

int main(){
	Date d1(2021, 7, 11);
	Date d2(2020, 4, 11);
    //==操作符优先级低于<<
	cout << (d1 == d2) << endl;
	system("pause");
	return 0;
}

 输出：

d1==d2是像下面这样调用的。

 二.static和explicit关键字

1. static成员

1.1概念

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

class A{
	//静态成员函数
	static int GetCount(){
		return _count;
	}
private:
	//静态成员变量
	static int _count;
};
//静态成员变量一定要在类外初始化
int A::_count = 2;

1.2特性

1. 静态成员为所有类对象所共享，不属于具体的实例化的对象。
2. 静态成员变量必须在类外定义。
3. 类静态成员(成员函数，成员变量)，可以使用类名::静态成员或者对象.静态成员来访问。
4. 静态成员函数没有隐藏的this指针，不能访问任何非静态成员。
5. 静态成员和类普通成员一样，也受访问限定符的限制。

说明：在类里的成员变量(静态，非静态)都只是声明，但是静态成员保存在静态区，它不仅属于实例化的对象中，而且属于这个类实例化的所有对象，也属于这个类，所以可以通过A::成员来访问。

静态和非静态的成员函数都存储在代码区，static修饰函数只是改变了链接属性，只能在当前源代码访问。

为什么不能用类来调用非静态函数呢？因为非静态有this指针，用类调用就this指针就不知道指向谁了。

两个问题：

1.静态成员函数可以调用非静态成员函数吗？

解答：不可以，没有this指针。

2.非静态成员函数可以调用静态成员函数吗？

解答：可以，不仅仅是因为有this指针的关系，因为它是静态的。

2.explicit关键字

        构造函数不仅可以构造域初始化对象，对于单个参数的构造函数，还具有类型转化的作用。

#include<iostream>
#include<Windows.h>
using namespace std;
class Date{

public:
	Date(int year = 0)
		:_year(year)
	{}
	Date(Date& d){
		_year = d._year;

	}
private:
	int _year;
};

int main(){
	Date d1(2020);
	d1 = 2021;
	return 0;
}

 但是上述代码可读性不好，用explicit修饰构造函数将会禁止单参数构造函数的隐式转化。

public:
	explicit Date(int year = 0)
		:_year(year)
	{}

private:
	int _year;
};

int main(){
	Date d1(2020);
	d1 = 2021;//报错
	return 0;
}

三.友元

        友元分为：友元函数和友元类。

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

3.1 友元函数

        我们知道类的私有成员在类内可以进行访问，类外不能访问。友元函数提供了一种方法可以在类外直接访问类的私有成员。友元函数不属于任何类，但是需要在类的内部声明，声明时需要加上friend关键字。

上面提及操作符重载时，提到如果将操作符重载函数写成全局函数可以通过友元来访问私有成员变量，代码如下：

#include<iostream>
#include<Windows.h>
using namespace std;
class Date{
    //将==运算符重载函数声明为友元函数
	friend bool operator==(const Date& d1, const Date& d2);
public:
	Date(int year = 0, int month = 1, int day = 1)
		:_year(year)
		, _month(month)
		, _day(day)
	{}
	Date(Date& d){
		_year = d._year;
		_month = d._month;
		_day = d._day;
	}
private:
	int _year;
	int _month;
	int _day;
};
//==运算符重载，友元函数可以访问私有成员变量
bool operator==(const Date& d1, const Date& d2){
	return d1._year == d2._year&&d1._month == d2._month&&d1._day == d2._day;
}


int main(){
	Date d1(2021, 7, 11);
	Date d2(2020, 7, 11);
	cout << (d1 == d2) << endl;
	system("pause");
	return 0;
}

说明：

• 友元函数可以访问类的私有成员和保护成员，但不是类的成员函数。
• 友元函数不能用const修饰(没有this指针)，const修饰成员函数实际是修饰this指针指向的对象。
• 友元函数可以在类定义的任何地方声明，它不受类访问限定符限制。
• 一个函数可以是多个类的友元函数。
• 友元函数的调用与普通函数的调用和原理相同。

3.2友元类

        友元类是在另一个类中声明一个友元类，这样友元类的所有成员函数可以访问另一个类的非公有成员。

class Date{
	//声明友元类
	friend class Time;
public:
	Date(int year = 0, int month = 1, int day = 1)
		:_year(year)
		, _month(month)
		, _day(day)
	{}
	Date(Date& d){
		_year = d._year;
		_month = d._month;
		_day = d._day;
	}
private:
	int _year;
	int _month;
	int _day;
};
class Time{
public：
	Time(int hour,int minute,int second)
	:_hour(hour)
	, _minute(minute)
	, _second(second)
	{

	}
    //可以访问Date的私有成员
	void SetDate(int year,int month,int day){
		_t._year = year;
		_t._month = month;
		_t._day = day;
	}
private:
	int _hour;
	int _minute;
	int _second;
	Date _t;
};

说明：

• 友元关系是单向的，不具有交换性。比如上述代码，Time是Date的友元类，但是Date不是Time的友元类，Date类不能访问Time的私有成员。
• 友元关系不能传递。比如C是B的友元，A是C的友元，并不能说明A是B的友元。

四.内部类

4.1概念

        如果一个类1定义在另外一个类2的内部，那么类1就叫做内部类。内部类就是在一个类里定义的类。

注意

1. 此时这个内部类是一个独立的类，它不属于外部类，更不能通过外部类的对象去调用内部类。外部类对内部类没有任何优越的访问权限。
2. 内部类天生就是外部类的友元类，但是外部类不是内部类的友元类。也就是说，内部类可以通过外部类对象访问外部类的任何成员，外部类不行。

4.2特性

1. 内部类可以定义在外部类的public，protected，private里。
2. 注意内部类可以直接访问外部类中的static，枚举成员，不需要加外部类对象或者类名
3. sizeof(外部类)就等于外部类的大小，与内部类没有关系。

class A{
public:
    //B是A的内部类
	class B{
	public:
		void f1(A& k){
			//static变量直接访问，不需要类名和对象
			cout << _a << endl;

			cout << k._b << endl;
		}
	};
private:
	static int _a;
	int _b;
};
int A::_a = 2;

int main(){
	//定义一个B类的对象
	A::B b;
}