Virtual functions in C

Question

Possible Duplicate:
How could one implement C++ virtual functions in C

In C++ the only difference between a class and a struct is the default access level. So you can have virtual functions in structures, inherit from structures and so on. My question is, can you also do this in C?

Answer 1

You can do "virtual functions" with function pointers stored in your structs. For inheratince, you can embed a struct in another struct but the syntax, again, is going to be different than what you would expect. You can write object-oriented programs in C (classic example is the unix file/socket/... API), but with a quite awkward syntax.

Relevant answers here: https://stackoverflow.com/search?q=C+virtual+functions

Answer 2

C has no native syntax for virtual methods. However, you can still implement virtual methods by mimicking the way C++ implements virtual methods. C++ stores an additional pointer to the function definition in each class for each virtual method. Thus, you can simply add a function pointer to a struct to simulate virtual methods.

For example

#include <stdio.h>
#include <stdlib.h>

int f2(int x)
{
    printf("%d\n",x);
}

typedef struct mystruct
{
    int (*f)(int);
} mystruct;


int main()
{
    mystruct *s=malloc(sizeof(mystruct));
    s->f=f2;
    s->f(42);
    free(s);
    return 0;
}

Answer 3

No you can't. 'virtual' is not part of the C vocabulary, neither is 'access level'

Answer 4

You can simulate virtual functions with function pointers. For instance,

struct foo
{
    void(*bar)(struct foo*, int, int);
};

void default_bar ( struct foo * f, int a, int b )
{
    printf("bar(%d,%d)\n", a, b);
}

void setup_foo ( struct foo * f )
{
    f->bar = &default_bar;
}

Then, you can "subclasss" the structure with something like:

struct meh
{
   /* inherit from "class foo". MUST be first. */
   struct foo base;
   int more_data;
};

/* override "method bar". */
struct custom_bar ( struct foo * f, int a, int b )
{
    struct meh * m = (struct meh*)f;
    printf("custom_bar(%d,%d)\n", a, b);
}

void setup_meh ( struct meh * m )
{
    setup_foo(&m->base);
    m->bar = &custom_bar;
}

All of this is labor-intensive and error prone, but it can be done. This type of "inheritance" and "override" implementation is common practice in some well-known C libraries, including jpeglib and libpng. They use this technique to allow you to override the I/O procedures if you're not satisfied with standard C I/O.

Edit: as noted in the comments, some of this code relies on (officially) non-standard behavior that "just happens" to work on most compilers. The main issue is that the code assumes that &m.base == &m (e.g. the offset of the base member is 0). If that is not the case, then the cast in custom_bar() results in undefined behavior. To work around this issue, you can add an extra pointer in struct foo as such:

struct foo
{
    /* same as before ...*/
    /* extra pointer. */
    void * hook;
};

Then, modify the stuff that touches the cast,

void setup_meh ( struct meh * m )
{
    m->base.hook = m;
   /* set up function pointers as usual... */
}

void custom_bar ( struct foo * f, int a, int b )
{
    struct meh * m = (struct meh*)f->hook;
    /* override. */
}

This technique is more reliable, especially if you plan to write the "derived struct" in C++ and use virtual functions. In that case, the offset of the first member is often non-0 as compilers store run-time type information and the class' v-table there.

Answer 5

You can not. C structs can not have behaviors. They can only have data.

Please see http://www.topcoder.com/tc?module=Static&d1=tutorials&d2=tenBestQuestions for differences between C structs and C++ structs. it is written in the second question.

C++ structures is as different as C++ classes are different from C structs. It's just an analogy.

Plus there's no such thing as inheritence in C. Without inheritence, what would you do with virtual functions?