如果基类指针不能访问派生类成员函数，那么多态有什么方便呢？

Question

要实现多态，我们需要使用一个基类指针指向一个派生类实例。多态性的一切都很好，除了，如果每个派生类都有一个或几个自己的成员函数怎么办？如果基类指针不能访问这些派生类的成员函数，那么多态有什么方便呢？

下面是一个例子。 “形状”是一个基类。 “square”和“circle”是两个派生类。

class shape {
public:
    virtual void getArea()=0;
};

class square: public shape {
private:
    int edge;
public:
    square(){edge = 1;}
    virtual void getArea(){  //polymorphism
        cout << edge*edge << "\n";
    }
    void getNumberOfEdge(){  //a new member function
        cout << "4\n";
    }
};

class circle: public shape {
private:
    int radius;
public:
    circle(){radius = 1;}
    virtual void getArea(){  //polymorphism
        cout << 3*radius*radius << "\n";
    }
    void getCurvature(){     //a new member function
        cout << 1/radius << "\n";
    }
};


int main(){
    shape* arr[2] = {
        new square(),
        new circle()
    };
    arr[0]->getArea();
    arr[1]->getArea();
    arr[0]->getNumberOfEdge();  //compiler error
}

getArea() 是实现多态性的一个很好的例子。但是访问派生类成员函数会给我编译器错误，我完全理解为什么。但从设计的角度来看，我们并不想为了每个派生类而在基类中添加一堆虚函数，对吧？

Answer 1

基类中的功能应该在基类中。特定于特定派生类的功能应该在这些派生类中。 virtual 函数允许代码操作形状并执行对任何形状都有效的操作，而无需了解如何对现在和将来可能存在的每种可能的形状类型执行这些功能。

但是从设计的角度来看，我们并不想仅仅为了每个派生类而在基类中添加一堆虚函数，对吧？

如果这些操作对基类有意义，那么它们可能应该去那里。如果它们是特定于形状的，那么它们属于对该功能有意义的特定类。

假设您有一个使用形状但没有八边形派生类的系统。多态性的关键在于，今天可以编写代码，如果有人添加它们，以后可以在八边形上完美运行。

Answer 2

使用正确的类型，您可以很好地解决边缘问题的数量，将多态性带到边缘！

让我们添加一个类：

// a base interface for all Edged shapes
struct HasEdges {
   virtual void getNumberOfEdges() const = 0;
    // side note: I'd prefer this getter to return an int
    // but keeping it as in the example
};

现在对于 Square（但不是对于 Circle！）我们可以这样做：

class Square: public Shape, public HasEdges {
// ...
public:
    void getNumberOfEdges() const override { /* implement */ }
// ...
};

主要是这样的：

int main(){
    shape* arr[2] = {
        new square(),
        new circle()
    };
    arr[0]->getArea();
    arr[1]->getArea();
    // some edgy thing below
    HasEdges* hasEdges = dynamic_cast<HasEdges*>(arr[0]);
    // above returns null on failure
    if(hasEdges) hasEdges->getNumberOfEdges();

    // releasing memory...
}

Answer 3

运行时多态性是指运行时的多态行为。 getArea() 定义的行为在运行时根据它指向的实例进行更改。 因此，您将多态性与静态编译问题混合在一起。基类没有成员函数名称getNumberOfEdge()，会出现编译错误。

如果你想调用特定的实现，为什么不让编译器看到它并转换它呢？

public:
    virtual void getArea()=0;
    template<typename T>
    const T * get() {
        return dynamic_cast<T *>(this);
    }
};

现在您可以将其转换为任何派生类型：

auto square_instance = arr[0]->get<square>();
if (square_instance) {
    square_instance->getNumberOfEdge();
}

A different approach to run time polymorphism is suggested by Sean Parent.我喜欢它并且现在更频繁地尝试这种方法。