Como digo esto se trata de C y no de C++.

Es posible emular, en C, el comportamiento de miembros privados de datos definidos por el programador, al estilo de la POO, para que los usuarios de esa estructura no puedan acceder directamente a los datos que hay dentro de ella.

Las ventajas que tiene esta técnica:
1. El usuario no puede modificar los datos directamente y deben pasar por los filtros que imponga el programador.
2. El programador puede cambiar los datos internos que tiene la estructura y su interfaz (funciones getters y setters) sin que el usuario tenga que recompilar todo su código para hacer uso de estas modificaciones.

Los inconvenientes:
1. Sólo se puede situar la estructura en memoria del montón con lo que aparece el problema de la fragmentación de la memoria
2. La memoria se debe liberar ya sea mediante free o una función que proporcione el programador a modo de destructor.

Aquí va el código:


dato.h

#ifndef __DATO_H__
#define __DATO_H__
 
typedef struct __dato__ DATO;
 
DATO* new_dato();
void delete_dato(DATO* objeto);
int get_dato(DATO* objeto);
void set_dato(DATO* objeto, int valor);
 
#endif

dato.c

#include <stdlib.h>
#include "dato.h"
 
struct __dato__ {
    int miembro_privado;
};
 
DATO* new_dato() {
    DATO* d = malloc(sizeof(DATO));
    d->miembro_privado = 0;
    return d;
}
 
void delete_dato(DATO* objeto) {
    free(objeto);
}
 
int get_dato(DATO* objeto) {
    return objeto->miembro_privado;
}
 
void set_dato(DATO* objeto, int valor) {
    objeto->miembro_privado = valor;
}

Ahora el cliente:

main.c

#include <stdio.h>
#include "dato.h"
 
int main() {
    DATO *d;
 
    d = new_dato();
    set_dato(d, 5);
    printf("%i\n", get_dato(d));
 
    /* d->miembro_privado = 4; /* <- Esto va a fallar */
    /* printf("%i\n", get_dato(d)); */
 
    delete_dato(d);
 
    return 0;
}

Si estás detrás de un compilador GCC o parecido este es el makefile:

CC=gcc
 
p: main.o dato.o dato.h
	${CC} main.o dato.o dato.h -o p
dato.o: dato.c dato.h
	${CC} -c dato.c dato.h
main.o: main.c dato.h
	${CC} -c main.c dato.h

Aquí se generan dos objetos que después se enlazan: por un lado el propio del tipo de dato, aquí dato.o, y por otro el del cliente consumidor del tipo de dato, aquí main.o.
dato.o se compila a partir de dato.c, del cual el cliente no sabe nada, y dato.h. Como programador darás el objeto generado y la cabecera dato.h a tu cliente.

Tu cliente hará su propio programa incluyendo la cabecera dato.h a su código (aquí representado por main.c) y enlazando su código objeto, aquí representado por main.o, con el que tu le proporcionas.
Compilado de esta forma no puede acceder al miembro del struct ya que solo ve el dato incompleto de la cabecera. Los datos internos están ocultos en el código objeto.
Lo único que ve el cliente es la interfaz proporcionada por el archivo de cabecera.