青少年编程与数学 02-010 C++程序设计基础 30课题、操作符重载

一、重载
- [1. 函数重载（Function Overloading）](#1. 函数重载（Function Overloading）)
- - 规则：
  - 注意事项：
- [2. 操作符重载（Operator Overloading）](#2. 操作符重载（Operator Overloading）)
- - 规则：
  - 语法：
- 总结
二、操作符重载
- [1. 操作符重载的基本概念](#1. 操作符重载的基本概念)
- [2. 操作符重载的语法](#2. 操作符重载的语法)
- - 成员函数形式
  - 非成员函数形式
- [3. 常用操作符重载示例](#3. 常用操作符重载示例)
- - [(1) 算术操作符重载（`+`, `-`, `*`, `/`）](#(1) 算术操作符重载（+, -, *, /）)
  - - 成员函数形式
    - 非成员函数形式
  - [(2) 赋值操作符重载（`=`）](#(2) 赋值操作符重载（=）)
  - [(3) 关系操作符重载（`==`, `!=`, `<`, `>`）](#(3) 关系操作符重载（==, !=, <, >）)
  - - 成员函数形式
  - [(4) 流操作符重载（`<<`, `>>`）](#(4) 流操作符重载（<<, >>）)
  - [(5) 下标操作符重载（`[]`）](#(5) 下标操作符重载（[]）)
  - [(6) 函数调用操作符重载（`()`）](#(6) 函数调用操作符重载（()）)
- [4. 操作符重载的限制](#4. 操作符重载的限制)
- [5. 操作符重载的最佳实践](#5. 操作符重载的最佳实践)
- [6. 总结](#6. 总结)
三、应用场景
- [1. **数学运算**](#1. 数学运算)
- - 示例：复数运算
- [2. **容器类**](#2. 容器类)
- - 示例：动态数组
- [3. **输入输出**](#3. 输入输出)
- - 示例：复数输入输出
- [4. **比较操作**](#4. 比较操作)
- - 示例：点比较
- [5. **函数对象（仿函数）**](#5. 函数对象（仿函数）)
- - 示例：加法器
- [6. **智能指针**](#6. 智能指针)
- - 示例：简单智能指针
- [7. **自定义迭代器**](#7. 自定义迭代器)
- - 示例：简单迭代器
- [8. **自定义类型转换**](#8. 自定义类型转换)
- - 示例：转换为布尔类型
- 总结

课题摘要:本文深入探讨了C++中操作符重载的概念、规则、语法及应用场景。操作符重载允许为自定义类型定义操作符行为，提高代码可读性和简洁性。可重载操作符包括算术、赋值、关系、流、下标和函数调用等，但不能改变操作符的优先级、结合性或操作数个数，也不能创建新操作符。重载形式有成员函数和非成员函数两种。应用场景涵盖数学运算、容器类、输入输出、比较操作、函数对象、智能指针、自定义迭代器和类型转换等。合理使用操作符重载可使代码更直观、易于维护，但需注意保持语义一致性和避免滥用。

一、重载

在C++中，重载（Overloading） 允许在同一作用域内定义多个同名函数或操作符，只要它们的参数列表不同。重载的目的是提高代码的可读性和灵活性。C++支持两种主要的重载形式：函数重载 和 操作符重载。

1. 函数重载（Function Overloading）

函数重载是指在同一作用域内定义多个同名函数，但这些函数的参数列表（参数的类型、数量或顺序）必须不同。

规则：

函数名必须相同。
参数列表必须不同（类型、数量或顺序）。
返回类型可以相同也可以不同，但仅返回类型不同不足以构成重载。

注意事项：

如果函数名和参数列表完全相同，仅返回类型不同，会导致编译错误。
默认参数可能会影响函数重载的解析，需谨慎使用。

2. 操作符重载（Operator Overloading）

操作符重载允许为用户自定义类型（如类或结构体）定义操作符的行为。通过重载操作符，可以使自定义类型的对象像内置类型一样使用操作符。

规则：

只能重载C++中已有的操作符，不能创建新的操作符。
至少有一个操作数是用户自定义类型（类或结构体）。
不能改变操作符的优先级和结合性。
部分操作符不能被重载（如 ::, .*, ?:, sizeof 等）。

语法：

cpp 复制代码

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

总结

函数重载和操作符重载是C++中强大的特性，能够提高代码的可读性和灵活性。
函数重载通过参数列表的差异实现同名函数的多态性。
操作符重载允许为用户自定义类型定义操作符的行为，使其更接近内置类型的使用方式。
合理使用重载可以显著提升代码质量，但需注意避免滥用和语义不一致的问题。

二、操作符重载

在C++中，操作符重载（Operator Overloading） 允许为用户自定义类型（如类或结构体）定义操作符的行为。通过重载操作符，可以使自定义类型的对象像内置类型一样使用操作符，从而提高代码的可读性和简洁性。

1. 操作符重载的基本概念

什么是操作符重载？

操作符重载是指为自定义类型定义操作符的行为。例如，可以为自定义的 Complex 类重载 + 操作符，使得两个 Complex 对象可以直接相加。

可重载的操作符

C++中大部分操作符都可以重载，但以下操作符不能重载：

作用域解析操作符 ::
成员访问操作符 .
成员指针访问操作符 .*
条件操作符 ?:
sizeof 操作符
typeid 操作符

操作符重载的两种形式

成员函数形式：将操作符重载为类的成员函数。
非成员函数形式：将操作符重载为全局函数（通常声明为类的友元函数）。

2. 操作符重载的语法

成员函数形式

cpp 复制代码

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

非成员函数形式

cpp 复制代码

返回类型 operator操作符(参数1, 参数2) {
    // 操作符的实现
}

3. 常用操作符重载示例

(1) 算术操作符重载（`+`, `-`, `*`, `/`）

成员函数形式

cpp 复制代码

class Complex {
private:
    double real;
    double imag;

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

    // 重载 + 操作符
    Complex operator+(const Complex& other) {
        return Complex(real + other.real, imag + other.imag);
    }

    // 重载 - 操作符
    Complex operator-(const Complex& other) {
        return Complex(real - other.real, imag - other.imag);
    }
};

非成员函数形式

cpp 复制代码

Complex operator+(const Complex& c1, const Complex& c2) {
    return Complex(c1.getReal() + c2.getReal(), c1.getImag() + c2.getImag());
}

(2) 赋值操作符重载（`=`）

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

cpp 复制代码

class MyArray {
private:
    int* data;
    int size;

public:
    MyArray(int s) : size(s) {
        data = new int[size];
    }

    // 重载赋值操作符
    MyArray& operator=(const MyArray& other) {
        if (this == &other) return *this; // 处理自我赋值

        delete[] data; // 释放原有资源
        size = other.size;
        data = new int[size];
        for (int i = 0; i < size; i++) {
            data[i] = other.data[i];
        }
        return *this;
    }
};

(3) 关系操作符重载（`==`, `!=`, `<`, `>`）

成员函数形式

cpp 复制代码

class Point {
private:
    int x, y;

public:
    Point(int x = 0, int y = 0) : x(x), y(y) {}

    // 重载 == 操作符
    bool operator==(const Point& other) const {
        return x == other.x && y == other.y;
    }

    // 重载 != 操作符
    bool operator!=(const Point& other) const {
        return !(*this == other);
    }
};

(4) 流操作符重载（`<<`, `>>`）

流操作符通常重载为非成员函数，并声明为类的友元函数。

cpp 复制代码

class Complex {
private:
    double real;
    double imag;

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

    // 声明友元函数
    friend ostream& operator<<(ostream& os, const Complex& c);
    friend istream& operator>>(istream& is, Complex& c);
};

// 重载 << 操作符
ostream& operator<<(ostream& os, const Complex& c) {
    os << "(" << c.real << " + " << c.imag << "i)";
    return os;
}

// 重载 >> 操作符
istream& operator>>(istream& is, Complex& c) {
    cout << "Enter real part: ";
    is >> c.real;
    cout << "Enter imaginary part: ";
    is >> c.imag;
    return is;
}

(5) 下标操作符重载（`[]`）

下标操作符通常重载为成员函数，用于访问类的内部数组。

cpp 复制代码

class MyArray {
private:
    int* data;
    int size;

public:
    MyArray(int s) : size(s) {
        data = new int[size];
    }

    // 重载 [] 操作符
    int& operator[](int index) {
        if (index < 0 || index >= size) {
            throw out_of_range("Index out of range");
        }
        return data[index];
    }
};

(6) 函数调用操作符重载（`()`）

函数调用操作符重载允许对象像函数一样被调用。

cpp 复制代码

class Adder {
public:
    int operator()(int a, int b) {
        return a + b;
    }
};

int main() {
    Adder add;
    cout << add(3, 4) << endl; // 输出: 7
    return 0;
}

4. 操作符重载的限制

不能改变操作符的优先级和结合性：重载的操作符保持原有的优先级和结合性。
不能改变操作符的操作数个数 ：例如，+ 操作符始终是二元操作符。
不能创建新的操作符：只能重载C++中已有的操作符。

5. 操作符重载的最佳实践

保持语义一致性：重载的操作符应保持其原有的语义，避免引起混淆。
优先使用成员函数形式：对于需要访问类私有成员的操作符，优先使用成员函数形式。
处理自我赋值：在重载赋值操作符时，确保正确处理自我赋值的情况。
避免滥用操作符重载：过度使用操作符重载可能导致代码难以理解和维护。

6. 总结

操作符重载允许为用户自定义类型定义操作符的行为。
操作符可以重载为成员函数或非成员函数（通常声明为友元函数）。
常用操作符重载包括算术操作符、赋值操作符、关系操作符、流操作符、下标操作符和函数调用操作符。
操作符重载应保持语义一致性，并避免滥用。

通过合理使用操作符重载，可以使自定义类型的对象更直观、更易于使用。

三、应用场景

操作符重载在C++中有广泛的应用场景，主要用于增强代码的可读性、简洁性和直观性。以下是一些常见的应用场景：

1. 数学运算

为自定义的数学类型（如复数、矩阵、向量等）重载算术操作符（+, -, *, / 等），使它们可以像内置类型一样进行运算。

示例：复数运算

cpp 复制代码

class Complex {
private:
    double real;
    double imag;

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

    // 重载 + 操作符
    Complex operator+(const Complex& other) const {
        return Complex(real + other.real, imag + other.imag);
    }

    // 重载 * 操作符
    Complex operator*(const Complex& other) const {
        return Complex(real * other.real - imag * other.imag,
                       real * other.imag + imag * other.real);
    }
};

int main() {
    Complex c1(3, 4);
    Complex c2(1, 2);
    Complex c3 = c1 + c2;  // 使用重载的 + 操作符
    Complex c4 = c1 * c2;  // 使用重载的 * 操作符
    return 0;
}

2. 容器类

为自定义的容器类（如动态数组、链表、栈、队列等）重载下标操作符（[]），使其可以像数组一样访问元素。

示例：动态数组

cpp 复制代码

class MyArray {
private:
    int* data;
    int size;

public:
    MyArray(int s) : size(s) {
        data = new int[size];
    }

    // 重载 [] 操作符
    int& operator[](int index) {
        if (index < 0 || index >= size) {
            throw out_of_range("Index out of range");
        }
        return data[index];
    }
};

int main() {
    MyArray arr(10);
    arr[0] = 1;  // 使用重载的 [] 操作符
    arr[1] = 2;
    return 0;
}

3. 输入输出

为自定义类型重载流操作符（<< 和 >>），使其可以直接通过 cin 和 cout 进行输入输出。

示例：复数输入输出

cpp 复制代码

class Complex {
private:
    double real;
    double imag;

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

    // 声明友元函数
    friend ostream& operator<<(ostream& os, const Complex& c);
    friend istream& operator>>(istream& is, Complex& c);
};

// 重载 << 操作符
ostream& operator<<(ostream& os, const Complex& c) {
    os << "(" << c.real << " + " << c.imag << "i)";
    return os;
}

// 重载 >> 操作符
istream& operator>>(istream& is, Complex& c) {
    cout << "Enter real part: ";
    is >> c.real;
    cout << "Enter imaginary part: ";
    is >> c.imag;
    return is;
}

int main() {
    Complex c;
    cin >> c;  // 使用重载的 >> 操作符
    cout << c; // 使用重载的 << 操作符
    return 0;
}

4. 比较操作

为自定义类型重载关系操作符（==, !=, <, >, <=, >=），使其可以直接进行比较。

示例：点比较

cpp 复制代码

class Point {
private:
    int x, y;

public:
    Point(int x = 0, int y = 0) : x(x), y(y) {}

    // 重载 == 操作符
    bool operator==(const Point& other) const {
        return x == other.x && y == other.y;
    }

    // 重载 < 操作符
    bool operator<(const Point& other) const {
        return x < other.x || (x == other.x && y < other.y);
    }
};

int main() {
    Point p1(1, 2);
    Point p2(3, 4);
    if (p1 == p2) cout << "p1 == p2" << endl;
    if (p1 < p2) cout << "p1 < p2" << endl;
    return 0;
}

5. 函数对象（仿函数）

通过重载函数调用操作符（()），使对象可以像函数一样被调用。这种对象称为函数对象 或仿函数。

示例：加法器

cpp 复制代码

class Adder {
public:
    int operator()(int a, int b) const {
        return a + b;
    }
};

int main() {
    Adder add;
    cout << add(3, 4) << endl; // 输出: 7
    return 0;
}

6. 智能指针

为自定义的智能指针类重载解引用操作符（*）和成员访问操作符（->），使其可以像普通指针一样使用。

示例：简单智能指针

cpp 复制代码

template <typename T>
class SmartPointer {
private:
    T* ptr;

public:
    SmartPointer(T* p = nullptr) : ptr(p) {}
    ~SmartPointer() { delete ptr; }

    // 重载 * 操作符
    T& operator*() const { return *ptr; }

    // 重载 -> 操作符
    T* operator->() const { return ptr; }
};

int main() {
    SmartPointer<int> ptr(new int(10));
    cout << *ptr << endl; // 输出: 10
    return 0;
}

7. 自定义迭代器

为自定义的容器类重载迭代器操作符（++, --, *, -> 等），使其可以像标准库中的迭代器一样使用。

示例：简单迭代器

cpp 复制代码

class MyArray {
private:
    int data[10];
    int size;

public:
    MyArray() : size(10) {
        for (int i = 0; i < size; i++) data[i] = i;
    }

    // 定义迭代器类
    class Iterator {
    private:
        int* ptr;

    public:
        Iterator(int* p = nullptr) : ptr(p) {}

        // 重载 ++ 操作符
        Iterator& operator++() {
            ++ptr;
            return *this;
        }

        // 重载 * 操作符
        int& operator*() const { return *ptr; }

        // 重载 != 操作符
        bool operator!=(const Iterator& other) const {
            return ptr != other.ptr;
        }
    };

    Iterator begin() { return Iterator(data); }
    Iterator end() { return Iterator(data + size); }
};

int main() {
    MyArray arr;
    for (auto it = arr.begin(); it != arr.end(); ++it) {
        cout << *it << " "; // 输出: 0 1 2 3 4 5 6 7 8 9
    }
    return 0;
}

8. 自定义类型转换

通过重载类型转换操作符，使自定义类型可以隐式或显式地转换为其他类型。

示例：转换为布尔类型

cpp 复制代码

class MyBool {
private:
    bool value;

public:
    MyBool(bool v = false) : value(v) {}

    // 重载 bool 类型转换操作符
    operator bool() const {
        return value;
    }
};

int main() {
    MyBool b(true);
    if (b) { // 隐式转换为 bool
        cout << "b is true" << endl;
    }
    return 0;
}

总结

操作符重载的应用场景非常广泛，主要包括：

数学运算（如复数、矩阵、向量等）。
容器类（如动态数组、链表等）。
输入输出（如自定义类型的流操作）。
比较操作（如自定义类型的比较）。
函数对象（仿函数）。
智能指针。
自定义迭代器。
自定义类型转换。

通过合理使用操作符重载，可以使代码更加直观、简洁和易于维护。

青少年编程与数学 02-010 C++程序设计基础 30课题、操作符重载

青少年编程与数学 02-010 C++程序设计基础 30课题、操作符重载

一、重载

1. 函数重载（Function Overloading）

规则：

注意事项：

2. 操作符重载（Operator Overloading）

规则：

语法：

总结

二、操作符重载

1. 操作符重载的基本概念

什么是操作符重载？

可重载的操作符

操作符重载的两种形式

2. 操作符重载的语法

成员函数形式

非成员函数形式

3. 常用操作符重载示例

(1) 算术操作符重载（+, -, *, /）

成员函数形式

非成员函数形式

(2) 赋值操作符重载（=）

(3) 关系操作符重载（==, !=, <, >）

成员函数形式

(4) 流操作符重载（<<, >>）

(5) 下标操作符重载（[]）

(6) 函数调用操作符重载（()）

4. 操作符重载的限制

5. 操作符重载的最佳实践

6. 总结

三、应用场景

1. 数学运算

示例：复数运算

2. 容器类

示例：动态数组

3. 输入输出

示例：复数输入输出

4. 比较操作

示例：点比较

5. 函数对象（仿函数）

示例：加法器

6. 智能指针

示例：简单智能指针

7. 自定义迭代器

示例：简单迭代器

8. 自定义类型转换

示例：转换为布尔类型

总结

(1) 算术操作符重载（`+`, `-`, `*`, `/`）

(2) 赋值操作符重载（`=`）

(3) 关系操作符重载（`==`, `!=`, `<`, `>`）

(4) 流操作符重载（`<<`, `>>`）

(5) 下标操作符重载（`[]`）

(6) 函数调用操作符重载（`()`）