Compilador de C + Makefile

Compilación manual en  C

Ejecuta el comando manualmente: Intenta ejecutar los comandos directamente en la terminal para ver qué errores aparecen. Prueba:  

gcc -Wall -c mi_libreria.c -o mi_libreria.o
gcc -Wall -c main.c -o main.o
gcc main.o mi_libreria.o -o programa_principal 

Si alguno de estos pasos falla, el error te dará más pistas sobre lo que está ocurriendo.

Interpretación de los comandos

Cada línea usa gcc (el compilador de C) con diferentes opciones:

1. gcc -Wall -c mi_libreria.c -o mi_libreria.o
   • -Wall: Activa muchas advertencias del compilador para detectar posibles problemas en el código.
   • -c: Compila el archivo mi_libreria.c pero sin generar el ejecutable, solo crea el archivo objeto (.o).
   • -o mi_libreria.o: Especifica que el archivo objeto generado se llamará mi_libreria.o.
2. gcc -Wall -c main.c -o main.o
   • Hace lo mismo que la primera línea, pero con main.c, generando main.o.
3. gcc main.o mi_libreria.o -o programa_principal
   • Sin -c, lo que significa que ahora estamos enlazando (linking) los archivos objeto (.o) para formar el ejecutable.
   • main.o mi_libreria.o: Se combinan ambos archivos objeto.
   • -o programa_principal: Especifica que el ejecutable final se llamará programa_principal.

 

Archivo Makefile

Makefile avanzado con mejoras como reglas automáticas, dependencias dinámicas y optimización. Este Makefile:

1. Compila automáticamente los archivos .c a .o.
2.  Enlaza los archivos objeto para crear el ejecutable.
3.  Maneja dependencias automáticamente.  
4. Incluye una regla clean para limpiar archivos intermedios.

# Nombre del ejecutable
EXECUTABLE = programa_principal

# Archivos fuente
SRC = mi_libreria.c main.c

# Archivos objeto (se generan automáticamente a partir de los archivos fuente)
OBJ = $(SRC:.c=.o)

# Compilador
CC = gcc

# Flags de compilación
CFLAGS = -Wall -Wextra -O2 -g

# Regla principal: compila y enlaza
all: $(EXECUTABLE)

# Regla para compilar el ejecutable
$(EXECUTABLE): $(OBJ)
    $(CC) $(OBJ) -o $(EXECUTABLE)

# Regla para compilar archivos objeto automáticamente
%.o: %.c
	$(CC) $(CFLAGS) -c $< -o $@

# Regla para limpiar archivos generados
clean:
    rm -f $(OBJ) $(EXECUTABLE)

# Regla para recompilar todo desde cero
rebuild: clean all

 

1. ✅ Uso de variables automáticas ($< representa el archivo fuente correspondiente). 
2. ✅ Generación automática de archivos objeto (OBJ = $(SRC:.c=.o)). 
3. ✅ Optimización (-O2) y depuración (-g) habilitadas en CFLAGS. 
4. ✅ Regla rebuild para recompilar desde cero en un solo comando (make rebuild).

 

Vamos a crear una librería de matemática

1. ✅ Suma, resta, multiplicación y división. 
2. ✅ Potenciación y logaritmos. 
3. ✅ Resolución de ecuaciones algebraicas de primer, segundo y tercer grado. 
4. ✅ Creación de coordenadas en un plano cartesiano.

 

1. Archivo de encabezado mi_libreria.h

Aquí declaramos las funciones:

#ifndef MI_LIBRERIA_H
#define MI_LIBRERIA_H

#include <math.h>

// Declaración de la función para sumar dos enteros
// Operaciones básicas
int sumar(int a, int b);
int restar(int a, int b);
int multiplicar(int a, int b);
double dividir(double a, double b);

// Operaciones avanzadas
double potencia(double base, double exponente);
double logaritmo(double valor, double base);

// Ecuaciones algebraicas
double ecuacion_primero(double a, double b);
double ecuacion_segundo(double a, double b, double c);
double ecuacion_tercero(double a, double b, double c, double d);

// Creación de coordenadas
typedef struct {
    double x;
    double y;
} Coordenada;

Coordenada crear_coordenada(double x, double y);

#endif
 

2. Implementación mi_libreria.c

Aquí definimos todas las funciones:

#include "mi_libreria.h" // Incluimos el archivo de encabezado correspondiente
#include <stdio.h>
// Implementación de las funciones
// Operaciones básicas
int sumar(int a, int b) {
    return a + b;
}

int restar(int a, int b) {
    return a - b;
}

int multiplicar(int a, int b) {
    return a * b;
}

double dividir(double a, double b) {
    if (b == 0) {
        printf("Error: división por cero.\n");
        return 0;
    }
    return a / b;
}

// Operaciones avanzadas
double potencia(double base, double exponente) {
    return pow(base, exponente);
}

double logaritmo(double valor, double base) {
    return log(valor) / log(base);
}

// Ecuaciones algebraicas
double ecuacion_primero(double a, double b) {
    return -b / a;
}

double ecuacion_segundo(double a, double b, double c) {
    double discriminante = b * b - 4 * a * c;
    if (discriminante < 0) {
        printf("No hay soluciones reales.\n");
        return 0;
    }
    return (-b + sqrt(discriminante)) / (2 * a);
}

double ecuacion_tercero(double a, double b, double c, double d) {
    (void)a; (void)b; (void)c; (void)d; // Evita advertencias sin afectar funcionalidad
    printf("Método numérico requerido para resolver ecuaciones de tercer grado.\n");
    return 0;
}

// Creación de coordenadas
Coordenada crear_coordenada(double x, double y) {
    Coordenada punto = {x, y};
    return punto;
}
 

3. Programa principal main.c

Probamos las funciones con ejemplos:

#include <stdio.h>
#include "mi_libreria.h" // Incluimos nuestra librería

int main() {
    int a = 10, b = 5;

printf("Si a = %d y b = %d\n" , a, b);

    printf("Suma: %d\n", sumar(a, b));
    printf("Resta: %d\n", restar(a, b));
    printf("Multiplicación: %d\n", multiplicar(a, b));
    printf("División: %.2f\n", dividir(a, b));

    printf("Potencia: %.2f\n", potencia(2, 3));
    printf("Logaritmo base 10 de 100: %.2f\n", logaritmo(100, 10));

    Coordenada punto = crear_coordenada(4.5, 3.2);
    printf("Coordenada creada: (%.2f, %.2f)\n", punto.x, punto.y);

    return 0;
}

4. Makefile para compilar todo

EXECUTABLE = programa_principal
SRC = mi_libreria.c main.c
OBJ = $(SRC:.c=.o)
CC = gcc
CFLAGS = -Wall -Wextra -O2 -g

all: $(EXECUTABLE)

$(EXECUTABLE): $(OBJ)
	$(CC) $(OBJ) -o $(EXECUTABLE) -lm

%.o: %.c
	$(CC) $(CFLAGS) -c $< -o $@

clean:
	rm -f $(OBJ) $(EXECUTABLE) 

Nota: Se añade -lm para enlazar la librería matemática (math.h).

¡Listo! 🔥 Ahora tienes una librería completa con operaciones avanzadas. Puedes compilar todo usando make y probar los resultados.

 

Paso 1: Abrir la terminal y Entrar a la carpeta del proyecto.

cd Practica-Leng-C/crear_libreria 

Paso 2: Ejecutar el Makefile con el comando "make"

make 

Paso 3: Abrir el ejecutable para ver resultado.

./programa_principal 

Paso 4: Eliminar los objetos ".o" creados y el ejecutable.

make clean

Paso 5: Limpiar la terminal

clear

Paso 6: salir y cerrar la terminal

exit