C++ 设计与声明原则

Rule18:让接口容易被正确使用，不易被误用
Make interfaces easy to use correctly and hard to use incorrectly

欲开发一个“容易被正确使用，不容易被误用”的接口，首先必须考虑客户可能做出什么样的错误。假设你为一个用来表现日期的class设计构造函数：

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

客户很容易犯下错误，比如会以错误的次序传递参数，或者传递无效的值。
可以导入新类型而获得上述情况的预防。
比如：

    struct Day    {    explicit Day(int d):val(d){}    int val;    }    struct Month    {    explicit Month(int d):val(d){}    int val;    }    struct Year    {    explicit Year(int d):val(d){}    int val;    }    class Date{    public :    Date(const Month& m,const Day& d,const Year&y);    }

• 设计class犹如设计type
  treat class design as type design
  设计一个新的类，应该带着和“语言设计者当初设计语言内置类型时”一样的谨慎态度。
  以下几个是设计时常需要面临的问题：

  • 新type的对象应该如何被创建和销毁？
  • 对象的初始化和对象的赋值该有什么样的差别？
  • 新type的对象如果被passed by value，意味着什么？记住，copy构造函数来定义一个type的pass-by-value该如何实现。
  • 什么是新type的合法值？有时候要设置数据值的约束条件，也就是说成员函数必须进行某些错误检查工作。
  • 谁该取用新的type的成员？ 这个问题可以帮助你决定哪些成员为public，protected，private。

• 宁以pass-by-reference-to-const替换pass-by-value
  默认情况下，函数参数都是以实际实参的副本为初值，而调用端所获得的亦是函数返回值的一个副本。这些副本右对象的拷贝构造函数产生，这可能使得pass-by-value成为费时的操作。
  使用 bool validateStudent(const Student& s);这种传递方式的效率高得多，没有任何构造函数或析构函数被调用，因为没有任何新对象被创建。修订后的这个参数声明中的const是重要的。因为如果是值传递，函数中对对象进行修改不会影响原对象，只会对副本做修改。现在Student以by reference方式传递，将它声明为const是必须的，因为不这样调用者会担忧validateStudent会不会改变他们传入的那个Student。
  以by reference方式传递参数也可以避免slicing（对象切割）问题。
  
  现在假设希望写个函数打印窗口名称，然后显示该窗口。

void printNameAndDisplay(Window w)    {    std::cout<<w.name();    w.display();    }

当你想调用上述函数，并传递WindowWithScrollBars对象时，参数w会被构造成为一个Windows对象，因为他是一个Window对象。 他的继承特征信息全部会被切除为基类特征。解决切割问题的办法就是以by reference-to-const的方式传递w。

• 必须返回对象时，别妄想返回其reference
  don’t try to return a reference when you must return an object
  因为有时会犯下一个致命错误：开始传递一些references指向其实并不存在的对象。
  函数创建新对象的途径有二：在stack空间或在heap空间创建之，如果定义一个local变量，就是在stack空间创建对象。比如下面代码：

    const Rational& operator*(const Rational& lhs,const Rational& rhs)     {    Rational result(lhs.n*rhs.n,lhs.d*rhs.d);    return result;    }

这个函数返回一个reference指向result。但是result是个local对象，而local对象在函数退出前被销毁了。
于是，可能会考虑在heap内构造一个对象，并返回reference指向它。heap-based对象由new创建，所以heap-based代码如下：

    const Rational& operator*(const Rational& lhs)     {    Rational* result = new Rational(lhs.n*this->n,lhs.d*this->d);    return result;    }

存在的问题是？谁该对new出来的对象实施delete操作？
上述不论on-the-stack或on-the-heap做法，都因为对operator*返回的结果调用构造函数而受惩罚。所以正确做法就是让那个函数返回一个新的对象。

inline const Rational operator *(const Rational& lhs){return Rational(this->n*lhs.n,this->d*lhs*d);}

• 将成员变量声明为private

注一下如何使用特化版本的函数模板
比如有一个函数模板如下：

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

有时我们需要特化这个函数模板，即当某一类比如叫Widget调用swap的时候不要使用原始模板的方法（这种复制操作效率有时可以进行优化，比如Widget希望自己实现，直接调换所指向的指针）
写法就像如下的形式：

namespace std{    template<>    void swap<Widget>(Widget& a,Widget &b)    {    swap(a.pImpl,b.pImpl);//若要置换Widgets就置换其pImpl指针    }}

但是，pImpl成员变量如果是私有（大多时候也是私有的），无法访问。我们：令Widget声明一个名为swap的public成员函数做真正的置换工作，然后将std::swap特化，令他调用该成员函数。

class Widget{ public: .... void swap(Widget& other){using std::swap;swap(pImpl,other.pImpl);}...};namesapce std{template<>void swap<Widget>(Widget &a,Widget &b){ a.swap(b); //若要置换Widgets，调用其swap成员函数}}