运算符重载 请结合实例说明
时间: 2023-05-11 17:07:26 浏览: 63
运算符重载是指在类中重新定义运算符的行为,使其能够适用于自定义类型的对象。例如,可以重载"+"运算符,使其能够对两个自定义类型的对象进行加法运算。下面是一个简单的例子:
```cpp
class Vector {
public:
int x, y;
Vector operator+(const Vector& other) const {
return Vector{x + other.x, y + other.y};
}
};
int main() {
Vector v1{1, 2};
Vector v2{3, 4};
Vector v3 = v1 + v2;
// v3.x = 4, v3.y = 6
return 0;
}
```
在上面的例子中,我们定义了一个名为Vector的类,它有两个成员变量x和y。我们重载了"+"运算符,使其能够对两个Vector对象进行加法运算。在main函数中,我们创建了两个Vector对象v1和v2,并将它们相加得到了一个新的Vector对象v3。
通过运算符重载,我们可以使自定义类型的对象具有与内置类型相似的行为,从而更方便地使用它们。
相关问题
类型转换运算符重载的代码实例
下面是一个类型转换运算符重载的代码实例,将一个自定义的类类型转换为整型:
```cpp
class MyInt {
public:
MyInt(int value = 0) : m_value(value) {}
operator int() const { return m_value; }
private:
int m_value;
};
int main() {
MyInt myInt(42);
int i = myInt; // 调用 operator int(),将 MyInt 类型转换为 int 类型
std::cout << i << std::endl; // 输出 42
return 0;
}
```
在上面的示例中,MyInt 类重载了类型转换运算符 operator int(),将 MyInt 类型转换为 int 类型。当需要将 MyInt 类型转换为 int 类型时,编译器会自动调用 operator int() 函数。在 main() 函数中,将 MyInt 类型的对象 myInt 赋值给 int 类型的变量 i,编译器会自动调用 operator int() 函数,将 MyInt 类型转换为 int 类型,并将转换结果赋值给变量 i。最终输出结果为 42。
运算符重载%的实例
下面是一个实现矩阵取模运算的示例,其中运算符%被重载为成员函数形式:
```c++
#include <iostream>
#include <vector>
class Matrix {
public:
Matrix(int n, int m) : n_(n), m_(m), data_(n * m) {}
// 运算符%的成员函数形式重载
Matrix operator%(const Matrix& other) const {
Matrix result(n_, m_);
for (int i = 0; i < n_; ++i) {
for (int j = 0; j < m_; ++j) {
result(i, j) = data_[i * m_ + j] % other(i, j);
}
}
return result;
}
int& operator()(int i, int j) {
return data_[i * m_ + j];
}
const int& operator()(int i, int j) const {
return data_[i * m_ + j];
}
private:
int n_;
int m_;
std::vector<int> data_;
};
int main() {
Matrix A(3, 3);
A(0, 0) = 1; A(0, 1) = 2; A(0, 2) = 3;
A(1, 0) = 4; A(1, 1) = 5; A(1, 2) = 6;
A(2, 0) = 7; A(2, 1) = 8; A(2, 2) = 9;
Matrix B(3, 3);
B(0, 0) = 2; B(0, 1) = 2; B(0, 2) = 2;
B(1, 0) = 3; B(1, 1) = 3; B(1, 2) = 3;
B(2, 0) = 4; B(2, 1) = 4; B(2, 2) = 4;
Matrix C = A % B;
for (int i = 0; i < 3; ++i) {
for (int j = 0; j < 3; ++j) {
std::cout << C(i, j) << " ";
}
std::cout << std::endl;
}
return 0;
}
```
在上面的示例中,运算符%被重载为成员函数形式,可以对两个 Matrix 类型的对象进行取模运算。在 main 函数中,我们创建了两个矩阵 A 和 B,并对它们进行了取模运算,将结果保存在矩阵 C 中。最后,我们输出了矩阵 C 中的元素,验证了运算符%的重载实现。