扩展1

1、必须在构造函数初始化列表里初始化的成员

1. 常量成员和引用类型：因为const常量成员和引用类型必须要初始化且不能赋值。
2. 特殊情况的对象：这个对象是一个类或结构体，并且他只有带参数的构造函数没有默认构造函数，那么一定要在初始化列表初始化（编译器无法帮助生成无参构造函数）。
3. 子类初始化父类的私有成员：必须在初始化列表调用父类的带参构造函数，如果在构造函数里面调用父类的带参构造函数，那么初始化的结果可能是个未知值。
4. 为了效率：不用初始化列表，类对自己的类成员分别进行的是一次隐式的默认构造函数的调用，和一次赋值操作符的调用。

2、函数指针，指针函数

函数指针：是一个指针，它指向一个函数的入口地址。

int print(){ return 1; }
int main(){
    int (*f1)() = print;
    int (*f2)() = &print;
    f1();
    (*f1)();
    return 0;
}

指针函数：是一个函数，它返回一个指针。

int* print(){ int a = 1;return &a; }

3、模板的特化

特化：使用模板有时会用到某些特殊类型需要特殊处理，那么就要特化出一个模板。模板特化中，template<>中不用写类型，特化函数的参数列表中的类型使用特化类型。
全特化：有一个主模板，所有类型全部被明确化。
偏特化：有一个主模板，只有部分类型被明确化，其余的靠主模板实例化。

template<typename T, typename U>    //主模板
bool isEqual(T &a, U &b){
    return sizeof(a) == sizeof(b);
}
template<>  //全特化
bool isEqual(char* &a, char* &b){
    return strncmp(a, b, sizeof(a)) == 0;
}
template<>  //偏特化
bool isEqual(string &a, U &b){
    return sizeof(a) == sizeof(b);
}

4、如何让类对象只在栈（堆）上分配空间？

静态建立对象：由编译器为对象在栈中分配内存。使用方法为，直接调用构造函数。
动态建立对象：使用new在堆中分配对象。

只在堆中：
不要直接将构造函数设为private，这样new的时候不能调用构造函数了。编译器在为对象分配栈空间时，会先查看析构函数访问性，如果是私有的就不会在栈上分配。所以把析构函数设为private。

class A{
public:
    A(){}
    static A* construct(){
        return new A();
    }
    void destroy(){
        delete this;
    }
private:
    ~A(){}
};

只在栈中：
不使用new即可，重载operator new，设为private访问。

class A{
public:
    A(){}
    ~A(){}
private:
    void* operator new(size_t t){}
    void operator delete(void* ptr){}
};

5、stdout、stderr

stdout：标准输出
stderr：标准错误
两者默认都是向屏幕输出，但是stdout可以重定向输出到磁盘文件，stderr不能。
stdout是行缓冲的，stderr是无缓冲的。

6、assert断言

assert不是一个函数，而是一个宏定义，定义在assert.h中。
assert(expression)的作用是判断表达式expression，如果为真则继续往下执行；如果为假，则向stderr输出错误信息，然后终止程序。
如果不想使用assert，那么就在#include<assert.h>前加上#define NDEBUG。

7、手写函数

char* strcat(char *dst, const char *src){
    assert(src != nullptr);
    assert(dst != nullptr);
    char *ret = dst;
    while(*dst!= '\0'){
        dst++;
    }
    while(*src != '\0'){
        *(dst++) = *(src++);
    }
    *dst= '\0';
    return ret;
}

int strcmp(const char *s1, const char *s2){
    assert(s1 != nullptr);
    assert(s2 != nullptr);
    while(*s1 != '\0' && *s2 != '\0'){
        if(*s1 < *s2){
            return -1;
        }
        else if(*s1 > *s2){
            return 1;
        }
        else{
            s1++;
            s2++;
        }
    }
    if(*s1 < *s2){
        return -1;
    }
    else if(*s1 > *s2){
        return 1;
    }
    else{
        return 0;
    }
}

参考资料

C++必须使用【初始化列表】初始化数据成员的三种情况
c++中模板的特化
《More Effective C++》条款27：如何让类对象只在栈（堆）上分配空间？