从函数返回指向结构的指针

Question

I use some library which declares some opaque types. I wrapped this type into my own structure to abstract over this library opaque type and got some problem. Here is code:

typedef struct my_struct my_struct;
struct my_struct{
    opaque_lib_t *const opaque_lib_ptr; //opaque_lib_t is the opaque type
                                        //came from the library
};

my_struct* initialize(){
    opaque_lib_t *opaque_lib_ptr;
    init(&opaque_lib_ptr);              //library function call
    return opaque_lib_ptr;
}

void use_and_release(my_struct *my_struct_ptr){
     //use and release my_struct
}

my_struct *my_struct_ptr =  initialize();
use_and_release(my_struct_ptr);         //crashes

In such an implementation the call to use_and_release crashes. So I tried to replace my_struct* initialize with the following implementation

my_struct* initialize(){
     opaque_lib_t *opaque_lib_ptr;
     init(&opaque_lib_ptr);
     my_struct *my_struct_ptr = malloc(sizeof(*my_struct_ptr));
     my_struct tmp = {.opaque_lib_ptr = opaque_lib_ptr};
     memcpy(my_struct_ptr, &tmp, sizeof(tmp));
     return my_struct_ptr;
}

With such an implementation it works fine. But I don't understand why the first did not work. I thought that the pointer to a structure and the pointer to its first element has the same value. So in this case it should be fine to just return opaque_lib_t* and cast it to my_struct* since my_struct* contains only one element.

Answer 1

Why you try to do with your first example is kind of attempting to emulating inheritance from object-oriented languages. It seems like you want my_struct to have an "is a" relationship with opaque_lib_t .

However that won't work because then you need the first member of my_struct to be an actual instance of the opaque_lib_t structure, ie it should be

struct my_struct{
    opaque_lib_t opaque_lib_instance;   //opaque_lib_t is the opaque type
                                        //came from the library
};

If opaque_lib_t really is an anonymous and opaque structure similar to FILE then that's not possible.

Another way of looking at is like this:

In memory my_struct will look something like

my_struct             opaque_lib_t
+----------------+    +-------------------+
| opaque_lib_ptr | -> | Unknown data      |
+----------------+    | More unknown data |
                      | ...               |
                      +-------------------+

You simply can't overlay opaque_lib_t on top of my_struct .

And when you do return opaque_lib_ptr; you effectively are saying that "this pointer is pointing to a my_struct whose first member is a pointer to opaque_lib_t ". And that is simply wrong because those are two very different structure.

Continuing with the first piece of code, if you try to use my_struct_ptr->opaque_lib_ptr then the memory you access is the initial data of the opaque_lib_t structure (whose pointer you returned).

---

Lastly about what you say

In my code I want to abstract over the specific library structures

I can understand that, but that's already the purpose of opaque_lib_t . You add an (unnecessary) abstraction on top of an abstraction.

I could understand your structure if it collected multiple related data, but not only the opaque_lib_t pointer.