RoBa’s Blog

Chapter 14

这章主要讲操作符重载。

操作符重载不能用于操作数都是内置类型的时候。比如，我们不能重载operator+(int,int)。操作符的优先级、结合性、操作数个数不能改变。重载&&,||和逗号后，不再保证求值顺序和短路运算，最好不要重载这几个。

大部分重载操作符可以作为普通函数或类的成员函数，在第二种情况下，参数列表里会少一个，因为省略了隐含的this。一般将算术和关系操作符定义非成员函数，而将赋值操作符定义为成员（如上章介绍）。如果作为普通函数，因为往往要访问私有成员，在类定义里往往要将该函数设为友元。操作符也可以用类似函数调用的形式访问，像这样 loli = operator+(loli, loli2).

赋值(=)、下标([])、函数调用(())、成员访问(->)这几种操作符必须定义为类成员。+=, ++之类，最好定义为成员。对称的运算，如+, ==，往往定义成普通函数。

重载IO操作符应该声明为普通函数，不然的话类就只能作为左操作数，就会变成这样的诡异形式 loli<<cout，明显不符合习惯。而我们又不能为iostream类添加成员，所以只能定义成普通函数了，然后把它作为我们的类的友元。

重载加法时应该返回一个新的对象而不是引用（所以a+b是右值），而+=一般返回的是对左操作符的引用。（这种情况下用+=效率高些？）

某些算法（例如find()）以及关联容器需要我们定义<或是==，要注意<的定义满足以前说的那几个条件。

下标运算符可能作为左值，故应返回引用。但对const对象应返回const引用，所以应该写const与非const两个版本的重载函数，如chapter 12所讲。

重载自增和自减操作符应该遵循惯例，前置返回引用，应该这样写：Loli& operator++()，后置返回变化之前的值，应该这样写：Loli operator++(int)，最后那个int是为了与前置区分，在函数体内无视它。

定义了函数调用操作符的类，又被称作函数对象，因为这种类的对象看上去表现得像一个函数。这种东西最常用在STL里，比如我们自己定义一个结构体的比较函数对象，优先按照年龄，然后按照姓名排序：

struct Lolicmp {
    bool operator()(const Loli &a, const Loli &b) {
        if (a.age != b.age) return a.age < b.age;
        return a.name < b.name;
    }
};

std::set<Loli, Lolicmp> loli_set;
std::vector<Loli> loli_arr;
sort(loli_arr.begin(), loli_arr.end(), Lolicmp());

标准库也定义了若干函数对象，比如我们最常用的greater<T>，所以把int数组从大到小排序就是sort(a, a+N, greater<int>())

Chapter 15

本章介绍OOP的核心：类继承和动态绑定。继承就是指类之间的层次关系，一个类是另一个类的派生类之类。动态绑定是指在运行时才决定是调用基类的成员函数还是派生类的成员函数，这就产生了所谓多态。C++里实现要想实现动态绑定需要用对象的引用或指针，看下面例子：

class Loli {
public:
    virtual void speak() { cout<<"oniisan~"<<endl; }
    virtual ~Loli() { }
    Loli() : age(0) { }
protected:
    int age;
};

class TsundereLoli : public Loli {
public:
    void speak() { cout<<"ulusai! I am "<<age<<" years old."<<endl; }
};

void func(Loli &t) { t.speak(); }

int main() {
    Loli a;
    TsundereLoli b;
    func(a);
    func(b);
    return 0;
}

这个程序有很多地方需要解释，下面会慢慢说。

执行上面程序会发现，两次调用func()实际上调用了不同的函数，尽管func里写的是接受基类的引用（在书里这个引用或指针的类型叫做静态类型），但传进去的对象会“知道”自己实际的类型（书里叫动态类型）。要实现这个功能，一定要把基类对象的相应成员函数声明为virtual，只有虚函数才会执行动态绑定，普通成员函数的执行是在编译期就确定的。如果上面例子中的speak()不是虚函数的话，因为func接受的是基类Loli的引用，故一定调用基类的speak()。注意，一旦基类里声明某函数为虚函数，它就一直是虚函数，在派生类的实现里无需再带virtual关键字（是不是带上更清晰些？）

基类与派生类之间的转换

如上所述，存在派生类引用（或派生类指针）到基类引用（或基类指针）的自动转换，这就是实现多态的关键。反之的自动转换则不存在，例如如果把上面func()函数改成接受TsundereLoli的引用，则编译不过，因为func(a)这句要求一个基类引用到派生类引用的转换，这是不能自动进行的。

上面说的是指针或引用的转换，对象的转换则完全不同，如果把上面的func函数改成 void func(Loli t) {…}，此时它自始至终都是接受一个Loli类型的对象，不存在动态绑定，如果把TsundereLoli对象传递过去，则TsundereLoli会被强行“切割”(slice down)成一个Loli对象，然后调用Loli::speak()，TsundereLoli对象的任何不属于Loli子对象的数据成员和函数成员将被丢弃。

下面来详细分析一下原因：

当用派生类对象对基类对象进行初始化或赋值时，有两种可能的情况发生：第一种情况很罕见，就是在基类里有一个以派生类为参数的复制构造函数和赋值运算符，像下面这样子：

class TsendereLoli;
class Loli {
public:
    Loli(const TsendereLoli &) { ... }
    Loli& operater=(const TsendereLoli &) { ... }
};

这时我们可以自己定义从派生类对象转换到基类对象时做什么。不过这种情况显然是非常罕见的，理论上基类的作者不应该知道具体是谁继承了自己，他只应该对自己以及父类负责。第二种情况是常见的，也就是基类里只有以自己的引用为参数的构造函数和赋值运算符（如果不写的话默认产生的也是这种）：

class Loli {
public:
    Loli(const Loli &) { ... }
    Loli& operater=(const Loli &) { ... }
};

这时如果我们把一个派生类作为参数传进构造函数或赋值过来，这时会发生的事情是：首先将基类类型的引用(Loli&)绑定到一个派生类的对象，然后将这个引用作为实参传递给复制构造函数或赋值符，因为是基类的引用且非虚函数，函数内部只能使用到派生类里的Loli子对象部分，如果调用函数的话也只能调用基类的函数，通常情况下函数内部的实现是把基类的成员一一复制过来（不写的话默认也是这样的），当函数结束后，就得到了一个真正是基类的对象，不存在任何派生类的成分，这时我们就说派生类被slice down了。

（15章未结束，待续）

Chapter 12 (cond)

关于构造函数

所谓构造函数初始化式(Constructor Initializer)是指在构造函数参数列表后面冒号里的那一列东西，这是一个很多熟练程序员都可能不太了解的地方，大家可能更习惯在构造函数的花括号里写东西。但是实际上只有在冒号后面的那些才是真正的初始化，在花括号执行的只是普通的赋值语句，明确地区分这两者看上去有点无聊，但某些情况下是必须要考虑的。一是效率上的原因，不管怎么写，在创建对象时都要先对每个成员进行初始化，然后再执行花括号里的普通计算。如果写在花括号里，实际上是先初始化一次，再赋值一次覆盖掉初始化的内容，这样就造成了浪费，如果成员是比较大的对象，效率上会有影响。二是某些对象是不允许赋值的，比如引用和const成员，这时只能在初始化式里初始化，不能在花括号里赋值。总之，尽量写在初始化式里比较好。

初始化的次序与成员声明的次序一致，与初始化式里的次序无关。尽量不要让初始化的值依赖其他成员变量，以免造成混乱。

如果初始化式里没有指明某个成员变量，则按照默认方式初始化：对于类类型成员调用默认构造函数，对于内置类型成员，如果是全局对象则置0，局部对象则为未定义值。

如果对类A声明了任何一个构造函数，则编译器不会再自动合成默认构造函数。这种情况下会带来诸多不便，比如如果某个类B以类A作为一个成员，则类B也不再有默认构造函数；不能声明A的静态数组；包含A的容器也不能只用一个表示大小的值来初始化，等等。所以通常情况下最好要有个默认构造函数。

如果类有接受一个参数的构造函数，这时就隐含了一种类型转换的可能，见下面代码：

class Loli {
public:
    Loli(int n) : age(n) {}
    int get_age() {return age;}
private:
    int age;
};

void print_loli_age(Loli loli) {
    cout<<loli.get_age();
}

虽然print_loli_age要接受一个Loli类型的参数，但我们可以直接调用print_loli_age(15)。因为Loli有一个接受一个int参数的构造函数，这样就把15自动转化生成了一个Loli类型。有的时候这样的隐式转换不是我们想要的，就需要在构造函数前面加一个explicit来禁止这种转化，此时如果想转化的必须显式调用：print_loli_age(Loli(15))

关于static成员

static成员独立于类的任何实例对象而存在。static成员函数没有this指针，也不能访问非static成员。static数据成员必须在类的定义体外定义恰好一次，在定义同时初始化，通常把它和类的成员函数的实现放在同一个源文件里。

Chapter 13

本章主要是三部分内容：复制构造函数、赋值运算符和析构函数

复制构造函数是一种特殊构造函数，具有单个形参，该形参（常用 const 修饰）是对该类类型的引用。当定义一个新对象并用一个同类型的对象对它进行初始化时，将显式使用复制构造函数。当将该类型的对象传递给函数或函数返回该类型的对象时，将隐式使用复制构造函数。

在初始化的时候，如果是直接在圆括号里写参数，例如 string s(10, ‘a’)，则调用相应的构造函数，如果出现了赋值号（不知道这么说严谨不），例如 string s = “aaaa”，则先生成一个临时对象，再调用复制构造函数复制过去。

当对象作为非引用的参数传递给函数的时候，以及从函数里返回一个非引用的对象的时候，会调用复制构造函数生成一个副本。另外如果是定义了类似vector<T> v(n)之类的东西的话，会先用默认构造函数生成一个临时对象，然后用复制构造函数复制n份。

如果没有显式声明复制构造函数，编译器会自动生成一个。多数情况下这就够用了，但是有些情况下还是不行的，比如对象里面有个指针或引用而我们想实现一个deep copy的功能，或者对象里有一个不可复制的成员，这时候就要自己定制了。定制的复制构造函数和普通的构造函数没什么大区别，接受一个相同类型的引用（通常是const）作参数，推荐用初始化式进行初始化，然后在花括号里干其他的事。

如果我们想禁止对象被复制，应该写一个private的复制构造函数（不能不写，不写会自动生成），但这样的话自己的成员函数和友元还是可以调用它，进一步的方法是只声明而不实现（好强-_-）。这样的话，如果是外部调用，会编译错误，如果是自己的成员函数或友元调用，会链接错误。

重载赋值运算符时，代码的写法看上去就像把operater=当作类的一个成员函数一样，它接受一个相同类型的const引用作为参数，返回值是同一类类型的引用。注意处理好赋值给自己的情况，这种情况通常要特判一下。

如果是new出来的对象，只有在delete时才会被删除（此时调用析构函数）。如果忘了删除就会导致所谓内存泄漏。内存泄漏往往只有在程序长时间运行后内存消耗严重时才表现出来，比较难于发现。

关于智能指针：所谓智能指针是指保存了一个“引用计数”的指针，它可以避免当多个指针指向同一对象时，通过其中某个指针把对象删除了，但其他的指针并不知道，继续访问就会导致错误。通过保存一个引用计数，只有当指向这个对象的指针数为0时，才真正把对象删除。在这种情况下需要自己实现一个指针类，把原生指针包装一下，通过重写该指针类的构造、复制、析构函数实现引用计数的管理。在13章的最后给了一个很好的例子。(ps. 在boost里有标准的智能指针实现了？)