精华内容
参与话题
问答
  • 运算符重载 c++

    2017-01-05 15:20:06
    运算符重载形式 重载是c++的一大特性,不仅可以用于一般函数重载,还可以用于运算符重载,对于一些基本数据类型来说运算符可以直接拿来使用,所以运算符重载一般是应用于对象之间,而对象之间的运算符重载主要分为...

    运算符重载形式

      重载是c++的一大特性,不仅可以用于一般函数重载,还可以用于运算符重载,对于一些基本数据类型来说运算符可以直接拿来使用,所以运算符重载一般是应用于对象之间,而对象之间的运算符重载主要分为成员运算符重载和友元运算符重载两种形式。
    

    成员运算符重载:表示在类内定义的这个与运算符相关的函数是属于类的成员函数。所以他可以直接由对象调用对于双目运算符他只需要一个参数(另外一个参数其实就是调用它的对象)
    友元运算符重载:以友元函数的形式对对象进行运算符重载,所以对于双目运算符来说,它需要两个参数都写出来。

    #include<iostream>
    using namespace std;
    
    class A
    {
    public:
        A(int num);
        A operator +(int num);
        friend A operator+(int,const A&);
        void show();
    private:
        int _num;
    };
    A::A(int num)
    {
        _num = num;
    }
    A A::operator +(int num)
    {
        cout << "成员运算符重载:" << endl;
        A  a(this->_num + num);
        return a;
    }
    
    A operator+(int num, const A& a)
    {
        cout << "友元运算符重载:" << endl;
        //因为是类A的友元函数所以可以访问类A对象的私有成员
        A  b(num + a._num);
        return b;
    }
    void A::show()
    {
        cout << this->_num << endl;
    }
    int main()
    {
        A a(12);
        a = a + 2;
        a.show();
        a = 2 + a;
        a.show();
        system("pause");
        return 0;
    }

    这里写图片描述
    可以看出:

    对象在左边时调用的是成员运算符重载函数,而对象在右边时调用的是友元运算符重载函数,因为只有对象在左边时对象才可能访问自身的成员函数,对于双目运算符重载对象在运算符右边的情况则一定要使用有缘运算符重载才行。

    运算符重载种类

    一般运算符重载

        //加号重载
        A operator +(int num);
        friend A operator+(int, const A&);
        //减号重载
        A operator -(int num);
        friend A operator-(int, const A&);
        //乘号重载
        A operator *(int num);
        friend A operator*(int, const A&);
        //除号重载
        A operator /(int num);
        friend A operator/(int, const A&);
    具体函数实现参照上面加号重载的实现!    

    逻辑运算符重载

        bool operator || (const A&);
        bool operator && (const A&);
        bool operator ! ();
        bool A::operator&&(const A& a)
        {
            bool ret=false;
            if(a._num&&this->_num)
               ret=true;
            return ret;
        }
         bool A::operator||(const A& a)
        {
            bool ret=false;
            if(a._num||this->_num)
               ret=true;
            return ret;
        }
         bool A::operator!()
        {
            bool ret=false;
            if(!this->_num)
               ret=true;
            return ret;
        }

    这里的逻辑运算符的两个运算对象都是同一个类的对象所以只使用成员运算符重载即可,但如果两个运算对象是不同的类型则还需要使用友元运算符重载保证即使两个运算对象调换左右位置仍能正常达到运算符重载的效果。

    流运算符重载

    流运算符包括输入流和输出流。

    流运算符重载的两个运算对象一个是输入缓冲区/输出缓冲区,另一个是要输入/输出的对象。而类的对象在流运算符的右边,不能通过访问成员函数的形式调用运算符重载函数,所以只能使用友元运算符重载的形式。

        friend ostream& operator << (ostream&, A&);
        friend istream& operator >> (istream&, A&);
        ostream& operator << (ostream& output, A& a)
        {
            output<<a._num;
            return output;
        }
        istream& operator >> (istream& iutput, A& a)
        {
            input >> a._num;
            return input;
        }

    赋值运算符重载

        A& operator = (const A&);
        A& operator += (const A&);
        A& operator -= (const A&);
        A& operator *= (const A&);
        A& operator /= (const A&);
    
        A& A::operator += (const const A& a)
        {
             this->_num=this->_num+a._num;
             return *this;
        }

    因为是赋值运算符,所以在对对象赋值后还要返回对象的引用,这也是它与直接的四则运算符一个不同的地方(+,=,*,/只是返回一个临时对象!)。

    关系运算符

    关系运算的目的是为了判断俩个运算对象是不是满足某种关系,满足返回true,不满足返回false,所以关系运算符重载的返回值都为bool类型。

       bool operator > (const A& ); 
       bool operator < (const A& );
       bool operator == (const A& );
       bool operator >= (const A& );
       bool operator <= (const A& );
       bool A::operator >= (const A& a)
       {   bool ret=false;
           if(this->_num>a._num)
              ret=true;
           return ret;
       }
       //其它的类似

    四则运算符重载和拷贝构造函数的配合

    四则运算符重载函数返回的值是一个临时对象,在将这个返回值赋值给左值时根据左值的不同分为两种情况:
    对象3=对象1+对象2;
    这时返回值赋值给左值时会调用转换构造函数拿着这个返回值生成一个临时对象再将这个对象赋值给左值。
    类名 对象名=对象1+对象2
    这时返回值赋值给左值时,会直接调用拷贝构造函数,根据这个返回值生成新对象。

    以上不论哪种情况都会调用拷贝构造函数,所以如果类内含有指针,对四则运算符进行重载时一定要对拷贝构造函数重载使其从浅拷贝变为深拷贝!

    class A
    {
    public:
        A();
        A(char *);
        ~A();
        A operator +(const A&);
        A(const A&);
        void show();
    private:
        char* _data;
        int _len;
    };
    
    A::A() 
    {
        _len = 0;
        _data = nullptr;
    }
    
    A::A(char * str)
    {
        _len = strlen(str) + sizeof(char);
        _data = new char[_len];
        strcpy(_data, str);
    }
    
    A::~A()
    {
        if(_data)
           delete[] _data;
    }
    
    A A::operator +(const A& a)
    {
        char ch[255];
        strcpy(ch, _data);
        strcat(ch, a._data);
        A temp(ch);
        return temp;
    }
    
    //深拷贝,为新生成对象内部指针成员变量重新分配空间。
    A::A(const A& a)
    {
        this->_len = a._len;
        _data = new char[_len];
        strcpy(this->_data, a._data);
    }
    
    void A::show()
    {
        cout << this->_data << endl;
    }
    
    
    
    int main()
    {
        A a1("12");
        A a2("34");
        A a3= a1 + a2;
        a1.show();
        a2.show();
        a3.show();
        system("pause");
        return 0;
    }

    运行结果:

    这里写图片描述


    这里要注意的是:第一种情况中不仅要对拷贝构造函数重载还要对’=‘进行重载为对象的指针变量重新分配控件,不然在最后一步对象之间赋值时仍然会出错!

    展开全文
  • 运算符重载C++

    2013-03-19 20:38:44
    C++中预定义的运算符的操作...运算符重载的实质是函数重载,它提供了C++的可扩展性。 运算符重载是通过创建运算符函数实现的,运算符函数定义了重载的运算符将要进行的操作。运算符函数的定义与其他函数的定义类似,

    C++中预定义的运算符的操作对象只能是基本数据类型。但实际上,对于许多用户自定义类型(例如类),也需要类似的运算操作。这时就必须在C++中重新定义这些运算符,赋予已有运算符新的功能,使它能够用于特定类型执行特定的操作。运算符重载的实质是函数重载,它提供了C++的可扩展性。

    运算符重载是通过创建运算符函数实现的,运算符函数定义了重载的运算符将要进行的操作。运算符函数的定义与其他函数的定义类似,惟一的区别是运算符函数的函数名是由关键字operator和其后要重载的运算符符号构成的。运算符函数定义的一般格式如下:
    <返回类型说明符> operator <运算符符号>(<参数表>)
    {
    <函数体>
    }

    (1) 除了类属关系运算符"."、成员指针运算符".*"、作用域运算符"::"、sizeof运算符和三目运算符"?:"以外,C++中的所有运算符都可以重载。

    (2) 重载运算符限制在C++语言中已有的运算符范围内的允许重载的运算符之中,不能创建新的运算符。

    (3) 运算符重载实质上是函数重载,因此编译程序对运算符重载的选择,遵循函数重载的选择原则。

    (4) 用户自定义类的运算符一般都必须重载后方可使用,但两个例外,运算符“=”和“&”不必用户重载.

     

    哪些运算符可以用作重载?几乎所有的运算符都可用作重载。具体包含:
    算术运算符:=,-,*,/,%,++,--
    位操作运算符:—,|,~,^,<<,>>;
    逻辑运算符:!&&,||;
    比较运算符:>,<,>=,<=,==,!=
    赋值运算符:=,+=,- = ,*=,%=,\=^=,<<=,>>=;
    其他运算符:[ ],()->, ',new,delete,new[],delete[],->* .

     

    运算符有两种重载形式:成员函数形式和友元函数形式。这两种形式都可访问类中的私有成员。

    实例:自定义一个int包裹类,包装int,并且支持+运算符和=运算符

     

     1.用成员函数来重载运算符

    复制代码
    class Integer {
    public:
        Integer();
        Integer(int value);
        Integer operator+(int value);
        void operator=(int value);
    private:
        int m_value;
    };
    复制代码

     

    复制代码
    //integer.cpp
    #include "integer.h"
    
    Integer::Integer() {
        m_value = 0;
    }
    Integer::Integer(int value) {
        m_value = value;
    }
    
    Integer Integer::operator+(int value) {
        int tmpValue = m_value + value;
        return Integer(tmpValue);
    }
    
    void Integer::operator=(int value) {
         m_value = value;
    }
    复制代码



    使用示例:

     

    Integer integer = Integer(10); 
    Integer tmpInteger = 100; //重载=运算符
    tmpInteger = integer + 1; //重载+运算符

     

    2.使用友元函数来重载运算符

      使用成员函数重载运算符,我们做到了实现 integer + 1,可是如果是 1 + integer呢,这个时候我们必须使用友元函数重载+运算符:

     

    复制代码
    //integer.h
    class Integer {
    public:
        Integer();
        Integer(int value);
        Integer operator+(int value);
        void operator=(int value);
        operator int() const;
    private:
        int m_value;
        
    friend Integer operator+(int value, Integer integer);   
    };
    
    //Integer operator +(Integer integer, int value);  //不能声明该函数,否则会和成员函数冲突 
    Integer operator+(int value, Integer integer);
    复制代码

     

     

    复制代码
    //integer.cpp
    #include "integer.h"
    
    Integer::Integer() {
        m_value = 0;
    }
    Integer::Integer(int value) {
        m_value = value;
    }
    
    Integer Integer::operator+(int value) {
        int tmpValue = m_value + value;
        return Integer(tmpValue);
    }
    
    void Integer::operator=(int value) {
         m_value = value;
    }
    Integer::operator int() const {
        return m_value;
    }
    
    Integer operator+(int value, Integer integer) {
        int tmpValue = integer.m_value + value;
        return Integer(tmpValue);
    }
    复制代码

    使用示例:

     

    Integer integer = Integer(10);  
    Integer tmpInteger = 100;   //重载=运算符
    tmpInteger = integer + 1;   //重载Integer成员函数+运算符
    tmpInteger = 1 + tmpInteger;//重载友元函数+运算符

     

    转换运算符重载:

       从上述代码我们看到Integer integer = 1;(隐式调用构造函数),确实很方便,但是如果要实现 int i = Integer(100),实现自定义类型到内部类型的转换或者已有的类型,就需要转换运算符了。

       转换运算符的的形式如下:

       X::operator T()

       其中T是类型。

       代码示例如下:

       

    复制代码
    //integer.h
    class Integer {
    public:
        Integer();
        Integer(int value);
        Integer operator+(int value);
        void operator=(int value);
        operator int() const; //int 转换运算符 
    private:
        int m_value;
        
    friend Integer operator+(int value, Integer integer);   
    };
    
    //Integer operator +(Integer integer, int value);  //不能声明该函数,否则会和成员函数冲突 
    Integer operator+(int value, Integer integer);
    复制代码

     

    复制代码
    //integer.cpp
    #include "integer.h"
    
    #include <stdio.h>
    #include <stdlib.h>
    Integer::Integer() {
        m_value = 0;
    }
    Integer::Integer(int value) {
        m_value = value;
    }
    
    Integer Integer::operator+(int value) {
        int tmpValue = m_value + value;
        return Integer(tmpValue);
    }
    
    void Integer::operator=(int value) {
         m_value = value;
    }
    Integer::operator int() const {
        return m_value;
    }
    
    Integer operator+(int value, Integer integer) {
        int tmpValue = integer.m_value + value;
        return Integer(tmpValue);
    }
    复制代码

    使用示例:

     

    Integer integer = Integer(10);  
    Integer tmpInteger = 100;   //重载=运算符
    tmpInteger = integer + 1;   //重载Integer成员函数+运算符
    tmpInteger = 1 + tmpInteger;//重载友元函数+运算符
    int num = tmpInteger;       //重载int 转换运算符

     

     重载++运算符:

      前缀各后缀运算两种,为了区分这两种运算,将后缀运算符视为双目运算符,示例代码如下:

     

    复制代码
    //integer.h
    class Integer {
    public:
        Integer();
        Integer(int value);
        Integer operator+(int value);
        void operator=(int value);
        operator int() const; //int 转换运算符 
        Integer operator++(); //重载 ++Integer 
        Integer operator++(int value);//重载 Integer++ 
    private:
        int m_value;
        
    friend Integer operator+(int value, Integer integer);   
    };
    
    //Integer operator +(Integer integer, int value);  //不能声明该函数,否则会和成员函数冲突 
    Integer operator+(int value, Integer integer);
    复制代码

     

     

    复制代码
    //integer.cpp
    #include "integer.h"
    
    Integer::Integer() {
        m_value = 0;
    }
    Integer::Integer(int value) {
        m_value = value;
    }
    
    Integer Integer::operator+(int value) {
        int tmpValue = m_value + value;
        return Integer(tmpValue);
    }
    
    void Integer::operator=(int value) {
         m_value = value;
    }
    Integer::operator int() const {
        return m_value;
    }
    
    Integer Integer::operator++() {
        Integer tmpInteger;
        tmpInteger = ++m_value;
        return tmpInteger;
    }
    Integer Integer::operator++(int value) {
        Integer tmpInteger;
        tmpInteger = m_value++;
        return tmpInteger;
    }
        
    Integer operator+(int value, Integer integer) {
        int tmpValue = integer.m_value + value;
        return Integer(tmpValue);
    }
    复制代码

    使用示例:

     

    复制代码
        Integer integer = Integer(10);  
        Integer tmpInteger = 100;   //重载=运算符
        tmpInteger = integer + 1;   //重载Integer成员函数+运算符
        tmpInteger = 1 + tmpInteger;//重载友元函数+运算符
        int num = tmpInteger;       //重载int 转换运算符
        tmpInteger = integer++;     //重载 Integer++ 
        tmpInteger = ++integer;     //重载 ++Integer
    复制代码

     

    两种重载形式的比较:
    在多数情况下,将运算符重载为类的成员函数和类的友元函数都是可以的。但成员函数运算符与友元函数运算符也具有各自的一些特点:
    (1) 一般情况下,单目运算符最好重载为类的成员函数;双目运算符则最好重载为类的友元函数。
    (2) 以下一些双目运算符不能重载为类的友元函数:=、()、[]、->。
    (3) 类型转换函数只能定义为一个类的成员函数而不能定义为类的友元函数。
    (4) 若一个运算符的操作需要修改对象的状态,选择重载为成员函数较好。
    (5) 若运算符所需的操作数(尤其是第一个操作数)希望有隐式类型转换,则只能选用友元函数。
    (6) 当运算符函数是一个成员函数时,最左边的操作数(或者只有最左边的操作数)必须是运算符类的一个类对象(或者是对该类对象的引用)。如果左边的操作数必须是一个不同类的对象,或者是一个内部类型的对象,该运算符函数必须作为一个友元函数来实现。
    (7) 当需要重载运算符具有可交换性时,选择重载为友元函数。

    展开全文
  • 运算符重载 C++

    2012-05-20 18:39:58
    C++中预定义的运算符的操作对象...运算符重载的实质是函数重载,它提供了C++的可扩展性,也是C++最吸引人的特性之一。   运算符重载是通过创建运算符函数实现的,运算符函数定义了重载的运算符将要进行的操作
    
    
      C++中预定义的运算符的操作对象只能是基本数据类型。但实际上,对于许多用户自定义类型(例如类),也需要类似的运算操作。这时就必须在C++中重新定义这些运算符,赋予已有运算符新的功能,使它能够用于特定类型执行特定的操作。运算符重载的实质是函数重载,它提供了C++的可扩展性,也是C++最吸引人的特性之一。 

      运算符重载是通过创建运算符函数实现的,运算符函数定义了重载的运算符将要进行的操作。运算符函数的定义与其他函数的定义类似,惟一的区别是运算符函数的函数名是由关键字operator和其后要重载的运算符符号构成的。运算符函数定义的一般格式如下:

       

    <返回类型说明符> operator <运算符符号>(<参数表>)
    {

         
    <函数体>

    }

     运算符重载时要遵循以下规则:

    (1) 除了类属关系运算符"."、成员指针运算符".*"、作用域运算符"::"、sizeof运算符和三目运算符"?:"以外,C++中的所有运算符都可以重载。

    (
    2) 重载运算符限制在C++语言中已有的运算符范围内的允许重载的运算符之中,不能创建新的运算符。

    (
    3) 运算符重载实质上是函数重载,因此编译程序对运算符重载的选择,遵循函数重载的选择原则。

    (
    4) 重载之后的运算符不能改变运算符的优先级和结合性,也不能改变运算符操作数的个数及语法结构。

    (
    5) 运算符重载不能改变该运算符用于内部类型对象的含义。它只能和用户自定义类型的对象一起使用,或者用于用户自定义类型的对象和内部类型的对象混合使用时。

    (
    6) 运算符重载是针对新类型数据的实际需要对原有运算符进行的适当的改造,重载的功能应当与原有功能相类似,避免没有目的地使用重载运算符。

      运算符函数重载一般有两种形式:重载为类的成员函数和重载为类的非成员函数。非成员函数通常是友元。(可以把一个运算符作为一个非成员、非友元函数重载。但是,这样的运算符函数访问类的私有和保护成员时,必须使用类的公有接口中提供的设置数据和读取数据的函数,调用这些函数时会降低性能。可以内联这些函数以提高性能。)   

    成员函数运算符

     运算符重载为类的成员函数的一般格式为:

        
    <函数类型> operator <运算符>(<参数表>)

      
    {

         
    <函数体>

       }

      当运算符重载为类的成员函数时,函数的参数个数比原来的操作数要少一个(后置单目运算符除外),这是因为成员函数用this指针隐式地访问了类的一个对象,它充当了运算符函数最左边的操作数。因此:

    (1) 双目运算符重载为类的成员函数时,函数只显式说明一个参数,该形参是运算符的右操作数。

    (
    2) 前置单目运算符重载为类的成员函数时,不需要显式说明参数,即函数没有形参。

    (
    3) 后置单目运算符重载为类的成员函数时,函数要带有一个整型形参。

        调用成员函数运算符的格式如下:

        
    <对象名>.operator <运算符>(<参数>)

        它等价于

        
    <对象名><运算符><参数>

        例如:a
    +b等价于a.operator +(b)。一般情况下,我们采用运算符的习惯表达方式。

    友元函数运算符

     运算符重载为类的友元函数的一般格式为:

        friend 
    <函数类型> operator <运算符>(<参数表>)

       
    {

        
    <函数体>

       }

      当运算符重载为类的友元函数时,由于没有隐含的this指针,因此操作数的个数没有变化,所有的操作数都必须通过函数的形参进行传递,函数的参数与操作数自左至右一一对应。

     调用友元函数运算符的格式如下:

        
    operator <运算符>(<参数1>,<参数2>)

        它等价于

        
    <参数1><运算符><参数2>

        例如:a
    +b等价于operator +(a,b)。

    两种重载形式的比较

      在多数情况下,将运算符重载为类的成员函数和类的友元函数都是可以的。但成员函数运算符与友元函数运算符也具有各自的一些特点:

    (1) 一般情况下,单目运算符最好重载为类的成员函数;双目运算符则最好重载为类的友元函数。

    (
    2) 以下一些双目运算符不能重载为类的友元函数:=、()、[]、->

    (
    3) 类型转换函数只能定义为一个类的成员函数而不能定义为类的友元函数。

    (
    4) 若一个运算符的操作需要修改对象的状态,选择重载为成员函数较好。

    (
    5) 若运算符所需的操作数(尤其是第一个操作数)希望有隐式类型转换,则只能选用友元函数。

    (
    6) 当运算符函数是一个成员函数时,最左边的操作数(或者只有最左边的操作数)必须是运算符类的一 个类对象(或者是对该类对象的引用)。如果左边的操作数必须是一个不同类的对象,或者是一个内部 类型的对象,该运算符函数必须作为一个友元函数来实现。

    (
    7) 当需要重载运算符具有可交换性时,选择重载为友元函数。

    展开全文
  • 运算符重载c++

    2020-06-29 22:25:34
    1、运算符重载的概念 在c++中预定义的运算符只能操作基本的数据类型,在实际应用中,有些自定义的数据类型,如类和结构体,也需要类似的操作。 比如: class Complex //复数类 { private: double image; double real...

    1、运算符重载的概念
    在c++中预定义的运算符只能操作基本的数据类型,在实际应用中,有些自定义的数据类型,如类和结构体,也需要类似的操作。
    比如:

    class Complex    //复数类
    {
    private:
    double image;
    double real;
    public:
    Complex(double x=0.0,double y=0.0):real(x),image(y){}
    Complex Add(const Complex &c){Complex temp(real+c.real,image+c.image);return temp;}
    };
    int main(){Complex a(5,7),b(10,9),c;c=a.Add(b);}
    

    在这里的Add是复数之间的加法,而我们习惯上写为c=a+b;
    有两个整形(int)变量 i,j
    在编译器分析:i+j 时会解释:
    operator +(i,j)
    其中operator为关键字。当然编译器有许多这些的重载类型:
    operator +(int,int)
    operator +(float,float)
    operator +(double,double)
    所以系统会用operator +(int,int)与表达式operator +(i,j)进行匹配。这里既然系统预定义的运算符可以实现重载,那用户也可以向重载普通函数一样重载运算符函数。
    2、运算符重载的规则
    一般格式为:
    T operator @(参数表)
    {
    重载函数体
    }
    T为返回类型,@为运算符名称,参数表的个数取决于需要的操作数量。
    一般在对类的对象进行操作的函数中,都要能访问类的私有成员。所以一般定义运算符函数为成员函数(称为:成员运算符函数)或者友元函数(称为:友元运算符函数)
    c++允许重载的运算符
    算数运算符:+ - * / %
    关系运算符:==,!=,<,>,<=,>=
    逻辑运算符:&&,||,!
    赋值运算符:=,+=,-=,=,/=,%=,&=,^=,|=,<<=,>>=
    位运算符:|,&,~,^,<<,>>
    单目运算符:+,-,
    ,/
    自增,自减运算符:++,–
    动态内存操作运算符:new,delete,delete[]
    其他运算符:(),[]
    不允许重载
    成员运算符:.
    成员指针运算符:. *
    域操作运算符:::
    条件运算符:?:
    空间计算运算符:sizeof
    此外c++不允许定义新的运算符,只能对c++语言中预定义运算符进行重载
    3、运算符重载为友元函数
    声明的一般形式:
    friend T operator @(参数表);
    一般定义:
    T operator @(参数表)
    {
    //函数体
    }
    在类外定义时不需要加上域名。其中T为返回类型@为运算符名称
    双目运算符:
    friend T operator@(T a,T b);T为类型名(也是返回类型)@表示运算符,a为左操作数,b为右操作数。一般为了提高传参效率,参数通常都是引用类型。friend T operator@(T &a,T &b);
    单目运算符:
    friend T operator@(T a);T表示类名,@表示运算符,a为操作数。
    选择采用友元的方式的目的是希望尽量保持类的封装性。另外重载双目运算符时函数中的形参必须是两个,不能省略,重载的运算符不满足交换律。
    例如:
    希望将复数和一个整数相加,整数加到实数部分

    //声明为
    friend Complex operator +(Complex &c,int i);
    //定义为
    Complex operator +(Complex &c,int i){return(c.real+i,c.image);}
    //则有:
    c3=c1+5;//正确
    c3=5+c1;//错误,没有合适的匹配类型,需要在一次对函数进行相应的重载
    

    4、运算符重载为成员函数
    运算符重载为友元函数,相比于重载为友元函数;提高了类的独立性,保护了类的封装性。
    因此在一般情况下,应将类所涉及的所有操作都定义在类中,即应将类的运算符重载成类中的成员函数。因为是在类中定义的操作,操作的一方就是当前的对象,成员变量也可以自由访问。基于此,如果是双目运算符只需设置一个右侧运算量而左侧则为该对象本身;如果是单目运算符,就不必另外设置参数,运算符的操作量就是对象本身。
    举例:以Complex类,以成员函数重载减法“-”和相等比较运算“==”,以及求负取反符号“-”,说明运算符重载。

    class Complex    //复数类
    {
    private:
    	double image;
    	double real;
    public:
    	Complex(double x = 0.0, double y = 0.0) :real(x), image(y) {}//构造函数
    	Complex operator -() { return Complex(-real, -image); }//求负取反
    	Complex operator -(const Complex& c) {return Complex(real - c.real, image - c.image);}//减法操作,双目运算符
    	bool operator ==(const Complex& c) { return (real==c.real &&image==c.image ); }//判断是否相等
    	Complex& operator += (const Complex& c);
    	void show();//显示为复数类
    };
    
    Complex& Complex::operator+=(const Complex& c)
    {
    	real += c.real;
    	image += c.image;
    	return *this;
    }
    
    void Complex::show()
    {
    	cout << real << "+" << image << "!" << endl;
    }
    

    针对双目运算符被重载为成员函数,实质是运算符左侧的对象调用的自身的运算符函数函数,右侧的操作量作为运算符函数的参数,因此要求运算符左侧的操作量必须是类的对象。

    展开全文
  • C++ 运算符重载

    千次阅读 多人点赞 2018-12-26 21:39:21
    1. C++运算符重载的概念和原理 2. C++重载=(C++重载赋值运算符) 3. C++深拷贝和浅拷贝(C++深复制和浅复制) 4. C++运算符重载为友元函数 5. C++实现可变长度的动态数组 6. C++重载&lt;&lt;和&gt;...
  • C++学习笔记之运算符重载(赋值运算符,关系运算符重载)C++运算符重载 运算符重载 重载运算符 赋值运算符重载 C++编译器至少要给一个类添加4个函数 默认构造函数 默认析构函数 默认拷贝构造函数 赋值运算符 ...
  • 下面来进行这段代码的分析: struct node { //定义一个结构体node(节点)  int x;  int y; ... //node中有3个成员变量...a)const {//重载&lt;操作符。可以对两个node使用&lt;操作符进行比较  r...
  • 成员运算符重载函数 成员运算符重载函数,即把运算符重载函数定义为某个类的成员函数。 1、定义成员运算符重载函数的语法形式 (1)在类的内部,定义成员运算符重载函数的格式如下: 函数类型 operator 运算符(形参...
  • 一、++运算符重载 前置++运算符重载 成员函数的方式重载,原型为: 函数类型 & operator++(); 友元函数的方式重载,原型为: friend 函数类型 & operator++(类类型 &); 后置++运算符重载 成员函数的方式重载,原型...
  • C++村子里来了复数(Complex)一家子,也有俩兄弟c1和c2,想要来个累加,笨乎乎地,c1.add(c2)。c1和c2伤心极了,也想像其他小朋友一样,小手一拉,c1+c2,也能加起来。这个任务交给了正在看题的魔术师,帮他们一个...
  • 前言:C++基础已经学到一半了,开心中。因为之前楼主有看过视频,所以学...由于一般数据类型间的运算符没有重载的必要,所以运算符重载主要是面向对象之间的。 1.一般运算符重载 在进行对象之间的运算时,程序会调用与
  • 文章目录一、运算符重载二、复数类CComplex三、输出运算符重载 一、运算符重载 运算符重载: 使对象的运算运算表现得和编译器内置类型一样,使同一个运算符可以有不同的功能。即定义一个重载运算符的函数,使指定的...
  • c++ 运算符重载之成员函数重载
  • Problem A: 实现复数类中的加运算符重载【C++运算符重载】 Time Limit: 1 Sec Memory Limit: 128 MB Submit: 209 Solved: 136 [Submit][Status][Web Board] Description int家有i1和i2弟兄俩,小手一拉...
  • Problem A: 实现复数类中的加运算符重载【C++运算符重载】 Time Limit: 1 Sec Memory Limit: 128 MB Submit: 184 Solved: 122 [Submit][Status][Web Board] Description int家有i1和i2弟兄俩,...
  • 2.后置版本是否是新建了一个Triangular_iterator并将运算符的调用对象复制,那么为什么没有重载=运算符就能运算成功? 3.后置版本中的++_index到底是哪个对象的_index,是tmp的还是this的,最后返回的临时对象中的_...
  • C++学习笔记之运算符重载(加号+, 递增运算符++,–,左移运算符重载) 概念:   对已有的运算符重载重新进行定义,赋予其另一种功能以适应不同的数据类型 加号运算符重载 作用:实现两个自定义数据类型相加的运算...
  • 主要介绍了详解C++编程中的单目运算符重载与双目运算符重载,是C++入门学习中的基础知识,需要的朋友可以参考下
  • 还没看过的朋友可以点击链接前去看一下:C++ 运算符重载 https://blog.csdn.net/cpp_learner/article/details/104208689 其实他们之间的用法都是类似的,没有什么区别,都是围绕着关键字“operator"展开。 下面我举...
  • 运算符重载C++

    2018-04-25 14:25:58
    /*运算符重载 就是对已有的运算符(C ++中预定义的运算符)赋予多重的含义,是同一个运算符作用与不同类型的数据是导致不同类型的行为 实质:函数重载1 可以重载为普通函数也可以重载为成员函数2 把含运算符的表达式...
  • c++运算符重载

    2018-10-10 15:36:20
    c++运算符重载教学指导,用于理解重载运算符函数的作用、函数定义及函数实现

空空如也

1 2 3 4 5 ... 20
收藏数 24,045
精华内容 9,618
关键字:

运算符重载