1. Variables Básicas

Para declaarr una variable, se debe seleccionar el tipo de dato adecuado (como int, char, float), asignar un identificador válido y seguir la sintaxis estándar: tipo identificador;.

int contador;                  // Declaración de una variable entera
unsigned short int nivel;      // Tipo compuesto por múltiples palabras clave
int x, y, z;                   // Declaración múltiple de variables separadas por comas
int ancho = 10, alto = 20;     // Declaración con inicialización simultánea
char inicial = 'Z';            // Inicialización de una constante de carácter
double pi = 3.14159e0;         // Inicialización de una constante de punto flotante

2. Punteros

Los punteros son variables que almacenan direcciones de memoria. Su declaración requiere el uso del operador de indirección *.

int *puntero_entero;                 // Puntero a un tipo entero
const int *puntero_a_const;          // Puntero a un entero constante (el valor apuntado no puede cambiar)
int *const puntero_const;            // Puntero constante a entero (la dirección almacenada no puede cambiar)
const int *const p_constante_total;  // Puntero constante a un entero constante

Declaraciones de punteros más complejos:

int **doble_puntero;                 // Puntero a un puntero que apunta a un entero
int (*puntero_array)[10];            // Puntero a un arreglo de 10 enteros
float *(*puntero_a_array)[5];        // Puntero a un arreglo de 5 punteros a float
int (*puntero_funcion)(void);        // Puntero a una función sin parámetros que retorna un entero
struct Nodo *puntero_estructura;     // Puntero a una estructura de tipo Nodo

3. Arreglos

Los arreglos permiten almacenar múltiples valores del mismo tipo bajo un mismo identificador.

char buffer_letras[20];              // Arreglo de 20 caracteres
double mediciones[5];                // Arreglo de 5 números de doble precisión
int numeros[5] = {10, 20, 30};       // Inicialización parcial; el compilador llena el resto con ceros
int valores[] = {2, 4, 6, 8, 10};    // El tamaño se omite; el compilador lo infiere por la lista
char *nombres[4];                    // Arreglo de 4 punteros a carácter

4. Funciones

La declaración de funciones define el tipo de retorno, el nombre y la lista de parámetros.

void calcular_impuestos(float monto, char region); // Prototipo de función estándar
int *obtener_direccion_memoria(void);              // Función que retorna un puntero a entero

5. Estructuras

Las estructuras agrupan variables de diferentes tipos bajo un mismo nombre lógico.

struct Producto {                  // Definición de la estructura con etiqueta
    char nombre[50];               // Miembros con sus respectivos tipos
    int codigo;
    float precio;
};                                 // El punto y coma final es obligatorio

struct Producto item;              // Declaración de una variable usando la etiqueta
struct Producto p1, p2;            // Declaración de múltiples variables

struct Producto laptop = {         // Inicialización de la estructura
    "Laptop Gamer",
    1024,
    1299.99
};

Estructuras anidadas:

struct Direccion {
    char calle[50];
    char ciudad[30];
};

struct Empleado {
    struct Direccion ubicacion;    // Estructura anidada como miembro
    int id;
};

struct Empleado trabajador = {     // Inicialización de estructura anidada
    {"Av. Principal 123", "Madrid"},
    5542
};

6. Uniones

Las uniones son similares a las estructuras, pero todos sus miembros comparten el mismo espacio de memoria. El tamaño de la unión será el de su miembro más grande.

union DatoGenerico {               // Plantilla de unión con etiqueta
    int entero;
    double flotante;
    char caracter;
};

union DatoGenerico valor;          // Variable de tipo unión
union DatoGenerico registro[5];    // Arreglo que contiene 5 uniones
union DatoGenerico *ptr_dato;      // Puntero a la unión

7. Enumeraciones

Las enumeraciones definen un conjunto de constantes enteras con nombres descriptivos.

enum EstadoPedido {
    PENDIENTE,
    PROCESANDO,
    ENVIADO,
    ENTREGADO
};

enum EstadoPedido estado_actual;   // Declaración de una variable de tipo enumeración

8. Typedef

La palabra clave typedef no crea nuevos tipos de datos, sino que establece alias para tipos existentes, mejorando la legibilidad del código.

typedef unsigned char byte_t;      // Alias para un byte sin signo

typedef char Cadena[100];          // Alias para un arreglo de caracteres
Cadena titulo, autor;              // Equivale a: char titulo[100], autor[100];

typedef char* PunteroChar;         // Alias para un puntero a carácter
void procesar_texto(const PunteroChar origen, const PunteroChar destino);

typedef struct {                   // Alias para una estructura anónima
    int id;
    char nombre[30];
} Usuario;

Usuario nuevo_usuario;             // Equivale a declarar una variable de la estructura anterior

9. Macros del Preprocesador

La directiva #define permite realizar sustituciones de texto simples antes de la compilación.

#define PI 3.14159                 // Macro de constante simple

#define NOMBRE_APP "MiAplicacion"  // Macro de cadena de texto (limitada a una línea)

#define MINIMO(a, b) ((a) < (b) ? (a) : (b)) // Macro con parámetros; se recomienda encerrar todo en paréntesis