Effective C++

目录

规则2：尽量使用const、enum、inline替换#define

　　1、使用const替换#define

　　2、定义一个类的专属常量：在类内使用const和static

　　　　需要在实现文件中再定义一次已经在类内声明了的static变量

　　3、使用inline定义内联函数，替换#define

规则3：尽量可能使用const

　　1、const用于指针中

　　2、const用于STL中的迭代器中

　　3、令函数返回一个const对象，往往可以避免客户因为错误使用而造成的意外，如下面的代码:

　　4、const类内成员函数：在函数的参数列表后加上一个const---mutable引入

　　　　使用const_cast为对象去掉const属性和使用static_cast为对象加上const属性的方法

规则2：尽量使用const、enum、inline替换#define

　　1、使用const替换#define

#define ASPECT_RATIO 1.653  //大写常用语宏，但是每次出现ASPECT_RATIO的地方，预处理器都会盲目的将ASPECT_RATIO替换为1.653,导致目标代码出现多个1.653
const double AspectRatio = 1.653;  //此时在目标代码中只出现一个存储1.653的地方

　　2、定义一个类的专属常量：在类内使用const和static

class GamePlayer{
private:
    static const int NumTurns = 5;  //static确保了所有类对象共享NumTurns(NumTurns只有一份)、const确保了NumTurns不可以被修改
    int scores[NumTurns];
};  //放在头文件中

需要在实现文件中再次定义在类中已经声明了的static变量的情况：

上面是NumTurns的声明式而非定义式。通常C++要求你给任何东西提供一个定义式，但如果它是一个类内static、const变量，只要不取它的地址，则可以声明并使用它而无需提供定义式。但是你需要取它的地址或编译器不明确的简直要看到一个定义式，那么需要提供下面的定义式：

class GamePlayer{
private:
    static const int NumTurns;  
    int scores[NumTurns];
};  //放在头文件中
const int GamePlayer::NumTurns = 5;  //NumTurns的定义式，放在实现文件而非头文件中,在定义式中获得初值

上述代码存在的问题：万一你的编译器错误的不允许类内static、const变量完成初值设定，而此时类内的scores需要使用该变量以确定数组内元素的个数，此时可以使用枚举：

class GamePlayer{
private:
    enum {NumTurns = 5};    //注意此时NumTurns是一个枚举，此时对NumTurns取地址是不合法的
    int scores[NumTurns];
};  //放在头文件中

　　3、使用inline定义内联函数，替换#define

引入：

#define CALL_WITH_MAX(a,b) f((a) > (b) ? (a) : (b))  //f是只带一个参数的函数
int a = 5, b = 0;
CALL_WITH_MAX(++a,b);    //在判断(++a) > (b)的时候a被累加一次，发现成立，然后再执行(++a)，并将++a的结果做为f的参数。即a被累加了两次
CALL_WITH_MAX(++a,b+10); //在判断(++a) > (b)的时候a被累加一次，发现不成立，然后将b做为f的参数。即a被累加了一次

在调用函数f之前，a的递增此时居然取决于它被拿来和谁比较，可以使用内联函数和模板来代替：

template<typename T>
inline void callWithMax(const T & a, const T & b){
    f(a > b ? a : b);
}

规则3：尽量可能使用const

　　1、const用于指针中

char greeting1[] = "Hello";
char greeting2[] = "GoodMorning";
char* p = greeting1;              //non-const pointer(p可以改变指向,p=greeting2合法),non-const data(p[0]='G'合法)
const char* p = greeting1;        //non-const pointer(p可以改变指向,p=greeting2合法),const data(p[0]='G'不合法)
char* const p = greeting1;        //const pointer(p不可以改变指向,p=greeting2不合法),non-const data(p[0]='G'合法)
const char* const p = greeting1;  //const pointer(p不可以改变指向,p=greeting2不合法),non-const data(p[0]='G'不合法)

其中const char* p = greeting1; 也可以写成：

char const * p = greeting1;

　　2、const用于STL中的迭代器中

const用于迭代器表示这个迭代器不可以指向不同的东西，但是它指向的东西是可以改变的，例如：
std::vector<int> vec;
...
const std::vector<int>::iterator iter = vec.begin();  //表示iter只可以指向vec容器内的第一个元素，不可以指向其他的元素，但是iter指向的元素本身是可以被改变的
*iter = 10;  //合法                                   //等价于T* const (char* const)
++iter;      //不合法

如果你希望迭代器所指向的东西不可以被改变，那么可以使用const_iterator:

std::vector<int> vec;
...
const std::vector<int>::const_iterator iter = vec.begin();  //等价于const T* (const char*)
*iter = 10;  //不合法
++iter;      //合法

　　3、令函数返回一个const对象，往往可以避免客户因为错误使用而造成的意外，如下面的代码:

class Rational{...};
const Rational operator*(const Rational & lhs, const Rational & rhs);

返回一个const Rational类对象的原因是避免客户出现下面的错误：

int main(){
     Rational a,b,c;
     ...
     (a*b)=c; 
     (a*b)将调用operator*()函数，然后返回一个const类型的Rational类对象，然后将c赋给该const Rational类对象是不合法的！  
}

需要补充个的知识点：

const int num = 5;
num = 6;  //不合法！！

　　4、const类内成员函数：在函数的参数列表后加上一个const

4.1两个成员函数如果只是常量性不同，则可以被重载，举例如下：

class TextBlock{
public:
    ....
    const char & operator[](std::size_t position) const{  //类内const成员函数
        return text[position];
    }
    const char & operator[](std::size_t position){             //类内non-const成员函数
        return text[position];
    }
private:    
    std::string text;
};

int main(){
    TextBlock tb("Hello");
    std::cout << tb[0];          //调用类内non-const成员函数
    
    const TextBlock ctb("Hello");
    std::cout << ctb[0];         //调用类内const成员函数
    
    return 0;
}

上面的这个例子有点造作，下面的这个例子才是真实环境下的类内const成员函数使用方法：

void print(const TextBlock & ctb){
    std::cout << ctb[0];        //调用类内const成员函数
    ...
}

对于上面的代码，将私有变量原型的类型string改为char*，在类外使用一个指针指向了类内成员变量，那么就有可能修改该const对象中的变量，如下面的代码：

class CTextBlock{
public:
    ....
    const char & operator[](std::size_t position) const{  //类内const成员函数
        return text[position];
    }
    const char & operator[](std::size_t position){             //类内non-const成员函数
        return text[position];
    }
private:    
    char* pText;
};
int main(){
    const CTextBlock cctb("Hello");
    char* pc = &cctb[0];
    *pc = 'J';              //此时cctb类对象中的*pText=Jello
    
    return 0;
}

上面的程序表明，你创建了一个常量对象并设以初值，并对它只调用const成员函数，但是你最终还是改变了它的值。

写到这里，需要停下来思考一个问题：成员函数如果是const意味着什么？
bitwise constness学派认为：不可以更改对象中任何成员变量(static变量除外)才可以说是const成员函数；
logical constness学派认为：在编译器侦测不出来的情况下，可以修改对象内的某一位，使编译器侦测不来的方法是使用mutable。

不符合bitwise constness观点的代码：

class CTextBlock{
    
    std::size_t length() const;
private:
    char* pText;
    std::size_t textLength;   //需要在length()类内修改，但是不符合bitwise constness观点
    bool lengthIValid;        //需要在length()类内修改，但是不符合bitwise constness观点
};
std::size_t CTextBlock::length() const{
    if(!lengthIValid){
        textLength = std::strlen(pText);   //在const成员函数内修改了类成员，不符合bitwise constness观点
        lengthIValid = true;               //在const成员函数内修改了类成员，不符合bitwise constness观点
    }
    return textLength;
}

由于不符合bitwise constness观点，以上代码会出现编译错误，使用mutable关键字修改类内需要在const成员函数内修改的类成员变量，修改方法如下：

class CTextBlock{
    
    std::size_t length() const;
private:
    char* pText;
    mutable std::size_t textLength;   //需要在length()类内修改，故将textLength声明为mutable变量
    mutable bool lengthIValid;        //需要在length()类内修改，故将textLength声明为mutable变量
};
std::size_t CTextBlock::length() const{
    if(!lengthIValid){
        textLength = std::strlen(pText);   //在const成员函数内修改了mutable类成员textLength，是合法的
        lengthIValid = true;               //在const成员函数内修改了mutable类成员lengthIValid，是合法的
    }
    return textLength;
}

4.2 const和non-const成员函数避免重复

如下面的代码，存在代码重复的问题：

class TextBlock{
public:
    ....
    const char & operator[](std::size_t position) const{       //类内const成员函数
        ...                     //边界检验
        ...                     //数据访问
        ...                        //数据完整性检验
        return text[position];
    }
    const char & operator[](std::size_t position){             //类内non-const成员函数
        ...                     //边界检验
        ...                     //数据访问
        ...                        //数据完整性检验
        return text[position];
    }
private:    
    std::string text;
};

于是在const operator[]()中和non-const operator[]()成员函数中，存在着代码重复的问题，解决方法是在non-const operator[]()成员函数中调用const operator[]()，那么就需要为该对象加上const属性，然后调用const operator[]()函数，最后再去掉const属性。其中为对象加上const属性方法是使用static_cast,为对象去掉const属性方法是使用const_cast,修改方法如下：

class TextBlock{
public:
    ....
    const char & operator[](std::size_t position) const{       //类内const成员函数
        ...                     //边界检验
        ...                     //数据访问
        ...                        //数据完整性检验
        return text[position];
    }
    char & operator[](std::size_t position){             //类内non-const成员函数
        return 
            const_cast<char &>(                    //3、将const operator[]()函数返回值的const属性去掉
                static<const TextBlock &>(*this)   //1、由于调用的是non-const属性的operator[]()，所以*this的原型是TextBlock &,无const属性，所以static<const TextBlock &>(*this)为*this加上const属性
                    [position]                     //2、调用const operator[]()
            );
    }
private:    
    std::string text;
};

为何不可以使用const成员函数调用non-const成员函数？
const成员函数承诺不修改类内变量，但non-const成员函数没有这样的承诺，如果使用const成员函数调用non-const成员函数就有可能发生在const成员函数中修改某一个类内变量是非法的，但是跑到non-const去修改该类内变量就是合法的了。