Preliminar

• clang, por defecto
  • C99 es la implementación de C por defecto en clang, no necesita opciones extra
    • Sin embargo esta implementación no es realmente estándar. Si quieres forzar el estándar, usa -std=c99
  • Si quieres usar C11, debes especificar -std=c11
  • clang compila el código fuente más rápidamente que gcc
• gcc necesita que especifiques -std=c99 o -std=c11
  • gcc compila más lentamente pero a veces genera ejecutables más rápidos
  • gcc-5 establece por defecto -std=gnu11, así que debes seguir especificando una versión estándar c99 o c11.

• -O2, -O3
  • generalmente querrás -O2, pero algunas veces querrás -O3. Prueba tu código con ambos niveles (y entre distintos compiladores) y mantente con los ejecutables más eficientes y rápidos.
• -Os
  • -Os ayuda si te preocupa la eficiencia de la caché (que debería)

• -Wall -Wextra -pedantic
  • las nuevas versiones de los compiladores tienen -Wpedantic, pero todavía aceptan el antiguo -pedantic por cuestiones de compatibilidad.
  • durante las pruebas deberías añadir -Werror y -Wshadow en todas tus plataformas
    • puede ser peliagudo enviar a producción con -Werror porque cada plataforma y cada compilador y cada librería pueden emitir distintas advertencias. Probablemente no querrás terminar la compilación entera de un usuario porque su versión de GCC en una plataforma que nunca habías visto se queja de manera nueva y sorprendente.
  • algunas opciones más sofisticadas son -Wstrict-overflow -fno-strict-aliasing
    • especifica -fno-strict-aliasing o estate seguro de que solo accedes a los objetos con el tipo que tuvieron en su definición. Como mucho código en C ya existente se salta lo último es mucho más seguro usar -fno-strict-aliasing particularmente si no controlas todo el código que debes compilar.
  • ahora mismo, clang reporta alguna sintaxis válida como advertencia, así que debes añadir -Wno-missing-field-initializers
    • GCC resolvió este problema después de GCC 4.7

• Unidades de compilación
  • La manera más común de compilar proyectos en C es generar un fichero objeto de cada fichero fuente y unirlo todos al final. Este procedimiento es muy bueno para el desarrollo incremental, pero no lo es para el rendimiento y la optimización. El compilador no puede detectar optimizaciones entre archivos con este método.
• LTO - Link Time Optimization
  • LTO arregla el problema de las unidades de compilación generando además una representación intermedia que puede ser sujeta de optimizaciones entre archivos. Este sistema ralentiza el tiempo de enlazado significativamente pero make -j puede ayudar.
  • clang LTO (guía)
  • gcc LTO
  • Ahora mismo, 2016, clang y gcc soportan LTO simplemente añadiendo -flto en las opciones tanto de compilación como de enlazado.
  • LTO todavía necesita asentarse. A veces, si tu programa tiene código que no usas directamente pero alguna librería sí, LTO puede borrarlo, porque detecta que en tu código no se hace nunca una llamada a esa función.

• -march=native
  • Le da al compilador permiso para usar todas las características de tu CPU
  • otra vez, compara el funcionamiento con los distintos tipos de optimización y que no tengan efectos secundarios.
• msse2 y -msse4.2 pueden ser útiles si necesitas características que no están disponibles en el sistema desde el que compilas.

Escribiendo código

Tipos

• int8_t, int16_t, int32_t, int64_t - enteros con signo
• uint8_t, uint16_t, uint32_t, uint64_t - enteros sin signo
• float - coma flotante de 32 bits
• double - coma flotante de 64 bits

Una excepción a nunca-char

El signo

long diff = (long)ptrOld - (long)ptrNew;

printf("%p is unaligned by %" PRIuPTR " bytes\",(void *)p, ((uintptr_t)somePtr & (sizeof(void *) - 1)));

Tipos dependientes del sistema

Máxima capacidad

Ese otro tipo

Mostrando tipos

• size_t - %zu
• ssize_t - %zd
• ptrdiff_t - %td
• valor del puntero - %p (muestra el valor en hexadecimanl, haz cast a (void *) primero)
• los tipos de 64 bits deben usar las macros PRIu64 (sin signo) y PRId64 (con signo)
• es imposible especificar un valor correcto multiplataforma sin la ayuda de estas macros
• intptr_t - "%" PRIdPTR
• uintptr_t - "%" PRIuPTR
• intmax_t - "%" PRIdMAX
• uintmax_t - "%" PRIuMAX

printf("Local number: %PRIdPTR\n\n", someIntPtr);

printf("Local number: %" PRIdPTR "\n\n", someIntPtr);

C99 permite declaraciones de variables en cualquier sitio

void test(uint8_t input) {
    uint32_t b;

    if (input > 3) {
        return;
    }

    b = input;
}

C99 permite a los bucles for declarar los contadores en la misma línea

uint32_t i;

    for (i = 0; i < 10; i++)

for (uint32_t i = 0; i < 10; i++)

La mayoría de compiladores soportan #pragma once

#ifndef PROJECT_HEADERNAME
#define PROJECT_HEADERNAME
.
.
.
#endif /* PROJECT_HEADERNAME */

C permite la inicialización estática de arrays ya asignados memoria

uint32_t numbers[64];
    memset(numbers, 0, sizeof(numbers));

uint32_t numbers[64] = {0};

C permite la inicialización estática de structs ya asignados en memoria

struct thing {
        uint64_t index;
        uint32_t counter;
    };

    struct thing localThing;

    void initThing(void) {
        memset(&localThing, 0, sizeof(localThing));
    }

struct thing {
        uint64_t index;
        uint32_t counter;
    };

    static const struct thing localThingNull = {0};
    .
    .
    .
    struct thing localThing = {.counter = 3};
    .
    .
    .
    localThing = localThingNull;

C99 permite arrays de longitud variable (VLA)

uintmax_t arrayLength = strtoumax(argv[1], NULL, 10);
    void *array[];

    array = malloc(sizeof(*array) * arrayLength);

    /* remember to free(array) when you're done using it */

uintmax_t arrayLength = strtoumax(argv[1], NULL, 10);
    void *array[arrayLength];

    /* no need to free array */

C99 permite indicar parámetros de punteros que no se solapan

Tipos de los parámetros

void processAddBytesOverflow(uint8_t *bytes, uint32_t len) {
    for (uint32_t i = 0; i < len; i++) {
        bytes[0] += bytes[i];
    }
}

Parámetros de devolución

void *growthOptional(void *grow, size_t currentLen, size_t newLen) {
    if (newLen > currentLen) {
        void *newGrow = realloc(grow, newLen);
        if (newGrow) {
            /* resize success */
            grow = newGrow;
        } else {
            /* resize failed, free existing and signal failure through NULL */
            free(grow);
            grow = NULL;
        }
    }

    return grow;
}

/* Return value:
 *  - 'true' if newLen > currentLen and attempted to grow
 *    - 'true' does not signify success here, the success is still in '*_grow'
 *  - 'false' if newLen <= currentLen */
bool growthOptional(void **_grow, size_t currentLen, size_t newLen) {
    void *grow = *_grow;
    if (newLen > currentLen) {
        void *newGrow = realloc(grow, newLen);
        if (newGrow) {
            /* resize success */
            *_grow = newGrow;
            return true;
        }

        /* resize failure */
        free(grow);
        *_grow = NULL;

        /* for this function,
         * 'true' doesn't mean success, it means 'attempted grow' */
        return true;
    }

    return false;
}

typedef enum growthResult {
    GROWTH_RESULT_SUCCESS = 1,
    GROWTH_RESULT_FAILURE_GROW_NOT_NECESSARY,
    GROWTH_RESULT_FAILURE_ALLOCATION_FAILED
} growthResult;

growthResult growthOptional(void **_grow, size_t currentLen, size_t newLen) {
    void *grow = *_grow;
    if (newLen > currentLen) {
        void *newGrow = realloc(grow, newLen);
        if (newGrow) {
            /* resize success */
            *_grow = newGrow;
            return GROWTH_RESULT_SUCCESS;
        }

        /* resize failure, don't remove data because we can signal error */
        return GROWTH_RESULT_FAILURE_ALLOCATION_FAILED;
    }

    return GROWTH_RESULT_FAILURE_GROW_NOT_NECESSARY;
}

Formato

#!/usr/bin/env bash

clang-format -style="{BasedOnStyle: llvm, IndentWidth: 4, AllowShortFunctionsOnASingleLine: None, KeepEmptyLinesAtTheStartOfBlocks: false}" "$@"

./script.sh -i *.{c,h,cc,cpp,hpp,cxx} 

#!/usr/bin/env bash

# note: clang-tidy only accepts one file at a time, but we can run it
#       parallel against disjoint collections at once.
find . \( -name \*.c -or -name \*.cpp -or -name \*.cc \) |xargs -n1 -P4 cleanup-tidy

# clang-format accepts multiple files during one run, but let's limit it to 12
# here so we (hopefully) avoid excessive memory usage.
find . \( -name \*.c -or -name \*.cpp -or -name \*.cc -or -name \*.h \) |xargs -n12 -P4 cleanup-format -i

#!/usr/bin/env bash

clang-tidy \
    -fix \
    -fix-errors \
    -header-filter=.* \
    --checks=readability-braces-around-statements,misc-macro-parentheses \
    $1 \
    -- -I.

• readability-braces-around-statements - fuerza a que todos los if/while/for tengan el cuerpo rodeado por llaves.
• ha sido un error que C permitiese las llaves opcionales. Son causa de muchos errores, sobre todo al mantener el código con el tiempo, así que aunque el compilador te lo acepte, no dejes que ocurra.
• misc-macro-parentheses - añade automáticamente paréntesis alrededor de los parámetros usados en una macro.

Legibilidad

Comentarios

Estructura de archivos

Otros detalles

Nunca uses malloc

• calloc sí tiene un impacto en el rendimiento en asignaciones enormes
• calloc sí tiene un impacto en el rendimiento en plataformas extrañas (sistemas empotrados, videoconsolas, hardware de 30 años de antigüedad, …)
• una buena razón para no usar malloc() es que no puede comprobar si hay un desbordamiento y es un potencial fallo de seguridad

• Benchmarking fun with calloc() and zero pages (2007)
• Copy-on-write in virtual memory management

Nunca uses memset (si puedes evitarlo)

Generics en C11

#define probarGenerics(X) _Generic((X), char: 1, int32_t: 2, float: 3, default: 0)

probarGenerics('a') // devolverá 1
probarGenerics(2) // devolverá 2