Primero, aquí es lo que entiendo y pienso lo que es verdad para la pregunta.

Utilice tipos de datos rápidos para variables individuales como contadores ofor Índices de bucle. Por ejemplo:

#define LOOP_COUNT (100U)

uint_fast8_t index;
for(index = 0; index < LOOP_COUNT; index++){
    /* Do something */
}

Supongo que el tipo más adecuado aquí esuint_fast8_t ya queindex nunca puede exceder de 255 y esta será la implementación más rápida para todas las plataformas. Si yo useunsigned int en cambio, será más rápido en plataformas de = = 16 bits, pero será más lento en plataformas de <16 bits comoint es de 16 bits mínimo por estándar. Además, si he usadouint8_t será más lento en plataformas de> 8 bits a medida que el compilador agrega unAND 0xFF instrucciones para verificar el desbordamiento de cada incremento (mi compilador ARM7 lo hace incluso en la optimización a toda velocidad).size_t Tampoco es una opción, ya que puede ser más grande que el tamaño entero nativo.

El lado malo (?) De esto, si se espera un desbordamiento de 8 bits, no va a suceder. El programador debe verificar el desbordamiento manualmente (como debe ser IMHO), lo que puede resultar en un código de buggy si se olvida. Además, el compilador (e incluso PC-Lint para mi sorpresa) no dará ninguna advertencia / problema si LOOP_COUNT se establece "accidentalmente" en un valor mayor a 255 en plataformas de> 8 bits, pero la advertencia se generará en una plataforma de 8 bits. lo que reducirá la portabilidad e introducirá errores, pero esto puede evitarse con#if cheques

Utilice la menor cantidad posible de tipos de datos si el uso de la memoria es preocupante, como en matrices o estructuras. Por ejemplo:

uint_least8_t array[100];

Es la forma más portátil y eficiente de declarar matrices si el uso de la memoria es preocupante. Este tipo proporcionará una matriz de bytes si el acceso de bytes es posible en la plataforma, y ​​de otro modo proporcionará la matriz de enteros de menor ancho accesible. Además, los tipos mínimos se pueden usar en estructuras si tenemos matrices de la estructura.

Los tipos mínimos también pueden sufrir los problemas que los tipos rápidos, ya que el ancho de las variables se puede cambiar en diferentes plataformas para ambos casos.

Evite los tipos de datos de ancho fijo tanto como sea posible, ya que es posible que ni siquiera existan en algunas plataformas, excepto el acceso al registro de hardware, el mapeo de protocolos de comunicación, etc., donde necesitamos conocer los bits exactos de la variable. Por ejemplo:

typedef struct {
    uint8_t  flags;
    uint8_t  length;
    uint8_t  data[100];
    uint16_t crc;
} __attribute__((packed)) package_t;

Generalmente__attribute__((packed)) (o algo similar) debe usarse para asegurar que no se insertará relleno para estos casos, ya que esto puede ser un problema por sí mismo.

Ahora, si mi comprensión es cierta, creo que es menos probable que se utilicen menos tipos de datos en matrices o estructuras, que es más probable que se utilicen tipos de datos rápidos para variables individuales y que es poco probable que se utilicen tipos de datos fijos para alcanzar el máximo Portabilidad y eficiencia. Pero escribir "rápido" y "menos" cada vez no es alentador. Entonces, pienso en un conjunto de tipos como sigue:

    typedef [u]intN_t       os_[u|s]exactN_t;
    typedef [u]int_fastN_t  os_[u|s]N_t;
    /* I couldn't come up with a better name */
    typedef [u]int_leastN_t os_[u|s]minN_t;
    /* These may change */
    typedef uint_least8_t   os_byte_t;
    typedef uint_least16_t  os_word_t;
    /* ... */

Primero y la pregunta importante es, ¿es cierto mi entendimiento?¿Cuál sería la forma más portátil y eficiente de usar los tipos estándar de C99 y cómo los declararía si no fuera cierto?¿Mi conjunto de tipos tiene sentido o es probable que produzca un código con errores?

Además, me complacería saber cómo y dónde se utilizan los tipos estándar de C99.