//---------------------------15/04/06----------------------------
//#18 让接口容易被正确使用，不易被误用
{
// 1:为了防止客户输入错误的参数，可以使用外覆类型来区别：
struct Day
{
explicit Day(int d): val(d) {}
int val;
};
struct Month
{
explicit Month(int m): val(m) {}
int val;
};
struct Year
{
explicit Year(int y): val(y) {}
int val;
};
class Date
{
public:
Date(const Month& m,
const Day& d, const Year& y);
...
};
// 这时，客户职能这么使用Date class：
Date d(Month(3), Day(30), Year(1995));
// 为了限制类型的值，比如一年只有12个月，Month应该反映这样的事实。
// 为了安全不直接使用enum，而是预先定义所有有效的Months：
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);
};
Date d(Month::Mar(), Day(30), Year(1995));
/* 2:预防客户错误的另一个办法是：限制类型内什么事可做，什么事不能做。也就是加上const。
3:除非有好理由，否则应该尽量令你的types的行为与内置types一致
4:任何接口如果要求客户必须记得做某些事情，就是有着“不正确使用”的倾向。
较佳接口的设计原则是先发制人，比如条款13中，
令factory函数返回一个智能指针，可以避免客户忘记使用智能指针: */
std::tr1::shared_ptr<Investment> createInvestment();
// 5:tr1::shared_ptr支持定制型删除器，可以防范DLL问题：
std::tr1::shared_ptr<Investment> createInvestment()
{
std::tr1::shared_ptr<Investment> retval(static_cast<Investment*>(0),
getRidOfInvestment);
retval = ...;
return retval;
}
}
//#19 设计class犹如设计type
{
/* 1:新type的对象应该如何被创建和销毁？
这会影响到你的class的构造函数和析构函数，以及内存分配函数和释放函数。
当然前提是如果你打算撰写他们。
2:对象初始化和对象的赋值该有什么样的差别
这个答案决定了构造函数和赋值操作符的行为，以及差异。
3:新type的对象如果被passed by value，意味着什么？
copy构造函数用来定义一个type的pass by value该如何实现。
4:什么是新type的“合法值”
你的class必须维护自己的约束条件，也就决定了你的成员函数
(特别是构造函数、赋值操作符、和所谓的setter函数)必须进行错误检查工作。
5:你的新type需要配合某个继承图系吗？
继承既有的class会受到哪些class的设计的束缚，特别是他们的函数是virtual或non_virtual的影响
如果允许别人继承自己的类，就会影响你所声明的函数是否为virtual
6:你的新type需要什么样的转换
是否需要隐式转换、显式转换。
7:什么样的操作符和函数对此新type而言是合理的？
这个答案决定你为你的class声明哪些函数，其中某些该是member函数。
8:什么样的标准函数应该驳回
你不想要系统为你声明的函数要声明为private。
9:谁该取用新type的成员
这个答案决定了哪个成员为public，protected，private。以及哪个class或function应该是friend
10:什么是新type的“为声明接口”
它对效率、异常安全性以及资源运用提供何种保证
11:你的新type有多么一般化
看看自己是否应该定义一个新的class template
12:你真的需要一个新type吗
如果只是为既有的class添加机能，那么可能单纯定义一个或多个non member函数或templates
更能达到目标。
*/
}
//#20 宁以pass by reference to const替换pass by value
{
/* 1:pass by value 需要调用copy构造函数产出一个副本，这可能使得pass by value
成为昂贵的操作。如果传递的是一个自定义class，通常需要调用一次copy构造函数
加 一次析构函数
如果这个class继承自别的类，又需要多调用好几次这两个函数。
2:by reference方式传递参数可以避免slicing(对象切割)问题：
一个derived class
对象以by value方式传递并被视为一个base class对象时，base class
的copy构造函数被调用，而“造成此对象的行为属于derived class
对象”的部分被切掉了，只留
下了一个base class对象。这绝不是你想要的。
3:reference通常以指针来实现出来，所以pass by reference就相当于传递指针。因此如果是一些
内置类型对象(比如int) pass by value
往往比 pass by reference的效率高些。
4:除了内置类型
和 stl的迭代器和函数对象，其他的对象都以pass by reference to const
替换 pass by value。
*/
}
//#21 必须返回对象时，别妄想返回其reference
{
// 1:一些值必须返回pass by value：
// 1>通过在stack上创建对象并返回这个对象的引用：
const Rantional& operator* (const Rantional& lhs,
const Rantional& rhs)
{
Rantional result(lhs.n * rhs.n, lhs.d * rhs.d);
return result;
}
/* 这里有两个点：
1)这样也调用构造了，效率并没提高。
2)返回了一个已经被销毁的对象。严重的错误！
2>通过在堆上创建对象并返回这个对象的引用：
*/
const Rantional& operator*(const Rantional& lhs,
const Rantional& rhs)
{
Rantional result =
new Rantional(lhs.n * rhs.n, lhs.d * rhs.d);
return result;
}
// 这样的话，谁负责delete？而且还是需要一次构造函数。
// 3>使用static对象：
const Rantional& operator* (const Rantional& lhs,
const Rantional& rhs)
{
static Rantional result;
result = ...;
return result;
}
// 这样首先线程不安全，其次使用if((a * b) == (c * d))总是返回true；
// 2:当一个函数必须返回新对象时，就让那个函数返回一个新对象呗！
inline const Rantional
operator* (const Rantional& lhs,
const Rantional& rhs)
{
return Rantional(lhs.n * rhs.n, lhs.d * rhs.d);
}
}
//#22 将成员变量声明为private
{
/* 1：首先看看成员变量不该是public：
1>一致性：如果没有public成员变量，客户唯一能访问对象的办法就是使用成员函数
客户就不需要在访问成员时疑惑地试着记住是否使用小括号。
2>可以更加精准地控制成员变量：你可以通过函数控制成员变量的读写。
3>封装性：如果通过函数访问成员变量，日后就算更改了这个变量的计算方法，或者直接更改了变量，
客户也不知道，也不必知道。
不封装就意味着不改变。
2：成员变量不该是protected：
道理和public第三点一样，这样对derived class并没有封装性可言
}