精华内容
下载资源
问答
  • __iter__和__next__是在类中自动实现迭代协议的运算重载符。 例如: class square: def __init__(self, start, stop): self.value = start -1 self.stop = stop def __iter__(self): return self def __...

    __iter__和__next__是在类中自动实现迭代协议的运算重载符。
    例如:

    class square:
    	def __init__(self, start, stop):
    		self.value = start -1 
    		self.stop = stop
    	def __iter__(self):
    		return self
    	def __next__(self):
    		if self.value == self.stop:
    		 	raise StopIteration
    		 self.value += 1
    		 return self.value ** 2
    

    以上我们使用了iter运算重载符,当我们声明一个类的实例时,这个实例就自动是一个迭代器,如果我们调用next方法时,就会自动调用类中的next方法,进行运算。加粗样式

    展开全文
  • C# 四则运算符重载

    2010-04-07 16:24:33
    四则运算符重载 代码简单 源代码公开 四则运算符重载 代码简单 源代码公开 四则运算符重载 代码简单 源代码公开 四则运算符重载 代码简单 源代码公开
  • 编程语言:C++ 编译环境:VS2008 实现功能:分数与整数的混合运算,包括正负数的运算 参考方向:操作符重载 适用于初学者的参考和学习
  • 操作符重载其实和函数没什区别,要记住的是: 重载运算操作的参数列表比普通函数少一个。表达式中最左边的对象是调用操作符重载函数的对象,而最右边的那个将被作为参数传送。  形式为:  返回类型 operator ...

         操作符重载其实和函数没什区别,要记住的是: 重载运算操作符的参数列表比普通函数少一个(  对于成员操作符,隐式的this指针被用作隐式的第一个参数)。表达式中最左边的对象是调用操作符重载函数的对象,而最右边的那个将被作为参数传送。

         形式为:

                 返回类型 operator 操作符 (参数列表){}

    总结提要:

     1.重载运算符:
         对于成员操作符,隐式的this指针被用作隐式的第一个参数。


    2.C++要求,=,[],(),->必须被定义为成员操作符。


    3.只有在C++预定义操作符集中的操作符才可以被重载。
       eg:
         int operator**();
    //error


    4.对于内置的操作符,它的预定义意义不能被改变。也不能为内置的数据类型定义其它的操作符。
       eg:
          int operator+(int,int);
    //error,不能为int重新定义内置的操作符


    5.程序员只能为类类型或枚举类型的操作时定义重载操作符。


    6.预定义的操作符优先级不能被改变。


    7.操作符预定义的操作个数必须被保留
       eg:
         bool operator!(int,int);
    //error,一元的逻辑非不能有两个参数


    8.重载后置运算符
       < type > ClassName :: operator ++ ( int )
      {  
          ......
      }
          
       friend <type> operator ++(ClassName &,int);


    9.重载operator[]下标运算符时建议返回引用类型,否则无法进行赋值操作
      eg:
       class A
       {
         public:
            ......
              char& operator[](int index);
          private:
            char *str;
        }
        
        A a("hello");
        a[1]='\a';
    //ok  如果重载为char operator[](int index); 则出错


    10.重载函数调用操作符operator();
       eg:
        class MyInt
    {
    public:
    int operator()(int abs);
    };


    int MyInt:: operator()(int abs)
    {
    return abs>=0?abs:-abs;
    }
    int main()
    {
      
    MyInt mi;
    cout<<mi(-1)<<endl;
    //1
    return 0;
    }



    下面给出一个仿C++string类的MyString类,该类重载了大部分常见的运算操作符。

    MyString.h


    #ifndef MyString_H

    #define MyString_H


    #include<iostream>
    using namespace std;
    class MyString
    {
    public:
    MyString():_size(0),str(NULL){};
        MyString(char *str);
    MyString(MyString &cp);
    char *c_str(){return str;}
    ostream& print(ostream &os)
    {
    if(str)
    {
    os<<str;
    }
    return os;
    }
    MyString& operator=(char *str);
    MyString& operator=(MyString &cp);
    MyString& operator+=(char *rstr);
    MyString& operator+=(MyString &cp);
    bool operator==(MyString &other)const;
    bool operator!=(MyString &other)const;
    bool operator>(MyString &other)const;
    bool operator<(MyString &other)const;
    bool operator==(char *other)const;
    bool operator!=(char *other)const;
    bool operator>(char *other)const;
    bool operator<(char *other)const;
    ~MyString(){ delete [] str;}
    private:
    int _size;
    char *str;
    static int length(char *str);
    static void copy(char *&des,char *source);
    static void constructor_init(MyString *ms,char *str);
    static int compare(char *str1,char *str2);

    };

    #endif



    MyString.cpp

    #include"MyString.h"


    //计算字符串的个数,不包括'\0';
    int MyString::length(char *str)
     {
    int count=0;
    while(str[count++]);
    return count-1;
     }


    //复制字符串
    void MyString::copy(char *&des,char *source)
    {
    int len=length(source);
    des=new char[len+1];
    int index=0;
    while(source[index])
    {
    des[index]=source[index];
    index++;


    }
    des[index]='\0';


    }


    //比较两字符串的大小
    int MyString::compare(char *str1,char *str2)
    {
    int index=0;
    while(str1[index]&&str2[index])
    {
    if(str1[index]!=str2[index])
        {
    return str1[index]-str2[index];
    }
    index++;
    }



    return (str1[index]=='\0'&&str2[index]=='\0')?0:(str1[index]=='\0'?-1:1);
    /*
    *
    等价于上面的语句
    if(str1[index]=='\0'&&str2[index]=='\0')
    {
    return 0;
    }
    else
    {
    if(str1[index]=='\0')
    {
    return -1;

    else
    {
    return 1;
    }
    }
    */
    }




    /*
     *用来初始化构造函数,由于MyString(char *)和MyString(MyString &cp)有相同的
     *部分,所以抽取出来,注意,这里的MyString *ms只能传递this指针,否则私有成员
     *无法访问
     */

    void MyString::constructor_init(MyString *ms,char *str)
    {
    if(str)
    {
    int len=length(str);
    ms->_size=len;
    copy(ms->str,str);

            }
    else
    {
    ms->_size=0;
    ms->str=NULL;
    }
    }


    MyString::MyString(char *str)
    {
        constructor_init(this,str);
    }




    MyString:: MyString(MyString &cp)
    {
    constructor_init(this,cp.c_str());
    }


    //重载字符串型的=运算符
    MyString& MyString::operator=(char *str)
    {
    if(str)
    {
    if(this->str)
    {
     delete [] this->str;
    }
    copy(this->str,str);
    this->_size=length(str);

        }
    return *this;


    }


    //重载MyString型的=运算符
    MyString& MyString::operator=(MyString &cp)
    {
    operator=(cp.c_str());
    return *this;
    }


    //重载字符串型的+=运算符
    MyString& MyString::operator+=(char *rstr)
    {
    if(rstr)
    {
     int len=_size+length(rstr);
     char *mstr=new char[len+1];
     int index=0;
     if(str)
     {
        while (str[index])  //把原字符串复制到mstr
        {
       mstr[index]=str[index];
       index++;
        }
     }
     int index1=0;
      while (rstr[index1])//把rstr接到mstr的尾部
     {
     mstr[index]=rstr[index1];
     index++;
     index1++;
     }
      mstr[index]='\0';
      *this=mstr;
      _size=len;
    }
         return *this;
    }


    //重载MyString型的+=运算符
    MyString& MyString::operator+=(MyString &cp)
    {
    operator+=(cp.c_str());
    return *this;
    }


    //重载字符串型的==运算符
    bool MyString::operator==(char *other)const
    {
    int len=length(other);
    if(_size==len)
    {
    int index=0;
    while((str[index]==other[index])&&other[index])
    {
    index++;
    }
    if(index==_size)
    {
    return true;
    }
    else
    {
    return false;
    }


    }
    return false;
    }


    //重载字符串型的+=运算符
    bool MyString::operator!=(char *other)const
    {
    if(operator==(other))
    {
     return false;
    }
    else
    {
    return true;
    }
    }


    //重载字符串型的>运算符
    bool MyString::operator>(char *other)const
    {
    return compare(str,other)>0?true:false;
    }


    //重载字符串型的<运算符
    bool MyString::operator<(char *other)const
    {

    return compare(str,other)<0?true:false;
    }


    //重载MyString型的==运算符
    bool  MyString::operator==(MyString &other)const
    {
    return operator==(other.c_str());
    }


    //重载MyString型的!=运算符
    bool  MyString::operator!=(MyString &other)const
    {
    return operator!=(other.c_str());
    }


    //重载MyString型的>运算符
    bool  MyString::operator>(MyString &other)const
    {
    return operator>(other.c_str());
    }


    //重载MyString型的<运算符
    bool  MyString::operator<(MyString &other)const
    {
    return operator<(other.c_str());
    }



    main.cpp

    #include<iostream>
    using namespace std;
    #include"MyString.h"


    //重载输出流<<
    ostream& operator<<(ostream &os,MyString &str)
    {


    str.print(os);
    return os;
    }


    int main(void)
    {

    MyString str;
    //测试无参构造函数
    MyString str1("hello");//测试字符串参构造函数
    str+=str1;   //测试MyString型+= 
    str+=" how "; //测试字符串型+= 
    MyString str2("are you");
    MyString str3(str2);//测试MyString型构造函数
    str+=str2;
    cout<<str<<endl;//输出hello how are you


    cout<<endl;


    MyString str4("hello");
    cout<<(str1==str4)<<endl;//1
    cout<<(str1!=str4)<<endl;//0
    cout<<(str1>str4)<<endl;//0
    cout<<(str1<str4)<<endl;//0


    cout<<endl;


    cout<<(str1=="hello")<<endl;//1
    cout<<(str1!="hello")<<endl;//0
    cout<<(str1>"hello")<<endl;//0
    cout<<(str1<"hello")<<endl;//0


    cout<<endl;


    MyString str5("helloa");
    cout<<(str1==str5)<<endl;//0
    cout<<(str1!=str5)<<endl;//1
    cout<<(str1>str5)<<endl;//0
    cout<<(str1<str5)<<endl;//1


    cout<<endl;


    cout<<(str1=="helloa")<<endl;//0
    cout<<(str1!="helloa")<<endl;//1
    cout<<(str1>"helloa")<<endl;//0
    cout<<(str1<"helloa")<<endl;//1


    cout<<endl;


    MyString str6("helloa");
    cout<<(str6==str1)<<endl;//0
    cout<<(str6!=str1)<<endl;//1
    cout<<(str6>str1)<<endl;//1
    cout<<(str6<str1)<<endl;//0


    cout<<endl;


    MyString str7("nihao");
    str1=str7;
    cout<<str1<<endl;//输出nihao
    str1="thanks";
    cout<<str1<<endl;//输出thanks
    return 0;
    }


    运行结果:



    展开全文
  • C++之自定义类型加法运算操作符重载概述:示例代码:.h(加法运算符重载类).cpp使用类:.h.cppover:文末一句话: 概述: 1.成员函数方式重载加法运算符; 2.全局函数重载加法操作运算符; 2.全局函数重载加法操作...

    概述:

    1.成员函数方式重载加法运算符;
    2.全局函数重载加法操作运算符;
    3.全局函数重载加法操作运算符(自定义类型和int);

    示例代码:

    .h(加法运算符重载类)

    #ifndef OPERATORADD_H
    #define OPERATORADD_H
    
    /**
     ** time   :    2020/1/3 PM21:41
     ** author :    Fantast
     ** declare:    加法运算符重载类
     **             1.成员函数方式重载加法运算操作符
     **             2.全局函数方式重载加法运算操作符
     **             3.函数重载加法运算操作符
     **/
    
    #include <QObject>
    
    class OperatorAdd
    {
    public:
        OperatorAdd();
        ~OperatorAdd();
    
    public:
        /**
         * @brief operator +    加法运算符重载(1.成员函数方式重载加法运算符)
         * @param oper
         * @return
         */
        OperatorAdd operator+(const OperatorAdd &oper);
    
    public:
        int m_A;
        int m_B;
    };
    
    /**
     * @brief operator +    全局函数重载加法操作运算符
     * @param p1
     * @param p2
     * @return
     */
    OperatorAdd operator+(OperatorAdd &p1,OperatorAdd &p2);
    OperatorAdd operator+(const OperatorAdd &oper,const int &num);
    
    #endif // OPERATORADD_H
    

    .cpp

    #include "OperatorAdd.h"
    
    OperatorAdd::OperatorAdd()
    {
    }
    
    OperatorAdd::~OperatorAdd()
    {
    }
    //成员函数
    OperatorAdd OperatorAdd::operator+(const OperatorAdd &oper)
    {
        OperatorAdd add;
        add.m_A = this->m_A + oper.m_A;
        add.m_B = this->m_B + oper.m_B;
        return add;
    }
    //全局函数
    OperatorAdd operator+(OperatorAdd &p1, OperatorAdd &p2)
    {
        OperatorAdd add;
        add.m_A = p1.m_A + p2.m_A;
        add.m_B = p1.m_B + p2.m_B;
        return add;
    }
    
    OperatorAdd operator+(const OperatorAdd &oper, const int &num)
    {
        OperatorAdd add;
        add.m_A = oper.m_A + num;
        add.m_B = oper.m_B + num;
        return add;
    }
    
    

    使用类:

    .h

    #ifndef OPERATOR_H
    #define OPERATOR_H
    
    #include <QWidget>
    #include <QDebug>
    
    namespace Ui {
    class Operator;
    }
    
    class Operator : public QWidget
    {
        Q_OBJECT
    
    public:
        explicit Operator(QWidget *parent = 0);
        ~Operator();
    
    private slots:
        void on_pushButton_Add1_clicked();
    
        void on_pushButton_clicked();
    
        void on_pushButton_Add2_clicked();
    
    private:
        void OperatorAddTestMemberFunc();
    
        void OperatorAddTestSituationFunc();
    
        void OperatorAddTestMemberIntFunc();
    
    private:
    	//把数据加载到界面
        void setDataToUi(const QString &text1,const QString &text2);
    
    private:
        Ui::Operator *ui;
    };
    
    #endif // OPERATOR_H
    

    .cpp

    #include "Operator.h"
    #include "ui_Operator.h"
    #include "OperatorAdd.h"
    
    Operator::Operator(QWidget *parent) :
        QWidget(parent),
        ui(new Ui::Operator)
    {
        ui->setupUi(this);
    
    }
    
    Operator::~Operator()
    {
        delete ui;
    }
    
    void Operator::OperatorAddTestMemberFunc()
    {
        OperatorAdd add1;
        add1.m_A = 10;
        add1.m_B = 10;
        OperatorAdd add2;
        add2.m_A = 20;
        add2.m_B = 20;
        OperatorAdd add3 = add1 + add2;
        //成员函数本质调用(同上)
        //OperatorAdd add3 = add1.operator +(add2);
        setDataToUi(QString::number(add3.m_A,10),QString::number(add3.m_B,10));
    }
    
    void Operator::OperatorAddTestSituationFunc()
    {
        OperatorAdd add1;
        add1.m_A = 20;
        add1.m_B = 20;
        OperatorAdd add2;
        add2.m_A = 20;
        add2.m_B = 20;
        OperatorAdd add3 = add1 + add2;
        //全局函数本质调用(同上)
        //OperatorAdd add3 = operator +(add1,add2);
        setDataToUi(QString::number(add3.m_A,10),QString::number(add3.m_B,10));
    }
    
    void Operator::OperatorAddTestMemberIntFunc()
    {
        OperatorAdd add1;
        add1.m_A = 20;
        add1.m_B = 20;
        OperatorAdd add3 = add1 + 110;
        //全局函数本质调用(同上)
        //OperatorAdd add3 = operator +(add1,add2);
        setDataToUi(QString::number(add3.m_A,10),QString::number(add3.m_B,10));
    }
    
    void Operator::setDataToUi(const QString &text1, const QString &text2)
    {
        ui->textBrowser->append(QString("%1-%2").arg(text1).arg(text2));
    }
    
    void Operator::on_pushButton_Add1_clicked()
    {
        OperatorAddTestMemberFunc();
    }
    
    void Operator::on_pushButton_clicked()
    {
        OperatorAddTestMemberIntFunc();
    }
    
    void Operator::on_pushButton_Add2_clicked()
    {
        OperatorAddTestSituationFunc();
    }
    
    

    over:

    欢迎大家关注作者在文末评论、点赞、转发以及批评指正!
    如果大家有更好的方法或有问题可以在文末评论一起讨论!
    共同学习!
    共同进步!

    文末一句话:

    我昊哥说了:人间正道是沧桑!
    铁子努力吧!要不然吃羊肉串都得闻味味啊!

    展开全文
  • 重载抽取运算f<<

    2012-06-13 12:43:32
    重载抽取运算fu friend ostream& operator ostream& operator { os os return os; }
      
    

    重载抽取运算fu<<

    friend ostream& operator<<(ostream& os,complex&);

    ostream& operator<<(ostream &os,complex &a)
    {
    os<<a.x<<"+";
    os<<a.y<<"i";

    return os;
    }

    展开全文
  • 实例003——操作符重载实现编译多态——复数的加法运算 实例003——操作符重载实现编译多态——复数的加法运算 实例003——操作符重载实现编译多态——复数的加法运算
  • c++赋值运算重载

    2014-04-09 13:14:01
    c++赋值运算符重载 stringvar
  • 2、 编写C++程序完成以下功能: (1) 实现复数类的运算重载:+,-,*,/,^(乘方)。
  • 编程语言:C++ 编译环境:VS2008 实现功能:分数运算重载 参考方向:C++ 操作符重载 适用于初学者参考
  • 一、操作符重载 1.什么是操作符重载 就是把一些操作通过关键字operator,组装成一个函数,关键字operator后面接需要重载的操作符号 2.为什么需要重载操作? (1)简单、方便,比起封装一个函数,使用...
  • 关于函数重载——复数运算的详细代码,有关于函数重载——复数运算所使用主要代码,以及重要的思想 及函数结构
  • 操作符重载

    2015-09-04 16:54:45
    可以使用操作,操作非默认类型的操作数。 让同样的操作执行不同的操作(操作其他...1、只能重载已经存在的操作(与函数重载不同),能创造一个新操作。 2、操作数的数目也应和原始定义一致 。1+2;Point +
  • 今天有朋友在成都程序员QQ群里提出一个的问题:在一个类的拷贝构造函数里,是否可以调用重载后的赋值运算操作,以便用一套代码来方便地实现对类成员的赋值处理。00001: class Foo {00002: public:00003: Foo(const...
  • 1.被重载的操作符不可以通过连接其他符号来创建新的操作。 2.重载操作必须有一个类类型或者枚举类型的操作数。 3.内置类型的操作,含义能改变,如整数加法(+)。 4.重载后的运算符可以保证操作的...
  • C++ 操作符重载

    千次阅读 2017-04-26 10:11:36
    操作符重载是为了运算更加符合我们在数学上的使用习惯。 1. 定义  operator   2. 原则  1)遵循已有操作的语法,如单目只能重载成单目  2)遵循已有操作的语义(但这个不是必须的)  3)操作符重载...
  • For this task, put your code in the following files: Matrix.cpp, Matrix.h. You are to write a class Matrix which includes appropriate fields associated with 2*2 matrices. A 2*2 matrix takes the ...
  • C++高精度运算类bign (重载操作)

    千次阅读 多人点赞 2014-04-20 09:31:22
    大数据操作,有如下问题: 计算:456789135612326542132123+14875231656511323132  456789135612326542132123*14875231656511323132 比较:...long long类型存储了,存储了就实现不成计算
  • 重载,在一个类定义中,可以编写几个同名的方法,但是只要它们的签名参数列表...下面关于操作符重载的具体实例(单目运算的自增及自减) /* *operator.cpp *cDate : 2013-9-28 *Author: sjin *Mail:413977243@qq
  • c++运算符重载矩阵运算 题目:对具有同行列数的整形矩阵进行加、减、乘、转置、赋值运算
  • C++学习中的实验课题,编写函数实现运算符的重载重载方法实现对时分秒的运算。代码中有(单目、双目)加减法、等于、(前置、后置)自减自增。
  • C++ 重载操作- 01 简单的入门

    万次阅读 2016-09-21 14:46:44
    重载操作是C++语言的高级功能,当我们写一个类的时候,可以根据需要学一个重载操作,如果 需要,我们可以写。大量的操作都可以重载。可以重载的操作有42个。有4个操作可以重载的。下面写几个例子...
  • link中重载运算,但是不是位运算,而是输出,类似C++,这个可以实现么?
  • 类可以重载打印、函数调用、属性点号运算等内置运算 重载使类实例的行为像内置类型。 重载是通过特殊名称的类方法来实现的。 换句话说,当类中提供了某个特殊名称的方法,在该类的实例出现在它们相关的表达式时,...
  • C++复数运算的运算符重载

    千次阅读 2015-07-19 09:07:22
    C++提供了运算符重载,极大地方便了自定义类型之间的运算, 本文就最简单的复数运算实现让初学者体会运算符重载的作用以及运算符重载的原理。
  • PTA 7-13 分数加法运算重载(30 分)

    千次阅读 2018-05-17 21:17:50
    7-13 分数加法运算重载(30 分)相信同学们对复数运算符重载已经相当熟悉啦,那今天那我们来看看分数又该如何处理呢?定义一个分数类FS,有私有成员分子fz,分母fm。另有公有成员函数FS operator + (const FS &...
  • c++实现日期类(class Date) 构造函数 拷贝构造 操作符重载(输入输出 比较操作 算数运算 自增自减)
  • C++操作符重载

    2013-04-27 14:29:01
    一、什么是操作重载 ...运算符重载和函数重载的不同之处在于操作符重载重载的一定是操作。我们不妨先直观的看一下所谓的操作重载: 1 #include 2 3 using namespace std; 4 5 int main() 6 {
  • 编写一个密码类,其中包含一个 str 密码字符串私有成员数据,一个“==”运算 符重载成员函数,用于比较用户输入的密码是否正确。并用数据测试该类。

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 100,829
精华内容 40,331
关键字:

关于运算重载符重载的不正确