C++在两个不同的子类中实现了虚拟方法的父类

Question

很难使标题明确清晰，但我会尝试解释上下文（以及下面的一些代码）。注：我看过类似的问题，但他们只处理1个孩子的情况。所以他们对我的情况并没有真正的帮助，因为我有两个孩子班。

上下文： 我有一个父类有2个孩子的形状：圆形和正方形。 我将有一个Shape对象的向量，但这些Shape对象实际上只能是Circle对象或Square对象。我需要Circle和Square类具有相同的父类，以便我可以将它们存储在同一个向量中。

诀窍是我需要使用矢量中的Shape对象来调用在Circle类或Square类中实现的方法，因此，我需要在父类中有一个“虚拟”版本的方法类形状。

下面是代码为我班的简化部分：

Shape.h：

class Shape{ 
public: 
    std::string getColor(); 

    virtual int getRadius() = 0; //Method implemented in Circle 
    virtual int getHeight() = 0; //Method implemented in Square 
    virtual int getWidth() = 0; //Method implemented in Square 

protected: 
    std::string color; 
}; 

class Circle : public Shape{ 
public: 
    int getRadius(); 

private: 
    int radius; 
}; 

class Square : public Shape{ 
public: 
    int getHeight(); 
    int getWidth(); 

private: 
    int height; 
    int width; 
}; 

在Shape.cpp我有这样的事情：

std::string Shape::getColor(){ 
    return color; 
} 

int Circle::getRadius(){ 
    return radius; 
} 

int Square::getHeight(){ 
    return height; 
} 

int Square::getWidth(){ 
    return width; 
} 

错误发生在main.cpp中，当我想创建圆形和方形对象时：

Circle *c = new Circle(...);//Error: cannot instantiate abstract class 
          //pure virtual function "Shape::getHeight" has no overrider 
          //pure virtual function "Shape::getWidth" has no overrider 


Square *s = new Square(...);//Error: cannot instantiate abstract class 
          //pure virtual function "Shape::getRadius" has no overrider 

所以好像我需要“getRadius”在Square类的声明和“的getHeight”和“的getWidth”在Circle类的声明...

我尝试添加他们与虚拟，但这使得圆形和方形抽象类，所以我不能与他们创建任何对象。

有没有办法让这项工作？

这是我发布在stackoverflow的第一个问题。我希望一切都很清楚。谢谢您的帮助！

Answer 1

您的虚拟方法不是真正为虚方法很好的候选人，因为他们有一个特定类的功能，但没有用其他的。

虚拟方法的好例子将由每个类实现，但具有不同的功能或结果，例如virtual int area()或virtual bool intersects(Shape * otherShape)等等。

无论如何，你这是怎么会被编译（有一些额外的）代码：

形状：

class Shape{ 
public: 
    std::string getColor(); 

    Shape() {} 
    virtual ~Shape() {} 

    virtual int getRadius() { return 0; } // no pure virtual 
    virtual int getHeight() { return 0; } // no pure virtual 
    virtual int getWidth() { return 0; } // no pure virtual 

protected: 
    std::string color; 
}; 


class Circle : public Shape { 
public: 
    Circle(int r) 
     : Shape() 
     , radius(r) 
    {} 

    Circle() : Circle(0) {} 
    ~Circle() { std::cout << __PRETTY_FUNCTION__ << std::endl; } 

    int getRadius() override { return radius; }; 

private: 
    int radius; 
}; 

方：

class Square : public Shape { 
public: 
    Square(int h, int w) 
     : Shape() 
     , height(h) 
     , width(w) 
    {} 

    Square() : Square(0, 0) {} 
    ~Square() { std::cout << __PRETTY_FUNCTION__ << std::endl; } 

    int getHeight() override { return height; } 
    int getWidth() override { return width; } 

private: 
    int height; 
    int width; 
}; 

测试：

int main() { 
    using shapes = std::vector< Shape * >; 

    shapes s; 
    s.push_back(new Circle(10)); 
    s.push_back(new Square()); 
    s.push_back(new Square(1, 3)); 
    s.push_back(new Circle()); 

    for (Shape * sh : s) { 
     std::cout 
      << " r " << sh->getRadius() 
      << " h " << sh->getHeight() 
      << " w " << sh->getWidth() 
      << std::endl; 
    }  

    for (Shape * sh : s) { delete sh; } s.clear(); 
} 

输出：

r 10 h 0 w 0 
r 0 h 0 w 0 
r 0 h 1 w 3 
r 0 h 0 w 0 
virtual Circle::~Circle() 
virtual Square::~Square() 
virtual Square::~Square() 
virtual Circle::~Circle() 

这里是一个更好地利用带面积示例虚拟方法：

#include <iostream> 
#include <vector> 

struct Shape { 
    Shape() {} 
    virtual ~Shape() {} 

    virtual double area() = 0; 
}; 

具有不同区域的实施延伸：

struct Circle : public Shape { 
    Circle(int r) 
     : Shape() 
     , radius(r) 
    {} 

    Circle() : Circle(0) {} 
    ~Circle() { std::cout << __PRETTY_FUNCTION__ << std::endl; } 

    virtual double area() override { return radius * radius * 3.14; } 

    int radius; 
}; 

struct Square : public Shape { 
    Square(int h, int w) 
     : Shape() 
     , height(h) 
     , width(w) 
    {} 

    Square() : Square(0, 0) {} 
    ~Square() { std::cout << __PRETTY_FUNCTION__ << std::endl; } 

    virtual double area() override { return height * width; } 

    int height; 
    int width; 
}; 

测试

int main() { 
    using shapes = std::vector< Shape * >; 

    shapes s; 
    s.push_back(new Circle(1)); 
    s.push_back(new Square(1, 1)); 
    s.push_back(new Square(2, 3)); 
    s.push_back(new Circle(2)); 

    for (Shape * sh : s) { 
     std::cout << sh->area() << std::endl; 
    } 

    for (Shape * sh : s) { delete sh; } s.clear(); 
} 

输出：

3.14 
1 
6 
12.56 
virtual Circle::~Circle() 
virtual Square::~Square() 
virtual Square::~Square() 
virtual Circle::~Circle() 

Answer 2

我希望你知道pure virtual和virtual函数之间的区别。 Pure virtual函数实质上是占位符函数，与没有正文。你的基类的形状更适合普通的virtual函数，这些函数可以但不必在子类中进行更改。取出函数声明中的= 0部分以使函数仅为virtual函数。

Answer 3

这应该让你朝着正确的方向前进。通过让你的成员不是纯虚拟的，你可以在派生类中实现它们，但是你不需要。

class Shape{ 
    public: 
    std::string getColor(); 

    virtual int getRadius(); //Method implemented in Circle 
    virtual int getHeight(); //Method implemented in Square 
    virtual int getWidth(); //Method implemented in Square 

protected: 
    std::string color; 
}; 

class Circle : public Shape{ 
public: 
    int getRadius(); 

private: 
    int radius; 
}; 

class Square : public Shape{ 
public: 
    int getHeight(); 
    int getWidth(); 

private: 
    int height; 
    int width; 
};