Effective C++（条款01-25）总结

条款01：视C++为一个语言联邦

1.C

2.面向对象的C++

3.C++模板

4.STL

条款02：尽量以const,enum,inline替换#define

1.对于单纯常量，最好以const对象或enum替换#define。

const相比于define的好处：

define直接常量替换，出现编译错误不易定位(不知道常量是哪个变量)

define没有作用域，const有作用域提供了封装性

const可以明确指定类型，而宏定义没有数据类型。

2.对于形似函数的宏，最好改用inline函数替换#define。

eg:

//define误用举例

#define MAX(a, b) a > b ? a : b

int a = 5, b = 0;
MAX(++a, b) //a++调用2次
MAX(++a, b+10) //a++调用一次

建议的做法：

template<typename T>
inline void callWithMax(const T&a,const T& b)
{
    f(a>b?a:b);
}

条款03：尽可能使用const

1.如果关键字const出现在星号左边，表示被指物是常量；如果出现在星号右边，表示指针自身是常量；如果出现在星号两边，表示被指物和指针两者都是常量。

2.const最具威力的用法是面对函数声明的应用。在一个函数声明式内，const可以和函数返回值、个参数、函数自身（如果是成员函数）产生关联。

（1）令函数返回一个常量指针，往往可以降低因客户错误而造成的意外。

eg:

class Rational{};
const Ration operator* (const Rational& lhs,const Rational& rhs);

如果这样声明了返回值，那么下面的无意识型错误就可以避免：

Rational a,b,c;
(a*b)=c;

（2）const参数

可以避免想要输入"=="却意外输入"="的错误。

（3）const 成员函数

const成员函数的目的是确认该函数可以用到const对象上。const成员函数使得1、class接口更加容易理解，确认哪些接口可以修改class成员。2、使操作const对象成为可能。

关于第2点，是因为const对象只能调用const成员函数；但是非const对象既可以调用普通成员函数，也可以调用const成员函数。这是因为this指针可以转换为const this，但是const this不能转换为非const this。

一个函数是不是const是可以被重载的。

（4）在const和非const成员函数中避免代码复制

在一些类中，const成员函数和non-const成员函数功能类似，在这两个函数中都要执行相同的代码，比如一些检查等。

class CTextBlock{
public:
	const char& operator[](std::size_t position)const
	{
		prepare();//准备
		return pText[position];
	}
	char& operator[](std::size_t position)
	{
		prepare();//准备
		return pText[position];
	}
	void prepare()const;//一些准备动作
	char * pText;
	int length;
};

这样看起来比较臃肿，可以是用来类型转换，把non-const转换为const，再转换其返回值类型

class CTextBlock{
public:
	const char& operator[](std::size_t position)const
	{
		prepare();//准备
		return pText[position];
	}
	char& operator[](std::size_t position)
	{
		return const_cast<char&>(static_cast<const CTextBlock&>(*this)[position]);
	}
	void prepare()const;//一些准备动作
	char * pText;
	int length;
};

 

条款04：确定对象被使用之前已先被初始化

1.永远在适用对象之前先将它初始化。对于无任何成员的内置类型，必须手工完成。比如int x=0；对于内置类型以外的任何其他东西，初始化责任落在构造函数身上。规则很简单，确保每一个构造函数都将对象的每一个成员初始化。

2.构造函数最好使用成员初值列，而不要在构造函数本体内使用赋值操作，因为这对于自定义类型的数据成员，会导致先调用相应的默认构造函数设初值，然后立刻再对它们赋新值，效率不高。而且初值列出的成员变量，其排列次序应该和它们在class中的声明次序相同。

3.为免除“跨编译单元之初始化次序”问题，以local static(局部静态对象)替换non-local static对象。

局部静态对象（local static object）在程序的执行路径第一次经过对象定义语句是初始化，并且直到程序终止才被销毁，在此期间及时对象所在的函数结束执行也不会对它有影响。

 条款05：了解C++默默编写并调用哪些函数

1.编译器可以暗自为class创建default构造函数、copy构造函数、copy assignment操作符，以及析构函数，所有这些和拿书都是public且inline。

2.编译器在下列情况下会拒绝为class产生默认operator=

（1）内含reference成员和const成员

（2）如果某个base classes将copy assignment操作符声明为private，编译器将拒绝为其derived classes生出一个copy assignment操作符。

条款06：若不想使用编译器自动生成的函数，就该明确拒绝

方法（1）：最好的

myClass()=delete;//表示删除默认构造函数

myClass(const myClass&)=delete;//表示删除默认拷贝构造函数，即不能进行默认拷贝

myClass & operatir=(const myClass&)=delete;//表示删除默认拷贝构造函数，即不能进行默认拷贝

方法（2）：可将相应的成员函数声明为private并且不予实现

class HomeForSale{
    private:
        HomeForSale(const HomeForSale&);//只有声明
        HomeForSale& operator=(const HomeForSale&);
};

方法（3）：专门为了阻止copying动作而设计的base class内。

class Uncopyable {
protected:
	Uncopyable() {}  //允许派生类对象构造和析构
	~Uncopyable() {}
private:
	Uncopyable(const Uncopyable&); //私有的，阻止派生类对象copying
	Uncopyable& operator=(const Uncopyable);
};
class HomeForSale :private Uncopyable {
	...
};

只要任何人-甚至是member函数或friend函数-尝试拷贝HomeForSale对象，编译期便试着生成一个copy构造函数和一个copy assignment操作符，这些函数的”编译器生成版“会尝试调用其base class的对应兄弟，那些调用会被编译器拒绝，因为其base class的拷贝函数是prrivate。

条款07：为多态基类声明virtual析构函数

1.带多态性质的base classes应该声明一个virtual析构函数。如果class带有任何virtual 函数，它就应该拥有一个virtual析构函数。

2.Classes的设计目的如果不是作为base classes使用，或不是为了具备多态性，就不该声明virtual析构函数。因为要想实现出virtual函数，会有vptr和vpbl的引入，白白浪费空间。许多人的心得是：只有当class内含至少一个virtual函数，才为它声明virtual析构函数。

08：别让异常逃离析构函数

1.析构函数绝对不要吐出异常。如果一个被析构函数调用的函数可能抛出异常，析构函数应该能捕捉任何异常，然后吞下它们（不传播）或结束进程。因为如果未进行处理，异常就会离开这个析构函数，抛出了难以驾驭的麻烦。

2.如果客户需要对某个操作函数运行期间抛出的异常做出反应，那么class应该提供一个普通函数（而非在析构函数中）执行该操作。

条款09：绝不在构造函数和析构函数中调用virtual函数

在构造和析构期间不要调用virtual函数，因为这类调用从不下降至derived class。

条款10：令operator=返回一个reference to *this

1.令赋值操作符返回一个reference to *this。这样能够实现连锁赋值，就像内置类型一样，x=y=z=15；

条款11：在operator+中处理“自我赋值”

1.确保当对象自我赋值时operator=有良好行为。其中技术包括“来源对象”和“目标对象”的地址、精心周到的语句顺序、以及copy-and-swap。

Widget& Widget::operator=(const Widget& rhs)
{
	if (this == &rhs)
		return *this;
	delete pb;
	pb = new Bitmap(*rhs.pb);
	return *this;
}

条款12：复制对象时勿忘其每一个成分

1.Copying函数应该确保复制“对象内的所有成员变量”及“所有base class成分“。

PriorityCustomer::PriorityCustomer(const PriorityCustomer& rhs)
	Customer(rhs),                //调用base class的copy构造函数
	priority(rhs.priority)
{
	 logCall("PriorityCustomer copy constructor ");
}

PriorityCustomer& PriorityCustomer::operator=(const PriorityCustomer& rhs)
 {
     logCall("PriorityCustomer copy assignment operator");
     Customer::operator=(rhs);     //对base class成分进行赋值动作
     priority = rhs.priority;
     return *this; 
}

2.不要尝试以某个copying函数实现另一个copying函数。如果你发现你的copy构造函数和copy assignment操作符有相近的代码，消除重复代码的做法是，建立一个新的成员函数给两者调用。这样的函数往往是private而且常被命名为init。这个策略可以安全消除copy构造函数和copy assignment操作符之间的代码重复。

条款13：以对象管理资源

1.为防止资源泄露，请使用RAII对象，它们在构造函数中获得资源并在析构函数中释放资源

什么是RAII？

RAII是Resource Acquisition Is Initialization的简称，是C++语言的一种管理资源、避免泄漏的惯用法。利用的就是C++构造的对象最终会被销毁的原则。RAII的做法是使用一个对象，在其构造时获取对应的资源，在对象生命期内控制对资源的访问，使之始终保持有效，最后在对象析构的时候，释放构造时获取的资源。

2.两个常被使用的RAII classes分别是trl::shared::ptr和auto_ptr。前者通常是较佳的选择，因为其copy行为比较直观。若选择auto_ptr，复制动作会使它（被复制物）指向null。

auto_ptrs的性质：通过copy构造函数或copy assignment操作符复制它们，它们会变为null，而复制所得的指针将取得资源的唯一拥有权。

//pInv1指向createInvestment返回物
std::auto_ptr<Investment> pInv1(createInvestment());
//现在pInv2指向对象，pInv1被设为null
std::auto_ptr<Investment> pInv2(pInv1);
//现在pInv1指向对象，pInv2被设为null
pInv1 = pInv2;

这一诡异的复制行为，附加上其底层条件：”受auto_ptrs管理的资源必须绝对没有一个以上的auto_ptr同时指向它“，意味auto_ptrs并非管理动态分配资源的好方法。

3.auto_ptr和trl::shared_ptr两者都是在其析构函数内做delete而不是delete[]动作。那意味着在动态分配而得的array身上使用auto_ptr或trl::shared_ptr是个馊主意。

std::auto_ptr<std::string>aps(new std::string[10]);  //delete的时候并不是按照你所预期的方式
std::trl::shared_ptr<int> spi(new int[1024]);   //同上

条款14：在资源管理类中心小心copying行为

1.复制RAII对象必须一并复制它所管理的资源，所以资源的copying行为决定RAII对象的copying行为。

2.普遍常见的RAII class copying行为是：抑制copying、施行引用计数法。不过其他行为也都有可能被实现。

看一个例子：

#include <iostream>
using namespace std;

class Lock
{
public:
        explicit Lock(int* pm) : m_p(pm)
        {
                lock(m_p);
        }

        ~Lock()
        {
                unlock(m_p);
        }
private:
        int *m_p;
        void lock(int* pm)
        {
                cout << "Address = " << pm << " is locked" << endl;
        }
        void unlock(int *pm)
        {
                cout << "Address = " << pm << " is unlocked" << endl;
        }
};
int main()
{
        int m = 5;
        Lock m1(&m);
        return 0;
}

这符合预期，当m1获得资源的时候，将之锁住，而m1生命周期结束后，也将资源的锁释放。
注意到Lock类中有一个指针成员，那么如果使用默认的析构函数、拷贝构造函数和赋值运算符，很可能会有严重的bug。

我们不妨在main函数中添加一句话，如下：

int main()
{
    int m = 5;
    Lock m1(&m);
    Lock m2(m1);
}

可见，锁被释放了两次，这就出问题了。原因是析构函数被调用了两次，在main()函数中生成了两个Lock对象，分别是m1和m2，Lock m2(m1)这句话使得m2.m_p = m1.m_p，这样这两个指针就指向了同一块资源。根据后生成的对象先析构的原则，所以m2先被析构，调用他的析构函数，释放资源锁，但释放的消息并没有通知到m1，所以m1在随后析构函数中，也会释放资源锁。
如果这里的释放不是简单的一句输出，而是真的对内存进行操作的话，程序就会崩溃。

归根到底，是程序使用了默认了拷贝构造函数造成的（当然，如果使用赋值运算的话，也会出现相同的bug），那么解决方案就是围绕如何正确摆平这个拷贝构造函数（和赋值运算符）。

第一个方法，禁止复制。利用条款6的方法（3）

class Lock:private Uncopyable{  //禁止复制，见条款6
    ...  
}

第二个方法，就是使用shared_ptr来进行资源管理（见前一个条款），但还有一个问题，我想在生命周期结束后调用Unlock的方法，其实shared_ptr里面的删除器可以帮到我们。

class Lock
{
public:
    explicit Lock(int *pm): m_p(pm, unlock){…}
private:
    shared_ptr<int> m_p;
}

所谓的“删除器”，那是一个函数或函数对象，当引用计数为0便被调用（此机能并不存在于auto_ptr-它总是将指针删除）。

条款15：在资源管理类中提供对原始资源的访问

1.资源管理类很棒。但是有些APIs直接指涉资源，所以需要绕过资源管理对象直接访问原始资源。

2.为了能操纵原始资源，我们要怎么做？ 

还好，shared_ptr和auto_ptr都提供一个get函数，用于执行这样的显示转换。这时如果在调用API时，如下：

shared_ptr<Investment> pInv(createInvestment());
int daysHeld(const Investment* pi);
int days = daysHeld(pInv);//错误，daysHeld需要的是Investment*指针，传递的却是个类型为shared_ptr<Investment>的对象
int days = daysHeld(pInv.get());//将pInv内的原始指针传给daysHeld

就像所有只能指针一样，shared_ptr和auto_ptr也重载了指针取值操作符（operator->和operator*），它们允许隐式转换至底部原始指针：

class Investment {
public:
	bool isTaxFree()const;
};
Investment* createInvestment();
shared_ptr<Investment> pi1(createInvestment());
bool taxablel = !(pi1->ixTaxFree());
auto_ptr<Investment> pi2(createInvestment());
bool taxable2 = !((*pi2).ixTaxFree());
//类同auto_ptr

但是有时候还是必须取得RAII对象内的原始资源，可以在RAII class中提供隐式转换函数或者显式转换函数。

显示转换函数：

FontHandle getFont();
class Font() {
public:
	//将RAII类对象显示转换为原始指针
	FontHandle get() const { return f; }
private:
	FontHandle f;
}

不幸的是这使得客户每当想要使用API时就会调用get

//假设是个C API，需要通过原始资源调用
void changeFontSize(FontHandle f, int newSize);
Font f(getFont());
int newFontSize;
changeFontSize(f.get(), newFontSize);

另一个办法是Font提供隐式转换函数，转型为FontHandle:

class Font() {
public:
	//将RAII类对象隐式转换为原始指针
	operator FontHandle () const { return f; }
private:
	FontHandle f;
}

这使得客户调用C API是较容易：

Font f(getFont());
int newFontSize;
changeFontSize(f, newFontSize);

但是隐式转换会增加错误发生机会

Font f1(getFont());
//原意是要拷贝一个Font对象，却反而将f1隐式转换为其底部的FontHandle然后才复制它
FontHandle f2 = f1;

3.APIs往往要求访问原始资源，所以每一个RAII class应该提供一个”取得其所管理之资源“的方法。

4.对原始资源的访问可能经由显式转换或隐式转换。一般而言显式转换比较安全，但隐式转换对客户比较方便。

条款16：成对使用new和delete时要采取相同的形式

1.当使用new（即用new动态创建一个对象），有两步。第一步，开辟内存（通过operator new，参考条款49、条款51）。第二步，针对此内存会有一个（或更多）构造函数被调用。同样使用delete时也有两步，针对此内存会有一个（或更多）析构函数被调用，然后内存才被释放（通过名为operator delete的函数，见条款51）。

2.如果你在new表达式中使用[]，必须在相应的delte表达式中也使用[]。如果你在new表达式中不使用[]，一定不要在相应的delete表达式中使用[]。

3.最好不要对数组形式做typedefs动作。这很容易，因为stl中含有string，vector等templates,可将对数组的需求降至几乎为0。

//每个人的地址有4行，每行是一个string
typedef std::string AddressLines[4];
//注意，new AddressLines返回一个string*，就像new string[4]一样
std::string* pal = new AddressLines;

//那么就把必须匹配“数组形式”的delete
delete[]pal;

条款17：以独立语句将newed对象置入智能指针

1.以独立语句将newed对象存储于智能指针内。如果不这么做，一旦异常被抛出，有可能导致难以察觉的资源泄露。

int priority();
int processWidget(shared_ptr<Widget> pw, int priority);
processWidget(shared_prt<Widget> pw(new Widget), priority());

以上代码执行三个行为，分别是 

1、执行priority()函数 
2、执行new Widget 

3、执行shared_ptr构造函数 

大家知道这三个行为顺序吗？ 

我想没人敢很自信的说顺序是什么，因为编译器在执行时，对以上三个行为的执行次序是不确定的，唯一确定的次序就是行为2在行为3之前

如果，执行次序是2、1、3.那么当函数priority()调用出现异常，new Widget返回的指针还没来得及放入shared_ptr中。这样会造成内存泄露。

所以，我们在编程的时候，最好将紧密行为单独编写为单一语句。 

如下：

std::trl::shared_prt<Widget> pw(new Widget);  //在单独语句内以智能指针存储newed所得对象
processWidget(pw,priority());

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

1.好的接口很容易被正确使用，不容易被误用。应该在设计的接口中努力达成这些性质。

2.促进正确使用的办法包括接口的一致性，以及与内置类型的行为兼容。

3.阻止误用的办法包括消除客户的资源管理责任。

4.shared_ptr支持定制型删除器。这可防范DLL问题（对象在动态连接程序库中被new创建，却在另一个DLL内被delete销毁），可被用来自动解除互斥锁（条款14）.

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

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

1.尽量以pass-by-reference-to-const替换pass-by-value。前者通常效率比较高效（因为后者会调用拷贝构造函数和析构函数）并可避免切割问题。

切割问题：

class Window {
public:
	string name() const;
	virtual void display() const;
};
class WindowWithScrollBars :public Window {
	virtual void display() const;
};

void printNameAndDisplay(Window w)
{
	cout << w.name();
	w.display();
}
WindowWithScrollBars wwsb;
printNameAndDisplay(wwsb);

上述的函数调用中，参数w会被构造成为一个Window对象；它是passed by value，造成wwsb之所以是个WindowWithScrollBars对象的所有特化消息都会被切除。在printNameAndDisplay函数内不论传递过来的对象原本是什么类型，参数w就像一个Window对象（因为其类型是Window）。因此在printNameAndDisplay内调用display调用的总是Window::display，绝不会是WindowWithScrollBars::display。

解决上述问题的办法是以by reference-to-const的方式传递w

void printNameAndDisplay(const Window& w)
{
	cout << w.name();
	w.display();
}

现在就可以调用WindowWithScrollBars::display。

2.以上规则并不适用于内置类型，以及STL的迭代器和函数对象。对它们而言，pass-by-value往往比较适当。

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

这一条款再看一遍书，一定要注意，这里是说不要返回对象的reference，而不是说成员变量。

1.绝不要返回pointer或reference指向一个local stack对象，或返回reference指向一个heap-allocated对象（因为delete可能会遗忘），或返回pointer或refeerence指向一个local static对象而可能同时需要多个这样的对象。

2.一个必须返回新对象的函数的正确写法是：让那个函数返回一个新对象

inline const Rational operator*(const Rational& lhs, const Rational& rhs)
{
	return Rational(lhs.n * rhs.n, lhs.d * rhs.d);
}

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

1.切记将成员变量声明为private。这可赋予客户访问数据的一致性、可细微划分访问控制、允诺约束条件获得保证，并提供class作者以充分的弹性。

如果成员变量不是public,客户唯一能够访问对象的办法就是通过成员函数。

封装的重要性毋庸置疑，如果你对客户隐藏成员变量（也就是封装它们），你可以确保class的约束条件总是会获得维护，因为只有成员函数可以影响它们。更进一步地说，你保留了日后变更实现的权利，如果你不隐藏它们，你很快会发现即使拥有class原始码，改变任何public事物的能力还是极端受到约束，因为那会破坏太多客户码。public意味不封装，而几乎可以说，不封装意味不可改变，特别是对被广泛使用的classes而言。被广泛使用的classes是最需要封装的一个族群，因为他们最能够从“改变采用一个较佳实现版本”中获益。protected成员变量的论点十分类似。实际上它和public成员变量的论点相同。

假设我们有一个public成员变量，而我们最终取消了它。多少代码可能会被破坏呢，是的所有使用它的客户码都会被破坏，而那时不可知的大量。因此public成员变量完全没有封装性，。假设我们有一个protected成员变量而我们最终取消了它，有多少代码被破坏，是的，所有使用它的derived classes都会被破坏，那往往也是个 不可知的大量。因此，protected成员变量就像public成员变量一样缺乏封装性，因为在这两种情况下，如果成员变量被改变，都会有不可预知的大量代码收到破坏，虽然这个结论有点违反直观，但经验丰富的程序库作者会告诉你，它是真的，一旦你将一个成员变量声明为public或protected而用户开始使用它，就很难改变那个成员变量所涉及的一切。太多代码需要重写、重新测试、重写编写文档、重新编译、。从封装的角度看，其实只有两种访问权限：private(提供封装)和其他（不提供封装）。

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

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

1.封装性更大。non-member，non-friend函数比member函数和friend函数具有更大的封装性，因为它们绝不会访问到class的private成员。所以当class的private成员被更改而其public接口不变时，就会有越少的代码受到影响。

2.non-member函数可允许class相关机能有较大的包裹弹性，从而会有较低的编译相依度。

将non-member函数组合在一个namespace内，但是根据non-member函数的和对应类的相关性不同，而存放在不同的头文件中。要知道，namespace和classes不同，前者可以跨越多个源码文件而后者不能。客户则按照自己的需求不同，来包裹不同的头文件，客户只需要对它们使用的那一小部分系统形成编译相依。

// 头文件webbrowser.h
namespace WebBrowserStuff
{
	class WebBrowser(); // 核心功能
	void ClearWebBrowser(WebBrowser& w); // non-member non-friend函数
}

// 头文件webbrowserbookmarks.h
namespace WebBrowserStufff
{
	…// 与书签相关的函数
}

// 头文件 webbrowsercookies.h
namespace WebBrowserStuff
{
	…// 与cookie管理相关的函数
}

不同的WebBrowser处理函数被包裹在相同的命名空间，但是又存放在不同的头文件中，使得用户可以按照自己的需求来选择。

3.宁可拿non-member non-friend函数来替换member函数。这样做可以增加封装性，包裹弹性和机能扩充性。

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

1.令classes支持隐式类型转换通常是糟糕的注意。但是也有例外，最常见的是建立数值类型时。假设你设计一个class用来表示有理数，允许整数”隐式转换“为有理数似乎颇为合理。

class Rational {
public:
	Rational(int numerator = 0, int denominator = 1);//允许int-to-Rational隐式转换
	int numerator()const;//分子访问函数
	int denominator()const;//分母访问函数
	const Rational operator*(const Rational& rhs)const;
};

Rational oneEighth(1, 8);
Rational oneHalf(1, 2);
Rational result1 = oneHalf*oneEighth;//正确
Rational result2 = oneHalf * 2;//正确
Rational result3 = 2 * oneHalf;//错误

倒数第二个正确，相当于result2=oneHalf.operator*(2);此时编译器知道你正在传递一个int，而函数需要的是Rational，所以发生了隐式类型转换。

最后一个错误的原因是：result3=2.operator*(oneHalf);但是int类型并没有这样的函数，所以错误。

那么如何才能正确执行Rational result3 = 2 * oneHalf？让operator*成为一个non-member函数

class Rational {
public:
	Rational(int numerator = 0, int denominator = 1);//允许int-to-Rational隐式转换
	int numerator()const;//分子访问函数
	int denominator()const;//分母访问函数
};
const Rational operator*(const Rational& lhs，const Rational& rhs)
{
	return Rational(lhs.numerator()*rhs.numerator(), lhs.denominator()*rhs.denominator());
}

2.如果你需要为某个函数的所有参数（包括被this指针所指的那个隐喻参数）进行类型转换，那么这个函数必须是个non-member。

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

这个条款需要看书

1.首先，如果swap缺省实现码对你的class或class template提供可接受的效率，你不需要额外做任何事。任何尝试置换（swap）那种对象的人否会取得缺省版本，而那将有良好的运作。

namespace std {
	template<typenmae T>
	void swap)(T& a,T& b)
	{
		T temp(a);
		a = b;
		b = temp;
	}
}

其次，如果swap缺省实现版的效率不足（那几乎总是意味着你的class或template使用了某种pimpl手法，也就是以指针指向一个对象，对象内含真正数据），试着做以下事情：

（1）提供一个public swap成员函数，让它高效地置换你的类型的两个对象值。这个函数不应该抛出异常。

（2）在你的class或template所在的命名空间提供一个non-member swap，并令它调用上述swap成员函数。

（3）如果你正编写一个class(而非class template)，为你的class特化std::swap。并令它调用你的swap成员函数。

2.当std::swap对你的类型效率不高时，提供一个swap成员函数，并确定这个函数不抛出异常，因为swap的一个最好应用是帮助classes提供强烈的异常安全性保障。

3.如果你提供了一个member swap,也该提供一个non-member swap用来调用前者。对于classes，也请特化std::swap。

4.为”用户定义类型“进行std templates全特化是好的，但千万不要尝试在std内加入某些对std而言全新的东西。也就是用户可以全特化std内的templates，但不可以添加新的templates(或classes或functions或其他任何东西)到std里面。