Effective C++读书笔记四(设计与声明)

迈不过友情╰ 2022-05-16 02:14 269阅读 0赞

### 条款18：让接口容易被正确使用，不易被误用 ###

如果客户企图使用某个接口而却没有获得他所预期的行为，那么这个代码就不该通过编译；如果代码通过了编译，它的所作所为就应该是客户想要的。  
要是想开发一个“容易被正确使用，不容易被误用”的接口，首先必须考虑客户有可能做出什么样的错误。来看个例子：

class Date
    {
    public:
        Date(int month, int day, int year);
        ...
    };

乍见之下这个接口没有什么问题，但它的客户很容易犯下至少两个错误。

*  他们也许会以错误的次序传递参数：  
    
    
     *  Date d(30, 3, 1995); //应该是“3,30”而不是“30,3”
 *  他们可能传递一个无效的月份或天数  
    
    
     *  Date d(2, 30, 1995); //应该是“3,30”而不是“2,30”

许多客户端错误可以因为导入新类型而获得预防。我们可以导入简单的外覆类型来区别天数、月份和年份，然后于Date构造函数中使用这些类型，如下：

struct Day
    {
        explicit Day(int d)
            :val(d) {}
        int day;
    };
    struct Month
    {
        explicit Month(int m)
            :val(m) {}
        int val;
    };
    struct Year
    {
        explicit Year(int y)
            :val(y) {}
        int val;
    };
    class Date
    {
    public:
        Date(const Month& m, const Day& d, const Year& y);
        ...
    };
    Date d(30, 3, 1995);                    //错误！不正确的类型
    Date d(Day(30), Month(3), Year(1995));  //错误！不正确的类型
    Date d(Month(3), Day(30), Year(1995));  //OK，类型正确

我们也可以令Day,Month和Year成为类并封装其数据，比简单的使用上面例子中的struct要好。  
防止客户错误的另一个办法是，限制类型内什么事可做，什么事不可做。常见的限制是加上const。  
下面是另一个一般性准则“让types容易被正确使用，不容易被误用”的表现形式：“除非有好理由，否则应该尽量令你的types的行为与内置types一致”。就是说，客户已经知道了int这样的类型有什么行为，那么你应该让你的类型在合情合理的前提下也有相同表现。  
避免无端与内置类型不兼容，真正的理由是为了提供行为一致的接口。例如STL容器的接口十分一致(虽然不是完美一致)，这使它们非常容易被使用。  
任何接口如果要求客户必须记得做某些事情，就是有着“不正确使用”的倾向，因为客户很可能会忘记做那件事。  
shared\_ptr有一个特别好的性质：它会自动使用它的每个指针专属的删除器。

### 条款19：设计class犹如设计type ###

C++就像其他面向对象编程语言一样，当你定义一个新的class，也就定义了一个新的类型。  
**1、新type的对象应该如何被创建和销毁？**

这会影响到你的类的构造函数和析构函数以及内存分配函数和释放函数的设计

**2、对象的初始化和对象的赋值该有什么样的差别？**

这决定了你的狗战士和赋值运算符重载的行为以及其间的差异。很重要的是别混淆了“初始化”和“赋值”，因为它们对应于不同函数调用

**3、新type的对象如果被以值传递，意味着什么？**

记住，拷贝构造函数用来定义一个类型的值传递该如何实现

**4、什么是新type的“合法值”？**

对class的成员变量而言，通常只有某些数值集是有效的。那些数值集决定了你的类必须维护的约束条件，也就决定了你的成员函数必须进行的错误检查工作。它也影响函数抛出异常

**5、你的新type需要配合某个继承图系吗？**

如果你继承自某些已经存在的类，你就受到那些类设计的束缚，特别是类中的函数是virtual还是non-virtual的。如果你允许其他类继承你的类，那你最好将自己的析构函数声明为virtual的

**6、你的新type需要什么样的转换？**

你的类生存于其它类型之间，因而彼此该有转换行为吗？如果你允许类型T1被隐式转换为T2，就必须在class T1内实现一个类型转换函数或者在class T2中四线一个可以被单一实参调用的构造函数。如果你只允许explicit构造函数存在，就得写出专门负责执行转换的函数。

**7、什么样的操作符和函数对此新type而言是合理的？**

这将决定你将为你的类声明哪些函数

**8、什么样的标准函数应该驳回？**

这些正是你必须声明为private者

**9、谁该取用新type的成员？**

这将决定了哪个成员为public，哪个为protected，哪个为private。也决定了哪一个类和函数应该是友元的，以及将它们嵌套与另一个是否合理

**10、什么是新type的“未声明接口”？**

你在效率、异常安全性以及资源运用方面提供的保证，将为你的类实现代码加上相应的约束条件

**11、你的新type有多么一般化？**

或许你其实并非定义了一个新的类型，而是定义一整个类型家族，那么你就不该定义一个新的类，而应该定义一个新的类模板

### 条款20：宁以pass-by-reference-to-const替换pass-by-value ###

缺省情况下C++以传值方式传递对象至函数。除非你特别指定，否则函数参数都是以实参的拷贝为初值，而调用端所获得的也是函数返回值的一个拷贝。这些拷贝由对象的拷贝构造函数产生。来看个例子：

class Person
    {
    public:
        Person();
        virtual ~Person();
        ...
    private:
        string name;
        string address;
    };
    class Student:public Person
    {
    public:
        Student();
        ~Student();
        ...
    private:
        string schoolName;
        string schoolAddress;
    };
    bool validataStudent(Student s);    //函数以值方式接受学生
    Student plato;                            
    bool platoIsOK = validataStudent(plato);

当上述函数被调用时，会发生什么呢？  
Student的拷贝构造函数会被调用，用plato去初始化s，然后当validataStudent函数返回，s会被销毁。所以相当于一次Student的拷贝构造调用，一次Student的析构函数调用。  
再看一下，Student类中包含两个string成员变量，并且还继承了Person类，而Person类中也有两个string成员变量。所以我们算一下，以值传递的方式传递一个Student对象我们需要调用：一次Student的拷贝构造调用，一次Person的拷贝构造，四次string的拷贝构造。  
而且当函数调用结束，同样的还有六次的析构函数被调用！！！

bool validataStudent(const Student& s);

但是当我们以引用传递，没有任何构造函数或析构函数被调用，因为没有任何新的对象被创建。修订后的这个参数的const是比较重要的，当我们以值传递的形式传递参数时，不用担心函数内部会改变它，但传引用的时候就需要考虑参数被修改的情况  
传引用也可以避免对象切割问题。当一个派生类对象以值方式传递并被视为一个基类对象，基类的拷贝构造函数会被调用。将只留下一个基类对象。  
引用往往以指针实现出来，因此传引用真正传递的其实是指针。但当你有个内置类型，或者STL的迭代器和函数对象。对他们而言传值往往比较恰当。

### 条款21：必须返回对象时，别妄想返回其引用 ###

我们认识了传值和传引用之后，一定要注意一个问题：不要开始传递一些引用指向其实并不存在的对象，这可不是一件好事。来看个例子：

class Rational
    {
    public:
        Rational(int num=0, int den=1);
    private:
        int num;  //分子
        int den;  //分母
    friend const Rational operator*(const Rational& lhs,const Rational& rhs);
    };

这个版本的operator\* 是以传值的方式返回结果的。我们可能会想到这样我们返回对象的构造和析构成本怎么办。所以将它改为传递引用。但是记住，所谓引用只是一个别名，代表某个已有的对象。任何时候看到一个引用声明式，你都应该立刻想到它的另一个名称是什么。就像我们的operator\*函数，如果它返回一个引用，后者一定指向某已经有的Rational对象。  
我们当然不希望这样一个Rational对象在调用该函数调用之前就存在。也就是说如果operator\*要返回一个引用，那它必须自己创建一个对象。  
函数创建新对象有两种途径：在栈空间或者在堆空间创建。如果定义一个局部变量，就是在栈空间创建对象。

const operator*(const Rational& lhs,const Rational& rhs)
    {
        Rational res(lhs.num*rhs.num, lhs.den*rhs.den);
        return res;
    }

但是这样是不行的。因为你的目的是避免调用构造函数，可是你新创建的局部变量res却必须调用构造函数，而且因为它是个局部变量，当你返回它的引用时，它就会被销毁。你的引用就指向了一块销毁掉的空间。  
所以再来尝试一下在堆上创建对象：

const Rational operator*(const Rational& lhs, const Rational& rhs)
    {
        Rational* res = new Rational(lhs.num*rhs.num, lhs.den*rhs.den);
        return res;
    }

可以看出来，你还是需要调用构造函数，因为你分配所得到的内存需要构造函数来初始化。而且你还面临着一个问题，你new出来的这个对象，该被谁delete呢？就好像下面的例子：

Rational w, x, y, z;
    w = x * y * z;

相当于调用了两次operator\*，也就是用了两次new。也就需要两次delete。可是没有合理的方法让operator\*使用者取得返回引用背后的那个真正的指针。绝对会存在内存泄漏。  
或许这个时候有人会想到那返回一个引用，指向一个被定义于函数内部的static Rational对象。直接说把，这样也是不行的，首先就是多线程安全问题，其次，如果你调用operator\*，确实会改变static Rational对象值，但由于返回的都是引用，所以调用端看到的永远是你内部的static对象值的现值。  
一个“必须返回新对象”的函数写法就是：就让这个函数返回一个新对象呗。虽然有了构造和析构的成本，但总不至于出错

### 条款22：将成员变量声明为private ###

先来看看public成员变量，为什么不采用？  
如果成员变量不是public。用户唯一能够访问对象的方法就是通过成员函数。如果public接口内的每样东西都是函数，客户就不需要在打算访问类成员时迷惑的试着记住是否该使用圆括号。  
使用函数可以让你对成员变量的处理有更精确的控制。如果你令成员变量public，每个人都可以读写它。但是如果你利用函数取得或设定其值，你就可以实现出“不准访问”、“只读访问”等等。因为许多成员变量应该被隐藏起来。  
还有就是“封装”了。如果你通过函数访问成员变量，之后可以更改某个计算替换这个成员变量，而类的用户一点也不会指定类的内部实现发生了变化。  
将成员变量隐藏在函数接口的背后，可以为“所有可能的实现”提供弹性。例如，这可使得成员变量被读或被写时轻松通知其他对象、可以验证类的约束条件以及函数的前提和事后状态、可以在多线程环境中执行同步控制等等。  
protected成员变量也是类似的，它在“语法一致性”、“细微划分访问空间”和“封装”上同样不好。别忘了protected成员所以派生类是可以访问的。  
所以最好将成员变量声明为private

### 条款23：宁以non-member、non-firend替换member函数 ###

来看个例子：

class WebBrowser
    {
    public:
        ...
        void clearCache();
        void clearHistory();
        void removeCookies();
        ...
    };

这个类用来表示网页浏览器。其中的函数用来清除下载元素高速缓存区、访问过的URL的历史记录，移除系统中的Cookies。  
我们可能会想着执行所有的动作，所以还有这样一个函数：

class WebBrowser
    {
    public:
        ...
        void clearEverything();    //内部调用上面三个函数
        ...
    };

当然，除了将它写在类中，我们还可以用一个非成员函数来封装这些函数，那么那种方法好呢？

面向对象守则要求，数据以及操作数据的那些函数应该被捆绑在一起，这意味它建议成员函数是较好的选择。但这是不对的，面向对象守则要求数据应该尽可能被封装，然而与直观相反地，成员函数clearEverything的封装性没有非成员函数好。来看看原因。  
先来谈谈封装：如果有些东西被封装，它就不再可见。越多东西被封装，越少人可以看到它，而如果越少的人看到它，我们就有越大的弹性去改变它，因为我们的改变仅仅影响的是那些可以看到它的人。这就是封装的好处了。  
再来看看对象内的数据：越少的代码可以看到数据，也就是访问它，越多的数据就可被封装，而我们就越能自由的改变对象数据。如何测试有多少代码可以看到某一块数据呢？答案就是，越多函数可访问它，也就是可以看到它，从而数据的封装性就越低。  
之前条款22曾说过，成员变量应该是private的，能访问private成员变量的就只有类的成员函数和友元函数了。如果现在有一个类成员函数和非成员，非友元的函数，它们有着相同的功能，那么有较好的封装性的就是非成员，非友元的函数，因为它不能去访问私有成员变量，这也就解释了刚刚的问题、  
注意：只因在意封装性而让函数成为类的非成员函数并不意味着它不可以是另一个类的成员函数。

### 条款24：若所有参数皆需类型转换，请为此采用non-member函数 ###

之前说到过一个有理数类的例子：

class Rational
    {
    public:
        Rational(int num=0, int den=1);
        int num()const;    //分子访问函数
        int dev()const;    //分母访问函数
    private:
        ...
    };

现在为了实现有理数相乘，你实现了operator\*，先实现为成员函数来看看

class Rational
    {
    public:
        ...
        const Rational operator*(const Rational& rhs)const;
    };

这样两个有理数就可以相乘了，还想做到混合运算怎么办？

Rational result = oneHalf * 2;   //正确
    reault = 2 * oneHalf;            //错误

乘法应该满足交换律啊，这样为什么不行，来看看真正的函数调用

result = oneHalf.operator*(2);
    result = 2.operator*(oneHalf);

显然，2没有相应的class更没有operator\*这个函数。编译器可能还会找这样的函数是否存在，虽然本例中没有。

result = operator*(2, oneHalf);

可能有人会有疑问，operator\*函数第二个参数需要的是Rational对象，为什么整数2可以呢？因为这里发生了隐式类型转换。编译器知道你传递了一个int，而函数需要的是Rational对象，他还知道只要调用Rational的构造函数，就可以变出一个适当的Rational对象。  
那第二个为什么不可以呢？因为只有当参数被列于参数列表内，这个参数才是隐式类型转换的合格参与者。第二个显然不是  
现在让我们把这个函数实现成非成员函数：

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

再试一下刚刚的两个例子，就会发现可以编译通过了。  
注意：不能够只因函数不该成为成员函数，就自动让它成为友元。就像上面的例子，如果将函数实现为友元函数也是不可以的。

## 条款25：考虑写出一个不抛异常的swap函数 ##

template<typename T>
    void swap(T& a, T& b)
    {
        T temp(a);
        a = b;
        b = temp;
    }

这是缺省情况下swap函数的实现，只要T支持拷贝，缺省的swap就会帮你交换，那下面这个例子呢？

class WidgetImpl
    {
    public:
        ...
    private:
        int a,b,c;
        vector<double> v;
        ...
    };
    class Widget
    {
    public:
        Widget(const Widget& rhs);
        Widget& operator=(const Widget& rhs)
        {
            ...
            *pImpl = *(rhs,pImpl);
            ...
        }
    private:
        WidgetImpl* pImpl;
    };

如果我们需要置换两个Widget对象的值，而实际上是需要交换这两个对象内部的pImpl指针。而我们的swap不但会复制三个对象，还会复制三个指针对象，显然缺乏效率  
我们需要自己在类中实现一个只交换指针的public版本：

class Widget
    {
    public:
        ...
        void sawp(Widget& other)
        {
            using std::swap;      //这个声明必须需要，稍后解释
            swap(pImpl,other.pImpl);
        }
        ...
    };
    namespace std    //std::swap的特化版本
    {
        template<>
        void swap<Widget>(Widget& a, Widget& b)
        {
            a.swap(b);
        }
    }

C++只允许对类模板偏特化，不能对函数模板偏特化。如果你打算偏特化一个函数模板，通常的做法是为它添加一个重载版本的。  
一般而言重载函数模板没有问题，但是std是个特殊的命名空间，客户可以全特化std内的模板，但是不可以添加新的模板到std里。那该怎么办呢？我们还是声明一个非成员函数，让它调用成员函数swap，但不在将那个非成员函数声明为std::swap的特化版本或重载版本

namespace Widget
    {
        ...
        template<typename T>
        class Widget{
       ...};
        ...
        template<typename T>
        void swap(Widget<T>& a, Widget<T>& b)
        {
            a.swap(b);
        }
    }

现在，只要我们想交换两个Widget对象，都会找到它的专属版本。如果你想让你的类专属版swap在尽可能多的情况下被调用，你需要在该类所在的命名空间内写一个非成员函数版本以及一个std::swap特化版本。  
总结：  
如果swap缺省实现对你的类或类模板提供可接受的效率，你不需要额外做任何事。其次，如果swap缺省实现办的效率不足试着做以下事情

*  提供一个public swap成员函数
 *  在你的类或模板所在的命名空间内提供一个非成员swap函数，并在它内部调用上述swap成员函数
 *  如果你正编写一个类，为你的类特化std::swap，并让它调用你的swap成员函数

最后的劝告：成员版swap绝不可抛出异常。那是因为swap的一个最好的应用就是帮助类提供强烈的异常安全性保障。这个约束只适用于成员版本的！不可适用于非成员版！因为swap缺省版本是以拷贝构造函数和赋值运算符重载为基础的，而一般情况下两者都允许抛出异常。所以当你写一个自带版本的swap，往往提供的不只是高效交换对象的方法，还不能抛出异常。