无法从基类指针访问子类方法

Question

不确定我的继承在哪里出错，但我似乎只能在将子类实例存储在基类指针中时访问基类的方法：

class Car
{
    public:
        Car():type("Car") {};
        Car(const char* t):type(t) {};
        void get_type() const { return this->type; };
    private:
        std::string type;
};

class Ford : public Car
{
    public:
        Ford():Car("Ford"), doors(4) {};
        Ford(int x):Car("Ford"), doors(x) {};
        void get_doors() const { return this->doors; };
    private:
        int doors;
};

int main()
{
    Car* c = nullptr;
    c = new Ford();
    c->get_doors(); // doesn't exist, only allows for get_type()
}

这很可能是指针的滥用。我承认 C++ 不是我的强项，所以我试图复制一个用 Python 编写的程序，它大量使用继承，但它比用 C++ 编写的程序简单得多，因为你没有明确使用指针和引用（在抽象级别）。

Answer 1

Python 方法是动态的 - 在 smalltalk 本质上是纯面向对象的。你向一个实例发送一条消息，如果它可以回复它，它就会回复。

C++ 不是这样的。它使用 static 类型。您已声明一个Car* 类型的对象，因此a) 它可以保存指向任何Car 实例或Car 子类型实例的指针，并且b) 它只能被告知这样做可以告诉Cars 做什么。

C++ 也有 virtual 方法。如果在Car 中声明的方法是虚拟的，那么它可以在Car 的子类中实现（例如，在Ford 中）。然后在通过Car 指针调用时将调用该子类的实现。

Answer 2

这正是应该发生的事情。 Car* 指针仅允许您查看 Car 成员。尝试使用 Ford* 指针来查看 Ford 方法。要了解原因，请考虑您有另一个派生自 Car 的类：

class Honda : public Car {
    // no get_doors() here
    void honk();
};

... 

Car* c = new Honda();
c->get_doors(); // What should happen here???

另一方面，如果您希望每个 Car 拥有自己的门数，您可以做几件事：

你可以在基类中声明一个常量成员：

class Car {
public:
    Car(int num_doors) : m_doors(num_doors) {}

    int get_doors() const { return m_doors; }
private:
    const int m_doors;
}

class Ford : public Car {
    Ford() : Car(4) {} // Now every ford has 4 doors
}

class Honda : public Car {
    Honda() : Car(5) {} // and every honda has 5
}

你可以做的另一件事是在你的基类中声明一个虚函数，并在每个子类中覆盖它：

class Car {
public:
    virtual int num_doors() const = 0;
}

class Ford : public Car {
    int num_doors() const override { return 4; } // Now every ford has 4 doors
}

class Honda : public Car {
    int num_doors() const override { return 5; } // and every honda has 5
}