Saltar a contenido

Práctica 1.2: Del código fuente al código ejecutable

P13 - Del código fuente al código ejecutable

En esta actividad escribirás un programa breve en C y observarás qué archivos se producen al compilarlo y enlazarlo por separado. Al terminar, podrás distinguir el archivo fuente, el objeto intermedio y el ejecutable, y explicar qué aporta cada etapa. La práctica desarrolla el apartado 1.2. Código fuente, objeto y ejecutable, asociado al CE 1.c.

1. Objetivos

  • Diferenciar el código fuente, el código objeto y el código ejecutable a partir de los archivos generados.
  • Compilar un programa C en un archivo objeto y enlazarlo después para obtener un ejecutable.
  • Explicar por qué el enlazador resuelve referencias y prepara el programa para su ejecución.
  • Identificar buenas prácticas reutilizables al construir programas con herramientas distintas.

2. Relación con RA y criterios de evaluación

Código Descripción
RA 1 Reconoce los elementos y herramientas que intervienen en el desarrollo de un programa informático, analizando sus características y las fases en las que actúan hasta llegar a su puesta en funcionamiento.
CE 1.c Se han diferenciado los conceptos de código fuente, objeto y ejecutable.

El criterio principal es CE 1.c. La actividad hace visibles las tres etapas mediante sus archivos y comandos, en lugar de limitarse a definir los conceptos.

3. Requisitos y recursos

  • Un ordenador con Linux, macOS o Windows y una terminal. En Windows se necesita una instalación de GCC compatible, por ejemplo MinGW-w64.
  • GCC instalado y accesible desde la terminal. Comprueba su disponibilidad con gcc --version; si el comando no se reconoce, utiliza el entorno de clase configurado o pide ayuda antes de continuar.
  • Un editor de texto o IDE para crear el archivo fuente. La terminal es necesaria para separar la compilación del enlazado; muchos IDE ejecutan ambas etapas con una sola acción y ocultan los archivos intermedios.
  • La teoría 1.2. Código fuente, objeto y ejecutable. Como ampliación, consulta 1.3. Código intermedio y 1.4. Traductores.
  • Trabajo en parejas o tríos. Repartid los papeles de edición, ejecución de comandos y registro de evidencias, y cambiadlos al repetir la actividad.

4. Pasos a seguir

4.1. Crear y reconocer el código fuente

  1. Crea una carpeta para la actividad y abre una terminal en ella. Comprueba que GCC está disponible con gcc --version. Anota la versión y el sistema operativo; así podrás explicar para qué entorno se generarán los archivos.

  2. Crea un archivo llamado programa.c con el siguiente código. Antes de compilarlo, identifica qué líneas contienen las instrucciones que has escrito y qué resultado esperas obtener.

    #include <stdio.h>

int main(void) {
    int num1 = 5;
    int num2 = 3;
    int resultado = num1 + num2;

    printf("El resultado es: %d\n", resultado);
    return 0;
}

  3. Guarda el archivo y verifica que se llama exactamente programa.c. Este archivo de texto, escrito en C y legible para el equipo de desarrollo, es el código fuente. Todavía no es el ejecutable que iniciará el sistema operativo.

4.2. Compilar para generar el código objeto

  1. Desde la carpeta que contiene programa.c, ejecuta:

    gcc -Wall -Wextra -std=c11 -c programa.c -o programa.o

    La opción -c pide a GCC que compile y ensamble el código, pero que no realice el enlazado final. Si el comando termina sin errores, debe aparecer programa.o. Si hay un mensaje de error o advertencia, léelo completo y corrige el problema antes de seguir.

  2. Comprueba que están programa.c y programa.o. En Linux o macOS puedes ejecutar ls -l programa.c programa.o; en PowerShell, Get-Item programa.c, programa.o. Registra los nombres y tamaños que muestra tu sistema. El archivo .o contiene código objeto y metadatos del formato de destino; puede incluir referencias que todavía debe resolver el enlazador.

  3. Piensa por qué programa.o no es todavía el ejecutable que vas a iniciar. No lo abras como si fuera un archivo de texto ni intentes ejecutarlo directamente: normalmente es un objeto reubicable, no un programa autónomo preparado para cargar como proceso. Como ampliación, puedes identificar su formato con file programa.o si tienes esa herramienta o inspeccionar una copia con un editor hexadecimal; no edites el archivo.

4.3. Enlazar y ejecutar el programa

  1. En Linux o macOS, enlaza el objeto para producir el ejecutable:

    gcc programa.o -o programa

    En PowerShell con MinGW-w64, utiliza:

    gcc programa.o -o programa.exe

    GCC actúa como controlador de la construcción y solicita el trabajo del enlazador. El enlazador combina el objeto con el código de inicio y las bibliotecas requeridas y resuelve las referencias disponibles. Esto no significa que todas las bibliotecas se copien dentro del ejecutable: algunas dependencias pueden cargarse dinámicamente al ejecutar el programa.

  2. Comprueba que se ha creado programa en Linux o macOS, o programa.exe en Windows. Este es el código ejecutable para el sistema y la arquitectura de destino con los que se ha construido; no presupongas que funcionará sin cambios en cualquier otro equipo.

  3. En Linux o macOS, ejecuta el archivo generado:

    ./programa

    En Windows PowerShell, utiliza:

    .\programa.exe

    Comprueba que aparece El resultado es: 8. Si el sistema indica que no encuentra el archivo, revisa el nombre, la carpeta actual y el comando correspondiente a tu sistema. En macOS y Linux, ./ indica que el ejecutable está en la carpeta actual.

4.4. Identificar buenas prácticas reutilizables

  1. Revisa los comandos y los archivos generados. Identifica al menos cuatro prácticas que te ayudarían también en otros lenguajes o proyectos: conservar y nombrar claramente el fuente, separar las etapas cuando quieras entender el proceso, leer los diagnósticos completos, comprobar cada artefacto antes de avanzar y tener en cuenta el sistema de destino.

  2. Explica por qué conviene distinguir entre los archivos fuente y los generados. No borres programa.c: si modificas el fuente, debes volver a compilar y enlazar para que el ejecutable incorpore los cambios.

  3. 4.4.3. Como ampliación, compara este flujo con la ejecución habitual de un archivo Python. No afirmes que Python nunca compila: una implementación como CPython puede generar bytecode y archivos .pyc, pero ese bytecode no es el archivo objeto nativo .o ni el ejecutable de C de esta práctica. Relaciona tu respuesta con la teoría de código intermedio.

5. Comprobaciones de finalización

  • Existe programa.c y puedes reconocer en él el código fuente escrito en C.
  • El comando con -c genera programa.o sin producir todavía el ejecutable final.
  • El enlazado genera un ejecutable con el nombre y formato correspondientes al entorno utilizado.
  • Al iniciar ese ejecutable aparece exactamente El resultado es: 8.
  • Puedes describir la función del compilador, del enlazador y de las bibliotecas sin afirmar que todas ellas se integran físicamente en un único archivo.
  • Has identificado buenas prácticas aplicables también a otros procesos de construcción y conservas las evidencias solicitadas.

6. Ejercicios y entregables

  1. 1.a. Completa una tabla con estos tres archivos: programa.c, programa.o y programa o programa.exe.
    • 1.a.1. ¿Quién o qué herramienta produce cada archivo?
    • 1.a.2. ¿A qué etapa del proceso pertenece cada uno?
    • 1.a.3. ¿Qué representa cada archivo?
    • 1.a.4. ¿Está preparado cada archivo para ejecutarse directamente como programa?
  2. 2. Responde con tus palabras:
    • 2.a. ¿Por qué el código fuente no se ejecuta directamente?
    • 2.b. ¿Qué hace el paso de compilación?
    • 2.c. ¿Qué resuelve el enlazador?
    • 2.d. ¿Qué fallaría si se omitiera la generación del objeto o el enlazado?
    • 2.e. ¿Por qué no se debe confundir un archivo objeto con un ejecutable aunque ambos contengan datos binarios?
  3. 3.a. Cambia los valores iniciales a 17 y 25.
    • 3.a.1. Antes de ejecutar, predice el resultado.
    • 3.a.2. Explica por qué no basta con modificar programa.c para actualizar el ejecutable anterior.
    • 3.b. Repite por separado la compilación, el enlazado y la ejecución, y contrasta el resultado con tu predicción.
  4. 4.a. Identifica al menos cuatro buenas prácticas reutilizables del paso 4.4 y justifica brevemente cómo ayudan a evitar errores o a hacer reproducible el trabajo.
  5. Entrega programa.c y un documento (README.md) identificado con tu nombre, módulo, unidad y práctica. Incluye la tabla de archivos, las respuestas, los comandos utilizados, el resultado de ambas ejecuciones, una captura o listado que evidencie los archivos generados y la reflexión sobre las buenas prácticas. No es necesario que el archivo binario se ejecute en el equipo de otra persona: puede depender de su sistema y arquitectura.

7. Solución orientativa

El resultado inicial debe ser El resultado es: 8. La orden de compilación con -c genera programa.o, mientras que la orden de enlazado genera programa o programa.exe. El código fuente es el archivo escrito en C; el objeto es una etapa intermedia con código y referencias que pueden quedar pendientes; el ejecutable es el archivo preparado para que el sistema operativo lo cargue en el entorno de destino. Al cambiar los operandos a 17 y 25, el resultado esperado es El resultado es: 42, pero hay que repetir la compilación y el enlazado.

Fuentes y referencias