Question

给定一个抽象基类Object和两个派生类Person和Gathering。其中Gathering是一个数据结构，用于存储指向数组内Person或其他Gathering指针的指针。

我想覆盖输出操作符，以便打印任何类型的Object。但是我不知道如何正确地覆盖运算符，所以当它收到类型Object时它知道如何处理它。

这是一个简单的代码，举例说明了我想要实现的目标：

#import <iostream>
#import <cstring>

class Object {
public:
    virtual ~Object(){};
};

class Person : public Object {
private:
    char * m_name;
public:
    Person(char * input) {
        m_name = new char[strlen(input)];
        strncpy(m_name, input, strlen(input));
    }

    char* getName() const{
        return m_name;
    }

    friend std::ostream& operator<<(std::ostream& os, const Person* p) {
        os << p->getName();
        return os;
    }
};

class Gathering : public Object {
private:
    int m_size;
    Object* m_buffer;

public:
    Gathering() : m_size(10) 
    {}

    friend std::ostream& operator<<(std::ostream& os, const Gathering* v) {
        for (int i=0; i<v->getSize(); i++) {
            //Trying to send Object to outputstream..
            os << "[" << v->getBuffer()[i] << "]";
        }
    }

    int getSize() const {
        return m_size;
    }

    Object* getBuffer() const {
        return m_buffer;
    }
};

我非常清楚问题是什么，如何理想这个？非常感谢任何参考或指针。

Answer 1

您可以在Object中添加虚拟成员函数，在运算符重载中调用它，并为子类正确实现它。

class Object {
public:
    virtual ~Object(){}

    virtual void print(std::ostream&){}

    friend std::ostream& operator<<(std::ostream& os, const Object& obj) {
        obj.print(os);
        return os;
    }
};

class Gathering : public Object {
private:
    int m_size;
    Object* m_buffer;

public:
    Gathering() : m_size(10) 
    {}

    virtual void print(std::ostream& os) {
        for (int i=0; i<v->getSize(); i++) {
            os << "["; 
            m_buffer[i].print(os);
            os << "]";
        }
    }

    int getSize() const {
        return m_size;
    }

    Object* getBuffer() const {
        return m_buffer;
    }
};

也没关联，但在你的子类中放置一个虚拟析构函数，使用向量而不是Object指针m_buffer或者至少在构造函数中初始化它，但我想你有学校限制或某事:)）

通用输出运算符重载与继承

1 个答案: