本章将分享C++中类和对象最后章节“深入探索类和对象：初始化列表及其static成员与友元”，希望通过这几篇关于类和对象文章可以帮助大家更好地理解类和对象的相关知识。

?个人主页：是店小二呀
?C语言笔记专栏：C语言笔记
?C++笔记专栏： C++笔记
?初阶数据结构笔记专栏： 初阶数据结构笔记
?Linux笔记专栏： Linux笔记

?喜欢的诗句:无人扶我青云志 我自踏雪至山巅

一、构造函数体赋值

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

class Data
{
public:
	Data()//错误的
	{	
		_n = 10;//左值不可修改
		_a = 1;
		_a = 10;
	}
private:
	int _a;
	const int _n;
};

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

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

二、初始化列表

2.1 初始化列表概念

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

class Date
{
public:
	Date(int year,int month,int day)
		:_n(1)
		,_month(2)
	{
        //赋值修改
		_year = year;
		_month = month;
		_day = day;
	}
private:
    //声明
	int _year=2020;//缺省值
	int _month;
	int _day;
	const int _n;
};
int main()
{
	Date d1(2024,3,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

从调试结果上来看，调用构造函数时，在初始化列表完成对成员对象的初始化;初始化列表结束后，进入函数体内完成赋初值。

如果没有在成员变量声明中给缺省值(在初始化列表使用)或在初始化列表中完成初始化，编译器会给随机值，之后是函数体里面的事

2.2 如何使用初始化列表

能使用初始化列表就使用初始化列表，由于不管没有初始化列表，编译器都会在初始化列表中完成初始化，再进函数体赋值。

虽然大部分成员变量可以在函数体中赋值，但是函数体可以对于成员多次赋值，不好控制。有些成员变量必须通过初始化列表完成初始化，不能进入函数体再赋值，比如:引用、const修饰成员

初始化列表的特性:

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

第二点:类中包括以下成员，必须放在初始化列表位置进行初始化

• 引用成员变量

• const成员变量

• 自定义类型成员(且该类有显示构造函数时)

• 其他成员，可以在初始化列表，也可以在函数体内；但是建议在初始化处理

class A
{
public:
	A(int a)
		:_a(a)
	{

	}
private:
	int _a;
};

class B
{
public:
	B(int data,int& ref)
		:data(10)
		,_n(1)
		,ref(ref)
	{

	}
private:
	int data;

	const int _n; //const修饰成员变量
	int& ref; //引用
	A _aa; //没有默认构造函数
};
int main()
{
	int x = 10;
	B d1(20,x);
	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

对于类类型成员有显示构造函数，才必要初始化列表中初始化。

在初始化列表中是不对自定义类型初始化，而是通过编译器调用对应默认构造函数完成初始化，不需要在初始化列表中初始化

第三点:在实际中是混着使用，初始化列表也可以调用函数，并且跟函数体内一样，需要考虑类型问题及其无法对指针进行判空的风险。

class A
{
    public:
    A()
        :_P((int *)malloc(4))
   private:
    int *_p2=(int *)malloc(4)
}

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

第四点:成员变量在类中声明次序就是其在初始化列表中的初始化顺序，与其在初始化表中的先后次序无关

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();
	return 0;

}

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

在初始化列表中顺序尽量对应着声明的顺序，这样子方便查看类中成员变量

2.3 构造函数支持隐式类型转换

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

关于类型转换:

int i = 1;
const double &d=i;

• 1
• 2

这个表达式没有报错，进行了隐式类型的转换，将整型类型转换为double类型，并且将值存放在临时变量(临时变量具有常性)。对此需要const进行修饰。

2.3.1 单参数隐式类型转换

对于自定义类型C cc = 2 ,其中支持隐式类型转换。当然这需要构造函数实现，单参数构造函数支持隐式类型转换。(整型类型通过隐式类型转换为自定义类型，并将值存储在临时变量中)

class C
{
public:
	C(int x=0)
		:_x(x)
	{

	}
	C(const C& cc)
	{
	cout << "C(const C& cc)" << endl;
	}
private:
	int _x;
};

int main()
{
	C cc2=2;
	const C& cc2 = 3;	
	return 0;
}

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

如果不存在从"int"转换到"C"的适当构造函数，就无法发生隐式类型转换
关于上面两种写法是等效的，但是推荐使用第二种写法更加简洁。首先整型类型2通过隐式类型转换构造出临时对象，在Push接口中进行拷贝构造。现在编译器可能进行优化，同一个表达式中连续步骤构造，一般会被合二为一。

2.3.2 双参数隐式类型转换(C++11中支持)

这属于多参数隐式类型转换，不涉及std::initializer_list初始化列表。

class A
{
public:
	A(int a1,int a2)
		:_a1(a1)
		,_a2(a2)
	{}
private:
	int _a1;
	int _a2;
};

int main()
{
	A aa1 = { 1,2 };
	const A& aa2 = { 1,2 };
}

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

三、explicit

用explicit修饰构造函数，将会禁止构造含函数的隐式转换

面对隐式类型的类型转换，如果禁止类型转换。要求必须创建对象时，调用默认构造函数完成给值。explicit 构造函数名（）：{}

1.单参构造函数，没有使用explicit修饰，具有类型转换作用

explicit Date(int year)
    :_year(year){}

• 1
• 2

2.虽然有多个参数，但是创建对象时，两个参数（实参部分）可以不传递，没有使用explicit修饰，具有类型转换作用。比如:用一个整型变量给类对象赋值

explicit Date(int year,int month=3,int day=8)
    :_year(year)
       ,_month(month)
        ,_day(day)
    {}
Date d1(2020)
    d1=2023;

• 1
• 2
• 3
• 4
• 5
• 6
• 7

四、static成员

static修饰成员:

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

统计调用构造函数次数:

关于统计次数这个问题，采用全局变量是一个不太好的方式。虽然全局变量可以在不同地方都可以使用这个变量，使之缺乏安全性。那么将该变量封装到类中，每次调用都希望相加都是同一变量，因此引出静态成员变量。

如果需要统计构造次数，那么该对象不是属于某个对象，而是属于所有对象，属于这个类。对此静态成员变量定义初始化必须要在类外部，而不能是类内部。需要域作用限定符突破类域，不需要管访问权限。

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

int A::_sum=0;

int main()
{
	A a1, a2;
	A a3(a1);
	cout << A::GetACouunt() << endl;;
	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

由于静态成员函数不存在this指针，一般静态成员函数只为静态成员变量服务

static的特性:

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

问题:

1. 静态成员函数可以调用非静态成员函数吗？
2. 非静态成员函数可以调用类的静态成员函数吗？

答:

1. 静态成员函数可以调用非静态成员函数，但是需要通过对象或者指针来调用非静态成员函数。
2. 非静态成员函数可以直接调用类的静态成员函数，使用类名或者对象名即可。

五、友元

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

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

5.1 友元函数

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

class Date
{
    friend ostream& operator<<(ostream& _cout, const Date& d);
    friend istream& operator>>(istream& _cin, Date& d);
public:
    Date(int year = 1900, int month = 1, int day = 1)
    : _year(year)
    , _month(month)
    , _day(day)
{}
private:
    int _year;
    int _month;
    int _day;
};

ostream& operator<<(ostream& _cout, const Date& d)
{
    _cout << d._year << "-" << d._month << "-" << d._day;
return _cout;
}

istream& operator>>(istream& _cin, Date& d)
{
    _cin >> d._year;
    _cin >> d._month;
    _cin >> d._day;
return _cin;
}
int main()
{
    Date d;
    cin >> d;
    cout << d << endl;
 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

友元函数小结:

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

5.2 友元类

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

友元类小结:

• 友元类的所有成员函数都可以是另一个类的友元函数，都可以访问另一个类中的非公有成员
• 友元关系是单向的，不具有交换性（在B对A友元，那么A相当于在B打通单向通道，A可以进去，B不可以进来）
• 友元关系不能传递(C是B的友元，B是A的友元，则不能说明C是A的友元)
• 友元关系不能继承(你爸的朋友，不一定是你朋友)

5.3 替代友元方式

替代友元的方法就是类中提供set/get，如果需要大面积使用set/get，不如搞一个可控制的友元(不想破坏封装)

六、内部类(了解即可，基本没人使用)

概念：如果一个类定义在另一个类的内部，这个内部类就叫做内部类。内部类是一个独立的类，它不属于外部类，更不能通过外部类的对象去访问内部类成员。外部类对内部类没有优越的访问权限。

注意:内部类天生就是外部类的友元类（但是外部类不是内部类的友元），参见友元类的定义，内部类可以通过外部类的对象参数来访问外部类中的所有成员。

class A
{
private:
	int h;
public:
	class B
	{
	public:
		void Print(const A& a)
		{
			cout << a.h << endl;
		}
	private:
		int h2;
	};
};
int main()
{
	A::B b;
	b.Print(A());//A()构造函数，在通过引用接受，调用成员
	return 0;
}

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

内部类小结:

• 内部类可以定义在外部类的public、protected、private都是可以的
• 注意内部类可以直接访问外部类中的static成员，不需要外部类的对象类名
• sizeof(外部类)=外部类，跟内部类没有任何关系
• 内部类这个类收到外部类的类域的限制
• C++不喜欢使用内部类，类独立更好使用。

七、匿名对象

字面意思不写对象名，在使用该对象方便一点点

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();

	A aa2(2);
	//匿名对象在这种场景下就很好用，当然还有一些其他场景
	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

匿名对象小结：

• 虽然不能A aa1()去定义对象（编译器无法识别）,但是可以A()定义匿名对象
• 匿名对象是不用取名字
• 匿名对象的生命周期只有这一行，下一行就会自动调用析构函数

八、拷贝对象时编译器优化

在传值和传返回值的构成中，一般编译器会做一些优化，减少对象的拷贝，这个一些场景下还是非常有用的。（不同平台就有不同的结果，需要看编译器优化情况和变量大小）

结果:图一:构造+拷贝

图二:构造+拷贝+拷贝 优化为 构造+拷贝，这里ret在f3函数结束前，使用aa拷贝ret

图三：构造+拷贝+拷贝优化构造，编译器很聪明的，直接优化成构造给值ret。

• 类A提供了显式的构造函数和拷贝构造函数，编译器可能会避免执行一些默认的优化，就按照提供的函数处理，而不会尝试使用更高效的默认实现。
• 如果没有提供显式构造和拷贝函数，编译器选择使用默认生成的函数可能进行优化，优化可以减少不必要的构造函数调用，提高代码的效率。

九、再次理解类和对象

在类和对象阶段。类时对某一类实体(对象)来进行描述的，描述该对象具有那些属性、方法、完成后就形成了一种新的自定义类型，才能该自定义类型就可以实例化具体的对象。

关于一道静态成员变量题目

求1+2+3+…+n，要求不能使用乘除法、for、while、if、else、switch、case等关键字及条件判断语句，位运算。

class Sum
{
public:
    Sum()
    {
        _i=_i+1;
        _sum+=_i;
    }
    static int Get_sum()
    {
        return _sum;
    }
 private:
    static int _i;
    static int _sum;
};
 int Sum:: _i;
 int Sum:: _sum;

class Solution 
{
public:
    int Sum_Solution(int n) 
    {
        Sum a[n];//看调用多少次构造函数
        return Sum::Get_sum();
    }
};

• 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

以上就是本篇文章的所有内容，在此感谢大家的观看！这里是店小二呀C++笔记，希望对你在学习C++语言旅途中有所帮助！