初识C++ · 类和对象(下)

news2024/11/28 2:40:40

目录

1 再谈构造函数

2 类中的隐式类型转换

3 Static成员

4 友元和内部类

5 匿名对象

6 编译器的一些优化

1 再谈构造函数

先看一段代码：

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 d1;
	return 0;
}

当我们生成解决方案的时候，系统会报错：没有默认的构造函数，因为我们显式调用了构造函数，也没有默认构造，我们没有给缺省值，参数也没有缺省值，调用的时候就会报错。

C++引入了一个概念叫做初始化列表，以冒号开始，逗号分割，括号给值：

Date()
	:_year(2024)
	,_month(4)
	,_day(30)
{}

也就是我们将构造函数写成这样，这样我们不传参也是可以成功的。

可能看起来没什么用？

class Stack
{
public:
Stack(int n)
	:_size(10)
	, _capacity(n)
	, arr(nullptr)
{
	//……
}
private:
	int _size;
	int _capacity;
	int* arr;
};
class MyQueue
{
public:
	MyQueue(int n)
		:s1(n)
		,s2(n)
	{
		_size = n;
	}
private:
	Stack s1;
	Stack s2;
	int _size;
};
int main()
{
	MyQueue q1(10);
	return 0;
}

对于类中有自定义类型的，我们原本的想法是给MyQueue一个值，然后初始化，并且stack调用自己的默认构造，如果没有初始化列表，Stack就完不成自己的初始化，那么MyQueue也就完不成自己的默认构造。

初始化列表赋值的时候都是用括号赋值，如果不想用括号，那么进入花括号里面进行赋值也是可以的，一般来说的话能直接括号就直接括号了。

赋值的括号里面可以是变量也可以是加减法一类的，也可以是常量。

有意思的是括号里面还可以进行运算。

初始化的本质可以理解为声明和定义，private那里是声明，初始化列表就是定义，定义的时候我们给缺省值也是没有问题的。

那么，初始化列表有那么几个需要注意的地方。

有三种成员必须要在初始化列表初始化：
第一种是const成员：

int main()
{
	const int a;
	a = 10;
	return 0;
}

这种代码就是错误的，因为const定义的变量只有一次初始化的机会，就是定义的时候，定义好了之后就不能改值的，所以const成员变量必须要在初始化列表初始化。

第二种是引用类型：

int main()
{
	int x = 10;
	int& xx;
	xx = x;
	return 0;
}

引用类型和const类型是一样的，不可能说先给一个外号，看谁像就给谁，所以引用类型也是要在初始化列表的时候给值。

第三种类型是没有默认构造的自定义类型的成员：

class Stack
{
public:
	Stack(int n)
		:_size(n)
		, _capacity(n)
		, arr(nullptr)
	{
		//……
	}

private:
	int _size;
	int _capacity;
	int* arr;
};
class MyQueue
{
public:
	MyQueue(int n = 10)
		:s1(n)
		,s2(n)
	{
		_size = n;
	}
private:
	Stack s1;
	Stack s2;
	int _size;
};

像这种，stack类必须要传参才是初始化的，没有默认构造函数，那么为了让他能顺利初始化，就在初始化列表里面初始化了。

对于初始化列表来说，三类成员必须在初始化列表初始化，其他类型的可以在初始化列表进行初始化，也可以进入函数体内初始化。

看个有意思的：
 

class Stack
{
public:
	Stack(int n = 4)
		:_size(n)
		, _capacity(n)
		, arr(nullptr)
	{}
private:
	int _size;
	int _capacity;
	int* arr;
};
class MyQueue
{
public:
	MyQueue(int n = 10)
	{
		_size = n;
	}
private:
	Stack s1;
	Stack s2;
	int _size;
};
int main()
{
	MyQueue q1;
	return 0;
}

我们给stack默认构造函数，使用MyQueue的初始化列表的时候没有Stack的初始化，那么stack会不会初始化呢？

stack类也是初始化了的，那么这就意味着，初始化列表不管你写不写编译器都是要走一遍的，所以C++打的补丁缺省值，实际上给的是初始化列表。即便我初始化列表什么都不写，仍然会走一遍初始化列表。无非就是调用它自己的默认构造函数而已。

一般的顺序都是先走一遍初始化列表，再走函数体，比如初始化一个指针，我们可以这样初始化：

	Stack(int n = 4)
		:_size(n)
		, _capacity(n)
		, arr((int*)malloc(sizeof(int) * 10))
	{
		memset(arr, 1, 40);
	}

函数体更多的是用来进行其他参数，初始化一般在初始化列表就可以了。

接下来看一个有意思的：

class A
{
public:
	A(int a)
		:_a1(a)
		,_a2(_a1)
	{}
	void Print()
	{
		cout << _a1 << " " << _a2 << endl;
	}
private:
	int _a2;
	int _a1;
};
int main()
{
	A a(1);
	a.Print();
	return 0;
}

问最后结果是什么？

答案可能出乎你的意料：

打印出来了一个随机值，这是因为初始化列表的一个特点：
成员变量的声明次序就是初始化列表中的初始化顺序

我们先声明的_a2，所以_a2先给值，是_a1给的，_a1还没开始初始化，所以给的是随机值，然后初始化_a1，这时候_a1初始化为了1，所以打印出来有一个是1，有一个是随机值。

如果我们声明次序换一下，就是Ok的：

2 类中的隐式类型转换

先来看一个很有用的小代码：

class A
{
public:
	A(int n)
		:_a(n)
	{}
private:
	int _a;
};
int main()
{
	A a1();
	A a2 = 2;
	return 0;
}

我们创建对象的时候，可以用构造函数创建，也可以利用隐式类型转换创建，内置类型被转换为自定义类型，这里是2构建了一个A的临时对象，然后临时对象拷贝复制给a2。

当然了如果我们要引用一个的话，就得加一个const了，因为const具有常性。

	const A& aa = 1;

按道理来说，2构造了一个临时对象，发生了一次构造，然后临时对象拷贝构造给a2，所以一共是两次函数调用，但是在编译认为连续的构造 + 拷贝构造不如优化为构造，测试一下：

class A
{
public:
	A(int n)
		:_a(n)
	{
		cout << "int n" << endl;
	}
	A(const A& aa)
		:_a(aa._a)
	{
		cout << "const A& aa" << endl;
	}
private:
	int _a;
};
int main()
{
	A a1(1);//构造
	A a2 = 2;//构造+拷贝构造 = 直接构造
	return 0;
}

这个隐式类型转换应用的场景比如：


class A
{
public:
	A(int n = 1)
		:_a(n)
	{
		cout << "int n" << endl;
	}
	A(const A& aa)
		:_a(aa._a)
	{
		cout << "const A& aa" << endl;
	}
private:
	int _a;
};

class Stack
{
public:
	void push(const A& aa)
	{
		//...
	}
private:
	int _size;
};

int main()
{
	A a1;
	Stack s1;
	s1.push(a1);
	s1.push(2);
	return 0;
}

我往栈里面插入一个自定义类型，如果没有隐式类型转换，我就需要先创建一个，再插进去，这多麻烦，有了隐式类型转换直接就插入进去了。

但是有没有发现一个问题就是，隐式类型转换是内置类型给给自定义类型，如果是多个参数，又怎么办呢?

先不急，还有一个关键字explicit，它的用法很简单，就是防止隐式类型转换的发生的：

当多参数的时候，万能的花括号就派上用场了：

class A
{
public:
	A(int n,int m)
		:_a(n)
		,_b(m + 1)
		,_c(n + 2)
	{
		cout << "int n" << endl;
	}
	 A(const A& aa)
		:_a(aa._a)
	{
		cout << "const A& aa" << endl;
	}
private:
	int _a;
	int _b;
	int _c;
};
int main()
{
	A a1 = { 1,2};
	A a2{ 1,3 };
	const A& aa{ 2,2 };
	return 0;
}

对于多参数的初始化，用花括号即可，并且在新的标准中可以不用等好，直接就花括号就可以了，

3 Static成员

class A
{
public:
	A()
	{
		_count++;
	}
	A(const A& aa)
	{
		_count++;
	}
	~A()
	{
		_count--;
	}
private:
	int _a;
	int _b;
	static int _count;
};

都知道static是用来修饰静态成员变量，那么在类里面如上，请问该类的大小是多大呢?

sizeof计算出来是8，也就是说_count是不在类里面的，因为它在静态区里面，那么结合初始化列表的知识，我们能给缺省值吗？

当然是不行的，因为缺省值最后都是要走初始化列表的，static的成员变量都不在类里面，怎么能走呢？

因为static的成员是静态的，我们只能在定义的时候给初始值，我们就只能在全局给一个初始值：

int A::_count = 1;

既然它是静态的，所以我们可以用来计数，比如实时观察有几个对象：

class A
{
public:
	A(int n = 1)
		:_a(n)
		,_b(n)
	{
		_count++;
	}
	A(const A& aa)
	{
		_count--;
	}
	~A()
	{
		_count++;
	}
//private:
	int _a;
	int _b;
	static int _count;
};

int A::_count = 0;

A Func()
{
	A a1;
	return a1;
}

int main()
{
	A a1;//1
	A a2 = a1;//2
	A a3 = 3;//3
	Func();//4
	//拷贝构造一个5
	cout << a1._count << endl;
	return 0;
}

函数里面有一次初始化，一次拷贝，加上主函数的三次，一共就是5个。

但是！

以上的所有操作都是基于count是公有的解决的，但是成员变量一般都是私有的，所以解决方法是用static修饰的函数：

static int Getcount()
{
	return _count;
}

因为函数也是静态的，所以没有this指针，那么访问的只能是静态成员，比如_count，其他成员变量都是不能访问的。

4 友元和内部类

友元前面已经简单提过，这里也介绍一下：

class A
{
	friend class B;
	//A是B的友元
public:
	//...
private:
	int _a1;
	int _a2;
};
class B
{
public:
	//...
private:
	int _b1;
	int _b2;
};

A是B的友元，友元的位置声明放在任意位置都是可以的，既然A是B的友元，也就是说A是B的朋友，那么B就可以访问A中的成员，如：

class A
{
	friend class B;
	//A是B的友元
public:
	//...
private:
	int _a1 = 1;
	int _a2 = 2;
};
class B
{
public:
	//...
	void BPrint()
	{
		cout << a1._a1 << endl;
	}
private:
	int _b1;
	int _b2;
	A a1;
};
int main()
{
	B bb;
	bb.BPrint();
	return 0;
}

但是反过来就不行了，A是B的朋友没错，但是B不是A的朋友，所以A不能使用B的成员，这个世界的情感很多都是单向的~

但是呢友元关系不能继承，之后介绍。

内部类，和友元关系挺大的：

class A
{
public:
	class B
	{
	public:

	private:
		int _b1 = 1;
		int _b2 = 2;
	};
private:
	int _a1 = 1;
	int _a2 = 2;
};

B是A的内部类，那么他们天生就有B是A的友元的关系，所以A可以直接访问B的成员变量，但是sizeof(外部类)的结果就是外部类：

内部类还可以直接访问外部类的static变量，不需要类名等：

class A
{
public:
	class B
	{
	public:
		void PirntK()
		{
			cout << _k << endl;
		}
	private:
	};
private:
	static int _k;
};
int A::_k = 1;
int main()
{
	A::B b1;
	b1.PirntK();
	return 0;
}

5 匿名对象

不少人看到匿名对象可能会联想到匿名结构体，不同的是匿名对象是对象实例化的时候不给名字，如：

class A
{
public:
	A(int num = 1)
		:_a(num)
	{
		cout << "int A" << endl;
	}
	~A()
	{
		_a = -1;
		cout << "~A" << endl;
	}
private:
	int _a;
};
int main()
{
	A a1;//有名对象
	A(1);//匿名对象
	return 0;
}

与匿名结构体不同的是，匿名i对象的声明周期只在这一行，没错，就是只有一行，我们可以通过析构函数调用实验一下：

int main()
{
	A(1);
	cout << "666" << endl;
	return 0;
}

如果是有名对象，那么析构函数的调用会在主函数结束的时候调用，那么666的打印就会在~A之前打印，但是这是匿名对象，创建即是销毁。

那么有用没呢？

存在即合理，比如我们调用函数：

class S
{
public:
	void P()
	{
		cout << " aaa " << endl;
	}
private:

};
int main()
{
	S s1;
	s1.P();
	S().P();
	return 0;
}

这是两种调用方法，两行代码的是有名对象的调用，一行代码的是匿名对象的调用，所以嘛，存在即合理。

6 编译器的一些优化

编译器的一些优化在2022是不太好观察的，因为2022的优化是比较大的，这里推荐的是Vs2019或者使用Linux机器观察，这里使用Vs2019观察：

先来看一下传值传参热热身：

class A
{
public:
	A(int num = 1)
		:_a(num)
	{
		cout << "int A" << endl;
	}
	A(const A& aa)
	{
		cout << "const A& aa" << endl;
	}
	~A()
	{
		cout << "~A" << endl;
	}
private:
	int _a;
};

//测试代码
void Func(A aa)
{}
int main()
{
	A a;
    Func(a);
	cout << endl;
	return 0;
}

顺序是a的构造->aa的拷贝构造->aa的析构(因为出了函数的作用域)->a的析构:

打印出来的换行也可以说明。

这里可能有人要问了，为什么拷贝构造函数要用个const修饰，因为有了匿名对象，呼应上了这就：
匿名对象发生的是临时变量的拷贝，具有常性，所以我们应该用const进行修饰

	Func(A(1));

1 连续的构造 + 拷贝构造 = 直接构造(不绝对)

如下三个场景：

int main()
{
	Func(2);

	Func(A(2));

	A aa = 3;
	return 0;
}

比如最后一个，给一个3，那么3会构造一个临时对象，临时变量拷贝给aa，整个过程就是连续的构造 + 拷贝构造，编译器会直接优化为构造。

但是为什么说不绝对呢？这和内联函数都是一样的，取决于编译器的实现，优化，内联函数对编译器来说都只是个建议，具体看的是编译器。

2 连续的拷贝构造 + 拷贝构造 = 一个拷贝构造

A Func()
{
	A aa;
	return aa;
}
int main()
{
	A ret = Func();
	return 0;
}

代码执行的顺序是aa的构造 -> aa返回临时变量进行拷贝 -> ret拷贝构造一个临时对象

这里是连续的拷贝构造即被编译器优化为一个拷贝构造：

但是……

int main()
{
	A ret;
	ret= Func();
	return 0;
}

这里是连续的拷贝构造吗？

并不是，ret  = Fun()这里是一个赋值重载，所以就不会有编译器的优化。

即拷贝 + 赋值重载 = 无法优化。

这是debug版本下的优化，release版本下的优化简直可以吓死人：


void operator=(const A& aa)
{
    cout << "operator=" << endl;
}
A Func()
{
	A aa;
	return aa;
}
int main()
{
	A ret;
	ret= Func();
	return 0;
}

原来是构造 + 构造 + 拷贝 +  赋值重载，这直接：​​​​​

拷贝直接优化掉了，直接赋值重载，这还不是最吓人的。

A Func()
{
	A aa;
	return aa;
}
int main()
{
	A ret= Func();
	return 0;
}

按道理来说，有构造 + 拷贝 + 拷贝，编译器直接三合一：

厉害吧？所以有时候观察麻烦就是因为编译器给优化掉了。

以上就是类和对象下的内容。

感谢阅读！

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：http://www.coloradmin.cn/o/1650321.html

如若内容造成侵权/违法违规/事实不符，请联系多彩编程网进行投诉反馈，一经查实，立即删除！

相关文章

Redis之Linux下的安装配置

Redis之Linux下的安装配置

Redis之Linux下的安装配置 Redis下载 Linux下下载源码安装配置 方式一 官网下载&#xff1a;https://redis.io/download ​ 其他版本下载&#xff1a;https://download.redis.io/releases/ 方式二&#xff08;推荐&#xff09; GitHub下载&#xff1a;https://github.com/r…
阅读更多...
基于ambari hdp的kafka用户授权读写权限

基于ambari hdp的kafka用户授权读写权限

基于ambari hdp的kafka用户授权读写权限 版本Kafka 2.0.0添加自定义配置修改admin密码重启kafka授权读取授权写入有效通配符部分举例 版本Kafka 2.0.0 添加自定义配置 authorizer.class.name kafka.security.auth.SimpleAclAuthorizer super.users User:admin allow.everyo…
阅读更多...
【强训笔记】day13

【强训笔记】day13

NO.1 代码实现&#xff1a; #include <iostream>#include<string>using namespace std;int n,k,t; string s;int func() {int ret0;for(int i0;i<n;i){char chs[i];if(chL) ret-1;else{if(i-1>0&&i-2>0&&s[i-1]W&&s[i-2]W) retk…
阅读更多...
Android 官网Ota介绍

Android 官网Ota介绍

构建 OTA 软件包 | Android 开源项目 | Android Open Source Project
阅读更多...
太阳能光伏在生活中的三大作用

太阳能光伏在生活中的三大作用

随着现在太阳能光伏的逐步发展&#xff0c;太阳能光伏已经越来越走近人们的生活&#xff0c;小编带大家盘点一下光伏在生活中的应用 一、发电 光伏的最初应用就是用来发电&#xff0c;以替代传统的化石燃料发电方式。光伏发电可以从根本上解决当今社会面临的能源短缺问题&…
阅读更多...
我的板子为什么测不了损耗

我的板子为什么测不了损耗

高速先生成员--周伟 最近我们珠海高速实验室正式对外开放了&#xff0c;我们也同步推出了关于高速信号测试、高速仪器的一些视频。 大家知道我们有仪器后&#xff0c;很多热心的小伙伴们就以为我们开挂了&#xff0c;什么都能测&#xff0c;然后就会来咨询我们&#xff0c;很多…
阅读更多...
申请免费一年期的https证书

申请免费一年期的https证书

现在https证书的普及度还是比较高的&#xff0c;大众对于https证书的需求度也日益提升。针对于一些个人用户或是企业而言&#xff0c;实现网站的https访问已经成为了一种标配。 当前的免费证书&#xff1a; 截止到2024年为止&#xff0c;基本所有平台都停止了对于一年期免费S…
阅读更多...
Windows环境编译 VVenC 源码生成 Visual Studio 工程

Windows环境编译 VVenC 源码生成 Visual Studio 工程

VVenC介绍 Fraunhofer通用视频编码器(VVenC)的开发是为了提供一种公开可用的、快速和有效的VVC编码器实现。VVenC软件基于VTM&#xff0c;其优化包括软件重新设计以减轻性能瓶颈、广泛的SIMD优化、改进的编码器搜索算法和基本的多线程支持以利用并行。此外&#xff0c;VVenC支…
阅读更多...
Python运维-日志记录、FTP、邮件提醒

Python运维-日志记录、FTP、邮件提醒

本章目录如下&#xff1a; 五、日志记录 5.1、日志模块简介 5.2、logging模块的配置与使用 六、搭建FTP服务器与客户端 6.1、FTP服务器模式 6.2、搭建服务器 6.3、编写FTP客户端程序 七、邮件提醒 7.1、发送邮件 7.2、接收邮件 7.3、实例&#xff1a;将报警信息实时…
阅读更多...
python实验三 实现UDP协议、TCP协议进行服务器端与客户端的交互

python实验三 实现UDP协议、TCP协议进行服务器端与客户端的交互

实验三 实验题目 1、请利用生成器构造一下求阶乘的函数Factorial()&#xff0c;定义一个函数m()&#xff0c;在m()中调用生成器Factorial()生成小于100的阶乘序列存入集合s中&#xff0c;输出s。 【代码】 def factorial():n1f1while 1:​ f * n​ yield (f)​ n1…
阅读更多...
Map集合的实现类~TreeMap

Map集合的实现类~TreeMap

重复依据&#xff1a;通过对键进行排序 先创建Student类&#xff0c;并在主函数new对象&#xff0c;然后创建TreeMap&#xff1a; 建立红黑树&#xff0c;需要在Student类后面实现类的接口&#xff1a; 重写其中的compareTo方法&#xff1a; 或者可以自定义比较器&#xff1a; …
阅读更多...
使用quicker进行局域网文件互传

使用quicker进行局域网文件互传

使用了动作&#xff1a;文件服务器 https://getquicker.net/Sharedaction?code7a49ca6b-d243-4478-1e87-08d9f1ba2358 在文件夹中打开打开这个动作就能使用。 配置 右键动作可以设置&#xff1a; 选择了最后一个之后&#xff0c;打开服务之后能在右下角有一个弹窗&#xff…
阅读更多...
ADS基础教程10-多态性（动态模型选择）

ADS基础教程10-多态性（动态模型选择）

目录 一、多态性定义二、操作步骤&#xff11;.模型建立&#xff12;.模型选择&#xff13;.执行仿真 一、多态性定义 ADS中支持一个Symbol中&#xff0c;可以同时存在多个子图。在仿真时可以动态选择不同的子图继续宁仿真。 二、操作步骤 &#xff11;.模型建立 在上一章A…
阅读更多...
OceanBase学习1：分布式数据库与集中式数据库的差异

OceanBase学习1：分布式数据库与集中式数据库的差异

目录 1. 传统集中式数据库 2. 数据库中间件的分库分表 3. 分布式数据库的基本特点及对比分析 4. OceanBase和传统数据库的对比 5. 小结 1. 传统集中式数据库 优点 成熟稳定:经过近40年的发展&#xff0c;应用到各行各业&#xff0c;产品技术非常成熟稳定行业适配性强:适配…
阅读更多...
从零开始的软件测试学习之旅(六)测试网络基础知识

从零开始的软件测试学习之旅(六)测试网络基础知识

测试网络基础知识 HTTP和HTMLURLDNS客户端和服务器请求方法和状态码面试高频Fiddler抓包工具教学弱网 HTTP和HTML 概念 html: HyperText Markup Language 超文本标记语言 http: HyperText Transfer Protocol 超文本传输协议 超文本: 图片, 音频, 视频 关系:http 可以对 html 的…
阅读更多...
用友GRP A++Cloud 政府财务云 任意文件读取漏洞复现

用友GRP A++Cloud 政府财务云 任意文件读取漏洞复现

0x01 产品简介 用友GRP A++Cloud 政府财务云系统具有多项核心功能，旨在满足各类组织的财务管理需求。首先，它提供了财务核算功能，能够全面管理企业的总账、固定资产、现金、应付应收等模块，实时掌握企业的财务状况，并通过科目管理、凭证处理、报表分析等功能为决策提供有…
阅读更多...
php使用服务器端和客户端加密狗环境部署及使用记录（服务器端windows环境下部署、linux环境宝塔面板部署、客户端部署加密狗）

php使用服务器端和客户端加密狗环境部署及使用记录（服务器端windows环境下部署、linux环境宝塔面板部署、客户端部署加密狗）

php使用服务器端和客户端加密狗环境部署及使用记录 ViKey加密狗环境部署1.windows环境下部署开发文档验证代码提示Fatal error: Class COM not found in 2.linux环境下部署&#xff08;宝塔面板&#xff09;开发文档验证代码提示Fatal error: Uncaught Error: Call to undefine…
阅读更多...
Redis 入坑基本指南

Redis 入坑基本指南

引言 本指南将帮助您了解如何安装、配置和基本使用 Redis。Redis 是一款开源的高性能键值存储系统&#xff0c;可用于缓存、数据库、消息中间件等多种用途。 1. 安装 Redis a. 下载 Redis&#xff1a; 可以从 Redis 官方网站&#xff08;https://redis.io&#xff09;下载最…
阅读更多...
CRM定义是什么？

CRM定义是什么？

CRM&#xff0c;即客户关系管理&#xff0c;是一种综合性的管理策略&#xff0c;旨在通过一系列技术手段和业务流程&#xff0c;建立、维护和优化企业与客户之间的关系。它不仅仅是一种技术工具&#xff0c;更是一种以客户为中心商业哲学&#xff0c;是现代企业提升竞争力、实现…
阅读更多...
Pycharm远程同步的mapping与sync

Pycharm远程同步的mapping与sync

用Pycharm进行项目远程部署的时候会遇到两个同步文件&#xff0c;一个是点击 tools—>deployment—>configration——>mapping 一个是链接虚拟环境的时候会有一个sync&#xff0c;那么这两种同步有什么区别呢&#xff1f; 区别就是&#xff0c;2包括1&#xff0c;要用…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023