当前位置：首页 > news >正文

智能指针

news 来源：原创 2024/4/29 15:44:17

智能指针

智能指针
- stdauto_ptr
- boostscoped_ptr
- boostshared_ptr
- boostscoped_array
- boostshared_array
- boostweak_ptr
- boostinstrusive_ptr
- 后记

std::auto_ptr

使用总结

1.(deprecated since C++11) (until C++17) 1

2.尽量不要使用”=”. 如果使用了, 请不要再使用先前对象.

3.记住release(0)函数不会释放对象, 仅仅归还所有权, release(0)返回T*类型.

4.由于std::auto_ptr的”operator=”问题, 由其管理的对象不能放入 std::vector 等容器中. 同样的道理, std::auto_ptr最好不要当成参数传递.

示例代码

#include "simple.h"

#include <memory>

int main() {
        std::auto_ptr<Simple> my_memory(new Simple(1));   // 创建对象，输出：Simple：1
        if (my_memory.get()) {                            // 判断智能指针是否为空
                my_memory->PrintSomething();                    // 使用 operator-> 调用智能指针对象中的函数
                my_memory.get()->info_extend = "Addition";      // 使用 get() 返回裸指针，然后给内部对象赋值
                my_memory->PrintSomething();                    // 再次打印，表明上述赋值成功
                (*my_memory).info_extend += " other";           // 使用 operator* 返回智能指针内部对象，然后用“.”调用智能指针对象中的
函数
                my_memory->PrintSomething();                    // 再次打印，表明上述赋值成功
          }

        std::auto_ptr<Simple> instance(new Simple(1));
        if(instance.get()){
                std::auto_ptr<Simple> instance2;
                instance2 = instance; //导致instance悬空;
                instance2->PrintSomething();
                //instance->PrintSomething(); //崩溃;
                //instance2->release(); //并未释放内存, 只交出使用权; release返回Simple*;
                //instance2->reset(); //释放内存; reset(1)已经被启用;
                //delete instance2->release(); 也可释放内存; 但是release(0)已经被弃用;
        }

boost::scoped_ptr

总结

1.独享内存. 即不能被赋值给另一个同类scoped_ptr指针.

2.因为具有1所描述的特性, 避免了std::auto_ptr的几个问题. 比如赋值会编译错误;

3.没有release(0), 可以通过reset(1)释放内存.

代码
:

#include "simple.h"

#include <boost/smart_ptr.hpp>

int main() {
        boost::scoped_ptr<Simple> my_memory(new Simple(1));   // 创建对象，输出：Simple：1
        if (my_memory.get()) {                            // 判断智能指针是否为空
                my_memory->PrintSomething();                    // 使用 operator-> 调用智能指针对象中的函数
                my_memory.get()->info_extend = "Addition";      // 使用 get() 返回裸指针，然后给内部对象赋值
                my_memory->PrintSomething();                    // 再次打印，表明上述赋值成功
                (*my_memory).info_extend += " other";           // 使用 operator* 返回智能指针内部对象，然后用“.”调用智能指针对象中的函数
                my_memory->PrintSomething();                    // 再次打印，表明上述赋值成功
          }

        boost::scoped_ptr<Simple> instance(new Simple(1));
        if(instance.get()){
                boost::scoped_ptr<Simple> instance2;
                //instance2 = instance; //err, forbidden by compiler;
                //instance->release(); //err, has no such member function;
        }

          return 0;
}

boost::shared_ptr

总结

1.共享内存, 具有operator=操作, 带引用计数.

代码

#include "simple.h"

#include <boost/smart_ptr.hpp>

void TestSharedPtr(boost::shared_ptr<Simple> memory) {  // 注意：无需使用 reference (或 const reference)

  memory->PrintSomething();

  std::cout << "TestSharedPtr UseCount: " << memory.use_count() << std::endl;

}

int main() {
        boost::shared_ptr<Simple> my_memory(new Simple(1));   // 创建对象，输出：Simple：1
        if (my_memory.get()) {                            // 判断智能指针是否为空
                my_memory->PrintSomething();                    // 使用 operator-> 调用智能指针对象中的函数
                my_memory.get()->info_extend = "Addition";      // 使用 get() 返回裸指针，然后给内部对象赋值
                my_memory->PrintSomething();                    // 再次打印，表明上述赋值成功
                (*my_memory).info_extend += " other";           // 使用 operator* 返回智能指针内部对象，然后用“.”调用智能指针对象中的函数
                my_memory->PrintSomething();                    // 再次打印，表明上述赋值成功
          }

         std::cout << "TestSharedPtr2 UseCount: " << my_memory.use_count() << std::endl;

         TestSharedPtr(my_memory);

        std::cout << "TestSharedPtr2 UseCount: " << my_memory.use_count() << std::endl;



  //my_memory.release();// 编译 error: 同样，shared_ptr 也没有 release 函数

          return 0;
}

boost::scoped_array

scoped_ptr的数组版

代码 :

#include "simple.h"

#include <boost/smart_ptr.hpp>

int main(){
        boost::scoped_array<Simple> test_array(new Simple[2]);
        if(test_array.get()){
                test_array[0].PrintSomething();

                test_array.get()[0].info_extend = "Addition";
                test_array[0].PrintSomething();
                //(*test_array)[0].info_extend += "other"; //err, scoped_array has no *;
                //test_array[0].release(); //test_array[0] is a Simple;
                boost::scoped_array<Simple> test_array2;
                //test_array2=test_array; //err scoped_array has no operator=;
        }
}

boost::shared_array

shared_ptr的数组版

代码

#include "simple.h"

#include <boost/smart_ptr.hpp>

void test_shared_array(boost::shared_array<Simple> memory){ // no need to be reference or const reference;
        std::cout << "Test shared array use count:" << memory.use_count() << std::endl;
}

int main(){
        boost::shared_array<Simple> test_array(new Simple[2]);
        if(test_array.get()){
                test_array[0].PrintSomething();

                test_array.get()[0].info_extend = "Addition";
                test_array[0].PrintSomething();
                //(*test_array)[0].info_extend += "other"; //err, shared_array has no *;
                //test_array[0].release(); //test_array[0] is a Simple;
                boost::shared_array<Simple> test_array2;
                test_array2=test_array;
                std::cout << "Test shared array use count:" << test_array.use_count() << std::endl;
        }

        std::cout << "Test shared array use count:" << test_array.use_count() << std::endl;
        test_shared_array(test_array);
        std::cout << "Test shared array use count:" << test_array.use_count() << std::endl;
}