C++——初始化列表 | explicit关键字

这篇具有很好参考价值的文章主要介绍了C++——初始化列表 | explicit关键字 | static成员。希望对大家有所帮助。如果存在错误或未考虑完全的地方，请大家不吝赐教，您也可以点击"举报违法"按钮提交疑问。

C++——初始化列表 | explicit关键字 | static成员

💐专栏导读

🌸作者简介：花想云，在读本科生一枚，致力于 C/C++、Linux 学习。

🌸本文收录于 C++系列，本专栏主要内容为 C++ 初阶、C++ 进阶、STL 详解等，专为大学生打造全套 C++ 学习教程，持续更新！

🌸相关专栏推荐：C语言初阶系列 、C语言进阶系列 、数据结构与算法

💐文章导读

本章我们将继续加深对构造函数的学习。认识初始化列表、explicit关键字、static成员及学习static成员的相关特性。

在构造函数的学习中，我们知道可以通过构造函数对一个对象的成员变量赋初始值。我们以Date类为例：

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

	void print()
	{
		cout << _year << "年" << _month << "月" << _day << "日" << endl;
	}
private:
	int _year;
	int _month;
	int _day;
};

int main()
{
	Date d1(2023, 4, 6);
	d1.print();
	return 0;
}

虽然上述过程中通过构造函数的调用使得对象d1确实有了一个初始值，但是我们并不能将该过程称为对对象中成员变量的初始化。

构造函数体中的语句只能将其称为赋初值，而不能称作初始化。因为初始化只能初始化一次，而构造函数体内可以多次赋值。

那么初始化在何时进行呢？这就要提一提本章的主角之一——初始化列表了。

🌷初始化列表

🌺初始化列表的形式

初始化列表的样子还真有点新颖：

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

🍁示例

class Date
{
public:
	Date(int year, int month, int day)
		//初始化列表
		:_year(year),
		_month(month),
		_day(day)
	{}
	void print()
	{
		cout << _year << "年" << _month << "月" << _day << "日" << endl;
	}
private:
	int _year;
	int _month;
	int _day;
};

int main()
{
	Date d1(2023, 4, 6);
	d1.print();
	return 0;
}

C++——初始化列表 | explicit关键字 | static成员

🌺初始化列表的注意事项

每个成员变量在初始化列表中只能出现一次(初始化只能初始化一次)；
类中包含以下成员，必须放在初始化列表位置进行初始化：
- 引用成员变量；
- const成员变量；
- 自定义类型成员(且该类没有默认构造函数时)。

🍁示例

class B
{
public:
	B(int b)
		:_b(b)
	{}
private:
	int _b;
};
class A
{
public:
	A(int a, int i, int b)
		:_a(a),
		_i(i),
		_b1(b)
	{}
private:
	int& _a;
	const int _i;
	B _b1;
};

尽量使用初始化列表初始化，因为不管你是否使用初始化列表，对于自定义类型成员变量，一定会先使用初始化列表初始化。

🍁注意事项

有的小伙伴会误认为给成员变量赋缺省值就是初始化，切记只有在初始化列表中才进行初始化。

🍁举例

class Date
{
public:
	void print()
	{
		cout << _year << "年" << _month << "月" << _day << "日" << endl;
	}
private:
	//注意：此处为赋缺省值
	int _year = 0;
	int _month = 0;
	int _day = 0;
};

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

🍁示例1

class A
{
public:
	A()
		:a(10),
		 b(a)
	{}
	void print()
	{
		cout << "a= " << a << endl;
		cout << "b= " << b << endl;
	}
private:
	int a;
	int b;
};
int main()
{
	A a1;
	a1.print();
	return 0;
}

C++——初始化列表 | explicit关键字 | static成员
🍁示例2

class A
{
public:
	A()
		:b(10),
		 a(b)
	{}
	void print()
	{
		cout << "a= " << a << endl;
		cout << "b= " << b << endl;
	}
private:
	int a;
	int b;
};
int main()
{
	A a1;
	a1.print();
	return 0;
}

C++——初始化列表 | explicit关键字 | static成员
示例2中，出现该结果的原因是成员变量的声明顺序为先a后b，则初始化顺序也为先a后b。a在初始化时，使用b的值，而此时b还未初始化b的值为随机值，所以a的值也为随机值。接下来用10初始化b，所以b的值为10。

🌷explicit关键字

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

🍁什么是类型转换？

	int a=100;
	double b = a;

如上所示，a并不是直接赋值给b，而是先进行了隐式类型转换：

创建一个double类型的临时变量；
将a的值赋予临时变量；
将临时变量的值赋予b。

C++——初始化列表 | explicit关键字 | static成员

🌺单参数构造函数

🍁举例

定义一个Date类，且该类的构造函数只有一个参数，我们称为单参数构造函数：

class Date
{
public:
	Date(int year)
		:_year(year)
	{}
private:
	int _year=0;
};

Date d1(2023);

这是我们常见的创建一个对象的写法，此外还可以这样写：

Date d2 = 2023;

🍁注意事项

此处这种写法是我们的赋值运算符重载吗？
答案是，当然不是。赋值重载实现的功能是用一个已存在的对象赋值给另外一个对象。

那么为什么100可以赋值给d1呢？这是由于类型转换的原因。具体实现过程如下：

用100构造一个Date类型的临时对象；
再用临时对象对d1进行拷贝构造。

C++——初始化列表 | explicit关键字 | static成员
总结起来就是，该语句实现了2个过程——1个构造+1个拷贝构造。

🍁如何证明这一过程呢？

这就要用到explicit关键字了。

explicit修饰的构造函数禁止类型转换。

🍁示例

class Date
{
public:
	explicit Date(int year)
		:_year(year)
	{}
	
private:
	int _year=0;
	int _month=0;
	int _day=0;
};
int main()
{
	Date d2 = 100;
	return 0;
}

C++——初始化列表 | explicit关键字 | static成员

如图所示，此时编译器会报错。

🌺多参数构造函数

多参数构造函数与单参数类似。C++98中只支持除第一个参数外，其余参数都有默认值的情况。C++11中引进了一种新的写法。

🍁示例1(C++98)

class Date
{
public:
	//除第一个参数外，其余都有默认值
	//加上explicit关键字会报错
	Date(int year, int month=0, int day=0)
		:_year(year),
		_month(month),
		_day(day)
	{}
private:
	int _year;
	int _month;
	int _day;
};

int main()
{
	Date d2 = 100;
	return 0;
}

🍁示例2(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;
};

int main()
{
	Date d2 ={2023,10,26};//使用大括号
	return 0;
}

🌷static成员

🌺static成员的概念

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

class A
{
public:
	int getN()
	{
		return n;
	}
private:
	//类中进行声明
	static int n;
};

//类外进行定义与初始化
int A::n = 0;

🌺static成员的特性

静态成员变量必须在类外定义，定义时不添加static关键字，类中只是声明；
类静态成员即可用 类名::静态成员 或者 对象.静态成员 来访问；
静态成员也是类的成员，受public、protected、private 访问限定符的限制；

🍁示例1

class A
{
public:
	int getN()
	{
		return n;
	}
public:
	//类中进行声明
	static int m;
private:
	//类中进行声明
	static int n;
};

//在类外进行定义与初始化
int A::n = 0;
int A::m = 0;

int main()
{
	A a;
	a.m += 10;
	cout << a.getN() << endl;
	cout << a.m<< endl;
	return 0;
}

C++——初始化列表 | explicit关键字 | static成员

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

🍁示例2

class B
{
public:
	static int getN()
	{
		//错误示例
		//静态函数不能直接访问非静态成员
		//_a++;

		return n;//可以访问静态成员
	}
private:
	static int n;
	int _a;
};

静态成员为所有类对象所共享，不属于某个具体的对象，存放在静态区。

🍁一道有趣的试题

求1+2+3+…+n，要求不能使用乘除法、for、while、if、else、switch、case等关键字及条件判断语句（A?B:C)。

题目链接：求1+2+3+…+n。

这道题可以很好的帮我们理解第5条性质。

🌼解题思路

利用static成员被类的所有对象所共用的特性。声明static成员变量n，每创建一个对象就++n。再声明一个static成员变量sum，求所有n的和。

🌼题解

#include <regex>
class sum
{
public:
    sum()
    {
        _sum+=_i;
        ++_i;
    }
    static int GetSum()
    {
        return _sum;
    }
private:
    static int _sum;
    static int _i;
};

int sum::_sum = 0;
int sum::_i = 1;

class Solution {
public:
    int Sum_Solution(int n) {
        sum a[n];
        return sum::GetSum();
    }
};