Ajouter des chiffres d'un entier sans avoir à les convertir à la chaîne?

Est-il un moyen sûr d'ajouter un chiffre à la fin d'un entier sans convertir une chaîne de caractères et sans l'aide de stringstreams ?

J'ai essayé de google la réponse à cela et la plupart des solutions proposées en la convertissant en une chaîne de caractères et l'utilisation de stringstreams mais je tiens à le garder comme un entier pour assurer l'intégrité des données et pour éviter la conversion de types.
J'ai lu aussi une solution qui a suggéré de multiplier les int par 10, et en ajoutant les chiffres, cependant cela peut provoquer un débordement d'entier.
Est-ce sécuritaire de le faire ou est-il une meilleure méthode pour faire cela? Et si je fais cela, multiplier par 10 et ajouter les chiffres de la solution, quelles précautions dois-je prendre?

OriginalL'auteur nmuntz | 2009-05-26

  1. 25

    Votre meilleur pari est la multiplication par 10, et en ajoutant de la valeur. Vous pourriez faire un naïf vérifier comme suit:

    assert(digit >= 0 && digit < 10);
newValue = (oldValue * 10) + digit;
if (newValue < oldValue)
{
    //overflow
}
    Le dépassement de vérifier qui est faux. Par exemple, 4772185889 - 2^32 = 477218593, qui est plus grand que 477218588.
    Je suis d'accord, je l'ai lié à l'endroit où vous pouvez obtenir un moins naïve de la mise en œuvre.
    J'ai mis dans une réponse plus tard qui a très vite dépassement de vérifier cela fonctionne toujours.

    OriginalL'auteur user7116

  2. 3

    À empêcher le débordement:

    if ((0 <= value) && (value <= ((MAX_INT - 9) / 10))) {
    return (value * 10) + digit;
}

    En place de MAX_INT, vous pouvez utiliser std::numeric_limits<typeof(value)>::max() ou similaire, à l'appui de types autres que les int.

    OriginalL'auteur Steve Jessop

  3. 2
     assert(nombre >= 0 && chiffres < 10); 
newvalue = 10 * oldvalue; 
si (oldvalue < 0 ) { 
newvalue -= chiffres; 
} else { 
newvalue += chiffres; 
} 

//vérification de débordement SGN(oldvalue) == 0 || SGN(newvalue) == SGN(oldvalue)

    OriginalL'auteur Jim

  4. 2

    Ici est une meilleure et plus l'épreuve des balles de mise en œuvre de celui qui a été accepté comme une réponse aussi rapide:

    #include <climits>
#include <cassert>

unsigned int add_digit(unsigned int val, unsigned int digit)
{
   //These should be computed at compile time and never even be given a memory location
   static const unsigned int max_no_overflow = (UINT_MAX - 9) / 10U;
   static const unsigned int max_maybe_overflow = UINT_MAX / 10U;
   static const unsigned int last_digit = UINT_MAX % 10;

   assert(digit >= 0 && digit < 10);
   if ((val > max_no_overflow) && ((val > max_maybe_overflow) || (digit > last_digit))) {
      //handle overflow
   } else {
      return val * 10 + digit;
   }
   assert(false);
}

    Vous devez aussi être capable de faire cela dans une fonction inline. Le dépassement de vérifier presque toujours de court-circuit après la première comparaison. La clause après la && est tout simplement de sorte que vous pouvez (dans le cas d'un 32 bits en complément à deux nombre entier) ajouter 5 à la fin de 429496729, mais pas 6.

    OriginalL'auteur Omnifarious