[C++] 重载运算符与类型转换（1）

1、形式：返回值 operator符号（参数列表）{}

2、不能被重载的运算符：:: 作用域运算符 .* . 成员访问运算符 ?: 条件运算符；某些运算符（逗号，，取地址&，逻辑或||，逻辑与&&）不应该被重载：1）重载之后无法保留运算对象的求值顺序，比如逻辑与&&，逻辑或||和逗号运算符；2）无法保留运算符的短路求值属性，比如&&和||；3）有特殊含义的运算符，比如逗号和取地址。

3、建议：只有当操作的含义对于用户来说清晰明了时才使用运算符，否则运算符将产生二义性。

4、两种选择：作为类的成员函数或者作为普通的非成员函数

5、重载输出运算符

//定义

ostream& operator<<(ostream &os, const Sales_data &item) {

       os << item.isbn() <<" "<<item.units_sold<< "——重载输出运算符";

       return os;

}

1）尽量减少格式化操作

2）输入输出运算符必须是非成员函数

3）IO运算符一般被声明为友元

friend ostream& operator<<(ostream&, const Sales_data&);

friend istream& operator >> (istream&, Sales_data&);

6、重载输入运算符

//重载输入运算符

istream& operator >> (istream &is, Sales_data &item) {

       double price;

       is >> item.bookNo >> item.units_sold >> price;

       if (is) //检查输入是否成功

              item.revenue = item.units_sold*price;

       else

              item = Sales_data();//输入失败：对象赋予默认状态

       return is;

}

调用

/*重载运算符操作,调用*/

Sales_data sales_data;

operator >> (cin, sales_data);//输入

operator<< (cout, sales_data)<<endl;//输出

1）输入运算符必须处理输入可能失败的情况，而输出运算符不需要

7、算数和关系运算符

1）通常情况下，我们把算数和关系运算符定义成非成员函数，以允许对左侧或右侧的运算对象进行转换。

2）相等和不等关系运算符

//相等运算符——包括相等和不等判断，要求所有数据成员对应相等

bool operator==(const Sales_data &lhs, const Sales_data &rhs) {

       return lhs.isbn() == rhs.isbn()&&lhs.units_sold==rhs.units_sold&&lhs.revenue==rhs.revenue;

}

bool operator!=(const Sales_data &lhs, const Sales_data &rhs) {

       return !(lhs == rhs);

}

3）大于小于关系运算符：如果存在唯一一种可靠的<定义，则应该考虑为这个类定义<运算符。如果类同时还包含==，则当且仅当<的定义和==产生的结果一致时才定义<运算符。也就是说，只要不是==，就一定有一个小于另一个。

8、赋值和复合赋值运算符

1）无论形参是什么，赋值运算符都必须定义为成员函数。

//赋值运算符

StrVec& StrVec::operator=(initializer_list<string> il) {

       //alloc_n_copy分配内存空间并从给定范围内靠背元素

       auto data = alloc_n_copy(il.begin(), il.end());

       free();

       elements = data.first;

       first_free = cap = data.second;

       return *this;

}

2）复合赋值运算符定义在类的内部，两者都返回左侧运算对象的引用

//复合赋值运算符

Sales_data& Sales_data::operator+=(const Sales_data &rhs) {

       units_sold += rhs.units_sold;

       revenue += rhs.revenue;

       return *this;

}

9、算数运算符

1）算术运算符定义为非成员函数，通常使用定义的复合赋值运算符来定义对应的算术运算符，这样可以简化过程。

//算数运算符--返回对象的拷贝

Sales_data operator+(const Sales_data &lhs, const Sales_data &rhs) {

       Sales_data sum = lhs;

       sum += rhs;

       return sum;

}

10、下标运算符

1）下标运算符必须是成员函数。

2）如果一个类包含下标运算符，则它通常会定义两个版本：一个返回普通引用，另一个是类的常量成员并返回常量引用。

//下标运算符

string& StrVec::operator[](size_t n) {

       return elements[n];

}

const string& StrVec::operator[](size_t n) const{

       return elements[n];

}

11、递增和递减运算符

1）前置递增和递减

StrBlobPtr& StrBlobPtr::operator++() {

       check(curr,"increment past end of StrBlobPtr");//如果已经指向了容器的尾后位置，那么无法继续递增它

       ++curr;

       return *this;

}

StrBlob& StrBlobPtr::operator--() {

       --curr;

       check(curr, "decrement past end of StrBlobPtr");

       return *this;

}

a、递增和递减应该同时定义前置版本和后置版本，通常应该定义为类的成员函数。

b、为了区分前置和后置运算符，后置版本接受一个额外的（不被使用）int类型的形参。

c、后置操作调用了前置操作。

d、为了与内置版本保持一致，前置运算符返回对象的引用，而后置运算符返回原来对象的一个拷贝。

2）后置递增和递减

//后置递增和递减

StrBlobPtr StrBlobPtr::operator++(int) {

       StrBlobPtr ret = *this;

       ++(*this);//调用前置的操作

       return ret;

}

StrBlobPtr StrBlobPtr::operator--(int) {

       StrBlobPtr ret = *this;

       --(*this);

       return ret;

}

3）调用

//重载前置和后置递增递减运算符

StrBlobPtr p;

p.operator++();//调用后置运算符

p.operator++();//调用前置运算符

12、成员访问运算符

1）箭头运算符必须是类的成员函数，解引用运算符通常也是。

2）因为访问成员不会改变对象状态，所以定义为const。

3）注意箭头运算符的限定，P505

//成员访问运算符

string& StrBlobPtr::operator*()const {

       auto p = check(curr, "dereference past end");

       return (*p)[curr];

}

string* StrBlobPtr::operator->()const {

       //将实际工作委托给解引用运算符

       return &(this->operator*());

}

巴特西

[C++] 重载运算符与类型转换（1）

最新文章

热门文章