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

目录

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;//1A a2 = a1;//2A a3 = 3;//3Func();//4//拷贝构造一个5cout << 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.mzph.cn/news/833103.shtml

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

相关文章

【强训笔记】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…
阅读更多...
C++：模板初阶

C++：模板初阶

文章目录 泛型编程函数模板概念函数模板格式函数模板的原理函数模板的实例化模板参数的匹配原则 模板类类模板的定义格式类模板实例化 泛型编程 如何实现一个通用的交换函数呢&#xff1f; 函数重载可以帮助我们完成 void Swap(int& left, int& right) {int temp l…
阅读更多...
数据仓库项目---Day01

数据仓库项目---Day01

文章目录 框架的安装包数据仓库概念项目需求及架构设计项目需求分析项目框架技术选型系统数据流程设计框架版本选型集群资源规划设计 数据生成模块数据埋点主流埋点方式埋点数据上报时机 服务器和JDK准备搭建三台Linux虚拟机(VMWare)编写集群分发脚本xsyncSSH无密登录配置JDK准…
阅读更多...
Read timed out. （python 安装第三方库超时）

Read timed out. （python 安装第三方库超时）

不少人在安装python第三方库的时候经常发生下面情况 解决方法就是往上找 我这里就是 jupyterlab-4.1.8-py3-none-any.whl安装时间过长&#xff0c;失败 那就去国内镜像网站下载下来离线安装 https://pypi.tuna.tsinghua.edu.cn/simple/xxx&#xff08;xxx就是你的包名&#…
阅读更多...
Linux 进程间通信之共享内存

Linux 进程间通信之共享内存

&#x1f493;博主CSDN主页:麻辣韭菜&#x1f493;   ⏩专栏分类&#xff1a;Linux知识分享⏪   &#x1f69a;代码仓库:Linux代码练习&#x1f69a;   &#x1f339;关注我&#x1faf5;带你学习更多Linux知识   &#x1f51d; ​ 目录 ​编辑​ 前言 共享内存直接原理…
阅读更多...
Spring Boot3.x集成Disruptor4.0

Spring Boot3.x集成Disruptor4.0

Disruptor介绍 Disruptor是一个高性能内存队列&#xff0c;研发的初衷是解决内存队列的延迟问题(在性能测试中发现竟然与I/O操作处于同样的数量级)。基于Disruptor开发的系统单线程能支撑每秒600万订单&#xff0c;2010年在QCon演讲后&#xff0c;获得了业界关注。2011年&…
阅读更多...
geojson文件规格

geojson文件规格

geojson文件示例&#xff0c; {"type": "FeatureCollection","features": [{"type": "Feature","geometry": {"type": "Point","coordinates": [102.0, 0.5]},"properties&q…
阅读更多...
阴影渲染在AI去衣技术中的关键作用

阴影渲染在AI去衣技术中的关键作用

引言&#xff1a; 随着人工智能技术的飞速发展&#xff0c;深度学习在图像处理领域取得了突破性的进展。其中&#xff0c;AI去衣技术作为一种高度复杂的图像到图像的转换过程&#xff0c;不仅要求算法能够精确地识别并处理衣物纹理和结构&#xff0c;还要求生成的结果具有高度的…
阅读更多...
SaaS应用加速解决方案

SaaS应用加速解决方案

随着企业业务的迅速扩展&#xff0c;SaaS应用成为企业提升办公效率的关键。然而&#xff0c;在SaaS应用广泛使用的同时&#xff0c;访问速度受限、网络拥堵等问题也逐渐浮现。为了解决这些挑战&#xff0c;SaaS应用加速方案应运而生&#xff0c;旨在助力企业高效运转&#xff0…
阅读更多...
基于51单片机ESP8266wifi控制机器人—送餐、快递

基于51单片机ESP8266wifi控制机器人—送餐、快递

基于51单片机wifi控制机器人 &#xff08;程序&#xff0b;原理图&#xff0b;PCB&#xff0b;设计报告&#xff09; ​功能介绍 具体功能&#xff1a; 1.L298N驱动电机&#xff0c;机器人行走&#xff1b; 2.装备红外线感应检测到周围环境&#xff0c;进行行程判断&#xf…
阅读更多...
代码随想录第52天|300.最长递增子序列 718. 最长重复子数组

代码随想录第52天|300.最长递增子序列 718. 最长重复子数组

300.最长递增子序列 300. 最长递增子序列 - 力扣&#xff08;LeetCode&#xff09; 代码随想录 (programmercarl.com) 动态规划之子序列问题&#xff0c;元素不连续&#xff01;| LeetCode&#xff1a;300.最长递增子序列_哔哩哔哩_bilibili 给你一个整数数组 nums &#xff0…
阅读更多...
multipass和multipassd命令的区别

multipass和multipassd命令的区别

multipassd通常是multipass服务的后台守护进程&#xff0c;它负责管理和控制虚拟机实例。 命令区别 例&#xff1a; multipass restart my-vm 这个命令用于重启Multipass中的虚拟机实例。例如有一个名为my-vm的虚拟机实例。 multipassd restart 这会重新启动Multipass后台…
阅读更多...
Scroll生态项目Penpad，再获Presto Labs的投资

Scroll生态项目Penpad，再获Presto Labs的投资

Penpad是Scroll生态的LaunchPad平台&#xff0c;其整计划像收益聚合器以及RWA等功能于一体的综合性Web3平台拓展&#xff0c;该平台在近期频获资本市场关注&#xff0c;并获得了多个知名投资者/投资机构的支持。 截止到本文发布前&#xff0c;Penpad已经获得了包括Scroll联合创…
阅读更多...
了解 Postman：这个 API 工具的功能和用途是什么？

了解 Postman：这个 API 工具的功能和用途是什么？

在软件开发中&#xff0c;经常听到 Postman 这个软件名。但其实很多新手开发者只知道这是软件开发常用的软件&#xff0c;并不知道实际是一个什么样工具&#xff0c;不知道具体的作用是什么。那今天就跟大家好好唠唠 Postman 这个软件。想要学习更多关于 Postman 的知识&#x…
阅读更多...
Codigger：Web应用赋能的分布式操作系统让用户卓越体验

Codigger：Web应用赋能的分布式操作系统让用户卓越体验

Codigger&#xff0c;作为一个分布式操作系统&#xff0c;其独特之处在于其采用的浏览器/服务器&#xff08;Browser/Server&#xff0c;简称B/S&#xff09;架构。这种架构的核心思想是&#xff0c;通过浏览器来进入工作界面&#xff0c;页面交互部分事务逻辑在前端&#xff0…
阅读更多...
【Linux网络】PXE批量网络装机

【Linux网络】PXE批量网络装机

目录 一、系统装机 1.1 三种引导方式 1.2 系统安装过程 1.3 四大重要文件 二、PXE 2.1 PXE实现原理 2.2 PXE手动搭建过程 2.3 kickstart配合pxe完成批量自动安装 一、系统装机 1.1 三种引导方式 硬盘光驱(U盘)网络启动 1.2 系统安装过程 加载boot loader加载启动安…
阅读更多...
Autosar PNC网络管理配置-UserData的使用

Autosar PNC网络管理配置-UserData的使用

文章目录 前言ComComSignalComIPdu CanNmSignal Mapping总结 前言 之前配置的网络管理报文中的data都由ComM管理&#xff0c;后面客户新增了需求&#xff0c;最后两个byte需要发送Wakeup Reason&#xff0c;本文记录一下相关配置的修改 Com ComSignal 之前配置的PN_TX&…
阅读更多...
Java 线程池 ( Thread Pool )的简单介绍

Java 线程池 ( Thread Pool )的简单介绍

想象一下&#xff0c;你正指挥着一支超级英雄团队&#xff0c;面对蜂拥而至的敌人&#xff08;任务&#xff09;&#xff0c;不是每次都召唤新英雄&#xff08;创建线程&#xff09;&#xff0c;而是精心调配现有成员&#xff0c;高效应对。这就是Java线程池的魔力&#xff0c;…
阅读更多...
Codeforces Round 942 (Div. 2) A-D1

Codeforces Round 942 (Div. 2) A-D1

题目&#xff1a; Codeforces Round 942 (Div. 2) D2有缘再补吧… A. Contest Proposal 题意 两个升序&#xff08;不降&#xff09;的序列a和b&#xff0c;可以在a的任意位置插入任意数&#xff08;要保持升序&#xff09;&#xff0c;使对任意i&#xff0c;有a[i] < b[…
阅读更多...
28.leetcode---前K个高频单词(Java版)

28.leetcode---前K个高频单词(Java版)

题目链接: https://leetcode.cn/problems/top-k-frequent-words/description/ 题解: 代码: 测试:
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023