用c++编写程序实现<<的重载

在 C++ 中，可以通过重载运算符 `<<` 来实现对自定义类型的输出操作。下面是一个示例：

#include <iostream>

class MyClass {
public:
  MyClass(int num) : num_(num) {}
  friend std::ostream& operator<<(std::ostream& os, const MyClass& obj) {
    os << "MyClass(" << obj.num_ << ")";
    return os;
  }
private:
  int num_;
};

int main() {
  MyClass obj(42);
  std::cout << obj << std::endl; // 输出：MyClass(42)
  return 0;
}

在这个示例中，我们定义了一个名为 `MyClass` 的类，并在其中重载了运算符 `<<`。重载函数是一个友元函数，它接受两个参数：一个输出流对象 `os` 和一个常量引用 `obj`，表示要输出的对象。在函数中，我们将 `MyClass` 对象的内容以字符串形式输出到流对象中，并返回该流对象的引用。

在 `main` 函数中，我们创建了一个 `MyClass` 对象 `obj`，并使用 `<<` 运算符将其输出到标准输出流中。输出结果是字符串 `"MyClass(42)"`。

相关问题

编写c++用重载函数拷贝数组程序

好的，针对您的问题，以下是一个使用重载函数拷贝数组的示例程序：

#include <iostream>

void copyArray(int arr[], int size) {
  int newArr[size];
  for (int i = 0; i < size; i++) {
    newArr[i] = arr[i];
  }
  std::cout << "New Array: [";
  for (int i = 0; i < size; i++) {
    std::cout << newArr[i];
    if (i != size - 1) std::cout << ", ";
  }
  std::cout << "]" << std::endl;
}

void copyArray(char arr[], int size) {
  char newArr[size];
  for (int i = 0; i < size; i++) {
    newArr[i] = arr[i];
  }
  std::cout << "New Array: [";
  for (int i = 0; i < size; i++) {
    std::cout << newArr[i];
    if (i != size - 1) std::cout << ", ";
  }
  std::cout << "]" << std::endl;
}

int main() {
  int intArr[] = {1, 2, 3, 4, 5};
  int size = sizeof(intArr) / sizeof(intArr[0]);
  char charArr[] = {'a', 'b', 'c', 'd', 'e'};

  copyArray(intArr, size);
  copyArray(charArr, size);
  
  return 0;
}

在这个程序中，我们定义了两个名为 `copyArray` 的函数，分别接受整型数组和字符型数组作为参数，并在内部进行拷贝操作。这里使用了重载函数的方式，因为我们希望函数根据输入的参数类型的不同，在内部使用不同的数据类型。最后，在 `main` 函数中，我们定义了两个不同的数组并将它们传递给 `copyArray` 函数，验证每个函数都能正确地拷贝数组并输出结果。

c++编写程序利用重载运算符实现复数类对象的算术四则运算

好的，我可以帮你解答这个问题。以下是一个简单的复数类的代码示例，其中包括了算术四则运算符的重载实现。

#include <iostream>
using namespace std;

class Complex {
public:
    Complex(double real = 0.0, double imag = 0.0) : re(real), im(imag) {}
    Complex operator+(const Complex& c) const {
        return Complex(re + c.re, im + c.im);
    }
    Complex operator-(const Complex& c) const {
        return Complex(re - c.re, im - c.im);
    }
    Complex operator*(const Complex& c) const {
        return Complex(re * c.re - im * c.im, re * c.im + im * c.re);
    }
    Complex operator/(const Complex& c) const {
        double denominator = c.re * c.re + c.im * c.im;
        return Complex((re * c.re + im * c.im) / denominator,
                       (im * c.re - re * c.im) / denominator);
    }
    friend ostream& operator<<(ostream& os, const Complex& c) {
        os << "(" << c.re << ", " << c.im << "i)";
        return os;
    }
private:
    double re, im;
};

int main() {
    Complex a(1.0, 2.0);
    Complex b(3.0, 4.0);
    Complex c = a + b;
    Complex d = a - b;
    Complex e = a * b;
    Complex f = a / b;
    cout << "a + b = " << c << endl;
    cout << "a - b = " << d << endl;
    cout << "a * b = " << e << endl;
    cout << "a / b = " << f << endl;
    return 0;
}

在这个示例中，我们定义了一个复数类 `Complex`，其中包含实部和虚部两个私有数据成员。我们通过重载运算符 `+`、`-`、`*` 和 `/` 来实现了相应的算术四则运算。此外，我们还定义了一个友元函数 `operator<<`，用于输出复数类对象的值。

在 `main` 函数中，我们创建了两个 `Complex` 类对象 `a` 和 `b`，并对其进行了加、减、乘、除四种运算操作。最后，我们通过 `cout` 输出了运算结果。

希望这个示例能够帮助你了解如何利用重载运算符实现复数类对象的算术四则运算。