C++重写的方法没有被调用

Question

Shape.h

namespace Graphics {
    class Shape {
    public:
        virtual void Render(Point point) {};
    };
}

Rect.h

namespace Graphics {
    class Rect : public Shape {
    public:
        Rect(float x, float y);
        Rect();
        void setSize(float x, float y);
        virtual void Render(Point point);

    private:
        float sizeX;
        float sizeY;
    };
}

struct ShapePointPair {
    Shape shape;
    Point location;
};

像这样使用：

std::vector<Graphics::ShapePointPair> theShapes = theSurface.getList();

for(int i = 0; i < theShapes.size(); i++) {
    theShapes[i].shape.Render(theShapes[i].location);
}

此代码最终调用 Shape::Render 而不是 Rect::Render

我假设这是因为它正在转换Rect 到 Shape，但我不知道如何阻止它这样做。我试图通过重写 Render 方法来让每个形状控制它的渲染方式。

关于如何实现这一目标有什么想法吗？

Answer 1

这是您的问题：

struct ShapePointPair {
        Shape shape;
        Point location;
};

您正在存储一个Shape。您应该存储一个 Shape * 或一个 shared_ptr 或其他东西。但不是 Shape； C++ 不是 Java。

当您将 Rect 分配给 Shape 时，仅复制 Shape 部分（这是对象切片） 。

Answer 2

这个问题称为切片 - 当复制到基础时，您会丢失派生功能。
为了避免这种情况，使用指向基类的指针，即

std::vector<Graphics::Shape*> s;
s.push_back(&some_rect);

Answer 3

问题是，在您的向量中，您存储的是 Shape 对象的副本，并且复制 Shape 对象不会复制其派生类的数据或功能 - 您是 切片 多态性。

使用 new 和 delete 管理对象，并安排向量存储指向它们的指针。

Answer 4

多态性仅适用于指向形状的指针，不适用于形状对象。

Answer 5

您正在直接访问形状对象，以便覆盖工作，您需要通过指针或引用访问该对象。

例如，当您将 Shape 分配到 ShapePointPair 中时，代码将“切片”对象并仅将 Shape 位复制到 ShapePointPair 中，

这样做意味着您必须监视内存管理 - 因此您可以在结构中使用智能指针
形状点对 {
智能指针形状；
点位置；
};

Answer 6

不，这不是铸造。

您可以改为存储对基类 Point 的引用：

struct ShapePointPair {
        Shape shape;
        Point &location;
};

必须在结构的构造时设置此引用
形状点对。为此，向 ShapePointPair 添加一个构造函数
目的。它必须传递（新创建的）实例
矩形。

还要遵守内存管理职责（正确的
编写的析构函数等）。

Answer 7

您可以尝试 boost::ptr_vector

http://www .boost.org/doc/libs/1_40_0/libs/ptr_container/doc/ptr_container.html

Answer 8

我不确定能否解释清楚，因为我的英语很差。

我认为你应该使用它的引用或指针类型。
因为形状准确地定义了它必须做什么。

如果您直接使用代码，您的孩子会尝试复制并执行形状的工作。
这就是为什么你的覆盖功能不起作用的原因。

使用指针或引用
像这样。

pointer.h

class Parent {
public:
    virtual void work() { printf("parent is working now\n"); }
};
class Child1 {
public:
    virtual void work() { printf("child1 is working now\n"); }
};
class Child2 {
public:
    virtual void work() { printf("child2 is working now\n"); }
};
struct Holder {
    Parent* obj1;
    Parent* obj2;
};
int main() {
    Child1 child1;
    Child2 child2;
    Holder holder = { &child1, &child2 };
    holder.obj1->work();
    holder.obj2->work();
    return 0;
}

reference.h

class Parent {
public:
    virtual void work() { printf("parent is working now\n"); }
};
class Child1 {
public:
    virtual void work() { printf("child1 is working now\n"); }
};
class Child2 {
public:
    virtual void work() { printf("child2 is working now\n"); }
};
struct Holder {
    Parent& obj1;
    Parent& obj2;
};
int main() {
    Child1 child1;
    Child2 child2;
    Holder holder = { child1, child2 };
    holder.obj1.work();
    holder.obj2.work();
    return 0;
}

*ps：我个人使用抽象函数（virtual void Something() = 0;）。
因为有时我也忘记了它，所以我将其捕获为语法错误。