抽象类访问其子类函数

Question

是否可以作为父类从抽象类的指针访问子类的函数成员？ 这是抽象类

class Item {
    public:
        virtual double getTotalPrice() = 0;
};

这是子类

class Product : public Item {
    protected:
        string name;
    public:
        Product() {}
        string getName() {}
        double getTotalPrice() {}
};

是否可以在主驱动程序中从 Item 类的实例访问此 getName() 函数，因为我还想显示总价和产品名称？

Answer 1

• 如果您应该能够通过基类指针 delete 对象，则您的基类需要有一个 virtual 析构函数。
• 也制作getNamevirtual。

class Item {
public:
    virtual ~Item() = default;
    virtual const string& getName() /* const */ = 0;
    virtual double getTotalPrice() /* const */ = 0;
};

---

请注意，不允许您更改的 Product 类存在轻微缺陷。

• 它没有返回应该返回的值。
• getter 成员函数不是const。

如果您不能自己做，请提出一些更改：

class Product : public Item {
private: // prefer private member variables
    string name;
public:
    Product() = default;
    const string& getName() const override { return name; }
    double getTotalPrice() const override {
       // why is this implemented here when there's no price to return?
       return {};
    }
};

Answer 2

您不能拥有 abstract Item 类的实例（因为它是抽象的），但您可以拥有指向派生（和非抽象）@ 的 Item 指针（或引用） 987654323@班级。

但是因为 Item 声明没有 getName() ，你可能需要做一个 dynamic_cast 来检查指针是否真的是 Product，例如。

Item* item = new Product();
...

// at same later time or some ooter function:
// use dynamic_cast to check if the pointee is the type you expect it to be

Product* p = dynamic_cast<Product>(item);
if (p) p->getName();

虽然，不直接针对您的问题，我认为这里还有一个设计问题。像 Product 这样的东西由许多项目组成，所以它是 1:N 的组合关系。对于获得总价格的概念（例如 Billable ）将是更合适的。 所以我可能会建议类层次结构如下：

class Billable
{
public:
    virtual double getTotalPrice() const = 0;
    virtual ~Billable() {}
};

class Item : public Billable
{
    string name;
public:
    string getName() const { return name; }
    double getTotalPrice() const override { ... impl .. }
    // ... rest 
}

class Product : public Billable
{
    string name;
    vector<Items> items;
public:
    string getName() const { return name; }
    double getTotalPrice() const override
    {
         return accumulate(begin(items), end(items), 0, [](auto i) { return i->getTotalPrice(); });
    }
    // ... rest ...
    
}

Answer 3

如果您确定指针指向Product 类型的实际对象，则可以进行静态转换；如果您不确定并想先检查它，则可以进行动态转换。如果指针不指向派生类的对象，这将不起作用。

class Item {
    public:
        virtual double getTotalPrice() = 0;
};

class Product : public Item {
    protected:
        string name;
    public:
        Product() {}
        string getName() {return {};}
        double getTotalPrice() {return {};}
};

int main() {
    Product p;
    Item *i = &p;
    
    static_cast<Product *>(i)->getName();

    auto *ptr = dynamic_cast<Product *>(i);
    if (ptr) ptr->getName();
}

dynamic_cast 需要运行时类型信息 (RTTP) 并附带一些额外费用。

通常最好重新设计架构而不是沮丧。