Converti char in int in C e C ++

Come posso convertire a charin un intin C e C ++?

Dipende da cosa vuoi fare:

per leggere il valore come codice ASCII, è possibile scrivere

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

per convertire il carattere '0' -> 0, '1' -> 1ecc, è possibile scrivere

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

Spiegazione :
a - '0'è equivalente a ((int)a) - ((int)'0'), il che significa che i valori ascii dei caratteri vengono sottratti l'uno dall'altro. Poiché 0viene direttamente prima 1nella tabella ASCII (e così via fino a 9), la differenza tra i due dà il numero che il personaggio arappresenta.

Bene, nel codice ASCII, i numeri (cifre) iniziano da 48 . Tutto quello che devi fare è:

int x = (int)character - 48;

C e C ++ promuovono sempre i tipi almeno int. Inoltre i caratteri letterali sono di tipo intin C e charin C ++.

È possibile convertire un chartipo semplicemente assegnando a un int.

char c = 'a'; // narrowing on C
int a = c;

char è solo un numero intero di 1 byte. Non c'è nulla di magico con il tipo di carattere! Così come puoi assegnare un short a un int o un int a un long, puoi assegnare un char a un int.

Sì, il nome del tipo di dati primitivo sembra essere "char", il che insinua che dovrebbe contenere solo caratteri. Ma in realtà, "char" è solo un povero nome scelto per confondere tutti coloro che cercano di imparare la lingua. Un nome migliore per questo è int8_t, e puoi invece usare quel nome, se il tuo compilatore segue l'ultimo standard C.

Sebbene, naturalmente, dovresti usare il tipo char quando esegui la gestione delle stringhe, perché l'indice della classica tabella ASCII si adatta a 1 byte. Si potrebbe tuttavia fare la gestione delle stringhe con interi normale così, anche se non v'è alcuna ragione pratica nel mondo reale motivo per cui si vorrebbe mai farlo. Ad esempio, il seguente codice funzionerà perfettamente:

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

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

Devi capire che i caratteri e le stringhe sono solo numeri, come tutto il resto nel computer. Quando scrivi 'a' nel codice sorgente, viene pre-elaborato nel numero 97, che è una costante intera.

Quindi se scrivi un'espressione simile

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

questo è in realtà equivalente a

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

che passa quindi attraverso le promozioni di numeri interi in linguaggio C.

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

e quindi troncato a un carattere per adattarsi al tipo di risultato

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

Ci sono molte cose sottili come questa tra le righe, in cui char è implicitamente trattato come un int.

(Questa risposta si rivolge al lato C ++ delle cose, ma il problema dell'estensione del segno esiste anche in C).

Manipolazione tutti e tre i chartipi ( signed, unsigned, e char) è più delicato di quello che appare prima. I valori nell'intervallo da 0 a SCHAR_MAX(che è 127 per un 8 bit char) sono semplici:

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

Ma, quando somevalueè al di fuori di tale intervallo, solo passare attraverso unsigned charti dà risultati coerenti per gli "stessi" charvalori in tutti e tre i tipi:

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.

Questo è importante quando si usano le funzioni di ctype.h , come isuppero toupper, a causa dell'estensione del segno:

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

Si noti che la conversione tramite int è implicita; questo ha lo stesso UB:

char c = negative_char;
bool b = isupper(c);

Per risolvere questo problema, vai avanti unsigned char, cosa che si può fare facilmente avvolgendo le funzioni ctype.h tramite safe_ctype :

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.

Questo funziona perché qualsiasi funzione che accetta uno dei tre tipi di carattere può prendere anche gli altri due tipi di carattere. Porta a due funzioni che possono gestire qualsiasi tipo:

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)ti dà sempre un valore non negativo - anche quando viene passato un valore negativo charo negativo signed char- e chrprende qualsiasi valore ordproduce e restituisce esattamente lo stesso char.

In pratica, probabilmente verrei semplicemente a sfogliarlo unsigned charinvece di usarli, ma avvolgono in modo succinto il cast, forniscono un posto conveniente per aggiungere il controllo degli errori per int-to- chare sarebbero più brevi e più chiari quando è necessario utilizzarli più volte nelle vicinanze.

Utilizzare static_cast<int>:

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

Modifica: probabilmente dovresti cercare di evitare di usarlo(int)

int num = (int) lettera;

controlla Perché usare static_cast <int> (x) invece di (int) x? per maggiori informazioni.

Dipende da cosa intendi per "convertire".

Se hai una serie di caratteri che rappresenta un numero intero, come "123456", allora ci sono due modi tipici per farlo in C: Usa una conversione per scopi speciali come atoi () o strtol () o lo sscanf per scopi generici () . Il C ++ (che in realtà è un linguaggio diverso mascherato da aggiornamento) aggiunge un terzo, stringhe di stream.

Se vuoi dire che vuoi che lo schema di bit esatto in una delle tue intvariabili sia trattato come un char, è più facile. In C i diversi tipi interi sono in realtà più di uno stato d'animo rispetto ai "tipi" separati effettivi. Inizia a usarlo dove charsono richiesti e dovresti essere OK. Potresti aver bisogno di una conversione esplicita per far sì che il compilatore smetta di piagnucolare occasionalmente, ma tutto ciò che dovrebbe fare è eliminare eventuali bit extra oltre 256.

Ho delle nullabilità assolute in C, ma per una semplice analisi:

char* something = "123456";

int number = parseInt(something);

... questo ha funzionato per me:

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

Presumibilmente vuoi questa conversione per usare le funzioni della libreria standard C.

In tal caso, do (sintassi C ++)

typedef unsigned char UChar;

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

L'espressione viene UChar( c )convertita unsigned charin per eliminare i valori negativi che, ad eccezione di EOF, non sono supportati dalle funzioni C.

Quindi il risultato di quell'espressione viene usato come argomento effettivo per un intargomento formale. Dove si ottiene la promozione automatica int. In alternativa puoi scrivere esplicitamente l'ultimo passaggio, come int( UChar( c ) ), ma personalmente lo trovo troppo dettagliato.

Saluti e hth.,

Avevo problemi a convertire un array di caratteri come "7c7c7d7d7d7d7c7c7c7d7d7d7d7c7c7c7c7c7c7d7d7c7c7c7c7d7c7d7d7d7c7c2e2e2e"nel suo valore intero effettivo che sarebbe stato rappresentato da `7C 'come un valore esadecimale. Quindi, dopo aver navigato per chiedere aiuto, l'ho creato e ho pensato che sarebbe stato bello condividerlo.

Questo separa la stringa di caratteri nei suoi numeri interi giusti e può essere utile a più persone rispetto a me;)

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

Spero che sia d'aiuto!

Per char o short to int, devi solo assegnare il valore.

char ch = 16;
int in = ch;

Lo stesso per int64.

long long lo = ch;

Tutti i valori saranno 16.

int charToint(char a){
char *p = &a;
int k = atoi(p);
return k;
}

Puoi usare questo metodo atoi per convertire char in int. Per ulteriori informazioni, è possibile fare riferimento a questo http://www.cplusplus.com/reference/cstdlib/atoi/ , http://www.cplusplus.com/reference/string/stoi/ .