条款18：让接口容易被正确使用，不容易被误用
- 注意使用const，explicit，shared_ptr等来限制接口。
- 必要时可以创建一些新的类型，限制类型操作，束缚对象等。
- 注意保持接口的一致性，且与内置类型的行为兼容。
class Month {
public:
static Month Jan(){return Month(1);}
static Month Feb(){return Month(2);}
...
static Month Dec(){return Month(12);}
private:
explicit Month(int m) : val(m){}
int val;
};
条款19：设计class犹如设计type
- 对象的创建和销毁
- 对象的初始化和赋值
- 对象被以值传递（pass by value）
- 有效的对象
- class中一些成员变量是受约束的，决定了成员函数（特别是构造函数，赋值操作符和所谓的"setter"函数）必须进行检查工作。
- 新type用于继承中
- 继承自现有classes，就会受到这些classes的束缚，特别是受它们"virtual"和"non-virtual"成员函数的影响。
- 被继承，要考虑所声明的函数（特别是析构函数）是否为virtual
- 新type的转换
- 类型T1隐式转换为类型T2，可在class T1中写一个类型转换函数（operator T2() const）或在class T2中写一个构造函数（T2(T1)）
- 为type设计合理的操作符和函数
- 一些函数要被驳回不可调用（设置为private）
- 判断定义的type是否过于泛化
- 判断是否真的需要定义新的type
- 可写成新的drive class，non-member，templates以取代
条款20：宁以pass-by-reference-to-const替换pass-by-value
- 尽量以pass-by-reference-to-const替换pass-by-value，效率高效，可以避免对象切割问题。
- 对于内置类型，STL迭代器，和函数对象，"pass-by-value并不昂贵"，采用pass-by-value更合适(其实采用pass-by-reference-to-const也可以)。
条款21：必须返回对象时，别妄想返回其reference
- 不要返回pointer或者reference指向一个on stack对象
- 不要返回pointer或者reference指向一个on heap对象
- 需要用户delete，可以选择返回shared_ptr
- 不要返回pointer或者reference指向local static对象
- static只能有一份，但可能返回多个对象
- 确保只用一份时可以使用
以上约束在必要时可以违背，非绝对。
条款22：将成员变量声明为private
- 切记将成员变量申明为private
- protected并不比public更有封装性(用户可能继承你的base class)
条款23：宁以non-member、non-friend替换member函数
- 多一个成员函数，就多一分破坏封装性
- 当non-member与member函数实现相同功能时，使用non-member函数
- 尽量不要用友元
条款24：若所有参数皆需要类型转换，请为此采用non-member函数
- 如果要求成员函数要对this指针所指的自身对象进行类型转换，那么只能将这个函数改为非成员函数
- 其实质上是member函数没有办法转换this指针所指自身对象的类型
- 也尽量不要用友元会破坏封装性的
条款25：考虑写出一个不抛出异常的swap函数
- std::swap调用copy构造函数和赋值操作符，效率较低，因此可以自己提供swap函数
namespace std {
template<typename T>
void swap(T& a, T& b) {
T temp(a);
a = b;
b = temp;
}
}
- classes 可以提供一个member swap，再提供一个特化std::swap用来调用前者
#include <iostream>
#include <string>
#include <vector>
class WidgetImpl {
public:
WidgetImpl( int _a, int _b, int _c, std::vector<double> _v) :
a(_a), b(_b), c(_c), v(_v) {}
int geta(){return a;}
private:
int a, b, c;
std::vector<double> v;
};
class Widget {
public:
Widget(WidgetImpl* _p) : pImpl(_p) {}
Widget(const Widget& rhs) {
*pImpl = *(rhs.pImpl);
}
void swap(Widget& other) {
std::cerr << "member swap" << std::endl;
using std::swap;
swap(pImpl, other.pImpl);
}
WidgetImpl* getptr() {return pImpl;}
private:
WidgetImpl* pImpl;
};
namespace std {
template<>
void swap<Widget>(Widget& a, Widget& b) {
std::cerr << "std special swap" << std::endl;
a.swap(b);
}
}
int main()
{
std::vector<double> v1(0.,10);
std::vector<double> v2(1.,10);
WidgetImpl a1(0,0,0,v1) , a2(1,1,1,v2);
Widget b1(&a1), b2(&a2);
std::swap(b1, b2);
std::cerr << b1.getptr()->geta() << std::endl;
}
- classes 和 class templates 可以提供一个member swap，再提供一个non-member swap用来调用前者
#include <iostream>
#include <string>
template<typename T>
class WidgetImpl {
public:
WidgetImpl(T _t, int _a, int _b, int _c, std::vector<double> _v) :
t(_t), a(_a), b(_b), c(_c), v(_v) {}
T getT(){return t;}
private:
T t;
int a, b, c;
std::vector<double> v;
};
template<typename T>
class Widget {
public:
Widget(WidgetImpl<T>* _p) : pImpl(_p) {}
Widget(const Widget& rhs) {
*pImpl = *(rhs.pImpl);
}
void swap(Widget& other) {
std::cerr << "member swap" << std::endl;
using std::swap;
swap(pImpl, other.pImpl);
}
WidgetImpl<T>* getptr() {return pImpl;}
private:
WidgetImpl<T>* pImpl;
};
template<typename T>
void swap(Widget<T>& a, Widget<T>& b) {
std::cerr << "global swap" << std::endl;
a.swap(b);
}
int main()
{
std::vector<double> v1(0.,10);
std::vector<double> v2(1.,10);
WidgetImpl<std::string> a1("str1", 0,0,0,v1) , a2("str2",1,1,1,v2);
Widget<std::string> b1(&a1), b2(&a2);
swap(b1, b2);
std::cerr << b1.getptr()->getT() << std::endl;
}
