Effective C++看书笔记(4):设计与声明

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

阻止误用包括建立新类型，限制类型上的操作，束缚对象值，以及消除客户的资源管理责任。

智能指针支持定制型删除器。这可以防范DLL问题（即一个动态链接库里面new创建，却在另一个动态链接库里面delete）

19：设计class犹如设计type

没太懂。

20：宁以pass-by-reference-to-const替换pass-by-value。

默认情况都是by value传递对象。（函数参数以实参的复制副本为初值，调用端返回的也是函数返回值的一个复件）。

副本由对象的copy构造函数产出。

离开函数也会调用析构函数。

pass-by-reference-to-const可以回避构造和析构动作。

bool A(const Student& s);
1

传递效率高，没有任何构造函数或析构函数被调用，因为没有任何新对象被创建。

const是必要的，因为传的是引用，可以真正更改了，如果不需要更改就需要加上const。

副本不需要更改也不需要加const，因为本来就只能该副本

另一个好处

• 避免对象切割slicing问题（即当一个派生类对象以by value方式传递并被视为一个base class对象，base class的copy构造函数会被调用，会造成派生类被切割掉自己的部分完全变成一个基类对象。）

//函数原型
void print(Window shit)
{
    w.display();
}

//调用，会调用基类Window的display方法，而不是WindowWithScrollBars的display方法
WindowWithScrollBars w;
print(w);

//如果是这种方式就没问题
void print(const Window &w);
1
2
3
4
5
6
7
8
9
10
11
12

引用references往往以指针实现出来，所以传递引用通常是传递指针。

对象属于内置类型那么，pass by value往往比pass by reference效率高些。

STL的迭代器和函数对象也一般这样，被设计为passed by value。

不是所有小型types就用pass by value。对象小并不意味着copy构造函数不昂贵。

结论：

• 一般情况，内置类型和STL的迭代器和函数对象都pass by value。

• 其他东西一般都pass by reference to const替换。

21：必须返回对象时，别妄想返回其reference

比如计算函数里面，就必须返回结果的副本，否则返回引用，函数一结束，副本就没了。

即使这种情况，在函数里面new一个对象也不好。不要这样做。

也不要指向一个局部静态对象。

就返回一个副本

22：将成员变量声明为private

protected并不比public更具有封装性。

23：宁以non-member，non-friend替换member函数

没怎么看懂

有用：让non-member和类处于同一个命名空间内。

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

结论：如果你需要为某个函数的所有参数进行类型转换，那么这个函数必须是个non-member

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

swap将两对象的值彼此赋予对方。

典型实现

void swap(T &a,T &b)
{
    T temp(a);
    a=b;
    b=temp;
}
1
2
3
4
5
6

这些都是复制动作，对于某些类型而言，复制动作没有必要。

比如：以指针指向一个对象，内含真正数据那种类型，即pimpl，pointer to implementation。

例子：

class WidgetImpl{
    public:
    ...
        
    private:
    int a,b,c;
    std::vector<double> v;
};
1
2
3
4
5
6
7
8

class Widget{
    public:
    Widget(const Widget& rhs);
    Widget& operator=(const Widget& rhs)
    {
        ...
        *pImpl=*(rhs.pImpl);
        ...
    }
    ...
    private:
    WidgetImpl* pImpl;
};
1
2
3
4
5
6
7
8
9
10
11
12
13

实际上swap交换这些指针值即pImpl指针，但是默认的swap算法不知道这一点。

它不止复制三个Widgets，还复制三个WidgetImpl对象。效率很低。

解决办法如下

class Widget{
    public:
    ...
        
    void swap(Widget& other)
    {
        using std::swap;
        swap(pImpl,other.pImpl);
    }
    
    ...
};
1
2
3
4
5
6
7
8
9
10
11
12

namespace std{
    template<>
    void swap<Widget>(Widget& a,Widget& b)
    {
        a.swap(b);
    }
}
1
2
3
4
5
6
7