C++ 智能指针及实现（不成熟）

已于 2024-08-11 13:26:39 修改
阅读量294 收藏 3
点赞数 7
文章标签： c++ 开发语言
于 2024-08-11 13:25:22 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_44604409/article/details/141104399
版权

简要介绍

智能指针是C++11新特性，其特点是：RAII的设计思路，在对象创建时建立资源，在析构时释放资源，从而避免异常机制导致的资源未释放问题。

常用智能指针有

  1. shared_ptr：共享智能指针，可以使用多个指针指向同一个数据，并维护一个计数器变量，每有一个shared_ptr指向这个数据，计数器变量就加一，反之则减一。当计数器为0时，则delete 数据的指针。
  2. weak_ptr：弱引用，不增加引用计数，可以用于检测shared_ptr，也可以用于避免循环引用导致资源无法释放的情况。
  3. unique_ptr：独占资源，负责资源释放。

常用API：

  1. ->
  2. *
  3. get()，返回指针值（建议不要在返回值域做delete操作）

因此，使用如下代码创建智能指针基类BaseSmartPtr，并实现* -> 和 get()。（全文仅代表我自己学习的一个demo，我本人才疏学浅，STL并不是这么做的。并且我的实现是线程不安全的，要实现线程安全，起码需要一个mutex）

template <typename T>
class BaseSmartPtr
{
public:
    T &operator*() { return *_ptr; }

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

    T *get() { return _ptr; }

protected:
    BaseSmartPtr() {}

    BaseSmartPtr(T *ptr) : _ptr(ptr) {}
    ~BaseSmartPtr() {}

    void DeletePtr()
    {
        if (_ptr != nullptr)
            delete _ptr;
        _ptr = nullptr;
    }

    T *_ptr = nullptr;
};

共享指针shared_ptr

实现源码

// 为了方便WeakPtr使用lock函数返回SharedPtr，因此将WeakPtr设置为SharedPtr的友元类。
// 叠甲-1：我个人认为这不是很好的实现，还有一种实现是在BaseSmartPtr中 定义 _ptr _shared_count 和 _weak_count
// 叠甲-2：我在CSDN大部分的博客上看到的实现，都不是很完整，尤其是weakPtr的lock,expired,相比较而言，我觉得一起实现三种指针更加考验一个程序员。
template <typename T>
class WeakPtr;

template <typename T>
class SharedPtr : public BaseSmartPtr<T>
{
public:
    friend class WeakPtr<T>;
    SharedPtr() : BaseSmartPtr<T>() {}

    SharedPtr(T *ptr) : BaseSmartPtr<T>(ptr), _count(new long long(1))
    {
        std::cout << "T* ptr constructor of SharedPtr." << std::endl;
    }

    SharedPtr(T *ptr, long long *_count) : BaseSmartPtr<T>(ptr), _count(_count)
    {
        (*_count)++;
        std::cout << "T*  and long long *ptr constructor of SharedPtr(designed for WeakPtr)." << std::endl;
    }

    // copy constructor 拷贝构造函数
    SharedPtr(const SharedPtr<T> &sPtr) : BaseSmartPtr<T>(sPtr._ptr), _count(sPtr._count)
    {
        (*_count)++;
        std::cout << "copy constructor of SharedPtr." << std::endl;
    }

    // move constructor 移动构造函数
    SharedPtr(SharedPtr &&other) : BaseSmartPtr<T>(other._ptr), _count(other._count)
    {
        other._count = nullptr;
        other._ptr = nullptr;
        std::cout << "move constructor of SharedPtr." << std::endl;
    }

    // operator =  赋值运算符（左值）
    SharedPtr<T> &operator=(SharedPtr &other) noexcept
    {
        if (this->_ptr != other._ptr)
        {
            Release();

            this->_ptr = other._ptr;
            _count = other._count;
            ++(*_count);
        }
        std::cout << "operator = of SharedPtr." << std::endl;
        return *this;
    }

    // move operator =
    SharedPtr<T> &operator=(SharedPtr &&other) noexcept
    {
        if (this != &other)
        {
            Release();

            this->_ptr = other._ptr;
            _count = other._count;

            other._count = nullptr;
            other._ptr = nullptr;
        }

        std::cout << "move operator = of SharedPtr." << std::endl;

        return *this;
    }

    ~SharedPtr()
    {
        std::cout << "~ function of SharedPtr." << std::endl;
        Release();
    }

    long long use_count() { return this->_ptr != nullptr ? *_count : 0; }

    void reset(T *ptr = nullptr)
    {
        if (this->_ptr != ptr)
        {
            Release();

            if (ptr != nullptr)
            {
                this->_ptr = ptr;
                _count = new long long(1);
            }
            else
            {
                this->_ptr = nullptr;
                _count = nullptr;
            }
        }
    }

protected:
    void Release()
    {
        if (this->_ptr != nullptr) // 在_ptr不为空的情况下，对count--，如果--后count等于0执行函数体内
        {
            (*_count)--;
            if ((*_count) == 0)
            {
                //
                this->DeletePtr();
                delete _count;
                _count = nullptr;
                std::cout << " delete SharedPtr source." << std::endl;
            }
        }
    }

    // T *_ptr = nullptr;
    long long *_count = nullptr;
};

重点

  1. 引用计数++的更新；
  2. 移动构造和移动赋值；

弱引用智能指针weak_ptr

实现源码

template <typename T>
    class WeakPtr : public BaseSmartPtr<T>
    {
    public:
        WeakPtr() : BaseSmartPtr<T>() {}

        WeakPtr(const SharedPtr<T> &otherShared) : BaseSmartPtr<T>(otherShared._ptr), _count(otherShared._count)
        {
            std::cout << " WeakPtr constructed from SharedPtr." << std::endl;
        }

        WeakPtr(const WeakPtr<T> &other) : BaseSmartPtr<T>(other._ptr), _count(other._count)
        {
            std::cout << " WeakPtr constructed from WeakPtr." << std::endl;
        }

        WeakPtr<T> &operator=(const WeakPtr<T> &other)
        {
            std::cout << " WeakPtr oprtator = ." << std::endl;
            this->_ptr = other._ptr;
            _count = other._count;
            return *this;
        }

        ~WeakPtr()
        {
            std::cout << " deconstructor of WeakPtr." << std::endl;
        }

        SharedPtr<T> lock()
        {
            if (*_count > 0)
            {
                return std::move(SharedPtr<T>(this->_ptr, this->_count));
            }
            else
                return SharedPtr<T>();
        }

        bool expired()
        {
            return *(_count) > 0;
        }

    private:
        long long *_count = nullptr;
    };

重点

weak_ptr中比较难实现的是 lock函数。（尤其是在我这样的继承结构下，迫不得已使用友元类）

独占智能指针unique_ptr

实现源码

template <typename T>
class UniquePtr : public BaseSmartPtr<T>
{
public:
    UniquePtr() : BaseSmartPtr<T>() {}

    UniquePtr(T *ptr) : BaseSmartPtr<T>(ptr)
    {
        std::cout << " T* constructor of UniquePtr" << std::endl;
    }

    ~UniquePtr()
    {
        if (this->_ptr != nullptr)
        {
            std::cout << " destructor of UniquePtr and delete corresponding source." << std::endl;
            this->DeletePtr();
        }
    }

    // copy constructor and operator = are deleted to avoid copy
    UniquePtr(const UniquePtr<T> &other) = delete;
    UniquePtr &operator=(const UniquePtr<T> &other) = delete;

    UniquePtr(UniquePtr<T> &&other) : BaseSmartPtr<T>(other._ptr)
    {
        std::cout << "move destructor of UniquePtr." << std::endl;
        other._ptr = nullptr;
    }

    UniquePtr &operator=(UniquePtr<T> &&other) noexcept
    {
        std::cout << "move operator = of UniquePtr" << std::endl;
        if (this != &other)
        {
            if (this->_ptr != nullptr)
                this->DeletePtr();
            this->_ptr = other._ptr;
            other._ptr = nullptr;
        }

        return *this;
    }

    void reset(T *ptr = nullptr)
    {
        if (this->_ptr != ptr)
        {
            if (this->_ptr != nullptr)
                this->DeletePtr();
            this->_ptr = ptr;
        }
    }
};

重点

由于是独占资源，因此需要将拷贝构造函数和 operator = 设置为 delete；

保留移动赋值和移动 =。

完整代码（包含main测试）

#include <iostream>

namespace MySmartPtr
{
    template <typename T>
    class BaseSmartPtr
    {
    public:
        virtual T &operator*() { return *_ptr; }

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

        virtual T *get() { return _ptr; }

    protected:
        BaseSmartPtr() {}

        BaseSmartPtr(T *ptr) : _ptr(ptr) {}
        ~BaseSmartPtr() {}

        void DeletePtr()
        {
            if (_ptr != nullptr)
                delete _ptr;
            _ptr = nullptr;
        }

        T *_ptr = nullptr;
    };

    // 为了方便WeakPtr使用lock函数返回SharedPtr，因此将WeakPtr设置为SharedPtr的友元类。
    // 叠甲-1：我个人认为这不是很好的实现，还有一种实现是在BaseSmartPtr中 定义 _ptr _shared_count 和 _weak_count
    // 叠甲-2：我在CSDN大部分的博客上看到的实现，都不是很完整，尤其是weakPtr的lock,expired,相比较而言，我觉得一起实现三种指针更加考验一个程序员。
    template <typename T>
    class WeakPtr;

    template <typename T>
    class SharedPtr : public BaseSmartPtr<T>
    {
    public:
        friend class WeakPtr<T>;
        SharedPtr() : BaseSmartPtr<T>() {}

        SharedPtr(T *ptr) : BaseSmartPtr<T>(ptr), _count(new long long(1))
        {
            std::cout << "T* ptr constructor of SharedPtr." << std::endl;
        }

        SharedPtr(T *ptr, long long *_count) : BaseSmartPtr<T>(ptr), _count(_count)
        {
            (*_count)++;
            std::cout << "T*  and long long *ptr constructor of SharedPtr(designed for WeakPtr)." << std::endl;
        }

        // copy constructor 拷贝构造函数
        SharedPtr(const SharedPtr<T> &sPtr) : BaseSmartPtr<T>(sPtr._ptr), _count(sPtr._count)
        {
            (*_count)++;
            std::cout << "copy constructor of SharedPtr." << std::endl;
        }

        // move constructor 移动构造函数
        SharedPtr(SharedPtr &&other) : BaseSmartPtr<T>(other._ptr), _count(other._count)
        {
            other._count = nullptr;
            other._ptr = nullptr;
            std::cout << "move constructor of SharedPtr." << std::endl;
        }

        // operator =  赋值运算符（左值）
        SharedPtr<T> &operator=(SharedPtr &other) noexcept
        {
            if (this->_ptr != other._ptr)
            {
                Release();

                this->_ptr = other._ptr;
                _count = other._count;
                ++(*_count);
            }
            std::cout << "operator = of SharedPtr." << std::endl;
            return *this;
        }

        // move operator =
        SharedPtr<T> &operator=(SharedPtr &&other) noexcept
        {
            if (this != &other)
            {
                Release();

                this->_ptr = other._ptr;
                _count = other._count;

                other._count = nullptr;
                other._ptr = nullptr;
            }

            std::cout << "move operator = of SharedPtr." << std::endl;

            return *this;
        }

        ~SharedPtr()
        {
            std::cout << "~ function of SharedPtr." << std::endl;
            Release();
        }

        long long use_count() { return this->_ptr != nullptr ? *_count : 0; }

        void reset(T *ptr = nullptr)
        {
            if (this->_ptr != ptr)
            {
                Release();

                if (ptr != nullptr)
                {
                    this->_ptr = ptr;
                    _count = new long long(1);
                }
                else
                {
                    this->_ptr = nullptr;
                    _count = nullptr;
                }
            }
        }

    protected:
        void Release()
        {
            if (this->_ptr != nullptr) // 在_ptr不为空的情况下，对count--，如果--后count等于0执行函数体内
            {
                (*_count)--;
                if ((*_count) == 0)
                {
                    //
                    this->DeletePtr();
                    delete _count;
                    _count = nullptr;
                    std::cout << " delete SharedPtr source." << std::endl;
                }
            }
        }

        // T *_ptr = nullptr;
        long long *_count = nullptr;
    };

    template <typename T>
    class UniquePtr : public BaseSmartPtr<T>
    {
    public:
        UniquePtr() : BaseSmartPtr<T>() {}

        UniquePtr(T *ptr) : BaseSmartPtr<T>(ptr)
        {
            std::cout << " T* constructor of UniquePtr" << std::endl;
        }

        ~UniquePtr()
        {
            if (this->_ptr != nullptr)
            {
                std::cout << " destructor of UniquePtr and delete corresponding source." << std::endl;
                this->DeletePtr();
            }
        }

        // copy constructor and operator = are deleted to avoid copy
        UniquePtr(const UniquePtr<T> &other) = delete;
        UniquePtr &operator=(const UniquePtr<T> &other) = delete;

        UniquePtr(UniquePtr<T> &&other) : BaseSmartPtr<T>(other._ptr)
        {
            std::cout << "move destructor of UniquePtr." << std::endl;
            other._ptr = nullptr;
        }

        UniquePtr &operator=(UniquePtr<T> &&other) noexcept
        {
            std::cout << "move operator = of UniquePtr" << std::endl;
            if (this != &other)
            {
                if (this->_ptr != nullptr)
                    this->DeletePtr();
                this->_ptr = other._ptr;
                other._ptr = nullptr;
            }

            return *this;
        }

        void reset(T *ptr = nullptr)
        {
            if (this->_ptr != ptr)
            {
                if (this->_ptr != nullptr)
                    this->DeletePtr();
                this->_ptr = ptr;
            }
        }
    };

    template <typename T>
    class WeakPtr : public BaseSmartPtr<T>
    {
    public:
        WeakPtr() : BaseSmartPtr<T>() {}

        WeakPtr(const SharedPtr<T> &otherShared) : BaseSmartPtr<T>(otherShared._ptr), _count(otherShared._count)
        {
            std::cout << " WeakPtr constructed from SharedPtr." << std::endl;
        }

        WeakPtr(const WeakPtr<T> &other) : BaseSmartPtr<T>(other._ptr), _count(other._count)
        {
            std::cout << " WeakPtr constructed from WeakPtr." << std::endl;
        }

        WeakPtr<T> &operator=(const WeakPtr<T> &other)
        {
            std::cout << " WeakPtr oprtator = ." << std::endl;
            this->_ptr = other._ptr;
            _count = other._count;
            return *this;
        }

        ~WeakPtr()
        {
            std::cout << " deconstructor of WeakPtr." << std::endl;
        }

        SharedPtr<T> lock()
        {
            if (*_count > 0)
            {
                return std::move(SharedPtr<T>(this->_ptr, this->_count));
            }
            else
                return SharedPtr<T>();
        }

        bool expired()
        {
            return *(_count) > 0;
        }

    private:
        long long *_count = nullptr;
    };
}

using namespace MySmartPtr;

void TestSharedPtr()
{
    std::cout << "--------------------- Test Sharedptr ---------------------------" << std::endl;
    SharedPtr<int> sPtr1 = new int(1);
    SharedPtr<int> sPtr2 = sPtr1;
    SharedPtr<int> sPtr3(sPtr2);

    *sPtr1 = 100;
    std::cout << "sPtr1:" << *sPtr1 << std::endl;
    std::cout << "sPtr2:" << *sPtr2 << std::endl;
    std::cout << "sPtr3:" << *sPtr3 << std::endl;
    SharedPtr<int> sPtr4(std::move(sPtr3));

    sPtr2 = std::move(sPtr4);
}

struct TestStruct
{
    int x = 0;
    int y = 1;
    TestStruct(int a, int b) : x(a), y(b) {}

    int count()
    {
        return x + y;
    }
};

void TestUniqueptr()
{
    std::cout << "--------------------- Test Uniqueptr ---------------------------" << std::endl;
    UniquePtr<int> uPtr1 = new int(1);

    // UniquePtr<int> uPtr2(uPtr1); 无法调用

    UniquePtr<int> uPtr2 = std::move(uPtr1);
    std::cout << *uPtr2 << std::endl;

    uPtr1 = std::move(uPtr2);

    // UniquePtr<int> uPtr3(std::)

    auto i = uPtr1.get();
    std::cout << *i << std::endl;

    UniquePtr<TestStruct> SUPtr = new TestStruct(10, 11);
    std::cout << SUPtr->x << std::endl;
    std::cout << SUPtr->y << std::endl;
    std::cout << SUPtr->count() << std::endl;
}

void TestWeakPtr()
{
    std::cout << "--------------------- Test Weakptr ---------------------------" << std::endl;
    SharedPtr<int> sPtr = new int(1);
    WeakPtr<int> wPtr1 = sPtr;
    WeakPtr<int> wPtr2 = wPtr1;

    WeakPtr<int> wPtr3;
    wPtr3 = wPtr2;
}

// void

int main()
{

    TestSharedPtr();

    TestUniqueptr();

    TestWeakPtr();

    return 0;
}

久未
关注
C++ STL 四种智能指针
Dablelv 的博客专栏。
08-07 7万+
auto_ptrunique_ptrshared_ptrweak_ptrauto_ptr 是 C++98 提出的，C++11 已将其摒弃，并提出了 unique_ptr 替代 auto_ptr。虽然 auto_ptr 已被摒弃，但在实际项目中仍可使用，但建议使用更加安全的 unique_ptr，后文会详细叙述。shared_ptr 和 weak_ptr 则是 C+11 从准标准库 Boost 中引入的两种智能指针。
C++11：智能指针
Man9o
03-09 1457
全局对象：程序启动时分配，在程序结束时销毁。局部对象：当我们进入其定义所在的程序块时被创建，在离开块时销毁。局部static对象：在第一次使用前分配，在程序结束时销毁。静态内存：保存局部static对象、类static数据成员以及定义在任何函数之外的变量。栈内存：保存定义在函数内的非static对象。分配在静态或栈内存中的对象由编译器自动创建和销毁。对于栈对象，仅在其定义的程序块运行时才存在；static对象在使用之前分配，在程序结束时销毁。除了静态内存和栈内存，每个程序还拥有一个内存池。
C++的智能指针
m0_67623521的博客
07-10 928
目录前言1、unique_ptr2、auto_ptr引入问题3、shared_ptr接口：4、weak_ptr参考文章：C++STL（Standard Template Library）一共提供了四种指针：auto_ptr、unique_ptr、shared_ptr 和 weak_ptr，其中auto_ptr是c++98提供的，C++11 已将其摒弃，并提出了 unique_ptr 替代 auto_ptr。独占的指针，只可以自己使用，它指向的对象只可以他一个人使用，可以使用move将使用权转移。...
C++智能指针详解（C++11）
Hacker_Free的博客
04-02 343
1. C++为什么需要智能指针 我们知道除了静态内存和栈内存外，每个程序还有一个内存池，这部分内存被称为自由空间或者堆。程序用堆来存储动态分配的对象即那些在程序运行时分配的对象，当动态对象不再使用时，我们的代码必须显式的销毁它们。 在C++中，动态内存的管理是用一对运算符完成的：new和delete。new：在动态内存中为对象分配一块空间并返回一个指向该对象的指针，delete：指向一个动态独享的...
C++智能指针原理
zhuhongde的博客
08-20 366
参考文献 1.C++智能指针 2.C++智能指针简单剖析 3.智能指针 auto_ptr 详解 4.C++智能指针详解 5.请你介绍一下C++的智能指针——牛客网 一.什么是智能指针？为什么要有智能指针？ 在C++程序里，使用new关键字开辟的内存必须被手动delete掉，不然就会导致内存的泄漏，但是，当程序非常冗长，你能保证自己每一个手动开辟的内存块都释放了吗？在delete之前，倘若程序因为...
[C++](26)智能指针
CegghnnoR的博客
09-29 501
C++智能指针的引入，很大程度上方便了程序员的内存管理，如何了解智能指针的原理，正确使用智能指针，是我们学习的重点
C++智能指针 shared_ptr 精简 教程
探索C++编程的奥秘，分享深入的技术见解和实践，旨在激发读者创造力与解决问题的思维。
06-17 1048
C++智能指针 shared_ptr 精简 教程
C++智能指针
kessity的博客
09-29 483
一 智能指针   智能指针是一个类，这个类的构造函数中传入一个普通指针，然后开辟空间，析构函数中释放传入的指针。智能指针的类都是栈上的对象，所以当函数（或程序）结束时会自动被释放，   使用注意点： 所有的智能指针类都有一个explicit构造函数，以指针作为参数。因此不能自动将指针转换为智能指针对象，必须显式调用： shared_ptr<double> pd; double *......
C++智能指针--（初识智能指针）
逝水流年
05-01 405
在C++11中，智能指针 #include <memory> #include <iostream> // auto_ptr // shared_ptr // enable_shared_from_this // CRTP // weak_ptr // unique_ptr
c++11-智能指针和引用计数
icandoit2010的专栏
02-23 1万+
一、本节内容 本节内容包括： 对标准库的扩充: 智能指针和引用计数 RAII 与引用计数std::shared_ptrstd::unique_ptrstd::weak_ptr 二、RAII 与引用计数 了解 Objective-C/Swift 的程序员应该知道引用计数的概念。引用计数这种计数是为了防止内存泄露而产生的。基本想法是对于动态分配的对象，进行引用计数，每
C++新特性之四：标准库中的智能指针和引用计数
实战开发者Airex
04-30 276
总第33篇 本文主要介绍C++11/14在标准库中对智能指针和引用计数的扩充，以供大家学习和工作的过程中参考。 1.引用计数 引用计数是为了防止内存泄漏而产生的，其基本理念是：对于动态分配的对象进行引用计数，当增加一次对同一个对象的引用时，计数加1，当删除一次引用时，计数减1，当一个对象的引用计数减为0时，就自动删除指向的堆内存。 ...
重学C++：笔记（二）C++基础容器&C++指针、引用
TiercelChow’s Blog
08-23 651
文章目录第4章 C++基础容器4.1 序列容器--数组4.2 数组的增删改查及二维数组4.3 动态数组vector4.4 字符串第5章 彻底学会 C++ 指针，引用5.1 指针的概念5.2 指针的基本操作5.3 CPP程序的存储区域划分5.4 CPP动态分配和回收原则5.5 RAII初步5.6 C++中几种变量的对比5.7 内存泄漏5.8 智能指针5.9 引用 第4章 C++基础容器 4.1 序列容器–数组 off-by-one error数组下标 off-by-one error （差一错误） 数组中
C++智能指针 intrusive_ptr
晴天的专栏
08-30 5023
intrusive_ptr: intrusive_ptr是一个侵入式的引用计数型指针，它可以用于以下两种情形： 【1】对内存占用的要求非常严格，要求必须与原始指针一样； 【2】现存代码已经有了引用计数机制管理的对象 boost::intrusive_ptr一种“侵入式”的引用计数指针，它实际并不提供引用计数功能，而是要求被存储的对象自己实现引用计数功能，并提供intrusive_ptr
C++没落了？学习C++没有前途了？从业者给你揭晓答案
热门推荐
dvlinker的技术专栏
09-15 2万+
C++没落了？学习C++没有前途了？从业者给你揭晓答案，并进行深度解析
C++智能指针之shared_ptr
MOON5555的博客
04-24 267
shared_ptr 是为了解决 auto_ptr 在对象所有权上的局限性(auto_ptr 是独占的), 在使用引用计数的机制上提供了可以共享所有权的智能指针, 当然这需要额外的开销:　　(1) shared_ptr 对象除了包括一个所拥有对象的指针外, 还必须包括一个引用计数代理对象的指针。　　(2) 时间上的开销主要在初始化和拷贝操作上, *和-&gt;操作符重载的开销跟auto_ptr是一...
C++ STL中sort函数
weixin_43349440的博客
09-15 168
刷题中经常遇到，用于各种元素排序，可以自定义排序方式，vector、deque适用。详细讲解：https://zhuanlan.zhihu.com/p/36274119。，为避免QuickSort快排的递归调用带来过大的额外负荷，就改用。一旦分段后的数据量小于某个门槛。STL的sort算法，
CF C. Nikita and LCM
qq_74190237的博客
09-13 264
思维题.首先先对数组排序,考虑一种特殊情况,那就是如果数组最大值不能被其他数整除,这代表什么?代表其他数里面有某个质因子,最大值里面没有或者数量不管,所有最小公倍数都会大于最大值.那么其他情况的话,就可以确定所有的数都是最大数的因子,那么形成的最小公倍数也一定是最大数的因子,那么就可以枚举一下最大数的因子,就可以了.给长度为n的数组,求出最长的特殊子数组,如果子数组的最小公倍数不在原数组中,那么就是特殊的.
C++与QML的数据交互
qq_50679120的博客
09-11 520
这里没什么好说的，在C++中组合好json后，通过信号发送到qml中，qml中是可以解析json的。通过Q_PROPERTY属性，可以轻松地在QML中读取和修改数据，并将其更新到C++中，先创建一个类。在QML接收，直接通过data.can_id这样的形式去访问结构体中的元素。这两个也没什么好说的，在C++中直接发送信号就好了，在C++中声明并注册一个结构体。然后发送信号到QML中。
【C++】【网络】【Linux系统编程】单例模式，加锁封装TCP/IP协议套接字
最新发布
2301_79796701的博客
09-16 884
给系统，表明这个套接字所期望的、还未处理的（即还在等待被接受的连接）连接请求的最大队列长度。换句话说，它告诉系统内核为这个套接字分配多大的空间来存储尚未处理的连接请求。有关套接字编程的细节和更多的系统调用课参考《UNIX环境高级编程》一书，可以在如下网站搜索电子版，该书在第16章详细的介绍了各种接口。我们可以根据自己的需求，用面向对象的思想封装出接口简洁的类。在类似添加一个该类类型的指针，该指针是静态的并且是私有成员。结构体填充，为了使不同的地址格式能和套接字绑定，需要把对应的结构体强转成通用地址结构。
C++循环编程：在Android嵌入式系统中实现goto与高效代码
此外，学习lambda表达式、智能指针和移动构造函数等现代C++特性，能够帮助开发者编写出更强大、性能优越的应用程序。 通过本书提供的实例和练习，读者可以逐步提升自己的C++技能，理解如何利用C++14和C++17的新标准...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值