C++类和对象(下)——初始化列表、static成员和友元

以你之姓@ 2022-11-06 04:58 202阅读 0赞

### C++类和对象——初始化列表、static成员和友元 ###

*  一、再谈构造函数
 *   *  1.1 构造函数整体赋值
     *  1.2 初始化列表
     *   *  <1>为什么有初始化列表？
         *  <2> 如何使用初始化列表
         *  <3> 成员变量在类中声明次序就是其在初始化列表中的初始化顺序，与其在初始化列表中的先后次序无关
     *  1.3 explicit关键字
     *   *  <1> 匿名对象
         *  <2> 为什么有explicit关键字？
         *  <3> 如何使用explicit关键字？
 *  二、static成员
 *   *  2.1 概念
     *  2.2 特性
     *   *  <1> 静态成员为所有类对象所共享，不属于某个具体的实例
         *  <2> 静态成员变量必须在类外定义，定义时不添加static关键字
         *  <3> 类静态成员即可用类名::静态成员或者对象.静态成员来访问
         *  <4> 静态成员函数没有隐藏的this指针，不能访问任何非静态成员
         *  <5>静态成员和类的普通成员一样，也有public、protected、private3种访问级别，也可以具有返回值
         *   *  Q1: 静态成员函数可以调用非静态成员函数吗？
             *  Q2：非静态成员函数可以调用类的静态成员函数吗？
 *  三、C++11的成员初始化新玩法
 *   *  3.1 为什么？
     *  3.2 怎么用？
 *  四、友元
 *   *  4.1 友元函数
     *  4.2 友元类
 *  五、内部类

关于C++类和对象的学习  
[C++类和对象(上)——类的基本概念、类的限定符及封装和类成员函数的this指针][C_this]  
[C++类和对象(中)——类的6个默认成员函数(构造、析构、拷贝构造、赋值运算符重载)][C_6]  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQwMDc2MDIy_size_16_color_FFFFFF_t_70_pic_center]

# 一、再谈构造函数 #

## 1.1 构造函数整体赋值 ##

在创建对象时，编译器通过调用构造函数，给对象中各个成员变量一个合适的初始值。例如我们之前创建的Date类

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

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

## 1.2 初始化列表 ##

### <1>为什么有初始化列表？ ###

对于我们定义的日期类，当类中出现以下成员时，如果只用构造函数则无法完成变量的初始化了，以下的成员变量需要在定义的时候就需要初始化

*  **引用成员变量**
 *  **const成员变量**
 *  **自定义类型的成员变量**

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQwMDc2MDIy_size_16_color_FFFFFF_t_70]  
其次对于自定义的类成员变量，不使用初始化列表会调用多次构造函数  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQwMDc2MDIy_size_16_color_FFFFFF_t_70 1]

### <2> 如何使用初始化列表 ###

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

//1.2.2
    class Time
    {
        
    public:
    	Time(int hour = 1, int minute=1,int second = 1)
    		:_hour(hour)
    		,_minute(minute)
    		,_second(second)
    	{
        
    		cout << "Time(int hour = 1, int minute=1,int second = 1)" << endl;
    	}
    private:
    	int _hour;
    	int _minute;
    	int _second;
    };
    
    class Date
    {
        
    public:
    	//初始化列表写法
    	Date(int year=1900, int month=1, int day=1,int hour=1,int minute=1,int second=1)
    		:_year(year)
    		,_month(month)
    		,_day(day)
    		,_n(10)
    		,_ref(day)
    		,_t(hour,minute,second)
    	{
        
    		cout << "Date(int year, int month, int day,int hour,int minute,int second)" << endl;
    
    	}
    
    private:
    	int _year;
    	int _month;
    	int _day;
    
    	//定义的时候需要初始化
    	int& _ref;	//引用
    	const int _n; //const成员变量
    	Time _t;	//自定义类型的成员变量
    };
    
    void Test2()
    {
        
    	Date d1(2021,3,9,2,2,2);
    }

结果![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQwMDc2MDIy_size_16_color_FFFFFF_t_70 2]

### <3> 成员变量在类中声明次序就是其在初始化列表中的初始化顺序，与其在初始化列表中的先后次序无关 ###

如下代码的运行结果是什么？

//1.2.3
    class A
    {
        
    public:
    	A(int a)
    		:_a1(a)
    		, _a2(_a1)
    	{
        }
    	void Print() {
        
    		cout << _a1 << " " << _a2 << endl;
    	}
    private:
    	int _a2;
    	int _a1;
    };
    
    void Test2()
    {
        
    	A aa(1);
    	aa.Print();
    }

结果

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQwMDc2MDIy_size_16_color_FFFFFF_t_70 3]

## 1.3 explicit关键字 ##

### <1> 匿名对象 ###

匿名对象顾名思义就是没有名字，其作用域只在一行中有效，例如下面的代码

//1.3.1
    class B
    {
        
    public:
    	B(int b = 0)
    		:_b(b)
    	{
        
    		cout << "B(int b = 0)" << endl;
    	}
    
    	//析构函数
    	~B()
    	{
        
    		cout << "~B()" << endl;
    	}
    private:
    	int _b;
    };
    
    int main()
    {
        
    	B bb(10);	//生命周期在main函数域
    	B(2);	//匿名对象生命周期在这一行
    	return 0;
    }

![在这里插入图片描述][20210309170043403.png]  
![在这里插入图片描述][20210309170135185.png]

### <2> 为什么有explicit关键字？ ###

对于c++来说，构造函数不仅可以构造与初始化对象，**对于单个参数的构造函数，还具有类型转换的作用**。

当我们定义一个类进行初始化时，如果我们采取下面这种定义方式，**编译器会自动生成一个匿名对象，然后用匿名对象对cc对象进行拷贝构造**。

//1.3.2
    class C 
    {
        
    public:
    	C(int c)
    		:_c(c)
    	{
        
    		cout << "C()" << endl;
    	}
    
    private:
    	int _c;
    };
    
    int main()
    {
        
    	C cc(2);
    	cc = 8;	//编译器会自动生成一个匿名对象，然后用匿名对象对cc对象进行拷贝构造
    	return 0;
    }

### <3> 如何使用explicit关键字？ ###

**用explicit修饰构造函数，将会禁止单参构造函数的隐式转换**。

//1.3.3
    class C 
    {
        
    public:
    	explicit C(int c)
    		:_c(c)
    	{
        
    		cout << "explicit C(int c)" << endl;
    	}
    
    private:
    	int _c;
    };
    
    int main()
    {
        
    	C cc(2);
    	cc = 8;	//编译器会自动生成一个匿名对象，然后用匿名对象对cc对象进行拷贝构造
    	return 0;
    }

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQwMDc2MDIy_size_16_color_FFFFFF_t_70 4]

# 二、static成员 #

## 2.1 概念 ##

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

面试题：实现一个类，计算程序中创建出了多少个类对象？这个时候我们就可以使用static成员变量和static成员函数来实现

//2.1 实现一个类，计算程序中创建出了多少个类对象。
    class A
    {
        
    public:
    	//构造函数
    	A()
    	{
        
    		++_scount;
    	}
    	//拷贝构造函数
    	A(const A& a)
    	{
        
    		++_scount;
    	}
    	
    	static int GetAcount()
    	{
        
    		return _scount;
    	}
    private:
    	static int _scount;
    };
    
    //初始化在类外
    int A::_scount = 0;
    
    void TestA()
    {
        
    	cout << A::GetAcount() << endl;
    	A aa;
    	A bb;
    	A cc(bb);
    	cout << A::GetAcount() << endl;
    }

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQwMDc2MDIy_size_16_color_FFFFFF_t_70 5]

## 2.2 特性 ##

### <1> 静态成员为所有类对象所共享，不属于某个具体的实例 ###

### <2> 静态成员变量必须在类外定义，定义时不添加static关键字 ###

![在这里插入图片描述][20210310110452274.png]

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

![在这里插入图片描述][20210310110824391.png]

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

![在这里插入图片描述][20210310110530312.png]

### <5>静态成员和类的普通成员一样，也有public、protected、private3种访问级别，也可以具有返回值 ###

#### Q1: 静态成员函数可以调用非静态成员函数吗？ ####

不可以，因为静态成员函数没有隐藏的this指针

#### Q2：非静态成员函数可以调用类的静态成员函数吗？ ####

可以，因为非静态成员函数含有this指针，指定了静态成员函数的类域  
![在这里插入图片描述][20210310111246970.png]

# 三、C++11的成员初始化新玩法 #

## 3.1 为什么？ ##

对于C++98而言，类内自定义的内置类型，编译器会进行初始化，而其他内置类型不会，因此出现则会中初始化方法。  
具体查看这篇博客的2.2.7节内容  
[C++类和对象(中)——类的6个默认成员函数(构造、析构、拷贝构造、赋值运算符重载)][C_6]  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQwMDc2MDIy_size_16_color_FFFFFF_t_70 6]

## 3.2 怎么用？ ##

C++11支持非静态成员变量在声明时进行初始化赋值，但是要注意**这里不是初始化，这里是给声明的成员变量缺省值**。

//3.C++11的成员初始化新玩法
    class B
    {
        
    public:
    	B(int b = 0)
    		:_b(b)
    	{
        }
    	int _b;
    };
    class A
    {
        
    public:
    	void Print()
    	{
        
    		cout << a << endl;
    		cout << b._b << endl;
    		cout << p << endl;
    	}
    private:
    	// 非静态成员变量，可以在成员声明时给缺省值。
    	int a = 10;
    	B b = 20;
    	int* p = (int*)malloc(4);
    	//静态成员不可以
    	static int n;
    };
    int A::n = 10;
    
    int main()
    {
        
    	A a;
    	a.Print();
    	return 0;
    }

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQwMDc2MDIy_size_16_color_FFFFFF_t_70 7]

# 四、友元 #

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

## 4.1 友元函数 ##

问题：现在我们尝试去重载operator<<，然后发现我们没办法将operator<<重载成成员函数。**因为cout的输出流对象和隐含的this指针在抢占第一个参数的位置**。this指针默认是第一个参数也就是左操作数了。但是实际使用中cout需要是第一个形参对象，才能正常使用。所以我们要将operator<<重载成全局函数。但是这样的话，又会导致类外没办法访问成员，那么这里就需要友元来解决。operator>>同理

//4.1
    class Date
    {
        
    public:
    	Date(int year, int month, int day)
    		: _year(year)
    		, _month(month)
    		, _day(day)
    	{
        }
    	ostream& operator<<(ostream& _cout)
    	{
        
    		_cout << _year << "-" << _month << "-" << _day;
    		return _cout;
    	}
    private:
    	int _year;
    	int _month;
    	int _day;
    };
    int main()
    {
        
    	Date d(2017, 12, 24);
    	d << cout;
    	return 0;
    }

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQwMDc2MDIy_size_16_color_FFFFFF_t_70 8]  
友元函数可以**直接访问类的私有成员**，它是**定义在类外部的普通函**数，不属于任何类，但需要在类的内部声明，**声明时需要加friend关键字**。

//4.1
    class Date
    {
        
    friend ostream& operator<<(ostream& _cout, const Date& d);
    friend istream& operator >> (istream& _cin, Date& d);
    
    public:
    	Date(int year, int month, int day)
    		: _year(year)
    		, _month(month)
    		, _day(day)
    	{
        }
    	ostream& operator<<(ostream& _cout)
    	{
        
    		_cout << _year << "-" << _month << "-" << _day;
    		return _cout;
    	}
    private:
    	int _year;
    	int _month;
    	int _day;
    };
    
    ostream& operator<<(ostream& _cout, const Date& d)
    {
        
    	_cout << d._year << "-" << d._month << "-" << d._day << endl;
    	return _cout;
    }
    
    istream& operator >> (istream& _cin, Date& d)
    {
        
    	_cin >> d._year >> d._month >> d._day;
    
    	return _cin;
    }
    
    int main()
    {
        
    	Date d(2017, 12, 24);
    	cout<<d;
    	//Date d1;
    	cin >> d;
    	cout << d;
    	return 0;
    }

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQwMDc2MDIy_size_16_color_FFFFFF_t_70 9]

## 4.2 友元类 ##

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

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

class Date; // 前置声明
    class Time
    {
        
    	friend class Date; // 声明日期类为时间类的友元类，则在日期类中就直接访问Time类中的私有成员变量
    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.  内部类可以定义在外部类的public、protected、private都是可以的。
2.  注意内部类可以直接访问外部类中的static、枚举成员，不需要外部类的对象/类名。
3.  sizeof(外部类)=外部类，和内部类没有任何关系

class A
    {
        
    private:
    	static int k;
    	int h;
    public:
    	class B
    	{
        
    	public:
    		void foo(const A& a)
    		{
        
    			cout << k << endl;//OK
    			cout << a.h << endl;//OK
    		}
    	};
    };
    int A::k = 1;
    int main()
    {
        
    	A::B b;
    	b.foo(A());
    	return 0;
    }

[C_this]: https://blog.csdn.net/qq_40076022/article/details/113999669
[C_6]: https://blog.csdn.net/qq_40076022/article/details/114287079
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQwMDc2MDIy_size_16_color_FFFFFF_t_70_pic_center]: /images/20221023/8f1f8787be794e34a50c879f17ad3dc7.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQwMDc2MDIy_size_16_color_FFFFFF_t_70]: /images/20221023/2da8d93eb24e47f09d45b5f597c79488.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQwMDc2MDIy_size_16_color_FFFFFF_t_70 1]: /images/20221023/be3d1b8daabb4ac0b42fa3397e36e2ce.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQwMDc2MDIy_size_16_color_FFFFFF_t_70 2]: /images/20221023/8b93253ab38f4ab48d196aeee8c5a7f1.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQwMDc2MDIy_size_16_color_FFFFFF_t_70 3]: /images/20221023/0e4f41174bed48a6a1470c698566404d.png
[20210309170043403.png]: /images/20221023/ff99b99dd6c34c0a9fcab089dacfbb7e.png
[20210309170135185.png]: /images/20221023/1ddb31b6e8504f71b2caae4e2397fd56.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQwMDc2MDIy_size_16_color_FFFFFF_t_70 4]: /images/20221023/c6364dcceadd4002a3e5c83de146326f.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQwMDc2MDIy_size_16_color_FFFFFF_t_70 5]: /images/20221023/80c6e659f3e44476ab3e065427b0fda8.png
[20210310110452274.png]: /images/20221023/3d3c9f4721894fd1ae3e15bf1ead6ee9.png
[20210310110824391.png]: /images/20221023/3ea67876f81c4f8fa5e10fe97d1dc186.png
[20210310110530312.png]: /images/20221023/13a096c427f74125bc0061d3b8b4fe24.png
[20210310111246970.png]: /images/20221023/f59a0d1a793f49dca93d83e8bf46de8f.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQwMDc2MDIy_size_16_color_FFFFFF_t_70 6]: /images/20221023/5c9f8d5be9044753a4935d2fe7f03547.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQwMDc2MDIy_size_16_color_FFFFFF_t_70 7]: /images/20221023/ce65415cf5e74dd2884b5391e4a1b79b.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQwMDc2MDIy_size_16_color_FFFFFF_t_70 8]: /images/20221023/a8084a0c54d247b7a5fbf7277e627504.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQwMDc2MDIy_size_16_color_FFFFFF_t_70 9]: /images/20221023/aa804010941b4005b4fefd2dffe618fb.png