Convertir char en int en C et C++

Dépend de ce que vous voulez faire:

pour lire la valeur comme un code ascii, vous pouvez écrire

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

pour convertir le caractère '0' -> 0 , '1' -> 1 , etc, vous pouvez écrire

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

bien, dans le code ASCII, les nombres (chiffres) commencent par 48 . Tout ce que vous devez faire est:

int x = (int)character - 48;

C et c++ font toujours la promotion des types au moins int . En outre, les caractères littéraux sont de type int en C et char en C++.

vous pouvez convertir un type char simplement en assignant à un int .

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

char est juste un entier de 1 octet. Il n'y a rien de magique avec le type char! Comme vous pouvez attribuer un court à un int ou un int à un long, vous pouvez attribuer un char à un int.

Oui, le nom du type de données primitif se trouve être "char", ce qui insinue qu'il ne doit contenir que des caractères. Mais en réalité, "char" est juste un pauvre nom choisi pour confondre tous ceux qui essaient d'apprendre la langue. Un meilleur nom pour elle est int8_t, et vous pouvez utiliser ce nom au lieu de cela, si votre compilateur suit la dernière norme C.

bien sûr que vous devrait utiliser le type char lors de la manipulation des chaînes de caractères, parce que l'index de la table ASCII classique s'adapte dans 1 octet. Vous pourrait cependant, la manipulation des chaînes régulières ints, bien qu'il n'y a aucune raison pratique dans le monde réel, pourquoi vouloir le faire. Par exemple, le code suivant fonctionnera parfaitement:

  int str[] = {'h', 'e', 'l', 'l', 'o', '"151900920"' };

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

vous devez réaliser que les caractères et les chaînes ne sont que des nombres, comme tout le reste dans l'ordinateur. Lorsque vous écrivez " a " dans le code source, il est pré-traités dans le numéro 97, qui est une constante entière.

donc si vous écrivez une expression comme

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

c'est en fait l'équivalent de

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

qui passe alors à travers les promotions c entier de langue

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

et ensuite tronqué à un char pour s'adapter au type de résultat

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

il y a beaucoup de choses subtiles comme ceci entre les lignes, où char est implicitement traité comme un int.

(cette réponse aborde le côté C++ des choses, mais le problème de l'extension du signe existe aussi en C.)

la manipulation des trois types char ( signed , unsigned , et char ) est plus délicate qu'il n'y paraît. Les valeurs dans la gamme de 0 à SCHAR_MAX (qui est 127 pour un 8-bit char ) sont faciles:

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

mais, quand somevalue est en dehors de cette gamme, passer seulement unsigned char donne vous avez des résultats cohérents pour les" mêmes "valeurs char dans les trois types:

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.

ceci est important lors de l'utilisation des fonctions de ctype.h , tels que isupper ou toupper , en raison de l'extension du signe:

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

Note la conversion par int est implicite; cela a le même UB:

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

pour corriger cela, passer par unsigned char , ce qui est facilement fait par emballage ctype.h fonctions par le biais de 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.

cela fonctionne parce que n'importe quelle fonction prenant l'un des trois types de char peut aussi prendre les deux autres types de char. Il conduit à deux fonctions qui peuvent gérer n'importe lequel des types:

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) vous donne toujours une valeur non négative-même si passé un négatif char ou négatif signed char – et chr prend n'importe quelle valeur ord produit et rend le même char .

dans la pratique, je voudrais probablement juste mouler par unsigned char au lieu d'utiliser ceux-ci, mais ils font envelopper succinctement le moulage, fournir un endroit pratique pour ajouter le contrôle d'erreur pour int - à - char , et serait plus court et plus clair quand vous avez besoin de les utiliser plusieurs fois à proximité.

utiliser static_cast<int> :

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

modifier: vous devriez probablement essayer d'éviter d'utiliser (int)

int num = (int) letter;

check out Pourquoi utiliser static_cast(x) au lieu de (int)x? pour plus d'information.

cela dépend en quelque sorte de ce que vous entendez par"convertir".

si vous avez une série de caractères qui représentent un entier, comme" 123456", alors il y a deux façons typiques de faire cela en C: utilisez une conversion à usage spécial comme atoi () ou strtol () , ou l'usage général sscanf () . C++ (qui est vraiment un langage différent masqué comme une mise à niveau) ajoute un troisième, stringstreams.

si vous voulez dire que vous voulez que le modèle de bits exact dans une de vos variables int soit traité comme un char , c'est plus facile. Dans C les différents types entiers sont vraiment plus d'un État d'esprit que les "types"séparés réels. Il suffit de commencer à l'utiliser où char s sont demandés, et vous devriez être OK. Vous pourriez avoir besoin d'une conversion explicite pour faire que le compilateur cesse de geindre à l'occasion, mais tout ce qui devrait faire est de laisser tomber tout bits supplémentaire au-delà de 256.

je n'ai absolument null compétences en C, mais pour une analyse simple:

char* something = "123456";

int number = parseInt(something);

...cela a fonctionné pour moi:

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 + pow(n, x);
    }
    return sum;
}

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

probablement vous voulez cette conversion pour utiliser des fonctions de la bibliothèque C standard.

dans ce cas, do (syntaxe c++)

typedef unsigned char UChar;

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

l'expression UChar( c ) convertit en unsigned char afin de se débarrasser des valeurs négatives qui, à l'exception de EOF, ne sont pas supportées par les fonctions C.

puis le résultat de cette expression est utilisé comme argument réel pour un int argument formel. Lorsque vous obtenez promotion automatique à int . Vous pouvez aussi écrire cette dernière étape explicitement, comme int( UChar( c ) ) , mais personnellement je trouve cela trop verbeux.

Cheers & hth.,

j'avais des problèmes à convertir un tableau de charge comme "7c7c7d7d7d7d7c7c7c7d7d7d7d7c7c7c7c7c7c7d7d7c7c7c7c7d7c7d7d7d7c7c2e2e2e" en sa valeur entière réelle qui pourrait être représentée par `7C' comme une valeur hexadécimale. Donc, après avoir cherché de l'aide, j'ai créé ceci, et j'ai pensé que ce serait cool de le partager.

cela sépare la chaîne de caractères dans ses entiers droits, et peut être utile à plus de gens que juste moi;)

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

Espère que cela aide!

char ou short int, vous avez juste besoin d'affecter la valeur.

char ch = 16;
int in = ch;

idem à int64.

long long lo = ch;

toutes les valeurs seront 16.