智能指针——c++primer第五版12章——个人总结

//

#include "stdafx.h"
#include <memory>
#include <string>
#include <vector>
#include<new>
using namespace std;//名字空间，不然使用的时候写std::shared_ptr

int main()
{
//1:智能指针的定义与初始化；
shared_ptr<int> pint1;//定义,不初始化就是一个空指针
shared_ptr<int> pint2 = make_shared<int>();//默认初始化 int默认是0
shared_ptr<int> pint3 = make_shared<int>(44);//值初始化
shared_ptr<string> pstr1 = make_shared<string>(10, 'a');//用string的某一个重载构造函数初始化
auto pVecString1 = make_shared<vector<string>>();//auto也可以
//pint2 = new int(1024);
pint2.reset(new int(1024));//让pint2指向一个新对象,计数器-1，如有必要，释放原内存，新计数器+1

//2:shared_ptr与unique_ptr共有的操作
int * pint4 = pint2.get();//get()将返回一个int*类型的指针,注意不能释放掉pint4所指向的空间，不然会使pint2失效
swap(pint2, pint3);//或者
pint2.swap(pint3);//交换两个指针

//3:shared_ptr独有的操作
make_shared<int>(5);//构造shared_ptr的函数，返回值是shared_ptr<int>
bool isUnique = pint3.unique();//判断pint3是不是唯一指向这个对象的指针 这个例子中返回false
int useCount = pint3.use_count();//返回指向pint3指向对象的所有指针的个数 这个例子中返回1

//4:直接管理内存
string *ps1 = new string;//使用string的默认初始化构造函数
string *ps2 = new string();//使用string的""值初始化函数，只不过这个值是空值。
//我觉得上面这两句的概念不一样吧,但结果是一样的，都是空string。
int *pi1 = new int;//默认初始化 pi1指向的值未定义，int的默认初始化不会为它赋值，string的默认初始化为自己赋值为空。
int *pi2 = new int();//值初始化，pi2指向的值是0
auto pin = new auto(5);//可以推测出pin的类型是int *
const int *pci = new const int(1024);//动态分配的const必须初始化，const int *pci = new const int;是错误的
const string *pcsi = new const string;//默认是空串 这是可以的
int *p2 = new(nothrow)int;//相当于传递给new一个参数 如果内存没空间了 返回一个空指针，而不是报错 头文件#include<new>
delete ps1;//释放内存,但ps1变成空悬指针,指向的地方没有东西。
ps1 = nullptr;//重置指针为空，这是一种保护方式,

//5.shared_ptr new 结合使用
shared_ptr<double> pdou1(new double(10.8));//之后不用delete来释放内存，pdou1在作用域结束时会释放内存
//注意shared_ptr<double> pdou1=new double(10.8);的写法是错误的，因为shared_ptr的构造函数是explicit
if (!pstr1.unique())
pstr1.reset(new string(*pstr1));
*pstr1 += "hellpo";
//上面这三行代码的含义是：pstr1是我上面定义的智能指针，假设现在我想通过这个智能指针改变所指向对象的值，
//但是如果有其他智能指针也指向这个对象，那我就间接的把其他智能指针的对象也改变了，
//因为这些智能指针所指都是同一个对象。所以，判断一下是否自己是唯一指针，如果不是唯一指针的话，
//让pstr1重新指向一个拥有同一个对象值的string，相当于又开辟了一块内存。再改变新的对象.

//6.智能指针与异常
//如果在我写的这整段程序的这一位置出现了异常，那么最后的return0和}不会执行，即使这样，shared_ptr所指的内存也能自动释放,
//但是new出来的内存，没碰到delete就不能被释放. 优点：使用智能指针可以避免内存泄漏!

//7.unique_ptr 指向唯一的对象 不能拷贝 unique_ptr<int> unPin1(p2);是错误的 不能赋值 unPin1=p2也是错误的
unique_ptr<int> unPin1(new int(48));//unique_ptr<T,D> un(d);指向T对象，用类型为D的对象d来代替delete
//unPin1 = nullptr;//释放对象 或者nuPin1.reset(nullptr);
//unPin1.release();//返回原指针，同时原指针放弃对指针的控制权，并置空,但是这种写法是不正确的，因为内存不会释放！！！

//unPin1.reset();//unPin1.reset(p);释放并指向内置指针p
//用release 和 reset解决unique_ptr不能拷贝和赋值的情况,上面几行我注释掉，因为我要运行，不想让它变空
unique_ptr<int> unPin2(new int(53));
unique_ptr<int> unPin3(unPin2.release());//这样就可以拷贝了
unPin1.reset(unPin3.release());//这样就可以赋值了
int* unPin1copy = unPin1.release();//release一定要赋值 不然就没有释放内存 返回类型int*

//8.weak_ptr
auto p = make_shared<int>(76);
weak_ptr<int> wp(p);//weak_ptr用shared_ptr来构造，不增加引用计数，不控制对象的生存期 “弱”
wp = p;//支持赋值
wp.reset();//指针置空
wp.use_count();//返回这个对象shared_ptr的数量
wp.expired();//use_count为0时返回true
wp.lock();//返回一个shared_ptr 可以是空 或者是指向某对象的//weak_ptr不能用来访问对象,一定是用lock()
if(shared_ptr<int> np=wp.lock()){}

return 0;
}

#pragma once
#include <memory>
#include <string>
#include <vector>
#include<initializer_list>
#include"StrBlobPtr.h"

using namespace std;//不写名字空间的话 好麻烦
class StrBlob {
public:
typedef std::vector<std::string>::size_type size_type;
StrBlob():data(std::make_shared<std::vector<std::string>>()){}
StrBlob(std::initializer_list<std::string> &l):data(std::make_shared<std::vector<std::string>>(l)){}
size_type size()const { return data->size(); }
bool empty()const { return data->empty(); }
void push_back(std::string &s) { data->push_back(s); }
void pop_back(){
check(0, "popback on empty StrBlob");
data->pop_back();
}
std::string &front() {
check(0, "front on empty StrBlob");
return (*data)[0];
}
std::string &back() {
check(0, "back on empty StrBlob");
return (*data)[data->size() - 1];
}
const string &front()const{}//重载const类型
const string &back()const{}//同上
friend class StrBlobPtr;
StrBlobPtr begin() {
return StrBlobPtr(*this);
}
StrBlobPtr end() {
StrBlobPtr p = StrBlobPtr(*this, data->size());
return p;
}
private:
std::shared_ptr<std::vector<std::string>> data;
void check(size_type i,const std::string &msg)const{
//检查元素是否存在
if (i >= data->size())
throw out_of_range(msg);
}
};

#pragma once
#include <memory>
#include <string>
#include <vector>
#include<initializer_list>

using namespace std;
class StrBlobPtr {
public:
StrBlobPtr():cur(0){}
StrBlobPtr(StrBlob &rhs,size_t sz=0):wptr(rhs.data),cur(sz){}
private:
weak_ptr<vector<string> > wptr;
size_t cur;

shared_ptr<vector<string>> check(size_t i, const string &msg){
//check函数返回一个智能指针 如果不存在 回抛出异常
auto p = wptr.lock();
if (!p)
throw runtime_error("unbound");
if (i >= p->size())
throw out_of_range("msg");
return p;

}

};