C++类和对象 (下)

文章目录

  • 前言
  • 一. 再探构造函数
    • 初始化列表
    • 特性
    • 总结
    • 练习
  • 二. 类型转换
    • 2.1 隐式类型转换
    • 2.2 临时对象具有常性
    • 2.3 explicit关键字
    • 2.4 多参数类型转化
  • 三. static成员
    • 概念
    • 特性
    • 练习
  • 四. 友元
    • 概念
    • 特性
  • 五. 内部类
    • 概念
    • 特性
  • 六. 匿名对象
    • 概念
    • 特性
  • 七. 对象拷贝时的编译器优化
  • END


前言

在学习C++类和对象上和中的基础上,我们继续来学习C++类和对象剩下的内容,大致包括构造函数的初始化列表,隐式类型转换,static成员,友元,内部类,匿名对象,对象拷贝时编译器的优化。

一. 再探构造函数

初始化列表

之前我们实现构造函数时,初始化成员变量主要使用函数体内赋值,构造函数初始化还有一种方式,就是初始化列表

初始化列表的使用方式是以一个冒号开始,接着是一个以逗号分隔的数据成员列表,每个"成员变量"后面跟一个放在括号中的初始值或表达式。而函数体可以实现其它功能。

class Date
{
public:Date(int year, int month, int day):_year(year),_month(month),_day(day){cout << _year << "/" << _month << "/" << _day << endl;}
private:int _year;int _month;int _day;
};

对于自定义类型的成员,编译器自动调用它的默认构造函数,初始化列表可以不显示写。但是当这个自定义类型的成员没有默认的构造函数时,我们需要在初始化列表显示调用它的构造函数,否则就会报错。

#include<iostream>
using namespace std;
class Time
{
public:Time(int hour):_hour(hour){cout << "Time()" << endl;}
private:int _hour;
};
class Date
{
public:Date(int year = 1, int month = 1, int day = 1):_year(year),_month(month),_day(day),_t(10){}void Print() const{cout << _year << "/" << _month << "/" << _day << endl;}
private:int _year;int _month;int _day;Time _t; //没有默认构造函数
};
int main()
{Date d1;d1.Print();return 0;
}

可以看到类Time没有默认构造函数,所以我们需要手动在初始化列表里调用类对象_t的构造函数来实现初始化。如果不写就会报错,如下:

在这里插入图片描述

特性

1.每个成员变量在初始化列表中只能出现一次,语法理解上初始化列表可以认为是每个成员变量定义初始化的地方。

当有成员变量在初始化列表出现两次就会报错,如下:
在这里插入图片描述

2.引用成员变量,const成员变量,没有默认构造的类类型变量,必须放在初始化列表位置进行初始化,否则会编译报错。

#include<iostream>
using namespace std;
class Time
{
public:Time(int hour):_hour(hour){cout << "Time()" << endl;}
private:int _hour;
};
class Date
{
public:Date(int& x, int year = 1, int month = 1, int day = 1):_year(year),_month(month),_day(day),_t(10),_i(x),j(1){}void Print() const{cout << _year << "/" << _month << "/" << _day << endl;}
private:int _year;int _month;int _day;Time _t; //没有默认构造的类类型变量int& _i; //引用类型变量const int j; //const成员变量
};
int main()
{int i = 0;Date d1(i);d1.Print();return 0;
}

如果不放在初始化列表进行初始化,就会发生如下报错:
在这里插入图片描述
3.C++11支持在成员变量声明的位置给缺省值,这个缺省值主要是给没有显示在初始化列表初始化的成员使用的。

#include<iostream>
using namespace std;
class Time
{
public:Time(int hour):_hour(hour){cout << "Time()" << endl;}
private:int _hour;
};
class Date
{
public:Date(int& x):_i(x){}void Print() const{cout << _year << "/" << _month << "/" << _day << endl;}
private:// 注意这里不是初始化,这里给的是缺省值,这个缺省值是给初始化列表的// 如果初始化列表没有显示初始化,默认就会用这个缺省值初始化int _year = 2024;int _month = 11;int _day = 4;Time _t = 10;int& _i;const int j = 1;
};
int main()
{int i = 0;Date d1(i);d1.Print();return 0;
}

在这里插入图片描述
通过调试可以看出:当在成员变量声明时给缺省值,这个缺省值会给到初始化列表,如果没有在初始化列表里初始化成员变量,编译器会自动调用缺省值去初始化成员变量

  1. 尽量使用初始化列表初始化,因为那些不在初始化列表初始化的成员也会走初始化列表,如果这个成员在声明位置给了缺省值,初始化列表会用这个缺省值初始化。如果没有给缺省值,对于没有显示在初始化列表初始化的内置类型成员是否初始化取决于编译器,C++并没有规定。对于没有显示在初始化列表初始化的自定义类型成员会调用这个成员的默认构造函数,如果没有默认构造会编译错误。

在这里插入图片描述
5.初始化列表中按照成员变量在类中声明顺序进行初始化,跟成员在初始化列表出现的的先后顺序无关建议声明顺序和初始化列表顺序保持一致

#include<iostream>
using namespace std;
class Time
{
public:Time(int hour):_hour(hour){cout << "Time()" << endl;}
private:int _hour;
};
class Date
{
public:Date(int& x):_i(x),_t(10),_month(11),_year(2024),_day(4){}void Print() const{cout << _year << "/" << _month << "/" << _day << endl;}
private:int _year;int _month;int _day;Time _t;int& _i;
};
int main()
{int i = 0;Date d1(i);d1.Print();return 0;
}

在这里插入图片描述
在这里插入图片描述
在这里插入图片描述

进入调试可以知道,编译器不是按照成员在初始化列表出现的顺序来对成员进行初始化的,而是按照成员在类中声明的顺序

总结

无论是否显示写初始化列表,每个构造函数都有初始化列表
无论是否在初始化列表显示初始化,每个成员变量都要走初始化列表初始化

练习

#include<iostream>
using namespace std;
class A
{
public:A(int a):_a1(a), _a2(_a1){}void Print() {cout << _a1 << " " << _a2 << endl;}
private:int _a2 = 2;int _a1 = 2;
};
int main()
{A aa(1);aa.Print();return 0;
}

这段程序的运行结果是什么呢?我们先来看结果

在这里插入图片描述
这里有以下需要注意的地方:

1.成员变量在声明时给的值是缺省值,这个缺省值是给初始化列表的,不是初始化成员的。如果成员变量在初始化列表里显示初始化了,这个缺省值就不需要了,否则就用这个缺省值来对成员变量进行初始化。
2.初始化列表中按照成员变量在类中声明顺序进行初始化,跟成员在初始化列表出现的的先后顺序无关

因为_a1和_a2都是int类型(内置类型),所以编译器一开始不做处理,_a1和_a2都是随机值。类A的初始化列表先初始化_a2,_a2初始化为_a1,所以_a2还是随机值,然后再初始化_a1,_a1初始化为形参a,所以_a1初始化为1。

二. 类型转换

2.1 隐式类型转换

C++支持内置类型隐式类型转换为类类型对象,需要有相关内置类型为参数的构造函数。隐式类型转换(也称为类型强制转换)涉及将一种类型的对象转换为另一个类型的对象,而不需要显示地使用类型转换运算符。这种转换通常通过类的单参数构造函数来实现,这种构造函数被称为转换构造函数。

例如:

class MyClass {  
public:  MyClass(int value) {  // 转换构造函数  // 用于将 int 类型转换为 MyClass 类型  }  
};
#include<iostream>
using namespace std;
class A
{
public:A(int a):_a(a){cout << "A(int a)" << endl;}A(const A& aa){_a = aa._a;_b = aa._b;cout << "A(const A& aa)" << endl;}void Print() {cout << _a << " " << _b << endl;}
private:int _a;int _b = 1;
};
int main()
{// 1构造⼀个A的临时对象,再用这个临时对象拷贝构造aa// 编译器遇到连续构造+拷贝构造->优化为直接构造A aa = 1;aa.Print();return 0;
}

A aa = 1 这种将整数类型赋值给自定义类型有着明显的逻辑错误,但是类A实现了单个(整数)参数的构造函数,所以编译器调用类A的转换构造函数 A(int a) 来创建一个 A 类型的临时对象,这个临时对象是通过调用 A(1) 来构造的。最后通过调用 aa 的拷贝构造函数来实现 aa 对临时对象的拷贝。

在这里插入图片描述

注意:在C++11及以后的版本中,C++编译器可能会应用返回值优化命名返回值优化来避免不必要的临时对象创建和拷贝。这样就不会调用拷贝构造函数,编译器可以直接在目标对象的内存位置构造对象,而不是先创建一个临时对象再进行拷贝。

当编译器进行优化为直接构造时,对于创建对象aa的过程如下:

1.识别到A aa = 1;这一语句需要将整数 1 转换为A类型对象。
2.编译器直接在aa对象的内存位置调用构造函数A(int a),将参数 1 传入该构造函数。
3.构造函数内部,将参数 1 赋值给成员变量_a,并根据默认初始化规则初始化成员变量_b(如果没有显式指定初始值,_b会按照其类型进行默认初始化)。
4.这样就完成了对aa对象的构造,整个过程没有临时对象的创建和调用拷贝构造函数。

注意如果编译器进行优化为直接构造,通常相当于没有临时对象创建,但整数 1 仍然会隐式转换为 A 类型对象

因为即使是直接在目标对象的内存位置构造对象,编译器在识别到需要将整数转换为 A 类型对象时,仍然会调用接受一个整数参数的构造函数 A(int a)来进行类型转换操作。这个过程本质上还是隐式类型转换,只是编译器可能避免了创建临时对象和调用拷贝构造函数的额外开销。

2.2 临时对象具有常性

在这里插入图片描述

在上述例子中,如果尝试用A类型对象对整数1进行引用,编译器会报错。因为当整数1隐式类型转换为A类型的临时对象后,该临时对象具有常性,如果用非常量引用去引用该临时对象会导致权限的放大,从而导致编译器报错。

当使用const修饰引用时(const引用),编译器就不会报错。

#include<iostream>
using namespace std;
class A
{
public:A(int a):_a(a){}//因为打印函数不用改变对象的成员变量,所以这里最好使用const修饰this指针指向的对象//这样就防止通过this指针去修改对象的成员//也防止了常量对象调用Print函数时造成权限放大而导致编译器报错void Print() const{cout << _a << " " << _b << endl;}
private:int _a;int _b = 1;
};
int main()
{const A& aa = 1;aa.Print();return 0;
}

内置类型的类型转换

当内置类型发生类型转换时也会生成临时对象,引用该临时对象必须使用const引用,const 引用绑定到临时对象后会延长该临时对象的生命周期。

#include<iostream>
using namespace std;
int main()
{int i = 1;double d = i;// 不报错,整数i隐式类型转换为double类型,再赋值给d//double& d1 = i;// 报错,i创建了一个double类型的临时对象,临时对象具有常性,导致权限放大,编译器报错const double& d2 = i;// 不报错,权限的平移return 0;
}

类类型的类型转换

类类型的对象之间也可以隐式转换,需要相应的构造函数支持。比如整数1转换为类类型对象需要单参数(整数)的构造函数,同理,类类型对象之间的相互转换(A类型转换为B类型)也需要单参数(A类型对象)的构造函数。

#include<iostream>
using namespace std;
class A
{
public:A(int a1):_a1(a1){}void Print(){cout << _a1 << " " << _a2 << endl;}int Get() const{return _a1 + _a2;}
private:int _a1 = 1;int _a2 = 2;
};
class B
{
public://使用const引用减少拷贝,同时不会修改源对象的成员B(const A& a):_b(a.Get()){}
private:int _b = 0;
};
int main()
{A aa = 1;A aa1 = 2;// aa隐式类型转换为b对象// 原理跟上面类似B b = aa;const B& rb = aa1;// aa1创建了一个B类型的临时对象,因为临时对象具有常性,所以要使用const引用return 0;
}

2.3 explicit关键字

构造函数前面加explicit就不再支持隐式类型转换。

explicit A(int a):_a1(a), _a2(_a1)
{}

在这里插入图片描述
当整数1转换为A类型对象时会调用构造函数A(1),但是构造函数前面加了explicit关键字,使得整数1不能隐式地进行类型转换。

2.4 多参数类型转化

多参数的类型转换需要有相对应的多参数构造函数才能实现。C++11之后才支持多参数转化。

多参数的类型转换需要使用花括号 { }

#include<iostream>
using namespace std;
class A
{
public:A(int a1):_a1(a1){}A(int a1, int a2):_a1(a1), _a2(a2){}void Print(){cout << _a1 << " " << _a2 << endl;}int Get() const{return _a1 + _a2;}
private:int _a1 = 1;int _a2 = 2;
};
int main()
{// C++11之后才支持多参数转化A aa3 = { 2,2 };return 0;
}

同样地,若多参数构造函数不期望支持隐式类型转换,只需在构造函数前面加上explicit关键字即可

三. static成员

概念

static 成员,即静态成员,是编程中面向对象编程语言中的一个概念,它属于类而不是类的某个特定实例(对象)。

特性

  • 用static修饰的成员变量,称之为静态成员变量,静态成员变量一定要在类外进行初始化
#include<iostream>
using namespace std;
class A {
public://静态成员不能在类里面初始化/*A(int i = 1):_a(i){}*/void Print() const{cout << _a << endl;}
private:static int _a;
};
int A::_a = 1;
int main()
{A aa;aa.Print();return 0;
}

在这里插入图片描述

  • 非静态成员变量不能在类的外部定义
    在这里插入图片描述

  • 静态成员变量为所有类对象所共享,不属于某个具体的对象,不存在对象中,存放在静态区

  • 用static修饰的成员函数,称之为静态成员函数,静态成员函数没有this指针,不能访问非静态成员变量。

#include<iostream>
using namespace std;
class A {
public://静态成员不能在类里面初始化/*A(int i = 1):_a(i){}*/void Print() const{cout << _a << endl;}/*static int get(){return _b;//静态成员函数没有this指针,不能访问非静态成员变量}*/
private:static int _a;int _b;
};
int A::_a = 1;
int main()
{A aa;aa.Print();return 0;
}

在这里插入图片描述

  • 静态成员函数中可以访问其他的静态成员,但是不能访问非静态的,因为没有this指针
  • 非静态的成员函数,可以访问任意的静态成员变量和静态成员函数
  • 突破类域就可以访问静态成员,可以通过类名::静态成员或者对象.静态成员来访问静态成员变量和静态成员函数。
#include<iostream>
using namespace std;
class A {
public:void Print() const{cout << _a << " " << _b << endl;}static int get(){return _a;}
public:static int _a;
private:int _b = 2;
};
int A::_a = 1;
int main()
{A aa;cout << A::_a << endl;cout << aa._a << endl;cout << A::get() << endl;cout << aa.get() << endl;return 0;
}
  • 静态成员也是类的成员,受public、protected、private访问限定符的限制
    在这里插入图片描述
    在这里插入图片描述
    可以看到,不管是静态成员变量还是静态成员函数,它们都受public、protected、private访问限定符的限制。

  • 静态成员变量不能在声明位置给缺省值初始化,因为缺省值是给构造函数初始化列表的,静态成员变量不属于某个对象,不走构造函数初始化列表。

在这里插入图片描述

练习

设已经有A,B,C,D 4个类的定义,程序中A,B,C,D 4个类的构造函数和析构函数的调用顺序是什么?

#include<iostream>
using namespace std;
class A {
public:A(int i = 1):a(i){cout << "A()" << endl;}~A(){cout << "~A()" << endl;}
private:int a;
};
class B {
public:B(int i = 1):b(i){cout << "B()" << endl;}~B(){cout << "~B()" << endl;}
private:int b;
};
class C {
public:C(int i = 1):c(i){cout << "C()" << endl;}~C(){cout << "~C()" << endl;}
private:int c;
};
class D {
public:D(int i = 1):d(i){cout << "D()" << endl;}~D(){cout << "~D()" << endl;}
private:int d;
};
C c;
int main()
{A a;B b;static D d;return 0;
}

我们先来看结果:
在这里插入图片描述

构造函数的调用顺序:全局区域——>局部区域(在局部区域,不管是静态对象还是非静态对象,谁先调用构造就先构造谁)

析构函数的调用顺序:局部区域——>静态区——>全局区域(在局部区域,后构造的先析构)

四. 友元

概念

在C++中,友元(friend)是一种特殊的类成员或函数,它不属于类的成员,但可以访问类的私有(private)和保护(protected)成员。友元提供了一种机制,使得某些特定的函数或类可以访问类的内部数据,即使这些数据是私有的或受保护的。

友元提供了一种突破类访问限定符封装的方式友元分为:友元函数和友元类,在函数声明或者类声明的前面加 friend,并且把友元声明放到一个类的里面

友元函数:一个非成员函数可以被声明为某个类的友元,这样它就可以访问该类的所有私有和保护成员。友元函数的声明通常放在类的内部,但定义通常在类定义之外。

class MyClass {
private:int privateVar;
public:void setPrivateVar(int value) { privateVar = value; }friend void myFriendFunction(MyClass& obj);
};void myFriendFunction(MyClass& obj) {// 可以访问obj的私有成员obj.privateVar = 10;
}

友元类:一个类可以被声明为另一个类的友元,这样友元类的所有成员函数都可以访问声明它的类的私有和保护成员。

class MyClass {
private:int privateVar;
public:friend class MyFriendClass;
};class MyFriendClass {
public:void accessPrivateVar(MyClass& obj) {// 可以访问obj的私有成员obj.privateVar = 20;}
};

特性

  • 外部友元函数可访问类的私有和保护成员,友元函数仅仅是一种声明,他不是类的成员函数。
#include<iostream>
using namespace std;class A
{// 友元声明friend void func(const A& aa);
private:int _a1 = 1;int _a2 = 2;
};void func(const A& aa)
{cout << aa._a1 << " " << aa._a2 << endl;
}int main()
{A aa;func(aa);return 0;
}
  • 友元函数可以在类定义的任何地方声明,不受类访问限定符限制。
  • 一个函数可以是多个类的友元函数。
#include<iostream>
using namespace std;// 前置声明,否则A的友元函数声明时编译器不认识B
class B;class A
{// 友元声明friend void func(const A& aa, const B& bb);
private:int _a1 = 1;int _a2 = 2;
};class B
{// 友元声明friend void func(const A& aa, const B& bb);
private:int _b1 = 3;int _b2 = 4;
};void func(const A& aa, const B& bb)
{cout << aa._a1 << endl;cout << bb._b1 << endl;
}
int main()
{A aa;B bb;func(aa, bb);return 0;
}
  • 友元类中的成员函数都可以是另一个类的友元函数,都可以访问另一个类中的私有和保护成员
#include<iostream>
using namespace std;
class A
{// 友元声明friend class B;
private:int _a1 = 1;int _a2 = 2;
};
class B
{
public:void func1(const A& aa){cout << aa._a1 << endl;cout << _b1 << endl;}void func2(const A& aa){cout << aa._a2 << endl;cout << _b2 << endl;}
private:int _b1 = 3;int _b2 = 4;
};
int main()
{A aa;B bb;bb.func1(aa);bb.func2(aa);return 0;
}
  • 友元类的关系是单向的,不具有交换性,比如A类是B类的友元,但是B类不是A类的友元
  • 友元类关系不能传递,如果A是B的友元,B是C的友元,但是A不是C的友元
  • 友元有时提供了便利。但是友元会增加耦合度,破坏了封装,所以友元不宜多用

五. 内部类

概念

如果一个类定义在另一个类的内部,这个在类内部的类就叫做内部类。内部类是一个独立的类,跟定义在全局相比,他只是受外部类类域限制和访问限定符限制,所以外部类定义的对象中不包含内部类。

定义方式:内部类定义在外部类的内部,就像外部类的成员一样。

#include<iostream>
using namespace std;
class A {
public:class B {private:int _i = 3;int _j = 4;};
private:int _i = 1;int _j = 2;
};
int main()
{cout << sizeof(A) << endl;return 0;
}

特性

  • 内部类默认是外部类的友元类。内部类可以直接访问外部类的公共、保护和私有成员。外部类则不是内部类的友元
#include<iostream>
using namespace std;
class A
{
private:int _q = 2;int _h = 1;
public:class B // B默认就是A的友元{public:void foo(const A& a){cout << a._q << endl;cout << a._h << endl;}};
};
int main()
{//因为类B在类A里面,受到类域的限制,要实例化出一个B类型的对象,必须突破类域//需要使用域作用限定符::A::B b;A aa;b.foo(aa);return 0;
}
  • 内部类可以直接访问外部类的静态成员变量
#include<iostream>
using namespace std;
class A
{
private:static int _k;int _h = 1;
public:class B // B默认就是A的友元{public:void foo(const A& a){cout << a._k << endl;cout << a._h << endl;}//可以直接访问外部类的静态成员变量void print(){cout << _k << endl;}};
};
int A::_k = 1;
int main()
{cout << sizeof(A) << endl;A::B b;A aa;b.foo(aa);b.print();return 0;
}
  • 内部类本质也是一种封装,当A类跟B类紧密关联,A类实现出来主要就是给B类使用,那么可以考虑把A类设计为B的内部类,如果内部类使用访问限定符修饰(private/protected),那么A类就是B类的专属内部类,其他地方都用不了。

六. 匿名对象

概念

在C++中,匿名对象通常指的是没有名字的对象这种对象通常是临时的,并且只在创建它们的表达式中有效

用类型(实参)定义出来的对象叫做匿名对象,相比之前我们定义的类型对象名(实参)定义出来的叫有名对象。

#include<iostream>
using namespace std;
class A
{
public:A(int i = 1):_a(i){cout << "A(int i)" << endl;}~A(){cout << "~A()" << endl;}private:int _a;
};
int main()
{A a;A();return 0;
}

特性

  • 匿名对象生命周期只在当前一行,当编译器读到下一行代码时,匿名对象就会被自动销毁。一般临时定义一个对象当前用一下即可,就可以定义匿名对象。

在这里插入图片描述

  • 匿名对象可以调用它的成员函数
#include<iostream>
using namespace std;
class A
{
public:A(int i = 1):_a(i){cout << "A(int i)" << endl;}~A(){cout << "~A()" << endl;}int Get(int n){return n;}private:int _a;
};
int main()
{cout << A().Get(10) << endl;return 0;
}

在这里插入图片描述

  • 匿名对象可以作为参数传递给函数
#include<iostream>
using namespace std;
class A
{
public:A(int i = 1):_a(i){cout << "A(int i)" << endl;}~A(){cout << "~A()" << endl;}int Get(int n){return n;}private:int _a;
};
void Func(A a)
{}
int main()
{Func(A());return 0;
}

同时,匿名对象也可以作为函数参数的缺省值

void Func(A a = A())
{}
  • 匿名对象的引用

匿名对象是临时的,具有常性,想引用一个匿名对象时必须使用const引用(权限的平移)。使用const引用,我们可以确保引用不会修改源对象,同时延长了对象的生命周期,使其在整个程序运行期间都有效。这是因为const引用本身不会创建新的存储空间,而是直接引用原始对象。

#include<iostream>
using namespace std;
class A
{
public:A(int i = 1):_a(i){cout << "A(int i)" << endl;}~A(){cout << "~A()" << endl;}int Get(int n){return n;}private:int _a;
};
int main()
{A aa;const A& a = A();cout << "----------" << endl;return 0;
}

在这里插入图片描述
可以看到,通过const引用了一个匿名对象,const绑定到了匿名对象上使其生命周期延长,所以匿名对象不会被立马销毁。

如果不使用const引用,编译器就会报错,如下:
在这里插入图片描述

七. 对象拷贝时的编译器优化

1.现代编译器会为了尽可能提高程序的效率,在不影响正确性的情况下会尽可能减少一些传参和传返回值的过程中可以省略的拷贝。
2.如何优化C++标准并没有严格规定,各个编译器会根据情况自行处理。当前主流的相对新一点的编译器对于连续一个表达式步骤中的连续拷贝会进行合并优化,有些更新更"激进"的编译器还会进行跨行跨表达式的合并优化。

#include<iostream>
using namespace std;
class A
{
public:A(int a = 0):_a1(a){cout << "A(int a)" << endl;}A(const A& aa):_a1(aa._a1){cout << "A(const A& aa)" << endl;}A& operator=(const A& aa){cout << "A& operator=(const A& aa)" << endl;if (this != &aa){_a1 = aa._a1;}return *this;}~A(){cout << "~A()" << endl;}
private:int _a1 = 1;
};void f1(A aa)
{}
A f2()
{A aa;//cout << &aa << endl;return aa;
}
int main()
{//vs2019: 1构造一个临时对象A(1),临时对象再拷贝构造aa1,此时1隐式类型转换为临时对象//vs2022: 此时1隐式类型转换为临时对象A(1),相当于A aa1 = A(1);//为了避免拷贝,编译器优化为直接构造aa1,调用A aa1(1);A aa1 = 1;//传递实参aa1,拷贝构造aaf1(aa1);cout << endl;f1(1);// 隐式类型转换f1(A(1));// 显示调用,传匿名对象cout << endl;//vs2019: 构造+拷贝构造//vs2022: 直接构造(直接构造临时对象A())f2();cout << endl;//vs2019: 连续拷贝构造+拷贝构造->优化为一个拷贝构造//vs2022: 直接优化为直接构造,f2()中的aa不构造,构造aa2,并且aa是aa2的别名//aa和aa2的地址一样(在同一块内存空间),aa不会随着f2()的销毁而被析构A aa2 = f2();//cout << &aa2 << endl;cout << endl;//vs2019: 遇到连续拷贝构造+赋值重载->无法优化//vs2022: f2()可优化(直接构造),赋值重载无法优化aa1 = f2();cout << endl;return 0;
}

vs2019编译器(Debug)
在这里插入图片描述

vs2022编译器(Debug)
在这里插入图片描述
可以看到,版本越新的编译器优化得越好。

END

对以上内容有异议或者需要补充的,欢迎大家来讨论!

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

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

相关文章

玩的花,云产品也能拼团了!!!

说起拼单大家都不陌生&#xff0c;电商一贯的营销手段&#xff0c;不过确实可以给消费者省下一笔钱。双11到了&#xff0c;腾讯云产品也玩起了拼团&#xff0c;这明显是对开发人员和各企业的福利。 对于有云产品需求的个人或企业&#xff0c;这次绝对是难得的一次薅羊毛机会。…

深度学习-张量相关

一. 张量的创建 张量简介 张量是pytorch的基本数据结构 张量&#xff0c;英文为Tensor&#xff0c;是机器学习的基本构建模块&#xff0c;是以数字方式表示数据的形式。 例如&#xff0c;图像可以表示为形状为 [3, 224, 224] 的张量&#xff0c;这意味着 [colour_channels, h…

境内部署DIfy(上篇)

背景&#xff1a; 由于近2年大模型的火热催生出很多业务场景&#xff0c;这也迫使我们这些老一辈的程序搬运工去接触新事物&#xff0c;“工欲善其事必先利其器”&#xff0c;先从大模型应用开始摸索&#xff0c;网上大把工具&#xff0c;再三思考后决定先从Dify开始&#xff…

[CKS] 利用Trivy对image进行扫描

最近准备花一周的时间准备CKS考试&#xff0c;在准备考试中发现有一个题目关于Trivy镜像安全扫描的题目。 What’s Trivy Trivy的官方仓库https://github.com/aquasecurity/trivy&#xff0c;Trivy是一个开源的容器镜像漏洞扫描工具。它通过分析容器镜像中的操作系统包和应用…

vue3入门知识(一)

vue3简介 性能的提升 打包大小减少41%初次渲染快55%&#xff0c;更新渲染快133%内存减少54% 源码的升级 使用Proxy代替defineProperty实现响应式重写虚拟DOM的实现和Tree-Shaking 新的特性 1. Composition API&#xff08;组合API&#xff09; setupref与reactivecomput…

数据结构和算法入门

复杂度 大O记法 计算机怎么判断程序性能&#xff1f; 我们都知道编程基本上是在和数据打交道&#xff0c;大多数程序基本都在处理获取数据、查询数据、操作数据、返回数据相关的逻辑。 因此出现了数据结构和算法&#xff0c;这两者出现本质为了解决如何能够更快、更省进行数…

【Linux第八课-进程间通信】管道、共享内存、消息队列、信号量、信号、可重入函数、volatile

目录 进程间通信为什么&#xff1f;是什么&#xff1f;怎么办&#xff1f;一般规律具体做法 匿名管道原理代码 命名管道原理代码 system V共享内存消息队列信号量信号量的接口 信号概念为什么&#xff1f;怎么办&#xff1f;准备信号的产生信号的保存概念三张表匹配的操作和系统…

串的模式匹配

子串的定位操作通常称为串的模式匹配&#xff0c;它求的是子串(常称模式串)在主串中的位置。 子串——主串的一部分&#xff0c;一定存在 模式串——不一定能在主串中找到 朴素模式匹配 将主串中所有长度为m的子串&#xff08;共有n-m1个&#xff09;依次与模式串对比&…

继承的学习

1.继承 继承权限在类外&#xff0c;访问权限在类内部 1.1继承的概念 继承是面向对象程序设计使代码可以复用的重要手段&#xff08;解决类层次的复用问题&#xff09; 派生类&#xff1a;类特性的基础上进行扩展&#xff0c;增加方法&#xff08;成员函数&#xff09;和属性…

YOLOPv2论文翻译

YOLOPv2: Better, Faster, Stronger for Panoptic Driving Perception 摘要 在过去的十年中&#xff0c;多任务学习方法在解决全景驾驶感知问题方面取得了令人鼓舞的成果&#xff0c;既提供了高精度又具备高效能的性能。在设计用于实时实际自动驾驶系统的网络时&#xff0c;这…

跳表原理-课堂笔记

课程地址 跳表是一种基于随机化的有序数据结构&#xff0c;它提出是为了赋予有序单链表以 O(logn) 的快速查找和插入的能力 创建 首先在头部创建一个 sentinel 节点&#xff0c;然后在 L1 层采用“抛硬币”的方式来决定 L0 层的指针是否增长到 L1 层 例如上图中&#xff0c;L…

贪心day04(买卖股票的最佳时机)

1.买卖股票的最佳时机 题目链接&#xff1a;. - 力扣&#xff08;LeetCode&#xff09; 思路&#xff1a;我们其实只需遍历一篇就可以解决这个问题。首先我们定义一个min为无穷大值&#xff0c;再遍历只要有数字比min跟小我们就更改min的值就好&#xff0c;此时我们只需要找出…

【Python爬虫实战】深入解锁 DrissionPage:ChromiumPage 自动化网页操作指南

&#x1f308;个人主页&#xff1a;易辰君-CSDN博客 &#x1f525; 系列专栏&#xff1a;https://blog.csdn.net/2401_86688088/category_12797772.html ​ 目录 前言 一、ChromiumPage基础操作 &#xff08;一&#xff09;初始化Drission 和 ChromiumPage 对象 &#xff0…

VS Code 插件 MySQL Shell for VS Code

https://marketplace.visualstudio.com/items?itemNameOracle.mysql-shell-for-vs-code

稳压二极管详解

目录 1. 工作原理 2. 稳压二极管的伏安特性曲线 3. 正向特性&#xff1a; 4. 反向特性 5. 稳定电压&#xff08;Vz&#xff09; 6. 动态电阻&#xff08;rz&#xff09; 7.最大耗散功率&#xff08;PzM&#xff09; 8. 最大稳定工作电流&#xff08;IzMAX&#xff09;和…

Springboot 一个西餐主题网站-计算机设计毕业源码73020

目录 摘要 1 绪论 1.1 选题背景与意义 1.2国内外研究现状 1.3论文结构与章节安排 2系统分析 2.1 可行性分析 2.2 系统流程分析 2.2.1 数据流程 2.2.2 业务流程 2.3 系统功能分析 2.3.1 功能性分析 2.3.2 非功能性分析 2.4 系统用例分析 2.5本章小结 3 系统总体设…

JS渗透(安全)

JS逆向 基本了解 作用域&#xff1a; 相关数据值 调用堆栈&#xff1a; 由下到上就是代码的执行顺序 常见分析调试流程&#xff1a; 1、代码全局搜索 2、文件流程断点 3、代码标签断点 4、XHR提交断点 某通js逆向结合burp插件jsEncrypter 申通快递会员中心-登录 查看登录包…

世界技能竞赛大数据应用开发环境1:1还原

关注我&#xff0c;私信我获得集群环境 集群情况 模块A搭建环境&#xff0c;在容器中搭建大数据平台 Hadoop HA环境 Pc机&#xff0c;安装安装比赛需要软件 模块B中使用idea快速开发完成数据处理 模块E包含了接口数据&#xff0c;使用vs code快速搭建vue数据可视化

【c++丨STL】vector模拟实现

&#x1f31f;&#x1f31f;作者主页&#xff1a;ephemerals__ &#x1f31f;&#x1f31f;所属专栏&#xff1a;C、STL 目录 前言 一、vector底层刨析 二、模拟实现 1. 属性、迭代器以及函数声明 2. 功能实现 交换两个容器的内容 构造函数 拷贝构造 赋值重载 析构…

指针的运用

接下来我将会用的话&#xff0c;讲解我对指针运用仅有的印象 1.解引用 int a23; int*p&a; *p666; 而*p666&#xff1b;&#xff0c;便是解引用操作&#xff0c;跟简单地说*p便是解引用&#xff0c;它的意思是&#xff0c;对p中所储存的地址所在位置的内容进行操作&#xf…