C++ 面向对象补充

目录

初始化列表

explicit关键字

单参数构造函数

多参数构造函数

static成员

友元

内部类(不常用)

匿名对象

---

初始化列表

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

class Date
{
public:
	Date(int year, int month, int day)
		//初始化列表
		:_year(year),
		_month(month),
		_day(day)
	{}
	void print()
	{
		cout << _year << "年" << _month << "月" << _day << "日" << endl;
	}
private:
	int _year;
	int _month;
	int _day;
};

int main()
{
	Date d1(2023, 4, 6);
	d1.print();
	return 0;
}

注意事项

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

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

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

class B
{
public:
	B(int b)
		:_b(b)
	{}
private:
	int _b;
};
class A
{
public:
	A(int a, int i, int b)
		:_a(a),
		_i(i),
		_b1(b)
	{}
private:
	int& _a;
	const int _i;
	B _b1;
};

3. 尽量使用初始化列表初始化，因为不管你是否使用初始化列表，对于自定义类型成员变量，一定会先使用初始化列表初始化。

有的小伙伴会误认为给成员变量赋缺省值就是初始化，切记只有在初始化列表中才进行初始化。

class Date
{
public:
	void print()
	{
		cout << _year << "年" << _month << "月" << _day << "日" << endl;
	}
private:
	//注意：此处为赋缺省值
	int _year = 0;
	int _month = 0;
	int _day = 0;
};

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

class A
{
public:
	A()
		:a(10),
		 b(a)
	{}
	void print()
	{
		cout << "a= " << a << endl;
		cout << "b= " << b << endl;
	}
private:
	int a;
	int b;
};
int main()
{
	A a1;
	a1.print();
	return 0;
}

class A
{
public:
	A()
		:b(10),
		 a(b)
	{}
	void print()
	{
		cout << "a= " << a << endl;
		cout << "b= " << b << endl;
	}
private:
	int a;
	int b;
};
int main()
{
	A a1;
	a1.print();
	return 0;
}

示例2中，出现该结果的原因是成员变量的声明顺序为先a后b，则初始化顺序也为先a后b。a在初始化时，使用b的值，而此时b还未初始化b的值为随机值，所以a的值也为随机值。接下来用10初始化b，所以b的值为10。

explicit关键字

构造函数不仅可以构造与初始化对象，对于单个参数或者除第一个参数无默认值其余均有默认值的构造函数，还具有类型转换的作用。

什么是类型转换

	int a=100;
	double b = a;

如上所示，a并不是直接赋值给b，而是先进行了隐式类型转换：

1. 创建一个double类型的临时变量；
2. 将a的值赋予临时变量；
3. 将临时变量的值赋予b。

单参数构造函数

定义一个Date类，且该类的构造函数只有一个参数，我们称为单参数构造函数：

class Date
{
public:
	Date(int year)
		:_year(year)
	{}
private:
	int _year=0;
};

Date d1(2023);

这是我们常见的创建一个对象的写法，此外还可以这样写：

Date d2 = 2023;

注意事项：

• 此处这种写法是我们的赋值运算符重载吗？
  答案是，当然不是。赋值重载实现的功能是用一个已存在的对象赋值给另外一个对象。

那么为什么100可以赋值给d1呢？这是由于类型转换的原因。具体实现过程如下：

1. 用100构造一个Date类型的临时对象；
2. 再用临时对象对d1进行拷贝构造。

总结起来就是，该语句实现了2个过程——1个构造+1个拷贝构造。

如何证明？explicit修饰的构造函数禁止类型转换。

class Date
{
public:
	explicit Date(int year)
		:_year(year)
	{}
	
private:
	int _year=0;
	int _month=0;
	int _day=0;
};
int main()
{
	Date d2 = 100;
	return 0;
}

?如图所示，此时编译器会报错。

多参数构造函数

多参数构造函数与单参数类似。C++98中只支持除第一个参数外，其余参数都有默认值的情况。C++11中引进了一种新的写法。

C++98

class Date
{
public:
	//除第一个参数外，其余都有默认值
	//加上explicit关键字会报错
	Date(int year, int month=0, int day=0)
		:_year(year),
		_month(month),
		_day(day)
	{}
private:
	int _year;
	int _month;
	int _day;
};

int main()
{
	Date d2 = 100;
	return 0;
}

C++11

class Date
{
public:
	Date(int year, int month,int day)
		:_year(year),
		_month(month),
		_day(day)
	{}
private:
	int _year;
	int _month;
	int _day;
};

int main()
{
	Date d2 ={2023,10,26};//使用大括号
	return 0;
}

static成员

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

class A
{
public:
	int getN()
	{
		return n;
	}
private:
	//类中进行声明
	static int n;
};

//类外进行定义与初始化
int A::n = 0;

特性

1. 静态成员变量必须在类外定义，定义时不添加static关键字，类中只是声明；
2. 类静态成员即可用?类名::静态成员?或者?对象.静态成员?来访问；
3. 静态成员也是类的成员，受public、protected、private?访问限定符的限制；

class A
{
public:
	int getN()
	{
		return n;
	}
public:
	//类中进行声明
	static int m;
private:
	//类中进行声明
	static int n;
};

//在类外进行定义与初始化
int A::n = 0;
int A::m = 0;

int main()
{
	A a;
	a.m += 10;
	cout << a.getN() << endl;
	cout << a.m<< endl;
	return 0;
}

4. 静态成员函数没有隐藏的this指针，不能访问任何非静态成员；

class B
{
public:
	static int getN()
	{
		//错误示例
		//静态函数不能直接访问非静态成员
		//_a++;

		return n;//可以访问静态成员
	}
private:
	static int n;
	int _a;
};

5. 静态成员为所有类对象所共享，不属于某个具体的对象，存放在静态区。

友元

面向对象有三大特性——封装、继承、多态。从学习C++至今，我们一直在谈封装的重要性。但是在某些特殊的情况下，有时需要突破封装的限制。

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

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

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

{
//...
	//声明友元函数
	friend ostream& operator<<(ostream& out, const Date& d);
	friend istream& operator>>(istream& in, Date& d);
	//...
}
ostream& operator<<(ostream& out, const Date& d)
{
	out << d._year << "年" << d._month << "月" << d._day << "日";
	return out;
}

istream& operator>>(istream& in, Date& d)
{
	in >> d._year >> d._month >> d._day;
	return in;
}

友元函数有如下几条重要的性质：

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

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

class Time
{
	friend class Date;//声明日期类为时间类的友元类，则在日期类中可以直接发访问时间类
	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 = 2023, int month = 4, int day = 9)
		: _year(year)
		, _month(month)
		, _day(day)
	{}
	void SetTime(int hour, int minute, int second)
	{
		// 直接访问时间类私有的成员变量
		_t._hour = hour;
		_t._minute = minute;
		_t._second = second;
	}
private:
	int _year;
	int _month;
	int _day;
	Time _t;
};

友元类的重要性质如下：

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

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

友元关系不能继承（先不做解释）；

内部类(不常用)

如果一个类定义在另一个类的内部，这个类就叫做内部类。内部类是一个独立的类，它不属于外部类，更不能通过外部类的对象去访问内部类的成员。外部类对内部类没有任何优越的访问权限。

内部类有一个重要的性质——内部类天生就是外部类的友元。参照友元类的定义，内部类可以通过外部类的对象参数来访问外部类中的所有成员。但是外部类不是内部类的友元。

内部类性质

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

class A
{
private:
	//声明static成员
	static int k;
	int n=0;
public:
	class B // B天生就是A的友元
	{
	public:
		void print(const A& a)
		{
			cout << k << endl;
			cout << a.n << endl;
		}
	};
};

//初始化static成员
int A::k = 1;

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

	A a;
	b.print(a);
	return 0;
}

匿名对象

匿名对象，顾名思义，该对象没有名字就叫匿名对象。匿名对象重要的性质：

• 匿名对象的生命周期只在定义它的那一行；

class A
{
public:
	A(int a = 0)
		:_a(a)
	{}
private:
	int _a;
};

int main()
{
	//普通对象
	A a1;
	//匿名对象的定义
	return 0;
}

匿名对象看似鸡肋，但在某些场合下非常适用。比如，我们只想拿到类内部的某个成员的值，或只是想用一下类中的某个成员函数，为了一件简单的事而专门定义一个对象再销毁显得有点多此一举，那么就可以使用匿名对象。

class solution
{
public:
	int Sum_Solution(int n)
	{
		int sum = 0;
		for (int i = 1; i <= n; i++)
		{
			sum += i;
		}
		return sum;
	}
};
int main()
{
	//匿名对象的使用场景
	cout << solution().Sum_Solution(100) << endl;
	return 0;
}