• 【C++详解】——类和对象（下）（初始化列表、static成员、友元、匿名对象）

    📖 前言：本期将深度剖析封装细节&特性

    目录

    🕒 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
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14

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

    🕘 1.2 初始化列表

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

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

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17

    我们发现，通过初始化列表，就可以将内部成员进行初始化，但问题来了，构造函数不也可以给它们赋初值吗？

    事实上构造函数的确可以给上述类中的内部成员赋值，但是算不上是初始化，只能说是给其一个值让其有相应的内容，即构造函数可以多次给其赋值。然而，有一些类型的成员变量只能初始化一次且不能被再次修改，出现这样的情况就不能用构造函数赋值了，而是要用初始化列表进行初始化。

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

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

      • 引用成员变量
      • const成员变量
      • 自定义类型成员（且该类没有默认构造函数时）
    class A
{
public:
	A(int a)
		:_a(a)
	{}
private:
	int _a;
};

class B
{
public:

	B()
		:_n(10)
		, _m(2)
		, _aa(11)		// A没有默认构造的解决方案
	{
		// _n = 10;
	}

private:
	// const成员
	const int _n;  // 声明
	int _m = 1;    // 缺省值

	A _aa;
};

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27
    • 28
    • 29

    1. 尽量使用初始化列表初始化，每个成员都要走初始化列表，对于自定义类型成员变量，就算不显示在初始化列表写，也会走。
      如果在初始化列表显示写了就用显示写的初始化
      如果没有在初始化列表显示初始化：
      1、内置类型，有缺省值用缺省值，没有就用随机值
      2、自定义类型，调用默认它的默认构造函数，如果没有默认构造就报错

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

    3. 初始化列表可以与构造函数混用

    4. 一个类尽量提供默认构造（推荐提供全缺省）

    🕘 1.3 explicit关键字

    在提到explicit关键字的功能之前，我们首先要了解到什么是隐式类型转换

    class Date
{
public:
	Date(int year)
		:_year(year)
	{}
	void Print()
	{
		cout << _year << endl;
	}
private:
	int _year;
};

int main()
{
	Date d1(2022);	
	Date d2 = 2022;	// 本来是构造+拷贝构造，现在编译器优化后是直接构造
	d1.Print();		// 输出2022
	d2.Print();		// 输出2022
	const Date& d5 = 2022;		// 正常编译运行，临时变量具有常性

    Date d3(d1);//d3和d4都是拷贝构造
    Date d4 = d1;
	return 0;
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26

    通过运行结果得知，给d1和d2的初始化的结果是一样的。对于d1我们不稀奇，因为是利用了初始化列表进行了初始化；而对于d2，却将整形变量赋值给了Date类，这并不是像d3和d4那样的直接拷贝构造，这就涉及到了隐式类型转换：

    这个临时变量也是Date类，也就是说，我们先构造了一个临时变量，再将这个临时变量拷贝构造给了d2。

    就像你要夹汤圆，但是筷子功不好，直接夹夹不动，于是用勺子先舀到你碗里，再用筷子夹到嘴里。

    如果不想让隐式类型转换发生怎么办呢？

    class Date
{
public:
	explicit Date(int year)		// 加个explicit就好了
		:_year(year)
	{}
......
int main()
{
	Date d1(2022);	
	Date d2 = 2022;				// 报错

	const Date& d5 = 2022;		// 报错
......

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14

    这样上述的转换都失效了，无法编译通过。那这功能有什么用呢？
    关于这方面知识以后再介绍，在这里只需要知道：explicit修饰的单参数构造函数不支持隐式类型转换。

    对于单参数构造的explicit来说，C++98就已经支持，但对于多参数构造的explicit来说，直到C++11才支持。C++11是如何进行支持的呢？

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

int main()
{
	Date d1 = { 2022,11,1 };
	// 等价于
	Date d2(2022, 11, 1);

	const Date& d3 = { 2022,11,1 };
	d1.Print();
	d2.Print();
	d3.Print();
	return 0;
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27
    • 28
    • 29
    • 30

    即与单参数相比，多参数可以像d1、d3一样进行初始化，并且通过explicit修饰之后一样不支持隐式类型转换。

    🕒 2. static成员

    🕘 2.1 引入问题：统计创建对象的数量

    对于这个问题，我们知道，拷贝构造和构造函数二者都会产生新的对象，比如给函数参数拷贝，返回值拷贝等。演示过程如下：

    int N = 0;
class A
{
public:
	A(int a = 0)	//构造
		:_a(a)		//初始化列表
	{
		++N;
	}
	A(const A& aa)	//拷贝构造
		:_a(aa._a)	//初始化列表
	{
		++N;
	}

private:
	int _a;
};

void F1(A aa)
{}

A F2()
{
	A aa;	// 构造
	return aa;	// 拷贝构造
}

void F3(A& aa)
{}			// 引用不需要构造

int main()	//注意创建对象时的序号：1、2、3、4、5、6
{
	A aa1(1);   // 1
	A aa2 = 2;  // 2

	A aa3 = aa1;// 3 拷贝构造
	cout << N << endl;	// 输出3

	F1(aa1); // 4	传值传参调用拷贝构造
	cout << N << endl;	// 输出4
	F2(); // 5  构造＋拷贝构造
	cout << N << endl;	// 输出6
	F3(aa1);// 6
	cout << N << endl;	// 输出6
	return 0;
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27
    • 28
    • 29
    • 30
    • 31
    • 32
    • 33
    • 34
    • 35
    • 36
    • 37
    • 38
    • 39
    • 40
    • 41
    • 42
    • 43
    • 44
    • 45
    • 46
    • 47

    🕘 2.2 引入static

    对于N这个全局变量来说，是容易被其他地方修改的，因此N是不安全的，这时就需要static进行修饰，并将其放在类中。

    int A::N = 0;	// 定义初始化
class A
{
public:
......
private:
	int _a;
	static int N;	// 声明 注意：这里不能给缺省值定义
};
......

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10

    类里面的static：作用域受类域限制，事实上与其内部的成员函数一样都是公用的，即类的每个对象共享，而生命周期是全局的。因此我们输出时可以通过已经存在的任何一个对象进行访问。

    🕘 2.3 static修饰成员函数

    static修饰成员函数，被称为静态成员函数，在上述例子中，我们不想创建对象，但是却想访问N，就可以通过这种方式。

    对于静态函数来说，其内部就不存在隐藏的this指针，因此可见静态成员函数也不需要依靠对象访问，直接通过限定域就可以直接进行访问：

    class A
{
public:
	A(int a = 0)	//构造
		:_a(a)		//初始化列表
	{
		++N;
	}
	A(const A& aa)	//拷贝构造
		:_a(aa._a)	//初始化列表
	{
		++N;
	}

	static int GetN()	// 没有this指针，只能访问静态成员
	{
		return N;
	}

private:
	int _a;
	static int N;	// 声明
};

int A::N = 0;		// 定义初始化

void F1(A aa)
{}

A F2()
{
	A aa;	// 构造
	return aa;	// 拷贝构造
}

void F3(A& aa)
{}			// 引用不需要构造

int main()	//注意创建对象时的序号：1、2、3、4、5、6
{
	A aa1(1);   // 1
	A aa2 = 2;  // 2

	A aa3 = aa1;// 3 拷贝构造
	cout << A::GetN() << endl;	// 输出3

	F1(aa1); // 4	传值传参调用拷贝构造
	cout << A::GetN() << endl;	// 输出4
	F2(); // 5  构造＋拷贝构造
	cout << A::GetN() << endl;	// 输出6
	F3(aa1);// 6
	cout << A::GetN() << endl;	// 输出6
	return 0;
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27
    • 28
    • 29
    • 30
    • 31
    • 32
    • 33
    • 34
    • 35
    • 36
    • 37
    • 38
    • 39
    • 40
    • 41
    • 42
    • 43
    • 44
    • 45
    • 46
    • 47
    • 48
    • 49
    • 50
    • 51
    • 52
    • 53
    • 54

    这样就可以解决直接访问N的问题了。

    🕘 2.4 static特性总结

    1. 静态成员为所有类对象所共享，不属于某个具体的对象，存放在静态区
    2. 静态成员变量必须在类外定义，定义时不添加static关键字，类中只是声明
    3. 类静态成员即可用 类名::静态成员 或者 对象.静态成员 来访问
    4. 静态成员函数没有隐藏的this指针，不能访问任何非静态成员
    5. 静态成员也是类的成员，受public、protected、private 访问限定符的限制

    【问题】

    • 静态成员函数可以调用非静态成员函数吗？
    • 非静态成员函数可以调用类的静态成员函数吗？

    答：和权限的放大缩小相同，因此1可以，2不可以。

    练习🔎 JZ64 求1+2+3+…+n

    class Sum
{
public:
    Sum()
    {
        _ret += _i;
        ++_i;
    }

    static int GetRet()
    {
        return _ret;
    }

private:
    static int _i;
    static int _ret;
};

int Sum::_i = 1;
int Sum:: _ret = 0;

class Solution 
{
public:
    int Sum_Solution(int n)
    {
        Sum arr[n]; //调用N次构造函数
        return Sum::GetRet();
    }
};

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27
    • 28
    • 29
    • 30
    • 31

    🕒 3. 友元

    上一节在流提取和流插入的重载中提到了友元，这里就梳理一下相关概念

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

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

    🕘 3.1 友元函数

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

    说明：

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

    🕘 3.2 友元类

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

    • 友元关系是单向的，不具有交换性。
      比如下面Time类和Date类，在Time类中声明Date类为其友元类，那么可以在Date类中直接访问Time类的私有成员变量，但想在Time类中访问Date类中私有的成员变量则不行。
    • 友元关系不能传递：如果C是B的友元， B是A的友元，则不能说明C时A的友元。
    • 友元关系不能继承。（在后续C++继承中将会介绍）
    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
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27
    • 28
    • 29
    • 30
    • 31
    • 32
    • 33
    • 34
    • 35

    🕒 4. 内部类（了解）

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

    特性：

    • 内部类可以定义在外部类的public、protected、private都是可以的。
    • 注意内部类可以直接访问外部类中的static成员，不需要外部类的对象/类名。
    • sizeof(外部类)=外部类，和内部类没有任何关系。相当于两个独立的类，唯一的区别是B类的访问受A的类域和访问限定符的限制
    class A
{
private:
    int _a;
public:
    class B	// B天生就是A的友元，B能访问A。A不能访问B
    {
        int _b;
    };
};

// 等价于
class A
{
private:
    int _a;
public:
};

class B
{
    int _b;
};

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

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27
    • 28
    • 29

    练习的优化🔎 JZ64 求1+2+3+…+n

    class Solution 
{
public:
    class Sum
    {
    public:
        Sum()
        {
            _ret += _i;
            ++_i;
        }
    };

    int Sum_Solution(int n)
    {
        Sum arr[n]; //调用N次构造函数
        return _ret;
    }

private:
    static int _i;
    static int _ret;
};

int Solution::_i = 1;
int Solution:: _ret = 0;

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26

    🕒 5. 匿名对象

    class A
{
public:
	A(int a = 0)
		:_a(a)
	{
		cout << "A(int a)" << endl;

	}
	~A()
	{
		cout << "~A()" << endl;
	}
private:
	int _a;
};
class Solution {
public:
	int Sum_Solution(int n) {
		//...
		return n;
	}
};
int main()
{
	// 有名对象 -- 生命周期是局部域
	A aa0;
	A aa1 = 1;
	A aa2(2);
	//A aa2();	// 不能像这么定义对象，因为编译器无法识别这是一个函数声明，还是对象定义
	
	// 匿名对象 -- 生命周期是当前这一行
	A();
	A(3);
	
	//Solution so;
	//so.Sum_Solution(10);
	
	//直接为了一个方法就创建一个对象是有点多余的，因此引用下面的一次性使用的匿名对象。
	// 匿名对象在这样场景下就很好用，当然还有一些其他使用场景，这个我们以后遇到了再说
	Solution().Sum_Solution(10);
	return 0;
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27
    • 28
    • 29
    • 30
    • 31
    • 32
    • 33
    • 34
    • 35
    • 36
    • 37
    • 38
    • 39
    • 40
    • 41
    • 42
    • 43

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

    在传参和传返回值的过程中，一般编译器会做一些优化，减少对象的拷贝，这个在一些场景下还是非常有用的。

    注：内置类型没有构造和拷贝构造，因此不考虑内置类型的优化。

    对于编译器的自动优化，下面将对于优化的场景进行展示：

    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;
};

void f1(A aa)
{}

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

A f3()
{
	/*A aa(10);
	return aa;*/

	return A(10);
}

// 《深度探索C++对象模型》中的知识

int main()
{
	// 优化场景1
	//A aa1 = 1;  // A tmp(1) + A aa1(tmp) -> 优化 A aa1(1)

	// 优化场景2
	//A aa1(1); // 优化前
	//f1(aa1);

	//f1(A(1));  // 构造 + 拷贝构造  -> 优化 构造   优化后
	//f1(1);  // 构造 + 拷贝构造  -> 优化 构造      优化后
    
    // 优化场景3
	// f2();	  // 构造+拷贝构造
	//A ret = f2(); // 构造+拷贝构造+拷贝构造 ->优化 构造+拷贝构造
    
    // 优化场景4：
	/*A ret;   优化前
	ret = f2();*/
    
    
	A ret = f3();  //  构造+拷贝构造+拷贝构造 -> 优化 -> 构造
	// 这里利用了所有的优化效果，即通过返回值直接赋值减少了函数返回时临时变量的拷贝，通过匿名对象将创建对象的临时拷贝删去。

	return 0;
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27
    • 28
    • 29
    • 30
    • 31
    • 32
    • 33
    • 34
    • 35
    • 36
    • 37
    • 38
    • 39
    • 40
    • 41
    • 42
    • 43
    • 44
    • 45
    • 46
    • 47
    • 48
    • 49
    • 50
    • 51
    • 52
    • 53
    • 54
    • 55
    • 56
    • 57
    • 58
    • 59
    • 60
    • 61
    • 62
    • 63
    • 64
    • 65
    • 66
    • 67
    • 68
    • 69
    • 70
    • 71
    • 72
    • 73
    • 74
    • 75
    • 76
    • 77
    • 78
    • 79
    • 80
    • 81

    OK，以上就是本期知识点“类和对象（下）”的知识啦~~ ，感谢友友们的阅读。后续还会继续更新，欢迎持续关注哟📌~
    💫如果有错误❌，欢迎批评指正呀👀~让我们一起相互进步🚀
    🎉如果觉得收获满满，可以点点赞👍支持一下哟~

  • 相关阅读:
    【背包九讲——多重背包问题】
    《Linux驱动：DMA直接内存访问》
    C++ 内存模型 write_x_read_y 试例构造
    华为路由器多WAN口设置负载均衡
    apache是什么
    C语言字符函数和字符串函数详解
    uniapp 短信监听（验证码）插件 Ba-Sms
    【Github】 Github修改仓库的基本信息
    NFS网络文件系统
    爱创科技携手源石酒庄，助力酒企走出窜货售假“沼泽”
  • 原文地址：https://blog.csdn.net/HinsCoder/article/details/127280471