C++类基础（六）

最新推荐文章于 2024-06-02 09:08:44 发布
最新推荐文章于 2024-06-02 09:08:44 发布
阅读量318 收藏
点赞数
文章标签： c++ 开发语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_34762931/article/details/128894001
版权

构造、析构与复制成员函数
● 单一参数构造函数
– 可以视为一种类型转换函数

struct Str
{
    Str(int x)
        : val(x)
    {
        std::cout << val << '\n';
    }
private:
    int val;
};

void fun(Str m)
{
    std::cout << "void fun(Str m)\n";
}
int main()
{
    Str m(3);
    Str m2 = 4; //=实现了从int类型到Str类型的转换
    fun(5); //fun()函数也实现了从int类型到Str类型的转换
    return 0;
}

在这里插入图片描述

– 可以使用 explicit 关键字避免求值过程中的隐式转换

struct Str
{
    explicit Str(int x)
        : val(x)
    {
        std::cout << val << '\n';
    }
private:
    int val;
};

void fun(Str m)
{
    std::cout << "void fun(Str m)\n";
}
void foo(int x)
{
    std::cout << "void foo(int x)\t";
}
int main()
{
    Str m(3); //OK
    Str m2{3}; //OK
    Str m3 = Str(3); //OK
    Str m4 = Str{3}; //OK
    Str m5 = 4; //Error: No viable conversion from 'int' to 'Str'
    fun(5); //Error: No matching function for call to 'fun'
    fun(Str(5)); //OK
    fun(Str{5}); //OK
    Str m6 = static_cast<Str>(3) //OK
    return 0;
}

● 拷贝构造函数：接收一个当前类对象的构造函数.

struct Str
{
    Str() = default;
    Str(const Str& x) //拷贝构造函数。C++标准: 当存在一个构造函数时（即使是拷贝构造函数），编译器拒绝合成缺省构造函数
        : val(x.val)
    {
        std::cout << "Str(const Str& x)" << '\n';
    }
private:
    int val = 3; //类内初始化
};
int main()
{
    Str m; //当只有拷贝构造函数而没有缺省构造函数时Error:  No matching constructor for initialization of 'Str';当添加缺省构造函数时OK
    Str m2(m); //OK
    Str m3 = m; //OK
    Str m4 {m}; //OK
    return 0;
}

在这里插入图片描述

– 会在涉及到拷贝初始化的场景被调用，比如：参数传递。因此要注意拷贝构造函数的形参类型

struct Str
{
    Str() = default;
    Str(const Str& x) //拷贝构造函数，注意形参声明为const类型的引用。C++标准: 当存在一个构造函数时（即使是拷贝构造函数），编译器拒绝合成缺省构造函数
    //Str(Str x) //Error: Copy constructor must pass its first argument by reference. 实参传入到形参时调用拷贝构造函数，导致递归调用
    //Str(Str& x) //不理想，函数可能对传入的实参进行修改，所以添加const限定符表示函数不会修改实参的值
        : val(x.val)
    {
        std::cout << "Str(const Str& x)" << '\n';
    }
private:
    int val = 3; //类内初始化
};
int main()
{
    Str m; //当只有拷贝构造函数而没有缺省构造函数时Error:  No matching constructor for initialization of 'Str';当添加缺省构造函数时OK
    std::cout << "Start copy construction:\n";
    Str m2(m); //OK
    Str m3 = m; //OK
    Str m4 {m}; //OK
    return 0;
}

在这里插入图片描述

– 如果未显式提供，那么编译器会自动合成一个，合成的版本会依次对每个数据成员调用拷贝构造

struct Str
{
    int val;
    char* string; //注意动态内存申请时的浅拷贝
};
int main()
{
    Str m;
    Str m2 = m; //OK
    return 0;
}

struct Str
{
    Str(const Str&) = default;
    int val;
    char* string; //注意动态内存申请时的浅拷贝
};
int main()
{
    Str m; //Error: No matching constructor for initialization of 'Str'
    return 0;
}

struct Str
{
    Str() = default; //无需书写形参的名称
    Str(const Str&) = default;
    int val;
    char* string;
};
int main()
{
    Str m; //OK
    Str m2 = m; //OK
    return 0;
}

● 移动构造函数 (C++11) ：接收一个当前类右值引用对象的构造函数

int main()
{
    std::string ori("abc");
    std::string newStr = ori;
    std::cout << newStr << std::endl;
    std::cout << ori << std::endl;
    std::string newStr2 = std::move(ori); //移动构造: 将ori里面的内容转给了newStr2
    std::cout << newStr2 << std::endl;
    std::cout << ori << std::endl; //ori为空
    return 0;
}

在这里插入图片描述

– 可以从输入对象中“ ” 偷窃 资源，只要确保传入对象处于合法状态即可

struct Str
{
    Str() = default;
    Str(const Str&) = default;
    Str(Str&& x) //移动构造函数，注意形参声明为本类型的右值引用，因为当前操作存在对形参的写操作，所以不能有const限定符
        :val(x.val)
        ,a(std::move(x.a))
    {}
    void fun()
    {
        std::cout << val << '\t' << a <<std::endl;
    }
    int val = 3;
    std::string a = "abc";
};
int main()
{
    Str m;
    m.fun(); //输出3 abc
    Str m2 = std::move(m);
    m.fun(); //输出3
    return 0;
}

在这里插入图片描述

– 当某些特殊成员函数（如拷贝构造）未定义时，编译器可以合成一个

struct Str2
{
    Str2(const Str2&) //#4，定义了拷贝构造函数，编译器不会为这个类自动合成一个移动构造函数，也不会自动合成一个缺省构造函数
    {
        std::cout<< "Str2::Str2(const Str2&)\n" ;
    }
};

struct Str
{
    Str() = default; //使用编译器缺省的行为，此处编译器不能自动合成缺省构造函数，因为Str2没有缺省构造函数（见#4）
                     //#3，Error: default constructor of 'Str' is implicitly deleted because field 'm_str' has no default constructor
    Str(const Str&) = default;
    Str(Str&& x) = default;
    int val = 3;
    std::string a = "abc";
    Str2 m_str; //#2，Error: explicitly defaulted function was implicitly deleted here
};
int main()
{
    //Str2中没有定义缺省构造函数导致#1、#2和#3处的Error
    Str m; //#1，Error: Call to implicitly-deleted default constructor of 'Str'
    Str m2 = std::move(m);
    return 0;
}

struct Str2
{
    Str2() = default;
    Str2(const Str2&)
    {
        std::cout<< "Str2::Str2(const Str2&)\n" ;
    }
};

struct Str
{
    Str() = default;
    Str(const Str&) = default;
    Str(Str&& x) = default; //首先: 移动构造函数是有效的
    int val = 3;
    std::string a = "abc";
    Str2 m_str; //同时: 类Str的数据成员包含另一个用户自定义类型Str2，并且Str2类内只定义了拷贝构造函数没有定义移动构造函数
};
int main()
{
    Str m;
    Str m2 = std::move(m); //那么: 类Str的移动构造函数在处理数据成员(Str2)m_str时，会调用类Str2的拷贝构造函数
    return 0;
}

在这里插入图片描述

struct Str2
{
    Str2() = default;
    Str2(const Str2&)
    {
        std::cout<< "Str2::Str2(const Str2&)\n" ;
    }
    Str2(Str2&&)
    {
        std::cout << "Str2::Str2(Str2&&)\n";
    }
};

struct Str
{
    Str() = default;
    Str(const Str&) = default;
    Str(Str&& x) = default; //首先: 移动构造函数是有效的
    int val = 3;
    std::string a = "abc";
    Str2 m_str; //同时: 类Str的数据成员包括另一个用户自定义类型Str2，Str2类内定义了拷贝构造函数和移动构造函数
};
int main()
{
    Str m;
    Str m2 = std::move(m); //那么: 类Str的移动构造函数在处理数据成员(Str2)m_str时，会调用类Str2的移动构造函数（换言之，类Str2中有移动调移动，没移动调拷贝）
    return 0;
}

在这里插入图片描述

– 通常声明为不可抛出异常的函数

struct Str2
{
    Str2() = default;
    Str2(const Str2&) //拷贝构造函数可能会抛出异常
    {
        std::cout<< "Str2::Str2(const Str2&)\n" ;
    }
};

struct Str
{
    Str() = default;
    Str(const Str&) = default;
    Str(Str&& x) noexcept = default; //但是将移动构造函数声明为不会抛出异常，可能导致系统崩溃
    int val = 3;
    std::string a = "abc";
    Str2 m_str;
};
int main()
{
    Str m;
    Str m2 = std::move(m);
    return 0;
}

struct Str2
{
    Str2() = default;
    Str2(const Str2&)
    {
        std::cout<< "Str2::Str2(const Str2&)\n" ;
    }
    Str2(Str2&&) noexcept //OK
    {
        std::cout << "Str2::Str2(Str2&&)\n";
    }
};

struct Str
{
    Str() = default;
    Str(const Str&) = default;
    Str(Str&& x) noexcept = default; //OK, 编译器不会引入相应的异常逻辑，保证了不降低性能；更重要地，很多数据结构会在保证移动构造函数不会抛出异常的时候才会去使用它
    int val = 3;
    std::string a = "abc";
    Str2 m_str;
};
int main()
{
    Str m;
    Str m2 = std::move(m);
    return 0;
}

– 注意右值引用对象用做表达式时是左值！

struct Str
{
    Str() = default;
    Str(const Str&) = default;
    Str(Str&& x) noexcept //x声明为右值引用
    {
        std::string tmp = x.a; //x被视为左值来使用，没有“偷掉”x的数据成员std::string a
        std::cout << x.a <<std::endl;
        std::string tmp2 = std::move(x.a); //“偷掉”了x的数据成员std::string a
        std::cout << x.a <<std::endl;
    }
    int val = 3;
    std::string a = "abc";
};
int main()
{
    Str m;
    Str m2 = std::move(m);
    return 0;
}

在这里插入图片描述

struct Str
{
    Str(int input, std::string str)
    {
        val = input;
        a = str;
    }
    Str(const Str&) = default;
    Str(Str&& x) noexcept
    {
        std::string tmp = x.a;
        std::cout << x.a <<std::endl;
        std::string tmp2 = std::move(x.a);
        std::cout << x.a <<std::endl;
    }
    int val = 3;
    std::string a = "abc";
};
void fun(Str&& x) //x声明为右值引用，普通函数中也被视为左值来使用
{
    std::cout << x.a <<std::endl;
    std::string tmp2 = std::move(x.a); //也“偷掉”了x的数据成员std::string a
    std::cout << x.a <<std::endl;
}
int main()
{
    fun(Str(5, "mystring"));
    return 0;
}

在这里插入图片描述

参考
深蓝学院：C++基础与深度解析

文祐
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
C++拷贝构造函数语意学 copy constructor(The Semantics of Constructors)
zhangqixiang5449的博客
10-26 868
使用copy constructor的三种情况有三种情况，会以一个object的内容作为另一个class object的初值。 1.显式的以一个object的内容作为另一个class object的初值class X{......}; X x; X xx = x;2.当object被当做参数交给某个函数时void foo(X x); void bar(){ X xx; foo(xx
C++程序设计总结
echo_xiao9的博客
05-15 789
绪论 1.机器语言：每个语句用一组二进制数表示 汇编语言：和机器语言一样，不同类的机器有不同的汇编语言，要汇编器处理后机器才懂. 高级语言：需要编译器或解释器翻译后机器才懂 2.预处理命令: #include <iostream> using namespace std; 3.int long 4byte Short 2byte float 4byte 4.指数必须为整数 2.5e2.3是非法的 5.优先级： ! > 关系运算符 > &...
C++ 类与构造函数 三五法则
最新发布
baiiu
06-02 1114
定义了拷贝操作的类类通常拥有一个资源，而拷贝成员必须拷贝此资源。但是拷贝一个资源会导致一些额外开销。在这种拷贝并非必要的情况下，定义了移动构造函数和移动赋值运算符的类就可以避免此问题。
C++构造函数/拷贝控制
ArtAndLife的博客
04-17 1320
条款05：了解C++默默编写并调用哪些函数 ==> 请记住： （1）编译器可以暗自为class创建default构造函数、copy构造函数、copy assignment操作符，以及析构函数。 ==> 解析： 合成的构造函数和析构函数，主要供编译器用来防止一些必要的代码，如对成员变量（非静态）的默认构造函数、放置基类的构造函数（如果此类是一个派生类） 等；析构函数则反之（合成的析构函数是非virtual）。 至于 拷贝构造函数和拷贝赋值运算符，编译器合成的版本只是简单复制（浅拷贝）。 有两种情况
C++关于联合体嵌套结构体使用注意
qq_32162235的博客
10-26 2023
typedef struct B { string ip; } B; typedef union A{ B b; }A; 如上代码，在类内无法定义 A a; 这个成员变量，否则会出现如下错误提示： error: call to implicitly-deleted default constructor of '****' note: default constructor of '****' is implicitly deleted because field '****.
c++基础教案.ppt
11-24
这份基础教案主要涵盖了C++的核心概念，包括C++概述、函数、类和对象、友元和重载、模板以及继承。 ### 第一节 C++概述 1. **main()函数**：每个C++程序的入口点是`main()`函数，这是操作系统启动执行的起点。`...
C++基础与提高 王桂林
10-05
### C++基础与提高 #### 一、综述C++ 本书《C++基础与提高》由王桂林编写，旨在帮助读者全面理解C++语言的基本概念和技术，并深入探讨面向对象编程的核心思想及其在C++中的应用。 #### 二、C++的发展历程与应用...
C++语言基础
02-13
### C++语言基础知识点 #### 一、C++语言简介 C++是一种静态类型的、编译式的、通用的、大小写敏感的、不规则的编程语言，支持多种编程范式，包括面向对象、泛型、过程式编程等。C++是在C语言的基础上发展而来的，...
c++基础入门.docx
02-28
### C++基础入门知识点详解 #### 一、变量与数据类型 C++作为一种强大的静态类型编程语言，提供了丰富的数据类型来满足不同的需求。常见的数据类型包括： - **整型** (`int`, `short`, `long`): 用于表示整数。 - ...
C++基础教程-完整版Juan Soulie.pdf
01-08
第六章讲述了C++标准函数库，包括文件输入/输出、字符串处理、容器类、算法等。 学习建议 为了更好地学习C++，读者可以根据自己的需求选择学习章节，并且可以快速阅读前三章的内容，因为这些内容主要介绍了C++的...
WebRTC 编译
mabc1234的博客
02-01 1528
WebRTC 源码下载编译
错误解决：no matching constructor for initialization of 'std::thread'
热门推荐
...
02-16 2万+
在MacOS中，尝试在C++的多线程中传入参数，发现报错： no matching constructor for initialization of 'std::thread' 原因：MacOS的g++使用clang，默认不支持C++11多线程。 解决方法：编译指令加上 -std=c++11 例如：g++ -std=c++11 fileToCompile.cpp -o outputFile.ou...
拷贝构造函数和赋值表达式的区别
sd6264456的专栏
01-07 493
一、引入   拷贝构造函数，用已创建的对象来初始化新建对象，对于一个已经被初始化的对象则进行operator=赋值操作。 class   A;    A a; A b=a;   //拷贝构造函数调用 A b(a);   //拷贝构造函数调用 A a; A b; b =a;   //赋值运算符调用 拷贝构造函数首先是一个构造函数，它调用的时候产生
pass by value 与pass by reference 小结
csw_100的专栏
04-21 1万+
缺省条件下，c++都是以pass by value形式传递函数参数的，而值传递的参数，编译器知道这个参数收到保护，不会修改其值，实际上修改的都是通过拷贝构造函数另外创建的参数副本，当函数返回时还要调用相应的析构函数析构参数副本，这可能使得pass by value方式传递参数变成低效率的操作，不仅仅如此，pass by value还会造成“对象的切割”，当一个派生类derived class对象以
ioS开发－－Warning警告处理
zzzzzdddddxxxxx的专栏
11-29 1万+
去除警告的方法： #pragma clang diagnostic push #pragma clang diagnostic ignored"-Wunused-function" local void free_linkedlist(ll) linkedlist_data* ll; { free_datablock(ll->first_block); ll->first_blo
C++引用和拷贝构造函数(References & the Copy-Constructor)
吾尝终日而思矣，不如须臾之所学也
04-25 2073
         在Thiking in C++中，专门有一章来讲解References & the Copy-Constructor这个主题，讲解得比较透彻。根据英文的Copy-Constructor，“拷贝构造函数”是一个名词，而不是动宾结构的短语。我用我的方法对这一问题琢磨了一下，在本文的最后有完整的代码。1. Pass-By-Reference        在C++里可以使用
C++：pass by reference的时候真正传递的是什么？
tong_xin2010的专栏
08-27 1322
如果窥视c++编译器的底层，你会发现，references往往以指针实现出来，因此pass-by-reference通常意味着这真正传递的是指针。
C++类详解：从基础到高级特性
通过学习这些章节，学生可以掌握C++类的基础概念，理解如何创建、操作和管理类，以及如何利用类的特性提高程序的组织和性能。此外，了解静态成员和友元的使用对于高级编程技巧的理解至关重要。在实践中，合理运用...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值