C ++：Class&回调问题 [英] C++ : Class & callbacks issue

问题描述

这里是我的代码&要求：

我有2个A& B，它们没有任何继承。我使用一个类A的方法来调用类B的一个方法。然后类B的方法应该回调一个类A的方法来执行一个回调。

代码部分：

classA.h：

  #includeclassB.h
 
 class classA 
 {
 public：
 classA（）; 
 classB * pClassB; 
 void callClassB（）; 
 void callBack（）; 
}; 
  

classA.cpp：

  #includeclassA.h
 classA :: classA（）
 {
 pClassB = new classB（）; 
} 
 
 void classA :: callBack（）
 {
 return; 
} 
 
 void classA :: callClassB（）
 {
 pClassB-> callFunction（）; 
} 
  

classB.h：

  class classB 
 {
 public：
 classB（）; 
 void callFunction（）; 
} 
  

classB.cpp：

  #includeclassB.h
 classB :: classB（）
 {
} 
 
 void classB： ：callFunction（）
 {
 //我应该在这里调用classA的回调函数！ 
} 
  

问题是，我不能在classB.h中包含classA.h因为它会导致一些编译问题在其他地方（我不能解决）。我不能让classB作为classA的子类（如果可以，我只需要做 classA :: callBack（））。

UPDATE：这是我修改过的：

  class classB 
 {
 public：
 classB（classA& pCallBack）; 
 void callFunction（）; 
 void（classA :: * m_callback）（void）; 
}; 
 
 classA :: classA（）
 {
 pClassB = new classB（* this）; 
} 
 
 classB :: classB（classA& pCallBack）
 {
 m_callback = pCallBack; 
} 
  

我试图保存指针，但也失败。

解决方案

实际上，在每个其他是循环依赖，编译器无法解析。

使用向前声明

最多的打破循环依赖的简单方法是使用向前声明。前向声明只告诉编译器给定的名称表示一个类。这是足够的，如果你只使用指针/引用的类型，因为在这些情况下，编译器不需要该类型的完整定义。因此，您可以这样更改 classA.h ：

  class classB; 
 
 class classA 
 {
 public：
 classA（）; 
 classB * pClassB; 
 void callClassB（）; 
 void callBack（）; 
}; 
  

这样，标题不再依赖于classB.h 。当然，您现在需要 classA.cpp 中的 #include 标题：

  #includeclassA.h
 #includeclassB.h
 ... 
  

介绍一个接口

另一种方法是引入一个超级接口（或在C ++中，一个抽象超类） classA ，并让 classB 只能看到：

callback.h：

  class callback 
 {
 public：
 virtual void callBack = 0; 
}; 
  

classA.h：

  #includecallback.h
 
类classB; 
 
 class classA：public callback 
 {
 public：
 classA（）; 
 classB * pClassB; 
 void callClassB（）; 
 void callBack（）; 
}; 
  

classB.h：

  #includecallback.h
 
 class class B 
 {
 callback&嘛; 
 public：
 classB（callback& a）; 
 void callFunction（）; 
}; 
  

classB.cpp：

  #includeclassB.h
 
 classB :: classB（callback& a）：m_a（a）{} 
 
 classB :: callFunction （）
 {
 m_a.callBack（）; 
} 
  

如你所见，这样 classB 不以任何方式依赖 classA 。这实际上允许您以后用 callback 的任何其他实现替换 classA ，而不用触及

介绍一个函数指针

定义/使用与 classA :: callBack（）匹配的函数指针类型，并且只传递指向回调函数的指针 classB ，而不是整个 classA 对象。虽然，这只能与 static 方法无缝连接 - 对于非静态函数，您仍然需要一个 classA 对象。 / p>

更新

您正在混合两种方法（传递 classA 或只传递一个函数指针）。更好地坚持一个一个。第一种方法更简单，这是它的样子：

  class classA; 
 
 class classB 
 {
 classA&嘛; 
 public：
 classB（classA& a）; 
 void callFunction（）; 
}; 
 
 classB :: classB（classA& a）：m_a（a）{} 
 
 classB :: callFunction（）
 {
 m_a.callBack （）; 
} 
  

函数指针方法对于非静态成员函数会更复杂， 函数指针和要调用它的对象。一个替代的选择显示在@ Tadeusz的回答。

Here is my code & requirements:

I have 2 classes A & B, they don't have any inheritance. I used one method of class A to call one method of Class B. Then the class B's method should callback one of the class A's method to execute a callback.

Part of code:

classA.h:

#include "classB.h"

class classA
{
  public:
  classA();
  classB *pClassB;
  void callClassB();
  void callBack();
};

classA.cpp:

#include "classA.h"
classA::classA()
{
  pClassB = new classB();
}

void classA::callBack()
{
  return;
}

void classA::callClassB()
{
  pClassB->callFunction();
}

classB.h:

class classB
{
  public:
  classB();
  void callFunction();
}

classB.cpp:

#include "classB.h"
classB::classB()
{
}

void classB::callFunction()
{
   // I should call classA's callback here!
}

The problem is, I can't include classA.h in classB.h because it will cause some compile issue elsewhere(I can't solve that). I can't make classB as classA's subclass(if I can, I just have to do classA::callBack() instead). So is there a solution to this situation?

UPDATE：that's what I've modified:

class classB
{
  public:
  classB(classA& pCallBack);
  void callFunction();
  void (classA::*m_callback)(void);
};

classA::classA()
{
  pClassB = new classB(*this);
}

classB::classB(classA& pCallBack)
{
  m_callback = pCallBack;
}

I tried to save the pointer, but also failed. It says "assigning from incompatible type"... what's wrong with it??

解决方案

Indeed, reciprocally including both headers in each other is a circular dependency, which the compiler can't resolve. There are different ways to solve this, three of which I describe below.

Using forward declarations

The most straightforward way to break the circular dependency is to use forward declarations. A forward declaration only tells the compiler that a given name denotes a class. That is enough if you only use pointers/references to that type, because in these cases the compiler doesn't need the full definition of that type. So you can change classA.h like this:

class classB;

class classA
{
  public:
  classA();
  classB *pClassB;
  void callClassB();
  void callBack();
};

This way the header is not dependent on classB.h anymore. Of course, you need now to #include that header in classA.cpp:

#include "classA.h"
#include "classB.h"
...

Introducing an interface

Another way is to introduce a super interface (or in C++, an abstract superclass) to classA, and let classB see only that:

callback.h:

class callback
{
  public:
  virtual void callBack() = 0;
};

classA.h:

#include "callback.h"

class classB;

class classA : public callback
{
  public:
  classA();
  classB *pClassB;
  void callClassB();
  void callBack();
};

classB.h:

#include "callback.h"

class classB
{
  callback& m_a;
public:
  classB(callback& a);
  void callFunction();
};

classB.cpp:

#include "classB.h"

classB::classB(callback& a) : m_a(a) {}

classB::callFunction()
{
  m_a.callBack();
}

As you see, this way classB does not depend on classA in any way. This in fact allows you to later replace classA with any other implementation of callback, without touching classB's definition.

Introducing a function pointer

Yet another possibility would be to define / use a function pointer type matching that of classA::callBack(), and pass only the pointer to the callback function to classB, rather than the whole classA object. Although, this only works seamlessly with static methods - for nonstatic functions you still need a classA object for the call.

Update

You are mixing two approaches (passing an object of classA or passing only a function pointer) in your modified code. Better stick with one at a time. The first approach is simpler, this is how it would look like:

class classA;

class classB
{
  classA& m_a;
public:
  classB(classA& a);
  void callFunction();
};

classB::classB(classA& a) : m_a(a) {}

classB::callFunction()
{
  m_a.callBack();
}

The function pointer approach would be more complex for nonstatic member functions, because you needed both the function pointer and an object on which to invoke it. An alternative take on it is shown in @Tadeusz's answer.

这篇关于C ++：Class&回调问题的文章就介绍到这了，希望我们推荐的答案对大家有所帮助，也希望大家多多支持IT屋！