侯捷面向对象高级编程（上）

类class A里面的 static int a;static int fun（）  属于类，不属于对象
必须int A::a    
static函数 类 和 对象 都可以调用
static 必须要在类外赋值
static成员只能由static调用
static没有指针
静态函数没有this pointer参数，因此不能直接处理普通的对象，只能处理静态数据
static静态成员变量不能在类的内部初始化。
在类的内部只是声明，定义必须在类定义体的外部，通常在类的实现文件中初始化


const 和 #define 区别：
#define简单替换，没有数据类型，不能进行安全检查。
const有数据类型，调试时可以看到更安全，编译器可以进行安全检查，！！！推荐用const！！！
常量在定义后就不能被修改，所以定义时必须初始化
const定义常量从汇编的角度来看，只是给出了对应的内存地址，而不是像#define一样给出的是立即数。
const定义的常量在程序运行过程中只有一份拷贝，而#define定义的常量在内存中有若干个拷贝。
用const时参数为引用(数据类型不是int double之类的)，为了增加效率同时防止修改。例如 void fun(complex &a) 
类中的 const常量和引用 时必须在构造时初始化列表
class Apple{
private:
    int people[100];
public:
    Apple(int i); 
    const int apple_number;
    int& a；
};
Apple::Apple(int i):apple_number(i),a(i)
{

}

const成员函数只能访问const成员函数。
int add();
int getCount() const;
int Apple::getCount() const
{
    take(1);
    add();  // error
    //const成员函数只能访问const成员函数。
    return apple_number;
}

const对象只能访问const成员函数。
const Apple b(3);
b.add(); // error//const对象只能访问const成员函数。



尽可能传递引用reference，传引用过去，修改之后，都会改变；
但是在函数内生成的变量不能传引用，只能传值。因为函数结束后引用的指针就消失了。
如果只是为了提升速度，不向改变数据，那么传const引用（const complex& c）。这样传进去的东西，不能被修改。
返回值的传递，也尽量返回引用

相同类的对象，函数互为友元
complex a；
complex b；
a.fun(b) 
int fun(complex& b)
{
    return b.real+b.imag;// real imag都是private
}

操作符重载最好要返回自身引用，方便后面的连用 a+b+c+d+e...
成员函数的重载 只有一个参数
友元 非成员函数的重载  有两个参数

拷贝构造、拷贝赋值:对于含有指针的，不仅需要把指针复制，指针指向的值也需要复制
先检测是不是自我赋值，需要判断一下。
if(this==&str)
{
    return *this;
}
然后先把数据清空，然后新建指定大小的数组。然后把字符串内容复制过来。

栈区 是函数自动生成自动清除
堆区 是手动建立，手动删除

new arr[10];
delete[] arr;

构造函数放在private中，构造函数私有化的类的设计保证了其他类不能从这个类派生或者创建类的实例，外界就不能创造新的对象，只能通过类似下面的接口拿到
A& A::getInstance() {
    static A a;
    return a;
}
在后面需要用指针接收
A *p = &A::getInstance();

类的关系  
复合：
A类中还包含另一个B类  那么A里面可以调用B的函数来实现所有功能  比如queue中有（底层容器）sequence
先构造B，再构造A；析构相反AB
委托（引用的复合）：
A类中包含B类的指针
继承：
继承父类的成分
先构造父类，再构造子类，先析构子类，再析构父类

虚函数 纯虚函数
虚函数是必须在父类有实现的，纯虚函数是子类中必须实现的