c++ - 如何在子类中使用自定义的虚函数初始化基本成员变量

StructComponent类的构造函数采用不同的逻辑来根据info的传入对象的类型初始化其成员变量。在这里，我使用强制转换将传递参数转换为正确的子类对象。

class StructComponent
{
public:
    StructComponent(const ClassA& info)
    {
        if (info.getType() == CLASS_B)
        {
            const ClassC& classC = dynamic_cast<const ClassC&> info;
            ...
            apply a different logic for ClassB and init member accordingly
        } else if (info.getType() == CLASS_C) {
            apply a different logic for others
            ...
        } else {
                    apply default
            }
    }
}

class ClassA
{
public:
    ClassA(...)
    {
        m_shp = CreateStructComponent();
    }
    virtual boost::shared_ptr<StructComponent> CreateStructComponent()
    {
        return boost::shared_ptr<StructComponent> (new StructComponent(*this));
    }

    ...
    int getType() const { return CLASS_A; }

protected:
    boost::shared_ptr<StructComponent> m_shp;
}

class ClassB : public ClassA
{
public:
    ...

    virtual boost::shared_ptr<StructComponent> CreateStructComponent()
    {
        return boost::shared_ptr<StructComponent> (new StructComponent(*this));
    }
    ...
    int getType() const { return CLASS_B; }
}

class ClassC : public ClassA
{
public:
    ...

    virtual boost::shared_ptr<StructComponent> CreateStructComponent()
    {
        return boost::shared_ptr<StructComponent> (new StructComponent(*this));
    }
    ...
    int getType() const { return CLASS_C; }
}

Q1>代码正确是否忽略了潜在的设计问题？

Q2>假定ClassA的所有子类都具有功能CreateStructComponent的相同实现体。
有没有一种方法可以节省空间，而不必重复执行以下相同的代码：

return boost::shared_ptr<StructComponent> (new StructComponent(*this));

Q3>是否可以使用更好的设计？例如，有没有一种方法可以忽略
StructComponent？

最佳答案

1）不，这是不正确的，至少，它没有达到您的预期。它在ClassA的构造函数中调用一个虚函数，该虚函数将始终调用ClassA::CreateStructComponent()而不是在派生类中调用重写函数，因为当ClassA构造函数运行时，动态类型为ClassA。出于相同的原因，在StructComponent的构造函数中，getType()调用将始终解析为。

2）有很多方法可以解决该问题。您可以将代码放在模板中，因此它取决于类型，或者您可以通过在其他位置进行初始化来摆脱重复代码的需要。

3）为什么不简单地给ClassA::getType()重载的构造函数，一个带StructComponent，一个带ClassB另一个带ClassC？

再说一次，更好的解决方案可能是摆脱ClassA构造函数，并让StructComponent，ClassA或ClassB显式地进行初始化，以便每种类型都按其希望的方式进行初始化。如果初始化取决于创建它的类型，则初始化不属于ClassC构造函数。当前，您具有循环依赖关系，StructComponent需要了解使用它的所有类型，而使用它的所有类型也需要知道StructComponent。这通常是设计存在问题的迹象，所有类都紧密耦合在一起。如果StructComponent对其他类型一无所知，那会更好。

无论如何，这是一个可能的解决方案，它展示了一种在不复制代码的情况下将正确的类型传递给StrictComponent的方法，但是我认为这不是一个好的设计。请注意，StructComponent构造函数被传递为NULL，因此它可以根据类型执行不同的操作，但是无法访问其传递的对象。

class StructComponent
{
public:
    explicit StructComponent(const ClassA*)
    { /* something */ }

    explicit StructComponent(const ClassB*)
    { /* something else */ }

    explicit StructComponent(const ClassC*)
    { /* something completely different */ }
};

class Base
{
protected:
  template<typename T>
    explicit
    Base(const T*)
    : m_shp( boost::make_shared<StructComponent>((T*)NULL) )
    { }

    boost::shared_ptr<StructComponent> m_shp;
};

class ClassA : virtual public Base
{
public:
    ClassA() : Base(this) { }
};

class ClassB : public ClassA
{
public:
    ClassB() : Base(this) { }
};

class ClassC : public ClassA
{
public:
    ClassC() : Base(this) { }
};

这是另一种完全不同的方法，没有虚拟基础黑客，仍然删除重复的代码，并允许Structcomponent访问传递给它的对象（我认为这是一个坏主意）：

class StructComponent
{
public:
    explicit StructComponent(const ClassA& a)
    { /* something */ }

    explicit StructComponent(const ClassB& b)
    { /* something else */ }

    explicit StructComponent(const ClassC& c)
    { /* something completely different */ }
};

class ClassA
{
public:
    ClassA() : m_shp( create(*this) ) { }

protected:
    struct no_init { };

    explicit
    ClassA(no_init)
    : m_shp()
    { }

    template<typename T>
      boost::shared_ptr<StructComponent> create(const T& t)
      { return boost::make_shared<StructComponent>(t); }

    boost::shared_ptr<StructComponent> m_shp;
};

class ClassB : public ClassA
{
public:
    ClassB()
    : ClassA(no_init())
    { m_shp = create(*this); }
};

class ClassC : public ClassA
{
public:
    ClassC()
    : ClassA(no_init())
    { m_shp = create(*this); }
};

这是另一个选择，这次没有循环依赖关系，将不同的初始化代码移到了它所属的位置：

struct StructComponent
{
  StructComponent() { /* minimum init */ }
};

class ClassA
{
public:
    ClassA() : m_shp( createA() ) { }

protected:
    struct no_init { };

    explicit
    ClassA(no_init)
    : m_shp()
    { }

    boost::shared_ptr<StructComponent> createA()
    {
      // something
    }

    boost::shared_ptr<StructComponent> m_shp;
};

class ClassB : public ClassA
{
public:
    ClassB()
    : ClassA(no_init())
    { m_shp = createB(); }

private:
    boost::shared_ptr<StructComponent> createB()
    {
      // something else
    }
};

class ClassC : public ClassA
{
public:
    ClassC()
    : ClassA(no_init())
    { m_shp = createC(); }

private:
    boost::shared_ptr<StructComponent> createC()
    {
      // something completely different
    }
};