Effective C++学习笔记（第四章）

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

• 建立新的类型作为函数可以防止用户输入错误的数据，考察下面的类构造函数：

struct Date {
  Date(int day, int month, int year);
};

当用户调用构造函数时，很容易输入错误，比如将day的值当成year的值。这时候可以再创建Day，Month和Year新的数据类型：

struct Day {
  Day(int d) : val(d) {}
  int val;
};
struct Month {
  Month(int m) : val(m) {}
  int val;
};
struct Year {
  Year(int y) : val(y) {}
  int val;
};
// Date构造函数以Day，Month，Year作为输入
struct Date {
  Date(Month m, Day d, Year y);
};

• 使用共享指针（shared pointer）作为函数返回值，不仅可以避免用户忘记delete指针造成的内存泄露问题，还可以防止跨DLL delete问题。

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

设计一个class需要考虑以下问题：

• 如何创建和销毁对象
• 构造函数与赋值运算操作是否有区别
• 如果对象被值传递，涉及到哪些操作
• type的合法值
• 是否有继承关系
• 需要什么样的转换
• 什么样的操作符和函数对此新的type是合理的
• delete掉哪些操作
• 成员哪些为public，哪些为private
• type的泛化性，是否定义一个具体的class还是一个class template
• 是否真的需要定义一个新的type，是否可以通过已有type组合达到目的。

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

• 以引用方式传递参数通常比值传递方式更加高效，而且还可以避免对象切割问题。
• 内置类型一般以值传递比较合理，不适用此规则。

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

• 如果返回的是一个函数内部的局部对象，则切勿以引用方式返回，因为函数返回后，该局部对象将会被析构。

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

• 将成员变量设置为private能够提供更好的封装性。
• protected变量并不比public更具封装性。

条款23：宁以Non-member、Non-friend函数替换member函数

• 考察一个类中的成员函数，如果它的实现中不是必须要用类中的私有成员变量，则建议将此函数不要作为类的成员函数，而是以独立的函数形式呈现，函数的参数输入即是该类的对象。

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

• 数据举了一个复数相乘的例子：

class R {
public:
  const R operator*(const R& rhs) const;
};
R r1;

R r2 = r1 * 2; // 编译OK
R r3 = 2 * r1; // 此时编译不通过

编译不通过的语句中，“2”如果在*号前面则不能进行隐式转换为一个R对象。
这时候，采用一个non-member的操作符就比较合适了。

const R operator*(const R& lhs, const R& rhs)
{
  ...
}

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

• 在std空间内有一个默认的swap函数模板，它的定义如下：

namespace std {
template 
void swap(T& a, T& b)
{
    T tmp(a);
    a = b;
    b = tmp;
}
}

这里需要T类型对象支持operator = 操作。
考察以下类，如果我们要对其两个对象进行swap操作，将会出现一点效率的问题：

class MyImpl {
public:
private:
  std::vector myVec;
};
class MyClass {
public:
  MyClass& operator=(MyClass& rhs) 
  {
    ...
    *(pImpl) = *(rhs.pImpl);
    ...  
}
private:
  MyImpl *pImpl;
};

MyClass obj1, obj2;

std::swap(obj1, obj2);  // 产生额外的拷贝操作，效率非常低

如果我们此时调用std::swap函数对MyClass对象进行交换操作时，则会导致数据的拷贝，并且并没有达到交换的目的。

此时需要在MyClass类中提供一个swap成员函数，实现真正的交换功能：

class MyClass {
public:
  void swap(const MyClass& rhs) 
  {
    std::swap(pImpl, rhs.pImpl);
  }
};

接下来就需要对std空间内的swap函数针对MyClass类进行特例化：

namespace std {
template <>   // 这里为空代表是对swap模板进行特例化
void swap(MyClass& a, MyClass& b) noexcept
{
    a.swap(b);
}
}

int main()
{
  MyClass obj1, obj2;
  
  std::swap(obj1, obj2); // 调用上述特例化的版本，并且调用MyClass类中的swap成员函数，达到真正交换的目的。

  return 0;
}