Quelle est la bonne façon de mettre en œuvre une bonne "iTOA ()"?

Un bon int code> à string em> ou itoa () code> a ces propriétés;

• fonctionne pour tous [int_min ... int_max] code>, base [2 ... 36] code> sans débordement de tampon. LI>
• n'assume pas int code>. li>
• ne nécessite pas de complément de 2. li>
• ne nécessite pas non signé code> pour avoir une plus grande plage positive que int code>. En d'autres termes, n'utilise pas non signé code>. li>
• permet l'utilisation de '-' code> pour des nombres négatifs, même lorsque base! = 10 code>. li>. ul>

  adapter le traitement des erreurs au besoin. (besoin C99 ou plus tard): P>

  char* itostr(char *dest, size_t size, int a, int base) {
    // Max text needs occur with itostr(dest, size, INT_MIN, 2)
    char buffer[sizeof a * CHAR_BIT + 1 + 1]; 
    static const char digits[36] = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ";
  
    if (base < 2 || base > 36) {
      fprintf(stderr, "Invalid base");
      return NULL;
    }
  
    // Start filling from the end
    char* p = &buffer[sizeof buffer - 1];
    *p = '\0';
  
    // Work with negative `int`
    int an = a < 0 ? a : -a;  
  
    do {
      *(--p) = digits[-(an % base)];
      an /= base;
    } while (an);
  
    if (a < 0) {
      *(--p) = '-';
    }
  
    size_t size_used = &buffer[sizeof(buffer)] - p;
    if (size_used > size) {
      fprintf(stderr, "Scant buffer %zu > %zu", size_used , size);
      return NULL;
    }
    return memcpy(dest, p, size_used);
  }
  

sprintf est assez lent, si la performance compte, ce n'est probablement pas la meilleure solution.

Si l'argument de base est une puissance de 2 la conversion peut être effectuée avec un décalage et un masquage, et on peut éviter d'inverser la chaîne par enregistrer les chiffres des positions les plus élevées. Par exemple, quelque chose comme ceci pour la base = 16 p> xxx pré>

Const chiffre chiffre [] = {'0', '1', '2', '3', '4', '4' ',' 5 ',' 6 ',' 7 ',' 8 ',' 9 ',' 9 ',' A ',' B ',' B ',' C ',' E ',' E ',' F '}; P >

/* skip zeros in the highest positions */
int i = num_iter;
for (; i >= 0; i--)
{
    int digit = (value >> (bits_per_digit*i)) & 15;
    if ( digit > 0 )  break;
}

for (; i >= 0; i--)
{
    int digit = (value >> (bits_per_digit*i)) & 15;
    result[len++] = digits[digit];
}

• INTEGER-TO-ASCII doit convertir les données d'un type d'entier standard dans une chaîne ASCII. LI>
• Toutes les opérations doivent être effectuées à l'aide de l'indexation arithmétique du pointeur, pas d'une indexation de tableau. LI>
• Le nombre que vous souhaitez convertir est transmis comme un entier 32 bits signé. li>
• Vous devriez pouvoir prendre en charge les bases 2 à 16 en spécifiant la valeur entière de la base que vous souhaitez convertir en (base). li>
• Copiez la chaîne de caractères convertie sur le pointeur UINT8_T * transmis sous forme de paramètre (PTR). LI>
• Le numéro 32 bits signé aura une taille de chaîne maximale (indice: Think Base 2). Li>
• Vous devez placer un terminateur null à la fin de la fonction C-String convertie doit renvoyer la longueur des données converties (y compris un signe négatif). li>
• Exemple My_itoa (PTR, 1234, 10) doit renvoyer une longueur de chaîne ASCII de 5 (y compris le terminateur NULL). li>
• Cette fonction doit gérer les données signées. LI>
• Vous ne pouvez pas utiliser de fonctions de chaîne ou de bibliothèques. LI>

  . P>

  int32_t my_atoi(uint8_t *ptr, uint8_t digits, uint32_t base){
      int32_t sgnd=0, rslt=0;
      for(int i=0; i<digits; i++){
          if(*(ptr)=='-'){*ptr='0';sgnd=1;}
          else if(*(ptr+i)>'9'){rslt+=(*(ptr+i)-'7');}
          else{rslt+=(*(ptr+i)-'0');}
          if(!*(ptr+i+1)){break;}
          rslt*=base;
      }
      if(sgnd){rslt=-rslt;}
      return rslt;
  }
  

  • ASCII-TO-INTEGER doit convertir les données d'une chaîne représentée par ASCII en un type entier. LI>
  • Toutes les opérations doivent être effectuées à l'aide de pointeur arithmétique, pas d'indexation de tableau li>
  • La chaîne de caractères à convertir est transmise sous la forme d'un pointeur UINT8_T * (PTR). LI>
  • Le nombre de chiffres de votre jeu de caractères est transmis en tant qu'integer UINT8_T (chiffres). LI>
  • Vous devriez être capable de prendre en charge les bases 2 à 16. li>
  • L'entier converti 32 bits signé doit être retourné. LI>
  • Cette fonction doit gérer les données signées. LI>
  • Vous ne pouvez pas utiliser de fonctions de chaîne ou de bibliothèques. LI> ul>

    . p> xxx pré> ul>