zoukankan      html  css  js  c++  java
  • C++运算符重载学习总结

    在C ++中,我们可以使运算符适用于用户定义的类。 这意味着C ++能够为运算符提供数据类型的特殊含义,这种能力称为运算符重载

    例如,我们可以在像String这样的类中重载运算符'+',这样我们就可以通过使用+来连接两个字符串。

    其它示例中算术运算符可以重载的的类是复数,小数,大整数等。

    运算符重载的语法格式:

    Return_Type classname :: operator op(Argument list)

    {

        Function Body

    }

    在上面的语法中,Return_Type是要返回给另一个对象的值类型,operator op是运算符是关键字的函数,op是要重载的运算符。

    运算符函数必须是非静态(成员函数)或友元函数。

    运算符重载可以通过三种方法完成,它们是

    1)      重载一元运算符。

    2)      重载二元运算符。

    3)      使用友元函数重载二元运算符。

     

    以下是定义运算符函数的一些条件/规则:

    l  在非静态函数的情况下,二元运算符应该只有一个参数,而一元不应该有一个参数。

    l  在友元函数的情况下,二元运算符应该只有两个参数,而一元应该只有一个参数。

    l  如果实现了运算符重载,则所有类成员对象都应该是公共的。

     

    运算符函数和普通函数有什么区别?

    运算符函数与普通函数相同。 唯一的区别是,运算符函数的名称始终是operator关键字,后跟运算符符号,并且在使用相应的运算符时调用运算符函数。

     

    除了极个别的运算符外,大部分运算符都可以被重载。

    以下是可以重载的运算符列表:

    以下是不可以重载的运算符列表:

    为什么(点),::,?:和sizeof不可以重载看这里解释。

     

    关于运算符重载的重要方面:

    1)为了使操作符重载起作用,其中一个操作数必须是用户定义的类对象。

    2)赋值运算符:编译器自动为每个类创建一个默认赋值运算符。 默认赋值运算符确实将右侧的所有成员分配到左侧,并且在大多数情况下都能正常工作(此行为与复制构造函数相同)。

    3)转换运算符:我们还可以编写可用于将一种类型转换为另一种类型的转换运算符。重载的转换运算符必须是成员方法。 其他运算符可以是成员方法或全局方法。

    4)任何可以用单个参数调用的构造函数都可以用作转换构造函数,这意味着它也可以用于隐式转换为正在构造的类。

     

    综合例子:学习测试,仅供参考!

    OperatorOverloadingClass.h
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    31
    32
    33
    34
    35
    36
    37
    38
    39
    40
    41
    42
    43
    44
    45
    46
    47
    48
    49
    50
    51
    52
    53
    54
    55
    56
    57
    58
    59
    60
    61
    62
    63
    64
    65
    66
    67
    68
    69
    70
    71
    72
    73
    74
    75
    76
    77
    78
    79
    80
    81
    82
    83
    84
    85
    86
    87
    88
    89
    90
    91
    92
    93
    94
    95
    96
    97
    98
    99
    100
    101
    102
    103
    104
    105
    106
    107
    108
    109
    110
    111
    112
    113
    114
    115
    116
    117
    118
    119
    120
    121
    122
    123
    124
    125
    126
    127
    128
    129
    130
    131
    132
    133
    134
    135
    136
    137
    138
    139
    140
    141
    142
    143
    144
    145
    146
    147
    148
    149
    150
    151
    152
    153
    154
    155
    156
     
    #ifndef OPERATOROVERLOADINGCLASS_H
    #define OPERATOROVERLOADINGCLASS_H

    #include <iostream>
    using namespace std;

    const int SIZE = 10;

    class OperatorOverloadingClass
    {
    public:
        OperatorOverloadingClass();
        OperatorOverloadingClass(
    const int &number,
                                 
    const float &fnumber);

        
    // 赋值运算符
        void operator = (const OperatorOverloadingClass &obj)
        {
            m_number = obj.m_number;
        }

        
    // 函数调用()运算符
        OperatorOverloadingClass operator()(int a, int b, int c)
        {
            OperatorOverloadingClass D;
            
    // just put random calculation
            D.m_number = a + b + c;
            
    return D;
        }

        
    void print();

        
    /* OperatorOverloading
        */

        
    // 算术运算符
        // +
        OperatorOverloadingClass operator + (const OperatorOverloadingClass &obj);
        
    // -
        OperatorOverloadingClass operator - (const OperatorOverloadingClass &obj);
        
    // *
        OperatorOverloadingClass operator * (const OperatorOverloadingClass &obj);
        
    // /
        OperatorOverloadingClass operator / (const OperatorOverloadingClass &obj);
        
    // %
        OperatorOverloadingClass operator % (const OperatorOverloadingClass &obj);

        
    // 关系运算符
        // <
        bool operator < (const OperatorOverloadingClass &obj);
        
    // >
        bool operator > (const OperatorOverloadingClass &obj);
        
    // <=
        bool operator <= (const OperatorOverloadingClass &obj);
        
    // >=
        bool operator >= (const OperatorOverloadingClass &obj);
        
    // ==
        bool operator == (const OperatorOverloadingClass &obj);
        
    // !=
        bool operator != (const OperatorOverloadingClass &obj);

        
    // 位运算符
        // ^
        OperatorOverloadingClass operator ^ (const OperatorOverloadingClass &obj);
        
    // &
        OperatorOverloadingClass operator & (const OperatorOverloadingClass &obj);
        
    // |
        OperatorOverloadingClass operator | (const OperatorOverloadingClass &obj);

        
    // 逻辑运算符
        // &&
        bool operator && (const OperatorOverloadingClass &obj);
        
    // ||
        bool operator || (const OperatorOverloadingClass &obj);

        
    // 取地址运算符&
        int *operator &()
        {
            
    return &this->m_number;
        }
        
    // 内存操作运算符*
        int operator *(OperatorOverloadingClass *obj)
        {
            
    return obj->m_number;
        }

        
    // 输入输出运算符
        // <<
        friend ostream &operator<<(ostream &output, const OperatorOverloadingClass &obj )
        {
            output << 
    "number : " << obj.m_number;
            
    return output;
        }
        
    // >>
        friend istream &operator>>(istream &input, OperatorOverloadingClass &obj)
        {
            input >> obj.m_number;
            
    return input;
        }

        
    // 自增自减运算符
        // ++i
        OperatorOverloadingClass operator ++();
        
    // i++
        OperatorOverloadingClass operator ++(int);
        
    // --i
        OperatorOverloadingClass operator --();
        
    // i--
        OperatorOverloadingClass operator --(int);

        
    // 数组成员访问运算符[]
        int &operator[](int i)
        {
            
    if( i > SIZE )
            {
                cout << 
    "Index out of bounds" << endl;
                
    // return first element.
                return arr[0];
            }
            
    return arr[i];
        }

        
    // 类成员访问运算符->
        // https://www.cnblogs.com/codingmengmeng/p/9064702.html


        
    // 复合赋值运算符:+=、-=、*=、/=、%=、<<=、>>=、^=、&=、|=
        void operator += (const OperatorOverloadingClass &obj)
        {
            m_number += obj.m_number;
        }
        
    // 其余类似

        
    // 重载类型转换
        operator int()
        {
            
    return m_number;
        }
        
    operator float()
        {
            
    return m_fnumber;
        }

        
    // new delete
        void *operator new(size_t size);
        
    void operator delete(void *p);
        
    void *operator new[](size_t size);
        
    void operator delete[](void *p, size_t size);

    private:
        
    int     m_number;
        
    float   m_fnumber;
        
    int     arr[SIZE];
    };

    #endif // OPERATOROVERLOADINGCLASS_H
     OperatorOverloadingClass.cpp
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    31
    32
    33
    34
    35
    36
    37
    38
    39
    40
    41
    42
    43
    44
    45
    46
    47
    48
    49
    50
    51
    52
    53
    54
    55
    56
    57
    58
    59
    60
    61
    62
    63
    64
    65
    66
    67
    68
    69
    70
    71
    72
    73
    74
    75
    76
    77
    78
    79
    80
    81
    82
    83
    84
    85
    86
    87
    88
    89
    90
    91
    92
    93
    94
    95
    96
    97
    98
    99
    100
    101
    102
    103
    104
    105
    106
    107
    108
    109
    110
    111
    112
    113
    114
    115
    116
    117
    118
    119
    120
    121
    122
    123
    124
    125
    126
    127
    128
    129
    130
    131
    132
    133
    134
    135
    136
    137
    138
    139
    140
    141
    142
    143
    144
    145
    146
    147
    148
    149
    150
    151
    152
    153
    154
    155
    156
    157
    158
    159
    160
    161
    162
    163
    164
    165
    166
    167
    168
    169
    170
    171
    172
    173
    174
    175
    176
    177
    178
    179
    180
    181
    182
    183
    184
    185
    186
    187
    188
    189
    190
    191
    192
    193
    194
    195
    196
    197
    198
    199
    200
    201
    202
    203
    204
    205
    206
    207
    208
    209
    210
    211
    212
     
    #include "OperatorOverloadingClass.h"
    #include <QDebug>

    OperatorOverloadingClass::OperatorOverloadingClass()
    {
        m_number = 
    0;
        m_fnumber = 
    0.0;
        
    for(int i = 0; i < SIZE; i++)
        {
            arr[i] = i;
        }
    }

    OperatorOverloadingClass::OperatorOverloadingClass(
    const int &number,
            
    const float &fnumber)
        : m_number(number)
        , m_fnumber(fnumber)
    {
        
    for(int i = 0; i < SIZE; i++)
        {
            arr[i] = i;
        }
    }

    void OperatorOverloadingClass::print()
    {
        qDebug() << 
    "m_number =" << m_number;
    }

    OperatorOverloadingClass OperatorOverloadingClass::
    operator +(const OperatorOverloadingClass &obj)
    {
        OperatorOverloadingClass out;
        out.m_number = 
    this->m_number + obj.m_number;
        
    return out;
    }

    OperatorOverloadingClass OperatorOverloadingClass::
    operator -(const OperatorOverloadingClass &obj)
    {
        OperatorOverloadingClass out;
        out.m_number = 
    this->m_number - obj.m_number;
        
    return out;
    }

    OperatorOverloadingClass OperatorOverloadingClass::
    operator *(const OperatorOverloadingClass &obj)
    {
        OperatorOverloadingClass out;
        out.m_number = 
    this->m_number * obj.m_number;
        
    return out;
    }

    OperatorOverloadingClass OperatorOverloadingClass::
    operator /(const OperatorOverloadingClass &obj)
    {
        OperatorOverloadingClass out;
        out.m_number = 
    this->m_number / obj.m_number;
        
    return out;
    }

    OperatorOverloadingClass OperatorOverloadingClass::
    operator %(const OperatorOverloadingClass &obj)
    {
        OperatorOverloadingClass out;
        out.m_number = 
    this->m_number % obj.m_number;
        
    return out;
    }

    OperatorOverloadingClass OperatorOverloadingClass::
    operator ^(const OperatorOverloadingClass &obj)
    {
        OperatorOverloadingClass out;
        out.m_number = (
    this->m_number) ^ (obj.m_number);
        
    return out;
    }

    OperatorOverloadingClass OperatorOverloadingClass::
    operator &(const OperatorOverloadingClass &obj)
    {
        OperatorOverloadingClass out;
        out.m_number = (
    this->m_number) & (obj.m_number);
        
    return out;
    }

    OperatorOverloadingClass OperatorOverloadingClass::
    operator |(const OperatorOverloadingClass &obj)
    {
        OperatorOverloadingClass out;
        out.m_number = (
    this->m_number) | (obj.m_number);
        
    return out;
    }

    bool OperatorOverloadingClass::operator &&(const OperatorOverloadingClass &obj)
    {
        
    return (this->m_number) && (obj.m_number);
    }

    bool OperatorOverloadingClass::operator ||(const OperatorOverloadingClass &obj)
    {
        
    return (this->m_number) || (obj.m_number);
    }

    bool OperatorOverloadingClass::operator <(const OperatorOverloadingClass &obj)
    {
        
    if(m_number < obj.m_number)
        {
            
    return true;
        }
        
    return false;
    }

    bool OperatorOverloadingClass::operator >(const OperatorOverloadingClass &obj)
    {
        
    if(m_number > obj.m_number)
        {
            
    return true;
        }
        
    return false;
    }

    bool OperatorOverloadingClass::operator <=(const OperatorOverloadingClass &obj)
    {
        
    if(m_number <= obj.m_number)
        {
            
    return true;
        }
        
    return false;
    }

    bool OperatorOverloadingClass::operator >=(const OperatorOverloadingClass &obj)
    {
        
    if(m_number >= obj.m_number)
        {
            
    return true;
        }
        
    return false;
    }

    bool OperatorOverloadingClass::operator ==(const OperatorOverloadingClass &obj)
    {
        
    if(m_number == obj.m_number)
        {
            
    return true;
        }
        
    return false;
    }

    bool OperatorOverloadingClass::operator !=(const OperatorOverloadingClass &obj)
    {
        
    if(m_number != obj.m_number)
        {
            
    return true;
        }
        
    return false;
    }

    // overloaded prefix ++ operator
    OperatorOverloadingClass OperatorOverloadingClass:: operator++ ()
    {
        ++m_number;          
    // increment this object
        return OperatorOverloadingClass(m_number, 0.0);
    }

    // overloaded postfix ++ operator
    OperatorOverloadingClass OperatorOverloadingClass:: operator++( int )
    {

        
    // save the orignal value
        OperatorOverloadingClass T(m_number, 0.0);

        
    // increment this object
        ++m_number;

        
    // return old original value
        return T;
    }

    // overloaded prefix -- operator
    OperatorOverloadingClass OperatorOverloadingClass:: operator-- ()
    {
        --m_number;          
    // increment this object
        return OperatorOverloadingClass(m_number, 0.0);
    }

    // overloaded postfix -- operator
    OperatorOverloadingClass OperatorOverloadingClass:: operator--( int )
    {

        
    // save the orignal value
        OperatorOverloadingClass T(m_number, 0.0);

        
    // increment this object
        --m_number;

        
    // return old original value
        return T;
    }

    void *OperatorOverloadingClass::operator new(size_t size)
    {
        
    return malloc(size);
    }


    void OperatorOverloadingClass::operator delete(void *p)
    {
        free(p);
    }

    inline void *OperatorOverloadingClass::operator new[](size_t size)
    {
        OperatorOverloadingClass *p = (OperatorOverloadingClass *)malloc(size);
        
    return p;
    }

    inline void OperatorOverloadingClass::operator delete[](void *p, size_t size)
    {
        free(p);
    }
  • 相关阅读:
    10000个线程更新同一行数据
    CountDownLatchTest
    创建 oracle dblin
    extjs日期控件使用
    JAVA Date超强工具类,可直接取代util.Date使用
    JSP&Servlet学习手册
    JAVA 文本 TXT 操作工具类
    Leetcode 526.优美的排列
    Leetcode 525.连续数组
    Leetcode 523.连续的子数组和
  • 原文地址:https://www.cnblogs.com/MakeView660/p/11102349.html
Copyright © 2011-2022 走看看