opaque-pointers

When designing a C interface, it is common to let into the public interface ( .h ) only what needs to be known by the user program. Hence for example, the inner components of structures should remain hidden if the user program does not need to know them. This is indeed good practice, as the content and behavior of the struct could change in the future, without affecting the interface. A great way to achieve that objective is to use incomplete types. typedef struct foo opaqueType; Now an interface using only pointers to opaqueType can be built, without the user program ever needing to know the

There are a lot of questions out there about forward declarations and opaque types, but most seem to be from the perspective of the library author, or people trying to use incomplete types without pointers or some such. I'm using a library whose interface accepts/returns FOO * pointers. I'd like to confirm that I cannot (or should not) somehow forward-declare FOO or FOO * in my header file (which defines a struct with a FOO * member). I do know that I could just #include <library.h> in both my header and my .c file, but since this is really just a learning project, I wanted to get

Very often malloc() is absolutely not allowed when programming for embedded systems. Most of the time I'm pretty able to deal with this, but one thing irritates me: it keeps me from using so called 'opaque types' to enable data hiding. Normally I'd do something like this: // In file module.h typedef struct handle_t handle_t; handle_t *create_handle(); void operation_on_handle(handle_t *handle, int an_argument); void another_operation_on_handle(handle_t *handle, char etcetera); void close_handle(handle_t *handle); // In file module.c struct handle_t { int foo; void *something; int another

I've seen both of the following two styles of declaring opaque types in C APIs. Is there any clear advantage to using one style over the other? Option 1 // foo.h typedef struct foo * fooRef; void doStuff(fooRef f); // foo.c struct foo { int x; int y; }; Option 2 // foo.h typedef struct _foo foo; void doStuff(foo *f); // foo.c struct _foo { int x; int y; }; My vote is for the third option that mouviciel posted then deleted: I have seen a third way: // foo.h struct foo; void doStuff(struct foo *f); // foo.c struct foo { int x; int y; }; If you really can't stand typing the struct keyword,