（有指针Class - String）

---

1. Big Three: 拷贝构造函数, 拷贝赋值函数, 析构函数

2. 对于含指针类(Class with pointer), 必须含有copy ctor & copy op

3. static 和 Singleton

---

copy ctor (拷贝构造函数)

        新构造的对象: new 新地址;

        深度拷贝 = 拷贝值 + 拷贝地址;

---

copy operator (拷贝赋值函数)

        判断是否自我赋值(self assignment);

                if True: return self;

        被赋值对象: delete 原地址;

        新构造的对象: new 新地址;

        深度拷贝;

---

stack & heap(栈 & 堆)

        stack: 

                scope(作用域)内的一块内存空间, function body 内声明的任何变量;

                static object在scope结束之后仍然存在,直至整个程序结束;

        heap: 

                由操作系统提供的一块global内存空间, 可动态分配内存（dynamic allocate）;

                global object在整个程序结束之后才结束生命周期;

---

new的内部工作原理

        先分配 memory, 再调用 ctor

        ep:

                Complex * pc = new Complex(1, 2);

                编译器转化为:

                        1. void * mem = operator new( sizeof(Complex) );

                                        -- 内部调用 malloc(n)

                        2. pc = static_cast(mem);

                                        -- 转型 mem 从 void* 变成 Complex*

                        3. pc->Complex::Complex(1, 2);

                                        -- pc 指向新创建对象的头部

---

delete的内部工作原理

                先调用 dtor, 再释放 memory

                ep:

                String * ps = new String("Hello");

                ...

                delete ps;

                编译器转化为:

                        1. String::~String(ps);

                                        -- 析构函数 （删除动态分配的内存, 指针指向的内容）

                        2. operator delete(ps);

                                        -- 内部调用 free(ps) (删除指针)

---

static

                在一个class中(无static):

                                成员变量: 根据创建出对象的不同，可以有多份地址;

                                成员函数: 地址只有一份，通过this指针来调用不同的对象;

                                static成员变量: 

                                        1. 地址只有一份;

                                        2. 需在类外初始化，格式: Class_Name::static_data = value;

                                        3. 不能使用参数初始化表；

                                static成员函数: 

                                        1. 地址只有一份，没有this指针;

                                        2. 不能访问类中的非静态变量，只能处理static数据;

                                        3. 可用类或对象来调用;

---

ctor放在private区的设计模式(Singleton)

                ep:

                class A{

                public:

                    static A& getInstance();   

                    setup() {...}

                private:

                       A();

                        A(const A& rhs);

                  ...        };

                // 只有调用该静态方法，才会创建static变量，且只能创建一份

                A& A::getInstance()    {

                        static A a;

                        return a;        }

---

class template 与 function template

        类模板需要指定类型;

        函数模板会由编译器进行argument deduction推断类型;

---

namespace

        不同文件为相同namespace编写的内容会被自动结合到一起;

        两种使用方式:

                using namespace std;

                using std::cout;

---

内存分配的可视化