C++智能指针

最新推荐文章于 2024-09-26 12:00:11 发布
最新推荐文章于 2024-09-26 12:00:11 发布
阅读量842 收藏 10
点赞数 24
分类专栏： C++基础知识 文章标签： 开发语言 c++
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_73281594/article/details/141272279
版权

目录

C++智能指针

RAII

基本使用

unique_ptr和shared_ptr原理与模拟实现

unique_ptr原理与模拟实现

shared_ptr原理与模拟实现

基本结构设计

析构函数和构造函数设计

拷贝构造函数设计

赋值运算符重载函数设计

添加可自定义删除器功能

shared_ptr循环引用问题与weak_ptr的使用

智能指针的前身：auto_ptr

内存泄漏问题

内存泄漏的分类

避免内存泄漏

C++智能指针

RAII

RAII（Resource Acquisition Is Initialization）是一种利用对象生命周期来控制程序资源（如内存、文件句柄、网络连接、互斥量等等）的简单技术。

在对象构造时获取资源，接着控制对资源的访问使之在对象的生命周期内始终保持有效，最后在对象析构的时候释放资源。借此，我们实际上把管理一份资源的责任托管给了一个对象。这种做法有两大好处：

  1. 不需要显式地释放资源。
  2. 采用这种方式，对象所需的资源在其生命期内始终保持有效

在C++中，auto_ptr、unique_ptr以及shared_ptr都遵循RAII原则，但是weak_ptr因为不直接管理空间，所以不遵循RAII原则

基本使用

在C++ 11标准中，一共有三种常用的智能指针，分别是unique_ptr、shared_ptr和weak_ptr，下面是其三个的基本特性：

  1. unique_ptr：C++ 11中的unique_ptr的前身是C++ 扩展库boost中scope_ptr/scope_array，因为unique_ptr是一个模版类型，所以需要传递指针指向对象的类型作为模版参数，构造时可以使用普通指针进行构造，也可以直接在构造处通过new开辟空间，默认情况下只能指向一个内存空间，如果开辟连续的空间，因为unique_ptr底层默认使用的是delete，所以需要额外给一个自定义的删除器，另外，unique_ptr不支持赋值构造和拷贝构造，所以不可以使用unique_ptr进行构造；当unique_ptr指针销毁时，会自动调用析构函数销毁指针指向的内容；unique_ptr 不支持所有权的隐式转移；必须使用 std::move 显式转移所有权。
  2. shared_ptr：C++ 11中的shared_ptr的前身是C++扩展库boost中shared_ptr，基本使用方法与unique_ptr基本一致，但是shared_ptr可以支持赋值构造和拷贝构造，所以如果涉及到指针需要拷贝的情况，就可以考虑使用shared_ptr
  3. weak_ptr：C++ 11中新增的智能指针，用于解决shared_ptr循环引用的问题

以下面的结构测试各种智能指针：

struct Date
{
    int _year;
    int _month;
    int _day;

    Date(int year = 1900, int month = 1, int day = 1)
        :_year(year)
        , _month(month)
        , _day(day)
    {}

    ~Date()
    {
        cout << "~Date()" << endl;
    }
};
  • unique_ptr基本使用
// 用于连续空间的释放
struct Free
{
    void operator()(Date* ptr)
    {
        delete[] ptr;
    }
};

// 用于释放fopen返回的文件指针
struct FileCloser
{
    void operator()(FILE* fp)
    {
        fclose(fp);
    }
};

int main()
{
    // 创建一个对象
    unique_ptr<Date> up(new Date);

    // 创建一个对象数组
    // 如果直接使用下面的写法，需要单独传递一个删除器
    unique_ptr <Date, Free> upArr(new Date[3]);

    // 默认情况下，unique_ptr对数组有特化版本，也可以不需要传递删除器
    unique_ptr<Date[]> upArr1(new Date[3]);

    // unique_ptr不支持拷贝和赋值
    //unique_ptr<Date> up1(up);
    //unique_ptr<Date> up2 = up;

    // 删除器可以用于没有特化版本的情况
    unique_ptr<FILE, FileCloser> upFile(fopen("test.txt", "r"));
    
    return 0;
}
  • shared_ptr基本使用
// 释放连续的空间
struct Free
{
    void operator()(Date* ptr)
    {
        delete[] ptr;
    }
};

int main()
{
    // shared_ptr基本使用与unique_ptr一致
    // 创建一个对象
    shared_ptr<Date> sp(new Date);

    // 创建一个对象数组
    // 如果直接使用下面的写法，需要单独传递一个删除器
    // 不同与unique_ptr，shared_ptr的删除器可以使用lambda表达式或者函数对象
    shared_ptr<Date> spArr(new Date[3], Free()); // 使用函数对象
    shared_ptr<Date> spArr1(new Date[3], [](Date* ptr) {delete[] ptr; }); // 使用lambda表达式

    // shared_ptr支持拷贝和赋值
    shared_ptr<Date> sp1(sp);
    shared_ptr<Date> sp2 = sp;

    return 0;
}

特殊地，shared_ptr支持使用make_shared创建shared_ptr，make_shared是一个可变模版参数函数模版，函数返回一个shared_ptr，因为支持可变模版参数，所以可以传递构造对象的值，但是需要注意make_shared模版参数需要与接收的shared_ptr模版参数一致，make_shared在头文件<memory>中，使用时可以考虑引入

int main()
{
    // 使用make_shared创建对象
    // make_shared会在一次内存分配中同时创建对象和控制块
    shared_ptr<Date> sp3 = make_shared<Date>(2019, 1, 1);

    return 0;
}

unique_ptr和shared_ptr原理与模拟实现

unique_ptr原理与模拟实现

原理：unique_ptr本质是使用一个普通指针进行构造，给出了基本的指针操作，并且默认情况下会释放指针指向的单一空间，特点是将拷贝构造函数和赋值运算符重载函数修饰为=delete

基本结构模拟实现如下：

#pragma once

namespace simulate_unique_ptr
{
    template<class T>
    class unique_ptr
    {
    public:
        // 构造函数
        unique_ptr(T* ptr)
            :_ptr(ptr)
        {}

        // 析构函数
        ~unique_ptr()
        {
            if (_ptr)
            {
                cout << "~unique_ptr()" << endl;
                delete _ptr;
            }
        }

        // 禁止拷贝构造函数和赋值重载函数
        unique_ptr(const unique_ptr<T>& ptr) = delete;
        unique_ptr<T>& operator=(const unique_ptr<T>& ptr) = delete;

        // operator*()
        T& operator*()
        {
            return *_ptr;
        }

        // operator->()
        T* operator->()
        {
            return _ptr;
        }

    private:
        T* _ptr; // 普通指针
    };
}

shared_ptr原理与模拟实现

原理：因为shared_ptr支持拷贝，但是如果默认拷贝和赋值，则会出现同一块空间被释放两次导致的错误，所以在shared_ptr中还存在一个引用计数，用于记录有多少个shared_ptr指向同一块空间

基本结构模拟实现如下：

基本结构设计

对于构造shared_ptr指针来说，与unique_ptr一致，但是对于引用计数来说，需要注意不可以使用普通的成员变量直接进行计数，因为这种方法会导致不论是创建对象、拷贝还是赋值，每一个对象中的引用变量始终为1或者0，也不可以使用静态成员变量进行计数，考虑到静态变量是所有对象够用一份，当两个指针指向同一块空间时没有任何问题，此时计数器为2，但是如果有一个新的指针指向另一块空间，此时计数器更新为3，但是前面的两个指针和第三个指针不是指向同一块空间，不应该更改前面两个指针的计数器。两种情况分析如下图所示：

考虑到以上两种情况后，设计的计数器需要满足两个条件：1. 指向同一块空间的shared_ptr共用一个引用计数器 2. 指向不同空间的shared_ptr使用不同的引用计数器。可以使用在堆上开辟内存的计数器，成员变量只需要一个指针，指向堆上已经开辟好的计数器即可，如果有指向同一块空间的另一个shared_ptr时，只需要使其指针指向相同的计数器空间即可，初始情况下引用计数器的数值为1

析构函数和构造函数设计

设计构造函数时，只需要考虑两点：1. 使用普通指针构造shared_ptr 2. 将计数器指针指向在堆上开辟的空间

设计析构函数时，需要考虑到何时释放空间的问题，如果有两个指针指向同一块空间，则需要避免出现两次释放同一块空间的问题，所以可以考虑析构第一个指针时将该指针置为空并且计数器减小1

拷贝构造函数设计

设计拷贝构造函数只需要考虑将原来指针中的内容拷贝到新指针，再将计数器加1即可

赋值运算符重载函数设计

设计赋值重载需要考虑到下面的问题：

  1. 自己给自己赋值，包括两种情况：1. 两个相同的指针 2. 指向同一个位置的两个指针
  2. 赋值之前需要先释放被赋值的指针原来的空间，否则会出现内存泄漏问题（原因借下面的图分析）
  3. 赋值需要更改用于赋值的指针的引用计数器

具体步骤如下图所示：

#pragma once

namespace simulate_shared_ptr
{
    template <class T>
    class shared_ptr
    {
    public:
        // 构造函数
        shared_ptr(T* ptr = nullptr)
            :_ptr(ptr)
            ,_count(new int(1))
        {}

        void release()
        {
            if (--(*_count) == 0)
            {
                // 释放指向的空间
                delete _ptr;
                // 释放计数器空间
                delete _count;
                // 将指针置为空
                _ptr = nullptr;
                _count = nullptr;
            }
            else
            {
                // 如果不为0，只将当前指针置为空，防止出现野指针问题
                _ptr = nullptr;
            }
        }

        // 析构函数
        ~shared_ptr()
        {
            release();
        }

        // 赋值运算符重载函数
        shared_ptr<T> operator=(const shared_ptr<T>& ptr)
        {
            // 防止自己给自己赋值
            if (_ptr != ptr._ptr)
            {
                // 释放被赋值指针
                release();

                // 将被赋值指针指向ptr指针指向的内容
                _ptr = ptr._ptr;
                _count = ptr._count;
                // 更改赋值指针的引用计数
                ++(*_count);
            }

            return *this;
        }

        // 拷贝构造函数
        shared_ptr(const shared_ptr<T>& ptr)
            :_ptr(ptr)
            , _count(ptr._count)
        {
            ++(*_count);
        }

        // 其他部分
        // 获取原生指针
        T* get() const
        {
            return _ptr;
        }

        // 获取引用计数
        int use_count() const
        {
            return *_pcount;
        }

        // operator*()
        T& operator*()
        {
            return *_ptr;
        }

        // operator->()
        T* operator->()
        {
            return _ptr;
        }

    private:
        T* _ptr;
        int* _count;
    };
}
添加可自定义删除器功能

与unique_ptr不同的是，shared_ptr的自定义删除器是在构造对象参数列表中传递，并且可以使用任意函数对象，所以可以考虑使用function包装器对象作为成员（release函数中调用，因为没有模版参数，所以不可以直接使用构造函数中的模版参数对象），默认情况下使用delete

需要注意，因为需要默认情况下使用 delete，所以需要使在没有传递自定义删除器时调用 delete函数，此时lambda需要写在成员的后面，而不是构造函数关于自定义删除器的缺省参数，便于两个构造函数都可以初始化 _del成员 
#pragma once

#include <functional>

namespace simulate_shared_ptr
{
    template <class T>
    class shared_ptr
    {
    public:
        // ...
        // 支持自定义删除器的构造函数
        template<class D>
        shared_ptr(T* ptr, D del)
            : _ptr(ptr)
            , _count(new int(1))
            , _del(del)
        {}

        // ...
        void release()
        {
            if (--(*_count) == 0)
            {
                // 释放指向的空间
                _del(_ptr);
                // ...
            }
            else
            {
                // ...
            }
        }
    private:
        // ...
        function <void(T*)> _del  = [](T* ptr) {delete ptr; };
    };
}

shared_ptr循环引用问题与weak_ptr的使用

以下面的代码为例：

struct ListNode
{
    int _data;

    shared_ptr<ListNode> _next;
    shared_ptr<ListNode> _prev;

    ~ListNode()
    {
        cout << "~ListNode()" << endl;
    }
};

int main()
{
    // 创建两个节点相互指向
    shared_ptr<ListNode> p1(new ListNode);
    shared_ptr<ListNode> p2(new ListNode);

    p1->_next = p2;
    p2->_prev = p1;

    return 0;
}

上面的代码会出现内存泄漏的问题，首先分析内存泄漏出现的原因：

  1. 首先p2指针析构，因为p1指针的_next成员与p2指针共同管理一片空间，所以此时该空间的引用计数器由2变为1，p2指针置为空即可
  2. 接着析构p1指针，因为p2指针的_prev成员与p1指针共同管理一片空间，所以此时该空间的引用计数器由2变为1，p1指针置为空即可

此时两个指针都已经被释放了，所以程序结束，但是实际上因为还有_next和_prev指针管理空间导致这两片空间依旧没有被释放，从而造成内存泄漏

循环引用问题：

  1. 当p2指针析构时，当前空间引用计数器减1
  2. 当p1指针析构时，当前空间引用计数器减1
  3. 当_next指针需要析构时，需要p1指针指向的空间析构
  4. 当_prev指针需要析构时，需要p2指针指向的空间析构
  5. （循环开始）析构p2指针时，当前空间引用计数器减1

....

为了解决shared_ptr的循环引用问题，可以将ListNode的_next和_prev指针改为weak_ptr，因为weak_ptr支持使用shared_ptr构造

struct ListNode
{
    int _data;

    weak_ptr<ListNode> _next;
    weak_ptr<ListNode> _prev;

    ~ListNode()
    {
        cout << "~ListNode()" << endl;
    }
};

int main()
{
    // 创建两个节点相互指向
    shared_ptr<ListNode> p1(new ListNode);
    shared_ptr<ListNode> p2(new ListNode);

    p1->_next = p2;
    p2->_prev = p1;

    return 0;
}

输出结果：
~ListNode()
~ListNode()

需要注意，weak_ptr不可以单独用于管理对象，例如下面的代码：

// weak_ptr不可以单独使用，需要通过lock()创建shared_ptr

// weak_ptr<ListNode> p3(new ListNode); // 错误

// 正确代码：
shared_ptr<ListNode> p3(new ListNode);
weak_ptr<ListNode> p4 = p3;
// 通过lock()创建shared_ptr
shared_ptr<ListNode> p5 = p4.lock();

weak_ptr 本身不会影响由 shared_ptr 维护的引用计数，所以weak_ptr的基本结构类似下面的代码：

template<class T>
class weak_ptr
{
public:
    weak_ptr()
    {}

    weak_ptr(const shared_ptr<T>& sp)
        :_ptr(sp.get()) // 使用shared_ptr构造，不改变引用计数器
    {}

    weak_ptr<T>& operator=(const shared_ptr<T>& sp)
    {
        _ptr = sp.get();// 使用shared_ptr赋值，不改变引用计数器

        return *this;
    }

private:
    T* _ptr = nullptr;
};

并且当最后一个 shared_ptr 对象离开作用域或被设置为无效时，它指向的对象才会被删除，即使此时仍然存在 weak_ptr 指向该对象，除非使用lock()函数，例如下面的代码中

int main()
{
    weak_ptr<int> wp;
    shared_ptr<int> sp;
    
    {
        shared_ptr<int> n1(new int);
        wp = n1;
        cout << wp.expired() << endl;
        // 如果没有lock()，weak_ptr即使指向了n1的空间，一旦n1离开作用域，n1的空间就会被释放，wp指向的空间就同样被释放
        // 通过lock()获取shared_ptr，可以保证n1的空间不会被释放
        sp = wp.lock();
    }
    cout << wp.expired() << endl; // 没有lock()时，值为1，有lock()时，值为0
    
    return 0;
}

输出结果：
0
0

智能指针的前身：auto_ptr

C++ 98时没有前面类型的智能指针，但是可以使用auto_ptr达到基本一致的效果，但是auto_ptr本身的原理是一种管理权转移的思想，所以存在已经将管理权转移，但是依旧使用被转移资源的指针进行内容访问导致的空指针解引用问题，所以为了更好地管理，auto_ptr基本上被unique_ptr和shared_ptr代替

// auto_ptr的问题
auto_ptr<Date> ap(new Date);
auto_ptr<Date> ap1 = ap;
// ap的空间管理权已经转移给ap1，ap空指针访问
ap->_day = 10;

内存泄漏问题

内存泄漏：指因为疏忽或错误造成程序未能释放已经不再使用的内存的情况。内存泄漏并不是指内存在物理上的消失，而是应用程序分配某段内存后，因为设计错误，失去了对该段内存的控制，因而造成了内存的浪费

内存泄漏的危害：长期运行的程序出现内存泄漏，影响很大，如操作系统、后台服务等等，出现内存泄漏会导致响应越来越慢，最终卡死

例如下面的代码：

#include "vld.h"

void MemoryLeaks()
{
    // 1.内存申请了忘记释放
    int* p1 = (int*)malloc(sizeof(int));
    int* p2 = new int;

    // 2.异常安全问题
    int* p3 = new int[10];

    // Func(); // 如果这里Func函数抛异常导致 delete[] p3将不会执行，p3没被释放.

    delete[] p3;
}

int main()
{
    MemoryLeaks();
    return 0;
}

检查内存溢出情况（仅供参考）：

内存泄漏的分类

C/C++程序中一般我们关心两种方面的内存泄漏：

  1. 堆内存泄漏(Heap leak) ：堆内存指的是程序执行中依据须要分配通过malloc/calloc/realloc/new等从堆中分配的一块内存，用完后必须通过调用相应的 free或者delete 删掉。假设程序的设计错误导致这部分内存没有被释放，那么以后这部分空间将无法再被使用，就会产生Heap Leak。
  2. 系统资源泄漏：指程序使用系统分配的资源，比方套接字、文件描述符、管道等没有使用对应的函数释放掉，导致系统资源的浪费，严重可导致系统效能减少，系统执行不稳定。

避免内存泄漏

  1. 工程前期良好的设计规范，养成良好的编码规范，申请的内存空间记着匹配的去释放。
这个理想状态。但是如果碰上异常时，就算注意释放了，还是可能会出问题。需要下一条智能指针来管理才有保证。
  1. 采用RAII思想或者智能指针来管理资源。
  2. 有些公司内部规范使用内部实现的私有内存管理库。这套库自带内存泄漏检测的功能选项。
  3. 出问题了使用内存泄漏工具检测。
不过很多工具都不够靠谱，或者收费昂贵。

总结：内存泄漏非常常见，解决方案分为两种：1. 事前预防型，如智能指针等 2. 事后查错型，如泄漏检测工具。

怡晗★
关注
专栏目录
c++智能指针最全知识点即面试题目总结
02-27
对于需要面试C++相关岗位的文章，看完这篇文章，如果面试官再问你智能指针，我敢肯定，你一定可以侃侃而谈了~智能指针的面试题，只看这一篇就够了！相信看完这篇文章，妈妈再也不用担心面试官考我智能指针的问题啦...
C++ 智能指针 - 全部用法详解
热门推荐
cpp_learner的博客
08-02 7万+
血的教训？不学智能指针，本人丢了一份工作。
C++智能指针详解
qq_61635026的博客
10-02 2014
智能指针是存储指向动态分配（堆）对象指针的类。除了能够在适当的时间自动删除指向的对象外，他们的工作机制很像C++的内置指针。智能指针在面对异常的时候格外有用，因为他们能够确保正确的销毁动态分配的对象。他们也可以用于跟踪被多用户共享的动态分配对象。下面我们先分析一下下面这段程序有没有什么内存方面的问题？ 关于内存泄漏见文章【C++ 内存管理】RAII（Resource Acquisition Is Initialization），也称为 “资源获取就是初始化” ，是一种利用对象生命周期来控制程序资源（如内存
C++ 智能指针
weixin_54670782的博客
12-01 3812
智能指针 输入问题： 给定一个字符串，不知道有几个字符，怎样输入？ 使用cin.getline(); 输入一行。 智能指针概念 智能指针主要是针对裸指针进行了一次面向对象的封装，在构造函数中初始化资源地址，在析构函数中释放资源。当资源应该被释放时，指向它的智能指针可以确保自动释放它。 RAII RAII 对堆上空间进行自动化管理——利用对象自动析构的机制。 malloc， new 等动态分配的对象，很有可能忘记了去释放资源而导致泄露。 对于一个对象而言，在构造函数的时候申请空间，而在析构函数（在离开
c++智能指针详解
bitcarmanlee的博客
05-18 3万+
1.什么是智能指针 从比较简单的层面来看，智能指针是RAII(Resource Acquisition Is Initialization，资源获取即初始化)机制对普通指针进行的一层封装。这样使得智能指针的行为动作像一个指针，本质上却是一个对象，这样可以方便管理一个对象的生命周期。 在c++中，智能指针一共定义了4种： auto_ptr、unique_ptr、shared_ptr 和 weak_ptr。其中，auto_ptr 在 C++11已被摒弃，在C++17中已经移除不可用。 2.原始指针的问题 原始指
【C++进阶学习】第十三弹——C++智能指针的深入解析
2301_80220607的博客
08-13 2717
【C++进阶学习】：C++掌握内存管理重要一步——智能指针的深入解析：什么是智能指针？为什么需要智能指针？一篇带你搞清楚智能指针的作用及原理
C++智能指针基础用法详解
mahuifa的博客
04-21 1259
智能指针是C++中用于管理动态分配资源的强大工具，通过正确使用智能指针，可以显著减少内存泄漏的可能性，并提高代码的安全性和可维护性。
C++智能指针用法详解
12-22
　用智能指针便可以有效缓解这类问题，本文主要讲解参见的智能指针的用法。包括：std::auto_ptr、boost::scoped_ptr、boost::shared_ptr、boost::scoped_array、boost::shared_array、boost::weak_ptr、boost:: ...
C++智能指针-unique-ptr智能指针详解.pdf
02-27
《C++智能指针——unique_ptr智能指针详解》 智能指针是C++中用于自动管理动态分配内存的一种工具，它可以确保在适当的时候自动释放内存，从而避免内存泄漏的问题。其中，`unique_ptr`是一种特殊的智能指针，它拥有...
网站建设中常见的网站后台开发语言有哪几种，各自优缺点都是什么？
2301_80154636的博客
09-24 1158
总的来说，每种语言都有其特定的优势和局限，选择哪种语言取决于项目需求、团队技能和预期的维护成本等多种因素。理解这些语言的核心特性和适用场景可以帮助开发者做出更明智的选择，从而有效提升项目的成功率和开发效率。这些语言各有其独特的优缺点，适用于不同的开发场景和需求。市场上常见的网站后台开发语言有。
C++ 异步编程中：future与promise、packaged_task、async
zxf347085420的博客
09-23 964
std::launch::async | std::launch::deferred参数：是默认行为(可省略)。=》std::async真的是来帮忙的，你不用再想到底该怎么用std::future、std::promise和 std::packaged_task了，在已经有了td::future、std::promise和std::packaged_task的情况下，实现异步或多线程间通信，事实上std::promise::set_xxx函数会改变std::promise的状态为ready，
【C++】拆分详解 - string类
bubble_shadow的博客
09-23 984
string类的文档介绍注：此处及下文部分，蓝色下划线标识文本均为超链接，点击即可跳转字符串是表示字符序列的类标准的字符串类提供了对此类对象的支持，其接口类似于标准字符容器的接口，但添加了专门用于操作单字节字符字符串的设计特性。string类是使用char(即作为它的字符类型，使用它的默认char_traits和分配器类型(关于模板的更多信息，请参阅basic_string)。
c++ 使用 Graham 扫描的凸包（Convex Hull using Graham Scan）
csdn_aspnet的专栏
09-26 854
对于剩余的点，我们跟踪最近的三个点，并找到它们形成的角度。如果这些点的方向（按相同顺序考虑它们）不是逆时针的，我们丢弃 c，否则我们保留它。因此，第六步逐个处理点需要 O(n) 时间，假设堆栈操作需要 O(1) 时间。总体复杂度为 O(n) + O(nLogn) + O(n) + O(n)，即 O(nLogn)。在每个步骤中，算法都会检查添加到凸包中的最后两个点是否形成右转。格雷厄姆扫描算法是一种简单而有效的算法，用于计算一组点的凸包。凸包用于各种计算几何算法，例如查找最近的点对和计算一组点的直径。
Codeforces Round 973 (Div. 2) C. Password Cracking
puzhaoyu的博客
09-21 653
说明已经构建到了最右边，那么开始向左边构建。（写这题的时候一直不对，后来发现是忘记cin >> t了，归根结底还是不熟悉交互式编程的输入输出方式）猜一串二进制密码，每次可询问某串字符是否是密码的子串。从左到右不断构建ans字符串，每次不是加。，这可以通过询问得到。
C++ 知识要点：对象内存模型
叫好与叫座虽然不是对立面，但想在同一个作品中达到双重效果很难。
09-21 659
在C++中，通过和->访问对象成员的主要区别在于它们的访问方式和语法。用于直接对象，而->用于通过指针间接访问对象。尽管在底层实现和性能上可能存在微小的差异，但这些差异通常被现代编译器的优化所掩盖。更重要的是要考虑代码的可读性、维护性和安全性。在实际的C++实现中，不同的编译器可能会采用不同的策略来记录虚基类子对象的偏移信息。一些编译器可能会选择将偏移信息嵌入到虚函数表中，而另一些则可能会使用额外的指针。这些选择通常取决于编译器的设计目标、性能考虑以及与其他特性的兼容性。
简易STL实现 | Set 的实现
最新发布
AsherGu的博客
09-26 270
如何使用；代码实现及其他（包括之前红黑树可以运行实现）
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

怡晗★

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值