C++提升

#include <iostream>
class Test
{
public:
    Test(int a = 5, int b = 5) :ma(a), mb(b)
    {
        std::cout << "Test(int,int)" << std::endl;
    }
    ~Test()
    {
        std::cout << "~Test()" << std::endl;
    }
    Test(const Test& t) :ma(t.ma),mb(t.mb) { std::cout << "Test(const Test&)" << std::endl; }
    void operator=(const Test& t)
    {
        std::cout << " operator=" << std::endl;
        ma = t.ma;
        mb = t.mb;
    }
private:
    int ma;
    int mb;
};
Test t1(10, 10);//1.Test(int,int)
int main()
{
    Test t2(20, 20);//3.Test(int,int)
    Test t3 = t2;//4.Test(const Test&)
    static Test t4 = Test(30, 30);//5.Test(int,int)
    t2 = Test(40, 40);//6.Test(int,int) operator= ~Test()
    //逗号表达式 (50,50)=50
    t2 = (Test)(50, 50);//=>Test(50) 7.Test(int,int) operator= ~Test()
    t2 = 60;//8.Test(int,int) operator= ~Test()
    Test* p1 = new Test(70, 70);//9.Test(int,int)
    Test* p2 = new Test[2];//10.Test(int,int) Test(int,int)
    //Test* p3 = &Test(80,80);
    const Test& p4 = Test(90, 90);//11 Test(int,int) 生命周期延长
    delete p1;//12.~Test()
    delete[] p2;//13 ~Test() ~Test()
    return 0;
}
Test t5(100, 100);//2.Test(int,int)
#if 0
class Test
{
public:
    Test(int a = 10) :ma(a)
    {
        std::cout << "Test()" << std::endl;
    }
    ~Test()
    {
        std::cout << "~Test()" << std::endl;
    }
    Test(const Test& t) :ma(t.ma) { std::cout << "Test(const Test&)" << std::endl; }
    Test& operator=(const Test& t)
    {
        std::cout << " operator=" << std::endl;
        ma = t.ma;
        return *this;
    }
private:
    int ma;

};

int main()
{
    Test t1;
    Test t2(t1);
    Test t3 = t1;
    //Test(20) 显式生成临时对象 生存周期：所在的语句
    /*
    C++编译器对于对象构造的优化：用临时对象生成新对象的时候，临时对象就不产生了，直接构造新对象就可以了
    */
    Test t4 = Test(20);//Test t4(20);没有区别

    std::cout << "-----------------------" << std::endl;
    t4 = t2;
    //t4.operator=(const Test &t)
    //显式生成临时对象
    t4 = Test(30);
    t4 = (Test)30;//int ->Test(int) 显式转换，但是得有Test(int)这种类型的构造函数才可以转
    //隐式生成临时对象
    t4 = 30;//int ->Test(int) 隐式转换，但是得有Test(int)这种类型的构造函数才可以转
    std::cout << "-----------------------" << std::endl;
    //const Test* p = &Test(40);
    //语句结束，p指向的是一个已经析构的临时对象,所以指针指向临时对象是不安全的
    const Test& ref = Test(50);
    //按道理说，这句结束，Test要析构了，但是这个临时对象有名字了，所以延长了生命周期
    std::cout << "-----------------------" << std::endl;
    return 0;
}
#endif

对象的构造函数，拷贝构造，析构函数调用过程
临时对象

#include <iostream>

class Test
{
public:
    Test(int data = 10):ma(data)
    {
        std::cout << "Test(int)" << std::endl;
    }
    ~Test()
    {
        std::cout << "~Test()" << std::endl;
    }
    Test(const Test& t) :ma(t.ma)
    {
        std::cout << "Test(const Test&)" << std::endl;
    }
    void operator=(const Test& t)
    {
        std::cout << "operator=" << std::endl;
        ma = t.ma;
    }
    int getData()const
    {
        return ma;
    }
private:
    int ma;
};
//不能返回局部的或者临时对象的指针或者引用
Test GetObject(Test t)
{
    int val = t.getData();
    Test tmp(val);
    return tmp;
}
int main()
{
    Test t1;
    Test t2;
    t2 = GetObject(t1);
    return 0;
}

Test(int)
Test(int)
Test(const Test&)
Test(int)
~Test()
operator=
~Test()
~Test()
~Test()
这里看出函数调用背后方法有点多，要优化

#include <iostream>

class Test
{
public:
    Test(int data = 10) :ma(data)
    {
        std::cout << "Test(int)" << std::endl;
    }
    ~Test()
    {
        std::cout << "~Test()" << std::endl;
    }
    Test(const Test& t) :ma(t.ma)
    {
        std::cout << "Test(const Test&)" << std::endl;
    }
    void operator=(const Test& t)
    {
        std::cout << "operator=" << std::endl;
        ma = t.ma;
    }
    int getData()const
    {
        return ma;
    }
private:
    int ma;
};
//不能返回局部的或者临时对象的指针或者引用

/*
1.函数参数传递过程中，对象优先按引用传递，不要按值传递
2.函数返回对象的时候，应该优先返回一个临时对象，而不要返回一个定义过的对象
3.接收返回值是对象的函数调用的时候，优先按初始化的方式接收，不要按赋值的方式接收。
*/
Test GetObject(Test &t)
{
    int val = t.getData();
    /*Test tmp(val);
    return tmp;*/
    //返回临时对象
    return Test(val);
}
int main()
{
    Test t1;
    Test t2 = GetObject(t1);
    //t2 = GetObject(t1);
    return 0;
}

Test(int)
Test(int)
~Test()
~Test()

#include <iostream>

class String
{
public:
    String(const char* str = nullptr)//普通构造函数
    {
        if (str != nullptr)
        {
            //strlen计算字符串长度时，是不计入'\0'的
            m_data = new char[strlen(str) + 1];
            strcpy(this->m_data, str);
        }
        else
        {
            //这里不能直接把m_data赋值为nullptr，如果这里赋值
            //后面的构造函数都要判断地址为空的条件。
            m_data = new char[1];
            *m_data = '\0';
        }
        std::cout << "String(const char *)" << std::endl;

    }
    String(const String& other)//拷贝构造函数
    {
        m_data = new char[strlen(other.m_data) + 1];
        strcpy(m_data, other.m_data);
        std::cout << "String(const String&)" << std::endl;
    }
    ~String(void)//析构函数
    {
        delete[]m_data;
        m_data = nullptr;
        std::cout << "~String()" << std::endl;
    }
    String& operator = (const String& other)//赋值重载函数
    {
        std::cout << "String& operator=(const String&)" << std::endl;
        //防止自赋值
        if (this == &other)
        {
            return *this;
        }
        delete[]m_data;
        m_data = new char[strlen(other.m_data) + 1];
        strcpy(m_data, other.m_data);
        return *this;
    }
    const char* c_str()const
    {
        return m_data;
    }
private:
    char* m_data;//用于保存字符串
    friend String operator+(const String& lhs, const String& rhs);
};
String GetString(String& str)
{
    const char* pstr = str.c_str();
    String tmp(pstr);
    return tmp;
}
int main()
{
    String str1("aaaaaaaaaaaaaa");
    String str2;
    str2 = GetString(str1);
    std::cout << str2.c_str() << std::endl;
    /*
    C++17之前
    String(const char *)
    String(const char *)
    String(const char *)
    String(const String&) =>tmp拷贝构造main函数栈帧上的临时对象
    ~String()
    String& operator=(const String&)=》main函数栈帧上的临时对象给str2赋值
    ~String()
    aaaaaaaaaaaaaa
    ~String()
    ~String()
    */
    return 0;
}

str2 = GetString(str1);
这里需要解决的是当返回值是String,如何优化其中的临时对象，老是创建对象，如果还有申请别的空间，是很耗费效率的。所以我们应该利用临时对象，节省资源。下一节，使用右值引用解决问题
String(const char *)
String(const String&) =>tmp拷贝构造main函数栈帧上的临时对象
~String()
String& operator=(const String&)=》main函数栈帧上的临时对象给str2赋值
~String()
所以在C++17之后进行了强制优化，叫做
    RVO(返回值优化)：在函数返回一个临时对象时，编译器可以直接在调用者的栈帧上构造这个返回值，而不在函数内部再创建一个临时对象。
所以这是在C++17之后的效果：所以是直接在main函数上栈帧完成构造，所以就没有拷贝函数出现
String(const char *)
String(const char *)
String(const char *)
String& operator=(const String&)
~String()
aaaaaaaaaaaaaa
~String()
~String()
这里还是会构造一个临时对象，因为str2存在，所以在main函数上构造了，所以会产生一个临时对象
如果
String str2 = GetString(str1);
结果就大不一样了，这句会直接在str2上构造
String(const char *)
String(const char *)
aaaaaaaaaaaaaa
~String()
~String()
这样就不会有临时对象了。

#include <iostream>

class String
{
public:
    String(const char* str = nullptr)//普通构造函数
    {
        if (str != nullptr)
        {
            //strlen计算字符串长度时，是不计入'\0'的
            m_data = new char[strlen(str) + 1];
            strcpy(this->m_data, str);
        }
        else
        {
            //这里不能直接把m_data赋值为nullptr，如果这里赋值
            //后面的构造函数都要判断地址为空的条件。
            m_data = new char[1];
            *m_data = '\0';
        }
        std::cout << "String(const char *)" << std::endl;

    }
    //带左值引用参数的拷贝构造
    String(const String& other)//拷贝构造函数
    {
        m_data = new char[strlen(other.m_data) + 1];
        strcpy(m_data, other.m_data);
        std::cout << "String(const String&)" << std::endl;
    }
    //带右值引用参数的拷贝构造
    String(String&& other)//拷贝构造函数
    {
        std::cout << "String(String&&)" << std::endl;
        m_data = other.m_data;
        other.m_data = nullptr;
    }
    ~String(void)//析构函数
    {
        delete[]m_data;
        m_data = nullptr;
        std::cout << "~String()" << std::endl;
    }
    //带左值引用参数的赋值重载函数
    String& operator = (const String& other)//赋值重载函数
    {
        std::cout << "String& operator=(const String&)" << std::endl;
        //防止自赋值
        if (this == &other)
        {
            return *this;
        }
        delete[]m_data;
        m_data = new char[strlen(other.m_data) + 1];
        strcpy(m_data, other.m_data);
        return *this;
    }
    //带右值引用参数的赋值重载函数
    String& operator = (String&& other)//赋值重载函数
    {
        std::cout << "String& operator=(String&&)" << std::endl;
        //防止自赋值
        if (this == &other)
        {
            return *this;
        }
        delete[]m_data;
        m_data = other.m_data;
        other.m_data = nullptr;
        return *this;
    }
    const char* c_str()const
    {
        return m_data;
    }
private:
    char* m_data;//用于保存字符串
    friend String operator+(const String& lhs, const String& rhs);
};
String GetString(String& str)
{
    const char* pstr = str.c_str();
    String tmp(pstr);
    return tmp;
}
#if 0
int main()
{
    //右值引用
    int a = 10;
    int& b = a;//左值：有内存，有名字 右值：没名字(临时量)、没内存
    //int&& c = a;//无法将左值绑定到右值引用上
    //int& c = 20;//不能用左值引用绑定一个右值
    const int& c = 20;
    int&& d= 20;//可以把一个右值绑定到一个右值引用上
    /*
    const int& c = 20;
    int&& d= 20;
    这两的区别一个可以修改，一个不可以，c不可以，d可以
    */
    String&& e = String("aaa");//=》这是个临时量，所以是个右值

    int& f = d;//一个右值引用变量，本身是一个左值
    return 0;
}
#endif
int main()
{
    String str1("aaaaaaaaaaaaaa");
    String str2;
    str2 = GetString(str1);
    std::cout << str2.c_str() << std::endl;
    return 0;
    /*
    C++17以前
    String(const char *)
    String(const char *)
    String(const char *)
    String(String&&)
    ~String()
    String& operator=(String&&)
    ~String()
    aaaaaaaaaaaaaa
    ~String()
    ~String()
    */
}

我们使用带有右值引用的拷贝构造和赋值重载函数，解决临时对象的使用问题
str2 = GetString(str1);
如果没有重载带右值引用的函数，编译器会使用带左值引用的函数。
//带右值引用参数的拷贝构造
    String(String&& other)//拷贝构造函数
    {
        std::cout << "String(String&&)" << std::endl;
        m_data = other.m_data;
        other.m_data = nullptr;
    }
//带右值引用参数的赋值重载函数
    String& operator = (String&& other)//赋值重载函数
    {
        std::cout << "String& operator=(String&&)" << std::endl;
        //防止自赋值
        if (this == &other)
        {
            return *this;
        }
        delete[]m_data;
        m_data = other.m_data;
        other.m_data = nullptr;
        return *this;
    }
这里重载就是为了把临时对象的资源弄到手，不用先申请赋值后再释放后，太浪费资源。
但是这里使用后，并没有调用带右值引用参数的拷贝构造
String(const char *)
String(const char *)
String(const char *)
String& operator=(String&&)
~String()
aaaaaaaaaaaaaa
~String()
~String()
C++17之后引入RVO(返回值优化),所以没有拷贝调用出现

#include <iostream>
#include <vector>
class String
{
public:
    String(const char* str = nullptr)//普通构造函数
    {
        if (str != nullptr)
        {
            //strlen计算字符串长度时，是不计入'\0'的
            m_data = new char[strlen(str) + 1];
            strcpy(this->m_data, str);
        }
        else
        {
            //这里不能直接把m_data赋值为nullptr，如果这里赋值
            //后面的构造函数都要判断地址为空的条件。
            m_data = new char[1];
            *m_data = '\0';
        }
        std::cout << "String(const char *)" << std::endl;

    }
    //带左值引用参数的拷贝构造
    String(const String& other)//拷贝构造函数
    {
        m_data = new char[strlen(other.m_data) + 1];
        strcpy(m_data, other.m_data);
        std::cout << "String(const String&)" << std::endl;
    }
    //带右值引用参数的拷贝构造
    String(String&& other)//拷贝构造函数
    {
        std::cout << "String(String&&)" << std::endl;
        m_data = other.m_data;
        other.m_data = nullptr;
    }
    ~String(void)//析构函数
    {
        delete[]m_data;
        m_data = nullptr;
        std::cout << "~String()" << std::endl;
    }
    //带左值引用参数的赋值重载函数
    String& operator = (const String& other)//赋值重载函数
    {
        std::cout << "String& operator=(const String&)" << std::endl;
        //防止自赋值
        if (this == &other)
        {
            return *this;
        }
        delete[]m_data;
        m_data = new char[strlen(other.m_data) + 1];
        strcpy(m_data, other.m_data);
        return *this;
    }
    //带右值引用参数的赋值重载函数
    String& operator = (String&& other)//赋值重载函数
    {
        std::cout << "String& operator=(String&&)" << std::endl;
        //防止自赋值
        if (this == &other)
        {
            return *this;
        }
        delete[]m_data;
        m_data = other.m_data;
        other.m_data = nullptr;
        return *this;
    }
    const char* c_str()const
    {
        return m_data;
    }
private:
    char* m_data;//用于保存字符串
    friend String operator+(const String& lhs, const String& rhs);
    friend std::ostream& operator<<(std::ostream& out, const String& str);
};
String GetString(String& str)
{
    const char* pstr = str.c_str();
    String tmp(pstr);
    return tmp;
}
String operator+(const String& lhs, const String& rhs)
{
    /*char* ptmp = new char[strlen(lhs.m_data) + strlen(rhs.m_data) + 1];
    //这里需要释放，所以不能直接返回
    strcpy(ptmp, lhs.m_data);
    strcat(ptmp, rhs.m_data);
    String tmpstr(ptmp);
    delete[]ptmp;
    //return String(ptmp);
    return tmpstr;
    */
    //虽然上面这么写，已经很行了，但是还要优化
    String tmpStr;
    tmpStr.m_data= new char[strlen(lhs.m_data) + strlen(rhs.m_data) + 1];
    strcpy(tmpStr.m_data, lhs.m_data);
    strcat(tmpStr.m_data, rhs.m_data);
    return tmpStr;
}
std::ostream& operator<<(std::ostream& out, const String& str)
{
    out << str.m_data;
    return out;
}
int main()
{
    /*
    String str1 = "hello";
    String str2 = "world";
    std::cout << "-------------------------------------------------"<<std::endl;
    String str3 = str1 + str2;
    std::cout << "-------------------------------------------------" << std::endl;
    std::cout << str3 << std::endl;
    return 0;
    */
    /*
    String(const char *)
    String(const char *)
    -------------------------------------------------
    String(const char *)
    -------------------------------------------------
    helloworld
    ~String()
    ~String()
    ~String()
    */
    

    String str1 = "aaa";
    std::vector<String> vec;
    vec.reserve(10);
    std::cout << "-------------------------------------------------" << std::endl;
    vec.push_back(str1);
    vec.push_back(String("bbb"));
    std::cout << "-------------------------------------------------" << std::endl;
    /*
    String(const char *)
    -------------------------------------------------
    String(const String&)
    String(const char *)
    String(String&&)
    ~String()
    -------------------------------------------------
    ~String()
    ~String()
    ~String()
    */
}

#include <iostream>
class String
{
public:
    String(const char* str = nullptr)//普通构造函数
    {
        if (str != nullptr)
        {
            //strlen计算字符串长度时，是不计入'\0'的
            m_data = new char[strlen(str) + 1];
            strcpy(this->m_data, str);
        }
        else
        {
            //这里不能直接把m_data赋值为nullptr，如果这里赋值
            //后面的构造函数都要判断地址为空的条件。
            m_data = new char[1];
            *m_data = '\0';
        }
        std::cout << "String(const char *)" << std::endl;

    }
    //带左值引用参数的拷贝构造
    String(const String& other)//拷贝构造函数
    {
        m_data = new char[strlen(other.m_data) + 1];
        strcpy(m_data, other.m_data);
        std::cout << "String(const String&)" << std::endl;
    }
    //带右值引用参数的拷贝构造
    String(String&& other)//拷贝构造函数
    {
        std::cout << "String(String&&)" << std::endl;
        m_data = other.m_data;
        other.m_data = nullptr;
    }
    ~String(void)//析构函数
    {
        delete[]m_data;
        m_data = nullptr;
        std::cout << "~String()" << std::endl;
    }
    //带左值引用参数的赋值重载函数
    String& operator = (const String& other)//赋值重载函数
    {
        std::cout << "String& operator=(const String&)" << std::endl;
        //防止自赋值
        if (this == &other)
        {
            return *this;
        }
        delete[]m_data;
        m_data = new char[strlen(other.m_data) + 1];
        strcpy(m_data, other.m_data);
        return *this;
    }
    //带右值引用参数的赋值重载函数
    String& operator = (String&& other)//赋值重载函数
    {
        std::cout << "String& operator=(String&&)" << std::endl;
        //防止自赋值
        if (this == &other)
        {
            return *this;
        }
        delete[]m_data;
        m_data = other.m_data;
        other.m_data = nullptr;
        return *this;
    }
    const char* c_str()const
    {
        return m_data;
    }
private:
    char* m_data;//用于保存字符串
    friend String operator+(const String& lhs, const String& rhs);
    friend std::ostream& operator<<(std::ostream& out, const String& str);
};
String GetString(String& str)
{
    const char* pstr = str.c_str();
    String tmp(pstr);
    return tmp;
}
String operator+(const String& lhs, const String& rhs)
{
    /*char* ptmp = new char[strlen(lhs.m_data) + strlen(rhs.m_data) + 1];
    //这里需要释放，所以不能直接返回
    strcpy(ptmp, lhs.m_data);
    strcat(ptmp, rhs.m_data);
    String tmpstr(ptmp);
    delete[]ptmp;
    //return String(ptmp);
    return tmpstr;
    */
    //虽然上面这么写，已经很行了，但是还要优化
    String tmpStr;
    tmpStr.m_data = new char[strlen(lhs.m_data) + strlen(rhs.m_data) + 1];
    strcpy(tmpStr.m_data, lhs.m_data);
    strcat(tmpStr.m_data, rhs.m_data);
    return tmpStr;
}
std::ostream& operator<<(std::ostream& out, const String& str)
{
    out << str.m_data;
    return out;
}
template<typename T>
struct Allocator
{
    T* allocate(size_t size)//负责内存开辟
    {
        return (T*)malloc(sizeof(T) * size);
    }
    void deallocate(void* p)//负责内存释放
    {
        free(p);
    }
    /*
    void construct(T* p, const T& val)//负责对象构造
    {
        new (p) T(val);//定位new:在指定地址去构造值为val的对象
    }
    void construct(T* p, T&& val)//负责对象构造
    {
        new (p) T(std::move(val));//定位new:在指定地址去构造值为val的对象
    }
    */
    template<typename Ty>
    void construct(T* p, Ty&& val)//负责对象构造
    {
        new (p) T(std::forward<Ty>(val));//定位new:在指定地址去构造值为val的对象
    }
    void destroy(T* p)//负责对象析构
    {
        p->~T(); //~T()代表T类型的析构函数
    }
};
/*
容器底层内存开辟，内存释放，对象构造和析构，都通过allocator空间配置器来实现
*/
template<typename T, typename Alloc = Allocator<T>>
class vector
{
public:
    vector(int size = 10)
    {
        //需要把内存开辟和对象构造分开处理，不然我使用vector<Test> vec;
        //自动创建10个Test对象
        //_first = new T[size];
        _first = _allocator.allocate(size);
        _last = _first;
        _end = _first + size;
    }
    ~vector()
    {
        //析构容器有效的元素，然后释放_first指针指向的堆内存
        //delete[]_first;
        for (T* p = _first;p != _last;p++)
        {
            _allocator.destroy(p);//把_first指针指向的数组的有效元素进行析构操作
        }
        _allocator.deallocate(_first);//释放堆上的数组内存
        _first = _last = _end = nullptr;
    }
    vector(const vector<T>& rhs)
    {
        int size = rhs._end - rhs._first;
        //_first = new T[size];
        _first = _allocator.allocate(size);
        int len = rhs._last - rhs._first;
        for (int i = 0;i < len;i++)
        {
            //_first[i] = rhs._first[i];
            _allocator.construct(_first + i.rhs._first[i]);
        }
        _last = _first + len;
        _end = _first + size;
    }
    vector<T>& operator=(const vector<T>& rhs)
    {
        if (this == &rhs)
        {
            return *this;
        }
        //delete[]_first;
        for (T* p = _first;p != _last;p++)
        {
            _allocator.destroy(p);//把_first指针指向的数组的有效元素进行析构操作
        }
        _allocator.deallocate(_first);//释放堆上的数组内存
        int size = rhs._end - rhs._first;
        //_first = new T[size];
        _first = _allocator.allocate(size);
        int len = rhs._last - rhs._first;
        for (int i = 0;i < len;i++)
        {
            //_first[i] = rhs._first[i];
            _allocator.construct(_first + i.rhs._first[i]);
        }
        _last = _first + len;
        _end = _first + size;
        return *this;
    }
    void pop_back()//从容器末尾删除元素
    {
        if (empty())
            return;
        //--_last;
        //不仅要把_last指针--，还要析构删除的元素
        --_last;
        _allocator.destroy(_last);
    }
    T back() const//返回容器末尾的元素值
    {
        return *(_last - 1);
    }
    bool full() const
    {
        return _last == _end;
    }
    bool empty() const
    {
        return _first == _last;
    }
    int size() const
    {
        return _last - _first;
    }
    /*
    //接收左值
    void push_back(const T& val)//向容器末尾添加元素
    {
        if (full())
            expand();
        //*_last++ = val;
        //_last指针指向的内存构造一个值为val的对象
        _allocator.construct(_last, val);
        _last++;
    }
    //接收右值
    void push_back(T&& val)//一个右值引用变量本身是一个左值，所以调用construct是使用左值的construct
    {
        if (full())
            expand();
        _allocator.construct(_last, std::move(val));
        _last++;
    }
    */
    template<typename Ty> //函数模板的类型推演 + 引用折叠，就可以实现一个函数相当于两个函数
    void push_back(Ty&& val) //Ty String && + & =String& 引用折叠
    {
        if (full())
            expand();
        //move:移动语义，得到右值类型
        //std::forward<Ty>：类型的完美转发，能够识别左值和右值类型，并以对应的类型转发
        _allocator.construct(_last, std::forward<Ty>(val));
        _last++;
    }
private:
    T* _first;//指向数组起始的位置
    T* _last;//指向数组中有效元素的后继位置
    T* _end;//指向数组空间的后继位置
    Alloc _allocator;//定义容器的空间配置器对象
    void expand()//容器的二倍扩容
    {
        int size = _end - _first;
        //T* ptmp = new T[2 * size];
        T* ptmp = _allocator.allocate(2 * size);
        for (int i = 0;i < size;i++)
        {
            //ptmp[i] = _first[i];
            _allocator.construct(ptmp + i, _first[i]);
        }
        //delete[]_first;
        for (T* p = _first;p != _last;p++)
        {
            _allocator.destroy(p);
        }
        _allocator.deallocate(_first);
        _first = ptmp;
        _last = _first + size;
        _end = _first + 2 * size;
    }
};
int main()
{
    String str1 = "aaa";
    vector<String> vec;
    std::cout << "-------------------------------------------------" << std::endl;
    vec.push_back(str1);
    vec.push_back(String("bbb"));
    std::cout << "-------------------------------------------------" << std::endl;
}

template<typename Ty>
    void construct(T* p, Ty&& val)//负责对象构造
    {
        new (p) T(std::forward<Ty>(val));//定位new:在指定地址去构造值为val的对象
    }
    void destroy(T* p)//负责对象析构
    {
        p->~T(); //~T()代表T类型的析构函数
    }
 template<typename Ty> //函数模板的类型推演 + 引用折叠，就可以实现一个函数相当于两个函数
    void push_back(Ty&& val) //Ty String && + & =String& 引用折叠
    {
        if (full())
            expand();
        //move:移动语义，得到右值类型
        //std::forward<Ty>：类型的完美转发，能够识别左值和右值类型，并以对应的类型转发
        _allocator.construct(_last, std::forward<Ty>(val));
        _last++;
    }
这两段代码的重写

#include <iostream>

//智能指针 保证能做到资源的自动释放
//利用栈上的对象出作用域自动析构的特征，来做到资源的自动释放
//智能指针不能使其构造在堆上 CSmartPtr<int> *p=new CSmartPtr<int>(new int); delete p;这样就浪费了智能指针的意义
template<typename T>
class CSmartPtr
{
public:
    CSmartPtr(T* ptr = nullptr)
        :mptr(ptr) {}
    ~CSmartPtr()
    {
        delete mptr;
    }
    T& operator*()
    {
        return *mptr;
    }
    T* operator->()
    {
        return mptr;
    }
private:
    T* mptr;
};
int main()
{
    /*int* p = new int(10);
    *p = 30;
    delete p;*/
    CSmartPtr<int> ptr(new int);
    *ptr = 20;
    class Test
    {
    public:
        void test()
        {
            std::cout << "call Test::test" << std::endl;
        }
    };
    CSmartPtr<Test> ptr2(new Test());
    //(ptr2.operator->())->test();
    ptr2->test();
    return 0;
}

#include <iostream>
#include<memory>
template<typename T>
class CSmartPtr
{
public:
    CSmartPtr(T* ptr = nullptr)
        :mptr(ptr) {}
    CSmartPtr(const CSmartPtr<T>& src)
    {
        //mptr = new T(*src.mptr);
    }
    ~CSmartPtr()
    {
        delete mptr;
        mptr=nullptr;
    }
    T& operator*()
    {
        return *mptr;
    }
    T* operator->()
    {
        return mptr;
    }
private:
    T* mptr;
};
int main()
{
    /*
    不带引用计数的智能指针：本身只会让一个智能指针管理资源
    auto_ptr:C++库里面
    C++11:
    scoped_ptr
    scoped_ptr(const scope_ptr<T>&)=dekete;
    scope_ptr<T> & operator=(const scope_ptr<T>&)=delete;
    直接禁用对应拷贝和赋值，就不会发生之前auto_ptr的问题
    推荐使用：
    unique_ptr
    unique_ptr(const unique_ptr<T>&)=dekete;
    unique_ptr<T> & operator=(const unique_ptr<T>&)=delete;
    和scope_ptr不同的是，提供了带右值引用的赋值和拷贝
    unique_ptr(const unique_ptr<T>&&);
    unique_ptr<T> & operator=(const unique_ptr<T>&&);

    怎么解决浅拷贝问题？不解决，会出现double free
    */
    //CSmartPtr<int> p1(new int);
    //CSmartPtr<int> p2(p1);
    /*
    std::auto_ptr<int> ptr1(new int);
    std::auto_ptr<int> ptr2(new int);
    *ptr2 = 20;
    std::cout << *ptr1 << std::endl;
    */
    //auto_ptr是保证最后一个使用智能指针的可以使用，前面使用的底层地址全部置空，来解决浅拷贝问题。
    //不推荐使用auto_ptr，如果把auto_ptr放在容器当中，只要有拷贝构造调用，就会把前一个置为空，这样是很危险的，
    //vector<auto_ptr<int>> vec1;vec2(vec1);

    std::unique_ptr<int> p1(new int);
    std::unique_ptr<int> p2(std::move(p1));//显式调用std::move，不会出现auto_ptr可能无意识就调用了
    return 0;
}

#include <iostream>
#include <memory>


//对资源进行引用计数的类
template<typename T>
class RefCnt
{
public:
    RefCnt(T* ptr = nullptr)
        :mptr(ptr)
    {
        if (mptr != nullptr)
            mcount = 1;
    }
    void addRef()//增加资源的引用计数
    {
        mcount++;
    }
    int delRef()
    {
        return --mcount;
    }
private:
    T* mptr;
    int mcount;
};
template<typename T>
class CSmartPtr //shared_ptr weak_ptr都是线程安全的
{
public:
    CSmartPtr(T* ptr = nullptr)
        :mptr(ptr) 
    {
        mpRefCnf = new RefCnt<T>(mptr);
    }
    CSmartPtr(const CSmartPtr<T>& src)
        :mptr(src.mptr),mpRefCnf(src.mpRefCnf)
    {
        if (mptr != nullptr)
        {
            mpRefCnf->addRef();
        }
        
    }
    CSmartPtr<T>& operator=(const CSmartPtr<T>& src)
    {
        if (this == &src)
            return *this;
        if (0 == mpRefCnf->delRef())
        {
            delete mptr;
        }
        mptr = src.mptr;
        mpRefCnf = src.mpRefCnf;
        mpRefCnf->addRef();
        return *this;
    }
    ~CSmartPtr()
    {
        if (0 == mpRefCnf->delRef())
        {
            delete mptr;
            mptr = nullptr;
        } 
    }
    T& operator*()
    {
        return *mptr;
    }
    T* operator->()
    {
        return mptr;
    }
private:
    T* mptr;//执行资源的指针
    RefCnt<T>* mpRefCnf;//指向该资源引用计数对象的指针
};
int main()
{
    /*
    带引用计数的智能指针shared_ptr和weak_ptr
    都是线程安全的
    带引用计数：多个智能指针可以管理同一个资源
    带引用计数：给每一个对象资源，匹配一个引用计数；
    智能指针 =》获取资源时 =》引用计数+1
    智能指针 =》本身指针释放=》引用计数-1
    如果最后一个使用资源的智能指针不用了，释放该资源
    */
    CSmartPtr<int> ptr1(new int);
    CSmartPtr<int> ptr2(ptr1);
    CSmartPtr<int> ptr3;
    ptr3 = ptr2;
    *ptr1 = 20;
    std::cout << *ptr2 << " " << *ptr3 << std::endl;
    return 0;
}

但是，我这个自定义的还不是线程安全的。

#include <iostream>
#include <memory>
/*
shared_ptr:强智能指针 可以改变资源的引用计数
weak_ptr:弱智能指针  不会改变资源的引用计数 它只会观察资源，不会使用，本身就没有*和->的重载函数，
所以需要把弱智能指针提升为强智能指针，才可以使用。
weak_ptr =>shared_ptr =>资源（内存）

强智能指针循环引用是什么问题？什么结果？如何解决？
造成new出来的资源无法释放,资源泄露
定义对象的地方，用强智能指针；引用对象的地方使用弱智能指针
*/
class B;
class A
{
public:
    A()
    {
        std::cout << "A()" << std::endl;
    }
    void testA() { std::cout << "非常好用的方法！" << std::endl; }
    ~A()
    {
        std::cout << "~A()" << std::endl;
    }
    std::weak_ptr<B> _ptrb;
};
class B
{
public:
    B()
    {
        std::cout << "B()" << std::endl;
    }
    void func()
    {
        //_ptra->testA();
        std::shared_ptr<A>ps = _ptra.lock();//提升方法,可能失败
        if (ps != nullptr)
        {
            ps->testA();
        }
    }
    ~B()
    {
        std::cout << "~B()" << std::endl;
    }
    std::weak_ptr<A> _ptra;
};
int main()
{
    std::shared_ptr<A> pa(new A());
    std::shared_ptr<B> pb(new B());
    pa->_ptrb = pb;
    pb->_ptra = pa;
    std::cout << pa.use_count() << std::endl;
    std::cout << pb.use_count() << std::endl;
    pb->func();

    return 0;
}

#include <iostream>
#include <memory>
class Test
{};
int main()
{
    std::shared_ptr<int> sp1(new int(10));
    std::shared_ptr<Test> sp2(new Test());
    //std::shared_ptr<int> sp3 = std::make_shared<int>(10);
    auto sp3 = std::make_shared<int>(10);
    *sp3 = 20;
    std::cout << *sp3 << std::endl;
}

#include <iostream>
#include <thread>
#include <memory>
/*
多线程访问共享对象的线程安全问题
*/
class A
{
public:
    A()
    {
        std::cout << "A()" << std::endl;
    }
    void testA() { std::cout << "非常好用的方法！" << std::endl; }
    ~A()
    {
        std::cout << "~A()" << std::endl;
    }
};
//子线程
void handler01(std::weak_ptr<A> pw)
{
    
    //q访问A对象的时候，需要侦测A对象是否存活
    std::shared_ptr<A> sp = pw.lock();
    if (sp != nullptr)
    {
        sp->testA();
    }
    else
    {
        std::cout << "A对象已经析构，不能在访问" << std::endl;
    }
}
//main线程
int main()
{
    {
        std::shared_ptr<A> p(new A());
        std::thread t1(handler01, std::weak_ptr<A>(p));
        t1.detach();
        std::this_thread::sleep_for(std::chrono::seconds(2));
    }
    std::this_thread::sleep_for(std::chrono::seconds(20));
    //阻塞等待子线程结束
    //t1.join();
    return 0;
}

#include <iostream>
#include <memory>
#include <functional>
/*
智能指针的删除器 deletor
智能指针：能够保证资源绝对的释放 除了堆上的，文件资源等可以通过自定义删除器,因为底层的删除器是delete ptr;
所以可以根据实际情况，自定义删除器，满足析构要求
*/
//unique_ptr shared_ptr
/*
~unique_ptr(){是一个函数对象的调用 deletor(ptr);}

template <typename T>
class default_delete
{
public:
    void operator()(T *ptr)
    {
        delete ptr;
    }
};
*/
template<typename T>
class MyDeletor
{
public:
    void operator()(T* ptr)const
    {
        std::cout << "call MyDeletor.operator()" << std::endl;
        delete[]ptr;
    }
};
template<typename T>
class MyFILEDeletor
{
public:
    void operator()(T* ptr)const
    {
        std::cout << "call MyFILEDeletor.operator()" << std::endl;
        fclose(ptr);
    }
};
int main()
{
    //std::unique_ptr<int,MyDeletor<int>> ptr1(new int[100]);    //delete []ptr;
    //std::unique_ptr<FILE, MyFILEDeletor<FILE>> ptr2(fopen("data.txt","w"));

    //但是每一次都要自定义，太麻烦了，用一次就没用了，所以可以使用lambda表达式来实现，更方便
    //lambda表达式 -》函数对象 function
    std::unique_ptr<int, std::function<void(int*)>> ptr1(new int[100],
        [](int* p)->void {
            std::cout << "call lambda release new int [100]" << std::endl;
            delete[]p;
        });
    std::unique_ptr<FILE, std::function<void(FILE*)>> ptr2(fopen("data.txt", "w"),
        [](FILE* p)->void {
            std::cout << "call lambda release new fopen" << std::endl;
            fclose(p);
        });
    return 0;
}

#include <iostream>
#include <vector>
#include <functional>
#include <algorithm>
#include <ctime>
/*
* 绑定器和函数对象operator()
1.C++ STL的绑定器
bind1st:operator()的第一个形参变量绑定成一个确定的值
bind2nd:operator()的第二个形参变量绑定成一个确定的值

2.C++11从boost库中引入bind绑定器和function函数对象机制

3.lambda表达式 底层依赖函数对象的机制实现的
*/
template<typename Container>
void showContainer(Container &con)
{
    typename Container::iterator it = con.begin();
    for (;it != con.end();++it)
    {
        std::cout << *it << " ";
    }
    std::cout<<std::endl;
}
int main()
{
    std::vector<int> vec;
    srand(time(nullptr));
    for (int i = 0;i < 20;++i)
    {
        vec.push_back(rand() % 100 + 1);
    }
    showContainer(vec);
    sort(vec.begin(), vec.end());//默认升序
    showContainer(vec);
    //std::greater<int> 二元函数对象
    sort(vec.begin(), vec.end(),std::greater<int>());//降序
    showContainer(vec);

    //把70按顺序插入到vec容器当中 找第一个小于70的数字
    //需要一个一元函数对象
    //绑定器+二元函数对象 =》一元函数对象

    auto it=find_if(vec.begin(), vec.end(), std::bind1st(std::greater<int>(), 70));
    if (it != vec.end())
    {
        vec.insert(it, 70);
    }
    showContainer(vec);
    return 0;
}

#include<iostream>
#include <vector>
#include <algorithm>
#include <ctime>
#include <functional>
template<typename Container>
void showContainer(Container& con)
{
    typename Container::iterator it = con.begin();
    for (;it != con.end();++it)
    {
        std::cout << *it << " ";
    }
    std::cout << std::endl;
}

template<typename Iterator,typename Compare>
Iterator my_find_if(Iterator first, Iterator last, Compare comp)
{
    for (;first != last;++first)
    {
        if (comp(*first))
        {
            return first;
        }
    }
    return last;
}
template<typename Compare, typename T>
class _mybind1st //绑定器是函数对象的一个应用
{
public:
    _mybind1st(Compare comp, T val)
        :_comp(comp), _val(val)
    {}
    bool operator()(const T& second)
    {
        return _comp(_val, second);
    }
private:
    Compare _comp;
    T _val;
};

template<typename Compare,typename T>
_mybind1st<Compare, T> mybind1st(Compare comp, const T& val)
{
    //直接使用函数模板，好处是，可以进行类型的推演
    return _mybind1st<Compare, T>(comp, val);
}
int main()
{
    std::vector<int> vec;
    srand(time(nullptr));
    for (int i = 0;i < 20;++i)
    {
        vec.push_back(rand() % 100 + 1);
    }
    showContainer(vec);
    sort(vec.begin(), vec.end());//默认升序
    showContainer(vec);
    //std::greater<int> 二元函数对象
    sort(vec.begin(), vec.end(), std::greater<int>());//降序
    showContainer(vec);

    //把70按顺序插入到vec容器当中 找第一个小于70的数字
    //需要一个一元函数对象
    //绑定器+二元函数对象 =》一元函数对象
    //auto it = find_if(vec.begin(), vec.end(), std::bind1st(std::greater<int>(), 70));
    auto it = my_find_if(vec.begin(), vec.end(), mybind1st(std::greater<int>(), 70));
    if (it != vec.end())
    {
        vec.insert(it, 70);
    }
    showContainer(vec);
    return 0;
}