Hoe converteer ik een char naar een int in C en C++?
Antwoord 1, autoriteit 100%
Afhankelijk van wat u wilt doen:
om de waarde als een ascii-code te lezen, kunt u schrijven
char a = 'a';
int ia = (int)a;
/* note that the int cast is not necessary -- int ia = a would suffice */
om het teken '0' -> 0, '1' -> 1, enz., je kunt schrijven
char a = '4';
int ia = a - '0';
/* check here if ia is bounded by 0 and 9 */
Uitleg:
a - '0' is gelijk aan ((int)a) - ((int)'0'), wat betekent dat de ascii-waarden van de tekens van elk worden afgetrokken ander. Aangezien 0 direct voor 1 komt in de ascii-tabel (en zo verder tot 9), geeft het verschil tussen de twee het getal dat het teken a staat voor.
Antwoord 2, autoriteit 21%
Nou, in ASCII-code beginnen de cijfers (cijfers) bij 48. Het enige wat u hoeft te doen is:
int x = (int)character - 48;
Of, aangezien het teken ‘0’ de ASCII-code 48 heeft, kun je gewoon schrijven:
int x = character - '0'; // The (int) cast is not necessary.
Antwoord 3, autoriteit 10%
C en C++ promoten altijd typen naar ten minste int. Verder zijn lettertekens van het type int in C en char in C++.
Je kunt een char-type eenvoudig converteren door het toe te wijzen aan een int.
char c = 'a'; // narrowing on C
int a = c;
Antwoord 4, autoriteit 6%
char is slechts een geheel getal van 1 byte. Er is niets magisch met het char-type! Net zoals je een short aan een int kunt toewijzen, of een int aan een long, kun je een char aan een int toewijzen.
Ja, de naam van het primitieve gegevenstype is toevallig “char”, wat insinueert dat het alleen tekens mag bevatten. Maar in werkelijkheid is "char" is gewoon een slechte naamkeuze om iedereen te verwarren die de taal probeert te leren. Een betere naam ervoor is int8_t, en je kunt die naam gebruiken als je compiler de nieuwste C-standaard volgt.
Hoewel je natuurlijk het char-type moet gebruiken bij het afhandelen van strings, omdat de index van de klassieke ASCII-tabel in 1 byte past. Je zou echter ook string-handling doen met reguliere ints, hoewel er in de echte wereld geen praktische reden is waarom je dat ooit zou willen doen. De volgende code werkt bijvoorbeeld perfect:
int str[] = {'h', 'e', 'l', 'l', 'o', '\0' };
for(i=0; i<6; i++)
{
printf("%c", str[i]);
}
Je moet je realiseren dat karakters en strings slechts cijfers zijn, net als al het andere op de computer. Wanneer u ‘a’ in de broncode schrijft, wordt deze voorverwerkt tot het getal 97, wat een geheel getalconstante is.
Dus als je een uitdrukking schrijft zoals
char ch = '5';
ch = ch - '0';
dit is eigenlijk gelijk aan
char ch = (int)53;
ch = ch - (int)48;
die dan door de C-taal gehele promoties gaat
ch = (int)ch - (int)48;
en vervolgens afgekapt tot een teken om in het resultaattype te passen
ch = (char)( (int)ch - (int)48 );
Er gebeuren veel subtiele dingen zoals deze tussen de regels, waarbij char impliciet wordt behandeld als een int.
Antwoord 5, autoriteit 3%
(Dit antwoord behandelt de C++-kant van de zaak, maar het probleem met de tekenuitbreiding bestaat ook in C.)
Het omgaan met alle drie de typen char (signed, unsigned en char) is delicater dan eerst komt naar voren. Waarden in het bereik van 0 tot SCHAR_MAX (wat 127 is voor een 8-bits char) zijn eenvoudig:
char c = somevalue;
signed char sc = c;
unsigned char uc = c;
int n = c;
Maar wanneer somevalue buiten dat bereik valt, geeft alleen het doorlopen van unsigned char consistente resultaten voor de “dezelfde” char-waarden in alle drie de soorten:
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.
Dit is belangrijk bij gebruik van functies van ctype.h, zoals isupper of toupper, vanwege tekenextensie:
char c = negative_char; // Assuming CHAR_MIN < 0.
int n = c;
bool b = isupper(n); // Undefined behavior.
Merk op dat de conversie via int impliciet is; dit heeft dezelfde UB:
char c = negative_char;
bool b = isupper(c);
Om dit op te lossen, ga je door unsigned char, wat gemakkelijk gedaan kan worden door ctype.h-functies te verpakken 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.
Dit werkt omdat elke functie die een van de drie char-typen gebruikt, ook de andere twee char-typen kan aannemen. Het leidt tot twee functies die elk van de typen aankunnen:
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) geeft je altijd een niet-negatieve waarde zelfs wanneer een negatief char of een negatief signed char en chr neemt elke waarde die ord produceert en geeft exact dezelfde char terug.
In de praktijk zou ik waarschijnlijk gewoon door unsigned char casten in plaats van deze te gebruiken, maar ze vatten de cast beknopt samen en bieden een handige plek om foutcontrole toe te voegen voor int-to-char, en zou korter en duidelijker zijn als je ze meerdere keren in de buurt moet gebruiken.
Antwoord 6, autoriteit 2%
Gebruik static_cast<int>:
int num = static_cast<int>(letter); // if letter='a', num=97
Bewerken: u moet waarschijnlijk proberen het gebruik van (int)
te vermijden
int num = (int) letter;
bekijk Waarom static_cast<int>(x) gebruiken in plaats van (int)x? voor meer info.
Antwoord 7, autoriteit 2%
Ik heb absoluut null-vaardigheden in C, maar voor een eenvoudige ontleding:
char* something = "123456";
int number = parseInt(something);
…dit werkte voor mij:
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;
}
Antwoord 8
Het hangt er een beetje van af wat je bedoelt met “converteren”.
Als je een reeks tekens hebt die een geheel getal vertegenwoordigt, zoals “123456”, dan zijn er twee typische manieren om dat te doen in C: Gebruik een speciale conversie zoals atoi() of strtol(), of de algemene sscanf(). C++ (wat eigenlijk een andere taal is die zich voordoet als een upgrade) voegt een derde toe, stringstreams.
Als je bedoelt dat je wilt dat het exacte bitpatroon in een van je int-variabelen wordt behandeld als een char, dan is dat makkelijker. In C zijn de verschillende integer-types eigenlijk meer een gemoedstoestand dan daadwerkelijke afzonderlijke “types”. Begin het gewoon te gebruiken waar chars wordt gevraagd, en je zou in orde moeten zijn. Mogelijk hebt u een expliciete conversie nodig om de compiler af en toe te laten stoppen met zeuren, maar het enige dat u hoeft te doen, is alle extra bits voorbij 256 laten vallen.
Antwoord 9
Vermoedelijk wilt u deze conversie voor het gebruik van functies uit de C-standaardbibliotheek.
Doe in dat geval (C++ syntaxis)
typedef unsigned char UChar;
char myCppFunc( char c )
{
return char( someCFunc( UChar( c ) ) );
}
De uitdrukking UChar( c ) converteert naar unsigned char om negatieve waarden te verwijderen, die, behalve EOF, niet worden ondersteund door de C-functies.
Dan wordt het resultaat van die uitdrukking gebruikt als feitelijk argument voor een int formeel argument. Waar je automatische promotie krijgt naar int. Je kunt die laatste stap ook expliciet schrijven, zoals int( UChar( c ) ), maar persoonlijk vind ik dat te uitgebreid.
Proost & hth.,
Antwoord 10
Ik had problemen met het converteren van een char-array zoals "7c7c7d7d7d7d7c7c7c7d7d7d7d7c7c7c7c7c7c7d7d7c7c7c7c7d7c7d7d7d7c7c2e2e2e" in de werkelijke waarde van een hexadecimaal hexadecimaal. Dus nadat ik om hulp had gevraagd, heb ik dit gemaakt en ik dacht dat het cool zou zijn om te delen.
Dit scheidt de tekenreeks char in de juiste gehele getallen en kan nuttig zijn voor meer mensen dan alleen ik;)
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;
}
Hopelijk helpt het!
Antwoord 11
Voor char of short to int hoef je alleen maar de waarde toe te wijzen.
char ch = 16;
int in = ch;
Hetzelfde als int64.
long long lo = ch;
Alle waarden zijn 16.
Antwoord 12
int charToint(char a){
char *p = &a;
int k = atoi(p);
return k;
}
Je kunt deze atoi-methode gebruiken om char naar int te converteren. Voor meer informatie kunt u deze http://www.cplusplus.com/reference/ raadplegen cstdlib/atoi/ , http://www.cplusplus.com/reference/ string/stoi/.