C++14中类似toString()功能的实现方案咨询

嘿，这个需求在C++14里很好实现，我给你两种实用方案，你可以根据自己的场景来选择：

这种方式比较直接，给基类Fruit和派生类Apple分别实现输出运算符的重载。需要注意的是，派生类的重载可以复用基类的输出逻辑，避免重复代码。

首先给Fruit类添加友元的输出运算符：

#include <iostream>
#include <string>

class Fruit {
private:
    std::string m_name;
    std::string m_color;
public:
    Fruit(std::string name, std::string color) 
        : m_name(std::move(name)), m_color(std::move(color)) { }
    
    std::string getName() const { return m_name; }
    std::string getColor() const { return m_color; }

    // 声明友元运算符，让它能访问私有成员
    friend std::ostream& operator<<(std::ostream& os, const Fruit& fruit);
};

// 实现Fruit的输出运算符
std::ostream& operator<<(std::ostream& os, const Fruit& fruit) {
    os << "Fruit: " << fruit.m_name << ", Color: " << fruit.m_color;
    return os;
}

然后给Apple类也添加对应的友元运算符，并且在里面先输出基类的内容，再加上自己的成员：

class Apple : public Fruit {
private:
    double m_fiber;
public:
    Apple(std::string name, std::string color, double fiber) 
        : Fruit(std::move(name), std::move(color)), m_fiber(fiber) { }
    
    double getFiber() const { return m_fiber; }

    friend std::ostream& operator<<(std::ostream& os, const Apple& apple);
};

// 实现Apple的输出运算符
std::ostream& operator<<(std::ostream& os, const Apple& apple) {
    // 先输出基类部分
    os << static_cast<const Fruit&>(apple);
    // 再添加Apple自己的成员
    os << ", Fiber content: " << apple.m_fiber << "g";
    return os;
}

这样你就可以直接用std::cout打印对象了：

int main() {
    Fruit banana("Banana", "Yellow");
    Apple grannySmith("Granny Smith", "Green", 2.1);
    
    std::cout << banana << std::endl;
    std::cout << grannySmith << std::endl;
    return 0;
}

如果你的代码里有基类指针/引用指向派生类对象的场景（多态），上面的方案就不太够用了——因为直接用Fruit*指向Apple对象时，调用operator<<只会输出基类的内容。这时候可以用虚函数来实现统一的字符串生成逻辑：

首先在Fruit基类里定义一个虚函数toString()，然后派生类Apple重写它：

#include <iostream>
#include <string>
#include <sstream>

class Fruit {
private:
    std::string m_name;
    std::string m_color;
public:
    Fruit(std::string name, std::string color) 
        : m_name(std::move(name)), m_color(std::move(color)) { }
    
    std::string getName() const { return m_name; }
    std::string getColor() const { return m_color; }

    // 虚函数，派生类可以重写
    virtual std::string toString() const {
        std::ostringstream oss;
        oss << "Fruit: " << m_name << ", Color: " << m_color;
        return oss.str();
    }
};

class Apple : public Fruit {
private:
    double m_fiber;
public:
    Apple(std::string name, std::string color, double fiber) 
        : Fruit(std::move(name), std::move(color)), m_fiber(fiber) { }
    
    double getFiber() const { return m_fiber; }

    // 重写基类的toString函数
    std::string toString() const override {
        std::ostringstream oss;
        // 复用基类的toString内容
        oss << Fruit::toString();
        oss << ", Fiber content: " << m_fiber << "g";
        return oss.str();
    }
};

然后只需要写一个全局的operator<<，调用对象的toString()方法：

std::ostream& operator<<(std::ostream& os, const Fruit& fruit) {
    os << fruit.toString();
    return os;
}

这样即使是多态场景也能正确输出：

int main() {
    Fruit banana("Banana", "Yellow");
    Apple grannySmith("Granny Smith", "Green", 2.1);
    
    std::cout << banana << std::endl;
    std::cout << grannySmith << std::endl;

    // 多态场景
    const Fruit* fruitPtr = &grannySmith;
    std::cout << *fruitPtr << std::endl; // 会输出Apple的完整信息
    return 0;
}

两种方案对比：

• 方案1简单直接，适合没有多态需求的场景；
• 方案2支持多态，扩展性更好，后续添加新的派生类（比如Orange）只需要重写toString()就行，不用再写新的operator<<。

内容的提问来源于stack exchange，提问作者arshellium