Comment convertir un char
en un int
en C et C ++?
c
- clés et c++
, je pense que les réponses face aux deux langues sont raisonnables.
char
cela signifie vraiment.
Comment convertir un char
en un int
en C et C ++?
c
- clés et c++
, je pense que les réponses face aux deux langues sont raisonnables.
char
cela signifie vraiment.
Réponses:
Ça dépend de ce que tu veux faire:
pour lire la valeur sous forme de 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 */
Explication :
a - '0'
est équivalent à ((int)a) - ((int)'0')
, ce qui signifie que les valeurs ascii des caractères sont soustraites les unes des autres. Puisque 0
vient juste avant 1
dans le tableau ascii (et ainsi de suite jusqu'à 9
), la différence entre les deux donne le nombre que le caractère a
représente.
&
-> -10), et il vous donne des nombres supérieurs à 10 (comme x
-> 26)
'1'
fournit un nombre ascii qui ne l'est pas 1
, vous devez supprimer le décalage '0'
pour le réaligner pour qu'il compte de 0 à 9. Les nombres consécutifs 1-9 sont adjacents dans le nombre entier ascii.
Eh bien, en code ASCII, les chiffres (chiffres) commencent à 48 . Il vous suffit de:
int x = (int)character - 48;
'0'
C et C ++ promeuvent toujours les types au moins int
. De plus, les littéraux de caractères sont de type int
en C et char
en C ++.
Vous pouvez convertir un char
type simplement en l'attribuant à un int
.
char c = 'a'; // narrowing on C
int a = c;
operator+()
à cette fin.
int a = c;
) conservera toutes les valeurs négatives que les fonctions de bibliothèque standard C ne peuvent pas gérer. Les fonctions de bibliothèque standard C définissent la norme pour ce que signifie gérer les char
valeurs en tant que int
.
char n'est qu'un entier de 1 octet. Il n'y a rien de magique avec le type char! Tout comme vous pouvez attribuer un short à un int ou un int à un long, vous pouvez affecter un char à un int.
Oui, le nom du type de données primitif se trouve être "char", ce qui laisse entendre qu'il ne doit contenir que des caractères. Mais en réalité, "char" est juste un mauvais choix pour confondre tous ceux qui essaient d'apprendre la langue. Un meilleur nom est int8_t, et vous pouvez utiliser ce nom à la place, si votre compilateur suit la dernière norme C.
Bien que vous sûr devez utiliser le type char lorsque vous effectuez la gestion des chaînes, car l'index des ajustements de table ASCII classique dans 1 octet. Cependant, vous pouvez également manipuler des cordes avec des entiers réguliers, bien qu'il n'y ait aucune raison pratique dans le monde réel pour laquelle vous voudriez faire cela. Par exemple, le code suivant fonctionnera parfaitement:
int str[] = {'h', 'e', 'l', 'l', 'o', '\0' };
for(i=0; i<6; i++)
{
printf("%c", str[i]);
}
Vous devez comprendre que les caractères et les chaînes ne sont que des nombres, comme tout le reste de l'ordinateur. Lorsque vous écrivez «a» dans le code source, il est prétraité en nombre 97, qui est une constante entière.
Donc, si vous écrivez une expression comme
char ch = '5';
ch = ch - '0';
c'est en fait équivalent à
char ch = (int)53;
ch = ch - (int)48;
qui passe ensuite par les promotions entières du langage C
ch = (int)ch - (int)48;
puis tronqué à un caractère pour s'adapter au type de résultat
ch = (char)( (int)ch - (int)48 );
Il y a beaucoup de choses subtiles comme ça entre les lignes, où char est implicitement traité comme un int.
ascii
, vous ne devez pas supposer d'encodage spécifique. La valeur char
égale à int8_t
est incorrecte, car elle pourrait également être uint8_t
ou uint24_t
.
char
vaut toujours 1 octet et si les types int8_t
/ uint8_t
existent sur le système donné (ce qui est très probable), ils pourront ajuster le résultat de a char
, car ce sera alors 8 bits. Sur les systèmes très exotiques tels que divers DSP obsolètes, char
sera de 16 bits et uint8_t
n'existera pas. Écrire du code pour la compatibilité avec les DSP obsolètes est un non-sens, tout comme l'écrire pour la compatibilité avec ses systèmes de complément ou de signe et d'amplitude. Énorme perte de temps, car de tels systèmes existent à peine dans le monde réel.
(Cette réponse concerne le côté C ++ des choses, mais le problème d'extension de signe existe également en C.)
Manipulation des trois char
types ( signed
, unsigned
et char
) est plus délicate qu'il n'y paraît. Les valeurs comprises entre 0 et SCHAR_MAX
(qui est de 127 pour un 8 bits char
) sont faciles:
char c = somevalue;
signed char sc = c;
unsigned char uc = c;
int n = c;
Mais, lorsque se somevalue
situe en dehors de cette plage, le simple unsigned char
fait de vous donner des résultats cohérents pour les "mêmes" char
valeurs 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 lorsque vous utilisez des fonctions de ctype.h , telles que isupper
ou toupper
, en raison de l'extension de signe:
char c = negative_char; // Assuming CHAR_MIN < 0.
int n = c;
bool b = isupper(n); // Undefined behavior.
Notez que la conversion via int est implicite; cela a le même UB:
char c = negative_char;
bool b = isupper(c);
Pour résoudre ce problème, passez par unsigned char
, ce qui se fait facilement en encapsulant les fonctions ctype.h via 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 car toute fonction prenant l'un des trois types de caractères peut également prendre les deux autres types de caractères. 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 en cas de passage négatif char
ou négatif signed char
- et chr
prend n'importe quelle valeur ord
produit et rend exactement la même chose char
.
Dans la pratique, je ferais probablement un cast au unsigned char
lieu de les utiliser, mais ils enveloppent succinctement le cast, fournissent un endroit pratique pour ajouter la vérification des erreurs pour int
-to- char
, et seraient plus courts et plus clairs lorsque vous devez les utiliser plusieurs fois à proximité.
Utilisation static_cast<int>
:
int num = static_cast<int>(letter); // if letter='a', num=97
Edit: Vous devriez probablement essayer d'éviter d'utiliser(int)
int num = (int) lettre;
consultez Pourquoi utiliser static_cast <int> (x) au lieu de (int) x? pour plus d'informations.
Cela dépend en quelque sorte de ce que vous entendez par «convertir».
Si vous avez une série de caractères qui représente un entier, comme "123456", il existe deux façons typiques de le faire en C: Utilisez une conversion à usage spécial comme atoi () ou strtol () , ou le sscanf à usage général () . C ++ (qui est vraiment un langage différent se faisant passer pour une mise à niveau) ajoute un troisième, les flux de chaînes.
Si vous voulez dire que vous voulez que le motif de bits exact dans l'une de vos int
variables soit traité comme un char
, c'est plus facile. En C, les différents types entiers sont vraiment plus un état d'esprit que de véritables "types" séparés. Commencez simplement à l'utiliser là où char
on vous le demande, et ça devrait aller. Vous devrez peut-être une conversion explicite pour que le compilateur arrête de pleurnicher à l'occasion, mais tout ce qui devrait faire est de supprimer tous les bits supplémentaires au-delà de 256.
J'ai absolument des 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 + powInt(n, x);
}
return sum;
}
int powInt(int x, int y)
{
for (int i = 0; i < y; i++)
{
x *= 10;
}
return x;
}
Vraisemblablement, vous voulez cette conversion pour utiliser les fonctions de la bibliothèque standard C.
Dans ce cas, faites (syntaxe C ++)
typedef unsigned char UChar;
char myCppFunc( char c )
{
return char( someCFunc( UChar( c ) ) );
}
L'expression est UChar( c )
convertie unsigned char
en afin de se débarrasser des valeurs négatives qui, à l'exception d'EOF, ne sont pas prises en charge par les fonctions C.
Ensuite, le résultat de cette expression est utilisé comme argument réel pour un int
argument formel. Où vous obtenez une promotion automatique int
. Vous pouvez également écrire cette dernière étape explicitement, comme int( UChar( c ) )
, mais personnellement, je trouve cela trop verbeux.
Santé et hth.,
J'avais des problèmes pour convertir un tableau de caractères comme "7c7c7d7d7d7d7c7c7c7d7d7d7d7c7c7c7c7c7c7d7d7c7c7c7c7d7c7d7d7d7c7c2e2e2e"
dans 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éé cela et j'ai pensé que ce serait cool de partager.
Cela sépare la chaîne de caractères en ses entiers droits, et peut être utile à plus de gens que 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;
}
J'espère que cela aide!
int charToint(char a){
char *p = &a;
int k = atoi(p);
return k;
}
Vous pouvez utiliser cette méthode atoi pour convertir char en int. Pour plus d'informations, vous pouvez vous référer à ce http://www.cplusplus.com/reference/cstdlib/atoi/ , http://www.cplusplus.com/reference/string/stoi/ .