Wie konvertiert man eine Zeichenkette in Integer in C?

Ich bin versucht, herauszufinden, ob es eine alternative Möglichkeit der Umwandlung von string zu integer in C.

Ich regelmäßig Muster die folgenden in meinem code.

char s[] = "45";

int num = atoi(s);

So, gibt es eine bessere Möglichkeit oder einen anderen Weg?

InformationsquelleAutor der Frage user618677 | 2011-08-11

atoi c string

141

Es ist strtol was ist besser IMO. Auch ich habe den Geschmack gekommen in strtonumso verwenden Sie es, wenn Sie es haben (aber denken Sie daran, es ist nicht tragbar):
```
long long
     strtonum(const char *nptr, long long minval, long long maxval,
     const char **errstr);
```
BEARBEITEN

Könnten Sie auch interessieren strtoumax und strtoimax die standard-Funktionen im C99. Zum Beispiel könnten Sie sagen:
```
uintmax_t num = strtoumax(s, NULL, 10);
if (num == UINTMAX_MAX && errno == ERANGE)
    /* Could not convert. */
```
Sowieso, bleiben Sie Weg von atoi:
Den call atoi(str) ist äquivalent zu:
```
(int) strtol(str, (char **)NULL, 10)
```
außer, dass der Umgang mit Fehlern unterscheiden können. Wenn der Wert nicht
vertreten, ist das Verhalten undefiniert.
InformationsquelleAutor der Antwort cnicutar

Robuste C89 strtol-basierte Lösung

Mit:

keine undefinierten Verhalten (wie könnte es auch mit den atoi Familie)
eine strengere definition der integer-als strtol (z.B. keine führenden Leerzeichen noch nachfolgende trash chars)
Klassifikation der Fehler-case an (z.B., nützliche Fehlermeldungen an die Anwender)
eine "testsuite"

#include <assert.h>
#include <ctype.h>
#include <errno.h>
#include <limits.h>
#include <stdio.h>
#include <stdlib.h>

typedef enum {
    STR2INT_SUCCESS,
    STR2INT_OVERFLOW,
    STR2INT_UNDERFLOW,
    STR2INT_INCONVERTIBLE
} str2int_errno;

/* Convert string s to int out.
 *
 * @param[out] out The converted int. Cannot be NULL.
 *
 * @param[in] s Input string to be converted.
 *
 *     The format is the same as strtol,
 *     except that the following are inconvertible:
 *
 *     - empty string
 *     - leading whitespace
 *     - any trailing characters that are not part of the number
 *
 *     Cannot be NULL.
 *
 * @param[in] base Base to interpret string in. Same range as strtol (2 to 36).
 *
 * @return Indicates if the operation succeeded, or why it failed.
 */
str2int_errno str2int(int *out, char *s, int base) {
    char *end;
    if (s[0] == '\0' || isspace(s[0]))
        return STR2INT_INCONVERTIBLE;
    errno = 0;
    long l = strtol(s, &end, base);
    /* Both checks are needed because INT_MAX == LONG_MAX is possible. */
    if (l > INT_MAX || (errno == ERANGE && l == LONG_MAX))
        return STR2INT_OVERFLOW;
    if (l < INT_MIN || (errno == ERANGE && l == LONG_MIN))
        return STR2INT_UNDERFLOW;
    if (*end != '\0')
        return STR2INT_INCONVERTIBLE;
    *out = l;
    return STR2INT_SUCCESS;
}

int main(void) {
    int i;
    /* Lazy to calculate this size properly. */
    char s[256];

    /* Simple case. */
    assert(str2int(&i, "11", 10) == STR2INT_SUCCESS);
    assert(i == 11);

    /* Negative number . */
    assert(str2int(&i, "-11", 10) == STR2INT_SUCCESS);
    assert(i == -11);

    /* Different base. */
    assert(str2int(&i, "11", 16) == STR2INT_SUCCESS);
    assert(i == 17);

    /* 0 */
    assert(str2int(&i, "0", 10) == STR2INT_SUCCESS);
    assert(i == 0);

    /* INT_MAX. */
    sprintf(s, "%d", INT_MAX);
    assert(str2int(&i, s, 10) == STR2INT_SUCCESS);
    assert(i == INT_MAX);

    /* INT_MIN. */
    sprintf(s, "%d", INT_MIN);
    assert(str2int(&i, s, 10) == STR2INT_SUCCESS);
    assert(i == INT_MIN);

    /* Leading and trailing space. */
    assert(str2int(&i, " 1", 10) == STR2INT_INCONVERTIBLE);
    assert(str2int(&i, "1 ", 10) == STR2INT_INCONVERTIBLE);

    /* Trash characters. */
    assert(str2int(&i, "a10", 10) == STR2INT_INCONVERTIBLE);
    assert(str2int(&i, "10a", 10) == STR2INT_INCONVERTIBLE);

    /* int overflow.
     *
     * `if` needed to avoid undefined behaviour
     * on `INT_MAX + 1` if INT_MAX == LONG_MAX.
     */
    if (INT_MAX < LONG_MAX) {
        sprintf(s, "%ld", (long int)INT_MAX + 1L);
        assert(str2int(&i, s, 10) == STR2INT_OVERFLOW);
    }

    /* int underflow */
    if (LONG_MIN < INT_MIN) {
        sprintf(s, "%ld", (long int)INT_MIN - 1L);
        assert(str2int(&i, s, 10) == STR2INT_UNDERFLOW);
    }

    /* long overflow */
    sprintf(s, "%ld0", LONG_MAX);
    assert(str2int(&i, s, 10) == STR2INT_OVERFLOW);

    /* long underflow */
    sprintf(s, "%ld0", LONG_MIN);
    assert(str2int(&i, s, 10) == STR2INT_UNDERFLOW);

    return EXIT_SUCCESS;
}

GitHub upstream.

Basierend auf: https://stackoverflow.com/a/6154614/895245

InformationsquelleAutor der Antwort Ciro Santilli 新疆改造中心六四事件法轮功

19

Nicht die Funktionen aus ato... Gruppe. Diese defekt sind und praktisch nutzlos. Eine mäßig bessere Lösung wäre die Verwendung sscanfobwohl es auch nicht perfekt.

Konvertieren von string zu integer, Funktionen von strto... Gruppe verwendet werden soll. In Ihrem speziellen Fall wäre es strtol Funktion.

InformationsquelleAutor der Antwort AnT

Können Sie code ein wenig atoi() for fun:

int my_getnbr(char *str)
{
  int result;
  int puiss;

  result = 0;
  puiss = 1;
  while (('-' == (*str)) || ((*str) == '+'))
  {
      if (*str == '-')
        puiss = puiss * -1;
      str++;
  }
  while ((*str >= '0') && (*str <= '9'))
  {
      result = (result * 10) + ((*str) - '0');
      str++;
  }
  return (result * puiss);
}

Können Sie machen es auch rekursive wich kann alt in 3 Zeilen =)

InformationsquelleAutor der Antwort jDourlens

Wollte nur zu teilen, eine Lösung für unsigned long aswell.

unsigned long ToUInt(char* str)
{
    unsigned long mult = 1;
    unsigned long re = 0;
    int len = strlen(str);
    for(int i = len -1 ; i >= 0 ; i--)
    {
        re = re + ((int)str[i] -48)*mult;
        mult = mult*10;
    }
    return re;
}

InformationsquelleAutor der Antwort Jacob

Können Sie immer Rollen Sie Ihre eigenen!

#include <stdio.h>
#include <string.h>
#include <math.h>

int my_atoi(const char* snum)
{
    int idx, strIdx = 0, accum = 0, numIsNeg = 0;
    const unsigned int NUMLEN = (int)strlen(snum);

    /* Check if negative number and flag it. */
    if(snum[0] == 0x2d)
        numIsNeg = 1;

    for(idx = NUMLEN - 1; idx >= 0; idx--)
    {
        /* Only process numbers from 0 through 9. */
        if(snum[strIdx] >= 0x30 && snum[strIdx] <= 0x39)
            accum += (snum[strIdx] - 0x30) * pow(10, idx);

        strIdx++;
    }

    /* Check flag to see if originally passed -ve number and convert result if so. */
    if(!numIsNeg)
        return accum;
    else
        return accum * -1;
}

int main()
{
    /* Tests... */
    printf("Returned number is: %d\n", my_atoi("34574"));
    printf("Returned number is: %d\n", my_atoi("-23"));

    return 0;
}

Dies zu tun, was Sie wollen, ohne Kabelgewirr.

InformationsquelleAutor der Antwort ButchDean

Diese Funktion wird Ihnen helfen,

int strtoint_n(char* str, int n)
{
    int sign = 1;
    int place = 1;
    int ret = 0;

    int i;
    for (i = n-1; i >= 0; i--, place *= 10)
    {
        int c = str[i];
        switch (c)
        {
            case '-':
                if (i == 0) sign = -1;
                else return -1;
                break;
            default:
                if (c >= '0' && c <= '9')   ret += (c - '0') * place;
                else return -1;
        }
    }

    return sign * ret;
}

int strtoint(char* str)
{
    char* temp = str;
    int n = 0;
    while (*temp != '\0')
    {
        n++;
        temp++;
    }
    return strtoint_n(str, n);
}

Ref: http://amscata.blogspot.com/2013/09/strnumstr-version-2.html

InformationsquelleAutor der Antwort Amith Chinthaka

Ok, ich hatte das gleiche problem.Ich kam mit dieser Lösung.Es war für mich das beste.Ich habe versucht, atoi (), aber hat nicht funktioniert gut für mich.So, hier ist meine Lösung:

void splitInput(int arr[], int sizeArr, char num[])
{
    for(int i = 0; i < sizeArr; i++)
        //We are subtracting 48 because the numbers in ASCII starts at 48.
        arr[i] = (int)num[i] - 48;
}

InformationsquelleAutor der Antwort Khaled Mohammad

//I think this way we could go :
int my_atoi(const char* snum)
{
 int nInt(0);
 int index(0);
 while(snum[index])
 {
    if(!nInt)
        nInt= ( (int) snum[index]) - 48;
    else
    {
        nInt = (nInt *= 10) + ((int) snum[index] - 48);
    }
    index++;
 }
 return(nInt);
}

int main()
{
    printf("Returned number is: %d\n", my_atoi("676987"));
    return 0;
}

InformationsquelleAutor der Antwort Aditya Kumar

-3

Ja, Sie können die Speicherung der integer-direkt:
```
int num = 45;
```
Wenn Sie Parsen einen string, atoi oder strol wird gewinnen "kürzester-code" - Wettbewerb.

InformationsquelleAutor der Antwort Yann Ramin

-3

In C++ können Sie eine solche Funktion:

template <typename T>
T to(const std::string & s)
{
    std::istringstream stm(s);
    T result;
    stm >> result;

    if(stm.tellg() != s.size())
        throw error;

    return result;
}

Dies kann Ihnen helfen zu konvertieren eine beliebige Zeichenfolge zu jedem Typ float, int, double...

InformationsquelleAutor der Antwort neodelphi

Schreibe einen Kommentar

Du musst angemeldet sein, um einen Kommentar abzugeben.

BEARBEITEN