我与C++的爱恋：隐式类型转换

​

​

🔥个人主页：guoguoqiang. 🔥专栏：我与C++的爱恋

朋友们大家好，本篇内容我们来介绍初始化列表，隐式类型转换以及explicit的内容

一、初始化列表

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 初始化列表

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

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

我们发现const成员变量并不能用函数体进行初始化
int _year;
int _month;
int _day;
这三个成员既可以在函数体，又可以在初始化列表。
但是类中有的成员必须放在初始化列表位置进行初始化：
1.const 成员变量
2.引用成员变量
3.自定义类型成员（且没有默认构造函数）

int _year;
int _month;
int _day;
const int _n;

这个是声明，定义是对象实例化的时候完成的，有些成员必须在定义的时候初始化。

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

初始化列表是每个成员变量定义初始化的地方

class Date2 {
public:
	Date2(int year, int month, int day)	
		:_n(1)
	{
		_year = year;
		_month = month;
		_day = day;
	}
private:
	int _year;
	int _month;
	int _day;
	const int _n;
};

不管你写不写每个成员都要走初始化列表。没有在初始化列表中显式初始化_year、_month、和_day这三个成员变量，它们仍然会在初始化列表阶段被默认初始化，然后在构造函数体内被赋新的值
所有的成员，你可以在初始化列表初始化，也可以在函数体内部初始化。

我们之前也说到过缺省值，声明时给初始值。

private:
	int _year=2024;
	int _month;
	int _day;
	const int _n;

缺省值的本质是给初始化列表。

尽量使用初始化列表初始化，因为不管你是否使用初始化列表，对于自定义类型成员变量，一定会先使用初始化列表初始化。
引用类型必须在定义的时候初始化，所以也得使用初始化列表

class A {
public:
	A(int a = 0)
		: _a(a)
	{}
private:
	int _a;
};
class Date
{
public:
	Date(int year, int month, int day)
		:_n(1)
		, _year(year)
		, _month(month)
		, _day(day)
		, _ref(x)
	{}
private:
	int _year=1;
	int _month;
	int _day;
	const int _n;
	int& _ref;
	A aa;
};
int main() {
	Date d2(2024, 4, 20);
	return 0;
}

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

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

这个结果是什么呢？

我们发现a1是1而a2是随机值，成员变量的初始化顺序是由它们在类中的声明次序决定的。与其在初始化列表中的先后次序无关。
在A类中_a2比_a1先声明，因此_a2会先于_a1初始化。

应该按照成员变量在类中声明的顺序初始化它们，或者更改成员变量的声明顺序以反映期望的初始化顺序。

class A
{
public:
    A(int a)
       :_a1(a)//现在是_a1先初始化
       ,_a2(_a1)//然后_a2再初始化
   {}
    
    void Print() {
        cout<<_a1<<" "<<_a2<<endl;
   }
private:
    int _a1;//声明顺序改为先_a1
    int _a2;//后_a2
};
int main() {
    A aa(1);
    aa.Print();
}

1.3 隐式类型转换

class A
{
public:
    A(int a)
       :_a1(a)
   {}
    
    void Print() {
        cout<<_a1<<" "<<_a2<<endl;
   }
private:
    int _a1;
};
int main() {
    A aa1(1);
    aa1.Print();
    A aa2=2;
    aa2.Print();
}

构造函数不仅可以构造与初始化对象，对于单个参数或者除第一个参数无默认值其余均有默认值的构造函数，还具有类型转换的作用。这个构造函数允许构造函数参数类型到类类型的隐式类型转换。这种转换使得单个值可以被视为是该类的一个实例，即使没有显式地调用构造函数。

class A
{
public:
    A(int a)
        :_a1(a)
    {}

    void Print() {
        cout << _a1<< endl;
    }
private:
    int _a1;
};
int main() {
    A aa2 = 2;
    A& aa2 = 3;
    aa2.Print();
}

A& aa2 = 3;试图将一个整型字面量3赋给A类型的引用aa2。这行代码会导致编译错误，原因如下：

1. 引用的基本要求：在C++中，引用必须绑定到一个已经存在的对象上。引用本质上是对象的别名，它不能像指针那样独立存在
2. 引用与临时对象：临时变量具有常性，在引用前应该加const（const A& aa2）
   正确用法：

    const A& aa1=A(3);
    //或者
    const A& aa2 = 3;

A aa3(4);
A& aa4=aa3;

class Stack
{
public:
	void Push(const A& a)
	{
			//
	}
};

压栈

Stack st;
A aa3(3);
st.Push(aa3);

st.Push(4);

直接用隐式类型转换就方便了很多

1.4 explicit关键字

如果不想让隐式类型转换发生，我们就需要用 explicit修饰构造函数，禁止类型转换

单参构造函数，没有使用explicit修饰，具有类型转换作用
C++11及以后版本版本支持多个参数隐式类型转换

class A
{
public:
	//explicit A(int a1, int a2)
	A(int a1, int a2)
		:_a1(a1)
		,_a2(a2)
	{}

private:
	int _a1;
	int _a2;
};
int main()
{
    A aa={1,2};
	return 0;
}

如果不想让隐式类型转换发生可以加上explicit关键字。

感谢大家观看！！！