c++ auto_ptr智能指针


该类型在头文件memory中，在程序的开通通过 #include<memory> 导入，接下来讲解该智能指针的作用和使用。

使用方法：

　　auto_ptr<type> ptr(new type());   这是该指针的定义形式，其中 type 是指针指向的类型，ptr 是该指针的名称。

　　比如该type 是int，具体定义如下：

　　auto_ptr<int> ptr(new int(4));

　　比如该type 是map<int,vector<int> >，具体定义如下：

　　auto_ptr<map<int,vector<int> > > ptr(new map<int,vector<int> > ());

　　当然可以先定义，后赋值，如下所示：

　　auto_ptr<map<int,int> > ptr;

　　ptr = auto_ptr<map<int,int> >(new map<int,int> ());

 

作用1：保证一个对象在某个时间只能被一个该种类型的智能指针所指向，就是通常所说的对象所有权。

 

作用2：对指向的对象自动释放的作用，详情看如下代码。

代码片段一：

 

#include <iostream>

#include <string.h>
#include <memory>
#include <string>
#include <Windows.h>
#include <map>

#include <ctime>
#include <vector>
using namespace std;#define MAXN 20000000

class test_ptr
{
public:
    map<int,int> *p;
    test_ptr()
    {
        p = new map<int,int>();
        for(int i = 0;i<MAXN;i++)
            p->insert(make_pair(i,i));
    }
};

int main(int argc,char *argv[])
{
    for(int i = 0;i<100;i++)
    {
        Sleep(1000);
        cout << i << endl;  // 输出 创建次数
        test_ptr * tmp = new test_ptr();

    }
    
    system("pause");
    return 0;
}

 

在某些情况下，可能我们就会写出上面的代码来，通过运行会发现存在内存溢出。对于一些经验老道的程序员可能会作如下改写：

代码片段二：

#include <iostream>

#include <string.h>
#include <memory>
#include <string>
#include <Windows.h>
#include <map>
#include <ctime>
#include <vector>

using namespace std;


#define MAXN 20000000

class test_ptr
{
public:
    map<int,int> *p;
    test_ptr()
    {
        //p  = auto_ptr<map<int,int> > (new map<int,int>());
        p = new map<int,int>();
        for(int i = 0;i<MAXN;i++)
            p->insert(make_pair(i,i));
    }
    
    ~test_ptr()
    {
        delete p;
    }
    
};

int main(int argc,char *argv[])
{
    for(int i = 0;i<100;i++)
    {
        Sleep(1000);
        cout << i << endl;   
        test_ptr * tmp = new test_ptr();

    }
    
    system("pause");
    return 0;
}

在test_ptr 类中的析构函数中添加内存释放代码，但是在main函数中，定义的局部指针，当局部指针失效时并不会自动调用析构函数，在这种情况下也会导致内存泄漏问题。当然，如果细心的程序员可以在 test_ptr * tmp = new test_ptr() 后面加上一句 delete tmp ,这样也能够释放内存，不会出现内存泄漏问题。但是在某些情况下，很容易漏写，为了解决此问题，auto_ptr 就能发挥作用了。

代码片段三：

#include <iostream>

#include <string.h>
#include <memory>
#include <string>
#include <Windows.h>
#include <map>
#include <ctime>
#include <vector>

using namespace std;


#define MAXN 20000000

class test_ptr
{
public:
    map<int,int> *p;
    test_ptr()
    {
        p = new map<int,int>();
        for(int i = 0;i<MAXN;i++)
            p->insert(make_pair(i,i));
    }
    
    ~test_ptr()
    {
        delete p;
    }
    
};

int main(int argc,char *argv[])
{
    for(int i = 0;i<100;i++)
    {
        Sleep(1000);
        cout << i << endl;    //输出创建次数
        auto_ptr<test_ptr> tmp = auto_ptr<test_ptr> (new test_ptr());
        
    }
    
    system("pause");
    return 0;
}

在main函数中，创建test_ptr类型指针时，该指针是auto_ptr 类型的智能指针，当智能指针失效时，会自动调用该类的析构函数。所以这种写法可以不再显示调用delete 语句了。但是该智能指针也只是保证调用类的析构函数，如果析构函数并没有释放类中声明的变量，那该怎么办。

代码片段四：

#include <iostream>

#include <string.h>
#include <memory>
#include <string>
#include <Windows.h>
#include <map>
#include <ctime>
#include <vector>

using namespace std;


#define MAXN 20000000

class test_ptr
{
public:
    //auto_ptr<map<int,int> > p;
    map<int,int> *p;
    test_ptr()
    {
        //p  = auto_ptr<map<int,int> > (new map<int,int>());
        p = new map<int,int>();
        for(int i = 0;i<MAXN;i++)
            p->insert(make_pair(i,i));
    }
    /*
    ~test_ptr()
    {
        delete p;
    }
    */
};

int main(int argc,char *argv[])
{
    for(int i = 0;i<100;i++)
    {
        Sleep(1000);
        cout << i << endl;    //输出创建次数
        auto_ptr<test_ptr> tmp = auto_ptr<test_ptr> (new test_ptr());
        
    }
    
    system("pause");
    return 0;
}

在这种情况下，还是会出现内存泄漏问题，为了解决该问题，对类中声明的指针也是需要声明为auto_ptr类型。

代码片段五：

#include <iostream>

#include <string.h>
#include <memory>
#include <string>
#include <Windows.h>
#include <map>
#include <ctime>
#include <vector>

using namespace std;


#define MAXN 20000000

class test_ptr
{
public:
    auto_ptr<map<int,int> > p;
    test_ptr()
    {
        p  = auto_ptr<map<int,int> > (new map<int,int>());
        for(int i = 0;i<MAXN;i++)
            p->insert(make_pair(i,i));
    }
  
};

int main(int argc,char *argv[])
{
    for(int i = 0;i<100;i++)
    {
        Sleep(1000);
        cout << i << endl;    //输出创建次数
        auto_ptr<test_ptr> tmp = auto_ptr<test_ptr> (new test_ptr());
     
    }
    
    system("pause");
    return 0;
}

这样就不用显示定义类的析构函数，不用在外部显示调用delete函数，当然如果尽早调用delete函数也是可以的，尽早释放内存也比该指针失效再释放好一些，这些就是为了防止忘记调用。

 

通过如上分析：可以得出如下结论。

1 定义了智能指针，当智能指针失效时会自动调用类的析构函数。

2 在 类中定义的智能指针，不必在析构函数中显示的delete，当外部调用该类的析构函数时，会自动释放该智能指针指向的对象，释放内存。

3 如果类中定义的是智能指针，但是外部没有触发类中的析构函数调用，该智能指针指向的对象还是不能释放。

 

auto_ptr  智能指针的bug

auto_ptr 智能指针在c++ 11 标准中已经被抛弃，被抛弃的原因就是因为该bug。前面也提到过，一个对象只能被一个智能指针所引用，这样就会导致一个赋值问题。看如下代码

代码片段六：

 1 #include <iostream>
 2 
 3 #include <string.h>
 4 #include <memory>
 5 #include <set>
 6 
 7 using namespace std;
 8 
 9 
10 #define MAXN 20000000
11 
12 void pri(auto_ptr<set<int> > p)
13 {
14     set<int>::iterator ite = p->begin();
15     for(;ite!=p->end();ite++)
16     {
17         cout << *ite << endl;
18     }
19 }
20 
21 int main(int argc,char *argv[])
22 {
23     auto_ptr<set<int> > ptr(new set<int> ());
24 
25     for(int i = 0;i< 3;i++)
26     {
27         int a;
28         cin >> a;
29         ptr->insert(a);
30     }
31 
32     pri(ptr);
33 
34     pri(ptr);
35     
36     system("pause");
37     return 0;
38 }

初看这代码没什么问题，不过运行程序会崩溃。这就是该智能指针最大的bug, 在程序32行 调用pri(ptr) ，程序到这并没什么问题，但是第二次调用pri(ptr) 时程序就会崩溃。原因就是前面讲过，一个对象智能被一个智能指针所指向，在第一次调用pri()函数时，为了保证这一原则，当把ptr指针传入pri函数时，程序内部就把ptr置为空，所以到第二次调用时，就会出现崩溃的情况。对于这种情况的解决之道就是使用shared_ptr 指针（该指针的原理是通过引用计数器来实现的）。

如果要使用shared_ptr 智能指针，需要安装boost库，该库还包括许多其他功能。有兴趣的可以尝试以下，该类中的智能指针还是比较好用。也不存在很多其他bug。

有时间再详细介绍boost库中shared_ptr指针