C++ ---- 类和对象(下)-CSDN博客

本文链接：https://blog.csdn.net/weixin_59351791/article/details/130693621

初始化列表

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

初始化列表的语法

Date(int year,int month,int day)
    :_year(year)
    ,_month(month)
    ,_day(day)
{
}

初始化列表的特性

●每个成员变量在初始化列表中只出现一次，且一定会总初始化列表。

●在特殊场景下，必须在初始化列表位置进行初始化，如：引用成员变量，const成员变量，自定义类型成员（没有提供默认构造）

●成员变量在初始化列表中的初始化顺序按照成员变量在类中的声明顺序，与在初始化列表中的顺序无关。

1.对象每个成员真正初始化的位置在初始化列表，无论是否显示的写初始化列表，成员变量都要走初始化列表。

2.如果没有显示的写初始化列表，内置类型有缺省值用缺省值，没有缺省值用的是随机值。自定义类型，调用自己的默认构造，如果没提供默认构造就报错。

class B
{
public:
	B() 
	{
		cout << "B()默认构造调用" << endl;
	}
};
class A
{
public:
	A() {}

	int _a1;
	int _a2;
	B _b;
};

int main()
{
	A a;
	cout << a._a1 << a._a2 << endl;
	return 0;
}

如果B类没有提供默认构造，且没显示的写初始列表，直接报错。假设B类只提供了单参数的构造函数，没有默认构造。

	B(int x)
	{
		cout << "单参数的默认构造" << endl;
	}

自定义类型的成员变量定义的位置是在初始化列表，在B类没提供默认构造，且没显示写初始化列表的情况下，直接报错。

解决办法就是显示的写初始化列表，调用单参的构造函数。

3.当类中包含以下几个成员变量时，必须显示的写初始化列表，在初始化列表位置初始化：

●引用成员变量

class A
{
public:
	A(int x)
	:_ret(x)
	{}
private:
	int& _ret;
};
int main()
{
	A a(10);
	return 0;
}

分析：根据引用的特性，引用在定义的时候必须初始化，但是成员变量在类中的位置是声明，即使给缺省值也是声明，真正定义的位置在初始化列表，所以在引用成员变量的场景中，必须放在初始阿虎列表位置进行初始化。

●const成员变量

class A
{
public:
	A(int x) :_a1(x)
	{}
private:
	const int _a1;
};

int main()
{
	A a(10);
	return 0;
}

const修饰的变量在定义的时候也必须初始化，成员变量真正初始化的位置是初始化列表。

●自定义类型成员（没提供默认构造）

当自定义类型的成员变量没有提供默认构造函数时，用初始化列表显示的初始化：

class A
{
public:
	A(int x)
		:_a1(x)
	{
		cout << "非默认构造" << endl;
	}
private:
	int _a1;
};

class B
{
public:
	B()
		:_aa(100)
	{}
private:
	A _aa;
};
int main()
{
	B bb;
	return 0;
}

4.成员变量在初始化列表中的初始化顺序按照成员变量在类中的声明顺序，与在初始化列表中的顺序无关。

class A
{
public:
	A(int x)
	:_a2(x)
	,_a1(_a2)
	{}
	void Show()
	{
		cout << "_a1:" << _a1 << endl;
		cout << "_a2:" << _a2 << endl;
	}
private:
	int _a1;
	int _a2;
};

int main()
{
	A aa(10);
	aa.Show();
	return 0;
}

通过测试结果发现，在初始化列表中次序靠前的_a2并没有先初始化，而是先初始化了_a1。由此也证实了成员变量在初始化列表中的初始化顺序是按照声明次序来的。

explicit关键字

构造函数的隐式转换

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

class Date
{
public:
	//单参数构造
	Date(int year)
		:_year(year)
	{}
	//可以只传递一个参数的构造
	//Date(int year, int month = 1, int day = 1)
	//	:_year(year)
	//	,_month(month)
	//	,_day(day)
	//{

	//}
private:
	int _year;
	int _month;
	int _day;
};

int main()
{
	//发生了类型转换，构造+拷贝构造(编译器优化后，只有构造)
	Date d1 = 2001;

	return 0;
}

当我们用一个整型变量给日期类对象赋值时，编译器首先会用整型2001构造一个无名的临时对象，在把它拷贝给d1。（要完成的工作本来有构造+拷贝构造，编译器优化后，只有构造）。

const Date& d2 = 2002;

如果用Date& 引用整型，要用const修饰，整型会先构造一临时对象，临时对象具有常性，所以要加const修饰。

explicit的作用

上述的代码，虽然没错，但是在可读性上不是很好，如果你不想让构造函数支持类型转换，只需要用explicit关键字修饰构造函数即可。

class Date
{
public:
	//单参数构造，explicit禁止类型转换
	explicit Date(int year)
		:_year(year)
	{}
private:
	int _year;
	int _month;
	int _day;
};

int main()
{
	//exlicit禁止了类型转换
	Date d1 = 2001;

	return 0;
}

static修饰成员变量和成员函数

●修饰局部变量，更改了局部变量的生命周期，出了作用域依然未被销毁，直到程序结束，生命周期才结束。

●修饰全局变量，使得这个全局变量只能在当前源文件下使用。出了当前文件就没法访问。未使用static修饰，全局变量的作用域是整个工程，其他源文件也可以使用。

●修饰函数，被static修饰只能在当前源文件下使用。

static修饰成员变量

1.被static修饰的成员变量叫做静态成员，被所有对象共享，不属于某个对象，存放在静态区。

class A
{
private:
	static int a;
};

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

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

class A
{
private:
	static int a;
};
int A::a = 1;

3.静态成员不属于某个对象，存放在静态区，该成员变量是被所有对象共享的，如果它是公有的，也可以通过类名：：静态成员访问，或者用对象.的方式！

class A
{
public:
	static int a;
};
int A::a = 1;
int main()
{
	A a1;
	A a2;

	a1.a = 100;
	a2.a = 200;


	cout <<"a1.a " << a1.a << endl;
	cout <<"a2.a " << a2.a << endl;
	cout <<"A::a " << A::a << endl;

	A* ptr = nullptr;
	ptr->a = 1000;
	cout <<"ptr->a " << ptr->a<< endl;

	return 0;
}

上述指针和对象.的方式，实际上的作用也是突破类域，访问到静态成员变量。

static修饰成员函数

1.static修饰的成员函数被称为静态成员函数，静态成员函数没有隐藏的this指针，不能访问任何非静态成员。

class A
{
public:
	static void Fun()
	{
		_a1 += 10;
		_a2 += 20;
	}
private:
	int _a1;
	int _a2;
};

int main()
{
	A aa;
	aa.Fun();
	return 0;
}

2.静态成员函数，可以通过类名：：或者对象.突破类域直接调用。

class A
{
public:
	//静态成员函数没有隐藏的this指针
	static int Get()
	{
		cout << "Get()" << endl;
		
		//静态成员函数不能访问非静态成员变量
		//_a1++;错误写法

		//可以访问静态成员变量
		return _a2;
	}
private:
	int _a1;
	static int _a2;
};
int A::_a2 = 10;

int main()
{
	A aa;
	aa.Get();

	A::Get();
	return 0;
}

3.非静态成员函数可以调用静态成员函数。

class A
{
public:
	static void Fun1()
	{
		cout << "Hello" << endl;
	}
	void Fun2()
	{
		Fun1();
	}
private:
	int _a1;
	int _a2;
};

int main()
{
	A aa;
	aa.Fun2();
	return 0;
}

4.静态成员函数不能调用非静态的成员函数。因为调用非静态的成员函数需要用对象调用，静态成员函数没有this指针。

5.小问题：用上述知识，创建一个静态成员变量，计算程序中创建了多少个对象。

class A
{
public:
	A()
	{
		_count++;
	}
	A(const A& a)
	{
		_count++;
	}
	static int GetCount()
	{
		return _count;
	}
private:
	static int _count;
};

int A::_count = 0;
int main()
{
	cout << A::GetCount() << endl;
	
	A a1,a2,a3;
	A a4(a2);
	
	cout << A::GetCount() << endl;

	return 0;
}

友元

友元是一种突破封装的方式，在一定程度上提供了便利，但是也增加了代码的耦合度，破坏了封装，所以尽量少用。

友元函数

●友元函数是定义在类外的普通函数，不属于任何类。在需要访问的类的内部声明，声明时加friend关键字，就是该类的友元函数。

class Date
{
	friend void Show(const Date& day);
public:
	Date(int year, int month, int day)
		:_year(year)
		, _month(month)
		, _day(day)
	{
	}

private:
	int _year;
	int _month;
	int _day;
};

void Show(const Date& day)
{
	cout << day._year << "/" << day._month << "/" << day._day;
}
int main()
{
	Date d1(2001,10,3);
	Show(d1);

	return 0;
}

上述日期类的代码中，将Show函数定义成了类外的普通函数，并且访问了类中的私有成员变量，只需要在类中加上Show函数的友元声明即可。

●友元函数可以访问类的私有和保护成员，但不是类的成员函数。

	Date d1(2001,10,3);
	d1.Show();

●友元函数不能用const修饰，没有this指针。

void Show(const Date& day)const
{
	cout << day._year << "/" << day._month << "/" << day._day;
}

●友元函数可以在类定义的任何地方声明，不受访问限定符限制

●友元函数的调用和普通函数的调用是一样的。

●在日期类的实现中，对流插入和流提取进行了重载，这个场景就非常适合用友元。因为我们的使用习惯是类似与“cout<<d1”的，而在类中重载流插入和流提取this指针会抢占第一个参数的位置，以至于最后的用法变为了“d1<<cout”,基于这种情况，将这两个重载定义一般写在类外，这时还需要访问类内的私有成员，只需要在类中声明友元就可以了。

class Date
{
	friend ostream& operator<<(ostream& out, Date& d1);
	friend istream& operator>>(istream& in, Date& day);
public:
	Date() {}
	Date(int year, int month, int day)
		:_year(year)
		, _month(month)
		, _day(day)
	{
	}

private:
	int _year;
	int _month;
	int _day;
};

ostream& operator<<(ostream& out, Date& day)
{
	out << day._year << "/" << day._month << "/" << day._day;
	return out;
}
istream& operator>>(istream& in, Date& day)
{
	in >> day._year >> day._month >> day._day;
	return in;
}

int main()
{
	Date d1(2001,10,3);
	cout << d1 << endl;

	Date d2;
	cin >> d2;
	cout << d2 << endl;
	
	return 0;
}

友元类

●友元关系是单向的，A是B的友元，只是单向的友元，A可以访问B类中的私有和保护成员，反过来是B想访问A的私有和保护成员是不可以的。

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

class Date
{
public:
	Date(int year, int month, int day)
		:_year(year)
		, _month(month)
		, _day(day)
	{}
	void TimeInit(int hour, int minute, int second)
	{
		_t._hour = hour;
		_t._minute = minute;
		_t._second = second;
	}

private:
	int _year;
	int _month;
	int _day;
	Time _t;
};

int main()
{
	Date d1(2001,10,3);
	d1.TimeInit(12,59,60);
	return 0;
}

Date声明为Time的友元类后，在Date类中可以访问Time类的私有成员。但是如果TIme要访问Date中的私有成员是不被允许的。

友元关系不能传递，A是B的友元，A是C的友元，但这并不能说明B和C具有友元的关系。

内部类

●概念：在类的内部定义一个类。内部类是一个独立的类，并不属于外部类。所以用外部类的对象不能访问内部类的成员。外部类对内部类没有任何的访问权限。

class A
{
public:
	//内部类可以定义在任意访问限定符下
	class B
	{
	private:
		int _b;
		char _ch;
	};
private:
	int _a1;
	int _a2;
};

●计算外部类的大小，和内部类没有任何关系。

cout << sizeof(A) << endl;

●内部类是外部类的友元，可以访问外部类中的所有成员。

class A
{
public:
	class B
	{
	public:
		void Fun(const A& a)
		{
			cout << "我是A的内部类B，我访问了外部类A的私有成员!" << endl;
			cout << "_a1= " << a._a1 << "  _a2= " << a._a2 << endl;
		}
	};
private:
	int _a1 = 1;
	int _a2 = 2;
};

int main()
{
	A aa;

	A::B bb;
	bb.Fun(aa);
	return 0;
}

●内部类可以直接访问外部类中的static成员，不需要外部类的对象/类名"突破类域"。

class A
{
public:
	//内部类可以定义在任意访问限定符下
	class B
	{
	public:
		void Fun()
		{
			int n = 10;
			while (--n)
			{
				N++;
			}
			cout << N << endl;
		}
	};
private:
	static int N;
};
int A::N = 1;
int main()
{
	A::B bb;
	bb.Fun();
	return 0;
}

如上述代码示例所示，在内部类中可以

class A
{
public:
	void Fun()
	{
		cout << "Fun()" << endl;
	}
};

int main()
{
	A().Fun();
	return 0;
}

直接访问外部类的静态成员。

匿名对象

匿名对象是指没有被命名的临时对象，它们在程序中被创建并使用，但没有被赋予任何变量名或对象名。匿名对象通常用于简化代码，避免创建不必要的对象，或者作为函数返回值。

●匿名对象不用给对象取名字。

class A
{
public:
	void Fun()
	{
		cout << "Fun()" << endl;
	}
};

int main()
{
	A().Fun();
	return 0;
}

如果在后面的代码中都不需要在用到该对象，就可以将其写成匿名对象，如上述代码，可以通过匿名对象调用成员函数。

●匿名对象的声明周期只有一行。

class A
{
public:
	A() 
	{
		cout << "A()调用构造" << endl;
	}

	~A() 
	{
		cout << "~A()调用析构" << endl;
	}

};

int main()
{
	A();

	int a = 10;
	return 0;
}

通过调试可以发现，当22行执行完后，匿名对象就被销毁了，也就是说匿名对象只在当前行有效。如果需要在后续代码中使用该对象，应该将其赋值给一个命名对象。

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

class A
{
public:
	A() 
	{
		cout << "A()调用构造" << endl;
	}

	A(const A& a)
	{
		cout << "A(const A& a)拷贝构造" << endl;
	}
	A& operator=(const A& a)
	{
		cout << "A& operator=(const A& a)赋值重载" << endl;
	}
	~A() 
	{
		cout << "~A()调用析构" << endl;
	}

};

场景1：构造函数的隐式转换

	//场景1：单参数或者只有第一个参数需要传递的构造隐式类型转换
	A aa = 1;

场景2：传值优化

void Fun(A aa)
{
	//...
}

int main()
{
    //场景2:传值优化
	Fun(A(1));
	return 0;
}

优化前：构造+拷贝构造。优化后：构造。

场景3：返回值

A Fun()
{
	A aa(10);
	return aa;
}

int main()
{

	A ret = Fun();
	return 0;
}

优化前：构造+拷贝构造+拷贝构造。优化后：构造

场景4：返回匿名对象。

A Fun()

	return A(20);
}

int main()
{
	A ret = Fun();
	return 0;
}

优化前：构造+拷贝构造+拷贝构造。优化后：构造。