//---------------------------15/04/08----------------------------
//#23 宁以non_member、non_friend替换member函数
{
class WebBrowser
{
public:
...
void clearCache();
void clearHistory();
void removeCookies();
...
};
/* 对于上面这个函数，有的客户会想一次调用这三个函数，那么时使用member函数好呢，
还是non_menber non_friend函数好呢
1:对于封装性来说，是non_member版本比较好。
1>从封装开始讨论：如果某东西被封装，它就不再可见。愈多东西被封装，愈少人可以看到它。
而愈少人看到它，就有愈大的弹性去变化它，因为我们的改变仅仅直接影响看到改变的那些人事物。
就这一点来说，能够访问private成员变量的就是成员函数和friend函数。如果non_member和
member函数提供的功能是相同的，那么，封装性较大的是non_member函数，因为它不增加”能访问
class内private成分“的数量。
2>member函数说的只是针对能访问到private成员的类，并不是说这个函数不能是别的类的member函数。
2:把这些non_member函数放入namespace并分类到不同的头文件中。这么做的原因是，客户可以针对不同的
功能，包含不同的头文件。
*/
}
//#24 若所有参数皆需类型转换，请为此采用non_member函数
{
// 令class支持隐式类型转换通常是个糟糕的主意。然而也有例外，最常见的例外是在建立数值类型时。
// 如果要设计一个有理数的类，让他支持int隐式转换到有理数还是很合理的
class Rational
{
public:
Rational(int numerator =0, int denominator =1)//没有使用explicit，允许隐式转化
int numerator() const;
int denominator() const;
private:
};
// 让有理数类支持+ *等操作时，使用non_member函数实现，类内部的operatpr*()操作无法实现全部功能。
const Rational operator*(const Rational& rhs)const;
Rational oneHalf(1,2),result;
result = oneHalf * 2; //可以正确调用operator*()操作，2在参数列表中，可以隐式转换
result =2 * oneHalf; //错误，没有这样的操作
// 结论：只有当参数被列于参数列表内，这个参数才是隐式类型转换的合格参与者。
// 所以，只能使用non_member函数，把两个数都放入参数列表中
const Rational operator*(const Rational& lhs,const Rational& rhs)
{
return Rational(lhs.numerator() * rhs.numerator(),
lhs.denominator() * rhs.denominator());
}
// 是否让它成为friend的？没有必要，不是friend就能完成任务，就不必成为friend了
}
//#25 考虑写出一个不抛异常的swap函数
{
// swap原本是stl的函数：
namespace std
{
template<typename T>
void swap(T& a, T& b)
{
T temp(a);
a = b;
b = temp;
}
}
// 这种调用方式，在某些情况，会产生不必要的消耗：
class WidgetImpl
{
public:
...
private:
int a,b,c;
stad::vector<double> v;//意味着复制需要的时间很长
};
class Widget
{
public:
Widget(const Widget& rhs);
Widget&operator=(const Widget& rhs)
{
...
*pImpl = *(rhs.pImpl); //深拷贝
...
}
private:
WidgetImpl* pImpl;
};
// 当执行swap的时候，正常情况应该直接交换两个 pImpl的指针，而stl版本的却要复制三个widgetImpl对象
// 为了特化，可以声明一个成员函数对指针调用swap函数:
class Widget
{
public:
void swap(Widget& other)
{
using std::swap;
swap(pImpl, other.pImpl);
}
...
};
namespace std
{
template<>
void swap<Widget>(Widget& a, Widget& b)
{
a.swap(b);
}
}
// 当Widget时个class template时，这么做是错的：
namespace std
{
template<typename T>
void swap< Widget<T> >(Widget<T>& a, Widget<T>& b)
{
a.swap(b);
}
}
// 这样是在偏特化 swap的函数模版参数，并不是偏特化swap函数，所以可以使用重载：
namespace std
{
template<typename T>
void swap(Widget<T>& a, Widget<T>& b)
{
a.swap(b);
}
}
// 然而我们不能往std中添加新的东西。所以我们可以把non_member函数放到Widget的namespace那儿
namespace WidgetStuff
{
template<typename T>
class Widget{...};
...
template<typename T>
void swap(Widget<T>& a, Widget<T>& b)
{
a.swap(b);
}
}
// 使用
template<typename T>
void doSomething(T& obj1, T& obj2)
{
using std::swap; //为了std的swap可见，至于调不调用是编译器的事
...
swap(obj1, obj2);
}
/* swap总结：
1>提供一个public swap成员函数，让它高效地置换你的类型的两个对象值。
2>在你的class或template所在的命名空间内提供一个non_member swap，并令它调用上述swap成员函数
3>如果你编写的class不是class template。为你的class特化std::swap,并令让调用swap成员函数。
4>在使用swap时，记得使用 using std::swap，使得std::swap可见。
5>成员版swap绝对不能抛出异常。
*/
}