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

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 ++编写的程序要简单得多，因为您没有明确使用Pointers and References（at是抽象级别）。

Answer 1

Python方法是动态的-Smalltalk本质上是纯面向对象的。 您向实例发送一条消息，如果它可以回答，则可以。

C ++不是那样的。 它使用静态类型。 您已经声明了Car*类型的对象，因此a）它可以保存指向任何Car实例或Car子类型的实例的指针，并且b）仅被告知要执行Car可以被告知要做的事情。

C ++也有虚方法。 如果在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
}