【effective c++】设计与声明

1.让接口容易被正确使用，不易被误用

避免无端与内置类型不兼容，提供行为一致的接口

2.设计class犹如设计type

3.以pass-by-reference-to-const替换pass-by-value

pass-by-reference-to-const比较高效（避免了copy构造），当一个派生类对象（实参）以by value方式传递给一个基类对象形参时，基类的copy构造函数会被调用，会发生对象切割，只保留派生类对象的基类部分，而pass-by-reference-to-const可避免这个问题

以上规则不适用于内置类型，以及stl的迭代器和函数对象，对它们而言，pass-by-value比较适当

4.必须返回对象时，别妄想返回其reference

绝不要返回pointer或reference指向一个local stack对象(函数退出前对象已被销毁)，或返回reference指向一个heap-allocated对象(内存泄漏)，或返回pointer或reference指向一个local static对象而又可能同时需要多个这样的对象(此时这些对象其实是同一个对象)

const Rational& operator* (const Rational &lhs, const Rational &rhs) {
    static Ratioal result;
    // 计算result操作
    return result;
}

上述函数返回local static 对象，避免发生拷贝构造操作，但是凡是调用该函数返回的都是同一个static变量

5.将成员变量声明为private

主要是考虑到封装性

6.以non-member、non-friend替换member函数

愈多函数可访问数据，数据的封装性就愈低，故以non-member&&non-friend函数替换member函数(两函数提供相同的功能)，可增加封装性

将所有便利函数(即工具类函数)放在多个头文件内但隶属同一个命名空间，意味客户可以轻松扩展这一组便利函数(机能扩充性)，允许客户只对他们所用的那一部分头文件形成编译依赖关系

7.若所有参数皆需类型转换，请为此采用non-member函数

class Rational
{
public:
    Rational(int a = 0, int b = 1):numerator(a),denominator(b){}
    int getNumerator() const
    {
        return numerator;
    }
    int getDenominator() const
    {
        return denominator;
    }
    const Rational operator*(const Rational &rhs) const
    {
        return Rational(numerator * rhs.numerator, denominator * rhs.denominator);
    }
private:
    int numerator;
    int denominator;
};

int main()
{
    Rational oneEight(1, 8);
    Rational res = oneEight * 2;//隐式类型转换，Rational的构造函数被调用，若构造函数为explicit，则无法隐式转换
    cout << res.getNumerator() << " " << res.getDenominator() << endl; //输出2，8
    res = 2 * oneEight;//编译出错

    system("pause");
    return 0;
}            

只有当参数被列于参数列内，这个参数才是隐式类型转换的合格参与者，地位相当于"被调用之成员函数所隶属的那个对象"即this对象的那个隐喻参数，绝不是隐式转换的合格参与者

class Rational
{
public:
    Rational(int a = 0, int b = 1):numerator(a),denominator(b){}
    int getNumerator() const
    {
        return numerator;
    }
    int getDenominator() const
    {
        return denominator;
    }
private:
    int numerator;
    int denominator;
};

const Rational operator*(const Rational &lhs,const Rational &rhs)
{
    return Rational(lhs.getNumerator() * rhs.getNumerator(), lhs.getDenominator() * rhs.getDenominator());
}


int main()
{
    Rational oneEight(1, 8);
    Rational res = oneEight * 2;
    cout << res.getNumerator() << " " << res.getDenominator() << endl; //输出2，8
    res = 2 * oneEight;
    cout << res.getNumerator() << " " << res.getDenominator() << endl; //输出2，8

    system("pause");
    return 0;
}              

8.考虑写出一个不抛异常的swap函数

标准程序库提供的swap算法的典型实现：

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

对于“以指针指向一个对象，内含真正数据”的类型(pimpl手法：pointer to implementation),若置换两个对象值，只需要置换其pimpl指针，缺省的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;
};

// 可以将std::swap针对Widget特化
// 编译出错，pImpl是Widget的private成员变量
template<>
void swap<Widget>(Widget &a, Widget &b) {
    swap(a.pImpl, b.pImpl);
}

// 可以令Widget声明一个swap的public成员函数做真正的置换工作，然后将std::swap特化，令它调用该成员函数
class Widget {
public:
    void swap(Widget &other) {
        using std::swap;
        swap(pImpl, other.pImpl);
    }
};

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

所有STL容器都提供有public swap成员函数和std::swap特化版本，用以调用前者

http://www.cnblogs.com/ljygoodgoodstudydaydayup/p/4213384.html