C++ Primer 学习笔记——动态内存与智能指针(1)

程序用堆来存储动态分配的对象——即那些在程序运行时候分配的对象

当动态对象不再时候时，我们的代码必须显式地销毁他们

智能指针——shared_ptr

shared_ptr允许多个指针指向同一个对象

unique_ptr独占所指向的对象

weak_ptr是一种弱引用，指向shared_ptr所管理的对象

智能指针也是模板，在memory头文件中

shared_ptr<int> p;
unique_ptr<string> p2;
*p
p->mem
p.get()
swap(p,q)

make_shared函数

在动态内存中分配一个对象并初始化他，返回指向该对象的shared_ptr

shared_ptr<string> p=make_shared<string>();
auto p2=make_shared<int>(23);

shared_ptr自动销毁所管理的对象、自动释放相关联的内存

每个shared_ptr都有个计数器，无论何时拷贝一个shared_ptr，计数器会自加，而当我们给它赋一个新值（让他指向别的值），或者被销毁，计数器就自减。当计数器为0时，shared_ptr类自动销毁此对象（通过析构函数）

对于一块内存，shared_ptr类保证只要有任何shared_ptr对象引用他，他就不会被释放

//定义StrBlob类，如果2个对象公用底层的数据，当某个对象被销毁时，我们不能单方面的消除底层数据
class StrBlob
{

public:
typedef std::vector<string>::size_type size_type;
StrBlob() :data(make_shared<vector<string>>()){};
StrBlob(std::initializer_list<string> il) : data(make_shared<vector<string>>(il)){}//参数数量不定的类
size_type size(){ return data->size(); }
void push_back(const string &s)
{
data->push_back(s);
}
void pop_back()
{
check(0, "123");
data->pop_back();
}
string& front();
string& back();
string& front() const;
string& back() const;
private:
shared_ptr<vector<string>> data;
void check(size_type i, const string &msg) const
{
if (i >= data->size())
throw out_of_range(msg);
}
};

string& StrBlob::front()
{
return data->front();
}
string& StrBlob::back()
{
return data->back();
}
string& StrBlob::front() const
{
return data->front();
}
string& StrBlob::back() const
{
return data->back();
}

直接管理内存 new和delete

除非使用智能指针，否则不要分配动态内存

Elemtype *p=new Elemtype(initdata);
auto p=new auto(obj);
const int *p2=new const int(10);

delete p;
delete p2;

new返回一个指向该对象的指针,如果分配失败，返回一个空指针

由内置指针管理的动态内存在被显示释放之前一直会存在

//12.6使用内置指针
#include<iostream>
#include<vector>
using namespace std;
vector<int>* f()
{
return   new vector < int > ;
}
vector<int>* input()
{
auto T = f();
int word;
while (cin >> word)
T->push_back(word);
return T;
}
void output(vector<int>* T)
{
auto begin = T->begin();
while (begin != T->end())
{
cout << *begin;
begin++;
}
delete T;
}
int main()
{
output(input());
return 0;
}

//12.7使用智能指针
#include<iostream>
#include<vector>
#include<memory>
using namespace std;
shared_ptr<vector<int>> f()
{
return make_shared < vector<int> >();
}
shared_ptr<vector<int>> input()
{
auto p = f();
int word;
while (cin >> word)
{
p->push_back(word);
}
return p;
}
void output(shared_ptr < vector<int>> T)
{
auto begin = T->begin();
while (begin != T->end())
{
cout << *begin;
begin++;
}
}
int main()
{
output(input());
return 0;
}

shared_ptr和new一起使用

shared_ptr<int> p(new int(4));//必须使用直接初始化

智能指针——unique_ptr

在某一时候只能有一个unique_ptr指向指定对象

且不能拷贝和赋值（除了拷贝或赋值给一个即将被销毁的unique_ptr)

unique_ptr<int> p(new int(2));//只能直接初始化

p.release();返回当前保存的指针并将其置空

p.reset();释放p指向的对象

unique_ptr需要delete来释放对象

智能指针——weak_ptr

指向一个由shared_ptr管理的对象，

weak_ptr<T> wp(sp);

//12.20

遇到了A类中需要用B类，B类中需要A类的问题

暂时没解决