En el desarrollo con lenguaje C, la estructuración de funciones y la gestión del alcance de las variables son pilares fundamentales para escribir código eficiente y modular. A continuación, se detallan los aspectos técnicos del punto de entrada del programa, la visibilidad de los identifciadores y el control de almacenamiento.

1. La Función Principal: main

El punto de entrada de cualquier programa en C es la función main. Por convención, es invocada por el sistema operativo y rige el flujo de ejecución.

Retorno de ejecución

El estándar de C establece que main debe devolver un entero. Un retorno de 0 indica que el proceso finalizó correctamente, mientras que cualquier otro valor entero suele representar un código de error específico.

Argumentos de línea de comandos

La función principal puede recibir parámetros que permiten interactuar con el programa desde la terminal:

• argc (Argument Count): Un entero que indica la cantidad de argumentos recibidos (incluyendo el nombre del ejecutable).
• argv (Argument Vector): Un arreglo de punteros a cadenas de caracteres que contiene los valores de dichos argumentos.

#include <stdio.h>

int main(int total_params, char *valores[]) {
   printf("Procesando argumentos del sistema:\n");
   printf("Cantidad detectada: %d\n", total_params);
   
   for (int idx = 0; idx < total_params; idx++) {
       printf("Parametro [%d]: %s\n", idx, valores[idx]);
   }
   
   return 0;
}

2. Prototipos de Funciones

En C, el compilador procesa el código de forma secuencial. Si se intenta invocar una función antes de su definición, se generará un error o una advertencia. Los prototipos permiten declarar la firma de la función (nombre, tipo de retorno y parámetros) al inicio del archivo, postergando la implementación detallada para más adelante.

Esto mejora la legibilidad al permitir que main se sitúe en la parte superior del archivo fuente.

#include <stdio.h>

// Prototipo o declaración adelantada
double calcular_cuadrado(double n);

int main() {
   double resultado = calcular_cuadrado(5.5);
   printf("Resultado: %.2f\n", resultado);
   return 0;
}

// Definición de la función
double calcular_cuadrado(double n) {
   return n * n;
}

3. Ámbito de las Variables (Scope)

El ámbito determina la visibilidad y el tiempo de vida de un identificador dentro del código.

Ámbito Global

Las variables definidas fuera de cualquier bloque {} tienen alcance global. Son accesibles desde cualquier punto del programa y, si no se inicializan explícitamente, el compilador les asigna el valor 0 por defecto (o NULL/\0 según el tipo).

Ámbito Local y de Bloque

Las variables declaradas dentro de una función o un bloque específico (como un if o for) son locales. A diferencia de las globales, las variables locales no se inicializan automáticamente; contienen "basura" o valores impredecibles si no se les asigna uno.

• Stack (Pila): Es el área de memoria donde residen las variables locales. Se liberan automáticamente al terminar la ejecución de la función.
• Data Segment: Área donde residen las variables globales y estáticas.

void demostracion_bloque() {
   int externa = 10;
   
   if (externa > 5) {
       int interna = 20; // Solo existe dentro de este if
       printf("Suma: %d\n", externa + interna);
   }
   // printf("%d", interna); // Error: 'interna' no está definida aquí
}

4. Modificadores: static y extern

El modificador static

El uso de static varía según su contexto:

• Variables locales estáticas: Mantienen su valor entre llamadas sucesivas a la misma función. No se destruyen al salir del ámbito local, sino que persisten en el segmento de datos global, aunque su visibilidad sigue restringida a la función original.
• Variables/Funciones globales estáticas: Limitan la visibilidad del identificador únicamente al archivo fuente actual (encapsulamiento a nivel de archivo).

#include <stdio.h>

void contador_llamadas() {
   static int cuenta = 0; // Se inicializa solo una vez
   cuenta++;
   printf("Esta funcion se ha ejecutado %d veces\n", cuenta);
}

int main() {
   contador_llamadas(); // Salida: 1
   contador_llamadas(); // Salida: 2
   return 0;
}

El modificador extern

Se utiliza para declarar una variable o función que está definida en otro archivo fuente. Es la base de la compilación modular en proyectos de gran envergadura, permitiendo que diferentes unidades de traducción compartan estados globales.

Resumen de Comportamiento de Memoria