C++学习笔记——（十）智能指针，类型转换，宏

最新推荐文章于 2024-08-28 21:42:31 发布
最新推荐文章于 2024-08-28 21:42:31 发布
阅读量1.6k 收藏 1
点赞数
分类专栏： C/C++学习笔记 文章标签： c++ 开发语言 C++学习笔记
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/miyuexingchen/article/details/121660485
版权

注：编码工具是CLion+Cygwin64

目录

智能指针

shared_ptr

引用计数器

循环引用

weak_ptr

unique_ptr

仿写智能指针

类型转换

const_cast

static_cast

dynamic_cast

reinterpret_cast

宏

#define

宏函数

#if、#elif、#else、#endif

#ifdef、#ifndef、#undef

实践案例

智能指针

        智能指针可以用于自动回收new方式创建的对象。使用前需要先导入memory头文件。

shared_ptr

#include <iostream>

using namespace std;

#include <memory>
class Test{
public:
    ~Test(){
        cout << "Test析构函数" << endl;
    }
};
int main(){
    Test * test = new Test;
    shared_ptr<Test> ptr(test);
    return 0;
}

输出：

Test析构函数

        可以看到上面代码中没有调用delete函数回收对象，对象的析构函数也被调用了。       

引用计数器

        智能指针内部会有一个对象引用计数器，记录对象被智能指针引用的次数。

#include <iostream>

using namespace std;

#include <memory>
class Test{
public:
    ~Test(){
        cout << "Test析构函数" << endl;
    }
};
int main(){
    Test * test = new Test;
    shared_ptr<Test> ptr(test);
    cout << "引用计数值为：" << ptr.use_count() << endl;
    shared_ptr<Test> ptr2 = ptr;
    cout << "引用计数值为：" << ptr.use_count() << endl;
    cout << "引用计数值为：" << ptr2.use_count() << endl;
    return 0;
}

输出：

引用计数值为：1
引用计数值为：2
引用计数值为：2
Test析构函数

循环引用

        shared_ptr类型的智能指针可能导致循环引用，因而对象的析构函数无法被调用。

#include <iostream>

using namespace std;

#include <memory>
class B;
class A{
public:
    shared_ptr<B> ptr;

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

class B{
public:
    shared_ptr<A> ptr;

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


int main(){
    A * a = new A;
    B * b = new B;
    shared_ptr<A> ptrA(a);
    shared_ptr<B> ptrB(b);
    a->ptr = ptrB;
    b->ptr = ptrA;

    cout << "A的引用计数为：" << ptrA.use_count() << endl;
    cout << "B的引用计数为：" << ptrB.use_count() << endl;
    return 0;
}

输出：

A的引用计数为：2
B的引用计数为：2

        可以看到并没有输出A和B的析构函数中的打印信息，所以A和B的析构函数没有被调用。这是因为A和B都是通过new方式创建的对象，虽然ptrA和ptrB在main函数执行完被回收了，引用计数器也都减了1，但是A和B中的相互引用还存在，引用计数不为0，智能指针中没有调用delete函数释放A和B。

        ·要解决循环引用的问题，可以用另一种智能指针weak_ptr。

weak_ptr

        weak_ptr类型的智能指针，不会增加对象的引用计数。

#include <iostream>

using namespace std;

#include <memory>
class B;
class A{
public:
    weak_ptr<B> ptr;

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

class B{
public:
    weak_ptr<A> ptr;

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


int main(){
    A * a = new A;
    B * b = new B;
    shared_ptr<A> ptrA(a);
    shared_ptr<B> ptrB(b);
    a->ptr = ptrB;
    b->ptr = ptrA;

    cout << "A的引用计数为：" << ptrA.use_count() << endl;
    cout << "B的引用计数为：" << ptrB.use_count() << endl;
    return 0;
}

输出：

A的引用计数为：1
B的引用计数为：1
B析构函数
A析构函数

unique_ptr

        unique_ptr不允许同类型的类型指针赋值。

        unique_ptr没有引用计数。

#include <iostream>

using namespace std;

#include <memory>

class Test{
public:
    ~Test(){
        cout << "Test析构函数" << endl;
    }
};

int main(){
    Test * test = new Test;
    unique_ptr<Test> ptr(test);
//    unique_ptr<Test> ptr2 = ptr; // 编译不通过
    return 0;
}

输出：

Test析构函数

仿写智能指针

#include <iostream>

using namespace std;

template <typename T>
class Ptr{
private:
    T * object;
    int * count;
public:
    Ptr(){
        object = NULL;
        count = new int(1);
    }

    Ptr(T * t){
        object = t;
        count = new int(1);
    }

    ~Ptr(){
        if(--(*count) == 0){
            if(object)
            {
                delete object;
            }
            delete count;
            object = NULL;
            count = 0;
        }
    }

    // 用一个智能指针对象初始化一个新的智能指针对象时，会调用拷贝构造函数
    Ptr(const Ptr<T> & ptr){
        cout << "调用了Ptr的拷贝构造函数" << endl;
        ++(*(ptr.count));
        // 如果智能指针之前引用其他对象，则需要先释放
        if(--(*count) == 0){
            if(object){
                delete object;
            }
            delete count;
        }
        object = ptr.object;
        count = ptr.count;
    }

    // 先用默认构造函数初始化一个对象，再将另一个对象赋值给此对象时，会用到=
    // 所以要重载=运算符
    Ptr & operator=(const Ptr & ptr){
        cout << "调用了重载=运算符函数" << endl;
        ++(*(ptr.count));
        // 如果智能指针之前引用其他对象，则需要先释放
        if(--(*count) == 0){
            if(object){
                delete object;
            }
            delete count;
        }
        object = ptr.object;
        count = ptr.count;
        return *this;
    }

    int use_count(){
        return *(this->count);
    }
};

class Test{
public:
    ~Test(){
        cout << "调用了Test析构函数" << endl;
    }
};

int main(){
    Test * test = new Test();
    Ptr<Test> ptr(test);
    cout << "ptr引用计数为：" << ptr.use_count() << endl;
    // 调用拷贝构造函数
    Ptr<Test> ptr2 = ptr;
    cout << endl << "ptr引用计数为：" << ptr.use_count() << endl;
    cout << "ptr2引用计数为：" << ptr2.use_count() << endl;
    // 调用重载=运算符函数
    Ptr<Test> ptr3;
    ptr3 = ptr;
    cout << endl << "ptr引用计数为：" << ptr.use_count() << endl;
    cout << "ptr2引用计数为：" << ptr2.use_count() << endl;
    cout << "ptr3引用计数为：" << ptr3.use_count() << endl;
    return 0;
}

输出：

ptr引用计数为：1
调用了Ptr的拷贝构造函数

ptr引用计数为：2
ptr2引用计数为：2
调用了重载=运算符函数

ptr引用计数为：3
ptr2引用计数为：3
ptr3引用计数为：3
调用了Test析构函数

类型转换

const_cast

        常量转换，可以将常量指针转换为普通指针，从而可以修改该指针所指向的内存地址的值。

#include <iostream>

using namespace std;

class Test{
public:
    string name = "default";
};

int main(){
    const Test* test = new Test;
    cout << "before：name = " << test->name << endl;
//    test->name = "update";// 编译不通过
    Test * ntest = const_cast<Test*>(test);
    ntest->name = "update";
    cout << "after：name = " << test->name << endl;
    if(test){
        delete test;
        test = NULL;
    }
    return 0;
}

输出：

before：name = default
after：name = update

static_cast

        静态转换主要是转换指针类型，例如可以将void*转换为int*，double*等，前面线程中就用到了。

        静态转换还可以将父类型的对象转换为子类型。

        静态转换调用函数看等号左边变量类型，这是在编译器就决定了的。

#include <iostream>

using namespace std;

class Base{
public:
    void show(){
        cout << "Base show" << endl;
    }
};

class Sub: public Base{
public:
    void show(){
        cout << "Sub show" << endl;
    }
};

int main(){
    int number = 9999;
    void * vp = &number;
    int * ip = static_cast<int*>(vp);
    cout << "*ip = " << *ip << endl;

    Base * base = new Base;
    // 静态转换还可以将父类型的对象转换为子类型。
    Sub * sub = static_cast<Sub*>(base);
    base->show();
    // 静态转换调用函数看等号左边变量类型，这是在编译器就决定了的。
    sub->show();
    if(base){
        // 谁是new出来的，就delete谁
        delete base;
        base = NULL;
    }
    return 0;
}

输出：

*ip = 9999
Base show
Sub show

dynamic_cast

        动态转换运行期才能知道调用哪个函数。

        动态转换不能将父类型对象转换为子类型对象。

        动态转换返回如果是NULL，表示转换失败。

        动态转换中，父类的函数必须声明为虚函数。

#include <iostream>

using namespace std;

class Base{
public:
    virtual void show(){
        cout << "Base show" << endl;
    }
};

class Sub: public Base{
public:
    void show(){
        cout << "Sub show" << endl;
    }
};

int main(){
    Base * base = new Base;
    // 动态转换不可以将父类型的对象转换为子类型。
    Sub * sub = dynamic_cast<Sub*>(base);
    if(sub){
        cout << "Base->Sub转换成功" << endl;
        sub->show();
    }else{
        cout << "Base->Sub转换失败" << endl;
    }

    Sub * sub2 = new Sub;
    Base * base2 = dynamic_cast<Base*>(sub2);
    if(base2)
    {
        cout << "Sub->Base转换成功" << endl;
        base2->show();
    }else{
        cout << "Sub->Base转换失败" << endl;
    }

    if(base){
        // 谁是new出来的，就delete谁
        delete base;
        base = NULL;
    }
    if(sub2){
        // 谁是new出来的，就delete谁
        delete base;
        base = NULL;
    }
    return 0;
}

输出：

Base->Sub转换失败
Sub->Base转换成功
Sub show

reinterpret_cast

        强制转换，静态转换有的功能它都有，同时它还可以将对象转换为数值，可以将数值转换为对象。

        可以用于在Java和C++之间传递对象地址，Android源码中Handler和Binder都用到了reinterpret_cast，C++将对象转换为long型值传给Java，C++在需要对象的时候，Java再将long型值传给C++。

#include <iostream>

using namespace std;

class Test{
public:
    void show(){
        cout << "test reinterpret_cast" << endl;
    }
};
int main(){
    Test * test = new Test;
    long paddr = reinterpret_cast<long>(test);
    cout << "paddr = " << paddr << endl;
    Test * reTest = reinterpret_cast<Test*>(paddr);
    reTest->show();
    printf("paddr = %p\n", paddr);
    printf("test存储的地址值是：%p\n", test);
    printf("reTest存储的地址值是：%p\n", reTest);

    if(test){
        delete test;
        test = NULL;
    }
    return 0;
}

输出：

paddr = 34360045024
test reinterpret_cast
paddr = 0x80004ade0
test存储的地址值是：0x80004ade0
reTest存储的地址值是：0x80004ade0

宏

#define

        代码中使用宏变量，在预处理阶段会将变量替换为值。

#include <iostream>
using namespace std;

#define TAG "HONG"
int main() {

    // 预处理阶段，会将TAG替换为"HONG"
    cout << TAG << endl;
    return 0;
}

输出：

HONG

宏函数

#include <iostream>
using namespace std;

#define SHOW(V) cout << V << endl
#define ADD(A, B) A + B
#define MUL(A, B) A * B
int main() {

    SHOW(1);// 预处理后，会替换为cout << 1 << endl;
    SHOW("宏函数");// 预处理后，会替换为cout << "宏函数" << endl;
    SHOW(3.14);// 预处理后，会替换为cout << 3.14 << endl;
    cout << endl;
    cout << ADD(1, 2) << endl;// 预处理后，会替换为cout << 1 + 2 << endl;
    cout << ADD(1.03, 2) << endl;// 预处理后，会替换为cout << 1.03 + 2 << endl;
    cout << endl;
    cout << MUL(1, 2) << endl;// 预处理后，会替换为cout << 1 * 2 << endl;
    cout << MUL(1 + 1, 2 + 2) << endl;// 预处理后，会替换为cout << 1 + 1 * 2 + 2 << endl;由于是直接替换，不会出现想象中的cout << 1 * 4 << endl;
    return 0;
}

输出：

1
宏函数
3.14

3
3.03

2
5

#if、#elif、#else、#endif

        #if必须对应#endif，否则报错。

#include <iostream>
using namespace std;

int main() {
#define flag 1
#if flag
    cout << "真的" << endl;
#elif !flag
    cout << "假的" << endl;
#endif

#if flag
    cout << "true" << endl;
#else
    cout << "false" << endl;
#endif
    return 0;
}

输出：

真的
true

#ifdef、#ifndef、#undef

#include <iostream>
using namespace std;

int main() {

#ifndef CMACRO// 判断是不是没定义宏 CMACRO
#define CMACRO// 只有没定义宏 CMACRO，才会执行此句
#endif

#ifdef CMACRO// 判断是不是定义了宏 CMACRO
    cout << "定义了CMACRO" << endl;// 只有定义了宏才会执行此句
#endif

#ifdef CMACRO
#undef CMACRO // 取消定义宏 CMACRO
#endif

#ifdef CMACRO
    cout << "定义了CMACRO" << endl;
#else
    cout << "没定义CMACRO" << endl;
#endif

    return 0;
}

输出：

定义了CMACRO
没定义CMACRO

实践案例

        切换测试和线上环境

#include <iostream>
using namespace std;

#ifndef isRelease
#define isRelease 0
#endif

#if isRelease
#define RELEASE
#else
#define DEBUG
#endif

int main() {
#ifdef RELEASE
    cout << "是线上环境" << endl;
#else
    cout << "是测试环境" << endl;
#endif
    return 0;
}

输出：

是测试环境

迷月星辰
关注
专栏目录
8.智能指针、类型转换、转换函数等
107
03-23 1万+
C++复习11.说明符和限定符2.智能指针3.c++类型转换4.宏定义中#和##的作用5.static变量6.new和定位new运算符7. 类继承、虚函数以及运算符重载;v![在这里插入图片描述](https://img-blog.csdnimg.cn/20200323212426354.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVp...
Modern C++ 学习笔记 —— 智能指针篇
小小笑笑川的博客
07-01 455
Modern C++ 智能指针篇 关键字：智能指针、shared_ptr、unique_ptr 文章目录Modern C++ 智能指针篇RAII自己动手实现智能指针代码列表参考文档 RAII RAII，资源获取即初始化（Resource Acquisition Is Initialization），是一种C++编程中的惯用手法。但是不要被它的名字给误导了，它实际上的作用是将资源的生命周期与一个对象的生命周期相绑定。所谓的资源包括但不限于分配的堆内存、打开的套接字、打开的文件、锁定的互斥体等。 RAII 保证
【C++ 11】c++智能指针转化:static_pointer_cast、dynamic_pointer_cast、const_pointer_cast、reinterpret_pointer_ca
qq_43331089的博客
08-25 3593
如果需要进行类层次上的上下行转换时，可以使用std::static_pointer_cast()、std::dynamic_pointer_cast、std::const_pointer_cast()和std::reinterpret_pointer_cast()。它们的功能和std::static_cast()、std::dynamic_cast、std::const_cast()和std::reinterpret_cast()类似。，只是dynamic_cast在进行下行转换的时候（即基类到派生类）
【智能指针】shared_ptr基本用法和原理（共享指针）
最新发布
木牛的博客
08-28 250
最安全的分配和使用动态内存的方法是调用一个名为make_shared的标准库函数。
c++中的智能指针与类型转换
hqb_newfarmer的博客
02-18 1424
c++中的智能指针与类型转换
C++11-＞智能指针，类型转换
qq_55439426的博客
10-07 2468
无
C++ 智能指针 与 类型转换
weixin_46146815的博客
06-11 212
class A { public: static int num; int self_num; A() { self_num = num; } A(int i) { _i = i; } ~A() { std::cout << “~A” << std::endl; } int _i; }; int A::num = 100; class B : public A { public: static int num; B() { self_num = num; } ~B() { std::
Modern C++ 学习笔记——C++函数式编程
小小笑笑川的博客
07-13 3449
C++函数式编程看这一篇就够了，建议收藏~~~！！！ ModernC++学习笔记是一系列介绍现代C++新特性的文章，结合《effective modern C++》说明了如何更好的使用这些新特性。相互讨论，共同学习，不断成长
《C++ Primer Plus 第6版》第16章 string类和标准模板库 学习笔记——智能指针模板类
Anna_L的博客
12-23 297
智能指针模板类
C++学习笔记——STL学习笔记
Stretch9776的博客
09-06 764
前言 参考： 【刷题】刷题常用STL函数整理合集_zhuhongde的博客-CSDN博客_stl常用函数 STL教程：C++ STL快速入门（非常详细） (biancheng.net) C++ STL 教程 | 菜鸟教程 (runoob.com) 容器： C/C++STL常用容器用法总结_帅比王的博客-CSDN博客_c 容器 1 STL基础 STL(standard template library) ，中文可译为标准模板库或者泛型库，其包含有大量的模板类和模板函数，是 C++ 提供的一个基础模板的集合
C++学习笔记——C++的类
weixin_43809624的博客
09-22 471
第四章 C++的类 文章目录第四章 C++的类4.1类的定义及声明4.1.1基本概念4.1.2定义类时应注意的问题：4.1.3不同对象的构造和析构4.1.4程序不同结束形式对对象的影响：4.1.5接受与删除编译自动生成的函数4.2 成员访问权限及其访问4.3 内联、匿名类及位段4.4 new和delete4.5 隐含参数this4.6 对象的构造与析构 4.1类的定义及声明 4.1.1基本概念 类保留字：class、struct或union可用来声明和定义类。 类的声明：由保留字class、struct或
c++ 智能指针_C++：智能指针是如何实现的
weixin_39545310的博客
11-28 112
C++程序运行时，计算机内存从大类上分为栈和堆，在栈上的内存是由系统自动分配和回收的，而堆上的内存却是由程序员手动申请和释放的，如果程序员在内存的管理上出现失误，轻则程序运行结果与预期有差距，重则程序直接崩溃；栈和堆内存回收区别栈内存上的变量在过了作用域（大括号）后系统会自动回收，而堆内存则不会。 class MyClass{public: MyClass(){cout<<"start...
C++解析(20)：智能指针与类型转换函数
weixin_30535565的博客
12-08 256
0.目录 1.智能指针 2.转换构造函数 3.类型转换函数 4.小结 1.智能指针 内存泄漏（臭名昭著的Bug）： 动态申请堆空间，用完后不归还 C++语言中没有垃圾回收机制 指针无法控制所指堆空间的生命周期 我们需要什么： 需要一个特殊的指针 指针生命周期结束时主动释放堆空间 一片堆空间最多只能由一个指针标识 杜绝指针运算和指针比较 解决方案： 重载指针特征操作符（ -> 和 *...
C++之类型转化和智能指针
sprd_xiaoqi的博客
03-04 1370
提示：文章写完后，目录可以自动生成，如何生成可参考右边的帮助文档 文章目录 前言 一、pandas是什么？ 二、使用步骤 1.引入库 2.读入数据 总结 一、pandas 强制类型转化和智能指针相关, c++对类型转换做了细分，提供了四种不同类型转换，以支持不同需求的转换,型转换有了统一的标示符，利于代码排查和检视。 二、类型转化 1. static_cast 该转换用于将一种数据类型强制转换为另一种数据类型。在进行数据传递时转void*，即可以使用static_c..
c++智能指针转化:static_pointer_cast、dynamic_pointer_cast、const_pointer_cast、reinterpret_pointer_cast
热门推荐
sunlin972913894的博客
09-06 2万+
C++基类和派生类的智能指针转换：static_pointer_cast、dynamic_pointer_cast、const_pointer_cast、reinterpret_pointer_cast 当我们用“裸”指针进行类层次上的上下行转换时，可以使用dynamic_cast。当然我们也可以使用static_cast，只是dynamic_cast在进行下行转换的时候（即基类到派生类）具有类型检查功能，而static_cast没有。因此存在安全问题。 当我们使用智能指针时，如果需要进行类层次上的上下
C++智能指针与类型转换
qq_34606099的博客
08-19 1200
智能指针与类型转换
C++ 中针对智能指针的cast转换
探索C++编程的奥秘，分享深入的技术见解和实践，旨在激发读者创造力与解决问题的思维。
06-08 1396
在介绍智能指针转换方法之前，我们需要理解为什么不能直接使用传统的四种C++ cast（`static_cast`、`dynamic_cast`、`const_cast`、`reinterpret_cast`）来处理智能指针。智能指针的设计旨在自动管理内存，封装了原始指针，并在其生命周期内进行合适的内存管理操作。这些智能指针类型，如 `std::shared_ptr` 和 `std::unique_ptr`，具备复杂的构造和析构逻辑，不仅包含对内存的控制，还涉及引用计数等额外的状态管理。
智能指针与类型转换
Z1312389213的博客
06-13 893
auto_ptr拥有严格对象所有语义的智能指针 在c++98版本产生，在c++11版本已被抛弃。主要是因为auto_ptr有拷贝语义，允许一个智能指针赋值给另一个智能指针，此时会产生内存空间重复释放导致不安全问题的产生，以及拷贝后原对象失效，再次访问原对象导致程序崩溃。unique_ptr拥有独享对象所有语义的智能指针 独占式的智能指针，内部禁用了拷贝语义，在任何事件资源只能被一个智能指针占有，当一个unique_ptr离开作用域时(销毁了管理对象/通过等于或reset将管理对象交给另一个智能指针)，智能指
智能指针动态类型转换
weixin_43513512的博客
05-12 314
auto a = dynamic_pointer_cast©; 其中a 为智能指针，B为指针所指向的对象类型，c为原指针
C++学习笔记：从面向对象到指针操作
"这是一个关于21天精通C++的学习笔记，主要涵盖了C++的基本概念和核心特性，如面向对象编程、自定义数据类型、函数、参数传递、指针以及输入输出流。作者强调了深入学习和避免浮躁的重要性，认为真正的精通需要时间...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值