Question

我正在用C开发，我需要询问有关回调使用的信息。

假设我在回调的输入中定义了3种具有3种不同类型的回调，例如：

typedef void (*CB_1) (const struct paramType_1 *p);
typedef void (*CB_2) (const struct paramType_2 *p);
typedef void (*CB_3) (const struct paramType_3 *p);

好吧，我有3个回调数组，每个回调类型：

static CB_1         CB1List[10] ;
static CB_2         CB2List[10] ;
static CB_3         CB3List[10] ;

因此，我定义了3个要调用的回调列表（在不同的情况下），每个列表都是具有特定回调参数（paramType_1，paramType_2或paramType_3）的特定类型的回调（CB_1，CB_2或CB_3）。 / p>

现在假设我需要对每个回调执行相同的操作...由于特定参数不同，我必须将粘贴复制3倍于函数，例如...假设我需要向数组添加回调这个；

   static void CBAdd_1(CB_1 _cb) {   
      CB1List[i] = _cb
    }
   static void CBAdd_2(CB_2 _cb) {   
      CB2List[i] = _cb
    }
    static void CBAdd_3(CB_3 _cb) {  
      CB3List[i] = _cb
    }

什么是使用通用函数“ void CBAdd”而不将三个回调函数复制三遍的正确方法？也许使用（void *）参数或其他参数？

谢谢

Answer 1

是的，您需要一个如下的void *参数。或者（取决于您的需要），您可以使用联合而不是struct并将所有成员存储在该单一联合类型中。有了这个，联合类型参数将被传递给所有函数，函数定义可以决定使用哪个成员。

#include <stdio.h>

typedef struct paramType_1
{
  int p;
} paramType_1;

typedef struct paramType_2
{
  int p;
} paramType_2;

typedef struct paramType_3
{
  int p;
} paramType_3;

typedef void (*CB) (const void* p);

static CB CBList[10];

void CB_1(const void* p)
{
  const paramType_1* pt = (paramType_1*)p;
  printf("p1: %d\n", pt->p);
}

void CB_2(const void* p)
{
  const paramType_2* pt = (paramType_2*)p;
  printf("p2: %d\n", pt->p);
}

void CB_3(const void *p)
{
  const paramType_3* pt = (paramType_3*)p;
  printf("p3: %d\n", pt->p);
}

static int c = 0;

static void CBAdd(CB cb_)
{
  CBList[c++] = cb_;
}

int main()
{
  int i = 0;
  paramType_1 p1;
  paramType_2 p2;
  paramType_3 p3;

  for (i = 0; i < 3; i++)
  {
    CBAdd(CB_1);
  }

  for (i = 0; i < 3; i++)
  {
    CBAdd(CB_2);
  }

  for (i = 0; i < 3; i++)
  {
    CBAdd(CB_3);
  }

  p1.p = 1;
  p2.p = 2;
  p3.p = 3;

  for (i = 0; i < 3; i++)
  {
    (CBList[i])((void*)&p1);
  }

  for (i = 3; i < 6; i++)
  {
    (CBList[i])((void*)&p2);
  }

  for (i = 6; i < 9; i++)
  {
    (CBList[i])((void*)&p3);
  }

  return 0;
}

正确将回调用于相同的操作和不同的类型

1 个答案: