La regla del primer miembro

Parte de la sección Programación Orientada a Objetos del Journey de C de Coddy. Lección 29 de 61.

Cuando integras una estructura como el primer miembro de otra estructura, sucede algo muy potente: la dirección de memoria de la estructura externa es idéntica a la dirección de memoria de su primer miembro. Esto está garantizado por el estándar de C.

Considera nuestro ejemplo anterior:

typedef struct {
    int id;
} Parent;

typedef struct {
    Parent parent;  // Primer miembro
    int grade;
} Child;

Cuando creas una variable Child, el miembro Parent se encuentra justo al principio de la memoria de Child. Esto significa que un puntero a Child apunta exactamente a la misma dirección que un puntero a su miembro Parent.

Child c;
Child* child_ptr = &c;
Parent* parent_ptr = (Parent*)child_ptr;  // ¡Cast seguro!

Ambos punteros contienen la misma dirección. Esto te permite pasar un Child* a cualquier función que espere un Parent*:

void print_id(Parent* p) {
    printf("ID: %d\n", p->id);
}

// En main:
Child c;
c.parent.id = 42;
print_id((Parent*)&c);  // Funciona perfectamente

Esta técnica es la base de la herencia en C. Una función escrita para el tipo base puede operar sobre cualquier tipo derivado, siempre que la base esté incorporada primero. La conversión es segura porque las disposiciones de memoria coinciden perfectamente.

Desafío

Fácil

Exploremos la regla del primer miembro construyendo una jerarquía sencilla de animales. Crearás una estructura base Animal y una estructura derivada Dog, y después demostrarás cómo un puntero a Dog se puede convertir de forma segura en un puntero a Animal.

La idea clave que aplicarás es la siguiente: cuando Animal es el primer miembro de Dog, ambas estructuras comparten la misma dirección de memoria inicial. Esto significa que puedes pasar un Dog* a cualquier función que espere un Animal* convirtiendo el puntero.

Organizarás tu código en tres archivos:

animal.h: Define ambas estructuras con protectores de inclusión. Tu estructura Animal debe tener un único campo: legs (un entero que representa el número de patas). Tu estructura Dog debe incluir Animal como su primer miembro y añadir un campo name (un arreglo de caracteres de 50 caracteres). Declara también una función print_animal que acepte un parámetro Animal*.
animal.c: Implementa la función print_animal. Esta función trabaja con el tipo base. Solo conoce Animal e imprime cuántas patas tiene el animal.
main.c: Crea una variable Dog y asigna valores a sus campos (tanto a las patas del animal incluido como al nombre del perro). Después, demuestra la regla del primer miembro convirtiendo tu Dog* en un Animal* y pasándolo a print_animal. Imprime también el nombre del perro por separado para mostrar el panorama completo.

Recibirás dos entradas: el nombre del perro (una cadena) y el número de patas (un entero).

Tu salida debería verse así:

Dog: Buddy
Legs: 4

Donde Buddy es el nombre del perro y 4 es el número de patas. Imprime primero el nombre del perro desde main.c, después llama a print_animal con el puntero convertido para mostrar las patas.

Esto demuestra cómo una función escrita para el tipo base (Animal) puede trabajar sin problemas con un tipo derivado (Dog) mediante la conversión de punteros: el fundamento de la herencia en C.

Pruébalo tú mismo

#include <stdio.h>
#include <string.h>
#include "animal.h"

int main() {
    // Leer la entrada
    char name[50];
    int legs;
    scanf("%s", name);
    scanf("%d", &legs);
    
    // TODO: Crea una variable Dog
    
    // TODO: Establece el nombre del perro usando strcpy
    
    // TODO: Establece el número de patas (acceso a través del Animal embebido)
    
    // TODO: Imprime el nombre del perro en formato: "Dog: <name>"
    
    // TODO: Convierte Dog* a Animal* y llama a print_animal
    // ¡Esto demuestra la regla del primer miembro!
    
    return 0;
}