处理两种类型的链表的单个函数

Question

我有两个链表：-

struct Struct_A_s {
int a;
struct  Struct_A_s *next;
}Struct_A;

struct Struct_B_s {
int a;
int b;
int c;
int d;
struct  Struct_B_s *next;
}Struct_B;

我已经有几个在 Struct_A 上运行的函数。 像这样的事情：

“Add_tail(Struct_A *)”、“Remove_tail(Struct_B *)”、“Add_node(Struct_A *,int pos)、Add_head等都到位了。

对我的要求是我应该修改现有的函数，以便它们可以在 Struct_A 和 Struct_B 上运行。

在 C 中，有没有一种方法可以传递 void 指针（或类似的东西）并编写一些通用代码来处理 Struct_A 和 Struct_B。 代码大小在这里是一个大问题。目前我看到的唯一选择是从头开始为 Struct_B 重写所有代码（链表操作）。

Answer 1

有几种方法可以解决。而且我敢肯定，其他人比我可能有其他人建议的更熟练。

• 选项 A：传递一个 void 指针和某种数据类型指示，然后进行转换。
• 选项 B：将两个指针组合成一个并集并传递它。
• 选项 C：将类型和联合组合成一个结构并传递它
• 选项 D：使用更受尊重的替代方案来代替联合

一些示例代码...

enum DataType { TYPE_1, TYPE_2 };

struct Type1 { ... };
struct Type2 { ... };

union Data
{
    void*         addr;
    struct Type1* type1;
    struct Type2* type2;
}

struct Object
{
    DataType type;
    union Data data;
}

struct Thing
{
    DataType type;
    void* data;
}

void someFunc1( void* data, DataType type )
{
   switch( type )
   {
       case TYPE_1:
       {
           struct Type1* type1 = (struct Type1*)data;
           ...
           break;
       }
       case TYPE_2:
       {
           struct Type2* type2 = (struct Type2*)data;
           ...
           break;
       }
   }
}

void someFunc2( union Data* data, DataType type )
{
   switch( type )
   {
       case TYPE_1:
       {
           struct Type1* type1 = data->type1;
           ...
           break;
       }
       case TYPE_2:
       {
           struct Type2* type2 = data->type2;
           ...
           break;
       }
   }
}

void someFunc3( struct Object* object )
{
   switch( object->type )
   {
       case TYPE_1:
       {
           struct Type1* type1 = object->data.type1;
           ...
           break;
       }
       case TYPE_2:
       {
           struct Type2* type2 = object->data.type2;
           ...
           break;
       }
   }
}


void someFunc4( struct Thing* thing )
{
   switch( thing->type )
   {
       case TYPE_1:
       {
           struct Type1* type1 = (struct Type1*)thing->data;
           ...
           break;
       }
       case TYPE_2:
       {
           struct Type2* type2 = (struct Type2*)thing->data;
           ...
           break;
       }
   }
}

换个角度看……如果你有一个只需要a的方法，那么你可以做这样的事情……

void myFunc( int a ) { ... };

void someFunc3( struct Object* object )
{
    myFunc( object->type == TYPE_1 ? object->data.type1->a : object->data.type2->a );
}

更好的是...修改函数以接受对象并仅在底部区分...

void myFunc( struct Object* object )
{
   int* a;

   switch( object->type )
   {
       case TYPE_1:
       {
           a = &object->data.type1->a
           break;
       }
       case TYPE_2:
       {
           a = &object->data.type2->a;
           break;
       }
       default:
       {
           abort();
       }
   }

   // do work with a as though it were passed in as a pointer to int

   if( object->type == TYPE_2 )
   {
      // do additional work with the b, c, d elements, etc.
   }
}

Answer 2

是的，您可以使用void *，否则您可以使用Struct_A * 或Struct_B *。您需要仔细设计您的 API。通常，您最终会像bsearch() 和qsort() 那样使用一个或多个函数指针来执行特定于结构的操作（比较bsearch() 和qsort()）。

请注意，遍历链表会很困难，因为下一个指针在结构中的不同偏移量处。使用包含 next 指针和指向实际结构的 void * 的固定通用列表结构可能会做得更好。

typedef struct List List;

struct List
{
    List *next;
  //List *prev;   // Doubly-linked lists
    void *data;
};

这是“侵入式”和“非侵入式”列表结构之间的区别。您现有的设计使用侵入式列表结构；修改列表中的结构以包含指针。建议的替代设计是非侵入式的；您可以在不修改结构类型的情况下创建任何结构类型的列表。

Answer 3

您可以重新定义结构如下。您必须根据类型进行大量转换才能修改所有早期功能以同时适用于两者。两者都需要使用 Struct_A *。

struct Struct_A_s {
    int type;
    Struct_A_s *next;
    int a;
}Struct_A;

struct Struct_B_s {
    int type;
    Struct_A *next;
    int a;
    int b;
    int c;
    int d;
}Struct_B;