CPlusPlus

  // 空智能指针，可以指向string类型的对象
  shared_ptr<string> p1;

  // q为shared_ptr，q的引用计算器会增加
  shared_ptr<T> p(q);
  // q为内置指针，q必须指向new分配的内存，且能够转换为T*类型
  shared_ptr<T> p(q);
  // u为unique_ptr，p从u接管了对象的所有权；将u置空
  shared_ptr<T> p(u);
  // p接管了内置指针q所指向的对象的所有权。q必须能转换为T*类型。p将使用可调用对象d来代替delete
  shared_ptr<T> p(q, d);
  // p是shared_ptr p2的copy,唯一的区别是p将用可调用对象d来代替delete
  shared_ptr<T> p(p2,d);

  shared_ptr<int> p3 = make_shared<int>(42);
  shared_ptr<string> p4 = make_shared<string>(10, '9');
  shared_ptr<int> p5 = make_shared<int>();

  // p 和 q都为shared_ptr。下面赋值操作，首先会递减p的引用计数，如果计数为0则释放p所管理的内存，然后，递增q的引用计数，最后，p指向q所指对象。
  p = q;

  // 若p.use_count()为1，则返回true；否则返回false
  p.unique();

  // 返回共享对象的智能指针的数量
  p.use_count();

  // 如果p是唯一指向其对象的shared_ptr, reset会释放该对象，并将p置空；否则，p引用计数减1，并将p置空
  p.reset();
  // 如果p是唯一指向其对象的shared_ptr, reset会释放该对象，并令p指向内置指针q，初始化引用计数为1；否则，p原始的引用计数减1，并令p指向内置指针q，初始化现在的引用计数为1
  p.reset(q);

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;
}

// 空unique_ptr,可以指向类型为T的对象。u1会使用delete释放它的指针
unique_ptr<T> u1;
// u2会使用类型为D的可调用对象来释放它的指针
unique_ptr<T, D> u2;
// 空unique_ptr,可以指向类型为T的对象。用类型为D的对象d代替delete
unique_ptr<T, D> u(d);
// 释放u指向的对象，将u置为空
u = nullptr;
// u放弃对指针的控制权，返回其管理的指针，并将u置为空 
// Tips: release不会释放u所指向对象的内存空间
u.release();
// 释放u指向的对象
u.reset();
u.reset(nullptr);

// q为内置指针。下面操作会释放u指向的对象，并令u管理指针q指向的内存
u.reset(q);

// 空weak_ptr可以指向类型为T的对象
weak_ptr<T> w; 
// sp为shared_ptr, 将w绑定到sp
weak_ptr<T> w(sp);
// 将w置空
w.reset();
// 与w共享对象的shared_ptr的数量
w.use_count();
// expired 译为 过期。 若w.use_count()为0，返回true，否则返回false
w.expired();
// 如果w.expired()为true，返回一个空shared_ptr；否则返回一个指向w的对象的shared_ptr
w.lock();

//
// === 创建动态数组 初始化动态数组 ===
//
// get_size确定分配多少个int； pia指向第一个int
// 分配一个数组会得到一个元素类型的指针
int *pia = new int[get_size()];

// 10个未初始化的int
int *pia = new int[10]; 
// 10个值初始化为0的int 
int *pia = new int[10]();  
// 10个空string
string *psa = new string[10];
// 10个空string
string *psa = new string[10]();

// 10个int，前4个用给定初始化器初始化，剩余的进行值初始化为0
int *pia = new int[10]{0,1,2,3}; 
// 10个string，前4个用给定初始化器初始化，剩余的进行值初始化为空string
string *psa = new string[10](){"a", "an", "the"};

// 动态分配一个空数组是合法的
// 下面代码是正确的，但是不能对cp进行解引用
char *cp = new char[0];

//
// === 释放动态数组
//
// pa必须指向一个动态分配的数组或空
delete [] pa;

//
// === 智能指针管理动态数组
//
unique_ptr<int[]> up(new int[10]);
// 返回up管理的指针，将up置空
// Tips: 不会释放up管理指针所指对象的内存
up.release();

unique_ptr<int[]> up1(new int[10]);
// 自动用delete []销毁其指针
up1.reset();

unique_ptr<int[]> up2(new int[10]);
// 返回u拥有的数组中位置i处的对象
up2[0];

// c++11 shared_ptr不支持数组
shared_ptr<int> sp(new int[10], [](int* p){ delete[] p; });
for(size_t i=0; i!=10; ++i)
{
    // c++11 shared_ptr不支持下标运算符，使用get获取一个内置指针
    *(sp.get()+i) = i;
}
// c++17 shared_ptr支持数组
shared_ptr<int[]> sp(new int[10]);
for(size_t i=0; i<10; i++)
{
    // c++17 shared_ptr支持下标运算符
    sp[i] = i;
}

// 可分配string的allocator对象
allocator<string> alloc;

// 分配n个未初始化的string
// allocator分配的内存是未构造的
auto const p = alloc.allocate(n);

// p必须为类型为string的指针，指向一块原始内存；args被传递给string的构造函数，用来在p指向的内存中构造一个string对象
// 为了使用allocate返回的内存，必须用construct构造对象。使用未构造的内存，其行为是未定义的
alloc.construct(p, args);

// p必须为类型为string的指针，该方法对p所指的对象执行析构函数
alloc.destroy(p);

// 释放从p指针开始的内存，这块内存保存了n个类型为string的对象
// p必须是一个之前由allocate返回的指针，n必须为创建时要求的大小
// 调用deallocate之前，用户必须对每个在这块内存中创建的对象调用destroy
alloc.deallocate(p, n);

// 从迭代器b和e指出的输入范围中copy原始到迭代器b2指定的未构造的原始内存中。b2指向的内存必须足够大，能容纳输入序列中元素的copy
uninitialized_copy(b, e, b2);
// 从迭代器b指向的元素开始，copy n个元素到b2开始的内存中。b2指向的内存必须足够大，能容纳输入序列中元素的copy
uninitialized_copy_n(b, n, b2);
// 从迭代器b和e指出的原始内存范围中创建对象，对象的值均为t的copy
uninitialized_fill(b, e, t);
// 从迭代器b指出的原始内存开始创建n个对象，对象的值均为t的copy。b指向的内存必须足够大，能容纳n元素
uninitialized_fill_n(b, e, t);

string dots(10, '.');                   // 直接初始化
string s(dots);                         // 直接初始化
string s2 = dots;                       // 拷贝初始化
string null_book = "9-999-99999-9";     // 拷贝初始化
string nines = string(100, '9');        // 拷贝初始化

string null_book = "9-999-99999-9";     // 拷贝初始化

// 编译器可以将上面代码改写为
string null_book("9-999-99999-9");      // 编译器略过了拷贝构造函数

class Foo
{
public:
    // 为了与内置类型的赋值保持一致，赋值运算符通常返回一个指向其左侧运算对象的引用
    // 标准库通常要求保存在容器中的类型要具有赋值运算符，且其返回值是左侧运算对象的引用
    Foo& operator=(const Foo&); // 赋值运算符
}

class Foo
{
public:
    Foo() = default;
    Foo(const Foo&) = default;
    Foo& operator=(const Foo&);
    ~Foo() = default;
}

// 合成的拷贝赋值操作符不是内联函数
Foo& Foo::operator=(const Foo&) = default;

class Foo
{
public:
    Foo() = default;
    Foo(const Foo&) = delete;
    Foo& operator=(const Foo&) = delete;
    ~Foo() = default;
}

class HasPtr
{
public:
    HasPtr(const std::string& s=std::string()):ps(new std::string(s)), i(0){}
    HasPtr(const HasPtr& p):ps(new std::string(*p.ps)), i(p.i){}
    HasPtr& operator=(const HasPtr& p);
    ~HasPtr(){ delete ps; }
private:
    std::string *ps;
    int i;
}
HasPtr& HasPtr::operator=(const HasPtr& rhs)
{
    // 拷贝底层string
    auto newp = new string(*rhs.ps);
    // 释放旧内存
    delete ps;
    // 从右侧运算对象拷贝数据到本对象
    ps = newp;
    // 返回本对象
    return *this;
}

class HasPtr
{
public:
    HasPtr(const std::string& s=std::string()):ps(new std::string(s)), i(0), use(new std::size_t(1)){}
    HasPtr(const HasPtr& p):ps(p.ps), i(p.i), use(p.use){ ++*use; }
    HasPtr& operator=(const HasPtr& p);
    ~HasPtr();
    // ......
private:
    std::string *ps;
    int i;
    std::size_t *use; // 用来记录有多少对象共享*ps成员
}
HasPtr::~HasPtr()
{
    if(--*use==0)
    {
        delete ps;
        delete use;
    }
}
HasPtr& HasPtr::operator=(const HasPtr& rhs)
{
    ++*rhs.use;      // 递增右侧运算对象的引用计数
    if(--*use==0)    // 递减本对象的引用计数，如果没其他用户引用，则释放对象分配的成员
    {
        delete ps;
        delete use;
    }
    ps = rhs.ps;     // 将数据从rhs拷贝到本对象
    use = rhs.use;
    return *this;
}

class StrVec
{
public:
    StrVec(): // the allocator member is default initialized
        elements(nullptr), first_free(nullptr), cap(nullptr) { }
    StrVec(const StrVec&); // copy constructor
    StrVec &operator=(const StrVec&); // copy assignment
    ~StrVec(); // destructor
    void push_back(const std::string&); // copy the element
    size_t size() const { return first_free - elements; }
    size_t capacity() const { return cap - elements; }
    std::string *begin() const { return elements; }
    std::string *end() const { return first_free; }
    // ...
private:
    std::allocator<std::string> alloc; // allocates the elements
    // used by the functions that add elements to the StrVec
    void chk_n_alloc() { if (size() == capacity()) reallocate(); }
    // utilities used by the copy constructor, assignment operator, and destructor
    std::pair<std::string*, std::string*> alloc_n_copy (const std::string*, const std::string*);
    void free(); // destroy the elements and free the space
    void reallocate(); // get more space and copy the existing elements

    std::string *elements; // pointer to the first element in the array
    std::string *first_free; // pointer to the first free element in the array
    std::string *cap; // pointer to one past the end of the array
};

void StrVec::push_back(const string& s)
{
    chk_n_alloc(); // ensure that there is room for another element
    // construct a copy of s in the element to which first_free points
    alloc.construct(first_free++, s);
}

pair<string*, string*>StrVec::alloc_n_copy(const string *b, const string *e)
{
    // allocate space to hold as many elements as are in the range
    auto data = alloc.allocate(e - b);
    // initialize and return a pair constructed from data and
    // the value returned by uninitialized_copy
    // uninitialized_copy 是标准库函数，被定义在memory头文件中
    return {data, uninitialized_copy(b, e, data)};
}

void StrVec::free()
{
    // may not pass deallocate a 0 pointer; if elements is 0, there's no work to do
    if (elements) {
        // destroy the old elements in reverse order
        for (auto p = first_free; p != elements; /* empty */)
            alloc.destroy(--p);
        alloc.deallocate(elements, cap - elements);
    }
}

StrVec::StrVec(const StrVec &s)
{
    // call alloc_n_copy to allocate exactly as many elements as in s
    auto newdata = alloc_n_copy(s.begin(), s.end());
    elements = newdata.first;
    first_free = cap = newdata.second;
}

StrVec::~StrVec() { free(); }

StrVec &StrVec::operator=(const StrVec &rhs)
{
    // call alloc_n_copy to allocate exactly as many elements as in rhs
    auto data = alloc_n_copy(rhs.begin(), rhs.end());
    free();
    elements = data.first;
    first_free = cap = data.second;
    return *this;
}

void StrVec::reallocate()
{
    // we'll allocate space for twice as many elements as the current size
    auto newcapacity = size() ? 2 * size() : 1;
    // allocate new memory
    auto newdata = alloc.allocate(newcapacity);
    // move the data from the old memory to the new
    auto dest = newdata; // points to the next free position in the new array
    auto elem = elements; // points to the next element in the old array
    for (size_t i = 0; i != size(); ++i)
    {
        alloc.construct(dest++, std::move(*elem++));
    }
    free(); // free the old space once we've moved the elements
    // update our data structure to point to the new elements
    elements = newdata;
    first_free = dest;
    cap = elements + newcapacity;
}

int i = 42;
int &r = i;             // 正确：r引用i
int && rr = i;          // 错误：不能将一个右值引用绑定到一个左值上
int &r2 = i*42;         // 错误：i*42是一个右值
const int &r3 = i*42;   // 正确：可以将一个const的引用绑定到一个右值上
int &&rr2 = i*42;       // 正确：将rr2绑定到乘法结果上

int &&rr1 = 42;         // 正确：字面常量是右值
int &&rr2 = rr1;        // 错误：表达式rr1是左值！  解释：rr1是右值引用类型的变量，而变量是左值，不能将右值引用绑定到左值上

// 为了避免潜在的名字冲突，此处使用std::move而不是move
int && rr3 = std::move(rr1);

StrVec::StrVec(StrVec&& s) noexcept
: elements(s.elements), first_free(s.first_free), cap(s.cap)
{
    // 令s进入这样的状态——对其运行析构函数是安全的
    s.elements = s.first_free = s.cap = nullptr;
}

StrVec& StrVec::operator=(StrVec && rhs) noexcept
{
    // 直接检测自赋值
    if(this!=&rhs)
    {
        free();
        elements = rhs.elements;
        first_free = rhs.first_free;
        cap = rhs.cap;
        rhs.elements = rhs.first_free = rhs.cap = nullptr;
    }
    return *this;
}

class HasPtr{
public:
    HasPtr(HasPtr&& p) noexcept : ps(p.ps) {p.ps = 0;}
    // 赋值运算符既是移动赋值运算符，也是拷贝赋值运算符
    HasPtr& operator=(HasPtr rhs)
    {
        swap(*this, rhs);
        return *this;
    }
}

// 上面的赋值运算符有一个非引用参数，因此参数要进行拷贝初始化。依赖于实参的类型，拷贝初始化要么使用拷贝构造函数，要么使用移动构造函数（左值被拷贝，右值被移动）
hp = hp2;              // hp2是一个左值； hp2通过拷贝构造函数来拷贝
hp = std::move(hp2);   // std::move将一个右值引用绑定到hp2上，因此实参是一个右值引用，所以移动构造函数是精确匹配的。

  void StrVec::reallocate()
  {
      auto newcapacity = size() ? 2 * size() : 1;
      auto first = alloc.allocate(newcapacity);
      auto last = uninitialized_copy(
                                     make_move_iterator(begin()),
                                     make_move_iterator(end()),
                                     first
                                     );

      free();
      elements = first;
      first_free = last;
      cap = elements + newcapacity;
  }

class StrVec{
public:
    void push_back(const std::string&);  // 拷贝元素
    void push_back(std::string&&);       // 移动元素
};

class Foo{
public:
    Foo &operator=(const Foo&) &;    // 只能向可修改的左值赋值
};

class Foo{
public:
    Foo someMembFunc() & const;        // 错误
    Foo anotherMembFunc() const &;     // 正确
};

template<typename T>
int compare(const T& v1, const T& v2)
{
    if(v1 > v2) return 1;
    else if(v1 < v2) return -1;
    else return 0;
}

// 函数实参类型为int --> 函数形参类型为const int& --> 模板实参为int --> 模板参数为 int
// 编译器使用推断出的模板参数实例化一个特定版本的函数 int compare(const int& v1, const int& v2);
cout << compare(1, 0) << endl;

extern template class Blob<string>; // 实例化声明
template Blob<string>;              // 实例化定义

void f1(const int arg)
{
    std::cout << arg;
}
void f2(int arg)
{
    std::cout << arg;
}
void f3(const int& arg)
{
    std::cout << arg;
}
void f4(const int* arg)
{
    std::cout << *arg;
}
int i=10;
const int j=10;
const int& k = 10;
f1(i);    // 形参中的顶层const 被忽略。值传递，可以使用int i初始化 const int 类型的形参 arg
f2(j);    // 实参中的顶层const被忽略。值传递，可以使用const int j 初始化 int 类型的形参 arg
f2(k);    // 实参中的顶层const被忽略。值传递，可以使用const int& k 初始化 int 类型的形参 arg
f3(i);    // 形参中的顶层const被忽略。引用传递，可以使用int j 初始化 const int& 类型的形参 arg

template<typename T>
ostream& print(ostream& os, const T& t)
{
    return os << t;
}
template<typename T, typename... Args>  // 模板参数包
ostream& print(ostream& os, const T& t, const Args&... rest)  // 函数参数包
{
    os << t << ", ";
    // 可变参数版本的print函数接受三个参数：一个ostream&,一个const T&和一个参数包
    // 此处调用只传递了两个实参，因此rest中的第一个实参被绑定到t，剩余实参形成下一个print调用的参数包
    return print(os, rest...);
}

print(cout, 1, "hi", 42); // 包中有两个参数
// 上面的函数会按下面方式递归执行：
//                                  t       rest...       output
// print(cout, i, "hi", 42)         1       "hi", 42      1
// print(cout, "hi", 42)            "hi"    42            hi
// print(cout, 42)                                        42          // 调用非可变参数版本的print

template<typename T, typename... Args>
// 下面函数形参数部分(const Args&... rest) ，展开了模板参数包Args，为print生成函数参数列表
// 模式是const Args&，编译器将模式应用到模板参数包Args中的每个元素，得到一个逗号分割的零个或多个类型的列表，每个类型都形如const type&
// 例如：print(cout, 1, "hi", 42); 被实例化为 ostream& print(ostream&, const int&, const char[3]&, const int&)
ostream& print(ostream& os, const T& t, const Args&... rest) 
{
    os << t << ", ";
    // 下面函数实参部分(rest...)，展开了函数参数包rest，为print调用生成实参列表
    // 模式是函数参数包的名字(rest)，此模式展出一个由包中元素组成的，逗号分割的列表。
    return print(os, rest...);  // 展开
}

template<typename... Args>
ostream& errorMsg(ostream& os, const Args&... rest)
{
    // 模式是debug_rep(rest)，此模式表示对函数参数包rest中的每个元素调用debug_rep。展开结果将是一个逗号分割的debug_rep调用列表
    // 例如： errorMsg(cerr, fncName, code.num(), otherData, "other", item); 被编译器变为
    // errorMsg(cerr, debug_rep(fncName), debug_rep(code.num()), debug_rep(otherData), debug_rep("other"), debug_rep(item));
    return print(os, debug_rep(rest)...);
}

template<class... Args>
inline void StrVec::emplace_back(Args&&... args) //将Args扩展为一个右值引用的列表
{
    chk_n_alloc();
    // 下面调用的展开为 std::forward<Args>(args)...，其既展开了模板参数包Args，也展开了函数参数包args.
    // 此模式生成如下形式的元素 std::forward<Ti>(ti) Ti表示模板参数包中第i个元素的类型，ti表示函数参数包中第i个元素
    alloc.construct(first_free++, std::forward<Args>(args)...);
}

// new 表达式的工作机制
// 第一步 new表达式调用一个名为operator new或operator new[] 的标准库函数。该函数分配一块足够大的、原始的、未命名的内存空间以便存储特定类型的对象（或者对象的数组）
// 第二步 编译器运行相应的构造函数以构造这些对象，并为其传入初始值
// 第三步 对象被分配了空间并构造完成，返回一个指向该对象的指针
string *sp = new string("a value");
string *arr = new string[10];

// delete表达式的工作机制
// 第一步 对sp所指的对象或者arr所指的数组中的元素执行对应的析构函数
// 第二步 编译器调用名为operator delete 或 operator delete[] 的标准库函数释放内存空间。
delete sp;
delete[] arr;

// 标准库中默认的operator new 和 operator delete函数
void* operator new(size_t);
void* operator new[](size_t);
void  operator delete(void*) noexcept;
void  operator delete[](void*) noexcept;

void* operator new(size_t, nothrow_t&) noexcept;
void* operator new[](size_t, nothrow_t&) noexcept;
void  operator delete(void*, nothrow_t&) noexcept;
void  operator delete[](void*, nothrow_t&) noexcept;

// 下面为operator new 和 operator delete的简单实现方式
void *operator new(size_t size)
{
    if(void* mem = malloc(size))
    {
        return mem;
    }
    else
    {
        throw bad_alloc();
    }
}

void operator delete(void *mem) noexcept
{
    free(mem);
}

#include <iostream>
#include <typeinfo>
using namespace std;
void f()
{
    const auto& t_info = typeid(t);
    cout << t_info.name() << endl;
}

class Base
{
    friend bool opertator=(const Base& lhs, const Base& rhs)
    { return typeid(lhs)==typeid(rhs) && lhs.equal(rhs); }
public:
    // Base的接口成员
protected:
    //
    virtual bool equal(const Base&) const
    {
        // 执行比较两个Base对象的操作并返回结果
    }
}

class Derived: public Base
{
public:
    // Derived的其他接口成员
protected:
    bool equal(const Base&) const
    {
        auto r = dynamic_cast<const Derived&>(rhs);
        // 执行比较两个Derived对象的操作并返回结果
    }
}

t1 == t2         // t1和t2表示同一种类型，返回true
t1 != t2         // 
t.name()         // 返回一个C分格字符串，表示类型名称
t1.before(t2)    // 返回一个bool值，表示t1是否位于t2之前。before所采用的顺序关系是依赖于编译器的