Quel est le meilleur moyen C++ de multiplier les entiers non signés de manière modulaire en toute sécurité?

Imaginons que vous êtes à l'aide de <cstdint> et les types comme std::uint8_t et std::uint16_t, et souhaitez effectuer des opérations comme += et *= sur eux. Vous souhaitez que l'arithmétique sur ces nombres s'enroule de manière modulaire, comme typique en C/C++. Ce travaille normalement, et vous trouver expérimentalement fonctionne avec std::uint8_t, std::uint32_t et std::uint64_t, mais pas std::uint16_t.

Plus précisément, la multiplication avec std::uint16_t échoue parfois de manière spectaculaire, avec des builds optimisés produisant toutes sortes de résultats étranges. La raison? Indéterminé comportement dû au dépassement d'entier signé. Le compilateur optimise en fonction de l'hypothèse que le comportement indéfini ne se produit pas, et commence ainsi à élaguer des morceaux de code de votre programme. Le comportement indéfini spécifique est le suivant:

std::uint16_t x = UINT16_C(0xFFFF);
x *= x;

La raison en est les règles de promotion de C++et le fait que vous, comme presque tout le monde ces jours-ci, utilisez une plate-forme sur laquelle std::numeric_limits<int>::digits == 31. C'est-à-dire que int est 32 bits (digits compte les bits mais pas le bit de signe). {[16] } est promu à signed int, bien qu'il ne soit pas signé, et 0xFFFF * 0xFFFF déborde pour l'arithmétique signée 32 bits.

Démo du problème général:

// Compile on a recent version of clang and run it:
// clang++ -std=c++11 -O3 -Wall -fsanitize=undefined stdint16.cpp -o stdint16

#include <cinttypes>
#include <cstdint>
#include <cstdio>

int main()
{
     std::uint8_t a =  UINT8_MAX; a *= a; // OK
    std::uint16_t b = UINT16_MAX; b *= b; // undefined!
    std::uint32_t c = UINT32_MAX; c *= c; // OK
    std::uint64_t d = UINT64_MAX; d *= d; // OK

    std::printf("%02" PRIX8 " %04" PRIX16 " %08" PRIX32 " %016" PRIX64 "n",
        a, b, c, d);

    return 0;
}

Vous obtiendrez une belle erreur:

main.cpp:11:55: runtime error: signed integer overflow: 65535 * 65535
    cannot be represented in type 'int'

La façon d'éviter cela, bien sûr, est de lancer au moins unsigned int avant de multiplier. Seul le cas exact où le nombre de bits du type non signé est exactement égal à la moitié du nombre de bits de int est problématique. Tout plus petit entraînerait l'incapacité de la multiplication à déborder, comme avec std::uint8_t; tout plus grand entraînerait le mappage exact du type à l'un des rangs de promotion, comme avec std::uint64_t matching unsigned long ou unsigned long long selon la plate-forme.

Mais cela craint vraiment: il faut savoir quel type est problématique en fonction de la taille de int sur la plate-forme actuelle. Existe-t-il un meilleur moyen d'éviter un comportement indéfini avec une multiplication d'entiers non signés sans les labyrinthes #if?