c++基础 8.5_智能指针的用法

1. 智能指针的简单应用

功能：处理没有释放内存，所引起的内存泄漏的问题；
（1）智能指针的初始化类似于容器；

auto_ptr<int> ptr(new int(10)); //(1)智能指针的初始化类似于容器；

（2）指针类型所以需要考虑重载解引用(*)和指向符（->）,可以修改和不可修改；

const T& operator*()const{
   return *p;}  //(2.1)不可改变；
    T& operator*(){
   return *p;}   //(2.2)可以 改变
    const T* operator->()const{
   return p;}// 2.3
    T* operator->(){
   return p;} // 2.4

（3）问题：valgrind ./a.out 检测到浅拷贝，多次释放的问题

// auto_ptr<int> copy_ptr(ptr);
    //cout <<*copy_ptr << endl;  //(3)valgrid 检测内存出现浅拷贝，多次释放的问题

（4）解决办法：（c++11）:去除拷贝构造和赋值运算符重载；

auto_ptr(const auto_ptr&) = delete;
   auto_ptr& operator=(const auto_ptr&) = delete;//（4）解决方案（c++11）:去除拷贝构造和赋值运算符重载；

（完整代码见 001_intelligient_pointer.cpp）

#include <iostream>
#include <vector>
#include <list>
#include <set>
using namespace std;

template<typename T>
class auto_ptr{
   
    T* p;

public:
    auto_ptr(T* p):p(p){
   }
    ~auto_ptr(){
   delete p;}
    const T& operator*()const{
   return *p;}  //(2.1)不可改变；
    T& operator*(){
   return *p;}   //(2.2)可以 改变
    const T* operator->()const{
   return p;}// 2.3
    T* operator->(){
   return p;} // 2.4
   auto_ptr(const auto_ptr&) = delete;
   auto_ptr& operator=(const auto_ptr&) = delete;//（4）解决方案（c++11）:去除拷贝构造和赋值运算符重载；
};

struct Student{
   
    string name;
    int age;
};





int main(){
   
    auto_ptr<int> ptr(new int(10)); //(1)智能指针的初始化类似于容器；
    cout << *ptr << endl;           //(2)重载解引用运算符；,指针运算符
    *ptr = 11;
    cout << *ptr << endl;
    const  auto_ptr<int> cptr(new int(20));
    cout << *cptr << endl;

    auto_ptr<Student> stu(new Student{
   "张三",23});
    cout << (*stu).name<< endl; //(2)重载解引用运算符；,指针运算符
    cout << (*stu).age<< endl;

    cout << stu->name<< endl;//(2)重载解引用运算符；,指针运算符
    cout << stu->age<< endl;


   // auto_ptr<int> copy_ptr(ptr);
    //cout <<*copy_ptr << endl;  //(3)valgrid 检测内存出现浅拷贝，多次释放的问题


}

2. vector数组，释放内存的问题

（2.1）delete[] 和delete的区别

delete释放单个数据的内存；
delete[]释放数组的内存，不许要对应释放；

 Simple* p = new Simple[5];
    delete [] p;
    //delete p;   不匹配的释放，需要对应的释放；

（2.2）vector存放指针

vector里面存放指针的时候，需要手动释放内存；

   //(2)vector存放指针，不负责释放。需要手动释放；
    for(auto v:vec){
   
        delete v;
    }

（2.3）完整代码

#include <iostream>
#include <vector>
#include <list>
#include <set>
using namespace std;

template<typename T>
class auto_ptr{
   
    T* p;

public:
    auto_ptr(T* p):p(p){
   }
    ~auto_ptr(){
   delete p;}
    const T& operator*()const{
   return *p;}  //(2.1)不可改变；
    T& operator*(){
   return *p;}   //(2.2)可以 改变
    const T* operator->()const{
   return p;}// 2.3
    T* operator->(){
   return p;} // 2.4
   auto_ptr(const auto_ptr&) = delete;
   auto_ptr& operator=(const auto_ptr&) = delete;//（4）解决方案（c++11）:去除拷贝构造和赋值运算符重载；
};

struct Student{
   
    string name;
    int age;
};


class Simple{
   
public:
    Simple(){
   cout<<__func__ << endl;}
    ~Simple(){
   cout<<__func__ << endl;}
};


int main(){
   
    auto_ptr<int> ptr(new int(10)); //(1)智能指针的初始化类似于容器；
    cout << *ptr << endl;           //(2)重载解引用运算符；,指针运算符
    *ptr = 11;
    cout << *ptr << endl;
    const  auto_ptr<int> cptr(new int(20));
    cout << *cptr << endl;

    auto_ptr<Student> stu(new Student{
   "张三",23});
    cout << (*stu).name<< endl; //(2)重载解引用运算符；,指针运算符
    cout << (*stu).age<< endl;

    cout << stu->name<< endl;//(2)重载解引用运算符；,指针运算符
    cout << stu->age<< endl;


   // auto_ptr<int> copy_ptr(ptr);
    //cout <<*copy_ptr << endl;  //(3)valgrid 检测内存出现浅拷贝，多次释放的问题

    //（1）delete 和 delete[]的区别

    Simple* p = new Simple[5];
    delete [] p;
    //delete p;   不匹配的释放，需要对应的释放；

    vector<Simple*> vec;
    vec.push_back(new Simple);
    vec.push_back(new Simple);
    vec.push_back(new Simple);
    vec.push_back(new Simple);
    //(2)vector存放指针，不负责释放。需要手动释放；
    for(auto v:vec){
   
        delete v;
    }






}

3. 智能指针数组

（1）需要定义数组指针类，并将数组存入的指针数组；

template<typename T>
class ptr_array{
   
        T* p;
public:
    ptr_array(T* p):p(p){
   }
    ~ptr_array(){
   }
    const T& operator*()const{
   return *p;}  //(2.1)不可改变；
    T& operator*(){
   return *p;}   //(2.2)可以 改变
    const T* operator->()const{
   return p;}// 2.3
    T* operator->(){
   return p;} // 2.4
   ptr_array operator+(int n)const{
   
        return ptr_array(p+n);
   }
    ptr_array operator-(int n)const{
   
        return ptr_arr(p-n);
   }
   ptr_array operator++(){
   
        return ptr_arr(++p);
   }

   ptr_array operator++(int){
   
        ptr_array res(p);//创建一个对象，res初始值为p；
        ++p;
        return res;
   }
};

 ptr_array<int> arr(new int[10]);  //（1）需要定义数组指针类，并将数组存入的指针数组；
    for(int i = 0; i<10;++i){
   
        *(arr+i) = i;
    }

（2）暂时不释放内存，打印

 for(int i = 0;i < 10;++i){
   
        cout << (*arr++) << endl;  //(2)暂时不释放内存；
    }

（完整代码见 003_intelligent_pointer_bank.cpp）

#include <iostream>
#include <vector>
#include <list>
#include <set>
using namespace std;

template<typename T>
class auto_ptr{
   
    T* p;

public:
    auto_ptr(T* p):p(p){
   }
    ~auto_ptr(){
   delete p;}
    const T& operator*()const{
   return *p;}  //(2.1)不可改变；
    T& operator*(){
   return *p;}   //(2.2)可以 改变
    const T* operator->()const{
   return p;}// 2.3
    T* operator->(){
   return p;} // 2.4
   auto_ptr(const auto_ptr&) = delete;
   auto_ptr& operator=(const auto_ptr&) = delete;//（4）解决方案（c++11）:去除拷贝构造和赋值运算符重载；
};

template<typename T>
class ptr_array{
   
        T* p;
public:
    ptr_array(T* p):p(p){
   }
    ~ptr_array(){
   }
    const T& operator*()const{
   return *p;}  //(2.1)不可改变；
    T& operator*(){
   return *p;}   //(2.2)可以 改变
    const T* operator->()const{
   return p;}// 2.3
    T* operator->(){
   return p;} // 2.4
   ptr_array operator+(int n)const{
   
        return ptr_array(p+n);
   }
    ptr_array operator-(