Question

假设B类的对象是A类的成员。

class B{
    //Definitions
}

class A{
public:
    A();
    B b_child;
    int some_function();
}

B中定义的一个函数需要从其所有者（父？）A调用（公共）函数。有没有立即的方法来做到这一点？

到目前为止，我设法做到这一点的唯一方法是在类的定义之外实现它：

A a_obj;
a_obj.b_child.setowner(&aobj);

告诉b_child谁是其所有者。我不喜欢这个。我宁愿使用b_child的一些内置方法来访问它的父（如果可能的话）。如果那是不可能的，我宁愿直接在B的构造函数中传递所有者的地址，但我不知道如何在其定义中引用A的地址。

Answer 1

我宁愿使用一些内置方法让b_child访问其父级（如果可能的话）。

不，不是。

但我不知道如何在其定义中引用A的地址。

您可以使用this指针。

A() : b_child(this) { }

Answer 2

没有内置方法来获取变量的“所有者”，无论这意味着什么。您设置所有者的方法是正确的。此外，在B的构造中这样做也是正确的决定。示例代码：

class B
{
public:
    explicit B( A* owner ) : _owner( owner ) {}

    ...
private:
    A* _owner;
};

class A
{
public:
    A() : _child( this ) {}

    ...
private:
    B _child;
};

请注意，某些编译器可能会在该上下文中使用this向您发出警告，但对于当前示例它可以。只要确保你没有在A构造函数中调用任何B成员函数，因为你得到的指针仍指向那个阶段的未构造对象。

Answer 3

您应该使用this指针来引用其自身内的对象

class B{
    //Definitions
}

class A{
private:
    B b_child;
public:
    A()
    { 
       b_child.set_owner(this);
    }
}

Answer 4

您应该定义B，如下所示：

template <class T, int N>
class B
{
public:
  int example_func() { return static_cast<T&>(*this).some_function(); }
};

然后将B<A>作为A的子类（这样它就可以直接调用A。）

class A : protected B<A,0>, protected B<A,1>
{
    A();
    int some_function() { return 42; }
};

这称为curiously recurring template pattern。

如果您不希望B成为模板类，并且您只想将B与A一起使用，那么以下情况就可以了：

template <int N>
class B
{
public:
  int example_func() { return static_cast<A&>(*this).some_function(); }
};

class A : protected B<0>, protected B<1>
{
    A();
    int some_function() { return 42; }
};

或者，如果您想使用B而不只是A，但又不想让B成为模板类（例如，如果您想要一组指针，请B），您可以执行以下操作：

template <int N>
class B
{
public:
  int example_func() { return some_function(); }
  virtual int some_function() = 0;
};

class A : protected B<0>, protected B<1>
{
    A();
    int some_function() { return 42; }
};

这将在运行时解析some_function()调用，并要求将虚拟指针存储在您的类中。

从子类中调用类函数

4 个答案: