为不同成员变量重载同一类中的operator<<两次

在C++中，重载operator<<是一种常见的技术，用于自定义输出流的行为。如果你想为同一个类的不同成员变量重载operator<<两次，这通常意味着你想以不同的方式输出这些成员变量。然而，C++不允许直接重载一个函数的两个版本，它们必须有不同的参数列表。

为了实现类似的功能，你可以使用以下几种方法：

方法1：使用模板

你可以创建一个模板函数来处理不同类型的成员变量。

#include <iostream>

class MyClass {
public:
    int intValue;
    std::string stringValue;
};

template <typename T>
std::ostream& operator<<(std::ostream& os, const T& value) {
    os << value;
    return os;
}

int main() {
    MyClass obj{42, "Hello, World!"};
    std::cout << "intValue: " << obj.intValue << ", stringValue: " << obj.stringValue << std::endl;
    return 0;
}

在这个例子中，模板函数可以处理任何类型的成员变量。

方法2：使用不同的函数名

你可以为不同的成员变量创建不同的输出函数，并在类中提供接口来调用这些函数。

#include <iostream>

class MyClass {
public:
    int intValue;
    std::string stringValue;

    friend std::ostream& printInt(std::ostream& os, const MyClass& obj);
    friend std::ostream& printString(std::ostream& os, const MyClass& obj);
};

std::ostream& printInt(std::ostream& os, const MyClass& obj) {
    os << "intValue: " << obj.intValue;
    return os;
}

std::ostream& printString(std::ostream& os, const MyClass& obj) {
    os << ", stringValue: " << obj.stringValue;
    return os;
}

int main() {
    MyClass obj{42, "Hello, World!"};
    std::cout << printInt(std::cout, obj) << printString(std::cout, obj) << std::endl;
    return 0;
}

在这个例子中，我们定义了两个不同的友元函数来分别处理intValue和stringValue。

方法3：使用访问者模式

如果你有多个成员变量，并且每个变量都需要不同的处理方式，你可以考虑使用访问者模式。

#include <iostream>
#include <variant>

class MyClass {
public:
    std::variant<int, std::string> value;

    void accept(class Visitor& visitor) const;
};

class Visitor {
public:
    virtual void visit(int value) = 0;
    virtual void visit(const std::string& value) = 0;
};

void MyClass::accept(Visitor& visitor) const {
    std::visit([&visitor](const auto& val) { visitor.visit(val); }, value);
}

class MyVisitor : public Visitor {
public:
    std::ostream& os;

    MyVisitor(std::ostream& os) : os(os) {}

    void visit(int value) override {
        os << "intValue: " << value;
    }

    void visit(const std::string& value) override {
        os << ", stringValue: " << value;
    }
};

int main() {
    MyClass obj1{42};
    MyClass obj2{"Hello, World!"};

    MyVisitor visitor(std::cout);
    obj1.accept(visitor);
    std::cout << std::endl;
    obj2.accept(visitor);
    std::cout << std::endl;

    return 0;
}

在这个例子中，我们使用了C++17的std::variant和std::visit来实现访问者模式，这样可以为不同类型的成员变量提供不同的处理逻辑。