《C++ Primer》学习笔记（十四）：重载运算与类型转换

悠悠 2023-02-11 10:28 1阅读 0赞

### 《C++ Primer》学习笔记（十四）：重载运算与类型转换 ###

*  输入和输出运算符
 *  算术和关系运算符
 *  赋值运算符
 *  下标运算符
 *  递增和递减运算符
 *  成员访问运算符
 *  函数调用运算符
 *   *  标准库定义的函数对象
     *  可调用对象与function

**当一个重载的运算是成员函数时，`this`绑定到左侧运算对象。成员运算符函数的（显式）参数数量比运算对象的数量少一个。**

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzI1ODAwMzEx_size_16_color_FFFFFF_t_70]

//一个非成员函数的等价调用
    data1 + data2; //普通的表达式
    operator+(data1, data2); //等价的函数调用
    
    data1 += data2; //基于“调用的表达式”
    data1.operator+=(data2); //对成员运算符函数的等价调用

**注意：因为使用重载的运算符本质上是一次函数调用，所以这些关于运算对象求值顺序的规则无法应用到重载的运算符上。特别是，逻辑与运算符、逻辑或运算符和逗号运算符的运算对象求值顺序规则无法保留下来。除此之外，`&&`和`||`运算符的重载版本也无法保留内置运算符的短路求值属性，两个运算对象总是会被求值。因此不建议重载它们，因为可能使得用户一直习惯的求值规则不再适用。**

下面的准则有助于我们在**将运算符定义为成员函数还是普通的非成员函数**做出选择：

*  赋值（`=`）、下标（`[]`）、调用（`()`）和成员访问箭头（`->`）必须是成员函数。
 *  复合赋值运算符（例如`+=`）一般来说应该是成员，但并非必须，这一点与赋值运算符略有不同。
 *  改变对象状态的运算符或者与给定类型密切相关的运算符，如递增、递减和解引用运算符，通常应该是成员。
 *  具有对称性的运算符可能转换任意一端的运算对象，例如算术、相等性、关系和位运算符等，因此它们通常应该是普通的非成员函数。

**当我们把运算符定义为成员函数时，它的左侧运算对象必须是运算符所属类的一个对象。**

string s = "world";
    string t = s + "!";//正确：我们能把一个const char *加到一个string对象中
    string u = "hi"+s; //如果+是string的成员，则产生错误。因为"hi"+s等价于"hi".operator+(s)，而"hi"的类型是const char *,这是一种内置类型，没有这个成员函数

# 输入和输出运算符 #

与`iostream`标准库兼容的输入输出运算符必须是普通的非成员函数，而不能是类的成员函数。为了读写类的非公有数据成员，一般声明为友元。

ostream &operator<<(ostream &os, const Sales_data &item)
    {
        
    	os << item.isbn() << " " << item.units_sold << " "
    	   << item.revenue << " " << item.avg_price();
    	return os;
    }
    
    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 
    operator+(const Sales_data &lhs, const Sales_data &rhs)
    {
        
    	Sales_data sum = lhs;
    	sum += rhs; //如果类定义了相关的复合赋值运算符，一般使用复合赋值运算符来实现算术运算符
    	return sum;
    }

bool operator==(const A &lhs, const A &rhs)
    {
        
    	return lhs.unm == rhs.num;
    }
    
    bool operator!=(const A &lhs, const A &rhs)
    {
        
    	return !(lhs==rhs);
    }

**注意：如果存在唯一一种逻辑可靠的`<`定义，则应该考虑为这个类定义`<`运算符。如果类还同时包含`==`，则当且仅当`<`的定义和`==`产生的结果一致时才定义`<`运算符。**

# 赋值运算符 #

除了拷贝赋值运算符和移动赋值运算符外，标准库`vector`还定义了接受花括号内的元素列表作为参数的赋值运算符。为了与内置类型的赋值运算符保持一致，这个赋值运算符也返回其左侧运算对象的引用。

class StrVec{
        
    public:
    	StrVec &operator=(std::initializer_list<std::string>);
    }
    
    StrVec &operator=(std::initializer_list<std::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;
    }

**复合赋值运算符**通常情况下也定义为类成员。

//作为成员的二元运算符，左侧运算对象绑定到隐式的this指针
    Sales_data& Sales_data::operator+=（const Sales_data &rhs)
    {
        
    	units_sold += rhs.units_sold;
    	revenue += rhs.revenue;
    	return *this;
    }

# 下标运算符 #

\*\*下标运算符必须定义为成员函数。\*\*最好同时定义下标运算符的常量版本和非常量版本，当作用于一个常量对象时。下标运算符返回常量引用以确保我们不会为返回的对象赋值。

class StrVec{
        
    public:
    	std::string& operator[](std::size_t n)
    		{
        return elements[n];}
    	const std::string& operator[](std::size_t n) const
    		{
        return elements[n];}
    	
    private:
    	std::string *elements; //指向数组首元素的指针
    }

# 递增和递减运算符 #

定义递增和递减运算符的类应该同时定义前置和后置两个版本, 定义为类成员。后置版本接受一个额外的（不被使用）的`int`类型的形参。

class StrBlobPtr{
        
    public:
    	//递增和递减运算符
    	StrBlobPtr& operator++(); //前置++
    	StrBlobPtr operator++(int); //后置++
    
    	StrBlobPtr& operator--();//前置--
    	StrBlobPtr operator--(int);//后置--
    }
    
    StrBlobPtr& StrBlobPtr::operator++()
    {
        
    	check(curr, "increment past end of StrBlobPtr");
    	++curr; 
    	return *this;
    }
    
    StrBlobPtr StrBlobPtr::operator++(int)
    {
        
    	//此处无需检查有效性，调用前置运算符时才需要检查
    	StrBlob ret = *this; //记录当前的值
    	++*this; //前置++需要检查递增的有效性
    	return ret;
    }
    
    StrBlobPtr& StrBlobPtr::operator--()
    {
        
    	--curr; 
    	check(curr, "decrement past begin of StrBlobPtr");
    	return *this;
    }
    
    StrBlobPtr StrBlobPtr::operator--(int)
    {
        
    	//此处无需检查有效性，调用前置运算符时才需要检查
    	StrBlob ret = *this; //记录当前的值
    	--*this;//前置--需要检查递增的有效性
    	return ret;
    }

# 成员访问运算符 #

class StrBlobPtr{
        
    public:
    	std::string& operator*() const
    	{
        
    		auto p = check(curr, "dereference past end");
    		return (*p)[curr]; //*p是对象所指的vector
    	}
    
    	std::string* operator->() const
    	{
        
    		//将实际工作委托给解引用运算符
    		return & this->operator*();
    	}
    }

**重载的箭头运算符必须返回类的指针或者自定义了箭头运算符的某个类的对象。**

# 函数调用运算符 #

如果类重载了函数调用运算符，则可以像使用函数一样使用该类的对象（这种对象称为**函数对象**）。因为这样的类同时也能存储状态，所以与普通函数相比它们更加灵活。一个类可以定义多个不同版本的调用运算符，相互之间应该在参数数量或类型上有所区别。

struct absInt{
        
    	int operator()(int val) const{
        
    		return val<0 ? -val : val;
    	}
    }
    
    int i = -42;
    absInt absObj; //含有函数调用运算符的对象
    int ui = absObj(i); //将i传递给absObj.operator()

## 标准库定义的函数对象 ##

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzI1ODAwMzEx_size_16_color_FFFFFF_t_70 1]  
表示运算符的函数对象类常用来替换算法中的默认运算符。例如排序算法默认使用`operator<`来将序列升序排列，如果要执行降序排列，可以传入一个`greater`类型的对象。

sort(svec.begin(), svec.end(), greater<string>());

标准库规定其函数对象对于指针同样适用。

vector<string *> nameTable; //指针的vector
    //错误：nameTable中的指针彼此之间没有关系，所以<产生未定义的行为
    sort(nameTable.begin(), nameTable.end(), 
    		[](string *a, string *b) {
        return a<b;});
    
    //正确：标准库规定指针的less是定义良好的
    sort(nameTable.begin(), nameTable.end(), less<string *>());

## 可调用对象与function ##

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzI1ODAwMzEx_size_16_color_FFFFFF_t_70 2]

//列举了可调用对象与二元运算符对应关系的表格
    //所有可调用对象都必须接受两个int、返回一个int
    //其中的元素可以是函数指针、函数对象或者是lambda
    map<string, function<int(int,int)>> binops = {
        
    	{
        "+", add},                              //函数指针
    	{
        "-", std::minus<int>()},                //标准库函数对象
    	{
        "/", divide()},                         //用户定义的函数对象
    	{
        "*", [](int i, int j) {
        return i*j;}),   //未命名的lambda
    	{
        "%", mod} };                            //命名了的lambda对象

注意不能（直接）将重载函数的名字存入`function`类型的对象中，解决二义性的方法是存储函数指针而非函数名字：

int (*fp) (int, int) = add;
    binnops.insert( {
        "+", fp} );

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzI1ODAwMzEx_size_16_color_FFFFFF_t_70]: https://img-blog.csdnimg.cn/20200523122136692.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzI1ODAwMzEx,size_16,color_FFFFFF,t_70
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzI1ODAwMzEx_size_16_color_FFFFFF_t_70 1]: https://img-blog.csdnimg.cn/20200524102018948.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzI1ODAwMzEx,size_16,color_FFFFFF,t_70
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzI1ODAwMzEx_size_16_color_FFFFFF_t_70 2]: https://img-blog.csdnimg.cn/20200524105841818.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzI1ODAwMzEx,size_16,color_FFFFFF,t_70