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

#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;
}

#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;
}

#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;
}