c++-进阶其他

已于 2023-04-03 17:10:12 修改
阅读量348 收藏 1
点赞数
分类专栏： C/C++ 文章标签： c++ 开发语言
于 2022-12-29 09:39:52 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/L_fengzifei/article/details/128476509
版权

c++-进阶转换其他

转换构造函数

将其他类型转换为当前类型需要借助(转换)构造函数
转换构造函数也是一种构造函数，遵循一般构造函数的规则

#include <iostream>

using namespace std;

class Complex
{
private:
    double real;
    double imag;
public:
    Complex();
    Complex(double real,double imag);
    Complex(double real); // 转换构造函数 

    /*  
        友元函数
    */
    friend ostream& operator<<(ostream &out,Complex &c);
};

Complex::Complex()
{
    this->real=0.0;
    this->imag=0.0;
}

Complex::Complex(double real,double imag)
{
    this->imag=real;
    this->real=imag;
}

/*
    转换构造函数
    将double类型的参数real转换为complex类的对象

    转换构造函数也是构造函数，也可以用来进行初始化
*/
Complex::Complex(double real)
{
    this->real=real;
    this->imag=0.0;
}

// 将外部函数定义为友元函数
ostream & operator<<(ostream &out,Complex &c)
{
    cout<<"重载<<"<<endl;
    out<<c.real<<"+"<<c.imag<<"i"<<endl;
    return out;
}

int main()
{
    Complex a(10.0,20.2);
    cout<<a<<endl;

    /*
        等价于 a.complex(25.5)
        将赋值的过程转换成了函数调用的过程
    */
    a=25.5; // 调用转换构造函数
    cout<<a<<endl;
    
    /*
        以拷贝的方式初始化对象
        在以拷贝的方式初始化对象时，编译器先调用转换构造函数，将25.2转换为Complex类型，在拷贝给c

        对于已经重载了+运算符，可以进行算数相加
        c2=c1+20.2;
    */
    Complex c=20.2;

    return 0;
}

将当前类型转换为其他类型(类型转换函数)

operator datatype(){return data} type是要转换的目标类型，data是要返回的datatype类型的数据
只能出现在类中，类中的成员函数，该函数可以没有返回值类型的定义

#include <iostream>

using namespace std;

class Complex
{
private:
    double real;
    double imag;
public:
    Complex();
    Complex(double real,double imag);
    Complex(double real); // 转换构造函数 

    /*  
        友元函数
    */
    friend ostream& operator<<(ostream &out,Complex &c);

    friend Complex operator+(const Complex &c1,const Complex &c2);

    /*
        类型转换函数
    */
   operator double() const;

};

Complex::Complex()
{
    this->real=0.0;
    this->imag=0.0;
}

Complex::Complex(double real,double imag)
{
    this->real=real;
    this->imag=imag;
}

/*
    转换构造函数
    将double类型的参数real转换为complex类的对象

    转换构造函数也是构造函数，也可以用来进行初始化
*/
Complex::Complex(double real)
{
    this->real=real;
    this->imag=0.0;
}

// 将外部函数定义为友元函数
ostream & operator<<(ostream &out,Complex &c)
{
    cout<<"重载<<"<<endl;
    out<<c.real<<"+"<<c.imag<<"i"<<endl;
    return out;
}

Complex operator+(const Complex &c1,const Complex &c2)
{
    Complex c;
    c.real=c1.real+c2.real;
    c.imag=c1.imag+c2.imag;

    return c;
}

/*
    类型转换函数
*/
Complex::operator double() const
{
    return this->real;
}

int main()
{
    Complex c1(10.,20.);
    double f1=c1; // double d1 =Complex::operator double(&c1)
    cout<<f1<<endl;


    int n=Complex(11.,12.);
    cout<<n<<endl;

    return 0;
}

类型转换进阶 – 没看

见文档P392

移动构造函数

https://blog.csdn.net/weixin_44788542/article/details/126284429
https://blog.csdn.net/yue152152/article/details/127214251

C++11中的方法

拷贝构造与移动构造

拷贝构造

临时对象和拷贝构造后的对象各自占用不同的且大小相同的内存空间
即临时对象和新创建的对象申请的内存同时存在

对于匿名对象
只能调用const引用 这是因为常量左值一弄可以接受左值、右值、常量左值、常量右值
非常量左值引用，只能接收左值

对于非匿名对象(非临时对象，拷贝构造时可以选择const& 也可以选择非const&
系统优先选择后者(非const引用))
在这里插入图片描述

例子

g++ file.cpp -o file -fno-elide-constructors 取消编译优化

#include <iostream>
#include <string>

using namespace std;

class Integer
{
private:
    int *m_ptr;
public:
    Integer(int value);
    Integer(const Integer &src);
    Integer(Integer &src);
    ~Integer();
   
   int getValue(void);
};

Integer::Integer(int value)
    : m_ptr(new int(value))
{
    cout<<"有参构造函数"<<endl;
}

// 参数为常量左值引用的深拷贝构造函数
Integer::Integer(const Integer &src)
    : m_ptr(new int(*src.m_ptr)) // 创建的同时初始化
{
    cout<<"有参深拷贝构造函数"<<endl;
}

// 参数为左值引用的浅拷贝构造函数，转移堆内存资源所有权
Integer::Integer(Integer &src)
    : m_ptr(src.m_ptr) // 共享内存空间
{
    src.m_ptr=NULL; // 释放空间
    cout<<"有参浅拷贝构造函数"<<endl;
}

Integer::~Integer()
{
    cout<<"析构函数"<<endl;
    delete m_ptr;
}

int Integer::getValue(void)
{
    return *m_ptr;
}

Integer getNum(void)
{
    Integer a(100); // 有参构造函数
    return a;
}

int main()
{
    // 对于匿名对象
    // 只能调用const引用 这是因为常量左值一弄可以接受左值、右值、常量左值、常量右值
    // 非常量左值引用，只能接收左值
    Integer a(getNum()); // 拷贝构造
    cout<<"a: "<<a.getValue()<<endl;

    cout<<"*********"<<endl;
    // 对于非匿名对象(非临时对象，拷贝构造时可以选择const& 也可以选择非const&
    //               系统优先选择后者(非const引用))
    Integer temp(1000);
    Integer b(temp); //
    cout<<"b: "<<b.getValue()<<endl;

    return 0;
}
/*
    有参构造函数
    有参浅拷贝构造函数 // 局部变量到临时变量
    析构函数
    有参深拷贝构造函数 // 临时变量到主函数变量
    析构函数
    a: 100
    *********
    有参构造函数
    有参浅拷贝构造函数
    b: 1000
    析构函数
    析构函数
    析构函数
*/

移动构造

让这个临时对象原本控制的内存空间转移给构造出来的对象
原本由临时对象申请的内存空间，由于新创建对象的接管，临时对象不再指向该堆内存

返回返回一个局部变量，此时就是一个临时变量，因为在函数结束后就消亡了，对应内部的动态内存也会被析构掉，所以系统在执行return函数之前，需要在生成一个临时对象将a中的数据内存返回到被调的主函数中，

  1. 可以调用拷贝构造函数进行备份
  2. 使用移动构造函数把即将消亡的且仍需要用到的这部分内存的所有权进行转义，手动延长它的声明周期
  3. 如果没有移动构造函数，就使用普通的拷贝构造函数，否则优先选择移动构造函数
    在这里插入图片描述

例子

g++ file.cpp -o file -fno-elide-constructors 取消编译优化

#include <iostream>
#include <string>

using namespace std;

class Integer
{
private:
    int *m_ptr;
public:
    Integer() {m_ptr=new int(10);};
    Integer(int value);
    Integer(const Integer &src);
    Integer(Integer &&src);
    ~Integer();
   
   int getValue(void);
};

Integer::Integer(int value)
    : m_ptr(new int(value))
{
    cout<<"有参构造函数"<<endl;
}

// 参数为常量左值引用的深拷贝构造函数
Integer::Integer(const Integer &src)
    : m_ptr(new int(*src.m_ptr)) // 创建的同时初始化
{
    cout<<"有参深拷贝构造函数"<<endl;
}

// 参数为左值引用的浅拷贝构造函数，转移堆内存资源所有权
Integer::Integer(Integer&& src)
    : m_ptr(src.m_ptr) // 共享内存空间
{
    src.m_ptr=NULL; // 释放空间
    cout<<"有参移动构造函数"<<endl;
}

Integer::~Integer()
{
    cout<<"析构函数"<<endl;
    delete m_ptr;
}

int Integer::getValue(void)
{
    return *m_ptr;
}

Integer getNum(void)
{
    Integer a(100); // 无参构造函数
    return a;
}

int main()
{
	/*
		返回返回一个局部变量，此时就是一个临时变量，因为在函数结束后就消亡了，对应内部的动态内存也会被析构掉，所以系统在执行return函数之前，需要在生成一个临时对象将a中的数据内存返回到被调的主函数中，
		1. 可以调用拷贝构造函数进行备份
		2. 使用移动构造函数把即将消亡的且仍需要用到的这部分内存的所有权进行转义，手动延长它的声明周期
		3. 如果没有移动构造函数，就使用普通的拷贝构造函数，否则优先选择移动构造函数
	*/
    Integer a(getNum()); // 拷贝构造
    cout<<"a: "<<a.getValue()<<endl;

    cout<<"*********"<<endl;
    // 对于非匿名对象(非临时对象，拷贝构造时可以选择const& 也可以选择非const&
    //               系统优先选择后者(非const引用))
    Integer temp(1000);
    Integer b(temp); //
    cout<<"b: "<<b.getValue()<<endl;

    return 0;
}
/*
    有参构造函数 
    有参移动构造函数 // 局部变量到临时变量 不能调用const引用
    析构函数
    有参移动构造函数 // 临时变量到主函数变量 
    析构函数
    a: 100
    *********
    有参构造函数
    有参深拷贝构造函数
    b: 1000
    析构函数
    析构函数
    析构函数
*/

例子2

#include <iostream>
#include <string>
#include <cstring>

using namespace std;

class MyClass
{
private:
    char *str;
public:
    MyClass(); // 默认构造函数
    MyClass(const char *s); // 构造函数重载 深拷贝
    ~MyClass();

    MyClass & operator=(const MyClass &s); // 拷贝赋值操作符重载 （没有重载操作符时，或自动生成一个默认的）

    MyClass(MyClass &&s); // 移动构造，右值引用

    MyClass & operator=(MyClass &&s); // 移动赋值运算符重载
};

MyClass::MyClass(/* args */) // 构造函数
    :str(new char[1])
{
    cout<<"默认构造函数"<<endl;
    str[0]=0;
}

MyClass::MyClass(const char *s) // 构造函数重载
{
    cout<<"const 深拷贝"<<endl;
    str=new char[strlen(s)+1];
    strcpy(str,s);
}

MyClass & MyClass::operator=(const MyClass &s)
{
    cout<<"operator="<<endl;

    if (this->str!=s.str)
    {
        delete this->str;
        this->str=new char[strlen(s.str)+1];
        strcpy(this->str,s.str);
    }

    return *this;
}

MyClass::MyClass(MyClass &&s)
    :str(s.str)
{
    cout<<"移动构造"<<endl;
    s.str=new char[1];
    s.str[0]=0;
}

MyClass & MyClass::operator=(MyClass &&s)
{
    cout<<"移动operator="<<endl;
    if (this->str!=s.str)
    {
        this->str=s.str;
        s.str=new char[1];
        s.str[0]=0;
    }

    return *this;
}

MyClass::~MyClass()
{
    cout<<"析构函数"<<endl;
}

template <class T>
void moveSwap(T &a,T &b)
{
    T tmp(move(a)); // std::move() 为右值，这里会调用移动构造函数
    a=move(b); // move(b) 为右值 因此这里会调用移动构造函数
    b=move(tmp); // 同上
}


int main()
{
    MyClass s; // 默认构造

    cout<<"*********"<<endl;
    MyClass s1(MyClass("this1")); // 移动构造

    cout<<"*********"<<endl;
    MyClass s2;
    s2=MyClass("this2"); // 移动构造operator=


    return 0;
}

/*
    默认构造函数
    *********
    const 深拷贝
    移动构造
    析构函数
    *********
    默认构造函数
    const 深拷贝
    移动operator=
    析构函数
    
    析构函数
    析构函数
    析构函数
*/
aoaoGofei
关注
专栏目录
C++开发工程师成长之路----进阶篇
qq_42382539的博客
08-17 478
一、C/C++开发常用工具 常用工具介绍之C++集成开发环境（IDE） Microsoft Visual Studio： Windows平台下代码开发与编译工具，配合Visual Assist可跳转查看代码 VSCode： Windows平台下代码开发与编译工具，属于轻量型开发工具，需要配置插件 Ubuntu： Linux平台下代码开发和编译工具，可以灵活配置所需插件，可用第三方库用于开发 Eclipse： 可查看Linux平台代码，JAVA常用IDE，可以灵活配置所需插件 二、基于Linux平台开发要点
【C++题解】走楼梯-进阶版
szxguagua0807的博客
07-07 270
正在准备体育考试，他为跳远感到忧愁。级台阶，锻炼爆发力。为了方便枚举，我们可以选择从。你需要求：若刚开始时他处在。输出数量总数（最终结果需模。结束，然后要对i进行判断。所以循环从4开始，直到。
c++学习--c++进阶
m0_63599362的博客
10-09 1149
c++学习---时间复杂度，时间复杂度计算，二分法，前缀和，差分
C++常见面试题-进阶部分50题
kelvin_yin的专栏
12-19 711
C++常见面试题进阶部分50题
C++进阶教程
Weirdo的博客
06-10 2303
本教程介绍了C++中的一些高级特性和技术，包括面向对象编程、模板编程、STL的使用以及C++11/14/17等新标准中的新特性。这些特性和技术将帮助你更深入地理解C++，并提升你的编程能力。当然，C++的学习是一个持续的过程，不断地实践和探索将使你更加精通这门语言。
c++多线程--进阶
weixin_44048823的博客
01-22 353
文章目录c++多线程--进阶std::async和std::futurre含义:异步执行参数:参数={std::launch::async将在一个新线程中运行std::launch::deferred随着future调用get()后才在同一线程开始执行参数= \begin{cases} std::launch::async& \text{将在一个新线程中运行}\\ std::launch:...
C++——进阶之路
qq_36912885的博客
12-26 2611
我一直想是不是拜师，学学艺。有着大佬的庇佑，那岂不是轻车熟路，畅通无阻。后来，我又想了想。完全不用！按如今的环境，以及各种情况，综合因素，不可抗力，等等数不清的原因——不可能。 那么，究竟该如何在C++的道路上进阶。如果你是从娘胎里就开始编程的，有着这一个会编程的爹。那真是——如获至宝（苦命的孩子）。那么，我们半路出身的，野生的，该如何学习。又没有这么厉害的爹，考上大学都已经是自求多福了。选了计算机专业，希望以后出来能挣大钱。结果却是没日没夜的996。说了这么多，你还教人家...
c++_learning-进阶部分
qq_44599368的博客
10-18 744
类、类与类之间的关系：继承/组合/委托、可调用对象（函数指针、函数对象、匿名函数lambda表达式）、std::bind()绑定器、std::function类模板、c++11新标准：左/右值/左右值引用、可变参数模板、资源管理方案RAII、指针、重载new/delete/new[]/delete[]、智能指针：shared_ptr/weak_ptr/unique_ptr、c++的多态：静态/动态多态
程序员的自我修养--进阶之路
m0_55557037的博客
08-04 83
C Primer Plus 第6版 中文版.pdf。C++ Primer 中文版 第5版.pdf。C++编程思想（两卷合订本）.pdf。C程序设计语言 第2版.pdf。C++程序设计语言.pdf。
C++ 进阶汇总 [持续更新-建议收藏]
大道之行，始于足下
08-13 1557
C++ 进阶汇总 [持续更新-建议收藏]
C++基础-进阶.rar
11-06
这个"C++基础-进阶.rar"压缩包文件显然是一份全面的C++学习资料，旨在帮助初学者从基础知识逐渐过渡到进阶技能，最终通过项目历练提升实际操作能力。 C++的基础部分通常包括以下知识点： 1. **语法基础**：C++的...
算法开发--进阶内容1
08-08
在算法开发的进阶内容1中，我们主要探讨的是与计算机视觉和图像处理相关的高级话题。这些主题包括但不限于数值计算库的使用、图像处理的数学基础、C++实现的图像处理算法、深度学习在图像处理中的应用以及并行计算...
C语言程序设计--进阶篇教学视频
06-08
该课程为“C语言及程序设计”系列课程中的第三部“进阶篇”。作为终结篇C语言教程，介绍了在实际应用中应用广泛的结构体数据表示和处理、利用文件进行输入输出、利用多文件组织项目开发，并结合对程序设计的进一步...
ANO-Settler-V3-进阶版_匿名小四轴工程_
09-28
Keil工程中通常包含C或C++源代码，可能分为多个文件和文件夹，如主程序、驱动程序、传感器处理、通信协议等模块。开发者可以通过阅读和分析这些源代码来理解整个系统的运行机制，包括如何读取传感器数据、如何处理...
新生手册 - 进阶(1).pdf
11-10
STL是C++编程语言中的一个核心组件，它提供了多种容器（如vector、list、set、map等）、迭代器、算法和函数对象。STL的主要优点是代码复用、效率高和模块化设计。特别地，`map`和`sort`是两个非常实用的工具。`map`...
编译器、IDE对C/C++新标准的支持
编程语言技巧经验分享
11-08 724
很遗憾的是，微软VC++对C99的支持直到VS2015才基本完全支持，在VS2012之前，仅仅支持C89. 也正是2015年之前，这么多人骂微软并纷纷转移到其它C语言编译器的原因。VS2019开始才正式宣布支持C11/C17.对于C++标准，VS2013开始支持C++11，VS2017支持C++17, VS2019支持C++20, 显然，微软更偏爱C++.
C 学习（4）
search7的博客
11-05 750
C语言学习，每个模块来自工作中的？？？
GitLab 提交 C++ 技巧
nbspzs的专栏
11-08 121
在 GitLab 中提交 C++ 代码时，通常应只提交 源代码文件（例如 .cpp、.h）和 CMake 配置文件（例如 CMakeLists.txt），而不要提交通过 CMake 编译后的中间文件或构建产物。这样，当其他开发者克隆你的项目后，他们可以在自己的机器上使用 cmake 构建项目，而不需要下载编译产物。2. 跨平台兼容性：不同的开发者和平台可能会生成不同的编译产物，提交这些文件会造成不必要的冲突和问题。1. 在 .gitignore 文件中忽略编译生成的文件和目录。
C++builder中的人工智能（15）：C++高斯误差线性单元（GELU）
最新发布
caridle的专栏
11-08 409
激活函数（phi()），也称为转移函数或阈值函数，它根据净输入函数的给定值（sum）确定激活值（a = phi(sum)）。在这里，sum是它们权重中的信号之和，激活函数是这个和的新值，具有给定的函数或条件。换句话说，激活函数是将所有加权信号的和转换为该信号的新激活值的方法。有不同类型的激活函数，通常使用的是线性（恒等）、双极性和逻辑（sigmoid）函数。在C++（以及大多数编程语言）中，你可以创建自己的激活函数。注意，sum是净输入函数的结果，它计算所有加权信号的和。我们将使用这些作为输入函数的结果。
C++编程进阶：More Effective C++
《More Effective C++》是C++编程领域的一本经典教材，由Scott Meyers撰写，旨在帮助程序员提升C++编程的效率和质量。本书的核心在于分享作者深入实践后积累的工程经验，通过一系列简洁而深入的建议，揭示了C++语言...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值