Voulez Convertir Entier de Chaîne sans fonction itoa

je veux convertir int to char* en C, sans l'aide de itoa() fonction.

Parce que sur mon Linux, je itoa fonction n'est pas là. je suis en utilisant ce code que j'ai trouvé de ici

Je veux exécuter cette fonction sur les systèmes Embarqués, qui sont l'utilisation de Linux.

Donc je suis à la recherche d', sans l'utilisation de itoa.

Je dnt souhaitez utiliser sprintf aussi parce que ses utilisations pour juste des impressions.

De sorte que tout le corps s'il vous plaît aidez-moi à trouvé ce problème.

Grâce

  • Je dnt souhaitez utiliser sprintf aussi parce que ses utilisations pour juste des impressions Qui n'a pas de sens.
  • atoi serait inutile, car il convertit en ASCII en entier, et non pas vice versa.
  • Vérifier mes mises à jour Question
  • Pourquoi dites-vous que sprintf est utilisé pour les imprimer? il n'est pas vrai.
  • J'ai une chaîne de caractères fonctions de gestion qui pourraient être utiles pour l'OP. Je peux poster un lien, mais je ne sais pas si c'est autorisé - peut-être considéré comme un spam? Veuillez informer.
  • Généralement, les liens sont parfaitement bien, tant qu'ils sont pertinents.
  • c'est pourquoi il a écrit itoa et pas atoi
  • il a écrit (modifié) après le commentaire.
  • sprints, ou mieux, snprintf - est le chemin à parcourir. Ce n'est PAS pour "l'impression", mais pour la construction de tampons de chaîne (chaînes C inclus - lorsque la valeur null).

InformationsquelleAutor user1089679 | 2012-04-03
  1. 7

    Chose est snprintf est la fonction parfaite pour cela:

    char str[LEN];
snprintf(str, sizeof(str), "%d", num);
    • snprintf pour éviter le débordement, mais sinon, les bons conseils, ou simplement m'ignorer, parce que je ne peux pas lire, apparemment...
    • Quelque chose de mal avec ma réponse ?
    • Je n'ai pas downvote, mais stdio.h est généralement interdit de systèmes embarqués. MISRA-C par exemple, l'interdiction de la stdio.h à partir de l'ensemble de la production de code. Pauvre type de la sécurité et de mauvais rendement sont les principales préoccupations. Et puisque c'est si facile pour un programmeur d'écrire un ltid/atoi fonction, il n'y a vraiment pas besoin d'utiliser stdio.h uniquement à cette fin.
    • Ah, je vois. Je suppose que cela a du sens 🙂
    InformationsquelleAutor cnicutar
  2. 4

    Ici est un extrait de simple que vous pouvez utiliser. Il y a de plus élégant et de moyens avancés, mais ce que le travail soit fait.

    Dans les projets intégrés dans le passé, j'ai mesuré à environ 1000 fois plus efficace que sprintf(). Ce code est également MISRA-C conforme.

    void getDecStr (uint8_t* str, uint8_t len, uint32_t val)
{
  uint8_t i;

  for(i=1; i<=len; i++)
  {
    str[len-i] = (uint8_t) ((val % 10UL) + '0');
    val/=10;
  }

  str[i-1] = '
    void getDecStr (uint8_t* str, uint8_t len, uint32_t val)
{
uint8_t i;
for(i=1; i<=len; i++)
{
str[len-i] = (uint8_t) ((val % 10UL) + '0');
val/=10;
}
str[i-1] = '\0';
}
    '    ;
}
    • Je pense que vous avez besoin de quelque lumineux rouge clignotant d'avertissement des signes sur cette routine. Tout d'abord, il va pavé de la chaîne de retour avec des zéros à gauche si la mémoire tampon est plus grande que ce qui est absolument nécessaire. Deuxièmement, il ne gère pas les nombres négatifs; certes, vous déclarez que la prise non signé, mais l'OP a demandé une itoa() de travail, ce qui implique des entiers signés. Je dirais pour les "Tiers" n'étant paramètre radix, mais compte tenu de la i_to_a() de mise en œuvre de l'OP posté une réponse, je suppose qu'une partie de la MS itoa() interface n'est pas important pour lui.
    • C'est intentionnellement simple, les modifications peuvent être faites pour obtenir plus de fonctionnalités. Cette fonction a été écrit en temps réel des systèmes embarqués, et, par conséquent, il n'existe aucune fonctionnalité incluse dans ce qui n'est pas nécessaire. Des zéros sont là pour rendre deteministic.
    • Honnêtement, je voulais juste montrer comment, de façon flagrante, il est facile d'écrire du code comme celui-ci sur votre propre. Pourtant, si de nombreux programmeurs demander de atoi/ltid plus et plus... au Lieu de demander pour les poissons, peut-être apprendre comment attraper le poisson que vous-même. Ceci est particulièrement important si vous travaillez en tant que pêcheur.
    • Le rembourrage est toujours un piège. Si vous passez un de 100 caractères tampon, ça prend environ 3,5 x le temps le plus lent d'autres méthode que j'ai comparés ici. Si vous coupez la taille de la mémoire tampon de 10, c'est deux fois plus rapide que le plus rapide. Il va montrer que vous pouvez bum code pour la vitesse si vous connaissez les caractéristiques exactes de l'entrée de données, mais je ne dirais pas cela comme un objectif général de la fonction, sans que les alarmes.
    • Pourquoi serait-on jamais passer un tampon de plus de 11 caractères à la fonction? ULONG_MAX = 4294967295. 10 chiffres + 1 null terme comme le pire des cas. Aussi, "len" dans ce cas est le nombre de chiffres que la fonction main, pas la taille de la mémoire tampon.
    • "ULONG_MAX = 4294967295". Sur les plates-formes 32 bits, oui. Et, vous ne l'avez jamais juste par hasard défini un "assez grand" tampon? De toute façon, ces commentaires sont l'avertissement. 🙂
    • uint32_t sera de 32 bits, peu importe la plateforme.

    InformationsquelleAutor Lundin
  3. 3

    - Je trouver une mise de ltid de cette lien. Peut-être qu'il vous aide à vous comme il l'a fait pour moi.

    InformationsquelleAutor denizt
  4. 3
    #include <stdio.h>
#include <string.h>
#if 0
char *strrev(char *str){
char c, *front, *back;
if(!str || !*str)
return str;
for(front=str,back=str+strlen(str)-1;front < back;front++,back--){
c=*front;*front=*back;*back=c;
}
return str;
}
#endif
char *itoa(int v, char *buff, int radix_base){
static char table[] = "0123456789abcdefghijklmnopqrstuvwxyz";
char *p=buff;
unsigned int n = (v < 0 && radix_base == 10)? -v : (unsigned int) v;
while(n>=radix_base){
*p++=table[n%radix_base];
n/=radix_base;
}
*p++=table[n];
if(v < 0 && radix_base == 10) *p++='-';
*p='\0';
return strrev(buff);
}
int main ()
{
int i;
char str[33];
printf ("Enter a number: ");
scanf ("%d",&i);
itoa (i,str,10);
printf ("decimal: %s\n", str);
itoa (i, str, 16);
printf ("hexadecimal: %s\n", str);
itoa (i, str, 2);
printf ("binary: %s\n", str);
return 0;
}
    • C'est le plus lent des options posté jusqu'à présent. Sur mon système de test avec mon jeu de données de test, snprintf() a pris 17.1 sec, i_to_a() avec le malloc() et associés requis free() a pris de 18,7 sec, i_to_a() modifié pour prendre un préaffectés tampon a pris 15.2 sec, et votre itoa() a pris de 20,5 sec. La modification de votre itoa() à ajouter un nombre négatif de soutien et radices jusqu'à 36 pour le rendre compatible avec le MS de la mise en œuvre heurté que légèrement 20,7 sec. Néanmoins, +1 pour être intéressante. 🙂
    • 1.les nombres négatifs:int n -> int v, unsigned int n = c. 2.radices 2-36:"0123456789abcdef" -> "012...xyz". 3.Pourquoi lent : utilisation / %. E. g.remplacer Montgomery_reduction. Mais Ce qu'il n'a pas beaucoup de vitesse est nécessaire pour une utilisation quotidienne?
    • Je n'ai pas à prendre comme point de suite,aussi. mais provisoirement essayé de les corriger.
    • Merci, je me sens mieux maintenant. 🙂 Dans ma version, je n'ai pas restreindre les nombres négatifs à la base 10, mais je vois que c'est la façon dont MS l'a fait. Je suppose qu'ils étaient en train d'essayer de permettre hex/bin/oct sortie de valeurs avec le haut-ensemble de bits sans avoir les afficher comme négatif. Ils doivent avoir défini uitoa() à la place. Oh bien.
    • oui, MS ltid est de comprendre et donc de mettre un signe moins que lorsque la base 10. Toutefois, cela ne signifie pas que, pour limiter l'entrée négative.
    InformationsquelleAutor BLUEPIXY
  5. -1

    J'ai trouvé la solution concernant ce..

    Je suis Heureux et je veux ce qui m'attend.

    #include <string.h>
#include <stdlib.h>
char *i_to_a(int num);
int main()
{
char *str = i_to_a(4567);
printf("%s",str);
free(str);
str = NULL;
return 0;
}
int no_of_digits(int num)
{
int digit_count = 0;
while(num > 0)
{
digit_count++;
num /= 10;
}
return digit_count;
}
char *i_to_a(int num)
{
char *str;
int digit_count = 0;
if(num < 0)
{
num = -1*num;
digit_count++;
}
digit_count += no_of_digits(num);   
str = malloc(sizeof(char)*(digit_count+1));
str[digit_count] = '\0';
while(num > 0)
{
str[digit_count-1] = num%10 + '0';
num = num/10;
digit_count--;
}
if(digit_count == 1)
str[0] = '-';
return str;
}
    • Juste avoir à l'esprit que ce code des fuites de mémoire. Aussi, -1 pour l'enseignement de transtypage le résultat de malloc dans C. Lire ceci et this. Retirez le transtypage et je vais enlever le downvote.
    • Oui, main() devrait libérer de la mémoire tampon, mais à mon humble avis i_to_a() de ne pas allouer un tampon en premier lieu. Il n'y a aucune bonne raison, il ne faut pas se prendre une préaffectés tampon à la place. Les fonctions de l'utilitaire que de répartir et de retour tampons sont une odeur de code dans mon livre. Depuis qu'il est parti et ont divergé à partir de la MS itoa() interface, il pourrait tout aussi bien ajouter un paramètre de durée, trop, et de vérifier la saturation de la mémoire tampon.
    • Je suis entièrement d'accord avec tout ce que vous avez dit.
    • Veuillez vérifier mes mises à jour Répondre
    • Vous devez également vérifier que le malloc réussi. if(str!=NULL) {printf("Malloc failed\n"); /* nettoyage */ return;}
    • Échoue pour i_to_a(0). Échoue pour i_to_a(INT_MIN).
    • Comme pour le (0) cas, il suffit d'inverser le tandis que en ne-laps de temps

    InformationsquelleAutor user1089679