Punteros Opacos y Encapsulamiento en C

Prerrequisitos: structs, punteros, archivos .h/.c, TAD y compilación modular. Antes de seguir, distinguí una declaración incompleta de la definición de una estructura.

Objetivo: publicar una interfaz que oculte la representación y conserve la responsabilidad de creación y destrucción dentro del módulo.

Comprobación de salida: separá qué declaraciones pertenecen al .h público y cuáles deben quedar en el .c privado.

Desarrollo¶

Concepto y Mecanismo de Punteros Opacos¶

Los punteros opacos (opaque pointers) son una técnica fundamental en C para implementar encapsulamiento y ocultamiento de información (information hiding). Esta técnica permite ocultar la implementación interna de una estructura, exponiendo solo una interfaz pública al usuario, de manera análoga al encapsulamiento de miembros privados de una clase en lenguajes orientados a objetos.

El concepto de puntero opaco es esencial para construir APIs robustas y bibliotecas mantenibles, donde los detalles de implementación pueden cambiar sin romper el código cliente que las utiliza.

Motivación: El Problema del Acceso Directo¶

Considerá una implementación ingenua de un punto geométrico en dos dimensiones donde la estructura está completamente expuesta:

1
2
3
4
5
6
7
8
9
// punto_malo.h - NO USAR: Implementación expuesta
typedef struct
{
    double x;
    double y;
} punto_t;
// Funciones públicas
punto_t *crear_punto(double x, double y);
void desplazar_punto(punto_t *p, double dx, double dy);

Problemas de Esta Aproximación¶

1. Violación del encapsulamiento:

punto_t *p = crear_punto(3.0, 4.0);
// El usuario puede acceder y modificar directamente los campos internos
p->x = -9999.0; // Modificación directa sin control

2. Imposibilidad de cambiar la implementación: Si decidís cambiar la representación interna de coordenadas cartesianas ($x, y$) a coordenadas polares ($radio, angulo$) para optimizar operaciones de rotación, todo el código cliente se rompe porque depende de los campos x e y específicos de la estructura.

3. Falta de control sobre invariantes: No podés validar ni interceptar los cambios en los datos. Si la estructura requiriera que el punto se mantenga dentro de ciertos límites (por ejemplo, un plano acotado de una pantalla), no hay forma de evitar que el usuario asigne coordenadas fuera de rango directamente.

La Solución: Punteros Opacos¶

La técnica de punteros opacos consiste en declarar la estructura en el archivo de cabecera pero definirla en el archivo de implementación.

Estructura del Patrón¶

Archivo de Cabecera (.h) - Interfaz Pública

1
2
3
4
5
6
7
8
9
10
11
12
// punto.h - Interfaz pública
#ifndef PUNTO_H
#define PUNTO_H
// Declaración OPACA: el usuario solo ve que existe una estructura
typedef struct punto punto_t;
// Funciones públicas - la interfaz
punto_t *crear_punto(double x, double y);
void destruir_punto(punto_t **punto);
double punto_obtener_x(const punto_t *punto);
double punto_obtener_y(const punto_t *punto);
void punto_desplazar(punto_t *punto, double dx, double dy);
#endif // PUNTO_H

Archivo de Implementación (.c) - Detalles Privados

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
// punto.c - Implementación privada
#include "punto.h"
#include <stdlib.h>
// Definición COMPLETA de la estructura - solo visible aquí
struct punto
{
    double x;
    double y;
};
punto_t *crear_punto(double x, double y)
{
    punto_t *p = malloc(sizeof(*p));
    if (p == NULL)
    {
        return NULL;
    }
    p->x = x;
    p->y = y;
    return p;
}
void destruir_punto(punto_t **punto)
{
    if (punto != NULL && *punto != NULL)
    {
        free(*punto);
        *punto = NULL;
    }
}
double punto_obtener_x(const punto_t *punto)
{
    if (punto == NULL)
    {
        return 0.0;
    }
    return punto->x;
}
double punto_obtener_y(const punto_t *punto)
{
    if (punto == NULL)
    {
        return 0.0;
    }
    return punto->y;
}
void punto_desplazar(punto_t *punto, double dx, double dy)
{
    if (punto == NULL)
    {
        return;
    }
    punto->x += dx;
    punto->y += dy;
}

Código Cliente

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
// main.c - Usuario de la interfaz
#include "punto.h"
#include <stdio.h>
int main(void)
{
    punto_t *p = crear_punto(3.0, 4.0);
    if (p == NULL)
    {
        fprintf(stderr, "Error al crear el punto\n");
        return 1;
    }
    // El usuario SOLO puede usar la interfaz pública
    punto_desplazar(p, 1.5, -2.0);
    printf("Punto: (%.1f, %.1f)\n", punto_obtener_x(p), punto_obtener_y(p));
    // Esto NO COMPILA: el usuario no puede acceder a los campos internos
    // p->x = 10.0;  // ERROR: incomplete type 'struct punto'
    destruir_punto(&p);
    return 0;
}

Patrón de Destrucción Seguro: Puntero Simple vs. Doble Puntero¶

En el diseño de destructores para tipos opacos y TADs en C, existen dos aproximaciones clásicas:

1. Destructor Simple (Puntero Simple):

   void destruir_punto(punto_t *p)
   {
       if (p == NULL)
           return;
       free(p);
   }

   Funcionamiento: Se libera la memoria en el Heap, pero la variable puntero en el ámbito del cliente (el llamador) continúa almacenando la dirección de memoria liberada. Esto genera un puntero colgante (dangling pointer). Es responsabilidad exclusiva del programador cliente asignar de forma manual p = NULL; inmediatamente después de la llamada. Si el cliente olvida este paso, cualquier desreferencia posterior resultará en comportamiento indefinido o fallas de seguridad de tipo Use-After-Free (UAF).

2. Destructor Seguro (Doble Puntero - Recomendado y Unificado):

   void destruir_punto(punto_t **p)
   {
       if (p == NULL || *p == NULL)
           return;
       free(*p);
       *p = NULL; // Aniquilación automática del puntero del cliente
   }

   Funcionamiento: Al pasar la dirección del puntero del cliente (&p), el destructor no solo libera la memoria en el Heap, sino que también pone a NULL la variable del cliente en su propio ámbito. Esto mitiga por completo el riesgo de punteros colgantes de forma automática y transparente.

Por cuestiones de consistencia, robustez y seguridad de memoria, la cátedra exige unificar todos los destructores de tipos opacos y TADs bajo la firma de doble puntero (**self) y anular la referencia en el cliente.

Análisis Técnico: ¿Cómo Funciona?¶

Tipo Incompleto (Incomplete Type)

Cuando declarás:

1
typedef struct punto punto_t;

Sin dar la definición completa, creás un tipo incompleto (incomplete type). El compilador sabe que existe una estructura llamada punto, pero no conoce su contenido ni tamaño.

Restricciones del Tipo Incompleto

Con un tipo incompleto, el código cliente solo puede:

1. Declarar punteros al tipo:

   punto_t *p; // ✅ Permitido

2. Pasar punteros a funciones:

   punto_desplazar(p, 1.0, 2.0); // ✅ Permitido

3. Usar punteros en expresiones que no requieran el tamaño:

   if (p == NULL)
   {
       ...
   } // ✅ Permitido

Operaciones Prohibidas

El código cliente NO puede:

1. Declarar instancias por valor:

   punto_t p; // ❌ ERROR: incomplete type

2. Acceder a miembros:

   p->x = 5.0; // ❌ ERROR: incomplete type

3. Usar sizeof:

   sizeof(punto_t); // ❌ ERROR: incomplete type

4. Desreferenciar:

   punto_t copia = *p; // ❌ ERROR: incomplete type

Compilación Separada y el Rol del Enlazador

Para entender por qué es posible trabajar con tipos incompletos en C, debemos analizar el proceso de compilación separada:

1. La Fase de Compilación: Cada archivo fuente .c (ej. main.c y punto.c) se compila de manera independiente para producir un archivo objeto (ej. main.o y punto.o).

   • Cuando el compilador procesa main.c, solo lee la cabecera punto.h. Al encontrar la declaración de tipo opaco typedef struct punto punto_t;, registra punto_t como un tipo incompleto.

   • El compilador no necesita saber cuántos campos tiene struct punto ni su tamaño total en memoria para compilar main.c. Solo necesita saber el tamaño de las variables declaradas en main.c. Dado que en main.c solo se declaran punteros a punto_t (como punto_t *p), y el tamaño de cualquier puntero a estructura en C es constante (típicamente 8 bytes en sistemas de 64 bits, sin importar a qué estructura apunte), el compilador puede reservar el espacio adecuado y generar el archivo objeto main.o con éxito.

2. La Fase de Enlazado (Linking): El enlazador toma los archivos objeto main.o y punto.o y los une en el ejecutable final.

   • Es en punto.o donde reside la definición concreta de struct punto y el cuerpo de las funciones (como crear_punto y punto_desplazar).

   • El enlazador se encarga de resolver las direcciones de las llamadas a funciones en main.o, redirigiéndolas a las implementaciones reales presentes en punto.o.

   • Así, el ocultamiento es físico: en tiempo de compilación, el cliente no posee la estructura detallada; en tiempo de ejecución, el enlazador conecta las llamadas y las funciones operan sobre el espacio de memoria real asignado dinámicamente en el heap.

Ejercicios: Concepto y Mecanismo¶

Patrones de Diseño, Ventajas y Limitaciones¶

Ventajas de los Punteros Opacos¶

1. Encapsulamiento Fuerte

La implementación está completamente oculta. El código cliente no puede (ni accidentalmente) acceder o modificar los campos internos.

1
2
3
// Esto NO compila - el compilador protege los detalles internos
punto_t *p = crear_punto(3.0, 4.0);
p->x = 100.0; // ERROR en tiempo de compilación

2. Flexibilidad de Implementación

Podés cambiar completamente la implementación interna sin afectar al código cliente:

1
2
3
4
5
6
// punto.c - Versión con coordenadas polares (cambio de implementación)
struct punto
{
    double radio;
    double angulo; // en radianes
};

Si cambiás la implementación a coordenadas polares, las funciones públicas en punto.c realizarán la conversión matemática necesaria para retornar la proyección de x e y cuando el cliente llame a punto_obtener_x o punto_obtener_y. El código cliente que usa punto.h no necesita modificarse porque la interfaz pública sigue intacta.

3. Mantenimiento de Invariantes

Solo las funciones del módulo pueden modificar la estructura, garantizando que los invariantes se cumplan siempre. Por ejemplo, si tenés un tipo usuario_t que representa a un usuario del sistema:

1
2
3
4
5
6
7
8
9
10
bool usuario_establecer_edad(usuario_t *u, int nueva_edad)
{
    // Garantiza que la edad no sea negativa
    if (u == NULL || nueva_edad < 0)
    {
        return false;
    }
    u->edad = nueva_edad;
    return true;
}

El código cliente no puede burlar esta validación modificando el campo directamente.

4. Compatibilidad Binaria (ABI)

Si la interfaz pública no cambia, podés actualizar la biblioteca compilada (.so o .dll) sin recompilar las aplicaciones que la usan. Esto es crucial para bibliotecas del sistema.

5. Reducción de Dependencias

Los archivos que incluyen punto.h no necesitan incluir las dependencias internas de punto.c (por ejemplo, <math.h> si se usaran funciones trigonométricas), reduciendo tiempos de compilación y acoplamiento.

Patrones de Uso Comunes¶

Patrón Constructor/Destructor

Toda estructura opaca alocada dinámicamente debe proveer funciones para crear y destruir instancias:

// Convención de nombres: tipo_accion
tipo_t *crear_tipo(parametros);
void destruir_tipo(tipo_t **instancia);

Ejemplo:

1
2
3
usuario_t *usr = crear_usuario("Carlos", 35);
// ... usar usr ...
destruir_usuario(&usr);

Destrucción de Colecciones de Punteros Opacos

Cuando gestionás una colección (como un array dinámico o una lista enlazada) de punteros opacos, no podés liberar la colección llamando simplemente a free sobre ella. Hacerlo generará una fuga de memoria masiva, ya que los elementos individuales apuntados seguirán existiendo en el heap sin ninguna referencia para liberarlos.

Debés implementar un lazo de destrucción que recorra la colección elemento por elemento, invocando el destructor específico de cada tipo opaco, y recién entonces liberar la estructura contenedora.

Ejemplo práctico de destrucción de un array de usuarios:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
#define CANT_USUARIOS 5
void liberar_grupo_usuarios(usuario_t **grupo, size_t cantidad)
{
    if (grupo == NULL)
    {
        return;
    }
    // Recorremos la colección destruyendo cada elemento individual con un lazo
    for (size_t i = 0; i < cantidad; i++)
    {
        destruir_usuario(&grupo[i]);
    }
    // Finalmente, liberamos el array contenedor en sí
    free(grupo);
}

Patrón Getter/Setter

Para acceder a propiedades sin exponer los campos de la estructura:

1
2
3
4
5
// Getter - solo lectura
const char *usuario_obtener_nombre(const usuario_t *u);
int usuario_obtener_edad(const usuario_t *u);
// Setter - modificación controlada
bool usuario_establecer_edad(usuario_t *u, int nueva_edad);

Patrón de Verificación

Siempre verificá punteros nulos y condiciones de error de manera defensiva:

1
2
3
4
5
6
7
8
9
10
bool usuario_establecer_edad(usuario_t *u, int nueva_edad)
{
    // Verificaciones defensivas
    if (u == NULL || nueva_edad < 0)
    {
        return false;
    }
    u->edad = nueva_edad;
    return true;
}

Comparación con Otras Técnicas¶

vs. Estructuras Expuestas

vs. Void Pointers

1
2
3
4
5
// Opción 1: Puntero opaco (RECOMENDADO)
typedef struct punto punto_t;
double punto_obtener_x(const punto_t *p);
// Opción 2: Void pointer (EVITAR)
double punto_obtener_x(const void *p);

Problemas de void pointers:

• Pérdida de type safety (se puede pasar accidentalmente cualquier puntero sin advertencia del compilador).

• No hay verificación de tipos en tiempo de compilación.

• Requiere casts explícitos en la implementación.

• Es más propenso a errores de desarrollo.

Ejemplo Completo: Usuario Opaco¶

Este ejemplo implementa un módulo para gestionar un usuario, donde los campos internos (un string dinámico y un entero) se mantienen estrictamente encapsulados.

Interfaz Pública (usuario.h)

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
#ifndef USUARIO_H
#define USUARIO_H
#include <stdbool.h>
// Tipo opaco
typedef struct usuario usuario_t;
// Constructor/Destructor
usuario_t *crear_usuario(const char *nombre, int edad);
void destruir_usuario(usuario_t **u);
// Getters y Setters con validación
const char *usuario_obtener_nombre(const usuario_t *u);
int usuario_obtener_edad(const usuario_t *u);
bool usuario_establecer_edad(usuario_t *u, int nueva_edad);
// Operaciones
void usuario_imprimir(const usuario_t *u);
#endif // USUARIO_H

Implementación (usuario.c)

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
#include "usuario.h"
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
// Definición completa del usuario - solo visible aquí
struct usuario
{
    char *nombre;
    int edad;
};
usuario_t *crear_usuario(const char *nombre, int edad)
{
    if (nombre == NULL || edad < 0)
    {
        return NULL;
    }
    // Alocación robusta desreferenciando el puntero (regla {ref}`0x7001h`)
    usuario_t *u = malloc(sizeof(*u));
    if (u == NULL)
    {
        return NULL;
    }
    u->nombre = malloc(strlen(nombre) + 1);
    if (u->nombre == NULL)
    {
        free(u);
        return NULL;
    }
    memcpy(u->nombre, nombre, strlen(nombre) + 1);
    u->edad = edad;
    return u;
}
void destruir_usuario(usuario_t **u)
{
    if (u == NULL || *u == NULL)
    {
        return;
    }
    // Primero liberamos los recursos internos
    free((*u)->nombre);
    // Luego liberamos la estructura contenedora
    free(*u);
    *u = NULL;
}
const char *usuario_obtener_nombre(const usuario_t *u)
{
    if (u == NULL)
    {
        return NULL;
    }
    return u->nombre;
}
int usuario_obtener_edad(const usuario_t *u)
{
    if (u == NULL)
    {
        return -1;
    }
    return u->edad;
}
bool usuario_establecer_edad(usuario_t *u, int nueva_edad)
{
    if (u == NULL || nueva_edad < 0)
    {
        return false;
    }
    u->edad = nueva_edad;
    return true;
}
void usuario_imprimir(const usuario_t *u)
{
    if (u == NULL)
    {
        return;
    }
    printf("Usuario: %s | Edad: %d\n", u->nombre, u->edad);
}

Uso del Cliente

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
#include "usuario.h"
#include <stdio.h>
int main(void)
{
    usuario_t *u = crear_usuario("Martín", 21);
    if (u == NULL)
    {
        return 1;
    }
    usuario_imprimir(u);
    // Intento de modificación válida
    if (usuario_establecer_edad(u, 22))
    {
        printf("Edad actualizada con éxito.\n");
    }
    // Intento de asignación inválida
    if (!usuario_establecer_edad(u, -5))
    {
        printf("Error: no se admiten edades negativas.\n");
    }
    usuario_imprimir(u);
    destruir_usuario(&u);
    return 0;
}

Punteros Opacos en Bibliotecas Estándar¶

Muchas bibliotecas conocidas usan punteros opacos:

POSIX: FILE

1
2
3
4
// stdio.h
typedef struct _IO_FILE FILE;
FILE *fopen(const char *filename, const char *mode);
int fclose(FILE *stream);

No sabés cómo está implementado FILE internamente, pero podés usarlo a través de punteros.

OpenSSL

1
2
3
4
typedef struct ssl_ctx_st SSL_CTX;
typedef struct ssl_st SSL;
SSL_CTX *SSL_CTX_new(const SSL_METHOD *method);
SSL *SSL_new(SSL_CTX *ctx);

GTK+ (GUI)

1
2
3
typedef struct _GtkWidget GtkWidget;
typedef struct _GtkWindow GtkWindow;
GtkWidget *gtk_window_new(GtkWindowType type);

Todos estos ejemplos siguen el mismo patrón de puntero opaco.

Buenas Prácticas¶

1. Convenciones de Nombres

1
2
3
4
// Patrón: tipo_t para el tipo, crear_tipo/destruir_tipo para funciones
typedef struct usuario usuario_t;
usuario_t *crear_usuario(const char *nombre, int edad);
void destruir_usuario(usuario_t **u);

2. Documentación Clara

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
/**
 * Crea una nueva instancia de un usuario.
 *
 * @param nombre Cadena de caracteres que representa el nombre (no debe ser
   NULL).
 * @param edad Entero no negativo que representa la edad.
 * @return Puntero al usuario creado, o NULL si falla la asignación de memoria
 o los parámetros son inválidos.
 */
usuario_t *crear_usuario(const char *nombre, int edad);
/**
 * Destruye al usuario liberando toda la memoria asociada.
 *
 * @param u Usuario a destruir. Puede ser NULL.
 */
void destruir_usuario(usuario_t **u);

3. Manejo de Errores Consistente

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
// Retornar NULL en creación si falla
tipo_t *crear_tipo(void)
{
    tipo_t *t = malloc(sizeof(*t));
    if (t == NULL)
    {
        return NULL; // Indicación clara de fallo al cliente
    }
    // ... inicialización ...
    return t;
}
// Retornar bool en operaciones para reportar éxito o fracaso
bool tipo_operar(tipo_t *t, int dato)
{
    if (t == NULL)
    {
        return false; // Fallo: puntero inválido
    }
    // ... operación ...
    return true; // Éxito
}

4. Tolerancia a NULL

1
2
3
4
5
6
7
8
9
10
11
void destruir_tipo(tipo_t **t)
{
    // Tolerante a NULL - comportamiento similar a free()
    if (t == NULL || *t == NULL)
    {
        return;
    }
    // ... liberación ...
    free(*t);
    *t = NULL;
}

5. Uso de const para Intenciones

1
2
3
4
// Solo lectura - no modifica la estructura
double punto_obtener_x(const punto_t *punto);
// Modifica la estructura
void punto_desplazar(punto_t *punto, double dx, double dy);

Limitaciones y Consideraciones¶

1. Pérdida de Acceso Directo

No podés acceder directamente a los campos para debugging o inspección rápida en herramientas tradicionales:

1
2
// En GDB:
(gdb) print punto->x Cannot access memory at address 0x0 : incomplete type

Solución: Proveer funciones de inspección para debugging si es necesario:

1
2
3
#ifdef DEBUG
void punto_debug_print(const punto_t *p);
#endif

2. No se Puede Alocar en el Stack

1
2
3
4
// Esto NO compila con puntero opaco
punto_t p; // ERROR: incomplete type
// Debés usar el heap
punto_t *p = crear_punto(3.0, 4.0);

Implicación: Siempre hay un costo asociado a la alocación dinámica de memoria mediante malloc y free.

3. Dificultad para Copiar

No podés realizar una copia superficial por asignación directa:

1
punto_t copia = *original; // ERROR: incomplete type

Solución: Proveer una función de copia explícita (clonación):

1
punto_t *punto_clonar(const punto_t *original);

4. Compatibilidad con Análisis Estático

Algunas herramientas de análisis estático tienen dificultades para verificar el uso de memoria en tipos incompletos fuera de su archivo de implementación. Asegurate de que Valgrind y las opciones de compilación sanitizer rastreen correctamente todo el ciclo de vida de estas estructuras.

Ejercicios: Patrones y Buenas Prácticas¶

Contratos en Módulos C¶

El diseño de punteros opacos impone una separación estricta entre interfaz e implementación. Para formalizar esa separación, el Diseño por Contratos proporciona el marco conceptual: cada función de la interfaz tiene precondiciones (qué exige del cliente) y poscondiciones (qué garantiza al cliente).

Introducción al Diseño por Contratos¶

El Diseño por Contratos (Design by Contract, DbC) es una metodología formal de desarrollo de software introducida por Bertrand Meyer en el lenguaje Eiffel. Se fundamenta en la metáfora de un contrato legal entre partes: cada componente de software tiene obligaciones (precondiciones que debe garantizar el cliente) y beneficios (postcondiciones que garantiza el proveedor). Este enfoque transforma el desarrollo de software de una actividad artesanal a una disciplina ingenieril rigurosa.

La formalización mediante Lógica de Primer Orden (LPO) proporciona el rigor matemático necesario para especificar, verificar y razonar sobre la corrección de programas.

Ejercicios de Autoevaluación¶

#ifndef VECTOR3D_H
#define VECTOR3D_H
// Declaración opaca del tipo incompleto
typedef struct vector3d vector3d_t;
// Constructor y destructor
vector3d_t *vector_crear(double x, double y, double z);
void vector_destruir(vector3d_t **v);
// Operaciones que manipulan el tipo a través de punteros
vector3d_t *vector_sumar(const vector3d_t *v1, const vector3d_t *v2);
double vector_obtener_x(const vector3d_t *v);
double vector_obtener_y(const vector3d_t *v);
double vector_obtener_z(const vector3d_t *v);
#endif // VECTOR3D_H

int main(void)
{
    // El constructor interno en punto.c se encarga de malloc y de conocer el
    sizeof punto_t *p = crear_punto(3.0, 4.0);
    if (p == NULL)
    {
        return 1;
    }
    // ...
    destruir_punto(&p);
    return 0;
}

// API mal diseñada usando void*
void destruir_usuario(void *u);
// Código cliente erróneo
cuenta_t *mi_cuenta = crear_cuenta(12345, "Juan", 1000.0);
// Error conceptual: pasamos un tipo cuenta_t* a un destructor de usuario_t*
destruir_usuario(
    mi_cuenta); // El compilador no advierte el error y compila sin
quejas.

#ifndef CUENTA_H
#define CUENTA_H
#include <stdbool.h>
typedef struct cuenta cuenta_t;
cuenta_t *crear_cuenta(long nro, const char *titular, double saldo_inicial);
void destruir_cuenta(cuenta_t **c);
bool cuenta_depositar(cuenta_t *c, double monto);
bool cuenta_extraer(cuenta_t *c, double monto);
double cuenta_obtener_saldo(const cuenta_t *c);
#endif // CUENTA_H

#include "cuenta.h"
#include <stdlib.h>
#include <string.h>
struct cuenta
{
    long nro_cuenta;
    char *titular;
    double saldo;
};
cuenta_t *crear_cuenta(long nro, const char *titular, double saldo_inicial)
{
    if (titular == NULL || saldo_inicial < 0.0)
    {
        return NULL;
    }
    cuenta_t *c = malloc(sizeof(*c));
    if (c == NULL)
    {
        return NULL;
    }
    c->nro_cuenta = nro;
    c->titular = malloc(strlen(titular) + 1);
    if (c->titular == NULL)
    {
        free(c);
        return NULL;
    }
    strcpy(c->titular, titular);
    c->saldo = saldo_inicial;
    return c;
}
void destruir_cuenta(cuenta_t **c)
{
    if (c == NULL || *c == NULL)
    {
        return;
    }
    free((*c)->titular);
    free(*c);
    *c = NULL;
}
bool cuenta_depositar(cuenta_t *c, double monto)
{
    if (c == NULL || monto <= 0.0)
    {
        return false;
    }
    c->saldo += monto;
    return true;
}
bool cuenta_extraer(cuenta_t *c, double monto)
{
    if (c == NULL || monto <= 0.0 || c->saldo < monto)
    {
        return false;
    }
    c->saldo -= monto;
    return true;
}
double cuenta_obtener_saldo(const cuenta_t *c)
{
    if (c == NULL)
    {
        return 0.0;
    }
    return c->saldo;
}

#include "cuenta.h"
#include <stdlib.h>
void cartera_destruir(cuenta_t **cartera, size_t cantidad)
{
    if (cartera == NULL)
    {
        return;
    }
    // Liberamos cada cuenta individual recorriendo el arreglo con un lazo
    for (size_t i = 0; i < cantidad; i++)
    {
        destruir_cuenta(&cartera[i]);
        cartera[i] = NULL; // Evitamos punteros colgantes en el arreglo
    }
    // Liberamos el arreglo contenedor
    free(cartera);
}

// Firma del getter alternativo
char *cuenta_clonar_titular(const cuenta_t *c)
{
    if (c == NULL || c->titular == NULL)
    {
        return NULL;
    }
    char *copia = malloc(strlen(c->titular) + 1);
    if (copia != NULL)
    {
        strcpy(copia, c->titular);
    }
    return copia; // El cliente debe liberar esta memoria con free()
}

#include <assert.h>
int usuario_obtener_edad(const usuario_t *u)
{
    // Si u es NULL, el cliente violó la precondición del contrato.
    // Detenemos el programa de inmediato para alertar al desarrollador.
    assert(u != NULL);
    return u->edad;
}

int usuario_obtener_edad(const usuario_t *u)
{
    if (u == NULL)
    {
        return -1; // Valor centinela que indica error sin abortar la ejecución
    }
    return u->edad;
}

#include <stdbool.h>
static bool cuenta_validar_invariante(const cuenta_t *c)
{
    if (c == NULL)
    {
        return false;
    }
    if (c->titular == NULL)
    {
        return false;
    }
    if (c->saldo < 0.0)
    {
        return false;
    }
    return true;
}

Glosario¶

Síntesis y Resumen¶

Resumen¶

Los punteros opacos son una técnica esencial para construir software modular y mantenible en C:

Dominar los punteros opacos es esencial para escribir código C profesional, mantenible y robusto. Es la base del diseño modular en C y el equivalente más cercano al encapsulamiento de la programación orientada a objetos.

Referencias y Lecturas de Tipos Opacos¶

Referencias y Lecturas de Tipos Opacos¶

Textos Fundamentales¶

• Hanson (1996). C Interfaces and Implementations. Capítulo 1: Interfaces. Tratamiento exhaustivo de punteros opacos y diseño de interfaces.

• Kernighan & Ritchie (2014). The C Programming Language. Capítulo 6: Structures. Sección sobre tipos incompletos.

• King (2008). C Programming: A Modern Approach. Capítulo 19: Program Design. Information hiding y modularidad.

Documentación de Estándares¶

• ISO C99 Standard (6.2.5): Definición formal de tipos incompletos.

• ISO C11 Standard (6.7.2.3): Declaraciones de estructuras y tipos opacos.

Artículos y Recursos¶

• “Object-Oriented Programming With ANSI-C” - Axel-Tobias Schreiner. Uso avanzado de punteros opacos para simular OOP.

• POSIX API Design Guidelines - Ejemplos de APIs del sistema que usan punteros opacos extensivamente.