编辑“︁C++ 输入输出运算符重载”︁

= C++输入输出运算符重载 =

== 介绍 ==
在C++中，运算符重载（Operator Overloading）允许程序员为自定义类型重新定义运算符的行为。其中，'''输入运算符（>>）'''和'''输出运算符（<<）'''的重载尤为重要，因为它们使得自定义类型能够像内置类型一样使用标准输入输出流（如`cin`和`cout`）。

输入输出运算符重载通常用于：
* 简化自定义类型的输入输出操作
* 保持与标准库流的一致性
* 提供更直观的代码可读性

== 语法基础 ==
输入输出运算符是二元运算符，通常被重载为类的友元函数，以便它们能够访问类的私有成员。基本语法结构如下：

=== 输出运算符（<<）重载 ===
<syntaxhighlight lang="cpp">
// 声明为友元函数以便访问私有成员
friend std::ostream& operator<<(std::ostream& os, const MyClass& obj);
</syntaxhighlight>

=== 输入运算符（>>）重载 ===
<syntaxhighlight lang="cpp">
// 声明为友元函数以便访问私有成员
friend std::istream& operator>>(std::istream& is, MyClass& obj);
</syntaxhighlight>

== 详细示例 ==
让我们通过一个完整的例子来演示如何重载这些运算符。

=== 示例类定义 ===
<syntaxhighlight lang="cpp">
#include <iostream>
#include <string>

class Person {
private:
    std::string name;
    int age;
    
public:
    Person() : name(""), age(0) {}
    Person(std::string n, int a) : name(n), age(a) {}
    
    // 声明友元函数
    friend std::ostream& operator<<(std::ostream& os, const Person& p);
    friend std::istream& operator>>(std::istream& is, Person& p);
};
</syntaxhighlight>

=== 运算符实现 ===
<syntaxhighlight lang="cpp">
// 输出运算符实现
std::ostream& operator<<(std::ostream& os, const Person& p) {
    os << "Name: " << p.name << ", Age: " << p.age;
    return os;
}

// 输入运算符实现
std::istream& operator>>(std::istream& is, Person& p) {
    std::cout << "Enter name: ";
    is >> p.name;
    std::cout << "Enter age: ";
    is >> p.age;
    return is;
}
</syntaxhighlight>

=== 使用示例 ===
<syntaxhighlight lang="cpp">
int main() {
    Person p;
    std::cin >> p;    // 使用重载的输入运算符
    std::cout << p;   // 使用重载的输出运算符
    return 0;
}
</syntaxhighlight>

'''输入/输出示例:'''
<pre>
Enter name: Alice
Enter age: 25
Name: Alice, Age: 25
</pre>

== 关键注意事项 ==

1. '''返回流引用'''：运算符必须返回流对象的引用，以支持链式操作（如`cin >> a >> b`）。
2. '''输入参数'''：输出运算符的第二个参数通常是`const`引用，而输入运算符的第二个参数必须是非`const`引用。
3. '''错误处理'''：在实际应用中，应该添加输入验证和错误处理。
4. '''友元声明'''：由于这些运算符需要访问私有成员，它们通常被声明为类的友元。

== 高级主题 ==

=== 处理复杂输入 ===
对于包含空格的字符串输入，可以使用`std::getline`：

<syntaxhighlight lang="cpp">
std::istream& operator>>(std::istream& is, Person& p) {
    std::cout << "Enter name: ";
    std::getline(is >> std::ws, p.name);  // std::ws跳过前导空白
    std::cout << "Enter age: ";
    is >> p.age;
    return is;
}
</syntaxhighlight>

=== 格式化输出 ===
可以使用流操纵符（如`std::setw`）来格式化输出：

<syntaxhighlight lang="cpp">
#include <iomanip>

std::ostream& operator<<(std::ostream& os, const Person& p) {
    os << std::setw(10) << "Name: " << std::left << std::setw(15) << p.name 
       << std::setw(10) << "Age: " << p.age;
    return os;
}
</syntaxhighlight>

== 实际应用案例 ==
考虑一个简单的库存管理系统，其中`Product`类需要支持输入输出：

<syntaxhighlight lang="cpp">
class Product {
    std::string id;
    std::string name;
    double price;
    int quantity;
    
public:
    // ... 其他成员函数 ...
    
    friend std::ostream& operator<<(std::ostream&, const Product&);
    friend std::istream& operator>>(std::istream&, Product&);
};

std::ostream& operator<<(std::ostream& os, const Product& p) {
    os << "ID: " << p.id << "\n"
       << "Name: " << p.name << "\n"
       << "Price: $" << p.price << "\n"
       << "Quantity: " << p.quantity;
    return os;
}

std::istream& operator>>(std::istream& is, Product& p) {
    std::cout << "Enter product ID: ";
    is >> p.id;
    std::cout << "Enter product name: ";
    is >> std::ws;
    std::getline(is, p.name);
    std::cout << "Enter price: ";
    is >> p.price;
    std::cout << "Enter quantity: ";
    is >> p.quantity;
    return is;
}
</syntaxhighlight>

== 常见问题解答 ==

'''Q: 为什么输入输出运算符通常被重载为友元函数而不是成员函数？'''
A: 因为如果作为成员函数重载，左操作数必须是类的对象（如`obj << cout`），这与常规使用习惯（`cout << obj`）相反。

'''Q: 如何处理输入错误？'''
A: 可以检查流的状态：
<syntaxhighlight lang="cpp">
if (!(is >> p.age)) {
    is.setstate(std::ios::failbit);
    return is;
}
</syntaxhighlight>

== 总结 ==
输入输出运算符重载是C++中强大的特性，它允许自定义类型与标准流无缝集成。通过遵循正确的语法和惯例，可以创建直观且易于使用的接口。记住：
* 总是返回流引用
* 输入运算符参数应为非const引用
* 考虑添加适当的错误处理
* 保持与标准库一致的行为

掌握这一概念将显著提高代码的可读性和可用性，特别是在处理自定义类型的I/O操作时。

[[Category:编程语言]]
[[Category:C++]]
[[Category:C++ 运算符重载]]