Extracción de Funciones

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
void procesar_pedido(pedido_t *pedido)
{
    // Validar datos del cliente
    if (pedido->cliente.nombre == NULL || strlen(pedido->cliente.nombre) == 0)
    {
        return;
    }
    if (pedido->cliente.email == NULL || !strchr(pedido->cliente.email, '@'))
    {
        return;
    }
    // Calcular total con impuestos
    double subtotal = 0;
    for (int i = 0; i < pedido->num_items; i++)
    {
        subtotal += pedido->items[i].precio * pedido->items[i].cantidad;
    }
    double impuestos = subtotal * 0.21;
    double total = subtotal + impuestos;
    // Guardar en base de datos
    // ...
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
int procesar_usuario(const char *nombre, const char *email, int edad)
{
    // Validación embebida en la función principal
    if (nombre == NULL || strlen(nombre) < 3)
    {
        printf("Nombre inválido\n");
        return -1;
    }
    if (email == NULL || !strchr(email, '@'))
    {
        printf("Email inválido\n");
        return -1;
    }
    if (edad < 18 || edad > 120)
    {
        printf("Edad inválida\n");
        return -1;
    }
    // Lógica principal
    printf("Usuario %s registrado\n", nombre);
    return 0;
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
bool validar_nombre(const char *nombre)
{
    if (nombre == NULL || strlen(nombre) < 3)
    {
        printf("Nombre inválido\n");
        return false;
    }
    return true;
}
bool validar_email(const char *email)
{
    if (email == NULL || !strchr(email, '@'))
    {
        printf("Email inválido\n");
        return false;
    }
    return true;
}
bool validar_edad(int edad)
{
    if (edad < 18 || edad > 120)
    {
        printf("Edad inválida\n");
        return false;
    }
    return true;
}
int procesar_usuario(const char *nombre, const char *email, int edad)
{
    if (!validar_nombre(nombre))
        return -1;
    if (!validar_email(email))
        return -1;
    if (!validar_edad(edad))
        return -1;
    // Lógica principal ahora es clara
    printf("Usuario %s registrado\n", nombre);
    return 0;
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
void analizar_ventas(double ventas[], int n)
{
    // Calcular estadísticas
    double total = 0;
    double maximo = ventas[0];
    double minimo = ventas[0];
    for (int i = 0; i < n; i++)
    {
        total += ventas[i];
        if (ventas[i] > maximo)
            maximo = ventas[i];
        if (ventas[i] < minimo)
            minimo = ventas[i];
    }
    double promedio = total / n;
    printf("Total: %.2f\n", total);
    printf("Promedio: %.2f\n", promedio);
    printf("Máximo: %.2f\n", maximo);
    printf("Mínimo: %.2f\n", minimo);
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
typedef struct
{
    double total;
    double promedio;
    double maximo;
    double minimo;
} estadisticas_t;
estadisticas_t calcular_estadisticas(const double ventas[], int n)
{
    estadisticas_t stats = {0};
    if (n == 0)
        return stats;
    stats.maximo = ventas[0];
    stats.minimo = ventas[0];
    for (int i = 0; i < n; i++)
    {
        stats.total += ventas[i];
        if (ventas[i] > stats.maximo)
            stats.maximo = ventas[i];
        if (ventas[i] < stats.minimo)
            stats.minimo = ventas[i];
    }
    stats.promedio = stats.total / n;
    return stats;
}
void mostrar_estadisticas(estadisticas_t stats)
{
    printf("Total: %.2f\n", stats.total);
    printf("Promedio: %.2f\n", stats.promedio);
    printf("Máximo: %.2f\n", stats.maximo);
    printf("Mínimo: %.2f\n", stats.minimo);
}
void analizar_ventas(const double ventas[], int n)
{
    estadisticas_t stats = calcular_estadisticas(ventas, n);
    mostrar_estadisticas(stats);
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
void procesar_archivo(const char *ruta)
{
    FILE *f = fopen(ruta, "r");
    char linea[256];
    int lineas_procesadas = 0;
    int lineas_con_error = 0;
    while (fgets(linea, sizeof(linea), f))
    {
        // Limpiar salto de línea
        linea[strcspn(linea, "\n")] = '\0';
        // Saltar líneas vacías
        if (strlen(linea) == 0)
            continue;
        // Saltar comentarios
        if (linea[0] == '#')
            continue;
        // Parsear línea
        char *separador = strchr(linea, '=');
        if (separador == NULL)
        {
            lineas_con_error++;
            continue;
        }
        *separador = '\0';
        char *clave = linea;
        char *valor = separador + 1;
        // Trim whitespace
        while (*clave == ' ')
            clave++;
        while (*valor == ' ')
            valor++;
        // Procesar par clave-valor
        printf("%s -> %s\n", clave, valor);
        lineas_procesadas++;
    }
    fclose(f);
    printf("Procesadas: %d, Errores: %d\n", lineas_procesadas,
           lineas_con_error);
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
bool es_linea_valida(const char *linea)
{
    return strlen(linea) > 0 && linea[0] != '#';
}
bool parsear_par_clave_valor(char *linea, char **clave, char **valor)
{
    char *separador = strchr(linea, '=');
    if (separador == NULL)
    {
        return false;
    }
    *separador = '\0';
    *clave = linea;
    *valor = separador + 1;
    // Trim whitespace
    while (**clave == ' ')
        (*clave)++;
    while (**valor == ' ')
        (*valor)++;
    return true;
}
void procesar_linea_config(char *linea, int *procesadas, int *errores)
{
    // Limpiar salto de línea
    linea[strcspn(linea, "\n")] = '\0';
    if (!es_linea_valida(linea))
    {
        return;
    }
    char *clave;
    char *valor;
    if (!parsear_par_clave_valor(linea, &clave, &valor))
    {
        (*errores)++;
        return;
    }
    printf("%s -> %s\n", clave, valor);
    (*procesadas)++;
}
void procesar_archivo(const char *ruta)
{
    FILE *f = fopen(ruta, "r");
    if (f == NULL)
    {
        printf("Error abriendo archivo\n");
        return;
    }
    char linea[256];
    int lineas_procesadas = 0;
    int lineas_con_error = 0;
    while (fgets(linea, sizeof(linea), f))
    {
        procesar_linea_config(linea, &lineas_procesadas, &lineas_con_error);
    }
    fclose(f);
    printf("Procesadas: %d, Errores: %d\n", lineas_procesadas,
           lineas_con_error);
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
double calcular_precio_final(double precio_base, int cantidad,
                             bool es_mayorista, const char *codigo_postal)
{
    // Descuento por cantidad
    double descuento_cantidad = 0;
    if (cantidad >= 100)
    {
        descuento_cantidad = 0.20;
    }
    else if (cantidad >= 50)
    {
        descuento_cantidad = 0.15;
    }
    else if (cantidad >= 10)
    {
        descuento_cantidad = 0.10;
    }
    // Descuento mayorista
    double descuento_mayorista = es_mayorista ? 0.05 : 0;
    // Descuento total (no acumulativo lineal)
    double descuento_total = descuento_cantidad + descuento_mayorista;
    if (descuento_total > 0.25)
        descuento_total = 0.25;
    double subtotal = precio_base * cantidad * (1 - descuento_total);
    // Impuesto según región
    double impuesto = 0.21; // IVA estándar
    if (codigo_postal[0] == '9')
    { // Patagonia
        impuesto = 0.10;
    }
    // Cargo por envío
    double envio = 0;
    if (cantidad < 5)
    {
        envio = 500;
    }
    else if (cantidad < 20)
    {
        envio = 300;
    }
    return subtotal * (1 + impuesto) + envio;
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
double calcular_descuento_por_cantidad(int cantidad)
{
    if (cantidad >= 100)
        return 0.20;
    if (cantidad >= 50)
        return 0.15;
    if (cantidad >= 10)
        return 0.10;
    return 0.0;
}
double calcular_descuento_mayorista(bool es_mayorista)
{
    return es_mayorista ? 0.05 : 0.0;
}
double calcular_descuento_total(int cantidad, bool es_mayorista)
{
    const double DESCUENTO_MAXIMO = 0.25;
    double descuento = calcular_descuento_por_cantidad(cantidad) +
                       calcular_descuento_mayorista(es_mayorista);
    return (descuento > DESCUENTO_MAXIMO) ? DESCUENTO_MAXIMO : descuento;
}
double calcular_impuesto_regional(const char *codigo_postal)
{
    const double IVA_ESTANDAR = 0.21;
    const double IVA_PATAGONIA = 0.10;
    // Patagonia tiene código postal que empieza con 9
    if (codigo_postal[0] == '9')
    {
        return IVA_PATAGONIA;
    }
    return IVA_ESTANDAR;
}
double calcular_cargo_envio(int cantidad)
{
    if (cantidad < 5)
        return 500.0;
    if (cantidad < 20)
        return 300.0;
    return 0.0;
}
double calcular_precio_final(double precio_base, int cantidad,
                             bool es_mayorista, const char *codigo_postal)
{
    double descuento = calcular_descuento_total(cantidad, es_mayorista);
    double subtotal = precio_base * cantidad * (1 - descuento);
    double impuesto = calcular_impuesto_regional(codigo_postal);
    double total_con_impuesto = subtotal * (1 + impuesto);
    double envio = calcular_cargo_envio(cantidad);
    return total_con_impuesto + envio;
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
typedef enum
{
    ESTADO_PENDIENTE,
    ESTADO_ENVIADO
} estado_t;

typedef struct
{
    const char *cliente;
    double precio;
    int cantidad;
    estado_t estado;
} item_t;

double procesar_pedido(item_t items[], int n, bool aplicar_iva)
{
    double total = 0.0;
    for (int i = 0; i < n; i++)
    {
        if (items[i].cantidad > 0)
        {
            if (items[i].precio > 0)
            {
                if (items[i].estado == ESTADO_PENDIENTE)
                {
                    if (items[i].cantidad >= 10)
                    {
                        total += items[i].precio * items[i].cantidad * 0.80;
                    }
                    else
                    {
                        total += items[i].precio * items[i].cantidad;
                    }
                }
            }
        }
    }
    if (aplicar_iva)
    {
        total *= 1.21;
    }
    printf("Total: %.2f\n", total);
    return total;
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
/** @brief Indica si un ítem participa del total.
 *  @param item Ítem a evaluar.
 *  @pre item no es NULL.
 *  @post Devuelve true solo si cantidad y precio son positivos y el estado
 *        es pendiente.
 *  @returns true si el ítem es facturable.
 */
static bool item_facturable(const item_t *item)
{
    return item != NULL && item->cantidad > 0 && item->precio > 0 &&
           item->estado == ESTADO_PENDIENTE;
}

/** @brief Aplica el descuento por volumen.
 *  @param subtotal Importe bruto del ítem.
 *  @param cantidad Unidades vendidas.
 *  @pre subtotal es mayor o igual que cero.
 *  @post Devuelve el importe con el descuento por volumen.
 *  @returns Importe neto del ítem.
 */
static double descontar_por_volumen(double subtotal, int cantidad)
{
    if (cantidad >= 10)
    {
        return subtotal * 0.80;
    }

    return subtotal;
}

/** @brief Suma los ítems facturables sin impuestos.
 *  @param items Arreglo de ítems.
 *  @param n Cantidad de ítems.
 *  @pre items tiene al menos n elementos.
 *  @post Devuelve la suma neta de los ítems facturables.
 *  @returns Total sin impuestos.
 */
static double total_sin_impuestos(const item_t *items, int n)
{
    double total = 0.0;
    for (int i = 0; i < n; i++)
    {
        if (!item_facturable(&items[i]))
        {
            continue;
        }

        double subtotal = items[i].precio * items[i].cantidad;
        total += descontar_por_volumen(subtotal, items[i].cantidad);
    }

    return total;
}

/** @brief Agrega el IVA a un total neto.
 *  @param neto Total sin impuestos.
 *  @pre neto es mayor o igual que cero.
 *  @post Devuelve neto multiplicado por 1.21.
 *  @returns Total con IVA.
 */
static double con_iva(double neto)
{
    return neto * 1.21;
}

int main(void)
{
    item_t items[] = {
        {"Ana", 1000.0, 12, ESTADO_PENDIENTE},
        {"Beto", 500.0, 3, ESTADO_ENVIADO},
    };
    int n = (int)(sizeof(items) / sizeof(items[0]));

    double total = con_iva(total_sin_impuestos(items, n));
    printf("Total: %.2f\n", total);

    return 0;
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
// Funciones atómicas
bool es_letra(char c)
{
    return (c >= 'a' && c <= 'z') || (c >= 'A' && c <= 'Z');
}
bool es_digito(char c)
{
    return c >= '0' && c <= '9';
}
bool es_espacio(char c)
{
    return c == ' ' || c == '\t' || c == '\n';
}
// Función compuesta
bool es_alfanumerico(char c)
{
    return es_letra(c) || es_digito(c);
}
bool es_identificador_valido(const char *str)
{
    if (str == NULL || strlen(str) == 0)
        return false;
    if (!es_letra(str[0]) && str[0] != '_')
        return false;
    for (size_t i = 1; str[i] != '\0'; i++)
    {
        if (!es_alfanumerico(str[i]) && str[i] != '_')
        {
            return false;
        }
    }
    return true;
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
typedef struct
{
    double descuento_mayorista;
    double impuesto_estandar;
    double impuesto_reducido;
    double cargo_envio_pequeno;
    double cargo_envio_mediano;
} configuracion_precios_t;
double calcular_precio_con_config(double precio_base, int cantidad,
                                  bool es_mayorista,
                                  const configuracion_precios_t *config)
{
    // Uso de configuración inyectada
    double descuento = es_mayorista ? config->descuento_mayorista : 0.0;
    double subtotal = precio_base * cantidad * (1 - descuento);
    // ... resto del cálculo usando config
    return subtotal;
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
typedef bool (*criterio_filtro_t)(int valor);
bool es_par(int valor)
{
    return valor % 2 == 0;
}
bool es_positivo(int valor)
{
    return valor > 0;
}
int contar_elementos_que_cumplen(const int *arr, int n,
                                 criterio_filtro_t criterio)
{
    int contador = 0;
    for (int i = 0; i < n; i++)
    {
        if (criterio(arr[i]))
        {
            contador++;
        }
    }
    return contador;
}
// Uso
int pares = contar_elementos_que_cumplen(arr, n, es_par);
int positivos = contar_elementos_que_cumplen(arr, n, es_positivo);

1
2
3
4
5
6
7
8
9
10
11
12
13
14
// Excesivo - funciones triviales que no agregan valor
int incrementar(int x)
{
    return x + 1;
}
int decrementar(int x)
{
    return x - 1;
}
// Uso innecesariamente verboso
for (int i = 0; i < n; i = incrementar(i))
{
    // ...
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
// Problemático
void procesar(int a, int b, int c, int d, int e, int f, int g)
{
    // Difícil de usar y mantener
}
// Mejor: usar estructura
typedef struct
{
    int param_a;
    int param_b;
    int param_c;
    // ...
} parametros_procesamiento_t;
void procesar(const parametros_procesamiento_t *params)
{
    // Más claro
}

1
2
3
4
5
6
7
8
9
10
11
// Problemático
int calcular_total(int *contador_global)
{
    (*contador_global)++; // Efecto secundario oculto
    return *contador_global * 100;
}
// Mejor: efecto secundario explícito o función pura
int calcular_total_puro(int contador)
{
    return contador * 100;
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
// Mal: mezcla niveles de abstracción
void procesar_pedido(pedido_t *pedido)
{
    // Alto nivel
    if (!validar_pedido(pedido))
        return;
    // Bajo nivel - no pertenece aquí
    for (int i = 0; i < pedido->num_items; i++)
    {
        if (pedido->items[i].precio < 0)
        {
            return;
        }
    }
    // Alto nivel
    guardar_pedido(pedido);
}
// Bien: nivel consistente
void procesar_pedido(pedido_t *pedido)
{
    if (!validar_pedido(pedido))
        return;
    if (!validar_items(pedido))
        return;
    guardar_pedido(pedido);
}