我有一个父类，其中有 2 个或更多子类派生自它。随着更多需求的提出， future 不同子类的数量可能会增加，但它们都将遵循基类方案，并且将包含很少有自己独特的方法。让我举一个例子 -

#include <iostream>
#include <string>
#include <vector>
#include <memory>

class B{
    private: int a; int b;
    public: B(const int _a, const int _b) : a(_a), b(_b){}
    virtual void tell(){ std::cout << "BASE" << std::endl; }
};

class C : public B{
    std::string s;
    public: C(int _a, int _b, std::string _s) : B(_a, _b), s(_s){}
    void tell() override { std::cout << "CHILD C" << std::endl; }
    void CFunc() {std::cout << "Can be called only from C" << std::endl;}
};

class D : public B{
    double d;
    public: D(int _a, int _b, double _d) : B(_a, _b), d(_d){}
    void tell() override { std::cout << "CHILD D" << std::endl; }
    void DFunc() {std::cout << "Can be called only from D" << std::endl;}
};

int main() {
    std::vector<std::unique_ptr<B>> v;

    v.push_back(std::make_unique<C>(1,2, "boom"));
    v.push_back(std::make_unique<D>(1,2, 44.3));

    for(auto &el: v){
        el->tell();
    }
    return 0;
}

在上面的例子中 tell()方法可以正常工作，因为它是虚拟的并且在子类中被正确覆盖。但是现在我无法调用 CFunc()方法和DFunc()各自类的方法。所以我有两个选择 -

• 任一包CFunc()和 friend 在子类中一些已经定义的虚拟方法中，以便它一起执行。但随着数量的增加，我将放松对独特方法的特定执行的控制。

• 或者在基类中提供一些纯虚方法，比如void process() = 0并让它们根据需要在子类中定义。可能会留空void process(){}被一些人使用，被一些人使用。但同样感觉不对，因为我在此过程中丢失了返回值和参数。也像之前的选项一样，如果某个子类中有更多方法，这感觉不是正确的解决方法。

还有一个-

• dynamic_cast<> ?.这会是一个不错的选择吗 - 将父指针转换为子指针(顺便说一句，我在这里使用智能指针，所以只允许 unique/shared)然后调用所需的函数。但是我将如何区分黑白不同的子类？另一个可能返回一些唯一类枚举值的公共(public)成员？

我对这种情况非常陌生，希望得到一些反馈。我应该如何解决这个问题？

最佳答案

I've a parent class with 2 or more child class deriving from it... But I'll loose control over particular execution of unique methods as their number rises.

当方法的数量预计会增加并且派生类预计保持相对稳定时，另一个有用的选项是使用visitor pattern。 .以下使用boost::variant .

假设您从三个类(class)开始:

#include <memory>
#include <iostream>

using namespace std;
using namespace boost;

class b{};
class c : public b{};
class d : public b{};

您使用变体类型，而不是使用指向基类 b 的(智能)指针:

using variant_t = variant<c, d>;

和变体变量:

variant_t v{c{}};

现在，如果你想以不同的方式处理 c 和 d 方法，你可以使用:

struct unique_visitor : public boost::static_visitor<void> {
    void operator()(c c_) const { cout << "c" << endl; };
    void operator()(d d_) const { cout << "d" << endl; };
};

你会用它来调用

apply_visitor(unique_visitor{}, v);

请注意，您也可以使用相同的机制来统一处理所有类型，方法是使用接受基类的访问者:

struct common_visitor : public boost::static_visitor<void> {
    void operator()(b b_) const { cout << "b" << endl; };
};

apply_visitor(common_visitor{}, v);

请注意，如果类的数量增长速度快于方法的数量，这种方法会导致维护问题。

完整代码:

#include "boost/variant.hpp"
#include <iostream>

using namespace std;
using namespace boost;

class b{};
class c : public b{};
class d : public b{};

using variant_t = variant<c, d>;

struct unique_visitor : public boost::static_visitor<void> {
    void operator()(c c_) const { cout << "c" << endl; };
    void operator()(d d_) const { cout << "d" << endl; };
};

struct common_visitor : public boost::static_visitor<void> {
    void operator()(b b_) const { cout << "b" << endl; };
};

int main() {
    variant_t v{c{}};
    apply_visitor(unique_visitor{}, v);
    apply_visitor(common_visitor{}, v);
}

关于c++ - 从具有不同子类的父指针调用子方法，我们在Stack Overflow上找到一个类似的问题： https://stackoverflow.com/questions/39563063/