类和对象下篇（通俗易懂）

---

前言

本篇主要讲解构造函数进阶、static成员、友元以及内部类的主要内容！

---

一、构造函数进阶：

1.默认构造函数：

默认构造函数：当调用它时可以不需要传入任何参数。有三种类型：无参、全缺省的构造函数、用户不显示写编译器自动生成的。

class Date
{
    
    
public:
	Date()
	{
    
    
		_year = 2022;
		_month = 8;
		_day = 28;
	}
	Date(int year = 2022, int month = 8, int day = 28)//1
	{
    
    
		_year = year;
		_month = month;
		_day = day;
	}
private:
	int _year;
	int _month;
	int _day;
};

注意：以上这两种无参和全缺省虽然可以构成函数重载，但是会引发歧义，当你定义对象时不传参初始化，编译器对重载函数调用会不明确。

了解了什么是默认构造之后，我们看这段代码：
这段代码会报错，但是是为什么呢？？？

class B
{
    
    
public:
	B(int b)
	{
    
    
		_b = b;
	}
private:
	int _b;
};
class A
{
    
    
public:
	A(int x, int y)
	{
    
    
		_a = x;
		B b(y);
		_b = b;
	}
private:
	int _a;
	B _b;
};
int main()
{
    
    
	A a1(10, 20);
	return 0;
}

因为A类型对象调用构造函数初始化时,因为其中有B类型的自定义类型成员，会去调B类中的默认构造函数，但是B类中没有默认构造函数，所以会报错！

解决方法：可以在B类中添加默认构造函数解决。

但是这会导致一个问题，构造函数会先去B类中调用它的默认构造再回来进入A类构造函数体中继续执行函数内代码，还需要再去进行函数体内的一次拷贝构造加赋值才能达到想要的效果，这就显得很繁琐了。那有没有办法可以更方便呢？

C++初始化列表很好的解决了这个问题：

2.初始化列表：

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

class B
{
    
    
public:
	B(int b)
	{
    
    
		_b = b;
	}
private:
	int _b;
};
class A
{
    
    
public:
	A(int x, int y)
		:_a(x)
		,_b(y)
	{
    
    }
private:
	int _a;
	B _b;
};

注意事项：

1. 每个成员变量在初始化列表中只能出现一次(初始化只能初始化一次)。
2. 尽量使用初始化列表初始化，因为不管你是否使用初始化列表，对于自定义类型成员变量，一定会先使用初始化列表初始化。
3. 类中包含以下成员，必须放在初始化列表位置进行初始化：

• const成员变量。
• 引用成员变量。
• 自定义类型成员(且该类没有默认构造函数时。

3.explicit关键字：

为什么会有上图这种写法呢？
构造函数不仅可以构造与初始化对象，对于单个参数或者除第一个参数无默认值其余均有默认值的构造函数，还具有类型转换的作用。

上述代码可读性很差，用explicit修饰构造函数，可以禁止构造函数的隐式转换。

class A
{
    
    
public:
	explicit A(int a)
		:_a(a)
	{
    
    }
private:
	int _a;
};
int main()
{
    
    
	A a1 = 10;
	return 0;
}

二、static成员：

1.基本概念:

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

注意：静态成员变量一定要在类外进行初始化

class A
{
    
    
public:
	A(int a)
		:_a(a)
	{
    
    }
private:
	int _a;
	static int _n;
};
int A::_n = 20;
int main()
{
    
    
	A a1(10);
	return 0;
}

2.特点:

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

三、友元：

友元提供了突破封装的途径，虽然提供了便利，但是破坏了封装不宜多用。

1.友元函数:

我们先看一段重载<<运算符的代码：

class Date
{
    
    
public:
	Date(int year = 2022, int month = 8, int day = 28)//1
	{
    
    
		_year = year;
		_month = month;
		_day = day;
	}
	ostream& operator<<(ostream& out)
	{
    
    
		out << _year << "-" << _month << "-" << _day << endl;
		return out;
	}
private:
	int _year;
	int _month;
	int _day;
};
int main()
{
    
    
	Date d1(2022, 1, 1);
	//cout << d1;//error
	d1 << cout;//?????
	return 0;
}

当你对<<进行运算符重载时，因为cout正常使用时为左操作数，但是你会发现隐含的this指针必然就会占用左边的位置，导致你的cout不得不为第二个参数。所以这个时候只能重载成全局函数，但是重载成全局函数对类里的私有成员又访问不了。这个时候友元函数就起到了重要的作用！

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

class Date
{
    
    
	friend ostream& operator<<(ostream& out, const Date& date);
	friend istream& operator>>(istream& in, Date& date);
public:
	Date(int year = 2022, int month = 8, int day = 28)//1
	{
    
    
		_year = year;
		_month = month;
		_day = day;
	}
private:
	int _year;
	int _month;
	int _day;
};
//因为成员函数默认this在第一个，所以<<写成全局函数，用友元函数访问私有成员
ostream& operator<<(ostream& out, const Date& date)
{
    
    
	out << date._year << "-" << date._month << "-" << date._day << endl;
	return out;
}

istream& operator>>(istream& in, Date& date)
{
    
    
	in >> date._year >> date._month >> date._day;
	return in;
}
int main()
{
    
    
	Date d1(2022, 1, 1);
	cin >> d1;
	cout << d1 << endl;
	return 0;
}

2.友元类:

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

class Time
{
    
    
	// 声明日期类为时间类的友元类，则在日期类中就直接访问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;
};

注意：

1. 友元关系是单向的，不具有交换性。比如上述Time类和Date类，在Time类中声明Date类为其友元类，那么可以在Date类中直接访问Time
2. 类的私有成员变量，但想在Time类中访问Date类中私有的成员变量则不行。友元关系不能传递
3. 如果C是B的友元，B是A的友元，则不能说明C时A的友元。友元关系不能继承。

四、内部类：

概念：**如果B类定义在A类的内部，B类就叫做A类的内部类。**内部类不属于任何类，且外部类对内部类没有任何优越权限。

注意：内部类天生为外部类的友元类，但是外部类不是内部类的友元类

特点：

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

---

总结

以上就是今天要讲的类和对象下篇的内容，希望对刚刚阅读本篇博客的你有所帮助！