重载操作符与转换

--赋值、下标、成员訪问操作符

一、赋值操作符

类赋值操作符接受类类型形參，通常该形參是对类类型的const引用，但也能够是类类型或对类类型的非const引用。假设未定义这个操作符,则编译器将合成它。类赋值操作符必须是类的成员,以便编译器能够知道是否须要合成一个。并且还能够为一个类定义很多附加的赋值操作符，这些赋值操作符会由于右操作数的不同而构成重载！如string类型：

    string car("Volks");

    car = "Studebaker"; //接受C风格字符串实參

    string model;

    model = 'T';        //接受字符实參

    model = car;        //接受string实參

为了支持这些操作符，string类应包括例如以下的成员：

class string

{

public:

    string &operator=(const string &);

    string &operator=(const char *);

    string &operator=(char);

    //...

};

赋值操作符能够重载，不管形參为何种类型，赋值操作符都必须定义为成员函数！这一点与复合赋值操作符不同。

赋值必须返回*this的引用

为了与内置类型达成一致，赋值返回一个引用，同一时候也能够不用创建和撤销结果的暂时副本。返回值一般是左操作数的引用：

Sales_item &Sales_item::operator+=(const Sales_item &rhs)

{

    units_sold += rhs.units_sold;

    revenue += rhs.revenue;

    return *this;

}

【最佳实践】

一般而言：赋值操作符和复合赋值操作符应返回左操作数的引用！

//P442 习题14.14

Sales_item &Sales_item::operator=(const string &str)

{

    isbn = str;

    return *this;

}

//习题14.15/16

class CheckoutRecord

{

public:

    typedef unsigned Date;

    //...

    CheckoutRecord &operator=(const CheckoutRecord &rhs);

    //新加入�一本书

    CheckoutRecord &operator=(const string &);

    //新加入�一位等待读者

    CheckoutRecord &operator=(const pair<string,string> &);

private:

    double book_id;

    string title;

    Date date_borrowed;

    Date date_due;

    pair<string,string> borrower;

    vector< pair<string,string> * > wait_list;

};

CheckoutRecord &CheckoutRecord::operator=(const CheckoutRecord &rhs)

{

    book_id = rhs.book_id;

    title = rhs.title;

    date_borrowed = rhs.date_borrowed;

    date_due = rhs.date_due;

    borrower = rhs.borrower;

    //为vector赋值

    wait_list.clear();

    for (vector< pair<string,string> * >::const_iterator iter = rhs.wait_list.begin();

            iter != rhs.wait_list.end(); ++iter)

    {

        pair<string,string> *ppair = new pair<string,string>;

        *ppair = **iter;    //复制的是，vector中的对象，而不是指针！

        wait_list.push_back(ppair);

    }

    return *this;

}

CheckoutRecord &CheckoutRecord::operator=(const string &Title)

{

    title = Title;

    return *this;

}

CheckoutRecord &CheckoutRecord::operator=(const pair<string,string> &newReader)

{

    pair<string,string> *ppair = new pair<string,string>;

    *ppair = newReader;

    wait_list.push_back(ppair);

    return *this;

}

二、下标操作符

能够从容器中检索单个元素的容器类通常会定义下标操作符，即operator[]。如vector和string。

下标操作符必须定义为类成员函数。

1、提供读写訪问

定义下标操作符比較复杂的地方在于,它在用作赋值的左右操作符数时都应该能表现正常。下标操作符出如今左边,必须生成左值,能够指定引用作为返回类型而得到左值。仅仅要下标操作符返回引用,就可用作赋值的随意一方。

【最佳实践】

类定义下标操作符时，一般须要定义两个版本号：一个为非const成员并返回引用，还有一个为const成员并返回引用！

2、原型下标操作

class Foo

{

public:

    int &operator[] (const size_t);

    const int &operator[] (const size_t) const;

private:

    vector<int> data;

};

int &Foo::operator[](const size_t index)

{

    return data[index];	//注意：没有范围检測...

}

//除了函数原型不同之外，没有其它不论什么区别！

const int &Foo::operator[] (const size_t index) const

{

    return data[index];

}

//P443 习题14.17/18/19

class CheckoutRecord

{

public:

    typedef unsigned Date;

    typedef vector< pair<string,string> *>::size_type sizeType;

    //...

    pair<string,string> &operator[] (const size_t);

    const pair<string,string> &operator[] (const size_t) const;

    const pair<string,string> &get_a_waiter(sizeType) const;

private:

    double book_id;

    string title;

    Date date_borrowed;

    Date date_due;

    pair<string,string> borrower;

    vector< pair<string,string> * > wait_list;

};

pair<string,string> &CheckoutRecord::operator[](const size_t index)

{

    return *wait_list.at(index);

}

const pair<string,string> &CheckoutRecord::operator[](const size_t index) const

{

    return *wait_list.at(index);

}

/**尽管下标操作符使用简单，可是他也有他的缺点

*如：下标操作符适合于表示“获取容器中特定元素”的语义

*而获取一个等待者则语义不明

*这样就不如使用一个普通的成员函数表意明白！

*/

//事实上就是将函数原型做了略微的修改，其它方面都不做更改

const pair<string,string> &CheckoutRecord::get_a_waiter(sizeType index) const

{

    return *wait_list.at(index);

}

三、成员訪问操作符

为了支持指针型类，比如迭代器，C++语言同意重载解引用操作符(*)和箭头操作符(->)。

箭头操作符必须定义为类成员函数。解引用操作符不要求定义为成员，可是将他作为成员一般也是正确的！

1、构建更安全的指针

解引用操作符和箭头操作符经常使用在实现智能指针的类中。作为样例,假定想要定义一个类类型表示指向第十二章Screen类型对象的指针,将该类命名为ScreenPtr。

不用为 ScreenPtr类定义默认构造函数。因此,我们知道一个ScreenPtr对象将总 是指向一个Screen对象,不会有未绑定的ScreenPtr。应用程序能够使用ScreenPtr对象而无须首先測试它是否指向一个Screen对象。

像HasPtr类一样,ScreenPtr类将对其指针进行使用计数。我们将定义一个伙伴类保存指针及其相关使用计数:

class ScrPtr

{

    friend class ScreenPtr;

    Screen *sp;

    size_t use;

    ScrPtr(Screen *p):sp(p),use(1){}

    ~ScrPtr()

    {

        delete sp;

    }

};

ScrPtr保存指针及其相关使用计数。将ScreenPtr设为友元,以便ScreenPtr能够訪问使用计数。

class ScreenPtr

{

public:

    ScreenPtr(Screen *p):ptr(new ScrPtr(p)){}

    ScreenPtr(const ScreenPtr &orig):ptr(orig.ptr)

    {

        ++ ptr->use;

    }

    ScreenPtr &operator=(const ScreenPtr &);

    ~ScreenPtr()

    {

        if ( -- ptr->use == 0 )

            delete ptr;

    }

private:

    ScrPtr *ptr;

};

由于没有默认构造函数，所以ScreenPtr类型的每一个对象都必须提供一个初始化函数，初始化函数必须是还有一个ScreenPtr对象或者运行动态分配的Screen指针。

    ScreenPtr p1;               //Error

    ScreenPtr p2(new Screen);   //OK

2、支持指针操作

指针支持的基本操作有解引用操作和箭头操作，我们的类能够这样定义这些操作：

class ScreenPtr

{

public:

    Screen &operator*()

    {

        return * ptr->sp;

    }

    Screen *operator->()

    {

        return ptr -> sp;

    }

    const Screen &operator*() const

    {

        return * ptr -> sp;

    }

    const Screen *operator->() const

    {

        return ptr -> sp;

    }

//AS Before...

private:

    ScrPtr *ptr;

};

3、重载解引用操作符

我们的解引用操作符有const和非 const版本号。它们的区别在于返回类型:const成员返回const引用以防止用户改变基础对象。

4、重载箭头操作符

箭头操作符与众不同。它可能表现得像二元操作符一样:接受一个对象和一个成员名。对对象解引用以获取成员。不管外表怎样,箭头操作符不接受显式形參。

这里没有第二个形參,由于->的右操作数不是表达式,相反,是相应着类成员的一个标识符。没有明显可行的途径将一个标识符作为形參传递给函数,相反,由编译器处理获取成员的工作。

当这样编写时:

    point -> action();

由于优先级规则,它实际等价于这样编写:

    (point -> action) ();

换句话说,我们想要调用的是对point->action求值的结果。编译器这样对该代码进行求值【以下的一段话不太好理解，注意】:

1)假设point是一个指针,指向具有名为action的成员的类对象,则编译器将代码编译为调用该对象的 action成员。

2)否则,假设action是定义了operator->操作符的类的一个对象,则point-> action 与point.operator->()->action同样。即,运行point的operator-> (),然后使用该结果反复这三步。

3)否则,代码出错。

5、使用重载箭头

能够这样使用ScreenPtr对象訪问Screen对象的成员：

    Screen myScreen;

    ScreenPtr p(&myScreen);

    p -> display();

由于 p是一个ScreenPtr对象,p->display的含义与对(p.operator->())->display求值同样。对p.operator->()求值将调用ScreenPtr类的operator->,它返回指向Screen对象的指针,该指针用于获取并运行ScreenPtr所指对象的display成员。

6、对重载箭头的返回值的约束(最后两段不太好理解(ˇ_ˇ）～)

重载箭头操作符必须返回指向类类型的指针，或者返回定义了自己的箭头操作符的类类型对象！

假设返回类型是指针,则内置箭头操作符可用于该指针,编译器对该指针解引用并从结果对象获取指定成员。

假设返回类型是类类型的其它对象(或是这样的对象的引用),则将递归应用该操作符。编译器检查返回对象所属类型是否具有成员箭头,假设有,就应用那个操作符;否则,编译器产生一个错误。这个过程继续下去,直到返回一个指向带有指定成员的的对象的指针,或者返回某些其它值,在后一种情况下,代码出错。

//P446 习题14.20

ScreenPtr &ScreenPtr::operator=(const ScreenPtr &rhs)

{

    ++ rhs.ptr -> use;

    if (-- ptr->use == 0 )

    {

        delete ptr;

    }

    ptr = rhs.ptr;

    return *this;

}

//习题14.21

class NoName

{

public:

    NoName(Screen *p):ptr(new ScreenPtr(p)){}

    ScreenPtr operator-> ()

    {

        return *ptr;

    }

    const ScreenPtr operator-> () const

    {

        return *ptr;

    }

private:

    ScreenPtr *ptr;

};

//习题14.22

/*

*==操作符须要在类中声明

*    friend bool operator==(const ScreenPtr &lhs,

                           const ScreenPtr &rhs);

*/

inline

bool operator==(const ScreenPtr &lhs,const ScreenPtr &rhs)

{

    return lhs.ptr == rhs.ptr;

}

inline

bool operator!=(const ScreenPtr &lhs,const ScreenPtr &rhs)

{

    return !(lhs == rhs);

}