初识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.xdnf.cn/news/1410752.html

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

相关文章

日志行为分析

日志行为分析

1、恶意IP请求带有多个身份操作 可以看到上述日志中&#xff0c;某IP对登录了邮件并进行了相关操作&#xff0c;可以看到其登录了不同的账户&#xff0c;那么这个时候怎么判断其是正常的请求还是恶意请求呢&#xff1f; (1)、威胁情报&#xff0c;查找请求IP相关的威胁情报信息…
阅读更多...
MySQL 8.4 版本(LTS) 发布，一睹为快

MySQL 8.4 版本(LTS) 发布，一睹为快

前言 Oracle 前几天发布了 MySQL 8.4 版本(LTS)&#xff0c; 该版本是创新版的第一个长期支持版本。详细规划&#xff0c;请移步 技术译文 | 一文了解 MySQL 全新版本模型 关于 MySQL 的版本发布规划 Oracle MySQL 官方开发团队推出的新版本将过渡到新的 MySQL 版本模型。MyS…
阅读更多...
组合数问题

组合数问题

1.直接用递推&#xff1a; 下面是AC代码“&#xff1a; #include<bits/stdc.h> using namespace std; const int N2010,mod1e97; int a[N][N]; void init() {for(int i0;i<N;i){for(int j0;j<i;j){if(j0) a[i][j]1;else a[i][j](a[i-1][j]a[i-1][j-1])%mod;}} } i…
阅读更多...
FreeRTOS--任务通知方式

FreeRTOS--任务通知方式

一.任务通知(Task Notifications)介绍 FreeRTOS 每个已经创建的任务都有一个任务控制块&#xff08; task control block&#xff09;&#xff0c;任务控制块就是一个结构体变量&#xff0c; 用于记录任务的相关信息。 结构体变量中有一个 32 位的变量成员 ulNotifiedValue 是专…
阅读更多...
分割链表----一道题目的3种不同的解法

分割链表----一道题目的3种不同的解法

1.题目概述 以这个题目的事例作为例子&#xff0c;我们看一下这个题目到底是什么意思&#xff08;Leedcode好多小伙伴说看不懂题目是什么意思&#xff09;&#xff0c;就是比如一个x3&#xff0c;经过我们的程序执行之后&#xff1b;大于3的在这个链表的后面&#xff0c;小于3的…
阅读更多...
Qt5 框架学习及应用 — 对象树

Qt5 框架学习及应用 — 对象树

Qt 对象树 对象树概念Qt为什么使用对象树 &#xff1f;将对象挂到对象树上 对象树概念 对象树&#xff1a;对于树的概念&#xff0c;相信许多学过数据结构的同学应该都不会陌生。在学习数据结构的时候我们所接触的什么二叉树、多叉树、哈夫曼树、AVL树、再到红黑树、B/B树………
阅读更多...
java之web笔记

java之web笔记

1.Servlet技术 1.1 JavaWeb概述 在Sun的Java Servlet规范中&#xff0c;对Java Web应用作了这样定义:“JavaWeb应用由一组Servlet、HTML页、类、以及其它可以被绑定的资源构成。它可以在各种供应商提供的实现Servlet规范的Servlet容器中运行。 Java Web应用中可以包含如下内容…
阅读更多...
STM32——GPIO篇

STM32——GPIO篇

技术笔记&#xff01; 1. 什么是GPIO&#xff1f; GPIO是通用输入输出端口&#xff08;General-purpose input/output&#xff09;的英文简写&#xff0c;是所有的微控制器必不可少的外设之一&#xff0c;可以由STM32直接驱动从而实现与外部设备通信、控制以及采集和捕获的功…
阅读更多...
数据库和缓存一致性问题

数据库和缓存一致性问题

hello&#xff0c;各位小伙伴们大家好&#xff0c;我是颜书凌&#xff0c;下面给大家讲解一下数据库和缓存的一致性问题&#xff0c;话不多说 1、一致性介绍 一致性就是数据保持一致&#xff0c;在分布式系统中&#xff0c;可以理解为多个节点中数据的值是一致的。 强一致性…
阅读更多...
基于vmware虚拟机中yum源的配置

基于vmware虚拟机中yum源的配置

1.首先需确保虚拟机中已经连接了光盘映像&#xff08;如图在虚拟机右下方从左往右第二个&#xff09; 2.在虚拟机中找到光盘映像文件&#xff08;默认在/dev的sr0&#xff09; 3.将光盘文件挂载&#xff08;挂载后才可读取&#xff09; 为方便每一次开机之后自动挂载&#xff…
阅读更多...
类和对象【四】运算符重载

类和对象【四】运算符重载

文章目录 运算符重载的概念运算符重载&#xff08;函数&#xff09;返回值类型&#xff1a;任意类型函数名&#xff1a;operator已有操作符 运算符重载&#xff08;函数&#xff09;的特点和注意点3个比较特殊的运算符重载赋值运算符&#xff08;&#xff09;重载返回值类型和返…
阅读更多...
未来科技的前沿：深入探讨人工智能的进展、机器学习技术和未来趋势

未来科技的前沿：深入探讨人工智能的进展、机器学习技术和未来趋势

文章目录 一、人工智能的定义和概述1. 人工智能的基本概念2. 人工智能的发展历史 二、技术深入&#xff1a;机器学习、深度学习和神经网络1. 机器学习2. 深度学习3. 神经网络 三、人工智能的主要目标和功能1. 自动化和效率提升2. 决策支持和风险管理3. 个性化服务和预测未来 本…
阅读更多...
vulnhub靶场之FunBox-2

vulnhub靶场之FunBox-2

一.环境搭建 1.靶场描述 Boot2Root ! This can be a real life scenario if rockies becomes admins. Easy going in round about 15 mins. Bit more, if you are find and stuck in the rabbit-hole first. This VM is created/tested with Virtualbox. Maybe it works with…
阅读更多...
【tcl脚本实践Demo 1】文本生成、匹配、修改、读写

【tcl脚本实践Demo 1】文本生成、匹配、修改、读写

引言 在芯片设计的流程中，各种EDA工具在设计、综合、布局布线、验证、时序分析等等环节都会产出大量的文件信息。这些信息是海量的，如果单纯靠程序员自己查看信息效率很低并且很容易纰漏。所以脚本语言可以很好的解决这个问题，可以利用脚本语言匹配到敏感的信息，完成对信息…
阅读更多...
WindowSurfaceController method call stacktrace

WindowSurfaceController method call stacktrace

WindowSurfaceController: prepareToShowInTransaction showRobustly
阅读更多...
python判断大图中包含小图并输出位置总结

python判断大图中包含小图并输出位置总结

python判断大图中包含小图并输出位置总结 没啥可说的&#xff0c;项目遇到了就直接上代码&#xff0c;可以减轻劳动力&#xff0c;花最少得时间实现应用功能。 import cv2 # 读取大图片和小图片的路径 img_big cv2.imread(big_image.png) img_small cv2.imread(small_image…
阅读更多...
华为手机 鸿蒙系统-android studio识别调试设备，开启adb调试权限

华为手机 鸿蒙系统-android studio识别调试设备，开启adb调试权限

1.进入设置-关于手机-版本号&#xff0c;连续点击7次 认证&#xff1a;有锁屏密码需要输入密码&#xff0c; 开启开发者配置功能ok 进入开发者配置界面 打开调试功能 重新在androd studio查看可运行running devices显示了&#xff0c; 不行的话&#xff0c;重启一下android …
阅读更多...
AI诗歌创作

AI诗歌创作

诗歌作为一种文学形式&#xff0c;能够通过优美的语言和深刻的意境表达情感和思想&#xff0c;触动人心&#xff0c;引发共鸣。然而&#xff0c;如今随着生活节奏的加快和人们对实用性的追求&#xff0c;写诗这一传统艺术渐渐被人们所忽略。幸运的是&#xff0c;随着人工智能技…
阅读更多...
一本通-1225：金银岛

一本通-1225：金银岛

【题目描述】 某天KID利用飞行器飞到了一个金银岛上&#xff0c;上面有许多珍贵的金属&#xff0c;KID虽然更喜欢各种宝石的艺术品&#xff0c;可是也不拒绝这样珍贵的金属。但是他只带着一个口袋&#xff0c;口袋至多只能装重量为w的物品。岛上金属有s个种类, 每种金属重量不同…
阅读更多...
Spring Cloud Feign

Spring Cloud Feign

序言 本文给大家介绍一下 Spring Cloud Feign 的基础概念以及使用方式。 一、远程调用 在传统的单体系统中&#xff0c;我们通常是客户端去请求服务端的接口。但是在分布式的系统中&#xff0c;常常需要一个服务去调用另外一个服务的接口。在服务端如何去调用另外一个服务端…
阅读更多...
最新文章

Copyright @ 2022~2023