1、 operator =

const Array& operator = ( const Array& rhs);

返回值不为void是考虑到需要支持a=b=c;这种情况

前面的const是考虑到(a=b)=c;这种情况时，应该报错

由编译器自动创建的函数包括：默认的构造函数、拷贝构造函数、operator = 、析构函数

2、 operator <<

operator >> 必须写成友元函数

原因是<<运算符的函数签名是 ostream& operator<<(ostream&, your_class&) 这里第一个参数是ostream类型，你不可能修改ostream类型的定义，因此你不可

能将它定义成ostream类的成员函数。你必须把它定义成一个普通的函数，如果这个函数需要拿到your_class的私有成员，那么你就把这个函数在your_class内部声

明为friend

friend ostream& operator<<(ostream& outStream,const Rational& rhs);    friend istream& operator>>(istream& inStream,Rational& rhs);

输入函数最后的参数不能为const;

3、必须重载为成员函数的运算符： [], (), –>, =

原因是这些运算符左边必须是这个类的变量（或者是子类的）。

4 自动类型转换

4.1 自动类型转换-构造函数转换

class One    {    public:        One(){}    };    class Two    {    public:        Two(const One&){}   // here!    };    void f(Two){}    int main()    {        One one;        f(one);    }

为避免构造函数自动转换可能引起的问题，可以在前面加 explicit 关键字

class One    {    public:        One(){}    };    class Two    {    public:        explicit Two(const One&){}    };    void f(Two){}    int main()    {        One one;        // ! f(one); //不行了        f(Two(one));    }

 

4.2 自动类型转换-运算符转换

class Three    {        int i;    public:        Three(int ii=0,int=0): i(ii){}    };    class Four    {        int x;    public:        Four(int xx): x(xx){}        operator Three() const { return Three(x); } // here!    };    void g(Three) {}    int main()    {        Four four(1);        g(four);        g(1);    // CALL Three(1,0);    }

注意：使用构造函数技术没有办法实现从用户定义类型向内置类型转换，这只有运算符重载可能做到

4.3 自动类型转换的缺陷

4.3.1

class Orange;    class Apple    {    public:        operator Orange() const;    };    class Orange    {    public:        Orange(Apple);    };    void f(Orange);    int main()    {        Apple a;        f(a);    }

当两种类型的转换同时存在时，编译器不知道应该执行哪一个

4.3.

class Orange{};    class Pear{};    class Apple    {        operator Orange() const;        operator Pear() const;    };    void eat(Orange);    void eat(Pear);    int main()    {        Apple c;        eat(c);    // Error: Apple->Orange or Apple->Pear???    }

当类中有多个向其他类型的转换时，它们不应该是自动转换，而应该是用如makeA()和makeB()这样的名字来创建显式的函数调用

5、 operator() 实现回调，下面是CEGUI中实现时间回调的一个雏形：

class EventArgs    {    public:        // construction        EventArgs(): d_handled(false),d_hasWindow(false):{}        // data members        bool d_handled;        bool d_hasWindow;    };    class FuctionSlotBase    {        virtual ~FuctionSlotBase(){}        virtual operator()(const EventArgs& args) = 0;    };    template
     
          class MemberFunctionSlot: public FuctionSlotBase    {    public:        typedef bool(T::*MemberFunctionType)(const EventArgs&);        MemberFunctionSlot(MemberFunctionType func, T* obj):            d_function(func),            d_object(obj)        {}        virtual bool operator(const EventArgs& args)        {            return (d_object->*d_function)(args);        }    private:        MemberFunctionSlot d_function;        T* d_object;    };