Impression de plusieurs entiers sous la forme d’une chaîne décimale arbitrairement longue

Disons que j’ai 16 entiers non signés 64 bits. J’ai pris soin d’alimenter le support de manière appropriée entre eux lors de l’exécution d’opérations. Pourrais-je les alimenter dans une méthode pour les convertir en une seule chaîne de chiffres décimaux, comme s’il s’agissait d’un nombre binary de 1024 bits? En d’autres termes, est-il possible de créer une méthode qui fonctionnera pour un nombre arbitraire d’entiers représentant un entier plus grand?

J’imagine qu’il serait plus difficile pour les entiers signés, car il y a le plus important à traiter. Je suppose que ce serait le nombre entier le plus significatif qui serait le nombre entier signé, et le rest qui ne serait pas signé, pour représenter les «parties» restantes du nombre.

(Ceci est semi-lié à une autre question .)

C’est un peu flou.

Bien sûr, une fonction telle que

void print_1024bit(uint64_t digits[]); 

pourrait être écrit pour le faire. Mais si vous voulez dire si l’une des fonctions de la famille printf() de la bibliothèque standard peut le faire, alors je pense que la réponse est non.

Comme vous l’avez probablement vu dans l’autre question, le kernel de la conversion d’un nombre binary en une base différente b est constitué de deux opérations:

  • Modulo b , pour déterminer le chiffre le moins significatif actuel
  • Division par b , pour supprimer ce chiffre une fois qu’il a été généré

Appliqué jusqu’à ce que le nombre soit 0, tous les chiffres sont générés dans l’ordre inverse.

Donc, vous devez implémenter “modulo 10” et “diviser par 10” pour votre nombre 1024 bits.

Par exemple, considérons le nombre décimal 4711, que nous voulons convertir en octal uniquement pour cet exemple:

  1. 4711% 8 est 7, le chiffre le plus à droite est 7
  2. 4711/8 est 588
  3. 588% 8 est 4, le prochain chiffre est 4
  4. 588/8 est 73
  5. 73% 8 est 1
  6. 73/8 soit 9
  7. 9% 8 est 1
  8. 8/8 est 1
  9. 1% 8 est 1
  10. 1/8 est 0, nous avons terminé.

Donc, en lisant les chiffres en gras du bas vers le haut vers les chiffres les plus à droite, nous concluons que 4711 10 = 11147 8 . Vous pouvez utiliser une calculasortingce pour vérifier cela ou simplement vous fier à moi. 🙂

Vous pouvez utiliser l’ algorithme à double point , qui élimine le besoin de multiplication et de division multi-précision. En fait, la page Wikipedia contient une implémentation en C pour cet algorithme.

C’est possible, bien sûr, mais pas très simple.

Plutôt que de réinventer la roue, pourquoi ne pas réutiliser une bibliothèque?

La bibliothèque arithmétique multi-précision GNU est l’une de ces possibilités. Je n’ai pas eu besoin de telles choses moi-même, mais cela semble correspondre à votre facture.