¿Por qué se preferiría uint32_t en lugar de uint_fast32_t?

Parece que uint32_tes mucho más frecuente que uint_fast32_t(me doy cuenta de que esto es una evidencia anecdótica). Sin embargo, eso me parece contrario a la intuición.

Casi siempre, cuando veo el uso de una implementación uint32_t, todo lo que realmente quiere es un número entero que pueda contener valores de hasta 4.294.967.295 (generalmente un límite mucho más bajo en algún lugar entre 65.535 y 4.294.967.295).

Parece extraño usarlo luego uint32_t, ya que la garantía de 'exactamente 32 bits' no es necesaria, y la garantía de 'más rápido disponible> = 32 bits'uint_fast32_t parece ser exactamente la idea correcta. Además, aunque generalmente se implementa, en uint32_trealidad no se garantiza que exista.

Entonces, ¿por qué uint32_tse preferiría? ¿Es simplemente más conocido o existen ventajas técnicas sobre el otro?

uint32_tse garantiza que tendrá casi las mismas propiedades en cualquier plataforma que lo admita. ¹

uint_fast32_t tiene muy pocas garantías sobre cómo se comporta en diferentes sistemas en comparación.

Si cambia a una plataforma que uint_fast32_ttiene un tamaño diferente, todo el código que se utiliza uint_fast32_tdebe volver a probarse y validarse. Todos los supuestos de estabilidad se perderán. Todo el sistema funcionará de manera diferente.

Al escribir su código, es posible que ni siquiera tenga acceso a un uint_fast32_tsistema que no tenga un tamaño de 32 bits.

uint32_t no funcionará de manera diferente (ver nota al pie).

La corrección es más importante que la velocidad. Por tanto, la corrección prematura es un plan mejor que la optimización prematura.

En el caso de que estuviera escribiendo código para sistemas con uint_fast32_t64 bits o más, podría probar mi código para ambos casos y usarlo. Salvo necesidad y oportunidad, hacerlo es un mal plan.

Finalmente, uint_fast32_tcuando lo está almacenando durante cualquier período de tiempo o número de instancias, puede ser más lento que uint32simplemente debido a problemas de tamaño de caché y ancho de banda de memoria. Las computadoras de hoy están mucho más ligadas a la memoria que a la CPU, y uint_fast32_tpodrían ser más rápidas de forma aislada, pero no después de tener en cuenta la sobrecarga de la memoria.

¹ Como @chux ha señalado en un comentario, si unsignedes mayor que uint32_t, la aritmética activa uint32_tpasa por las promociones habituales de enteros, y si no, permanece como uint32_t. Esto puede provocar errores. Nada es perfecto.

¿Por qué mucha gente usa en uint32_tlugar de uint32_fast_t?

Nota: El nombre incorrecto uint32_fast_tdebería ser uint_fast32_t.

uint32_ttiene una especificación más estricta uint_fast32_ty, por lo tanto, ofrece una funcionalidad más consistente.

uint32_t pros:

• Varios algoritmos especifican este tipo. En mi opinión, la mejor razón para usar.
• Ancho y rango exactos conocidos.
• Las matrices de este tipo no generan desperdicio.
• La matemática de enteros sin signo con su desbordamiento es más predecible.
• Coincidencia más cercana en rango y matemáticas de los tipos de 32 bits de otros idiomas.
• Nunca acolchado.

uint32_t contras:

• No siempre está disponible (sin embargo, esto es raro en 2018).
  Ej: Plataformas que carecen de 8/16 números enteros / 32 bits (9/18/ 36 -bit, otros ).
  Ej .: Plataformas que utilizan un complemento distinto de 2. viejo 2200

uint_fast32_t pros:

• Siempre disponible.
  Esto siempre permite que todas las plataformas, nuevas y antiguas, utilicen tipos rápidos / mínimos.
• Tipo "más rápido" que admite el rango de 32 bits.

uint_fast32_t contras:

• El alcance se conoce sólo mínimamente. Por ejemplo, podría ser un tipo de 64 bits.
• Las matrices de este tipo pueden desperdiciar memoria.
• Todas las respuestas (la mía también al principio), la publicación y los comentarios usaron el nombre incorrecto uint32_fast_t. Parece que muchos simplemente no necesitan ni usan este tipo. ¡Ni siquiera usamos el nombre correcto!
• Acolchado posible - (raro).
• En casos seleccionados, el tipo "más rápido" puede ser realmente otro tipo. Entonces uint_fast32_tes solo una aproximación de primer orden.

Al final, lo que es mejor depende del objetivo de codificación. A menos que se codifique para una portabilidad muy amplia o alguna función de rendimiento mejorada, utilice uint32_t.

Hay otro problema al usar estos tipos que entra en juego: su rango en comparación con int/unsigned

Presumiblemente uint_fastN_tpodría ser el rango de unsigned. Esto no está especificado, pero es una condición cierta y comprobable.

Por lo tanto, uintN_tes más probable que uint_fastN_tsea ​​más estrecho el unsigned. Esto significa que uintN_tes más probable que el código que usa matemáticas esté sujeto a promociones de números enteros que uint_fastN_tcuando se trata de portabilidad.

Con esta preocupación: ventaja de portabilidad uint_fastN_tcon operaciones matemáticas seleccionadas.

Nota al margen sobre en int32_tlugar de int_fast32_t: en máquinas raras, INT_FAST32_MINpuede ser -2,147,483,647 y no -2,147,483,648. El punto más importante: los (u)intN_ttipos están estrictamente especificados y conducen a un código portátil.

¿Por qué mucha gente usa en uint32_tlugar de uint32_fast_t?

Respuesta tonta:

• No existe un tipo estándar uint32_fast_t, la ortografía correcta es uint_fast32_t.

Respuesta práctica:

• Mucha gente realmente usa uint32_toint32_t para su semántica precisa, exactamente 32 bits con aritmética envolvente sin firmar ( uint32_t) o representación de complemento a 2 ( int32_t). Los xxx_fast32_ttipos pueden ser más grandes y, por lo tanto, inapropiados para almacenar en archivos binarios, usar en matrices y estructuras empaquetadas o enviar a través de una red. Además, es posible que ni siquiera sean más rápidos.

Respuesta pragmática:

• Mucha gente simplemente no sabe (o simplemente no les importa) uint_fast32_t , como se demuestra en los comentarios y respuestas, y probablemente asumen que es simple unsigned inttener la misma semántica, aunque muchas arquitecturas actuales todavía tienen 16 bits inty algunas muestras raras de Museum tienen otros tamaños de int extraños menores de 32.

Respuesta de UX:

• Aunque posiblemente más rápido que uint32_t, uint_fast32_tes más lento de usar: lleva más tiempo escribir, especialmente teniendo en cuenta la búsqueda de ortografía y semántica en la documentación de C ;-)

La elegancia importa, (obviamente basada en opiniones):

• uint32_tSe ve lo suficientemente mal como para que muchos programadores prefieran definir el suyo propio u32o el uint32tipo ... Desde esta perspectiva, uint_fast32_tparece torpe más allá de la reparación. No es de extrañar que se sienta en el banco con sus amigos uint_least32_ty demás.

Una razón es que unsigned intya es "más rápido" sin la necesidad de ningún typedefs especial o la necesidad de incluir algo. Entonces, si lo necesita rápido, simplemente use el fundamental into el unsigned inttipo.
Si bien el estándar no garantiza explícitamente que sea más rápido, indirectamente lo hace indicando "Los enteros simples tienen el tamaño natural sugerido por la arquitectura del entorno de ejecución" en 3.9.1. En otras palabras, int(o su contraparte sin firmar) es con lo que el procesador se siente más cómodo.

Ahora, por supuesto, no sabes qué tamaño unsigned intpodría ser. Solo sabes que es al menos tan grande como short(y creo recordar que shortdebe tener al menos 16 bits, ¡aunque ahora no puedo encontrar eso en el estándar!). Por lo general, son simplemente 4 bytes, pero en teoría podría ser más grande o, en casos extremos, incluso más pequeño ( aunque personalmente nunca me he encontrado con una arquitectura en la que este fuera el caso, ni siquiera en computadoras de 8 bits en la década de 1980. ... tal vez algunos microcontroladores, quién sabe resulta que sufro de demencia, intera muy claramente de 16 bits en ese entonces).

El estándar C ++ no se molesta en especificar cuáles son los <cstdint>tipos o qué garantizan, simplemente menciona "lo mismo que en C".

uint32_t, según el estándar C, garantiza que obtiene exactamente 32 bits. Nada diferente, nada menos y nada de relleno. A veces, esto es exactamente lo que necesita y, por lo tanto, es muy valioso.

uint_least32_tgarantiza que sea cual sea el tamaño, no puede ser menor de 32 bits (pero muy bien podría ser mayor). A veces, pero mucho más raramente que un witdh exacto o "no me importa", esto es lo que quieres.

Por último, uint_fast32_tes algo superfluo en mi opinión, excepto para propósitos de documentación de intención. El estándar C dice "designa un tipo de entero que suele ser el más rápido" (tenga en cuenta la palabra "normalmente") y menciona explícitamente que no es necesario que sea el más rápido para todos los propósitos. En otras palabras, uint_fast32_tes casi lo mismo que uint_least32_t, que también suele ser el más rápido, solo que sin garantía (pero no garantía de ninguna manera).

Dado que la mayoría de las veces no te importa el tamaño exacto o quieres exactamente 32 (o 64, a veces 16) bits, y dado que el tipo "no importa" unsigned intes el más rápido de todos modos, esto explica por qué uint_fast32_tno es así. usado frecuentemente.

No he visto evidencia que uint32_tse utilice para su rango. En cambio, la mayoría de las veces que he visto uint32_tse usa para contener exactamente 4 octetos de datos en varios algoritmos, ¡con semántica de cambio y envolvente garantizada!

También hay otras razones para usar en uint32_tlugar de uint_fast32_t: A menudo es que proporcionará ABI estable. Además, el uso de la memoria se puede conocer con precisión. Esto contrarresta en gran medida lo que sea la ganancia de velocidad uint_fast32_t, siempre que ese tipo sea distinto del de uint32_t.

Para valores <65536, ya existe un tipo útil, se llama unsigned int( unsigned shortse requiere que tenga al menos ese rango también, pero unsigned intes del tamaño de palabra nativa) Para valores <4294967296, hay otro llamado unsigned long.

Y, por último, la gente no lo usa uint_fast32_tporque es muy largo de escribir y fácil de escribir mal: D

Muchas rasones.

1. Mucha gente no sabe que existen los tipos "rápidos".
2. Es más detallado escribir.
3. Es más difícil razonar sobre el comportamiento de sus programas cuando no conoce el tamaño real del tipo.
4. En realidad, el estándar no determina el más rápido, ni tampoco qué tipo es realmente más rápido puede depender mucho del contexto.
5. No he visto evidencia de que los desarrolladores de plataformas hayan pensado en el tamaño de estos tipos al definir sus plataformas. Por ejemplo, en Linux x86-64, los tipos "rápidos" son todos de 64 bits, aunque x86-64 tiene soporte de hardware para operaciones rápidas en valores de 32 bits.

En resumen, los tipos "rápidos" son basura sin valor. Si realmente necesita averiguar qué tipo es más rápido para una aplicación determinada, necesita comparar su código en su compilador.

Desde el punto de vista de la corrección y la facilidad de codificación, uint32_ttiene muchas ventajas sobreuint_fast32_t en particular, debido al tamaño definido con mayor precisión y la semántica aritmética, como muchos usuarios han señalado anteriormente.

Lo que quizás se ha pasado por alto es la supuesta ventaja de uint_fast32_tque puede ser más rápido , pero nunca se materializó de manera significativa. La mayoría de los procesadores de 64 bits que han dominado la era de los 64 bits (x86-64 y Aarch64 en su mayoría) evolucionaron a partir de arquitecturas de 32 bits y tienen operaciones nativas rápidas de 32 bits incluso en el modo de 64 bits. Así que uint_fast32_tes lo mismo que uint32_ten esas plataformas.

Incluso si algunas de las plataformas "también ejecutadas" como POWER, MIPS64, SPARC solo ofrecen operaciones ALU de 64 bits, la gran mayoría de las operaciones interesantes de 32 bits se pueden realizar sin problemas en registros de 64 bits: los de 32 bits inferiores lo harán tener los resultados deseados (y todas las plataformas principales al menos le permiten cargar / almacenar 32 bits). El desplazamiento a la izquierda es el principal problema, pero incluso eso se puede optimizar en muchos casos mediante optimizaciones de seguimiento de valor / rango en el compilador.

Dudo que el desplazamiento a la izquierda ocasionalmente un poco más lento o la multiplicación 32x32 -> 64 supere el doble del uso de memoria para tales valores, en todas las aplicaciones excepto en las más oscuras.

Finalmente, señalaré que si bien la compensación se ha caracterizado en gran medida como "uso de memoria y potencial de vectorización" (a favor de uint32_t) versus recuento / velocidad de instrucciones (a favor de uint_fast32_t), incluso eso no me queda claro. Sí, en algunas plataformas necesitará instrucciones adicionales para algunas operaciones de 32 bits, pero también guardará algunas instrucciones porque:

• El uso de un tipo más pequeño a menudo permite al compilador combinar inteligentemente operaciones adyacentes usando una operación de 64 bits para lograr dos operaciones de 32 bits. Un ejemplo de este tipo de "vectorización del pobre" no es infrecuente. Por ejemplo, la creación de una constante struct two32{ uint32_t a, b; }en me raxgusta two32{1, 2} se puede optimizar en una sola, mov rax, 0x20001mientras que la versión de 64 bits necesita dos instrucciones. En principio, esto también debería ser posible para operaciones aritméticas adyacentes (misma operación, diferente operando), pero no lo he visto en la práctica.
• Un menor "uso de memoria" a menudo conduce a menos instrucciones, incluso si la memoria o la huella de caché no son un problema, debido a que se copia cualquier estructura de tipo o matrices de este tipo, se obtiene el doble de rentabilidad por cada registro copiado.

• Los tipos de datos más pequeños a menudo aprovechan mejores convenciones de llamadas modernas como SysV ABI, que empaquetan datos de estructura de datos de manera eficiente en registros. Por ejemplo, puede devolver una estructura de hasta 16 bytes en los registros rdx:rax. Para una función que devuelve una estructura con 4 uint32_tvalores (inicializada a partir de una constante), eso se traduce en

  ret_constant32():
      movabs  rax, 8589934593
      movabs  rdx, 17179869187
      ret
  

  La misma estructura con 4 64 bits uint_fast32_tnecesita un movimiento de registro y cuatro tiendas en la memoria para hacer lo mismo (y la persona que llama probablemente tendrá que leer los valores de la memoria después de la devolución):

  ret_constant64():
      mov     rax, rdi
      mov     QWORD PTR [rdi], 1
      mov     QWORD PTR [rdi+8], 2
      mov     QWORD PTR [rdi+16], 3
      mov     QWORD PTR [rdi+24], 4
      ret
  

  De manera similar, al pasar argumentos de estructura, los valores de 32 bits se empaquetan aproximadamente el doble de densamente en los registros disponibles para los parámetros, por lo que es menos probable que se quede sin argumentos de registro y tenga que pasar a la pila ¹ .

• Incluso si elige usarlo uint_fast32_tpara lugares donde "la velocidad importa", a menudo también tendrá lugares donde necesite un tipo de tamaño fijo. Por ejemplo, al pasar valores para salida externa, de entrada externa, como parte de su ABI, como parte de una estructura que necesita un diseño específico, o porque usa inteligentemente uint32_tpara grandes agregaciones de valores para ahorrar espacio en la memoria. En los lugares donde sus uint_fast32_ttipos y `` uint32_t` necesitan interactuar, puede encontrar (además de la complejidad del desarrollo), extensiones de signos innecesarias u otro código relacionado con la discrepancia de tamaño. Los compiladores hacen un buen trabajo optimizando esto en muchos casos, pero aún no es inusual ver esto en la salida optimizada cuando se mezclan tipos de diferentes tamaños.

Puedes jugar con algunos de los ejemplos anteriores y más en godbolt .

¹ Para ser claros, la convención de empaquetar estructuras de manera ajustada en registros no siempre es una clara ventaja para valores más pequeños. Significa que es posible que los valores más pequeños tengan que "extraerse" antes de que puedan utilizarse. Por ejemplo, una función simple que devuelve la suma de los dos miembros de la estructura juntos necesita un mov rax, rdi; shr rax, 32; add edi, eaxtiempo para la versión de 64 bits, cada argumento obtiene su propio registro y solo necesita un solo addo lea. Aún así, si acepta que el diseño de "empaquetar las estructuras firmemente al pasar" tiene sentido en general, los valores más pequeños aprovecharán más esta característica.

A efectos prácticos, uint_fast32_tes completamente inútil. Está definido incorrectamente en la plataforma más extendida (x86_64) y realmente no ofrece ninguna ventaja en ningún lugar a menos que tenga un compilador de muy baja calidad. Conceptualmente, nunca tiene sentido utilizar los tipos "rápidos" en estructuras / matrices de datos: cualquier ahorro que obtenga del tipo que es más eficiente para operar será eclipsado por el costo (pérdidas de caché, etc.) de aumentar el tamaño de su conjunto de datos de trabajo. Y para las variables locales individuales (contadores de bucles, temporales, etc.), un compilador que no sea de juguete generalmente puede trabajar con un tipo más grande en el código generado si eso es más eficiente, y solo truncar al tamaño nominal cuando sea necesario para la corrección (y con tipos firmados, nunca es necesario).

La única variante que es teóricamente útil es uint_least32_t, para cuando necesita poder almacenar cualquier valor de 32 bits, pero quiere ser portátil a máquinas que carecen de un tipo de tamaño exacto de 32 bits. Prácticamente, hablando, sin embargo, eso no es algo de lo que deba preocuparse.

Según tengo entendido, intinicialmente se suponía que era un tipo entero "nativo" con una garantía adicional de que debería tener al menos 16 bits de tamaño, algo que se consideraba un tamaño "razonable" en ese entonces.

Cuando las plataformas de 32 bits se volvieron más comunes, podemos decir que el tamaño "razonable" ha cambiado a 32 bits:

• Windows moderno usa 32 bits inten todas las plataformas.
• POSIX garantiza que intsea ​​de al menos 32 bits.
• C #, Java tiene un tipo intque se garantiza que sea exactamente de 32 bits.

Pero cuando la plataforma de 64 bits se convirtió en la norma, nadie se expandió intpara convertirse en un entero de 64 bits debido a:

• Portabilidad: mucho código depende de inttener un tamaño de 32 bits.
• Consumo de memoria: duplicar el uso de memoria para cada uno intpuede no ser razonable en la mayoría de los casos, ya que en la mayoría de los casos las cifras en uso son mucho menores que 2 mil millones.

Ahora, ¿por qué preferirías uint32_thacerlo uint_fast32_t? Por la misma razón, los lenguajes, C # y Java siempre usan números enteros de tamaño fijo: el programador no escribe código pensando en tamaños posibles de diferentes tipos, escribe para una plataforma y prueba el código en esa plataforma. La mayor parte del código depende implícitamente de tamaños específicos de tipos de datos. Y es por eso que uint32_tes una mejor opción para la mayoría de los casos: no permite ninguna ambigüedad con respecto a su comportamiento.

Además, ¿es uint_fast32_trealmente el tipo más rápido en una plataforma con un tamaño igual o superior a 32 bits? Realmente no. Considere este compilador de código de GCC para x86_64 en Windows:

extern uint64_t get(void);

uint64_t sum(uint64_t value)
{
    return value + get();
}

El ensamblado generado se ve así:

push   %rbx
sub    $0x20,%rsp
mov    %rcx,%rbx
callq  d <sum+0xd>
add    %rbx,%rax
add    $0x20,%rsp
pop    %rbx
retq

Ahora, si cambia get()el valor de retorno a uint_fast32_t(que es 4 bytes en Windows x86_64) obtendrá esto:

push   %rbx
sub    $0x20,%rsp
mov    %rcx,%rbx
callq  d <sum+0xd>
mov    %eax,%eax        ; <-- additional instruction
add    %rbx,%rax
add    $0x20,%rsp
pop    %rbx
retq

Observe cómo el código generado es casi el mismo excepto por una mov %eax,%eaxinstrucción adicional después de la llamada a la función que está destinada a expandir el valor de 32 bits en un valor de 64 bits.

No existe tal problema si solo usa valores de 32 bits, pero probablemente usará aquellos con size_tvariables (¿tamaños de matriz probablemente?) Y esos son de 64 bits en x86_64. En Linux uint_fast32_tes de 8 bytes, por lo que la situación es diferente.

Muchos programadores usan intcuando necesitan devolver un valor pequeño (digamos en el rango [-32,32]). Esto funcionaría perfectamente si intfuera un tamaño entero nativo de la plataforma, pero como no está en plataformas de 64 bits, otro tipo que coincida con el tipo nativo de la plataforma es una mejor opción (a menos que se use con frecuencia con otros enteros de menor tamaño).

Básicamente, independientemente de lo que diga el estándar, de uint_fast32_ttodos modos está roto en algunas implementaciones. Si le preocupa la instrucción adicional generada en algunos lugares, debe definir su propio tipo de entero "nativo". O puede usarlo size_tpara este propósito, ya que generalmente coincidirá con el nativetamaño (no estoy incluyendo plataformas antiguas y oscuras como 8086, solo plataformas que pueden ejecutar Windows, Linux, etc.).

Otro signo que muestra que intse suponía que era un tipo entero nativo es "regla de promoción de enteros". La mayoría de las CPU solo pueden realizar operaciones en modo nativo, por lo que la CPU de 32 bits generalmente solo puede hacer sumas, restas, etc. de 32 bits (las CPU Intel son una excepción aquí). Los tipos enteros de otros tamaños solo se admiten mediante instrucciones de carga y almacenamiento. Por ejemplo, el valor de 8 bits debe cargarse con la instrucción apropiada "cargar 8 bits con signo" o "cargar 8 bits sin signo" y expandirá el valor a 32 bits después de la carga. Sin la regla de promoción de enteros, los compiladores C tendrían que agregar un poco más de código para las expresiones que usan tipos más pequeños que el tipo nativo. Desafortunadamente, esto ya no es válido con arquitecturas de 64 bits, ya que los compiladores ahora tienen que emitir instrucciones adicionales en algunos casos (como se mostró arriba).

En muchos casos, cuando un algoritmo funciona con una matriz de datos, la mejor forma de mejorar el rendimiento es minimizar el número de pérdidas de caché. Cuanto más pequeño sea cada elemento, más de ellos pueden caber en el caché. Esta es la razón por la que todavía se escribe mucho código para usar punteros de 32 bits en máquinas de 64 bits: no necesitan nada cercano a 4 GiB de datos, pero el costo de hacer todos los punteros y compensaciones necesita ocho bytes en lugar de cuatro. sería sustancial.

También hay algunas ABI y protocolos especificados para necesitar exactamente 32 bits, por ejemplo, direcciones IPv4. Eso es lo que uint32_trealmente significa: use exactamente 32 bits, independientemente de si eso es eficiente en la CPU o no. Estos solían declararse como longo unsigned long, lo que causó muchos problemas durante la transición de 64 bits. Si solo necesita un tipo sin signo que contenga números hasta al menos 2³²-1, esa ha sido la definición de unsigned longdesde que salió el primer estándar C. En la práctica, sin embargo, se asumió que un código antiguo longpodría contener cualquier puntero o desplazamiento de archivo o marca de tiempo, y se asumió que el código antiguo tenía exactamente 32 bits de ancho, por lo que los compiladores no necesariamente pueden hacer longlo mismo int_fast32_tsin romper demasiadas cosas.

En teoría, sería más apto para el futuro que un programa lo use uint_least32_t, y tal vez incluso cargar uint_least32_telementos en una uint_fast32_tvariable para los cálculos. ¡Una implementación que no tuviera ningún uint32_ttipo podría incluso declararse en conformidad formal con la norma! (Simplemente no sería capaz de compilar muchos programas existentes.) En la práctica, no hay arquitectura ya dónde int, uint32_ty uint_least32_tno son los mismos, y ninguna ventaja, actualmente , a la realización de uint_fast32_t. Entonces, ¿por qué complicar demasiado las cosas?

Sin embargo, mire la razón por la que todos los 32_ttipos debían existir cuando ya lo teníamos long, y verá que esas suposiciones han estallado en nuestras caras antes. Es posible que su código termine ejecutándose algún día en una máquina donde los cálculos de 32 bits de ancho exacto son más lentos que el tamaño de la palabra nativa, y hubiera sido mejor usarlo uint_least32_tpara almacenamiento y uint_fast32_tcálculo religiosamente. O si cruzas ese puente cuando llegas y solo quieres algo simple, ahí está unsigned long.

Para dar una respuesta directa: creo que la verdadera razón por la que uint32_tse usa over uint_fast32_to uint_least32_tes simplemente que es más fácil de escribir y, debido a que es más corto, mucho más agradable de leer: si crea estructuras con algunos tipos, y algunos de ellos son uint_fast32_to similar, entonces a menudo es difícil alinearlos bien con intu boolotros tipos en C, que son bastante cortos (caso en cuestión: charvs. character). Por supuesto, no puedo respaldar esto con datos duros, pero las otras respuestas solo pueden adivinar la razón también.

En cuanto a razones técnicas para preferir uint32_t, no creo que las haya; cuando sea absolutamente necesario un int sin firmar exacto de 32 bits, entonces este tipo es su única opción estandarizada. En casi todos los demás casos, las otras variantes son técnicamente preferibles, específicamente, uint_fast32_tsi le preocupa la velocidad y uint_least32_tsi le preocupa el espacio de almacenamiento. El uso uint32_ten cualquiera de estos casos corre el riesgo de no poder compilar, ya que no se requiere que exista el tipo.

En la práctica, los uint32_ttipos y relacionados existen en todas las plataformas actuales, excepto algunos DSP muy raros (hoy en día) o implementaciones de broma, por lo que existe poco riesgo real al usar el tipo exacto. Del mismo modo, si bien puede encontrarse con penalizaciones de velocidad con los tipos de ancho fijo, ya no son (en las CPU modernas) paralizantes.

Por eso, creo, el tipo más corto simplemente gana en la mayoría de los casos, debido a la pereza del programador.