《C++ primer》第14章重载操作符与转换

最新推荐文章于 2022-07-04 16:07:21 发布

梅始愚

最新推荐文章于 2022-07-04 16:07:21 发布

阅读量804

点赞数

分类专栏： C++

本文链接：https://blog.csdn.net/skyFuhrer/article/details/8853313

版权

C++ 专栏收录该内容

10 篇文章 0 订阅

订阅专栏

重载操作符的定义

保留字operator后接需要定义的操作符符号
重载操作符必须具有至少一个类类型或枚举类型操作数。不能重新定义用于内置类型对象的操作符的含义
优先级和结合性是固定的
不在具备短路特性
操作符定义为非成员函数时，通常将他们设置为类的友元
将要作关联容器键类型应定义<操作符。关联容器默认使用键类型的<操作符。例如sort用法，而find用法使用==操作符
选择那些操作符为成员函数：=,[],(),->,++,-- 普通的非成员函数：算数操作符，相等操作符，关系操作符，位操作符

输入输出操作符

支持I/O操作的类所提供的I/O接口，一般与iostream为内置类型的定义的接口相同，许多类应该重载输入输出操作符
为了与IO标准库一致，操作符应该接受ostream&作为第一个形参，对类类型const对象作为第二个形参，并返回对ostream形参的引用。
```
ostream & operator<<(ostream& os,const ClassType &object)
{
    os << // ....
    return os;
}
```
输出操作符应输出对象的内容，进行最小限度的格式化，不应该输出换行符
IO操作符必须定义为非成员函数，因为左操作数必须是类类型的对象 item << cout，不符合我们使用习惯，要想支持正常的使用方法，左操作数必须是ostream类型，而标准库不允许添加，所以唯一的方法是设置为非成员函数，将IO操作符设置为友元。
输入操作符第二个形参为非const引用，因为要把数据写入

输入操作符必须处理错误和文件结束的可能性

istream & operator>>(istream & in,Sales_item& s)
{
   double price;
    in >> s,isbn>>s.units_sold>>price;
    if(in)
       s.revenue = s.units_sold * price;
    else
       s = Sales_item();
     return in;
}

如果发生了错误，应将形参恢复为空的Sales_item对象，防止已经读入的部分导致以后输入的数据不一致

算术操作符和关系运算符

设置为非成员函数，为了保持与内置操作符保持一致，加法返回一个右值，而不是一个引用。
既定义了算数操作符又定义了复合赋值操作符，一般使用复合赋值操作符（+=）来实现算数操作符（+）
如果定义了==操作符，应该定义!=操作符，后者调用前者
定义了==操作的类更容易与标准库一起使用。例如find，默认使用==，如果定义了==，则这些算法可以无需任何特殊处理而用于该类类型

赋值操作符

类赋值操作符必须是类的成员，以便编译器可以知道是否需要合成一个
一般而言，赋值操作符返回的是左操作数的引用（*this）

下标操作符

下标操作符必须定义为类成员函数
类定义下标操作符的时候，一般需要两个版本，一个为非const成员并返回引用，另一个是const成员并返回const引用

成员访问操作符

箭头操作符必须定义为类成员函数。解引用操作符不要求定义为成员，但它作为成员一般也是正确的
构建更安全的指针（参考智能指针）

箭头操作符只是看上去像二元操作符，因为->的右操作数不是表达式，应该看成类成员的标识符

Screen p(& myScreen)
p->display(cout);
//p->operator()求值将调用ScreenPtr类的operator->，返回指向Screen对象的指针，该指针用于获得ScreenPtr所指对象的display成员

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

自增操作符和自减操作符

为了与内置类型一致，前缀操作符应返回被增量或减量的引用。
设计时，可以初始化beg,end从而确保curr超过数组的末端。（见示例）
区别操作符的前缀与后缀，普通重载不能区别前缀操作符还是后缀操作符，为了解决这一问题，后缀操作符接受一个额外的（无用）int型形参。
后缀操作符应当返回旧值，并且是值返回，而不是引用返回。

调用操作符与函数对象

可以为类类型对象重载函数操作符。这样函数名与普通变量实现了统一

struct absInt{
    int operator() (int val){
         return val < 0 ? -val : val;
    }
}
int i = -42;
absInt absObj;
unsigned int ui = absObj(i);

定义了调用操作符（()）的类，其对象称为函数对象，即它们的行为类似函数的对象。

将函数对象运用于标准库算法中，它比函数更加灵活

class GT-cls{
public:
    GT-cls(size_t val = 0):bound(val){}
    bool operator()(const string &s)
    { return s.size() >= bound;}
private:
    std::string::size_type bound;
};

cout << count_if(words.begin(),words.end(),GT_cls(6))<<.....

标准库也定义了一些函数对象，如plus<Type>等
函数适配器：绑定器和求反器，绑定器就是通过将一个操作数绑定而将二元对象转换为一元对象。

转换与类类型

我们可以用一个实参调用非explict构造函数定义隐式转换，这是定义了到类类型的转换
我们定义从类类型的转换，编译器将自动执行这个转换。这种转换可以方便诸如混合型表达式的操作
转换操作符通用形式：operator type() const { return ...;}，其中type是内置类型名，一般而言，不允许转换为函数类型和数组类型
转换函数必须是成员函数，不能指定返回类型，并且形参表必须为空
注意使用类类型的转换，太过自由，容易导致二义性
在调用重载函数时，需要使用构造函数或强制类型转换实参，这是设计拙劣的表现

本章代码

class CheckedPtr
{
public:
	CheckedPtr(void);
	~CheckedPtr(void);
	//默认构造函数
	CheckedPtr(int *b,int *e):beg(b),end(e),curr(b){}
	//自增操作符
	CheckedPtr& operator++();
	CheckedPtr& operator--();
	CheckedPtr operator++(int);
	CheckedPtr operator--(int);
	//下标操作符
	int& operator[](const size_t index);
	const int& operator[](const size_t index)const;
	//解引用操作符
	int& operator*();
	const int& operator*()const;
	//为相等操作符定义友元函数
	friend inline bool operator==(const CheckedPtr &lhs,const CheckedPtr &rhs);
	friend CheckedPtr operator+(const CheckedPtr &lhs,const size_t n);
	friend CheckedPtr operator-(const CheckedPtr &lhs,const size_t n);
private:
	int *beg;
	int *end;
	int *curr;
};

#include "CheckedPtr.h"
#include <stdexcept>

CheckedPtr::CheckedPtr(void)
{
}
CheckedPtr::~CheckedPtr(void)
{
}
CheckedPtr& CheckedPtr::operator++()
{
	if(curr == end)
	{
		throw std::out_of_range("超出末端");
	}
	++curr;
	return *this;
}
CheckedPtr& CheckedPtr::operator--()
{
	if(curr == beg)
	{
		throw std::out_of_range("超出首端");
	}
	--curr;
	return *this;
}
CheckedPtr CheckedPtr::operator++(int)
{
	CheckedPtr ret(*this);
	++*this;//调用前缀操作符
	return ret;
}
CheckedPtr CheckedPtr::operator--(int)
{
	CheckedPtr ret(*this);
	--*this;
	return ret;
}
int& CheckedPtr::operator[](const size_t index)
{
	if(index >= (end - beg))
		throw std::out_of_range("超出末端");
	if(index < 0)
		throw std::out_of_range("超出前端");
	return *(beg+index);
}
const int& CheckedPtr::operator[](const size_t index)const
{
	if(index >= (end - beg))
		throw std::out_of_range("超出末端");
	if(index < 0)
		throw std::out_of_range("超出前端");
	return *(beg+index);
}
int& CheckedPtr::operator*()
{
	if(curr >= end)
	{
		throw std::out_of_range("超出末端");
	}
	return *curr;
}
const int& CheckedPtr::operator*()const
{
	if(curr >= end)
	{
		throw std::out_of_range("超出末端");
	}
	return *curr;
}
inline bool operator==(const CheckedPtr &lhs,const CheckedPtr &rhs)
{
	//可以调用private数据么
	return (lhs.curr == rhs.curr && lhs.beg == rhs.beg && lhs.end == rhs.end )? true : false;
}
CheckedPtr operator+(const CheckedPtr &lhs,const size_t n)
{
	CheckedPtr temp(lhs);
	temp.curr += n;
	if(temp.curr > temp.end)
		throw std::out_of_range("超出末端");
	return temp;
}
CheckedPtr operator-(const CheckedPtr &lhs,const size_t n)
{
	CheckedPtr temp(lhs);
	temp.curr -= n;
	if(temp.curr < temp.beg)
		throw std::out_of_range("超出前端");
	return temp;
}