1. 类中含有指针—— class with pointer member(s) ——的情况经常发生，典型的有：string 类。
2. STL中的 string 类太复杂，copy on write 等等特性。
3. 采用“防卫式头文件声明”。
4. s2 赋值给 s3。
String s3("hello"), s2;
s3 = s2;
5. complier 会默认生成：拷贝构造函数 和 拷贝赋值函数（操作符重载），其执行的原理是按位依次赋值。带指针的类不适合使用默认的构造函数。
class String
{
public:
String (const String& str); //拷贝构造函数
String& operator= (const String& str); //拷贝赋值函数
} String s3(s1); //拷贝构造
String s2 = s3; //拷贝赋值
6. String 类实现原理
class String
{
public:
String(const char* cstr=);
private:
char* m_data; //指针动态分配存储空间
} String::String(const char* cstr)
{
if (cstr) {
m_data = new char[strlen(cstr)+];
strcpy(m_data, cstr);
}
else {
m_data = new char[];
*m_data = '\0';
}
}
7. 只要类中带有指针，就必须自定义拷贝构造函数和拷贝赋值函数。
8. 三个特殊函数（big three）：拷贝构造、拷贝赋值、析构函数。
9. 尽量使用“常量成员函数”:
char* get_c_str() const
{
//do something
}
10. 浅拷贝：编译器默认生成的类实例间拷贝行为，对带有指针的类来说会引发 memory leak。
深拷贝：用户定义的行为（实质是一种构造函数）。
兄弟——类的不同实例——间互为 friend（友元），可以直接取对方的私有成员。
11. 一定要在 operator= 中检查是否 self assignment，是编程经验的体现。
String& String::operator=(const String& str)
{
// check self assignment
if (this == &str)
return *this; delete[] m_data;
m_data = new char[ strlen(str.m_data) + ];
strcpy(m_data, str.m_data);
return *this;
}
12. stack and heap
stack：
存在于某scope（作用域）的一块内存空间（memory space）。例如当用户调用函数，函数本身会形成一个stack用来放置它所接收的参数，以及返回地址。
在函数本体内声明的任何变量，其所使用的内存块都取自上述stack。
heap：
或谓 system heap，是指操作系统提供的一块 global 内存空间，程序可动态分配（dynamic allocated）从某中获得的若干区块。
13. stack object 对象的生命期：
class Complex {......};
......
{
Complex c1(, );
}
c1便是 stack object，其生命在作用域（scope）结束之际结束。这种作用域之内的 object 又称为 auto object，因为它会被“自动”清理。
14. static local object 对象的生命期：
class Complex {......};
......
{
static Complex c2(, );
}
c2便是static object，其生命期在作用域（scope）结束之后仍然存在，直到整个程序结束。
15. global object 对象的生命期：
class Complex {......};
......
Complex c1(, );
int main()
{
//do sometihing
return ;
}
c1便是所谓 global object，其生命期在整个程序结束之后才结束，也可以视为一种 static object，作用域是“整个程序”。
16. （对象的） 存在/消失 ≈ 构造/析构 （函数）何时被调用。
17. heap objects 对象的生命期：
class Complex {......};
...
{
Complex *p = new Complex;
...
delete p;
}
p 所指的是 heap objects ，其生命在它被 delete 之际结束。
若当作用域结束还未 delete 则会内存泄漏（memory leak）：因为当作用域结束时，指针p所指的heap object仍然存在，但指针p的生命却结束了，作用域之外再也看不到指针p，也就没机会 delete p。
18. new： 先分配memory，再调用constructor
Complex *p = new Complex(1, 2);
以上的一行代码，编译器会转化为：
Complex *pc; void* mem = operator new( sizeof( Complex ) ); // 分配内存
pc = static_cast<Complex*>(mem); // 转型
pc->Complex::Complex(, ); // 构造函数
- operator new——操作符“new”——是C++函数，其内部调用malloc（）。
pc->Complex::Complex(1, 2); => Complex::Complex(pc, 1, 2); / Complex::Complex(this, 1, 2);
19. delete：先调用 de-constructor，在释放内存
Complex *ps = new String("hello world");
...
delete ps;
编译器转化为
Complex::~Complex(ps); // 析构函数
operator delete(ps); // 释放内存
operator delete(ps); 内部调用 free（ps）
20. array new 一定要搭配 array delete。
String *p = new String[];
...
delete[] p;
21. 头文件.h 防卫式声明
22. 32位平台下，一根指针 4 字节。
23. return by reference 使用门槛：传递的 object 不是 local object。
24. “常量成员函数”：不修改类成员数据部分的函数。
char* get_c_str() const
{
// do something
}
const 加在 （）与｛｝之间。
25. inline 关键字一定要加！全部的，无负面作用。
26. static data member 内存中只有一份，不在乎存在多少实例。
static data memeber 一定在类的声明之外设初值。
static member function 调用方式有二：（1）通过 object 调用（2）通过 class name 调用。
class Account {
static void set_rate(double val);
};
Account::set_rate(8.0); // 通过类名调用
Account a1;
a1.set_rate(8.0); // 通过实例调用
27. Q：“声明”和“定义”的区别？
A：定义会程序获得内存。
28. singleton——把ctor放在private区
class A{
public :
static A& getInstance(){ return a; }
setup();
private:
A();
A(const A& ths);
static A a;
};
// 调用示例
A::getInstance().setup();
29. Meyer`s singleton——把ctor放在private区
把静态的“自己”放在函数里。好处：只有当函数被调用时，才创建object，即使离开函数以后static object也依然存在。如果该函数没被调用过，那么连一个static object也不会存在。
class A{
public :
static A& getInstance();
setup();
private:
A();
A(const A& ths);
static A a;
};
A& A::getInstance()
{
static A a;
return a;
}
// 调用示例
A::getInstance().setup();
30. Q：为什么cout可以接收各种内置类型“对象”？
A：因为标准库对“<<”做了针对各种内置类型的运算符重载
31. “template会造成代码膨胀是必要的”——侯捷
代码膨胀：模版会针对用户定义的每一种类型都生成一份代码，代码的大意相同，只是类型不同。
32. class template
template <typename T>
class Complex {
public:
Complex(T r = , T i = )
: re(r), im(i)
{}
private:
T re, im;
}; int main()
{
complex<double> c1(, );
return ;
}
33. function template
class Complex {
public:
bool operator< (const Complex& ths) const
{...}
};
template <class T>
inline const T& min(const T& a, const T& b)
{
return b < a ? b : a; // 编译器遇到“<”会自动寻找对应类型的运算符重载
}
int main()
{
Complex c1, c2, c3;
c3 = min(c1, c2);
}
对于 c3 = min(c1, c2) 不必明确指出类型，因为complier会对function template进行实参推导（argument deduction）。
34. namespace
using directive
using namespace std;
using declaration
using std::cout std::cin >> ...
cout << ...
35. string.h 代码：
#ifndef __MYSTRING__
#define __MYSTRING__ class String
{
public:
String(const char* cstr=);
String(const String& str);
String& operator=(const String& str);
~String();
char* get_c_str() const { return m_data; }
private:
char* m_data;
}; #include <cstring> inline
String::String(const char* cstr)
{
if (cstr) {
m_data = new char[strlen(cstr)+];
strcpy(m_data, cstr);
}
else {
m_data = new char[];
*m_data = '\0';
}
} inline
String::~String()
{
delete[] m_data;
} inline
String& String::operator=(const String& str)
{
if (this == &str)
return *this; delete[] m_data;
m_data = new char[ strlen(str.m_data) + ];
strcpy(m_data, str.m_data);
return *this;
} inline
String::String(const String& str)
{
m_data = new char[ strlen(str.m_data) + ];
strcpy(m_data, str.m_data);
} #include <iostream>
using namespace std; ostream& operator<<(ostream& os, const String& str)
{
os << str.get_c_str();
return os;
} #endif
36. 更多细节深入
•operator type() const;
•explicit complex(…) : initialization list { }
•pointer-like object
•function-like object
•Namespace
•template specialization
•Standard Library
•variadic template (since C++11)
•move ctor (since C++11)
•Rvalue reference (since C++11)
•auto (since C++11)
•lambda (since C++11)
•range-base for loop (since C++11)
•unordered containers (Since C++)