shared_ptr<int> pi = make_shared<int>(25);

auto ps = make_shared<string>(10, '9');

auto r = make_shared<int>(42);  //r指向的int只有一个引用者
r = q;          //给赋值，r指向另一个地址//递增q指向的对象的引用计数//递减r原来指向的对象的引用计数// r原来指向的对象已经没有引用者，会自动释放

#include <iostream>
#include <string>
#include <vector>
#include <memory>
#include <stdexcept>
using namespace std;class StrBlob
{
public:typedef vector<string>::size_type size_type;   StrBlob();StrBlob(initializer_list<string> il);size_type size() const {return data->size();}bool empty() const {return data->empty();}//添加和删除元素 void push_back(const string &t) {data->push_back(t);}void pop_back();//元素访问string &front();string &back(); const string &front() const;const string &back() const; private:shared_ptr<vector<string>> data;  //如果data[i]不合法，抛出一个异常 void check(size_type index, const string &msg) const;
};//默认构造函数
StrBlob::StrBlob() : data(make_shared<vector<string>>()) {}//拷贝构造函数
StrBlob::StrBlob(initializer_list<string> il) : data(make_shared<vector<string>>()) {}void StrBlob::check(size_type index, const string &msg) const
{if(index >= data->size())throw out_of_range(msg);
}void StrBlob::pop_back()
{check(0, "pop_back on empty StrBlob");data->pop_back();
}const string &StrBlob::front() const
{check(0, "front on empty StrBlob");return data->front();
}string &StrBlob::front()
{const auto &s = static_cast<const StrBlob*>(this)->front();return const_cast<string &>(s);
}const string &StrBlob::back() const
{check(0, "back on empty StrBlob");return data->back();
}string &StrBlob::back()
{const auto &s = static_cast<const StrBlob*>(this)->back();return const_cast<string &>(s);
}int main()
{  std::shared_ptr<StrBlob> sp;  StrBlob s1({"wang","wei","hao"});  StrBlob s2(s1);//共享s1内的数据  std::string st = "asd";  s2.push_back(st);  //s2.front();  std::cout << s2.front() << std::endl;  std::cout << s2.back() << std::endl;  std::cout << s1.front() << std::endl;  std::cout << s1.back() << std::endl;
}  

结果：

#include <iostream>
#include <string>
#include <vector>  using namespace std;  int main()
{  //在自由空间分配的内存是无名的，因此new无法为其分配的对象命名，而是返回一个指向该对象的指针。  int *p = new int;  int *p2 = new int(10);  string *p3 = new string(10,'a');  vector<string> *p4 = new vector<string>{"a","b","c"};  //也可以对动态分配的对象进行值初始化，只需在类型名之后加一对空括号  string *p5 = new string(); //值初始化  string *p6 = new string;   //默认初始化  int *p7 = new int;         //但是对于内置类型是未定义的。*p7值未定义  //对动态分配的对象进行初始化通常是个好主意。  //auto   auto p8 = new auto("abc");  //p8指向一个与obj类型相同的对象 auto p9 = new auto{1,2,3}; //error：括号中只能有单个初始化器 //const  //一个动态分配的const对象必须进行初始化。  const string *p10 = new const string("aha");  const int pci = new const int(1024); //内存耗尽  int *p11 = new int;  //如果分配失败,new会抛出一个std::bad_alloc  int *p12 = new (nothrow) int; //如果分配失败返回一个空指针。 bad_alloc和nothrow定义在#include <new>
}  

#include <memory>
#include <iostream>  using namespace std;  int main()
{  //p也指向p2指向的内存，那么p原来所指向的内存区域就没有其他指针指向了，也没有释放，内存泄漏  int *p = new int(20);  int *p2 = new int(40);  p = p2;  //p3也指向p4所指向的内存，但是p3原先指向的内存区域计数器变为0时，内存自动会释放。  auto p3 = make_shared<int>(20);  auto p4 = make_shared<int>(30);  p3 = p4;
}  

shared_ptr<int> p1 = new int(1024); //错误：必须使用直接初始化形式
shared_ptr<int> p2(new int(1024));    //正确：使用了直接初始化形式 

shared_ptr<int> clone(int p) {
return new int(1024);   //错误：不能进行普通指针到智能指针的隐式转换
}shared_ptr<int> clone(int p) {
return shared_ptr<int>(new int(1024));    //正确：需要显示绑定到智能指针
}

{  auto p = make_shared<int>(20);  auto q = p.get();  delete q;
}  

if(!p.unique())
{
p.reset(new string(*p));
*p += newVal；
}

void f()
{shared_ptr<int> sp(new int(42)); //分配一个新对象//这段代码抛出一个异常，且在f中未被捕获//在函数结束时，shared_ptr能自动释放内存
}

connection connect(destination *);
void disconnect(connection);
void f(destination &d)
{  connection c  = connect(&d);  //使用连接...disconnect(d);//如果没有调用disconnect，那么永远不会断开连接。
}  

connection connect(destination *);
void disconnect(connection);
void end_connection(connection *p) {disconnect(*p);}
void f(destination &d)
{  connection c = connect(&d);  shared_ptr<connection> p(&c, end_connection);  //使用连接//f退出时，会自动调用end_connection。
}  

#include <iostream>
#include <string>
#include <memory>using namespace std;
typedef string connection;connection &connect(connection *s)
{cout << "正在建立连接..." << endl;s = new connection("connect");return *s;
}void disconnect(connection *s)
{cout << "正在断开连接..." << endl;
}int main()
{connection p;connection *dis;p = connect(dis);shared_ptr<connection> sp(&p, disconnect);
} 

#include <iostream>
#include <string>
#include <memory>
#include <functional>
#include <algorithm>  using namespace std;
typedef string connection;  connection& connect(connection *s)
{  cout << "正在连接..." << endl;  s = new connection("connect");  return *s;
}  void disconnect(connection *s)
{  cout << "正在断开连接..." << endl;
}  int main()
{  connection p;  connection *d;  p = connect(d);  //shared_ptr<connection>sp(&p,disconnect);      //error:lambda代表了删除函数。那么参数列表也要和删除函数一致，因为delete内部是free(p)。  //shared_ptr<connection>sp(&p, [&p] { disconnect(&p); });   shared_ptr<connection>sp(&p,   [](connection *s) { disconnect(s); });
}  

shared_ptr 的传递删除器(deleter)方式比较简单, 只需要在参数中添加具体的删除器函数名, 即可; 注意是单参数函数;

#include <memory>
#include <iostream>
#include <string>  using namespace std;  unique_ptr<int> clone(int p)
{  unique_ptr<int> q(new int(p));  //手动new，并绑定 return q;
}  int main()
{  unique_ptr<string> p(new string("aaa"));  shared_ptr<string> p2(new string("aaa"));  //unique_ptr<string> p3(p);   error:不能拷贝  //unique_ptr<string> p4 = p;  error:不能赋值  unique_ptr<string> p5;  string s = "a";  //p5.reset(&s);              error:两次释放  //两种转移所有权的方法  unique_ptr<string> p6(p.release()); //p.release()，释放p对指针对象的控制权，返回指针并将p置空,并不会释放内存  unique_ptr<string> p7;  p7.reset(p6.release());           //p6释放控制权，p7指向这个对象。  //特殊的拷贝和赋值  int i = 10;  clone(i);
}  

在早的版本中提供了auto_ptr的类，它有unique_ptr 的部分特性，但是不能在容器中保存auto_ptr, 也不能在函数中返回 auto_ptr, 编写程序时应该使用unique_ptr.

#include <memory>
#include <iostream>  using namespace std;  typedef int connection;  connection *connect(connection *d)
{  cout << "正在连接..." << endl;  d = new connection(40);  return d;
}  void disconnect(connection *p)
{  cout << "断开连接..." << endl;
}  int main()
{  connection *p,*p2;  p2 = connect(p);  cout << p << endl;   cout << *p2 << endl;  unique_ptr<connection, decltype(disconnect)*> q(p2, disconnect);  //在尖括号中提供类型，圆括号内提供尖括号中的类型的对象。  //使用decltype()关键字返回一个函数类型，所以必须添加一个*号来指出我们使用的是一个指针
}  

auto p = make_shared<int>(42);
weak_ptr<int> wp(p);  //wp若共享p：p的引用计数未改变if(shared_ptr<int> np = wp.lock())
{//如果np不为空，则成立//在if中,np和p共享对象
} 

/*
*避免拷贝,多个指针共用一个vector<string>
*使用weak_ptr访问共享的对象
* */#include <iostream>
#include <vector>
#include <string>
#include <initializer_list>
#include <memory>
#include <stdexcept>
#include <fstream>
#include <sstream>  class StrBlob;
class StrBlobPtr;class StrBlob
{
public:friend class StrBlobPtr;typedef std::vector<std::string>::size_type size_type;StrBlob(); //默认构造函数  StrBlob(std::initializer_list<std::string>il); //拷贝构造函数  size_type size() { return data->size(); }      //对data进行解引用就是对vector<string>操作  std::string& front();std::string& back();const std::string& front()const;const std::string& back()const;void push_back(const std::string &s) { data->push_back(s); }void pop_back();//StrBlobPtr begin() { return StrBlobPtr(*this); }  //StrBlobPtr end() { auto ret = StrBlobPtr(*this, data->size());    //                   return ret; }  private:void check(size_type sz, std::string msg) const;std::shared_ptr<std::vector<std::string>> data;
};std::string& StrBlob::front()
{const auto &s = static_cast<const StrBlob*>(this)->front();return const_cast<std::string&>(s);
}std::string& StrBlob::back()
{const auto &s = static_cast<const StrBlob*>(this)->back();return const_cast<std::string&>(s);
}const std::string& StrBlob::front()const
{check(0, "front on empty vector");return data->front();
}const std::string& StrBlob::back()const
{check(0, "back on empty vector");return data->back();
}void StrBlob::check(size_type sz, std::string msg)const
{if (sz >= data->size())throw std::out_of_range(msg);
}StrBlob::StrBlob() :
data(std::make_shared<std::vector<std::string>>()) { }StrBlob::StrBlob(std::initializer_list<std::string> il) :
data(std::make_shared<std::vector<std::string>>(il)) { }/* --------------------------------------------------------------------------------- *///必须定义在StrBlobPtr的后面
//否则error: invalid use of incomplete type ‘class StrBlob’
class StrBlobPtr
{
public:friend StrBlob;StrBlobPtr() :curr(0){ }StrBlobPtr(StrBlob &s, std::size_t sz = 0) :wptr(s.data), curr(sz){ }std::string& deref()const;  //返回当前string  StrBlobPtr& incr();         //递增  private:std::shared_ptr<std::vector<std::string>> check(std::size_t i, const std::string &msg)const;std::weak_ptr<std::vector<std::string>> wptr;std::size_t curr;  //当前下标
};StrBlobPtr& StrBlobPtr::incr()
{check(curr, "increment past end of StrBlobPtr");++curr;                //推进当前位置。    return *this;          //为什么要return *this, 如果再次自加可以重复，举个例子就像赋值一样 a = b = c;  如果不返回对象不能继续赋值。
}                              //return *this是一份拷贝。 return this是地址。  std::string& StrBlobPtr::deref()const
{auto p = check(curr, "dereference past end");  //shared_ptr引用计数会增加,但是作用域结束后，引用计数又会减1  return (*p)[curr];    //p是所指的vector
}//check检查是否存在shared_ptr和大小
std::shared_ptr<std::vector<std::string>> StrBlobPtr::check(std::size_t i, const std::string &msg)const
{auto ret = wptr.lock(); //检查是否存在，存在返回shared_ptr,不存在返回空的shared_ptr.  if (!ret)throw std::runtime_error("unbound StrBlobPtr");if (i >= ret->size())throw std::out_of_range(msg);return ret;
}int main(int argc, char*argv[])
{std::fstream is(argv[1]);std::string s;StrBlob S;while (std::getline(is, s)){std::string temp;std::istringstream ist(s);while (!ist.eof()){ist >> temp;S.push_back(temp);}}std::cout << "size:" << S.size() << std::endl;StrBlobPtr sp(S);for (auto i = 0; i < S.size(); ++i){std::cout << sp.deref() << std::endl;sp.incr();}
}