Reducing the size of returned/passed data structures in C

Question

I am taking the operating system class in mit online, I completed the first assignement http://ocw.mit.edu/courses/electrical-engineering-and-computer-science/6-828-operating-system-engineering-fall-2012/assignments/MIT6_828F12_assignment1.pdf
but what surprised me is how they return the data structures, they work with a data structure and they return a smaller data structure, and to use it they just cast it back. I see that it can optimize the code but is this safe ? is it good practice ?

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

struct small
{
    int  n ;
};

struct big
{
    int n ;
    char * string ;
};

struct small* f()
{
    struct big* x = malloc(sizeof(struct big));
    x->n = 'X';
    x->string = strdup("Nasty!");
    return (struct small*) x ;
}

int main(int argc, char *argv[])
{
    struct big *y = (struct big*)f();
    printf("%s\n",y->string);
}

EDIT 1 : here is the link from mit, i just replicated the idea in my own code. http://ocw.mit.edu/courses/electrical-engineering-and-computer-science/6-828-operating-system-engineering-fall-2012/assignments/sh.c

Answer 1

1. No structure is returned, but a pointer to a structure. A pointer contains the address of the memory where the actual object is located. (In this case it has been allocated dynamically with malloc, hence has dynamic storage duration and will live until the pogram ends or a free is called on the pointer.)

2. The code is legal and has defined semantics. 6.3.2.3/7 of the n1570 draft says

   A pointer to an object type may be converted to a pointer to a different object type. If the resulting pointer is not correctly aligned for the referenced type, the behavior is undefined. [does not apply here. -ps] Otherwise, when converted back again, the result shall compare equal to the original pointer.

Note that the structures could be completely unrelated (the first data element does not need to be the same type). The cast could even be to a built-in type like int.

The issue may be different if the object were accessed through a pointer of the wrong type (which it isn't) because of aliasing issues.

Answer 2

Yes it is safe, as long your compiler follows the C standard

Why doesn't GCC optimize structs?

But no, I do not consider this a good practice.

Good practices are relative, and should never be use as a rule. This construction is required if you want to simulate OO inheritance behavior with C.

Answer 3

To answer your questions:

Is it safe?

Obviously not. Just casting the type of a pointer to something else is something you should only do if you are positively sure it's the right type.

However, if you know that, everything is fine.

Is it good practice?

No, not in this shape.

You sometimes do Object Oriented Programming in C in a similar way (compare CPython's PyObject): You use one "base" object, and one "type" struct which have a structure like:

struct obj_type {
  const char* name;
  size_t length; // this is important so that you can copy the object later on without knowing its insides
};

struct obj_base {
  obj_type* type;
};

Because it is guaranteed that in C, pointers to structs point to the address of their first element, you can use further objects that build atop of that:

struct more_complex_object {
  obj_type* type; 
  int value;
};

...
int main() {
  obj_type *more_complex_object_type = malloc(sizeof(obj_type));
  more_complex_object_type->name = "A more complex object type";
  more_complex_object_type->length = sizeof(more_complex_object);
  more_complex_object *obj = malloc(more_complex_object_type->length);
  obj->type = more_complex_object_type;
  obj->value = 10;
  ...
  //let's now use it as a simple instance of the "super" object
  obj_base* just_an_object = (obj_base*)more_complex_object;
  //when we copy things, we make sure to copy the full length:
  obj_base* target = malloc(sizeof(more_complex_object));
  memcpy(target, just_an_object, just_an_object->type->length);

  //now, when handling an object, we can check its type
  if(just_an_object->type == more_complex_object_type) {
    more_complex_object *my_obj = (more_complex_object)just_an_object;
    printf("value: %d\n", my_obj->value);
  }
}