C++ Primer 笔记-第12章 动态内存

// 数据不共享的情况：
vector<string> v1;    // 空 vector

{   // 新作用域
    vector<string> v2 = { "a", "an", "the" };
    v1 = v2;    // 从 v2 拷贝元素到 v1 中
}   // v2 被销毁，其中的元素也被销毁
    // v1 有三个元素，是原来 v2 中元素的拷贝


// 数据共享的情况：
// 假定我们希望定义一个名为 StrBlob 的类，保存一组元素
// 与容器不同，我们希望 StrBlob 对象的不同拷贝之间共享相同的元素
StrBlob b1;    // 空 StrBlob

{   // 新作用域
    StrBlob b2 = { "a", "an", "the" };
    b1 = b2;    // b2 和 b1 共享相同的元素
}   // b2 被销毁了，但是 b2 中的元素不能销毁
    // b1 指向最初的由 b2 创建的元素

// StrBlob.h
class StrBlob{
public:
    StrBlob();
    StrBlob(std::initializer_list<std::string> il);

private:
    std::shared_ptr<str::vector<string>> data;
}

// StrBlob.cpp
StrBlob::StrBlob() : data(make_shared<vector<string>>()) {}
StrBlob::StrBlob(initializer_list<string> il) :
                data(make_shared<vector<string>>(il)) {}

int* pi = new int;          // pi指向一个动态分配的、未初始化的无名对象

// 默认初始化
string* ps1 = new string;            // 默认初始化为空string
int* pi1 = new int;                  // 默认初始化，*pi1的值未定义

// 传统构造方式
int *pi2 = new int(1024);            // pi2指向的对象值为1024
string* ps2 = new string(10, '9');   // *ps2为“9999999999”
vector<int>* pv = new vector<int>{0, 1, 2, 3};  // vector有4个元素，值依次从0到3

// 值初始化
string* ps3 = new string();          // 值初始化为空string
int* pi3 = new int();                // 值初始化为0

const string* pcs = new const string;   // 隐式初始化
const int* pci = new const int(1024);   // 显示初始化

int* p1 = new int;              // 如果分配失败，会抛出 std::bad_alloc

// 向new传递一个标准库定义的nothrow对象
int* p2 = new (nothrow) int;    // 如果分配失败，返回一个空指针

int* p(new int(1024));  // p指向动态内存
auto q = p;             // p和q指向同一块内存
delete p;               // p和q均变为无效
p = nullptr;            // 此时p不再绑定到任何对象
// 此时重置p对q没有任何作用，q仍然指向原来那块（已经被释放的）内存地址
// 在实际系统中，查找指向相同内存的所有指针是异常困难的！

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

shared_ptr<int> clone(int p){
    return new int(p);                  // 错误
    return shared_ptr<int>(new int(p)); // 正确
}

// 如果p是唯一指向其对象的shared_ptr，reset会释放此对象。
p.reset();

// 若传递了可选的参数内置指针q，会令p指向q，否则会将p置为空。
p.reset(q);

//若还传递了参数d，将会调用d而不是delete来释放q
p.reset(q, d);

// ptr是传值方式传递，因此拷贝时会递增其引用次数。
void process(shared_ptr<int> ptr){
    // 使用ptr
}   // ptr离开作用域，ptr会被销毁。由于ptr销毁了，引用次数会递减

// process正确的使用方法：
shared_ptr<int> p(new int(42)); // 此时引用计数为1
process(p);     // 拷贝p会递增其引用次数，此时在process中引用计数值为2
int i = *p;     // 离开了process作用域，引用计数值为1 

// process错误的使用方法：
int *x(new int(1024));  // 危险：x是普通指针，不是智能指针
process(x);             // 错误：不能将int* 转换为shared_ptr<int>
process(shared_ptr<int>(x)); // 合法，但是由于传参时使用的是一个临时变量，
                             // 临时变量在传递完之后会被销毁，所以传完参
                             // 之后的process里的ptr引用计数为1
int j = *x; // 未定义：离开了process作用域，引用计数值为0，此时x为一个悬空指针

shared_ptr<int> p(new int(42)); // 引用计数为1
// 新程序块
{
    // 两个独立的shared_ptr指向相同的内存    
    shared_ptr<int> q(p.get());   // 错误：将get用来初始化指针指针
}   // 程序块结束，q被销毁，它指向的内存被释放

int foo = *p;   // 未定义：p指向的内存已经被释放了

class destination;
class connection;   // 假定connection没有析构函数

connection connect(destination* d) {}
void disconnect(connection c) {}

void f(destination& d)
{
    connection c = connect(&d);
    // ...
    // 如果我们在f退出前忘记调用disconnect，就无法关闭c了
}

// 使用智能指针管理对象的生命周期
// 定义删除器
void end_connection(connection* p) { disconnect(*p); }
void f(destination& d)
{
    connection c = connect(&d);
    shared_ptr<connection> p(&c, end_connection);
    // ...
    // 当f退出时（即便是由于异常而退出），connection会被正确关闭
}

unique_ptr<int> clone(int p) {
    return unique_ptr<int>(new int(p));
}

unique_ptr<int> clone(int p) {
    unique_ptr<int> ret(new int(p));
    return ret;
}

// 将之前的例子中的shared_ptr换成unique_ptr
void f(destination& d)
{
    connection c = connect(&d);
    
    // 使用decltype来指明函数指针类型
    // 必须加一个*来指出我们正在使用该类型的指针
    unique_ptr<connection, decltype(end_connection)*>
        p(&c, end_connection);
}

auto p = make_shared<int>(42);
weak_ptr<int> wp(p);    // wp弱共享p；p的引用计数未改变

// 如果np不为空则条件成立
if(shared_ptr<int> np = wp.lock()) {
    // 在if中，np与p共享对象
}

int* p1 = new int[42];  // p1指向第一个int

//也可以使用一个表达数组类型的类型别名来分配一个数组
typedef int arrT[42];   // arrT表示42个int的数组类型
int* p = new arrT;      // 分配一个42个int的数组，p指向第一个int

int* pia = new int[3];              // 3个未初始化的int
int* pia2 = new int[3]();           // 3个值初始化为0的int
int* pia3 = new int[3]{0, 1, 2};    // 跟列表相同的int
int* pia4 = new int[3]{0, 1, 2, 3}; // 列表数目超出，抛出bad_array_new_length异常

// 虽然可以用空括号对数组中元素的进行值初始化
// 但是不能在括号中给出初始化器
// 这意味着不能用auto分配数组
int obj = 1;
auto p = new auto[3](obj);

unique_ptr<int[]> up(new int[10]);

for(size_t i = 0; i != 10; ++i)
    up[i] = i;  // 可以使用下标运算符来访问数组中的元素。

up.release();   // 自动用delete[]销毁其指针

shared_ptr<int> sp(new int[10, [](int* p) { delete[] p; }]);

// shared_ptr 未定义下标运算符，并且不支持指针的算数运算
for(size_t i = 0; i != 10; ++i)
    *(sp.get() + i) = i;    // 必须用get获取内置指针才能访问元素

sp.reset(); // shared_ptr没有release()

vector<int> vi{0, 1, 2, 3};

// 分配一块比vector中元素所占用空间大一倍的动态内存，
allocator<string> alloc;
auto p = alloc.allocate(vi.size() * 2);

// 然后将原vector中的元素拷贝到前一半空间，
// copy有两种写法：
// q 指向最后一个构造的元素之后的位置。
auto q = uninitialized_copy(vi.begin(), vi.end(), p);
auto q = uninitialized_copy_n(vi.begin(), vi.size(), p);

// 对后一半的空间用一个给定值进行填充，
// fill也有两种写法：
uninitialized_fill(q, q + n, 42);
uninitialized_fill_n(q, vi.size(), 42);