Code Source en C embarqué pour un entier non signé de la chaîne

Sans recourir à la bibliothèque standard utoa, je suis à la recherche pour le code source de utoa afin que je puisse le personnaliser pour chaque projet. J'ai d'entier non signé (32 bits) avec sortie tels que 0xFFFF_FFFF

Je suis également à la recherche pour le code source entier non signé et demi-mot à la chaîne dans un format binaire.

utoa ne fait pas partie de la bibliothèque C standard. (C'est peut-être une partie de votre mise en œuvre de libc mais ce n'est pas la norme.)
est-ce un devoir? si oui, veuillez étiqueter comme tel.
Non ce n'est pas des devoirs à faire, pourquoi tout le monde suppose que c'est le cas!!!.

InformationsquelleAutor riscy | 2011-08-03

c embedded

5

Essayez ceci:
```
char *dec(unsigned x, char *s)
{
    *--s = 0;
    if (!x) *--s = '0';
    for (; x; x/=10) *--s = '0'+x%10;
    return s;
}
```
Vous l'appelez avec un pointeur vers la fin de l'appelant-à condition de la mémoire tampon, et la fonction retourne le pointeur vers le début de la chaîne. Le tampon doit avoir une longueur d'au moins 3*sizeof(int)+1 pour être sûr.

Bien sûr, cela est facilement adapté à d'autres bases.
- Merci, je lui donner un aller pour la base 16 (hexadécimal).
- Pour la base 16, vous aurez besoin soit de spécial chiffres <10 >=10 séparément ou à utiliser Kerrek de la chaîne d'indexation de la solution.
InformationsquelleAutor R..
3

Theres beaucoup de ltid source des fichiers facilement trouvé sur google... Qui devrait vous donner ce que vous voulez, par exemple. ltid de opensource.apple.com

Ou de l'écrire à partir de zéro, il n'est pas trop dur.

InformationsquelleAutor Keith Nicholas
1

Qui n'est pas très difficile. Continuer à diviser par 10 et utilisez le reste de mod 10 comme un index dans "0123455679". Vous construisez ce de droite à gauche, de sorte que vous avez à tampon, le résultat et le retour dans le sens inverse:
```
char * utoa(unsigned int n)
{
  char * res, buf[30]; //long enough for largest number
  unsigned int i, counter = 0;

  if (n == 0)
    buf[counter++] = '0';

  for ( ; n; n /= 10)
    buf[counter++] = "0123456789"[n%10];

  res = malloc(counter);

  for (i = 0; i < counter; ++i)
    res[i] = buf[counter - i - 1];

  return res;
}
```
- J'ai du mal à résister à donner -1 pour un inutile-utilisation-de-malloc comme une réponse à un systèmes embarqués question...
- Eh bien, vous avez à mettre le résultat quelque part. J'ai confiance que l'OP est assez souple pour s'adapter aux besoins, que ce détail a clairement rien à voir avec l'algorithme de base!
- C'est pourquoi je n'ai pas -1 il. Mais vraiment, ceux d'entre nous qui savent mieux devrait être un bon exemple, plutôt que de laisser les OP de fixer la solution (et je suppose une bonne moitié de question-askers serait "fixer" votre réponse à l'utilisation d'un static tampon plutôt que l'appelant a fourni de la mémoire tampon, ce qui n'est pas une bonne chose...)
- Par la manière, l'indexation dans "0123456789" est un moyen inefficace pour écrire '0'+n, et ce dernier n'est pas un hack, il est nécessaire de travailler en tant que partie de la langue.
- L'ancien permet arbitraire de symboles, si 🙂 Mais utiliser quelle que soit la flotte votre bateau. (À propos de "vraiment inefficace": Ma méthode causes de un complémentaires instructions de montage sur '0'+n%10...)
- Et de 11 octets de la chaîne constante des données. 🙂 En PIC de bibliothèques, il peut également introduire un GOT-registre de dépendance (pour l'adressage relatif) dans une fonction qui, autrement, aurait été purement indépendant de la position, même sans -fPIC.
InformationsquelleAutor Kerrek SB

#include <stdint.h>
#include <string.h>

char * utox(uint32_t n) {
    static char hexstr[sizeof(n)*2+1];
    char * p = hexstr + sizeof(hexstr) -1;
    int x;

    memset(hexstr, '0', sizeof(hexstr));

    *p-- = '#include <stdint.h>
#include <string.h>
char * utox(uint32_t n) {
static char hexstr[sizeof(n)*2+1];
char * p = hexstr + sizeof(hexstr) -1;
int x;
memset(hexstr, '0', sizeof(hexstr));
*p-- = '\0';
while (n) {
x = n % 16;
if (x < 10)
*p-- = '0' + x;
else
*p-- = 'A' + x - 10;
n /= 16;
}
return hexstr;
}
';

    while (n) {
        x = n % 16;
        if (x < 10)
            *p-- = '0' + x;
        else
            *p-- = 'A' + x - 10;

        n /= 16;
    }

    return hexstr;
}

Cela devrait le faire, c'est zéro plaquettes. Il suffit de changer le type de n dans les paramètres de la fonction sera de le faire fonctionner pour tout type entier/taille.

Évidemment, cette solution n'est pas thread-safe. (Non pas que l'OP cité que comme une exigence.)
C'est un système embarqué, d'habitude c'est très bien, sauf si il veut utiliser que dans un ISR ou avec une tige de RTOS. J'aime bien cette solution, la plupart du temps parce que je peux être sûr de les limites du tableau de sorte que son plus sûr. Il est trivial de au lieu de gérer la matrice de moi-même, de faire fonctionner sur un pointeur.
Ma solution préférée consiste à demander à l'appelant de passer un tampon (et de la taille de la mémoire tampon) dans. Mais bon, beaucoup de chemins mènent à Rome...

InformationsquelleAutor Vinicius Kamakura

La plupart des fonctions mentionnées/suggéré ici utilise le module opérateur%, ce qui est très cher pour un système embarqué.

Donc, à l'aide de diviser par 10 idée est le seul éminent option, je suppose. Ici, il est:

/*for byte which is 3 digit most*/


void itoa(unsigned char value,char *desitination)
{
desitination[0] = '/*for byte which is 3 digit most*/
void itoa(unsigned char value,char *desitination)
{
desitination[0] = '\0';
desitination[1] = '\0';
desitination[2] = '\0';
desitination[3] = '\0';//you at least 4 char array, last char is NULL
while (value >= 100)
{
desitination[0]++;
value -= 100;
}
desitination[1] = '0';
while (value >= 10)
{
desitination[1]++;
value -= 10;
}
value+= '0';
desitination[2] =value;
}
';
desitination[1] = '/*for byte which is 3 digit most*/
void itoa(unsigned char value,char *desitination)
{
desitination[0] = '\0';
desitination[1] = '\0';
desitination[2] = '\0';
desitination[3] = '\0';//you at least 4 char array, last char is NULL
while (value >= 100)
{
desitination[0]++;
value -= 100;
}
desitination[1] = '0';
while (value >= 10)
{
desitination[1]++;
value -= 10;
}
value+= '0';
desitination[2] =value;
}
';
desitination[2] = '/*for byte which is 3 digit most*/
void itoa(unsigned char value,char *desitination)
{
desitination[0] = '\0';
desitination[1] = '\0';
desitination[2] = '\0';
desitination[3] = '\0';//you at least 4 char array, last char is NULL
while (value >= 100)
{
desitination[0]++;
value -= 100;
}
desitination[1] = '0';
while (value >= 10)
{
desitination[1]++;
value -= 10;
}
value+= '0';
desitination[2] =value;
}
';
desitination[3] = '/*for byte which is 3 digit most*/
void itoa(unsigned char value,char *desitination)
{
desitination[0] = '\0';
desitination[1] = '\0';
desitination[2] = '\0';
desitination[3] = '\0';//you at least 4 char array, last char is NULL
while (value >= 100)
{
desitination[0]++;
value -= 100;
}
desitination[1] = '0';
while (value >= 10)
{
desitination[1]++;
value -= 10;
}
value+= '0';
desitination[2] =value;
}
';//you at least 4 char array, last char is NULL
while (value >= 100)
{
    desitination[0]++;
    value -= 100;
}
desitination[1] = '0';

while (value >= 10)
{
     desitination[1]++;
     value -= 10;
}
value+= '0';
desitination[2] =value;
}

InformationsquelleAutor Biddut Mitra

Il y a beaucoup de mise en œuvre de la ltid. C'est l'un d'eux qui prend en compte la base de 2 à 36:

/**
 * C++ version 0.4 char* style "itoa":
 * Written by Lukás Chmela
 * Released under GPLv3.

 */
char* itoa(int value, char* result, int base) {
    //check that the base if valid
    if (base < 2 || base > 36) { *result = '/**
* C++ version 0.4 char* style "itoa":
* Written by Lukás Chmela
* Released under GPLv3.
*/
char* itoa(int value, char* result, int base) {
//check that the base if valid
if (base < 2 || base > 36) { *result = '\0'; return result; }
char* ptr = result, *ptr1 = result, tmp_char;
int tmp_value;
do {
tmp_value = value;
value /= base;
*ptr++ = "zyxwvutsrqponmlkjihgfedcba9876543210123456789abcdefghijklmnopqrstuvwxyz" [35 + (tmp_value - value * base)];
} while ( value );
//Apply negative sign
if (tmp_value < 0) *ptr++ = '-';
*ptr-- = '\0';
while(ptr1 < ptr) {
tmp_char = *ptr;
*ptr--= *ptr1;
*ptr1++ = tmp_char;
}
return result;
}
'; return result; }

    char* ptr = result, *ptr1 = result, tmp_char;
    int tmp_value;

    do {
        tmp_value = value;
        value /= base;
        *ptr++ = "zyxwvutsrqponmlkjihgfedcba9876543210123456789abcdefghijklmnopqrstuvwxyz" [35 + (tmp_value - value * base)];
    } while ( value );

    //Apply negative sign
    if (tmp_value < 0) *ptr++ = '-';
    *ptr-- = '/**
* C++ version 0.4 char* style "itoa":
* Written by Lukás Chmela
* Released under GPLv3.
*/
char* itoa(int value, char* result, int base) {
//check that the base if valid
if (base < 2 || base > 36) { *result = '\0'; return result; }
char* ptr = result, *ptr1 = result, tmp_char;
int tmp_value;
do {
tmp_value = value;
value /= base;
*ptr++ = "zyxwvutsrqponmlkjihgfedcba9876543210123456789abcdefghijklmnopqrstuvwxyz" [35 + (tmp_value - value * base)];
} while ( value );
//Apply negative sign
if (tmp_value < 0) *ptr++ = '-';
*ptr-- = '\0';
while(ptr1 < ptr) {
tmp_char = *ptr;
*ptr--= *ptr1;
*ptr1++ = tmp_char;
}
return result;
}
';
    while(ptr1 < ptr) {
        tmp_char = *ptr;
        *ptr--= *ptr1;
        *ptr1++ = tmp_char;
    }
    return result;
}

Plus de variations peuvent être trouvés ici qui inclut la vitesse de la performance des implémentations différentes.

InformationsquelleAutor sg7

Vous devez vous connecter pour publier un commentaire.