类和对象(下)

1、再谈构造函数

1.1 构造函数体赋值

在创建对象时，编译器通过调用构造函数，给对象中各个成员变量一个合适的初始值

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

虽然上述构造函数调用之后，对象中已经有了一个初始值

但是不能将其称为对对象中成员变量的初始化( 只能将其称为赋初值)

因为初始化只能初始 化一次，而构造函数体内可以多次赋值。

 

1.2初始化列表

初始化列表：以一个冒号开始，接着是一个以逗号分隔的数据成员列表，每个"成员变量"后面跟

一个放在括号中的初始值或表达式。

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

注意:

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

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

引用成员变量

const成员变量

自定义类型成员(且该类没有默认构造函数时)

class A
{
public:
	A(int a)
		:_a(a)
	{}
private:
	int _a;
};
class B
{
public:
	B(int a, int b)
		:_a(a)
		, _b(b)
		, _n(10)
	{}
private:
	A _a;// 没有默认构造函数
	int& _b;// 引用
	const int _n; // const 
};

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

一定会先使用初始化列表初始化。

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

次序无关 

class A
{
public:
	A(int a)
		:_a1(a)
		, _a2(_a1)
	{}

	void Print() {
		cout << _a1 << " " << _a2 << endl;
	}
private:
	int _a2;
	int _a1;
};
int main() {
	A aa(1);
	aa.Print();
}

声明次序就是初始化次序，所以应该是先初始化a2再初始化a1

那么打印的值就是1和随机值

 1.3explicit关键字

构造函数不仅可以构造与初始化对象，对于单个参数或者多个参数的构造函数，还可以通过赋值类型转换的方式构造对象

class Date
{
public:
	Date(int year)
		:_year(year)
	{}
	Date(int year, int month, int day)
		:_year(year)
		,_month(month)
		,_day(day)
	{}
	void Print()const
	{
		cout << _year << '/' << _month << '/' << _day << endl;
	}
	void Print()
	{
		cout << _year << '/' << _month << '/' << _day << endl;
	}
private:
	int _year;
	int _month;
	int _day;
};


int main()
{
	//C++支持单个参数的构造函数这样使用
	Date d1 = 2023;//先用2023去创建临时对象，再用该对象去拷贝构造
	d1.Print();
	//支持多参数
	Date d2 = { 2023,11,17 };
	d2.Print();
	//const要匹配
	const Date d3 = { 2023,11,18 };
	d3.Print();
	return 0;
}

 但是这样写可读性不好，可以用explicit关键字修饰该构造函数

加了explicit后就不允许这样构造对象了，不支持隐式类型转换了

2、static成员

2.1概念

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

用 static修饰的成员函数，称之为静态成员函数。

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

假如我们要计算用这个类创建了多少个对象，构造函数调用(初始化)了几次

加上static之后，count就属于这个类

每个对象都能用它，但不支持缺省值

受访问限定符(private)限制，main函数不能直接调用count要写一个GetCount函数去返回count 

using namespace std;

class A
{
public:
	A(){++count;}
	A(const A& t){++count;}
	~A(){}
	int GetCount() 
	{ return count; }
private:
	static int count;//类里面声明

};
//类外面定义
int A::count = 0;
A func()
{
	A aa;
	return aa;
}

int main()
{
	A aa;//有名对象
	//为了调用GetCount而创建的所以count要-1
	func();
	cout <<aa.GetCount()-1<< endl;
	cout << A().GetCount() - 2 << endl;//A()这种写法叫匿名对象，其生命周期只有在这一行
	return 0;
}

还有一种更好的方法

直接将GetCount 写成静态成员函数(特点:没有this指针)，这样就不用每次调用函数都要专门去新建一个对象了。那么静态成员函数该怎么调用呢？

类名 + 域作用限定符

cout<<A::GetCount()<<endl;

注意：由于没有this指针，静态成员函数无法访问其它非静态成员变量 

using namespace std;

class A
{
public:
	A(){++count;}
	A(const A& t){++count;}
	~A(){}
	static int GetCount() 
	{ return count; }
private:
	static int count;//类里面声明

};
//类外面定义
int A::count = 0;
A func()
{
	A aa;
	return aa;
}

int main()
{
	A aa;
	func();
	cout <<A::GetCount()<< endl;
	return 0;
}

 总结：

静态成员函数和静态成员变量，本质是受限制的全局变量和全局函数，只不过专属这一个类

受类和访问限定符的限制

2.2特性

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

2. 静态成员变量必须在类外定义，定义时不添加static关键字，类中只是声明

3. 类静态成员可用 类名::静态成员 或者 对象.静态成员 来访问

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

5. 静态成员也是类的成员，受public、protected、private 访问限定符的限制

3、友元

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

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

3.1友元函数

之前我们写全局函数，不得已将类的成员变量的限定访问操作符改成了公有(public)

而友元函数可以突破封装，就算类的成员变量是私有(private)，友元函数也可以直接访问

这样就不用该限定访问操作符

它是定义在类外的普通函数，不属于任何类，但需要在类内声明，声明时要加friend关键字

using namespace std;
class Date
{
	//友元声明
	friend ostream& operator<<(ostream& _cout,const Date& d);
	friend istream& operator<<(istream& _cin, const Date& d);
public:
	Date(int year, int month, int day)
		: _year(year)
		, _month(month)
		, _day(day)
	{}
private:
	int _year;
	int _month;
	int _day;
};

3.2友元类

假设有个类Date要经常访问另一个类Time的私有，那么可以加一个友元类的声明

friend class Date

声明日期类为时间类的友元类，则在日期类中就直接访问Time类中的私有成员变量

class Time
{
	friend class Date;
public:
	Time(int hour, int minute, int second)
		: _hour(hour)
		, _minute(minute)
		, _second(second)
	{}

private:
	int _hour;
	int _minute;
	int _second;
};

注意:友元关系是单向的，不具有交换性

友元关系不能传递

比如：C是B的友元，B是A的友元，但是C和A没有友元关系

4、内部类

概念：如果一个类定义在另一个类的内部，这个内部类就叫做内部类。

内部类是一个独立的类，它不属于外部类，更不能通过外部类的对象去访问内部类的成员。

外部类对内部类没有任何优越的访问权限

注意：内部类就是外部类的友元类，参造友元类的定义，内部类可以通过外部类的对象参数来访

问外部类中的所有成员。但是外部类不是内部类的友元。

举例：

using namespace std;
class A
{
public:
	class B  
	{
	public:
		int _b;
	};

private:
	int _a;

};
int main()
{
	cout << sizeof(A) << endl;
	return 0;
}

结果是4，也就是不计算B的成员变量

B天生就是A的友元，B可以访问A，但是A不能访问B

A和B的关系: B是一个普通类，只是受A的类域和访问限定符的限制，使用B需要搜A的域

特性：

1. 内部类可以定义在外部类的public、protected、private都是可以的。

2. 注意内部类可以直接访问外部类中的static成员，不需要外部类的对象/类名。

3. sizeof(外部类)=外部类，和内部类没有任何关系。

5、拷贝对象时的一些编译器优化

在传参和传返回值的过程中，一般编译器会做一些优化，减少对象的拷贝

using namespace std;
class A
{
public:
	A(int a = 0)
		:_a(a)
	{
		cout << "A(int a)" << endl;
	}
	A(const A& aa)
		:_a(aa._a)
	{
		cout << "A(const A& aa)" << endl;
	}
		A& operator=(const A& aa)
	{
		cout << "A& operator=(const A& aa)" << endl;
		if (this != &aa)
		{
			_a = aa._a;
		}
		return *this;
	}
	~A()
	{
		cout << "~A()" << endl;
	}
private:
	int _a;

};
A f2()
{
	A aa;
	return aa;
}
int main()
{
	A aa1(1);//构造
	A aa2(aa1);//拷贝构造
	A aa3 = aa1;//拷贝构造
	return 0;
}

拷贝对象时的一些编译器优化

A aa1 = 1;

先用1构造一个临时对象；再用临时对象拷贝构造aa1

优化：同一个表达式中，连续的构造+构造 or 构造+拷贝构造  or 拷贝构造+拷贝构造 会合二为一

构造 + 构造 => 构造  

构造 + 拷贝构造 => 构造

拷贝构造 + 拷贝构造 => 拷贝构造

A func2()
{
	A aa;
	return aa;
}



int main()
{
	A aa(1);
	A ret = func2();//连续拷贝构造会优化
	func2();//不优化
	return 0;
}