访问父类中的子成员，C++

Question

我面临需要访问父类中的子成员变量的情况。我知道这违反了 OO 原则，但我必须处理这样一种情况，即数百个类从一个类继承，并且其中一半停止使用父变量之一，并声明并使用自己的（需要切换从 int 到 int[] 并且显然这样做的人没有考虑在父类中应用此更改）。

一种选择是使用虚拟函数来处理它，但这意味着我必须更改数百个文件/对象中的代码并测试它们中的每一个。因此，我认为如果可以使用一些老式的 C 指针魔法来访问父方法中的这些变量，这将消除对数百个虚拟函数的需求。

基本上这就是我想要实现的目标：

class Parent
{
    void DoSomething()
    {
        // This is what I need
        childMember = 0;
    }
}

class Child1 : Parent
{
    int childMember;
}

class Child2 : Parent
{
    int childMember;
}

如果这可能，请告诉我。如果是，我该如何实现。
欢迎其他建议，但请记住，我只想在父类中进行更改。
TIA。

Answer 1

如果允许您更改子类的源代码，您可以这样做：

class Parent
{
public:
    void DoSomething()
    {
        getMember() = 0;
    }
    virtual int & getMember() = 0;
};

class Child1 : public Parent
{
    int childMember;
public:
    int & getMember()
    {
        return childMember;
    }
};

class Child2 : public Parent
{
    int childMember;
public:
    int & getMember()
    {
        return childMember;
    }
};

否则，如果你的对象有虚拟表（至少一个虚拟方法），你可以结合C++11 typeid使用static_cast()，因为它比dynamic_cast快三倍左右：

#include <typeinfo>

class Parent
{
public:
    virtual void DoSomething();
};

class Child1 : public Parent
{
public:
    int childMember;
};

class Child2 : public Parent
{
public:
    int childMember;
};

void Parent::DoSomething()
{
    if (typeid(Child1) == typeid(*this))
    {
        auto child = static_cast<Child1*>(this);
        child->childMember = 0;
    }
    else if (typeid(Child2) == typeid(*this))
    {
        auto child = static_cast<Child2*>(this);
        child->childMember = 0;
    }
};

Answer 2

我没有得到静态演员表的反对票。以下作品：

#include <stdio.h>
class B;
class A {
    public:
        A();
        void print();
    private:
        B *child;
};

class B : public A {
    friend class A;
    public:
        B();
    private:
        int value;
};

A::A(){
    child = static_cast<B*>(this);
}

void A::print(){
    printf("value = %d\n", child->value);
}

B::B(){
    value = 10;
}

int main(){
    B b;
    b.A::print();
}

只需确保将 A 函数的声明放在 B 类的定义之后。您可以区分子类，因为如果您找到了正确的子类，静态转换将返回非 NULL。我发现这种方法也很有用，因为 Child 类 (B) 几乎没有改变。

Answer 3

CRTP 可能在这里有帮助：

struct Parent
{
    virtual void DoSomething() = 0;
};

template <typename Derived>
struct ParentProxy : Parent
{
    virtual void DoSomething()
    {
        Derived* p = dynamic_cast<Derived*>(this);
        p->childMember = 27;
    }
};

struct Child1 : ParentProxy<Child1>
{
    int childMember;
};

struct Child2 : ParentProxy<Child2>
{
    int childMember;
};

int main()
{
    Child1 child1;
    Child2 child2;

    Parent* objects[] = { &child1, &child2 };
    const int objectCount = sizeof(objects) / sizeof(objects[0]);
    for (int index = 0; index < objectCount; ++index)
    {
        Parent* parent = objects[index];
        parent->DoSomething();
    }
}

我更改了可编译的代码 - 可能不是您的要求 - 但随后提供了更好的（=可编译的）示例代码。

Answer 4

是否可以选择包含您需要访问的 childMember 的中间抽象类？

如果是这样：

class Parent
{
    virtual void DoSomething() //Parent must be a polymorphing type to allow dyn_casting
    {
        if (AbstractChild* child = dynamic_cast<AbstractChild*>(this)) {
            child->childMember = 0;
        } else //Its not an AbstractChild
    }
}

class AbstractChild : Parent 
{ 

     int childMember; 
     virtual void DoSomething() = 0;
}

class Child1 : AbstractChild {
     virtual void DoSomething() { }
}

Answer 5

您可以使用curiously recurring template pattern 来实现此目的。

template<typename T>
class Parent
{
    void DoSomething()
    {
        // This is what I need
        T::childMember = 0;
    }

    virtual ~Parent() {}
};

class Child1 : Parent<Child1>
{
  int childMember;

  friend class Parent<Child1>;
};

Answer 6

显然你有一些派生类的子集使用childMember。 对于这些类，您有一些可以调用的方法“DoSomething()”。我猜对于所有其他派生类，方法DoSomething() 不适用。为什么不为这组派生类创建另一个抽象级别？

class Parent
{
    // no DoSomething()
}

class ChildMemberClasses : Parent
{
    int childMember;

    void DoSomething()
    {
        // code that uses childMember
    }
}

class ChildWithChildMember : ChildMemberClasses
{
    // other stuff
}

如果DoSomething() 对没有childMember 的类有一些意义，你仍然可以在Parent 中将它定义为虚方法。像这样：

class Parent
{
    virtual void DoSomething()
    {
        // code that does not use childMember
    }
}

class ChildMemberClasses : Parent
{
    int childMember;

    void DoSomething()
    {
        // code that uses childMember
    }
}

class ChildWithChildMember : ChildMemberClasses
{
    // other stuff
}

Answer 7

唯一干净的方法是使用虚函数方法。

如果Parent 类至少有一个虚函数（不一定是DoSomething），还有一种很糟糕的方法：

void DoSomething() {
    if (Child1* child = dynamic_cast<Child1*>(this)) {
        child->childMember = 0;
    } else if (Child2* child = dynamic_cast<Child2*>(this)) {
        child->childMember = 0;
    } // and so on, and so forth
}

（如果Parent 没有虚函数，那么dynamic_cast 将不起作用。不过，任何设计为从中继承的类都应该至少有一个虚函数，即使它只是析构函数。）

Answer 8

static_cast<Child*>(this)->childMember = 0; 应该可以工作。

Answer 9

没有安全、可靠的方法可以使用指针来执行此操作。您可以使用巧妙的指针偏移来解决问题，但这将依赖于 childMember 出现在所有子类中的同一位置。