访问子类变量的正确解决方案是什么？

Question

如何访问Triangle 类的sideA 和height 成员，以及如何访问Square 类的sideA，这些都是从Shape 类派生的？

实现它的正确方法是什么？

Shapes.h：

class Shape
{
public:
    virtual double getArea() = 0;
};

class Triangle : public Shape 
{
public:
    double sideA = 3;
    double height = 2;
    double getArea() {
        return 0.5 * sideA * height;
    }
};

class Square : public Shape 
{
public:
    double sideA = 4;

    double getArea() {
        return sideA * sideA;
    }
};

Main.cpp：

int main()
{
    Shape* sh = new Triangle();
    std::cout << sh->getArea() << std::endl;
    std::cout << sh->??? //get the height of triangle
    delete sh;
}

Answer 1

您正在尝试通过您定义的接口访问不可用的信息，class Shape 只允许访问 区域。

要获得高度，正确的方法是扩展接口以提供该信息。

class Shape
{
public:
    virtual double getArea() = 0;
    virtual double getHeight() = 0;
};

class Triangle : public Shape 
{
public:
    double sideA = 3;
    double height = 2;
    double getArea() {
        return 0.5 * sideA * height;
    }
    double getHeight() {
        return height;
    }
};

class Square : public Shape 
{
public:
    double sideA = 4;

    double getArea() {
        return sideA * sideA;
    }
    double getHeight() {
        return sideA;
    }
};

Answer 2

Shape 没有 height。您正在多态地使用三角形。这意味着你有一个Shape* 并且只能使用Shape 的接口，无论对象的实际类型是什么。如果您想要Triangle，请使用Triangle 而不是Shape。如果您仍想多态地使用Triangle 和Rectangle，那么您应该将公共接口放入基类中。在你的情况下，两者都有一个sideA，所以你可以这样做：

struct Shape {
    double sideA = 3;
    virtual double getArea() = 0;
    virtual ~Shape(){}   
};

struct Triangle : public Shape {
    double height = 2;
    double getArea() {
        return 0.5 * sideA * height;
    }
};

struct Square : public Shape {
    double getArea() {
        return sideA * sideA;
    }
};

int main() {
    Shape* sh = new Triangle();
    std::cout << sh->sideA;
    delete sh;
}

PS：以上内容并非全部真相。如果你有一个Shape*，并且你知道它是一个Triangle*，那么你可以使用dynamic_cast，但是这样做通常是设计不佳的标志。您应该努力编写不需要演员表的类。

Answer 3

因为您的基类有一个virtual 函数¹，您可以使用dynamic_cast 转换来检查指向它的指针是否实际上是指向其派生类之一的指针。这将返回nullptr，如果它不属于“测试”类，或者是一个指向派生类的可用指针，如果它是：

int main()
{
    Shape* sh = new Triangle();
    std::cout << sh->getArea() << std::endl;
    if (dynamic_cast<Square*>(sh) != nullptr) { // Check for a valid Square pointer
        Square* sq = dynamic_cast<Square*>(sh);
        std::cout << sq->sideA << std::endl;
    }
    else if (dynamic_cast<Triangle*>(sh) != nullptr) { // Check for a valid Trianlge pointer
        Triangle* tr = dynamic_cast<Triangle*>(sh);
        std::cout << tr->height << std::endl;
    }
    else {
        std::cout << "Unspecified shape type: height unknown!" << std::endl;
    }
    delete sh;
    return 0;

¹请注意，因为你的Shape类中有一个虚函数，你还应该给它一个虚析构函数：

class Shape {
public:
    virtual double getArea() = 0;
    virtual ~Shape() { }
};

有关虚拟析构函数需求的进一步讨论，请参见此处：When to use virtual destructors?。

---

编辑：在您的具体情况下，answer given by rustyx 确实是“正确”的方法；但是，了解/欣赏dynamic_cast 选项的使用很有用，因为如果您从无法修改的第三方基类派生类，这可能是唯一解决方案，因此无法向其添加等效的 getHeight() 函数。

Answer 4

您可以将变量声明为Triangle* 而不是Shape*，这样您就可以访问派生类和基类的方法和变量：

int main()
{
    Triangle* sh = new Triangle();
    Square* sh2 = new Square();
    std::cout << sh->getArea() << std::endl; //3
    std::cout << sh2->getArea() << std::endl; //16
    std::cout << sh->sideA << std::endl; //3
    std::cout << sh2->sideA << std::endl; //4
    delete sh;
}

要安全地使用delete sh，你应该有一个虚拟析构函数

class Shape
{
public:
    virtual double getArea() = 0;
    virtual ~Shape(){} //virtual destructor
};

既然你已经有了一个抽象类，为什么不使用它来访问派生类中的数据：

Here is how I would do it:

#include <iostream>
#include <memory>

class Shape
{  
private:
    double sideA; //shared members can be defined in base class, assuming all
                  //derived classes will have sideA member
protected:    
    Shape(double sideA) : sideA(sideA) {}//for initialization of sideA in derived classes
public:    
    Shape() = default;
    virtual double getArea() = 0;
    double getSideA() { //shared logic
        return sideA;
    }
    virtual ~Shape(){} //virtual destructor
};

class Triangle : public Shape 
{
private:
    double height = 2; //specific property
public:    
    Triangle() : Shape(3) {} //intialize sizeA
    double getHeight(){ //specific method, must instanciate Triangle to access
                        //for collections it's best to use interface method like getArea()
         return height;
    }
    double getArea() override {
        return 0.5 * getSideA() * height;
    }   
};

class Square : public Shape 
{
public:
    Square() : Shape(4) {} //intialize sizeA
    double getArea() override {
        return getSideA() * getSideA();
    }
};


int main()
{
    std::unique_ptr<Shape> sh(new Triangle); //smart pointer
    std::unique_ptr<Shape> sh2(new Square);  //smart pointer

    std::cout << sh->getArea() << std::endl; //3
    std::cout << sh2->getArea() << std::endl; //16
    std::cout << sh->getSideA() << std::endl; //3
    std::cout << sh2->getSideA() << std::endl; //4
    //delete sh; //no need, smart pointer
}

看看smart pointers。