积土成山，风雨兴焉；积水成渊，蛟龙生焉；积善成德，而神明自得，圣心备焉。故不积跬步，无以至千里；不积小流，无以成江海。骐骥一跃，不能十步，驽马十驾，功在不舍。锲而舍之，朽木不折；锲而不舍，金石可镂。蚓无爪牙之利，筋骨之强，上食埃土，下饮黄泉，用心一也。蟹六跪而二螯，非蛇蟮之穴无可寄托者，用心躁也。是故无冥冥之志者，无昭昭之明；无昏昏之事者，无赫赫之功

——荀子《劝学篇》

（1）string类里面存在指针，属于类的两种类型之一；有指针的类必须要有析构函数；不带指针的类，其拷贝构造操作可以用编译器自带的功能，但是类里面有指针，则必须自己重写。

int main()
{
    string s1();
    string s2("hello");
    
    string s3(s1);//拷贝构造
    cout<<s3<<endl;
    s3=s2;//拷贝赋值
    cout<<s3<<endl;
}

（2）因为string类的元素大小是不确定的，所以用指针

class string
{
public:
    string(const char* cstr = 0);//构造函数
//带指针的类，以下三个函数一定要写
    string(const string& str);//拷贝构造函数，接受自己这种类型的东西进行构造，所以是拷贝构造
    string& operator=(const string& str);//操作符重载，接受的也是自己这种东西，所以称为拷贝赋值；
    ~string();
//
    char* get_c_str() const { return m_data }
private:
    char* m_data;//指针
}

(3)字符串就是一个指针指向头，最后有一个结束符号（c&c++）。字符串的构造和析构函数为

对于没有指针的类，不需要清理，因为定义的内容会随着函数结束而自动清理掉；但是含有指针的类中，过程中做了

动态分配，占用了动态内存，不会随着函数结束而被清理，所以需要单独清理该内存，防止内存泄漏。

inline 
string::string(const char* cstr = 0)//构造函数
{
    if(cstr)
    {
        m_data = new char[strlen(cstr)+1];
        strcpy (m_data, cstr);//如果构造函数已赋值，则先分配一个大小为所赋值字符串的长度的内存加1，最后的1用来存结束符号。然后将所赋值cstr拷贝到m_data中。
    }
    else
    {
        m_data = new char[1];
        *m_data = ' ';//如果构造函数未赋值，则自动分配一个大小为1的内存用来存结束符号
    }
}

inline
string::~string()
{
    delete[] m_data;//析构函数，清理，注意delete[]的写法
}

(4)新建字符串的几种形式。动态分配内存一定要及时delete

//main.cpp
{
    string s1();
    string s2("hello");

    string* p = new string("hello");
    delete p;//动态分配内存，新建指向”hello“的变量，用完以后一定要及时删除
}

（5）类里面如果有指针，则一定要有拷贝构造和拷贝赋值！

下图中没有拷贝构造函数的b=a操作，会使得b直接指向与a同样的地址，而b原来指向的地址则成为野内容，内存泄漏，同时hello 被两个指针指向也存在危险性。

拷贝构造函数：

inline
string::string(const string& str)
{
    m_data = new char[ strlen(str.m_data)+1];//深拷贝，创造一片空间容纳蓝本
    strcpy(m_data, str.m_data);//将内容拷贝进内存
}

{
    string s1("hello");
    string s2(s1);//拷贝构造
    s2=s1;//拷贝赋值
}

拷贝赋值函数：检测是否自我赋值 or 赋值

{
    string s1("hello");
    s2=s1;//拷贝赋值
}

inline
string& string::operator = (const string& str)//拷贝赋值
{
    if（this == &str）{ return *this;}//检测是不是自我赋值，这一步非常重要，如果不写，当使用者自我赋值时会出错，原因如下图
   
     //操作步骤
    delete[] m_data;//1.先清掉自己
    m_data = new char[ strlen(str.m_data)+1];//2.构造与左边值相同大小的空间
    strcpy(m_data, str.m_data);//3.把左边值复制进来
    return *this;
}

二、堆、栈与内存管理

（1）所谓堆（stack）和栈（heap）

1.1 定义

stack：存在于某作用域的一块内存空间。例如当你调用函数，函数本身即会形成一个stack用开放置它所接收的参数，以及返回地址。在函数内声明的任何变量，在其所用的内存块上都取自上述stack。

heap:操作系统提供的一块global内存空间，程序可动态分配，从中获得若干区块。

class Complex{....};

{
    Complex c1(1,2);//存储在栈中，c1的存储会随着函数结束而消失.local object
    Complex *p = new Complex(3);//动态获得堆的内存，因此不会随着函数结束而消失，必须手动delete掉.static object

}

1.2 stack生命周期

a, stack objects：离开作用域就会消失，又称为auto object(指其析构函数会自动调用)

b.static local objects:生命在作用域结束之后仍然存在，直到程序结束。

c.global objects: 全局对象，生命同样在整个程序结束之后消失。

{
    Complex c1(1,2);//stack object
    static Complex c2(1,2);//static object
}

Complex m(1,2)//global object

int main()
{
    ...
    return 0;
}

1.3 heap objects生命周期

class Complex {...};

{
    Complex* p = new Complex;
    ....
    delete p;
}
//p所指的便是heap object, 其生命在它被delete之后结束

//VS

{
    Complex* p = new Complex;
    ....
}
//以上出现内存泄漏，因为当作用域结束，p所指的heap object仍然存在，但指针p的生命却结束了，作用域之外再也看不到p了，因此没办法再delete p了。

没有delete相对应的指针所指的内容，那么就会占用内存，造成内存泄漏。而消除内存泄漏，只需delete p即可，而不用delete *p。

1.3.1动态分配所得的array，到底有多大？--侯捷独家

a.调试状态下：存储一个数据的内存大小是：数据本身大小+上下cookie+灰色填充（结果不是16的倍数时要向下分配内存直至满足16的倍数）

b.非调试状态下：只存储上下cookie和数据本身大小。

1.3.2 动态分配下的数组array存储

array new & array delete要一起搭配。

{
     Complex *p = new Complex[3];//指针指向复数数组头
     String *p = new String[3];//数组里面有三个指针
}

图片说明：对于内有3个元素的数组存储，调试模式下（左1）内存分配包括3个数组元素+上下Debugger Header+上下cookie+表数量（8*3+（32+4）+4*2+4），以及不满16倍内存，自动增加内存直至为16倍数；左二是非调试模式。

1.3.3 delete[] 与 delete 的区别

delete的动作分为两步，首先调用析构函数删除变量，然后删除其内存。所以如下调用delete的时候，系统会自动调用析构函数，然后根据上下cookie给出的内存大小进行整块内存删除。因此对于数组内存储的是非指针变量的array new，delete不加[]，是不会造成内存泄漏的。但是！！！如果内部存储的是指针，那么没有加[]，编译器会不知道需要需要调用多次析构函数，从而造成只删除第一个数组元素及其指向的数据，而不会删除后续的。内存泄漏的部分是剩余数组内指针元素指向的部分。

.所以，为了保险起见，array new 一定要搭配 array delete[]/

三、类模板、函数模板

3.1  静态全局变量的作用域为单个源文件的区域；全局变量的作用域是整个工程文件的区域。

(1) 静态数据：带有this pointer;

           使用场景：对于不同类名的某一属性，只能有一份，如银行系统的利率，百人都是同一利率

(2) 静态函数：没有this pointer；只能存取、处理静态数据

(3) 静态的数据在类外一定要进行定义，赋不赋初值都是可以的。

(4)调用static函数方式两种：

a.通过类名调用；(在还没有对象被建立的时候)

b.通过用户调用

class Account
{
public:
    static double m_rate;
    static void set_rate(const double & x) { m_rate = x;}
};
double Account::m_rate = 8.0;//！！！静态数据在class外一定要进行定义

int main()
{
    Account::set_rate(5.0);//调用static函数方式两种：a.通过类名调用；
    Account a;
    a.set_rate(7.0);//b.通过用户调用
}

3.2 把ctors放在private区（Singleton，利用静态实现该种设计模式）

初级版本一，缺陷：如果外界不需要A，那么已经被创建的a就会造成内存占用浪费

class A
{
public:
    static A& getInstance {return a; };
    setup（）{......}
private:
    A();
    A(const A& rhs);
    static A a;//仅一份的创建
...
};

A::getInstance().setup();//通过这种方式来调用唯一的类的函数

升级版本二

class A
{
public:
    static A& getInstance {return a; };
    setup（）{......}
private:
    A();
    A(const A& rhs);
...
};

A& A::getInstance()//当没有人使用A时，她就不会被创建，一旦有人使用，就会被创建，并且不会随着函数消失而消失
{
    static A a;
    return a;
}


A::getInstance().setup();//通过这种方式来调用唯一的类的函数

3.3 补充类模板，class template

template<typename T>//表明T为一个类型模板
class complex
{
public:
    complex (T r=0, T i=0):re(r), im(i) {}
    complex& operator += {const complex& };
    T real() const { return re; }
    T imag() const { return im; }
private:
    T re, im;

    friend complex& __doap1 (complex*, const complex& );
};

//用法
{
    complex<double> c1(2.5, 1.5);
    complex<int> c2(2,6);
    ...
}

3.4 函数模板 function template

template <class T>
inline
const T& min(const T& a, const T& b)
{
    return b<a? b:a;
}


class stone
{
public:
    stone();
    bool operator < (const stone& rhs) const
    { return  _weight < rhs._weight; }

private:
    int _w, _h, _weight;
};

//使用
stone r1(2,3), r2(2,3), r3;
r3 = min(r1, r2);

3.5 补充 namespace

namespace是把所有包在命名空间里，为了防止与别人定义的重名，则把你的内容包在namespace里。

using namespace std;//一次把标准库全打开。一些常见小程序用这种
{
cout<<...
}

//为了防止标准库全打开，会出现混乱，那么单独打开需要的内容
using std::cout;
{
cout<<..
}

//
{
std::cout<<...
}

3.6更多细节学习

• Standard Library:需要好好利用
• operator type() const;
• explicit complex(...)：initialization list {}
• pointer-like object
• function-like object
• Namespace
• template specialization
• variadic template 
• move ctor
• Rvalue reference
• auto
• lambda
• range-base for loop
• unordered containers

完！！！