是否可以在 C 中编写与类型无关的函数，并在实现中派生类型？

Question

我们有很多看起来像这样的重复代码：

void WriteA(A *to, A *from);
void WriteB(B *to, B *from);
void WriteC(C *to, C *from);

void WriteA(A *to, A *from){
    *to = *from;
}

void WriteB(B *to, B *from){
    *to = *from;
}

void WriteC(C *to, C *from){
    *to = *from;
}

即使 C 没有函数重载或模板，我还是想让它成为一个通用函数。我想我在这里唯一的选择是使用 void 指针。

void Write(void *to, void *from);

但是，似乎没有办法在函数内部导出类型：

void Write(void *to, void *from){
    *to = *from
}

编译器错误：非法类型：void '=' void

似乎也没有办法传递第三个参数，它是一个类型名（同样，我认为只有 C++ 可以用模板完成）。

我将如何编写这种函数？如果可能的话，我想避免使用预处理器。

我想我也许可以这样做：

void Write(void *to, void *from){
    memcpy(pTo, pFrom, sizeof(*pTo));
}

但是，
编译器错误：不知道对象的大小

Answer 1

鉴于您正在尝试复制 C++ 可以实现的功能，为什么不复制 C++ 的功能并实现继承和虚函数？

这是白板代码，既未编译也未测试，但与我过去用 C 实现 OO 设计时所做的事情非常相似。将其作为您可以使用和扩展的模式。

坚持你的示例代码，在你想要通用 copy 函数的地方，首先定义抽象基础 class。

typedef struct base_class
{
    void (*copy) (const void *this, void *to);
}

现在有些继承了classes:

typedef struct A
{
    const base_class *base;
    // Other members
} A;

typedef struct B
{
    const base_class *base;
    // Other members
} B;

为派生的 classes 创建基础 copy 函数和构造函数。断言试图提供一些类型安全

void copy_A(const void *this, void *to)
{
    assert(((const A *)this)->base == ((A *)to)->base)
    memcpy(to, this, sizeof(A));
}

void make_A(A *newA)
{
    const base_class base = {copy_A};
    assert(newA);
    newA->base = &base;
    // other initialization 
}


void copy_B(const void *this, void *to)
{
    assert(((const B *)this)->base == ((B *)to)->base)
    memcpy(to, this, sizeof(B));
}

void make_B(B *newB)
{
    const base_class base = {copy_B};
    assert(newB);
    newB->base = &base;
    // other initialization 
}

最后，你的通用复制方法：

void Write (void *to, const void *from)
{
    const base_class *source_vtable = from;
    source_vtable->copy(from, to);
}

这不是类型安全的，因为不能保证 *from 包含 vtable。为了使其防弹，您真的希望 base_class 包含一个初始标记字段，可以检查该字段以确保那里确实有一个函数 table。

base_class可以扩展包含多个常用函数。

Answer 2

如果您依赖于 struct 成员，一种方法是使用 C 预处理器。

但是根据您的评论，您实际上只依赖于 struct 类型和成员，这是在特定位置完成的分配。

最简单的方法是在上面的评论中使用 Leonardo Herrera 的建议并传入 struct 尺寸，然后使用 memcpy() struct 参数的大小。

另一种可能性是创建两个函数，一个执行赋值前的工作，另一个执行赋值后的工作，然后调用第一个函数，进行实际赋值，然后调用第二个函数。例如：

// define the structs that we are using.
typedef struct {
     int jj;
     int kk;
} s1;

typedef struct {
     int kk;
     int ii;
     int jj;
} s2;

// define the function that does the first part of the work
void PhaseOne (/* arg list */)
{
    // phase one of the functionality
}

// define the function that does the second part of the work
void PhaseTwo (/* arg list */)
{
    // phase two of the functionality
}

myFunctionUser (void)
{
    s1  a1, b1;
    s2  a2, b2;

    // do things with a1 and b1 in prep to call the function
    // do things with a2 and b2 in prep to call the function

    PhaseOne (/* arg list */);
    a1 = b1;
    PhaseTwo (/* arg list */);

    PhaseOne (/* arg list */);
    a2 = b2;
    PhaseTwo (/* arg list */);

    // do more stuff

}

如果需要在 PhaseOne() 和 PhaseTwo() 之间传递状态，或者如果需要对根据 PhaseOne() 的状态分配的变量进行一些更改或 PhaseTwo() 那么您可能需要一个 struct 或其他变量类型。

然而，另一件事是编写一个函数，该函数接受指向另一个函数的指针，并在另一个函数中进行赋值。这是借用了 C 标准库如何使用 qsort() 函数的比较函数的想法。使用这种方法，如果除了赋值之外还有其他与结构有关的事情，那么指向的函数将是执行此操作的地方，因为此时您可以转换为适当的类型，然后执行任何操作。

// define the structs that we are using.
typedef struct {
     int jj;
     int kk;
} s1;

typedef struct {
     int kk;
     int ii;
     int jj;
} s2;

void AssignS1 (void *a, void *b) { *((s1 *)a) = *((s1 *)b); return; }
void AssignS2 (void *a, void *b) { *((s2 *)a) = *((s2 *)b); return; }

void myFunction (void *a, void *b, void (*pFunc)(void *x, void *y))
{
     //   do stuff
     pFunc(a, b);    // do the assignment
     //   do more and more and tons of stuff
}

myFunctionUser (void)
{
    s1  a1, b1;
    s2  a2, b2;

    // do things with a1 and b1 in prep to call the function
    // do things with a2 and b2 in prep to call the function

    myFunction (&a1, &b1, AssignS1);

    myFunction (&a2, &b2, AssignS2);

    // do more stuff

}

仅供参考，这是一种使用 C 预处理器根据特定结构类型生成源代码的方法。它非常丑陋且难以调试，并且需要程序员一定程度的纪律。这是一个用于说明过程的小而简单的函数，我向您保证它不会很好地扩展。

// define a macro that will generate various type specific versions of a function.
#define WriteThing(s) void WriteThing##s (s *a, s *b) \
    { *a = *b;  if (a->jj != 4) { a->jj += b->jj + 10;} return; }

// define the function we will use to call the above function based on the type of the arguments
#define WriteThingCall(s,a,b) WriteThing##s (a, b)

// define the structs that we are using.
typedef struct {
    int jj;
    int kk;
} s1;

typedef struct {
    int kk;
    int ii;
    int jj;
} s2;

// generate the functions we are going to need for our different types
WriteThing(s1)

WriteThing(s2)

// example function of how to use this approach.
void func (void)
{
    s1  a1 = {0}, b1 = {0};
    s2  a2 = {0}, b2 = {0};

    WriteThingCall(s1, &a1, &b1);
    WriteThingCall(s2, &a2, &b2);

}

是否可以在 C 中编写与类型无关的函数，并在实现中派生类型？

Is it possible to write type agnostic functions in C, and derive the type in the implementation?

c

function

templates

generics

void-pointers