Question

我有两个A和B类，其定义如下：

class A
{
    public:
    void *connector;
};

class B
{
    public:
    void *connector1;
    void *connector2;
};

首先，让我们假设我根据这些类创建了三个对象C1，C2和C3，

A C1;
B C2;
A C3;

我使用以下代码连接它们

C1.connector = &C2;
C2.connector1 = &C1;
C2.connector2 = &C3;
C3.connector = &C2;

所以目前我有这个：C1＆lt; - ＆gt; C2 - ＆lt; - ＆gt; C3（第一个例子）。

重要：我在所有类中使用void指针的原因是因为我无法从一开始就预测对象将如何连接。例如，如果我创建第四个对象并建立这些连接（C1和C2与以前相同），则此问题的答案应该是有效的：

B C3;    
A C4;

C1.connector = &C2;
C2.connector1 = &C1;
C2.connector2 = &C3;
C3.connector1 = &C2;
C3.connector2 = &C4;
C4.connector = &C3;

这对应于该C1＆lt; - ＆gt;。 C2 - ＆lt; - ＆gt; C3 - C3。 C4（第二个例子）。

我到处尝试搜索一个简单的解决方案来实现这些对象之间的通信。甚至有几个同名的问题，但我找不到所询问的问题和我试图解决的问题的相应答案之间的相似性。也许是因为我从一开始就没有正确地接近这一点。无论如何，通过通信我的意思是C2可以在C1中调用方法的简单方法，反之亦然。

1）我试图用模板做，但无法弄清楚如何做到这一点。所有类都是模板，并且缝合起来非常人为和复杂（难以阅读，维护和实现）。

2）我尝试使用指针的转换，但由于我不知道正确的形式，他们连接的类的起点我无法做到。

重要提示：虽然我无法保证连接，但我可以很好地生活，因为例如，B类对象确切地知道它将在连接到其连接器的对象中执行的方法的名称。

为清楚起见，我们假设我们引入了一种方法

int get_value();

在A类和B类中（但每个类的实现都不同）。因此，在上面的第二个例子中，C2可以在C1上调用它，C3可以在C2上调用该方法。但请注意，C2和C3是同一类的对象。

好的，既然我解释了我的问题，我想问一个简单的解决方案来解决这个问题。例如，一段代码，用于实现C2和C1之间以及C3和C2之间的通信（参见上面的示例2）。

具体来说，我认为对象C2 / C3可以在C1 / C2中调用get_value方法的示例，这样C2 / C3可以将值存储在私有/公共变量中将是完美的。

我意识到我试图实现这一点的方式可能不是最好的，并且也欢迎以不同方法解决问题的答案。但如果可能的话，请告诉我一些代码和一些解释，因为我的主要目标和专业知识不是编程技能。

非常感谢你。

Answer 1

基本上，void *不是要走的路。

一种替代方法可能是使用不合理：

class OBJ 
{
public:  
    virtual string getValue()=0; 
};

class A : public OBJ 
{
public:
    OBJ *connector;
    string getValue();
};

class B : public OBJ
{
public:
    OBJ *connector1;
    OBJ *connector2;
    string getValue();
};

然后，对象可以轻松地“通信”，引用基础OBJ类的公共成员。

C1.connector->getValue(); 
C1.connector->connector2->getValue();

Answer 2

解决此问题的典型方法是定义一个描述通信的接口类 - 可以执行的功能：

// create an interface to communicate with
struct connected
{
    virtual ~connected() {} // must have virtual dtor

    virtual int get_value() = 0; // pure virtual functions
};

class A
: public connected // implement the connected interface
{
    int value;

public:
    A(int value = 0): value(value) {}

    // implement the connected interface
    int get_value() override { return value; }

    connected* connector = nullptr;
};

class B
: public connected // implement the connected interface
{
    int value;

public:
    B(int value = 0): value(value) {}

    // implement the connected interface
    int get_value() override { return value; }

    connected* connector1 = nullptr;
    connected* connector2 = nullptr;
};

int main()
{
    A C1;
    B C2;
    A C3;

    C1.connector = &C2;
    C2.connector1 = &C1;
    C2.connector2 = &C3;
    C3.connector = &C2;

    C2.connector1->get_value(); // use the connected interface
}

这是有效的，因为A和B 也类型为connected，所以他们只需要关心他们有指向其他{的事实{1}}类型，如果它们是connected或A，则无需关心。

Answer 3

我不知道您的确切需求，但也许您应该阅读observer pattern它可能对您有所帮助。或者，如果你可以尝试使用Qt，它有一个很好的siganl-slot机制。

C ++中对象之间的通信

3 个答案: