运算符重载C++

最新推荐文章于 2025-01-03 18:46:37 发布

转载最新推荐文章于 2025-01-03 18:46:37 发布 · 572 阅读

98 篇文章

订阅专栏

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) 当需要重载运算符具有可交换性时，选择重载为友元函数。