[知识点]c++运算符重载

于 2024-06-08 18:01:33 发布
阅读量1.5k 收藏 28
点赞数 14
文章标签： c++ 开发语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_33673253/article/details/139541480
版权

在 C++ 中，运算符重载（Operator Overloading）允许你定义或修改运算符的行为，使其适用于用户定义的类型（例如类或结构体）。通过运算符重载，你可以使自定义类型与内置类型一样自然地使用运算符。

重载运算符的基本原则

  1. 不能创建新的运算符：只能重载已有的 C++ 运算符。
  2. 不能改变运算符的优先级和结合性：重载运算符的优先级和结合性与原运算符相同。
  3. 必须有一个用户定义类型的操作数：至少有一个操作数是用户定义类型（类或结构体）。
  4. 某些运算符不能被重载：例如，::（作用域解析运算符）、.*（成员指针访问运算符）、.（成员访问运算符）、?:（三元运算符）等。

运算符重载的方法

运算符可以作为成员函数或非成员函数（通常是友元函数）进行重载。

成员函数重载
  • 一元运算符：无参数。
  • 二元运算符：一个参数。
非成员函数（友元函数）重载
  • 一元运算符：一个参数。
  • 二元运算符：两个参数。

常见运算符重载示例

1. 重载赋值运算符 =

赋值运算符通常作为成员函数重载，用于实现深拷贝。

#include <iostream>
#include <cstring>

class String {
private:
    char* data;
public:
    String(const char* str = "") {
        data = new char[strlen(str) + 1];
        strcpy(data, str);
    }

    String(const String& other) {
        data = new char[strlen(other.data) + 1];
        strcpy(data, other.data);
    }

    ~String() {
        delete[] data;
    }

    String& operator=(const String& other) {
        if (this != &other) {
            delete[] data;
            data = new char[strlen(other.data) + 1];
            strcpy(data, other.data);
        }
        return *this;
    }

    void print() const {
        std::cout << data << std::endl;
    }
};

int main() {
    String str1("Hello");
    String str2 = str1;
    String str3;
    str3 = str2;
    str1.print();
    str2.print();
    str3.print();
    return 0;
}
2. 重载算术运算符 +
#include <iostream>

class Complex {
private:
    double real, imag;
public:
    Complex(double r = 0.0, double i = 0.0) : real(r), imag(i) {}

    // 成员函数重载
    Complex operator+(const Complex& other) const {
        return Complex(real + other.real, imag + other.imag);
    }

    void print() const {
        std::cout << "(" << real << ", " << imag << ")" << std::endl;
    }
};

int main() {
    Complex c1(3.0, 4.0);
    Complex c2(1.0, 2.0);
    Complex c3 = c1 + c2;
    c3.print();
    return 0;
}
3. 重载关系运算符 ==
#include <iostream>

class Complex {
private:
    double real, imag;
public:
    Complex(double r = 0.0, double i = 0.0) : real(r), imag(i) {}

    // 成员函数重载
    bool operator==(const Complex& other) const {
        return real == other.real && imag == other.imag;
    }

    void print() const {
        std::cout << "(" << real << ", " << imag << ")" << std::endl;
    }
};

int main() {
    Complex c1(3.0, 4.0);
    Complex c2(3.0, 4.0);
    if (c1 == c2) {
        std::cout << "c1 is equal to c2" << std::endl;
    } else {
        std::cout << "c1 is not equal to c2" << std::endl;
    }
    return 0;
}
4. 重载输入输出运算符 << 和 >>

输入输出运算符通常作为友元函数重载。

#include <iostream>

class Complex {
private:
    double real, imag;
public:
    Complex(double r = 0.0, double i = 0.0) : real(r), imag(i) {}

    friend std::ostream& operator<<(std::ostream& os, const Complex& c) {
        os << "(" << c.real << ", " << c.imag << ")";
        return os;
    }

    friend std::istream& operator>>(std::istream& is, Complex& c) {
        is >> c.real >> c.imag;
        return is;
    }
};

int main() {
    Complex c1;
    std::cout << "Enter a complex number (real and imaginary part): ";
    std::cin >> c1;
    std::cout << "You entered: " << c1 << std::endl;
    return 0;
}

5. 重载数组下标运算符 []

#include <iostream>

class Array {
private:
    int* data;
    size_t size;
public:
    Array(size_t sz) : size(sz) {
        data = new int[size];
    }

    ~Array() {
        delete[] data;
    }

    int& operator[](size_t index) {
        return data[index];
    }

    const int& operator[](size_t index) const {
        return data[index];
    }

    size_t getSize() const {
        return size;
    }
};

int main() {
    Array arr(10);
    for (size_t i = 0; i < arr.getSize(); ++i) {
        arr[i] = i * 10;
    }
    for (size_t i = 0; i < arr.getSize(); ++i) {
        std::cout << arr[i] << " ";
    }
    std::cout << std::endl;
    return 0;
}

6. 重载前置和后置递增递减运算符 ++ 和 --

#include <iostream>

class Counter {
private:
    int value;
public:
    Counter(int val = 0) : value(val) {}

    // 前置递增
    Counter& operator++() {
        ++value;
        return *this;
    }

    // 后置递增
    Counter operator++(int) {
        Counter temp = *this;
        ++value;
        return temp;
    }

    // 前置递减
    Counter& operator--() {
        --value;
        return *this;
    }

    // 后置递减
    Counter operator--(int) {
        Counter temp = *this;
        --value;
        return temp;
    }

    int getValue() const {
        return value;
    }
};

int main() {
    Counter c(5);
    std::cout << "Initial value: " << c.getValue() << std::endl;
    ++c;
    std::cout << "After prefix increment: " << c.getValue() << std::endl;
    c++;
    std::cout << "After postfix increment: " << c.getValue() << std::endl;
    --c;
    std::cout << "After prefix decrement: " << c.getValue() << std::endl;
    c--;
    std::cout << "After postfix decrement: " << c.getValue() << std::endl;
    return 0;
}

友元函数的作用
友元函数可以访问类的私有和保护成员，因此可以实现非成员函数的灵活性，同时保留对类内部状态的访问能力。

何时需要友元函数重载
对称性：对于某些运算符，尤其是二元运算符（如 +, -, *, /, ==, != 等），将运算符重载为友元函数可以实现更好的对称性，允许左操作数和右操作数分别是类对象和非类对象。例如，a + b 和 b + a 需要对称处理。
访问私有成员：当运算符需要访问类的私有或保护成员时，可以将其定义为友元函数，以便访问这些成员。
非成员函数：某些运算符（如输入输出运算符 << 和 >>）通常需要定义为非成员函数，因为左操作数是标准库类型（如 std::ostream 或 std::istream），不能作为类的成员函数来实现。

总结

将运算符重载为成员函数或友元函数都会对类的设计和使用产生不同的影响。理解这些影响可以帮助你做出最佳选择。以下是将运算符重载为成员函数和友元函数的一些影响和考虑。

成员函数重载的影响

  1. 调用方式的限制
  2. 访问权限
  3. 对称性
  4. 简化实现

1. 调用方式的限制 （主要差别）

成员函数重载运算符的一个主要限制是，它只能在类的实例作为左操作数时调用。这是因为成员函数隐含地接受类实例作为第一个参数。

示例：成员函数重载 +
#include <iostream>

class Complex {
private:
    double real, imag;

public:
    Complex(double r = 0.0, double i = 0.0) : real(r), imag(i) {}

    // 成员函数重载 + 运算符
    Complex operator+(const Complex& rhs) const {
        return Complex(real + rhs.real, imag + rhs.imag);
    }

    void print() const {
        std::cout << "(" << real << ", " << imag << ")" << std::endl;
    }
};

int main() {
    Complex c1(3.0, 4.0);
    Complex c2(1.0, 2.0);
    Complex c3 = c1 + c2; // 合法，c1 是左操作数
    // Complex c4 = 1.0 + c1; // 非法，左操作数不是 Complex 类实例
    c3.print(); // 输出: (4.0, 6.0)

    return 0;
}

在这个例子中，c1 + c2 是合法的，因为 c1 是 Complex 类的实例。但 1.0 + c1 是非法的，因为 1.0 不是 Complex 类的实例。

2. 访问权限

成员函数重载可以直接访问类的私有和保护成员，无需通过公共接口。这在某些情况下可以简化实现。

示例：成员函数重载 + 访问私有成员
#include <iostream>

class Complex {
private:
    double real, imag;

public:
    Complex(double r = 0.0, double i = 0.0) : real(r), imag(i) {}

    // 成员函数重载 + 运算符
    Complex operator+(const Complex& rhs) const {
        return Complex(real + rhs.real, imag + rhs.imag);
    }

    void print() const {
        std::cout << "(" << real << ", " << imag << ")" << std::endl;
    }
};

int main() {
    Complex c1(3.0, 4.0);
    Complex c2(1.0, 2.0);
    Complex c3 = c1 + c2;
    c3.print(); // 输出: (4.0, 6.0)

    return 0;
}

3. 对称性

对于需要对称处理的运算符（如 +, == 等），友元函数提供了更好的对称性，因为它们可以对任意顺序的操作数进行操作。

示例：友元函数重载 + 支持对称性
#include <iostream>

class Complex {
private:
    double real, imag;

public:
    Complex(double r = 0.0, double i = 0.0) : real(r), imag(i) {}

    // 友元函数重载 + 运算符
    friend Complex operator+(const Complex& lhs, const Complex& rhs);

    void print() const {
        std::cout << "(" << real << ", " << imag << ")" << std::endl;
    }
};

// 友元函数实现 + 运算符
Complex operator+(const Complex& lhs, const Complex& rhs) {
    return Complex(lhs.real + rhs.real, lhs.imag + rhs.imag);
}

int main() {
    Complex c1(3.0, 4.0);
    Complex c2(1.0, 2.0);
    Complex c3 = c1 + c2;
    Complex c4 = c2 + c1; // 同样合法
    c3.print(); // 输出: (4.0, 6.0)
    c4.print(); // 输出: (4.0, 6.0)

    return 0;
}

4. 简化实现

对于一些运算符来说，成员函数实现比友元函数实现更简洁，因为它们不需要显式地访问私有成员。

示例：成员函数重载 ==
#include <iostream>

class Complex {
private:
    double real, imag;

public:
    Complex(double r = 0.0, double i = 0.0) : real(r), imag(i) {}

    // 成员函数重载 == 运算符
    bool operator==(const Complex& rhs) const {
        return real == rhs.real && imag == rhs.imag;
    }

    void print() const {
        std::cout << "(" << real << ", " << imag << ")" << std::endl;
    }
};

int main() {
    Complex c1(3.0, 4.0);
    Complex c2(3.0, 4.0);
    Complex c3(1.0, 2.0);

    if (c1 == c2) {
        std::cout << "c1 is equal to c2" << std::endl; // 输出
    } else {
        std::cout << "c1 is not equal to c2" << std::endl;
    }

    if (c1 == c3) {
        std::cout << "c1 is equal to c3" << std::endl;
    } else {
        std::cout << "c1 is not equal to c3" << std::endl; // 输出
    }

    return 0;
}

友元函数的优势

友元函数可以用于解决上述成员函数重载的限制，例如支持非对称操作数和更好的对称性。

示例：友元函数重载 + 支持非类对象
#include <iostream>

class Complex {
private:
    double real, imag;

public:
    Complex(double r = 0.0, double i = 0.0) : real(r), imag(i) {}

    // 友元函数重载 + 运算符
    friend Complex operator+(const Complex& lhs, const Complex& rhs);

    // 友元函数重载 Complex + double
    friend Complex operator+(const Complex& lhs, double rhs);

    // 友元函数重载 double + Complex
    friend Complex operator+(double lhs, const Complex& rhs);

    void print() const {
        std::cout << "(" << real << ", " << imag << ")" << std::endl;
    }
};

// 友元函数实现 Complex + Complex
Complex operator+(const Complex& lhs, const Complex& rhs) {
    return Complex(lhs.real + rhs.real, lhs.imag + rhs.imag);
}

// 友元函数实现 Complex + double
Complex operator+(const Complex& lhs, double rhs) {
    return Complex(lhs.real + rhs, lhs.imag);
}

// 友元函数实现 double + Complex
Complex operator+(double lhs, const Complex& rhs) {
    return Complex(lhs + rhs.real, rhs.imag);
}

int main() {
    Complex c1(3.0, 4.0);
    Complex c2(1.0, 2.0);
    Complex c3 = c1 + c2;
    Complex c4 = c1 + 5.0;
    Complex c5 = 5.0 + c1;

    c3.print(); // 输出: (4.0, 6.0)
    c4.print(); // 输出: (8.0, 4.0)
    c5.print(); // 输出: (8.0, 4.0)

    return 0;
}
  • 成员函数重载：适用于一元运算符或当左操作数必须是类实例时。成员函数重载可以直接访问类的私有成员。
  • 友元函数重载：适用于需要对称性、需要访问类的私有成员以及需要支持非类对象作为操作数的运算符。友元函数可以访问类的私有和保护成员。

使用模板进行运算符重载

使用模板可以实现更加通用的运算符重载方案，适用于多种类型的相加操作。
示例：使用模板重载 + 运算符

在这里插入代码片


#include <iostream>
#include <type_traits>

class Complex {
private:
    double real, imag;

public:
    Complex(double r = 0.0, double i = 0.0) : real(r), imag(i) {}

    // 友元函数模板重载 + 运算符，支持 Complex + T
    template<typename T>
    friend typename std::enable_if<!std::is_same<T, Complex>::value, Complex>::type
    operator+(const Complex& lhs, const T& rhs) {
        return Complex(lhs.real + rhs, lhs.imag);
    }

    // 友元函数模板重载 + 运算符，支持 T + Complex
    template<typename T>
    friend typename std::enable_if<!std::is_same<T, Complex>::value, Complex>::type
    operator+(const T& lhs, const Complex& rhs) {
        return Complex(lhs + rhs.real, rhs.imag);
    }

    // 友元函数重载 Complex + Complex
    friend Complex operator+(const Complex& lhs, const Complex& rhs);

    void print() const {
        std::cout << "(" << real << ", " << imag << ")" << std::endl;
    }
};

// 友元函数实现 Complex + Complex
Complex operator+(const Complex& lhs, const Complex& rhs) {
    return Complex(lhs.real + rhs.real, lhs.imag + rhs.imag);
}

int main() {
    Complex c1(3.0, 4.0);
    Complex c2(1.0, 2.0);
    Complex c3 = c1 + c2;
    Complex c4 = c1 + 5.0;
    Complex c5 = 5.0 + c1;

    c3.print();  // 输出: (4.0, 6.0)
    c4.print();  // 输出: (8.0, 4.0)
    c5.print();  // 输出: (8.0, 4.0)

    return 0;
}

在这个示例中，我们使用了模板和 std::enable_if 来实现通用的运算符重载，以支持 Complex 对象与任意类型的值进行相加。通过 std::enable_if 和 std::is_same 检查，确保模板重载仅适用于非 Complex 类型。
template：定义一个模板，参数类型为 T。
typename std::enable_if<!std::is_same<T, Complex>::value, Complex>::type：条件性地定义返回类型。
std::is_same<T, Complex>::value：检查类型 T 是否与 Complex 类型相同。
!std::is_same<T, Complex>::value：取反，检查类型 T 是否不等于 Complex。
std::enable_if<!std::is_same<T, Complex>::value, Complex>::type：如果 T 不是 Complex 类型，则 std::enable_if 定义了一个类型 type，该类型为 Complex。否则，模板实例化失败。

运算符重载使得自定义类型的使用更加直观和自然。通过运算符重载，可以实现与内置类型一致的语法和行为，提高代码的可读性和可维护性。在进行运算符重载时，需注意以下几点：

  1. 确保重载的运算符符合预期的行为：重载后的运算符应当符合人们对该运算符的常规预期。
  2. 避免滥用运算符重载：虽然运算符重载可以提高代码的简洁性，但不应滥用，特别是对于不适合运算符语义的操作。
  3. 遵循运算符的优先级和结合性：重载运算符的优先级和结合性与原运算符保持一致。
好悬给我拽开线
关注
  • 14
    点赞
  • 踩
  • 28
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
C++运算符重载（小白友好）
qq_55904031的博客
09-17 703
文章目录前言一、什么是运算符重载二、运算符重载原理1.原理2.具体实现三、类内部的运算重载和全局运算符重载1.类内部运算符重载2.全局运算符重载3.类内运算符重载和全局运算符重载的区别总结 前言 C++运算符重载是面向对象三大特性之一多态的体现 本文章为初学者为巩固知识所创作，知识有限，大佬轻喷 一、什么是运算符重载 在C++中函数可以发生重载，让同一个函数名的函数通过传入不同参数从而实现不同的效果 运算符重载就是让不同类型的变量（对象）通过C++中运算符操作的时候产生不同的效果 举个栗子： int类型
C++运算符重载详解
热门推荐
lishuzhai的专栏
03-02 15万+
为什么要对运算符进行重载： C++预定义中的运算符的操作对象只局限于基本的内置数据类型，但是对于我们自定义的类型（类）是没有办法操作的。但是大多时候我们需要对我们定义的类型进行类似的运算，这个时候就需要我们对这么运算符进行重新定义，赋予其新的功能，以满足自身的需求。 C++运算符重载的实质： 运算符重载的实质就是函数重载或函数多态。运算符重载是一种形式的C++多态。目的在于让人能够用同名的函
c++运算符重载
rotation博客
05-19 3718
什么是运算符重载？ 运算符重载是通过创建运算符函数实现的，运算符函数定义了重载的运算符将要进行的操作。运算符函数的定义与其他函数的定义类似，惟一的区别是运算符函数的函数名是由关键字operator和其后要重载的运算符符号构成的。运算符函数定义的一般格式如下： <返回类型说明符> operator <运算符符号>(<参数表>) { <函数体>}为什么要重载运算符？ C++中预定义的运算符的操作
C++语法——详解运算符重载
weixin_61857742的博客
07-28 3万+
运算符重载是C++的一个重要特性。有了运算符重载，在代码编写时能更好的实现封装。 一.运算符重载介绍 运算符重载，就是让原本已经存在的运算符有了新的用法和意义。 比如我们熟知的减号（-），原本是用来进行数字的相减处理。但经过运算符重载后，它可以用来进行其他类型的相减，像时间相减、日期相减、字符相减等等。只要是你能想到的，通过运算符重载基本都能够实现。 对于C++而言，运算符重载一般是作为类的成员函数出现。因为当我们需要运算符重载时，往往是类中一种特殊的类型需要处理或者类本身需要处理。就像我们可能会把.
【C++】运算符重载
weixin_57133810的博客
05-08 1782
C+中的运算符重载
C++运算符重载
02-20
标题"‘C++运算符重载’"涉及到的关键知识点主要包括以下几个方面： 1. **运算符重载的原理**：运算符重载是通过函数重载实现的，即为同一个运算符提供不同的函数实现，这些函数通常作为类的成员函数或友元函数。...
C++运算符重载题库及答案.pdf
02-27
C++运算符重载是编程中的一个重要概念，它允许我们为已有的运算符赋予新的含义，以便在...以上是关于C++运算符重载的一些基础知识点和常见问题解答。理解并熟练掌握这些内容，对于编写高效、清晰的C++代码至关重要。
使用C++实现矩阵运算（运算符重载）
01-06
下面将详细解释这个主题中的关键知识点。 首先，我们要理解C++中的运算符重载。运算符重载允许我们在不同的上下文中为同一个运算符赋予不同的含义，这在处理自定义数据类型如矩阵时非常有用。例如，我们可以通过...
实验二 运算符重载的应用.doc
02-25
五、知识点总结 1. 构造函数的使用：构造函数是类的一种特殊成员函数，它的主要作用是初始化对象的成员变量。 2. 引用的使用：引用是C++中的一种重要概念，它允许开发者可以在函数中传递变量的地址，提高代码的灵活...
c++ 运算符重载(简单易懂)
shenmingyi.blog.csdn.net
09-07 3万+
c++ 运算符重载: 您可以重定义或重载大部分 C++ 内置的运算符。这样，您就能使用自定义类型的运算符。 重载的运算符是带有特殊名称的函数，函数名是由关键字 operator 和其后要重载的运算符符号构成的。 与其他函数一样，重载运算符有一个返回类型和一个参数列表。 //重载 + 运算符 , 把两个 Box 相加 Box operator+(const Box b...
C++的运算符重载
很不错的 blog
08-31 15万+
　　C++中预定义的运算符的操作对象只能是基本数据类型。但实际上，对于许多用户自定义类型（例如类），也需要类似的运算操作。这时就必须在C++中重新定义这些运算符，赋予已有运算符新的功能，使它能够用于特定类型执行特定的操作。运算符重载的实质是函数重载，它提供了C++的可扩展性，也是C++最吸引人的特性之一。 　　运算符重载是通过创建运算符函数实现的，运算符函数定义了重载的运算符将要进
【C++】[ ]、=、==、!= 运算符重载（以数组为例）
dai_wen的博客
05-09 2万+
[ ]，==，!=运算符重载
C++ 运算符重载
yh的博客
03-27 4364
C++中几乎可以重载全部的运算符，而且只能重载C++中已经有的。不能重载的运算符：“. ”、“.*”、“::”、“？.”； 重载之后运算符的优先级和结合性都不会改变； 运算符重载是针对新类型的实际需要，对原有运算符进行适当的改造； 例如：使用复数类的对象可以用“+”运算符实现加法，是时钟类对象可以用“++”运算符实现时间增加1秒。 1. 运算符重载为成员函数 1.1 双目运算符重载为...
C++运算符重载(超全）
LancasterLiu的博客
06-27 3万+
C++运算符重载 1) 运算符重载的本质为函数重载，但有一定的规则需要遵循。[1] (1)重载运算符时,运算符的运算顺序和优先级不变,操作数个数不变。 (2)不能创造新的运算符,只能重载C++中已有的运算符,并且规定有6个运算符不能重载,如表所示。 不能重载的运算符 含义 . 类属关系运算符 .* 成员指针运算符 :: 作用域运算符 ?: 条件运算符 # 编译预处理符号 sizeof() 取数据类型的长度 (3)运算符重载是针对新类型的实际需求,对原有的运算符进行适当
c++（重载[]运算符）
Andrew的博客
04-25 1485
c++支持重载[]符，这样就可以像操作普通数组一样操作对象数组。 下面创建一个intarray数组类，实现对数据下标的越界检查。 class IntArray { private: int *aptr; int arraySize; void memError(); //处理内存分配错误 void subError(); //处理下标越界 pub...
c++运算符重载知识点
最新发布
11-29
下面是一些C++运算符重载的知识点： 1. 运算符重载是通过函数来实现的，函数名是由关键字operator和要重载的运算符符号组成的。 2. 运算符重载函数可以是类的成员函数，也可以是全局函数。如果是成员函数，那么它...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值