初始化列表 / 隐式转换 / 静态

已于 2024-08-19 10:46:36 修改
阅读量336 收藏 15
点赞数 7
分类专栏： C++程序设计 文章标签： c++ 笔记 开发语言
于 2024-08-19 09:16:28 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_74093370/article/details/141192265
版权

目录

初始化列表

大部分时候成员变量在对象实例化的时候调用构造函数就整体定义了，注意此时只有定义，不算初始化。而定义后的值的值是在构造函数里面给的。我们知道构造函数可以执行很多语句，可以给成员变量多次赋值。此时就不能说在构造函数内部初始化了。
但是有些成员必须在定义的时候初始化。如果定义一个const成员变量，但是const成员变量规定不能在构造函数里面给他初始化而且const就只有一次初始化的机会。此时就可以在初始化列表给他初始化。
初始化列表的写法：

class Date
{
public:
	Date(int y)
		:_year(1)
		,_month(2)
		,_day(3)//初始化列表初始化的值
	{
		_year = y;
		//_day = 100;const无法在构造函数中改变
		cout << "Date(int y)" << endl;
	}
	Date(const Date& d)//拷贝构造也可以有初始化列表
		:_year(1)
		, _month(2)
		, _day(3)
	{
		cout << "Date(Date& d)" << endl;
	}
private:
	int _year;
	int _month;
	const int _day;
};

在构造函数下面写初始化列表，来拷贝构造和构造函数都可以有初始化列表

祖师爷为了区分初始化和定义就设计了初始化列表，在初始化列表中初始化我们的成员变量。我们每一次定义对象执行构造函数时，会先走初始化列表，即使我们没写也会走初始化列表。 初始化列表给了初始值，如果没有初始值，在C++11中的打了补丁，给了缺省值，即在类声明的时候给的值，其实就是初始化时候要给的值，如果没有缺省值，那初始化就给默认值。

private:
	int _year = 10;
	int _month = 20;
	const int _day = 30;

如上，如果没有给初始化列表，初始值就是这些缺省值

建议能用初始化列表就用初始化列表，因为初始化列表是必走的。

注意:

  1. const必须走初始化列表，因为const属性必须给予初始值, 必须使用初始化列表，这里说使用初始化列表是，必须给一个缺省值或者在初始化列表给一个值。
  2. 引用必须走初始化列表，因为引用只能是一个对象的引用，一个对象可以有多个引用，但一个引用只能对应一个引用对象。从这个角度看，引用就像是一个常量一样。
    引用既可以给缺省值引用也可以在初始化列表进行引用
private:
	int _year;
	int _month;
	const int _day;
	int& yy = _month;

自定义类型也会走初始化列表，然后去调用自己的默认构造，如果他没有默认构造就会报错，这一点在之前写构造函数时提到过。但是有了初始化列表，我们在初始化列表里面给自定义类型参数，此时就不会报错。此时相当于直接定义然后调用了构造。

如下，如果我们不写初始化列表里面的a(1,2)，编译器就会报错，因为类A没有默认构造函数。但是如果在初始化列表里面写了的话，就相当于定义的对象，并且给了参数。然后走他的构造函数。

class A
{
public:
	A(int a, int b)
		:x(a+10)
	{
		cout << "A(int a, int b)" << endl;
		cout << x << endl;
	}
private:
	int x;
};

class Date
{
public:
	Date(int y)
		:_year(1)
		,_month(2)
		,_day(3)
		, yy(_month)
		,a(1,2)
	{
		_year = y;
		cout << "Date(int y)" << endl;
		cout << _day << endl;
	}
	Date(const Date& d)//拷贝构造也可以有初始化列表
		:_year(1)
		, _month(2)
		, _day(3)
		, yy(_month)
		, a(1, 2)
	{
		cout << "Date(Date& d)" << endl;
	}
private:
	int _year;
	int _month;
	const int _day;
	int& yy = _month;
	A a;
};

int main()
{
	Date d1(1);
	return 0;
}

上述代码执行结果如下：
在这里插入图片描述
初始化列表主要解决的就是这三类问题:
引用成员变量，const成员变量，自定义类型成员(且没有默认构造函数）。就是那些不能在函数体内定义的成员变量。
其他的成员，可以在初始化列表，也可以在构造函数内初始化处理，但是建议在初始化列表里面处理。

另一个注意的点是：
初始化列表按照声明顺序初始化

class Date
{
public:
	Date(int y)
		:_month(2) 
		,_year(_month)
	{
		cout << _year << endl;
		cout << _month << endl;
	}
private:
	int _year;
	int _month;
};

int main()
{
	Date d1(1);
	return 0;
}

执行结果是
在这里插入图片描述
可以发现初始化列表先写了month，再写的year，但是year并没有使用month的值初始化自己。调试的时候也是执行的year行再执行的month行。

隐式转换

单参数的隐式类型转换

看下面代码理解隐式转换：

class Date
{
public:
	Date(int y)
	{
		cout << y << endl;
	}
private:
	int _year;
	int _month;
};

int main()
{
	Date d1(11);
	Date d2 = 12;
	return 0;
}

执行结果为
在这里插入图片描述
可以发现代码中Date d2 = 12;，是将一个整形赋值给了一个类类型。这样的写法就是隐式类型转换。但是前提是单参数构造函数，只有单参数构造函数才支持隐式类型转换。

转换原理： 整型12作为参数构造了一个临时对象，然后d2再通过临时对象进行拷贝构造，但是编译器会进行优化，同一个表达式的连续步骤的构造，一般会合二为一，此时不会去执行拷贝构造，如果上述代码写了拷贝构造也不会执行的。
但是当我真正去使用的时候会发现，编译器直接调用了构造函数，可以直接理解为将等号右边直接进行了传参。
比如改为下面代码

class Date
{
public:
	Date(int y)
	{
		cout << y << endl;
		cout << this << endl;
	}
	Date(Date& d)
	{
		d._month = 100;
	}
	void operator=(Date d)
	{
		cout << "void operator=(Date d)" << endl;
	}
	Date* Print()
	{
		cout << "Date* Print()" << endl;
		cout << this << endl;
		return this;
	}
private:
	int _year;
	int _month;
};

int main()
{
	Date d1(11);
	Date d2 = 12;
	cout << d2.Print() << endl;
	const Date& d3 = 13;
	int i = 10;
	double j = i;
	return 0;
}

执行结果就是
在这里插入图片描述

可以发现全部调用的都是构造函数

需要注意的地方有两点：

  1. 并不是只有刚创建的是才会进行隐式类型转换。如果创建过后在进行赋值，此时执行的就是赋值运算符重载，如果没有写就会进行浅拷贝，若此时成员变量有const限制的变量时，编译器就会报错。在VS2022中会报1>D:\Desktop\cpp\Project1\Project1\main.cpp(432,5): error C2280: “Date &Date::operator =(const Date &)”: 尝试引用已删除的函数
    这是因为如果没有定义自定义的复制构造函数或复制赋值运算符，编译器会默认生成这些函数。但当这些函数尝试访问 const 成员时，由于它们不能被改变，因此编译器会将复制赋值运算符标记为“已删除”。 此时就没有默认生成拷贝构造，如果我们写了赋值运算符的重载，并且不牵扯const限制的变量，就不会在报错。
    比如下面代码，如果把注释去掉就不会报错了
class Date
{
public:
	Date(int y)
	{
		cout << "Date(int y)" << endl;
	}
	//void operator=(Date d)
	//{

	//}
private:
	int _year;
	int _month;
	const int _day = 1;
};

int main()
{
	Date d1(1);
	d1 = 3;
	return 0;
}

但是如果没有const限制的成员变量，就不会出现上述报错，此时还是像刚创建一样，进行隐式类型转换，但是接着执行的就是赋值运算符重载，并且不会像刚赋值一样被优化不去执行，是真的执行了赋值运算符重载。

  1. 类型转换或者传值返回会产生临时变量，临时变量具有常性，所以引用不加const会报错
int main()
{
	Date d1(11);
	Date d2 = 12;
	const Date& d3 = 13;
	int i = 10;//这种赋值不产生临时变量
	const double j = i;
	return 0;
}

上述代码中d3是13临时对象的引用，13产生的临时对象具有常性，不能被改变，所以要加const，但是此时临时的，所以可能会产生野引用。但是const会延长临时对象的生命周期，临时对象在其引用的作用域结束后才会被销毁。 这里要注意，此外这句话不像Date d2 = 12; Date d2 = 12;会直接调用构造函数，传参然后创建d2对象。但是const Date& d3 = 13;是会产生临时变量的。这条语句不是创建对象，只要创建对象才会被优化。

i 赋值给 j ，i 会进行类型转换产生一个临时的具有常性的变量，然后赋值给 j ，此时 j 应该被const限制。不然是不正确的，但是有的编译器会优化，不会报错，VS2022就没有报错。
但是Date d2 = 12;按理来说也有一个具有临时对象，此时的拷贝构造的参数应该是const限制的，但是上面说了会优化为直接执行构造函数传参，所以这里也不存在这个错误了。

这种隐式类型转换使用的情况一般是下面这种：

void StackPush(Date d)
{
	//
}
StackPush(1);

这样写可以很方便的进行Push，而不需要创建一个对象再Push。

多参数的隐式类型转换

上面写的多参数的构造函数不能进行隐式类型转换，其实并不，只是要加限制，不能直接加个等号就进行赋值了。

class Date
{
public:
	Date(int y, int j)
	{
		cout << y << endl;
		cout << j << endl;
	}
	Date(Date& d)
	{
		d._month = 100;
	}
	void operator=(Date d)
	{
		cout << "void operator=(Date d)" << endl;
	}
private:
	int _year;
	int _month;
};

int main()
{
	Date d1(11, 111);
	Date d2 = { 12, 122 };
	const Date& d3 = { 13, 133 };
	int i = 10;
	double j = i;
	return 0;
}

要像上述代码，写一个大括号才能进行隐式类型转换，此时执行的流程和上面单参数的的执行过程是一样的。
如果类里含有类类型的成员变量，我们也可以使用上述方法给缺省值。

explicit关键字

explicit是C++中的一个关键字，它用来修饰只有一个参数的类构造函数，以表明该构造函数是显式的，而非隐式的。当使用explicit修饰构造函数时，它将禁止类对象之间的隐式转换，以及禁止隐式调用拷贝构造函数。
例如：

class Date
{
public:
	explicit Date(int y)
	{
		cout << y << endl;
		cout << this << endl;
	}
private:
	int _year;
	int _month;
};

此时就不能进行隐式类型转换了，多参数的也一样。

static

通过一个场景引出static
怎样统计我们调用了几次构造函数？
可以定义一个全局变量，在构造和拷贝构造里面进行加 1 操作。
如下：

int n = 0;
class Date
{
public:
	Date()
	{
		++n;
	}
	Date(const Date& d)
	{
		++n;
	}
private:
};

Date Func()
{
	Date a;
	return a;
}
int main()
{
	Date d1;
	Date d2;
	Func();
	cout << n << endl;
	return 0;
}

定义一个全局的n，每次进入构造就执行一次++n操作。但是执行后输出结果却是3次，其实应该是4次，在Func()函数的return时是传值返回，会执行一次拷贝构造，但是编译器认为没有人使用，返回了也没用，就不执行拷贝构造了，其实试的时候发现就算有对象承接，也不会执行，应该是优化的原因。并且定义为全局的可能会在不经意间被修改。总之，这种方式不靠谱。

于是可以使用static关键字，封装成静态的。static修饰的仍然是全局的，封装在类中，可以在全局使用，而且不会出现上述的被优化或者被修改的情况。
写法如下：

class Date
{
public:
	Date()
	{
		++n;
	}
	Date(const Date& d)
	{
		++n;
	}
//private:
	static int n;
};
int Date::n = 0;
Date Func()
{
	Date a;
	return a;
}
int main()
{
	Date d1;
	Date d2;
	Func();
	cout << Date::n << endl;
	return 0;
}

需要注意的是：
static修饰的变量不能给缺省值，因为它此时不是属于某一个对象，而是属于所有对象，属于整个类。 所以也不能在初始化列表初始化，初始化列表是初始化某一个对象的。但是static不是属于某一个对象的。而且要在类外面定义。类里面是声明。
可以理解为此时还是全局的一个静态变量，但是受到了类域和访问限定符的限制。
此时若要访问这个变量，就要加访问限定符，如下几种情况都是可以的：

int main()
{
	Date d1;
	Date d2;
	Date* ptr = nullptr;
	Func();
	cout << d1.n << endl;
	cout << d2.n << endl;
	cout << ptr->n << endl;
	cout << Date::n << endl;
	return 0;
}

此时访问的都是n，只要确定是哪个类就好，指定类确定或者通过对象确定都可以。像指向空的Date类型指针都可以访问的，因为n并不在ptr指向的地址，而是在静态区，这样访问知识为了让他突破类域，找到n在哪。
但是上述的访问也要在公有的情况下才可以，其实和全局的区别不大。所以没关系如果要是私有，就要用公有的函数才可以访问了。
如下：

class Date
{
public:
	Date()
	{
		++n;
	}
	Date(const Date& d)
	{
		++n;
	}
	int Getn()
	{
		return n;
	}
private:
	static int n;
};

int Date::n = 0;

Date Func()
{
	Date a;
	return a;
}
int main()
{
	Date d1;
	Date d2;
	Date* ptr = nullptr;
	Func();
	cout << d1.Getn() << endl;
	return 0;
}

同样可以把函数封装为静态的，如下：

class Date
{
public:
	Date()
	{
		++n;
	}
	Date(const Date& d)
	{
		++n;
	}
	static int Getn()
	{
		return n;
	}
private:
	static int n;
};
int Date::n = 0;
Date Func()
{
	Date a;
	return a;
}
int main()
{
	Date d1;
	Date d2;
	Date* ptr = nullptr;
	Func();
	cout << d1.Getn() << endl;
	cout << Date::Getn() << endl;
	return 0;
}

此时可以通过类进行访问这个函数，但是要注意，静态的成员函数没有this指针，此时要做的事情如果牵扯到this指针就无法执行。

其实由于VS2022编译器优化的过于厉害，用上述的static其实也无法正确统计调用的构造的次数，也可能是真的就调用了编译器返回的那么多次，那么多次可能对于编译器来说够了。编译器会有各种优化，并且会修改我们的代码，所以被优化导致不符合预期也是正常的。

Hungry_11
关注
  • 7
    点赞
  • 踩
  • 15
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
类初始化和实例初始化1
08-08
5. 初始化：执行类的静态初始化代码，包括静态变量的显示赋值和静态代码块。这些代码按照在源代码中出现的顺序依次执行。JVM会在类加载时生成一个名为()的特殊方法，用于聚合这些静态初始化操作，()方法只执行一次。...
C#中数组初始化与数组元素复制的方法
09-03
注意，源数组和目标数组的元素类型可以不同，但需要满足赋值兼容性（如这里的`int`可以隐式转换为`Object`）。 ### 3. 示例分析 在给出的代码示例中，首先创建了两个数组：一个`int`类型的`intArr`和一个`Object`...
编程思想14章构造函数的初始化表达式
01-17
同时，C++11引入了统一的构造，这意味着类可以隐式地转换为其非静态成员函数参数匹配的类型。这在某些情况下提供了便利，但也会增加潜在的误用风险，因此在设计类时应谨慎考虑。 总的来说，理解并掌握构造函数的...
数组初始化-参考价值不大，需要的下.docx
03-17
当使用简化的静态初始化语法时，数组的声明和初始化必须在同一行完成。 以上内容适用于不同的人群，包括学生、人工智能领域的从业者、项目经理、软件公司员工、软件教师以及求职者。在个人练习、编写报告或准备...
C++匿名函数lamba简介
yao_tao11的博客
08-18 510
Lambda 表达式是 C++11 引入的一个功能，允许你在代码中定义匿名函数（即没有名字的函数）。这种表达式可以用于简化函数对象的定义，并使得代码更简洁。Lambda 表达式特别适用于局部的、一次性的函数对象，如用于 STL 算法中。捕获方式含义[ ]空捕获列表，Lambda不能使用所在函数中的变量.[names]names是一个逗号分隔的名字列表，这些名字都是Lambda所在函数的局部变量。默认情况下，这些变量会被拷贝，然后按值传递，名字前面如果使用了&，则按引用传递[&]
c++编程（22）——STL（6）set
2301_77239666的博客
08-16 1027
欢迎来到博主的专栏——c++编程博主ID：代码小豪。
【漫谈C语言和嵌入式011】嵌入式系统中常用的校验方式
2403_83044722的博客
08-18 336
在嵌入式系统中，选择合适的校验方式取决于应用场景的需求。简单的数据传输可以使用奇偶校验或校验和，而对于更复杂、更可靠的数据传输，CRC和汉明码则是更好的选择。
C++ | Leetcode C++题解之第337题打家劫舍III
Ddddddd_158的博客
08-15 328
C++ | Leetcode C++题解之第337题打家劫舍III
C语言典型例题43
2302_77517102的博客
08-18 267
有一个函数：y={x,x
【C语言】字符串操作函数详解
EleganceJiaBao的博客
08-14 1032
这些头文件提供了字符串操作所需的函数声明。以下是常用字符串操作函数的详细讲解，包括每个函数的参数、返回值说明以及示例代码。每个函数的使用说明还包括了适当的表格以帮助理解其功能和用法。
C++_基本语法笔记_模板
qq_45629864的博客
08-14 430
思想是Java里的泛型（不确定用什么类型的数据）这里template这一句，意思是声明T是泛型，后面写用到泛型T的函数。建议都用应用场景：不同数据类型的交换函数。
C++编译器对类模板的按需实例化
2301_76197086的博客
08-16 122
简析C++类模板的按需实例化
typdef 与 struct
ligreenjian的博客
08-14 129
int age;int num;//每使用一次就要多一个struct。使用typdef就简洁些。
C++版设计模式简介 与 初识 工厂模式
最新发布
小嵌同学的博客
08-18 660
关于并发编程的更多内容我会在后续的实际开发中进行总结，然后分享给大家！接下来将会和大家一起学习C++的设计模式😷(1)设计模式 是 软件开发人员在软件开发过程中 面临的一般问题的解决方案。(2)这些解决方案是众多软件开发人员经过 相当长的一段时间的 试验 和 错误总结出来的。(3)使用设计模式是为了重用代码、让代码更容易被他人理解、保证代码可靠性。
整型二分,浮点二分法 C++
xcc134679的博客
08-16 291
需要注意的是，由于浮点数的精度问题，如果要查找的目标值非常接近区间的边界，可能无法准确地找到目标值，而是得到一个非常接近但不完全相等的浮点数。另外，在实际应用中，可能还需要设置一个终止条件来避免无限循环，例如在已知的精度范围内无法再继续缩小区间。浮点二分法的基本思想是通过将区间不断地二分，来逐步缩小查找范围，直到找到目标值或确定目标值不存在。- 如果M等于目标值，那么找到了目标值，返回M。- 如果M小于目标值，那么将L设为M，继续二分。- 如果M大于目标值，那么将R设为M，继续二分。
C++的内存分区
m0_63764282的博客
08-14 404
在C++中，程序的内存主要被分为几个不同的区域（或称为“分区”），这些区域用于存储不同类型的数据。
【C++】vector的介绍和使用
2303_80828380的博客
08-17 261
vector的认识与使用
【嵌入式系统】第10章 LES 硬件介绍（6）模数转换ADC，模拟比较器,功能说明，模块控制，采样电路（东南大学）
persona5joker的博客
08-15 733
【嵌入式系统】第17章 LES 硬件介绍（6）模拟比较器,结构框图，信号描述，功能说明，模块控制，采样电路（东南大学）
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值