首页 > 其他分享 >运算符重载

运算符重载

时间：2024-05-03 21:14:19浏览次数：27  
标签：const int ++ 运算符 operator 重载 Integer

运算符重载

基本规则

可以重载的运算符：

不可重载的运算符：

//返回类型 operator后面加运算符(参数列表)
//eg.  Integer operator+(Integer l, Integer r);

class Integer{
public:
    Integer(int n = 0) : i(n) {}
    const Integer operator+(const Integer& v){	//在类中定义运算符重载函数
        return Integer(i+v.i);
    }
    const void print_i(){ cout << i << endl; }
private:
    int i;
};

int main()
{
    Integer x(10),y(20);
    Integer z = x + y;	//相当于 x.operator+(y)
    z.print_i();	//打印结果
    
    z = x + 3;	//ok，打印出13
    z.print_i();	
    
    z = 3 + 7;	//ok,将10传给构造函数创建一个Integer对象
    z.print_i();
    
    z = 3 + y;	//error，3不是Integer对象，没有实现运算符重载，会报错
    z.print_i();	
    
    return 0;
}

由上面的例子可以看到，z = 3 + y会报错，因为3不是Integer对象，双目运算符重载调用的是运算符左边的对象的运算符重载函数。可将成员函数修改为全局函数(在类中将该函数添加friend关键字)。

class Integer{
public:
    Integer(int n = 0) : i(n) {}
    friend const Integer operator+(const Integer& l, const Integer& r);
    const void print_i(){ cout << i << endl; }
private:
    int i;
};

const Integer operator+(const Integer& l, const Integer& r){	//全局函数
        return Integer(l.i + r.i);
}

int main()
{
    Integer x(10),y(20);
    Integer z = x + y;	//相当于 x.operator+(y)
    z.print_i();	//打印结果
    
    z = x + 3;	//ok，打印出13
    z.print_i();	
    
    z = 3 + 7;	//ok,将10传给构造函数创建一个Integer对象
    z.print_i();
    
    z = 3 + y;	//ok，会调用全局函数 
    z.print_i();	
    
    return 0;
}

是否将运算符重载设置为成员函数的基本规则：

1、单目运算符应该被设置为成员函数

2、= () [] -> ->*必须设置为成员函数

3、赋值运算符应该被设置为成员函数

4、其他的双目运算符应该作为全局函数(如+、-、*、/等)


原型

常见操作符的原型：

操作符++和--，++和--也是可以实现运算符重载，怎么区分是++x还是x++？

首先要了解a++和++a的区别：

a++可以这么理解：先对a原来的值(a=5)拷贝一份，接着执行a = a + 1，最后将之前拷贝的副本赋值给b，于是就有b = 5, a = 6

++a可以这么理解：先执行a = a + 1，最后将新的结果a = 7赋值给b，于是就有b = 7, a = 7

int main()
{
    int a = 5;
    int b = a++;	//b = 5, a = 6
    cout << "b = " << b << ",a = " << a <<endl;
    int c = ++a;	//a = 7, c = 7
    cout << "c = " << c << ",a = " << a <<endl;
    
    return 0;
}

输出结果：


++、--运算符的重载

按照这样的运算规则对++运算符进行重载。

class Integer{
public:
    Integer(int n = 0) : i(n) {}
    friend const Integer operator+(const Integer& l, const Integer& r);
    friend const Integer operator-(const Integer& l, const Integer& r);
    const int get() { return i;}
    const Integer& operator++();	//++x，++做前缀
    const Integer operator++(int);	//x++，int并不会作为形参传递，返回的是一个新的Integer对象，所以不加引用
    const Integer& operator--();	//--x，--做前缀
    const Integer operator--(int);	//x--，int并不会作为形参传递
private:
    int i;
};

//对'+'运算符重载
const Integer operator+(const Integer& l, const Integer& r){	//全局函数
        return Integer(l.i + r.i);
}

//直接对原来对象的值进行修改
const Integer& Integer::operator++(){
    *this = *this + 1;  //调用'+'的重载函数
    return *this;   //返回一个integer对象，加&是是因为这是对原来的对象的直接修改
}

//返回值不加引用是因为返回的是一个局部对象，return后实际上会执行一个拷贝构造函数操作
const Integer Integer::operator++(int){ //返回一个新创建的对象
    Integer old(*this);
    ++(*this);  //调用上面的++重载函数
    return old;
}

//实现--x
const Integer& Integer::operator--(){
    *this = *this - 1;
    return *this;
}

//实现x--
const Integer Integer::operator--(int){
    Integer old(*this); //拷贝构造函数
    --(*this);  //调用--x的重构函数
    return old;
}


int main()
{
    Integer x(5);
    Integer y = x++;
    cout << "y.i = " << y.get() << ", x.i = " << x.get() << endl;
    Integer z = ++x;
    cout << "z.i = " << z.get() << ", x.i = " << x.get() << endl;
    
    return 0;
}

可以看到输出结果与上个例子结果一致。


关系运算符的重载

通过==重载来实现!=的重载，通过<重载来实现>、<=、>=的重载，这么写的好处是充分利用已有函数，后期修改只需修改两个函数。

class Integer{
public:
    Integer(int n = 0) : i(n) {}
    friend const Integer operator+(const Integer& l, const Integer& r); //友元函数
    friend const Integer operator-(const Integer& l, const Integer& r);
    const int get() { return i;}
    const Integer& operator++();	//++x，++做前缀
    const Integer operator++(int);	//x++，int并不会作为形参传递，返回的是一个新的Integer对象，所以不加引用
    const Integer& operator--();	//--x，--做前缀
    const Integer operator--(int);	//x--，int并不会作为形参传递
    //overload relational operators
    bool operator==(const Integer& r) const;
    bool operator!=(const Integer& r) const;
    bool operator<(const Integer& r) const;
    bool operator<=(const Integer& r) const;
    bool operator>=(const Integer& r) const;
    bool operator>(const Integer& r) const;

private:
    int i;
};

// overload relational operators definition
bool Integer::operator==(const Integer& r) const{
    return (i == r.i);
}

bool Integer::operator!=(const Integer& r) const{
    return !(*this == r);   //调用==的重载函数
}

bool Integer::operator<(const Integer& r) const{
    return i < r.i;
}

bool Integer::operator>(const Integer& r) const{
    return r < *this;   //调用<的重载函数
}

bool Integer::operator<=(const Integer& r) const{
    return !(r < *this);   //调用>的重载函数, <=就是>取反
}

bool Integer::operator>=(const Integer& r) const{
    return !(*this < r);   //调用<的重载函数, >=就是<取反
}


int main()
{
    Integer x(5);
    Integer y(7);
    
    cout << boolalpha << (x < y) <<endl;	//调用x.operator<(y)，boolalpha使得打印出bool类型
    cout << boolalpha << (x > y) <<endl;
    cout << boolalpha << (x == y) <<endl;
    
    return 0;
}

输出结果：


类型转换

用户定义的类型转换：当构造函数是单个参数或运算符转换的隐式类型转换时编译器会进行隐式转换。

C++类型转换：

对于用户定义的类型，有两种方法实现T==>C。一是C中存在用T作为单个参数传递的构造函数，二是T中存在用运算符重载的方式实现T==>C。

构造函数实现自动类型转换

#include <iostream>

class One{
public:
    One()  {}   
};

class Two{
public:
    Two(const One&){}
};


void f(Two){}

int main()
{
    One one;    
    f(one);     //wants a Two, has a one

    return 0;
}

f()函数需要Two类型的对象作为参数，当将对象one作为参数传递时，编译器会查找是否存在用类One来构建类Two的构造函数，这时会调用Two::Two(const One&)，结果就是将Two的对象作为参数传递给f()。

自动类型转换可以避免定义两个不同版本的f()函数，但是自动类型转换会隐式地调用Two的构造函数，会对程序的效率有影响。

避免编译器使用构造函数实现自动类型转换需要加关键词explict，如下：

class One{
public:
    One()  {}   
};

class Two{
public:
    explicit Two(const One&){}
};


void f(Two){}

int main()
{
    One one;
    //f(one);		//error
    f(Two(one));     //ok，Two(one)创建了一个临时的对象将其作为参数传递给f()
    return 0;
}

运算符重载实现自动类型转换

class Three{
private:
    int i;
public:
    Three(int ii) : i(ii) {}
};

class Four{
private:
    int x;
public:
    Four(int xx) : x(xx) {}
    operator Three() const { return Three(x); } //函数名就是要转换的类型，所以最前面不用加返回值类型
};

void g(Three) {}

int main()
{
    Four four(1);
    g(four);	//实现Four==>Three，再将转换后的对象传递给g()
    g(1);		//调用Three(1,0)
    return 0;
}

自动类型转换的缺陷

当上述提到的两种自动类型转换的情况同时存在时，就会产生一个模糊的转换，两种方式都能实现隐式的自动类型转换，编译器不知道使用哪种方式，就会出现报错的情况

class Orange{
public:
    Orange(const Apple&);       //Convert Apple to Orange
};


class Apple{
public:
    operator Orange() const;    //Convert Apple to Orange
};

void f(Orange){ }

int main()
{
    Apple a;
    //f(a);       //ambiguous conversion
    return 0;
}

类型转换总结

尽量不要使用这种自动类型转换，函数调用时会出现各种问题，使用显式类型转换函数，如double ToDouble()来代替operator double() const。


参考资料：

Thinking in C++，Chapter 12 Operator Overloading

浙江大学翁凯C++教程

标签：const,int,++,运算符,operator,重载,Integer
From： https://www.cnblogs.com/qianxiaohan/p/18171607

相关文章

  • python教程2：变量+数据类型+运算符
    一、变量程序是从上到下依次逐⾏执⾏的，所以变量必须先定义，后调⽤，否则会报错变量定义规范 二、数据类型1、数字类型可⽤type()⽅法来查看数据类型 2、字符串多引号多引号什么作⽤呢？作⽤就是多⾏字符串必须⽤多引号字符串拼接3、布尔类型布尔类型很简单，就两个......
  • day1-py注释、变量、运算符
    一、python注释1、注释单行注释：#，ctrl+/多行注释:三对单引号、双引号注释的作用：备注，解释说明注意:注释的代码是不会执行的二、变量1、变量是什么变量存储数据的值变量=值(数据类型)#将数据的值赋值给变量2、变量名的命名规则1）只能由数字、字母、下划线组成2）不能用......
  • JavaScript运算符及优先级全攻略，点击立刻升级你的编程水平！
    在编程的世界里，运算符是构建逻辑、实现功能的重要工具。它能帮助我们完成各种复杂的计算和操作。今天，我们就来深入探索JavaScript中运算符的奥秘，掌握它们的种类和优先级，让你的代码更加高效、简洁！一、什么是运算符运算符，顾名思义，就是用于执行特定操作的符号。在JavaScript中，运......
  • C++里也有菱形运算符？
    最近在翻《c++函数式编程》的时候看到有一小节在说c++14新增了“菱形运算符”。我寻思c++里好像没什么运算符叫这名字啊，而且c++14新增的功能很少，我也不记得有添加这种语法特性。一瞬间我有些怀疑我的记忆了，所以为了查漏补缺，我写了这篇文章。什么是菱形运算符这个概念在Java里比......
  • 逻辑运算符
        逻辑运算符包含：&&,||,!。但是逻辑运算符不要求它操作数的值也为0或者1，C语言会把任何零值当作false，任何非零值当作true。    其中需要特别注意的是，&&和||会对操作数进行"短路"计算。也就是说，这些操作符会首先计算左操作数的值，然后计算右操作......
  • 运算符的分类
    运算符的分类JS中的运算符，分类如下：算数运算符自增/自减运算符一元运算符三元运算符（条件运算符）逻辑运算符赋值运算符比较运算符下面来逐一讲解。算术运算符用于执行两个变量或值的算术运算。此外，算数运算符存在隐式类型转换的情况，前文“数据类型转换......
  • shell-文件运算符
    一、常用文件测试运算符文件是否存在：[[-efilename]]是否可读:[[-rfilename]]是否可写:[[-wfilename]]是否可执行:[[-xfilename]]是否为空:[[-sfilename]]是否为目录：[[-dfilename]]是否为普通文件:[[-ffile......
  • C++多态与虚拟：函数重载（Function Overloading）
    重载（Overloading）：所谓重载是指不同的函数实体共用一个函数名称。例如以下代码所提到的CPoint之中，有两个memberfunctions的名称同为x():1classCPoint{23public:4floatx();5voidx(floatxval);67};  其两个memberfunctions实现代码如下：1f......
  • 使用 Gradio 的“热重载”模式快速开发 AI 应用
    在这篇文章中，我将展示如何利用Gradio的热重载模式快速构建一个功能齐全的AI应用。但在进入正题之前，让我们先了解一下什么是重载模式以及Gradio为什么要采用自定义的自动重载逻辑。如果您已熟悉Gradio并急于开始构建，请直接跳转到第三部分构建文档分析应用。重载模式具体是......
  • python身份运算符
    在Python中，身份运算符用于比较两个对象的内存地址，即它们是否引用了同一个对象。Python中的身份运算符包括is和isnot。is：如果两个变量引用了同一个对象，则返回True。isnot：如果两个变量引用的不是同一个对象，则返回True。下面是一个简单的示例：x=[1,2,3]y=[1,2,......

赞助商

阅读排行

网站主页关于我们联系我们网站地图

本网站内容转载自其他媒体，侵权联系[admin##ips99.com]。

Copyright © 2020-2023 IPS99 版权所有 IPS99