1. big three

带有指针的class， 拷贝构造，拷贝赋值和析构函数必须自己写（深拷贝）。编译器给的那一套是浅拷贝（会内存泄漏，及同时修改会有危险）。 stl中的string类是采用的深拷贝。
（1）拷贝构造

inline
String::String(const char *cstr = 0)
{
     if(ctor)
     {
          m_data = new char[strlen(cstr)+1];
          strcpy(m_data, cstr);
     }
     else
     {
          m_data = new char[1];
          *m_data = '\0';
     }
}

inline
String::String(const string &str)
{
     m_data = new char[strlen(str.m_data)+1];
     strcpy(m_data, str.m_data);
}

（2）拷贝赋值：要先检查是否自我赋值（self-assignment）

inline
String & operator = (const String &str)
{
     if(this == &str)
          return *this;

     delete m_data;
     m_data = new char[strlen(str.m_data)+1];
     strcpy(m_data, str.m_data);
     return *this;
}

（3）析构函数

inline
String::~String()
{
     delete []m_data;
}

2. 堆栈和内存管理

（1）不同对象类型的生命周期

    stack object的生命周期在作用域内（scope）。
    static local object的生命周期在作用域结束之后仍然存在，直到整个程序结束。
    global object的生命周期在整个程序。
    heap object的生命周期在被delete之后结束。

{
    Complex *p = new Complex;
    ...
    delete p;//p指针的生命周期在作用域内，p指向的对象的作用域是是在delete的时候结束。
}

（2）new和delete的深刻含义

• new会先利用operator new(size_t)函数（内部调用malloc）分配内存，之后进行转型，再调用构造函数。delete会先调用析构函数，再调用operator delete函数（内部调用free）释放内存。

• 给对象分配内存空间，如图1所示。第一个的内存块是vs在调试模式下编译后，对Complex对象分配的内存块。Complex的数据成员占8个字节；灰色部分是调试模式下所在的内存4字节×8+4字节 = 32字节；还有vs下当对象总字节数不满足16的整数倍时，会自动添加填充字节pad；上下红色的cookie，4字节×2 = 8字节，内部存放的数值是0x41因为总字节数是64，16进制表示就是0x40，还有要再加最后一个bit位来表示对内存是分配还是回收，1表还是分配，0表示回收。因为总字节数都是16的倍数，最后4个bit位都是0，所以最后4位可以被借用。第二个内存块是vs在release模式下编译后对Complex对象的内存分配。

  
  
  1

• 给对象数组分配内存空间，如图2所示。vs会在记录数组中对象的个数。

  
  
  2
• array new一定要搭配array delete。
  String *p = new String[3];
  delete[] p; //唤起3次析构
  delete p; //唤起1次析构，剩下两个元素new出来的空间不会被释放。
  特例，如果class中没有指针，释放对象数组时用delete p，不会发生内存泄漏的。

3. static

（1）non-static成员函数：同一个类的各个对象对应的non-static成员函数只有一份，non-static的数据成员各自有一份，通过this pointer找到对应对象的数据成员，再执行non-static函数（内部会有this指针）。
（2）static数据成员：同一个类的各个对象只有一份。在class外部要定义这个数据成员。double Account::m_rate = 8.0;
（3）static成员函数：没有this pointer，只能处理static数据。
调用方式：通过object，或通过class name.
eg. 单例模式 将实例化静态对象放在静态成员函数中而不是作为数据成员，好处是当调用这个函数时这个对象才会出现，且只有这一份。

4. cout

继承于ostream，ostream对<<运算符进行了大量重载，所以用cout可以打印各种类型数据。

5. 类模板

template<typename T>， template<class T>，在使用时会根据不同的类型，产生不同的类，产生代码膨胀，不过这个并不是不好。

5. 函数模板

template<typename T>， template<class T>，编译器会对函数模板进行实参推导（argument deduction）.

6. namespace

using directive: using namespace std; std标准库。
using declaration: using std::cout; 后面在使用其他的名字时要加std，eg.std::cin
std::cout std::cin

7. 更多细节...

（1）operator type() const; 类的成员函数，将类类型转换为其他类型。
（2）explicit：只能修饰只有一个参数（其他参数有默认值）的构造函数，作用防止隐式自动转化。explicit对具有多个参数（除了有默认值的参数之外）的构造函数没有用处。eg. CExample obj = 123;如果构造函数不加explicit，那么编译器会自动将123转换为对应的类对象， CExample temp(123); 之后调用拷贝构造，CExample obj(temp);

注：图片来自Boolan.