GTK interface structure: Why is it built as casting interface? - c

Question

GTK3 provides functions, that make casting necessary. As in
gtk_grid_attach(GTK_GRID(grid), button, 0,0,0,0)
However, this method will always take a grid. So why wouldn't the cast be inside the function? The call would become:
gtk_grid_attach(grid, button, 0,0,0,0)
And would therefore be much shorter and easier readable (because no redundancy).
edit:
Due to the discussion in the comments, I'll try to make my question more clear using the example from David Ranieri below
Given the code:
typedef struct {char *sound;} animal_t;
typedef struct {animal_t animal; char *name;} dog_t;
typedef struct {animal_t animal;} cat_t;
#define DOG(animal) (dog_t *)animal
#define CAT(animal) (cat_t *)animal
There are two ways to implement the function dog_print_name without loosing the typecheck-mechanism. In the example below I will hand over a cat, where a dog is expected.
(1)
void dog_print_name(dog_t *dog)
{
puts(dog->name);
}
int main(){
// ...
dog_print_name(DOG(cat)); // perfom type check here
// and fail on 'cat'
}
(2)
void dog_print_name(void *dog)
{
dog_t *dog_ = DOG(dog); // check performed
// will fail, if 'dog' is a cat.
puts(dog->name);
}
int main(){
// ...
dog_print_name(cat); // no check performed here
}
These two pieces of code being given, what is the reason one would choose implementation (1) over implementation (2)?
The goal is to get a warning / error on a call where dog is expected, but cat is given.

Answer 1

It's needed because C doesn't handle polymorphism. It can't check if that argument's type is valid based on the class hierarchy. So the macro triggers a check for that, and also make sure that even if you stored your pointer in the right pointer type, the content it points to (a GObject-derived object) uses the right type.
Here, grid has the right type, but not the right content. Making an explicit check makes debugging much easier.
GtkGrid *grid = gtk_image_new();
GtkButton *button = gtk_button_new();
gtk_grid_attach(grid, button, 0,0,0,0); // Won't catch early the fact that grid is a GtkImage, not a GtkGrid.
Also, most of the times, you just declare everything as a pointer to a GtkWidget. This is because depending on which methods you call, the class they come from may be different, so you'll need to cast anyway.
GtkWidget *grid = gtk_grid_new();
GtkWidget *button = gtk_button_new();
gtk_grid_attach(GTK_GRID(grid), button, 0,0,0,0); // WILL check at runtime that grid is a GtkGrid.
gtk_grid_remove_row(GTK_GRID(grid), 0);
gtk_container_add(GTK_CONTAINER(grid), button);

Answer 2

Just to expand a bit the nice answer of #liberfforce:
The only type allowed to receive a pointer to a different type without a cast is void *, so you need the cast because some functions (like grid_attach) are expecting to receive the derived object (GtkGrid), not the base (GtkWidget)
A little example that illustrates how inheritance works in gtk:
typedef struct {char *sound;} animal_t;
typedef struct {animal_t animal; char *name;} dog_t;
typedef struct {animal_t animal; int age;} cat_t;
#define DOG(animal) (dog_t *)animal
#define CAT(animal) (cat_t *)animal
static animal_t *new_dog(char *name)
{
dog_t *dog = malloc(sizeof *dog);
dog->animal.sound = "worf";
dog->name = name;
return &dog->animal;
}
static animal_t *new_cat(int age)
{
cat_t *cat = malloc(sizeof *cat);
cat->animal.sound = "meow";
cat->age = age;
return &cat->animal;
}
void animal_print_sound(animal_t *animal)
{
puts(animal->sound);
}
void dog_print_name(dog_t *dog)
{
puts(dog->name);
}
void cat_print_age(cat_t *cat)
{
printf("%d\n", cat->age);
}
int main(void)
{
animal_t *dog = new_dog("Bobbie");
animal_t *cat = new_cat(5);
animal_print_sound(dog);
animal_print_sound(cat);
dog_print_name(DOG(dog));
cat_print_age(CAT(cat));
return 0;
}
So why wouldn't you implement:
void dog_print_name(animal_t *dog) { puts(DOG(dog)->name); }
void cat_print_age(animal_t *cat) { printf("%d\n", CAT(cat)->age); }
?
From a "users"-perspective dog_print_name(dog); looks more
understandable to me.
Because in this way the compiler can not protect you checking the type, think what will happen if you pass dog_print_name(cat); using your approach.