it-swarm.com.de

Konvertieren Sie char in int in C und C ++

Wie konvertiere ich ein char in ein int in C und C++?

322
mainajaved

Kommt darauf an, was du machen willst:

um den Wert als ASCII-Code zu lesen, können Sie schreiben

char a = 'a';
int ia = (int)a; 
/* note that the int cast is not necessary -- int ia = a would suffice */

um das Zeichen '0' -> 0, '1' -> 1 usw. zu konvertieren, können Sie schreiben

char a = '4';
int ia = a - '0';
/* check here if ia is bounded by 0 and 9 */

Erklärung:
a - '0' entspricht ((int)a) - ((int)'0'), dh die ASCII-Werte der Zeichen werden voneinander subtrahiert. Da 0 direkt vor 1 in der ASCII-Tabelle steht (und so weiter bis 9), ergibt die Differenz zwischen den beiden die Zahl, die das Zeichen a darstellt.

450
Foo Bah

Nun, im ASCII Code beginnen die Zahlen (Ziffern) mit 48. Alles was Sie tun müssen ist:

int x = (int)character - 48;
76
Vlad Isoc

C und C++ befördern Typen immer auf mindestens int. Außerdem sind Zeichenliterale vom Typ int in C und char in C++.

Sie können einen char -Typ einfach konvertieren, indem Sie ihn einem int zuweisen.

char c = 'a'; // narrowing on C
int a = c;
58
Matt Joiner

char ist nur eine 1-Byte-Ganzzahl. Es gibt nichts Magisches mit dem Saiblingstyp! So wie Sie einem Int ein Short oder einem Long ein Int zuweisen können, können Sie einem Int ein Char zuweisen.

Ja, der Name des primitiven Datentyps lautet zufällig "char", was bedeutet, dass er nur Zeichen enthalten sollte. Aber in Wirklichkeit ist "char" nur eine schlechte Wahl, um alle zu verwirren, die versuchen, die Sprache zu lernen. Ein besserer Name dafür ist int8_t, und Sie können diesen Namen stattdessen verwenden, wenn Ihr Compiler dem neuesten C-Standard folgt.

Natürlich sollten Sie sollte den char-Typ verwenden, wenn Sie Zeichenfolgen verarbeiten, da der Index der klassischen ASCII -Tabelle in 1 Byte passt. Sie könnten jedoch auch mit regulären Ints String-Handling machen, obwohl es in der realen Welt keinen praktischen Grund gibt, warum Sie das jemals wollen würden. Der folgende Code funktioniert beispielsweise einwandfrei:

  int str[] = {'h', 'e', 'l', 'l', 'o', '\0' };

  for(i=0; i<6; i++)
  {
    printf("%c", str[i]);
  }

Sie müssen sich darüber im Klaren sein, dass Zeichen und Zeichenketten wie alles andere im Computer nur Zahlen sind. Wenn Sie 'a' in den Quellcode schreiben, wird es in die Zahl 97 vorverarbeitet, die eine Ganzzahlkonstante ist.

Also, wenn Sie einen Ausdruck wie schreiben

char ch = '5';
ch = ch - '0';

das ist eigentlich gleichbedeutend mit

char ch = (int)53;
ch = ch - (int)48;

das geht dann durch die C-Sprache Integer-Promotions

ch = (int)ch - (int)48;

und dann auf ein Zeichen gekürzt, um dem Ergebnistyp zu entsprechen

ch = (char)( (int)ch - (int)48 );

Es gibt eine Menge subtiler Dinge zwischen den Zeilen, in denen char implizit als int behandelt wird.

29
Lundin

(Diese Antwort befasst sich mit der C++ - Seite der Dinge, aber das Zeichenerweiterungsproblem existiert auch in C.)

Die Behandlung aller drei char Typen (signed, unsigned und char) ist heikler als es zuerst erscheint. Werte im Bereich von 0 bis _SCHAR_MAX_ (127 für ein 8-Bit-char) sind einfach:

_char c = somevalue;
signed char sc = c;
unsigned char uc = c;
int n = c;
_

Wenn jedoch somevalue außerhalb dieses Bereichs liegt, erhalten Sie beim Durchlaufen von _unsigned char_ konsistente Ergebnisse für die "gleichen" char -Werte in allen drei Typen:

_char c = somevalue;
signed char sc = c;
unsigned char uc = c;
// Might not be true: int(c) == int(sc) and int(c) == int(uc).
int nc = (unsigned char)c;
int nsc = (unsigned char)sc;
int nuc = (unsigned char)uc;
// Always true: nc == nsc and nc == nuc.
_

Dies ist wichtig, wenn Funktionen aus ctype.h verwendet werden, z. B. isupper oder toupper, da das Vorzeichen erweitert wird:

_char c = negative_char;  // Assuming CHAR_MIN < 0.
int n = c;
bool b = isupper(n);  // Undefined behavior.
_

Beachten Sie, dass die Konvertierung durch int implizit ist. Dies hat die gleiche UB:

_char c = negative_char;
bool b = isupper(c);
_

Um dies zu beheben, gehen Sie _unsigned char_ durch, was einfach durch Umschließen von ctype.h Funktionen durch safe_ctype geschieht:

_template<int (&F)(int)>
int safe_ctype(unsigned char c) { return F(c); }

//...
char c = CHAR_MIN;
bool b = safe_ctype<isupper>(c);  // No UB.

std::string s = "value that may contain negative chars; e.g. user input";
std::transform(s.begin(), s.end(), s.begin(), &safe_ctype<toupper>);
// Must wrap toupper to eliminate UB in this case, you can't cast
// to unsigned char because the function is called inside transform.
_

Dies funktioniert, da jede Funktion, die einen der drei Zeichentypen verwendet, auch die anderen beiden Zeichentypen verwenden kann. Es führt zu zwei Funktionen, die mit jedem der Typen umgehen können:

_int ord(char c) { return (unsigned char)c; }
char chr(int n) {
  assert(0 <= n);  // Or other error-/sanity-checking.
  assert(n <= UCHAR_MAX);
  return (unsigned char)n;
}

// Ord and chr are named to match similar functions in other languages
// and libraries.
_

ord(c) gibt Ihnen immer einen nicht negativen Wert - auch wenn ein negativer char oder ein negativer _signed char_ übergeben wurde - und chr nimmt einen beliebigen Wert an ord erzeugt und gibt ihn zurück genau das gleiche char.

In der Praxis würde ich wahrscheinlich nur _unsigned char_ durchgehen, anstatt diese zu verwenden, aber sie umschließen die Besetzung kurz und bündig. Sie bieten einen praktischen Ort, um die Fehlerprüfung für int- bis -char hinzuzufügen. und wäre kürzer und klarer, wenn Sie sie mehrmals in unmittelbarer Nähe verwenden müssen.

16
Fred Nurk

Benutze static_cast<int>:

int num = static_cast<int>(letter); // if letter='a', num=97

Bearbeiten: Sie sollten wahrscheinlich versuchen, die Verwendung zu vermeiden (int)

int num = (int) letter;

check out Warum static_cast <int> (x) anstelle von (int) x verwenden? für weitere Informationen.

11
herohuyongtao

Es hängt davon ab, was Sie mit "konvertieren" meinen.

Wenn Sie eine Reihe von Zeichen haben, die eine Ganzzahl darstellen, wie "123456", gibt es zwei typische Möglichkeiten, dies in C zu tun: Verwenden Sie eine spezielle Konvertierung wie atoi () oder strtol () oder der allgemeine Zweck sscanf () . C++ (das ist wirklich eine andere Sprache, die sich als Upgrade tarnt) fügt einen dritten hinzu, Stringstreams.

Wenn Sie möchten, dass das genaue Bitmuster in einer Ihrer Variablen int als char behandelt wird, ist dies einfacher. In C sind die verschiedenen Integer-Typen tatsächlich eher ein Geisteszustand als tatsächliche separate "Typen". Beginnen Sie einfach damit, wo Sie nach chars gefragt werden, und Sie sollten in Ordnung sein. Möglicherweise benötigen Sie eine explizite Konvertierung, damit der Compiler gelegentlich aufhört zu jammern, aber alles, was Sie tun sollten, ist, zusätzliche Bits nach 256 zu löschen.

6
T.E.D.

Ich habe absolut null Fähigkeiten in C, aber für ein einfaches Parsen:

char* something = "123456";

int number = parseInt(something);

... das hat bei mir geklappt:

int parseInt(char* chars)
{
    int sum = 0;
    int len = strlen(chars);
    for (int x = 0; x < len; x++)
    {
        int n = chars[len - (x + 1)] - '0';
        sum = sum + powInt(n, x);
    }
    return sum;
}

int powInt(int x, int y)
{
    for (int i = 0; i < y; i++)
    {
        x *= 10;
    }
    return x;
}
5
Henke

Möglicherweise möchten Sie diese Konvertierung für die Verwendung von Funktionen aus der C-Standardbibliothek.

In diesem Fall tun (C++ - Syntax)

typedef unsigned char UChar;

char myCppFunc( char c )
{
    return char( someCFunc( UChar( c ) ) );
}

Der Ausdruck UChar( c ) wird in unsigned char konvertiert, um negative Werte zu entfernen, die mit Ausnahme von EOF von den C-Funktionen nicht unterstützt werden.

Das Ergebnis dieses Ausdrucks wird dann als tatsächliches Argument für ein formales Argument int verwendet. Wo Sie automatisch zu int befördert werden. Sie können diesen letzten Schritt auch explizit wie int( UChar( c ) ) schreiben, aber ich persönlich finde das zu ausführlich.

Prost & Hth.,

Für char oder short to int müssen Sie nur den Wert zuweisen.

char ch = 16;
int in = ch;

Dasselbe gilt für int64.

long long lo = ch;

Alle Werte sind 16.

0
Riwels

Ich hatte Probleme, ein Zeichen-Array wie "7c7c7d7d7d7d7c7c7c7d7d7d7d7c7c7c7c7c7c7d7d7c7c7c7c7d7c7d7d7d7c7c2e2e2e" in seinen tatsächlichen Integer-Wert zu konvertieren, der durch "7C" als ein Hexadezimalwert dargestellt werden kann. Nachdem ich um Hilfe gekreuzt hatte, schuf ich dies und dachte, es wäre cool, es zu teilen.

Dies trennt die Zeichenkette in ihre rechten ganzen Zahlen und kann für mehr Leute als nur für mich hilfreich sein;)

unsigned int* char2int(char *a, int len)
{
    int i,u;
    unsigned int *val = malloc(len*sizeof(unsigned long));

    for(i=0,u=0;i<len;i++){
        if(i%2==0){
            if(a[i] <= 57)
                val[u] = (a[i]-50)<<4;
            else
                val[u] = (a[i]-55)<<4;
        }
        else{
            if(a[i] <= 57)
                val[u] += (a[i]-50);
            else
                val[u] += (a[i]-55);
            u++;
        }
    }
    return val;
}

Ich hoffe es hilft!

0
Mathorlaz