Was ist die richtige Art und Weise der Umsetzung eine gute "itoa ()" - Funktion?

Ich Frage mich, ob meine Umsetzung eines "itoa" - Funktion korrekt ist. Vielleicht können Sie mir helfen es ein bisschen mehr "richtige" ist, ich bin mir ziemlich sicher, ich bin etwas fehlt. (Vielleicht gibt es bereits eine Bibliothek diese Weise die Umwandlung der Art, wie ich will, es zu tun, aber... konnte nicht finden)

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <ctype.h>

char * itoa(int i) {
  char * res = malloc(8*sizeof(int));
  sprintf(res, "%d", i);
  return res;
}

int main(int argc, char *argv[]) {
 ...

Seien Sie vorsichtig. Es gibt nichts, um anzuzeigen, dass der Benutzer benötigt, um zu löschen Sie die return-pointer hinterher.
Verwandte: stackoverflow.com/q/4351371/103167
Sie hat nicht realisiert itoa. Sie nur weitergeleitet Ihren job, um die library-Funktion sprintf die nicht den job für Sie.

InformationsquelleAutor Nicolas C. | 2010-08-09

c char string

7

Die einzige wirkliche Fehler ist, dass Sie nicht überprüfen Sie den Rückgabewert von malloc für null.

Den Namen itoa ist Art von bereits für eine andere Funktion, nicht-standard, aber nicht selten. Es muss nicht Speicher, sondern schreibt es in einen Puffer, sofern der Anrufer:
```
char *itoa(int value, char * str, int base);
```
Wenn Sie nicht wollen, verlassen Sie sich auf Ihrer Plattform mit, dass, würde ich immer noch raten, nach dem Muster. String-handling-Funktionen die neu zugewiesenen Speicher in C sind in der Regel mehr ärger als Sie Wert sind, auf lange Sicht, weil die meisten der Zeit, die Sie am Ende tut die weitere manipulation, und so haben Sie, um eine Menge von Zwischenergebnissen. Vergleichen Sie zum Beispiel:
```
void delete_temp_files() {
    char filename[20];
    strcpy(filename, "tmp_");
    char *endptr = filename + strlen(filename);
    for (int i = 0; i < 10; ++i) {
        itoa(endptr, i, 10); //itoa doesn't allocate memory
        unlink(filename);
    }
}
```
vs.
```
void delete_temp_files() {
    char filename[20];
    strcpy(filename, "tmp_");
    char *endptr = filename + strlen(filename);
    for (int i = 0; i < 10; ++i) {
        char *number = itoa(i, 10); //itoa allocates memory
        strcpy(endptr, number);
        free(number);
        unlink(filename);
    }
}
```
Wenn Sie hatte Grund, besonders besorgt über die Leistung (zum Beispiel, wenn Sie implementieren eine stdlib-Stil-Bibliothek einschließlich itoa), oder wenn Sie waren die Umsetzung der Grundlagen, dass sprintf nicht unterstützt, dann könnten Sie nicht aufrufen sprintf. Aber wenn Sie möchten, eine base-10-string, dann ist dein Erster Instinkt war richtig. Es gibt absolut nichts "Falsches" über die %d Formatbezeichner.

Hier ist eine mögliche Umsetzung itoa für Basis 10 nur:
```
char *itobase10(char *buf, int value) {
    sprintf(buf, "%d", value);
    return buf;
}
```
Hier ist eine, die enthält die snprintf-Stil Ansatz für Puffer-Längen:
```
int itobase10n(char *buf, size_t sz, int value) {
    return snprintf(buf, sz, "%d", value);
}
```
- Das ist dumm, wenn er nicht der Rückkehr Speicher zugewiesen ist, warum dann nicht einfach anrufen snprintf direkt. snprintf(endptr, bytes, "%d", number) - Dies würde verhindern, dass eine temporäre variable Erklärung und nicht diejenigen, die buffer-overflow-Möglichkeiten in diesem Beispiel-code.
- den Grund nicht zu nennen snprintf direkt das ist der gleiche Grund, jemals jemand schreibt eine Funktion: zu Abstrakt, der Betrieb, die speziell für die Umwandlung eines integer zu einem string, im Gegensatz zu irgendeiner der vielen Dinge, die snprintf können mit den unterschiedlichen string-Formate. Es ist nur ein Puffer-überlauf, der Möglichkeit, in diesem code auf Plattformen, wo int mindestens 48 bits, und ich denke, dass Problem wurde gut abgedeckt anderswo. Fühlen Sie sich frei, zu verschmelzen, eins von denen in dieser Antwort 🙂
- Trotzdem, snprintf wird oft überbewertet. Wenn Sie sind besorgt über buffer-overflows, und Ihre Lösung ist die Verwendung von snprintf, dann warum sind Sie nicht besorgt über das abschneiden der Ergebnis-string und immer die falsche Antwort? Eine "sichere" Programm, das nicht wirklich funktioniert ist natürlich besser als ein unsicheres Programm, das nicht funktioniert, aber noch nicht groß ;-p
- das ist, warum snprintf gibt eine negative, wenn es abschneiden und Sie auf Fehler überprüfen. Beste aus beiden Welten!
- Standard snprintf zurück nicht negativ auf das abschneiden - das ist ein pre-C99-ism in z.B. Microsoft _snprintf und sehr alte glibc-Versionen. Es gibt die Anzahl der bytes, die geschrieben hatte, die Größe war ausreichend groß. Die überprüfung für die negative Rendite bedeutet, dass Sie verpassen abschneiden auf standard-Implementierungen. snprintf ist gut für die "Messen, zuordnen, schreiben Sie" Muster, aber es hilft nicht viel mit kurz-Puffer IMO. Und das sogar noch, bevor Sie sich sorgen darüber, ob die Länge, die Sie haben übergeben, ist tatsächlich korrekt. Die sichere Handhabung von Strings in C ist hart.
- Ich wusste gar nicht, dass war nicht standard, danke für die info. Ich würde lieber sehen, snprintf, als eine Funktion, die einfach wraps snprintf. Verstehe ich "Abstraktion", aber ich würde es nicht tun in diesem Fall. Würden Sie empfehlen strcpy_strings_that_start_with_a statt strcpy?
- natürlich nicht, denn die beiden hätten genau die gleichen Parameter und die Umsetzung. Würden Sie empfehlen die Vermeidung von http-Bibliotheken, zugunsten der Manipulation sockets direkt? Wir spielen mit irreführenden Extreme auf unbestimmte Zeit - in diesem Fall-wrapper "entfernt" einen parameter, um eine "inverse", um die standard-Funktion atoi, so dass es nicht viel im Vergleich mit der direkten Verwendung von snprintf, aber es tut mehr als nichts. Die Existenz von atoi macht itoa eine besonders Natürliche Abstraktion.
- Ich denke, letztlich, ich denke, es lohnt sich immer, schreiben, was auch immer Funktionen entsprechen, die Abstraktionen, die caller will (wo möglich, und die performance zulässt), auch wenn Sie am Ende sehr ähnlich zu bestehenden Funktionen. Wenn ich fand mich oft zu wollen, kopieren Saiten, die unbedingt beginnen mit a ich denke, vielleicht würde ich eine Funktion schreiben, die asserts das erste Zeichen und ruft dann strcpy. Auf ein release zu bauen, wäre es ein do-nothing-wrapper.
InformationsquelleAutor Steve Jessop

//Yet, another good itoa implementation
//returns: the length of the number string
int itoa(int value, char *sp, int radix)
{
    char tmp[16];//be careful with the length of the buffer
    char *tp = tmp;
    int i;
    unsigned v;

    int sign = (radix == 10 && value < 0);    
    if (sign)
        v = -value;
    else
        v = (unsigned)value;

    while (v || tp == tmp)
    {
        i = v % radix;
        v /= radix; //v/=radix uses less CPU clocks than v=v/radix does
        if (i < 10)
          *tp++ = i+'0';
        else
          *tp++ = i + 'a' - 10;
    }

    int len = tp - tmp;

    if (sign) 
    {
        *sp++ = '-';
        len++;
    }

    while (tp > tmp)
        *sp++ = *--tp;

    return len;
}

//Usage Example:
char int_str[15]; //be careful with the length of the buffer
int n = 56789;
int len = itoa(n,int_str,10);

Es findet '\0', seien Sie vorsichtig, wenn Sie es
Ich habe gerade verändert die Funktion geben Sie die Länge der erstellten Zeichenfolge.
Ihre Behauptung über die v /= radix schneller als v = v /radix ist nicht wahr. Jeder compiler erzeugt den gleichen code für beide Formen. Getestet habe ich es mit gcc-Optimierungen deaktiviert.
Hinzufügen *sp = '\0'; vor return len; so dass sp wird ein richtig null-terminierte ASCII-Zeichenkette, die Sie verwenden können, um Funktionen wie strcpy.

InformationsquelleAutor Minh Nguyen

3

Ich denke, Sie werden allozieren, vielleicht zu viel Speicher. malloc(8*sizeof(int)) geben Sie 32 bytes auf den meisten Maschinen, das ist wahrscheinlich, übermäßige für eine text-Darstellung eines int.
- Du hast Recht. Da 2^15 - 1 ist eigentlich 32767, ich brauche nur 6*sizeof(char)
- Und einer mehr für das Zeichen, wenn man bedenkt, dass negative zahlen.
- danke ! (nicht +1, ich bin noch nicht registriert), aber ich würde haben !
- sizeof(int)*3+2 sollte immer ausreichend sein (jedes byte trägt 3 stellen oder weniger, und die zusätzlichen 2 sind für Zeichen und null-Terminierung.
- Nicht auf Architekturen, auf denen CHAR_BIT größer als 9 ist. ZB. manche DSPs haben CHAR_BIT == 32 und sizeof(int) == 1.
- Huh. Wie ist das für so etwas. Eins ist sicher, SO hilft die Herausforderung meine Vorurteile. Danke!
- Wenn Sie möchten, zu berücksichtigen, dass, Sie können stattdessen ((CHAR_BIT * sizeof(type) - 1) / 3 + 2) für signed-Typen, oder ((CHAR_BIT * sizeof(type)) / 3 + 1) für unsigned-Typen.
- Schön! Vielen Dank für die zusätzlichen Informationen! Ein .NETTO Kerl, ich bin beeindruckt, wie viel Ihr lernen, wenn Sie dip unter die .NET/Java/Python/etc Abstraktion.
- das ist genau der Grund, warum ich diese Frage gestellt; auch mit einer Frage, die so einfach, wie es war, ich konnte nicht denken Sie an all die Fälle, und mein Programmier-Stil ist nicht Brillant, noch.
InformationsquelleAutor kbrimington

Einen guten int zu string oder itoa() hat diese Eigenschaften;

Funktioniert für alle [INT_MIN...INT_MAX] -, Basis - [2...36] ohne Puffer-überlauf.
Nicht davon ausgehen int Größe.
Nicht erforderlich 2 ergänzen.
Nicht erforderlich unsigned einen größeren positiven Bereich als int. In anderen Worten, nicht verwenden unsigned.
Ermöglicht die Verwendung von '-' für negative zahlen, auch wenn base != 10.

Passen Sie die Fehlerbehandlung benötigt. (muss C99 oder später):

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);
}

InformationsquelleAutor chux

2

Ich bin mir nicht ganz sicher, wo Sie bekommen 8*sizeof(int) als die maximal mögliche Anzahl der Zeichen -- ceil(8 /(log(10) /log(2))) ergibt sich ein Multiplikator von 3*. Darüber hinaus unter C99 und einige ältere POSIX-Plattformen können Sie erstellen, die eine passgenaue Zuweisung der version mit sprintf():
```
char *
itoa(int i) 
{
    int n = snprintf(NULL, 0, "%d", i) + 1;
    char *s = malloc(n);

    if (s != NULL)
        snprintf(s, n, "%d", i);
    return s;
}
```
HTH
- Zwei Aufrufe snprintf scheint wie eine schlechte Praxis.
- gut, wenn der format-string ist nur %d es ist nicht wirklich notwendig, da Sie arbeiten können, die max benötigt Raum zur compile-Zeit. Für einen 32bit int, es ist 12, also würde man normalerweise nicht zu viel sorgen über die Zuteilung. Dieses Allgemeine Muster der Aufruf snprintf zweimal ist absolut standard Zeug, aber.
InformationsquelleAutor llasram
2

fand ich eine interessante Ressource im Umgang mit verschiedenen Themen, die mit der itoa Umsetzung

Sie würde vielleicht schauen Sie auch

itoa () - Implementierungen mit performance-tests
- char* Durchführung 0,4-version in diesem Dokument ist die höchste Leistung der Umsetzung.
- Der link ist kaputt.
- Ich habe aktualisiert, der link auf die post
InformationsquelleAutor Adam
1

Sollten Sie eine Funktion in der printf Familie für diesen Zweck. Wenn Sie schreiben werden, das Ergebnis zu stdout oder eine Datei, verwenden Sie printf/fprintf. Andernfalls verwenden Sie snprintf mit einem Puffer groß genug, um 3*sizeof(type)+2 bytes oder mehr.

InformationsquelleAutor R..
1

sprintf ist ziemlich langsam, wenn es um performance geht, ist es wahrscheinlich nicht die beste Lösung.

wenn die Basis-argument ist eine Potenz von 2 ist die Umwandlung kann getan werden, mit shift und Maskierung, und man kann vermeiden, die Umkehrung der Zeichenfolge, die durch die Aufnahme der Ziffern aus den höchsten Positionen. Zum Beispiel so etwas wie dieses für Basis=16
```
int  num_iter = sizeof(int) / 4;
```
const char Ziffern[] = {'0', '1', '2', '3', '4', '5', '6', '7', '8', '9', 'a', 'b', 'c', 'd', 'e', 'f'};
```
/* 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];
}
```
Für Dezimalzahlen gibt es auch eine nette Idee für die Verwendung einer statischen array groß genug, um dem Datensatz die zahlen in umgekehrter Reihenfolge, siehe hier

InformationsquelleAutor Sergey Solovyev
0

Sollte dies funktionieren:
```
#include <string.h>
#include <stdlib.h>
#include <math.h>

char * itoa_alloc(int x) {
   int s = x<=0 ? 1 ? 0; //either space for a - or for a 0
   size_t len = (size_t) ceil( log10( abs(x) ) );
   char * str = malloc(len+s + 1);

   sprintf(str, "%i", x);

   return str;
}
```
Wenn Sie nicht wollen, verwenden Sie die math/floating-point-Funktionen (und noch die Verknüpfung in die Mathematik-Bibliotheken) Sie sollten in der Lage sein zu finden, nicht-floating-point-Versionen von log10 durch die Suche im Web und tun:

size_t len = my_log10( abs(x) ) + 1;

Geben könnten Sie 1 mehr byte als Sie benötigt, aber Sie hätten genug.
- Scheint wie eine Menge Arbeit zu berechnen, die richtige Größe, wenn die maximale ist eine bekannte 12 bytes. ceil, log10, abs, zwei temporäre Variablen (insgesamt 8 bytes) und eine ternäre operation.
- Ja, aber der Allgemeine Prozess funktioniert für jede große ganze Zahl.
- Schlägt mit INT_MIN.
InformationsquelleAutor nategoose
0

Gibt es ein paar Vorschläge, die ich machen könnte. Sie können einen statischen Puffer und strdup zu vermeiden, wiederholt die Zuweisung von zu viel Speicher auf nachfolgende Aufrufe. Ich würde auch hinzufügen, einige Fehler zu überprüfen.
```
char *itoa(int i)
{
  static char buffer[12];

  if (snprintf(buffer, sizeof(buffer), "%d", i) < 0)
    return NULL;

  return strdup(buffer);
}
```
Wenn diese aufgerufen wird, die in einer multithreaded-Umgebung, entfernen Sie "static" aus dem Puffer Erklärung.

InformationsquelleAutor Brandon Horsley

-1

main()
{
  int i=1234;
  char stmp[10];
#if _MSC_VER
  puts(_itoa(i,stmp,10));
#else
  puts((sprintf(stmp,"%d",i),stmp));
#endif
  return 0;
}

InformationsquelleAutor user411313

Schreibe einen Kommentar

Du musst angemeldet sein, um einen Kommentar abzugeben.