智能指针

最新推荐文章于 2023-03-21 22:10:51 发布

Ftworld21

最新推荐文章于 2023-03-21 22:10:51 发布

阅读量345

点赞数

分类专栏： C/C++

本文链接：https://blog.csdn.net/Ftworld21/article/details/103420296

版权

C/C++ 专栏收录该内容

44 篇文章 0 订阅

订阅专栏

c++难点之一就是要比较关注内存管理的问题，如果内存不及时释放就会造成内存泄漏。智能指针出现之前，程序员都是手动释放已经申请的堆内存，但有时候比较容易忘记，也有可能就是程序执行异常了，导致释放内存的代码没有执行，例如以下代码就需要自己手动释放内存。

class Test1206
{
public:
   Test1206(const char *str)
   {
       int len = strlen(str);
       p = new char[len+1];
       strncpy(p, str, len);
       p[len] = '\0';
       cout << "test1206 constructed" << endl;
   }
   ~Test1206()
   {
       delete p;//手动释放
       cout << "test1206 deconstructed" << endl;
   }

   void print()
   {
       cout << p << endl;
   }

private:
char *p = NULL;
};

int main()
{
   Test1206 *t = new Test1206("Hello,World!");
   t->print();
   delete t;//手动释放

return 0;
}

总之手动释放内存很容易导致内存泄漏。智能指针就是用来解决手动释放内存的问题的，比较常用的智能指针就是share_ptr。

(1) shared_ptr(存在线程安全问题)

struct test_shared_ptr_t
{
   ~test_shared_ptr_t()
   {
       cout << "destructed" << endl;
   }
   int a = 0;
   int b = 0;
   int c = 0;
};

int main()
{
shared_ptr<int> ptr = make_shared<int>(2);//自动释放内存如果不填2 会有一个默认的值
cout << ptr.get() << " " << *(ptr.get()) << " " <<*ptr << endl;

shared_ptr<test_shared_ptr_t> ptr2(new test_shared_ptr_t);//自动释放内存
cout << ptr2.get() << " " << ptr2->a << " " << ptr2->b << " " << ptr2->c << endl;

return 0;
}

程序输出为:

0000022A86CE9F80 2 2
0000022A86CEFE60 0 0 0
destructed

从上面的程序可以发现，shared_ptr指针有两种初始化的方式，一种是通过make_shared(推荐使用这次方式)，另外一种是通过把new出来的指针传给shared_ptr的构造函数。比较有意思的是智能指针ptr既可以使用.运算符也可以使用->运算符。

class TestSharePtr
{
public:
   void insert_data()
   {
       auto tmp = make_shared<test_shared_ptr_t>();
       tmp->a = 10;
       tmp->b = 10;
       tmp->c = 10;

       share_map.insert(std::make_pair(10, tmp));
   }
   void delete_data()
   {
       if (share_map.count(10)) {
           share_map.erase(10);
           std::cout << "erase data" << std::endl;
       }
   }

   ~TestSharePtr()
   {
       std::cout << "test_share_ptr deleted!" << std::endl;
   }
   std::map<int, std::shared_ptr< test_shared_ptr_t>> share_map;
};

int main()
{
   TestSharePtr tst;
   tst.insert_data();
   while (1) {
       Sleep(1000);
       tst.delete_data();
   }

return 0;
}

从上面的例子可以发现erase智能指针对象的时候会自动调用构造函数。

struct test_shared_ptr_t
{
   ~test_shared_ptr_t()
   {
       cout << "test_shared_ptr_t destructed" << endl;
   }
   int a = 0;
   int b = 0;
   int c = 0;
};

class TestSharePtr
{
public:
   TestSharePtr()
   {
       test1 = std::make_shared<test_shared_ptr_t>();
       test2 = new test_shared_ptr_t;
   }
   ~TestSharePtr()
   {
       std::cout << "TestSharePtr deleted!" << std::endl;
       delete test2;
   }
   std::shared_ptr<test_shared_ptr_t> test1;
   test_shared_ptr_t* test2;
};