C++ ----类与对象（下）

Posted 2021-06-24 L_add

类与对象

• • 深入构造函数
  • • 构造函数体赋值
    • 初始化列表
    • explicit关键字
    • 匿名对象
  • 友元
  • • 友元函数
    • 友元类
  • static成员
  • • 概念
    • 特性
  • 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;
};	

函数调用之后，对象中已经有了一个初始值，但不能称为类对象的初始化，构造函数体中的语句只能将其称作为赋初值，而不是初始化。因为初始化只能初始化一次，而函数构造体内可以多次赋值

初始化列表

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

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

1. 每个成员变量在初始化列表中只能出现一次（只能初始化一次）
2. 类中包含以下成员，必须放在初始化列表位置进行初始化：
   a.引用成员变量
   b.const成员变量
   c.自定义类型成员（该类没有构造函数）

class A
{
public:
	A(int a)
		:_a(a)
	{}
private:
	int _a;
};
class Date
{
public:
	Date(int year = 0, int month = 1, int day = 1)
		:_year(year)
		, _month(month)
		, _n(10)
		, ret(year)
		, _a(1)
	{

		_day = day;
		//_n = 10 //不能在函数体内初始化，必须使用初始化列表初始化
		//ret = year
	}
private://不是定义，是声明，没开空间
	//不需要初始化
	int _year;
	int _month;
	int _day;

	//必须在初始化列表
	//一个对象的单个成员变量在初始化列表是它定义的阶段
	const int _n;
	int& ret;
	A _a;
};

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();
	// 1  随机值
	//建议类中成员变量声明的顺序和初始化列表中出现的顺序保持一致
}

explicit关键字

构造函数不仅可以构造与初始化对象，对于单个参数的构造函数，还可以类型转换

用explicit修饰构造函数，会禁止单参构造函数的隐式类型转换

class A
{
public:
	explicit A(int a)
		:_a(a)
	{}
private:
	int _a;
};
int main()
{
	A aa1(1);
	A aa2 = 2;//单参数的构造函数，支持隐式类型转换
	//先构造一个临时对象 A tmp(2),再拷贝构造 A aa2(tmp)

	//int i = 0;
	//double d = i;//隐式类型转换
	return 0;
}

匿名对象

int main()
{
	A aa1(1);//标准构造函数调用，定义有名对象
	A aa2(2);//隐式类型转换，编译器优化后，也是直接调用构造

	A(3);//构造匿名对象，生命周期只在这一行
	//		A aa4()
	//      aa4.f();
	//匿名：A().f();写起来更简洁
	return 0;
}

友元

友元分为：友元函数和友元类
友元提供了一种突破封装的方式，更加便利，但会增加耦合度，破坏封装。所以友元不宜过多

友元函数

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

class Date
{
	//友元函数的声明
	friend ostream& operator<<(ostream&out,const Date&d1);
	friend istream& operator>> (istream&in, Date&d);
public:
	Date(int year = 0, int month = 1, int day = 1)
	{
		_year = year;
		_month = month;
		_day = day;
	}
private:
	int _year;
	int _month;
	int _day;
};
//cout<<d1
ostream& operator<<(ostream&out,const Date& d)
//void operator<<(Date* this,ostream& out)
{
	out << d._year << "-" << d._month << "-" << d._day << endl;
	return out;

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

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

友元类

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

• 友元的关系是单向的，不具有交换性（eg:D是T的友元类，D可以访问T，T不能访问D）
• 友元关系不能传递

static成员

概念

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

//计算一个程序中A定义出多少个对象
class A
{
public:
	A()
	{
		++_n;
	}
	A(const A& a)//拷贝构造
	{
		++_n;
	}
	int GetP()
	{
		return _n;
	}//想获取私有值，定义共有函数
private:
	//不在构造函数中初始化
	static int _n;//n是存在静态区，属于整个类，也属于类的所有对象
};
//静态成员变量的初始化
//特例，不受访问限定符限制否则没办法定义初始化
int A::_n = 0;
int main()
{
	A a;
	A a1;
	A a2;
	A();
	cout << sizeof(A) << endl;//1
	cout << sizeof(a) << endl;//1
	//cout << A::_n << endl;//共有时
	//cout << a1._n << endl;都可以
	//cout << a2._n << endl;
	//cout << A()._n << endl;
	cout << a1.GetP() << endl;
	cout << A().GetP() << endl;

	return 0;
}

特性

1. 静态成员为所有类对象共享，不属于某个具体的对象，放在静态区
2. 静态成员变量必须再类外定义，定义时不加static关键字
3. 类静态成员即可用类名::静态成员或对象，静态成员来访问
4. 静态成员函数没有隐藏的this指针，不能访问任何非静态成员
5. 静态成员和类的普通成员一样，有3种访问级别，也可以具有返回值

C++11的成员初始化

//C++11
class B
{
public:
	B()
		:_x(0)
	{
		cout << "B()" << endl;
	}
	int _x;

};
class A
{
public:
	A(int a = 1; int*p = nullptr)
		:_a(a)
		, _p(p)
	{}
private:
	//声明-》缺省值
	int _a = 0;
	int* _p = nullptr;
	int* arr = (int*)malloc(sizeof(int)* 5);
	B _b = 6;//拷贝构造+构造	
};
int main()
{
	A aa;//默认构造函数
	return 0;
}

内部类

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

1. 内部类可以定义在外部类的public、private、protected中
2. 内部类可以直接访问外部类中的static、枚举成员、不需要外部类的对象/类名
3. sizeof(外部类)=外部类，和内部类无关

class A
{
public:
	//B叫做A的内部类
	class B//B是A的友元类，B可以访问A
	{
	public:
		B()
			:_x(0)
		{
			cout << "B()" << endl;
		}
		int _x;

	};
	A(int a = 1)
	{}
	
private:
	int _a = 0;
	B _b;	
};