Konvertieren von char zu int in C#

Ich habe einen char in c#:

char foo = '2';

Nun möchte ich die 2 in einen int. Ich finde, dass Konvertieren.ToInt32 liefert die tatsächlichen Dezimalwert des char und nicht die Zahl 2. Die folgenden arbeiten:

int bar = Convert.ToInt32(new string(foo, 1));

int.Parsen funktioniert nur auf strings.

Gibt es keine native Funktion in C# zu gehen, einen char zu int, ohne dass es ein string? Ich weiß, das ist trivial, aber es scheint nur seltsam, dass es nichts natives, um direkt die Konvertierung.

InformationsquelleAutor KeithA | 2008-10-27

c#char int

119

Interessante Antworten, aber die docs sagen anders:

Verwenden Sie die GetNumericValue Methoden
konvertieren Char - Objekt darstellt
eine Zahl in einen numerischen Wert geben. Verwenden
Parse und TryParse konvertieren
Zeichen in einer Zeichenfolge in eine Char
Objekt. Verwenden ToString konvertieren Char
Objekt zu einem String Objekt.

http://msdn.microsoft.com/en-us/library/system.char.aspx
- ahh! also es ist etwas eigenes! Seltsam, dass es gibt ein double zurück. Ich mag diese Antwort besser. Danke für den Hinweis it out.
- Es gibt einen Grund für Sie, um zurückzukehren, Doppel: char.GetNumericValue('¼') Erträge 0.25. Die Freuden des Unicode... 😉
- Dies ist nicht eine Antwort, das beantwortet die eigentliche Frage, Char.GetNumericValue('o'), Char.GetNumericValue('w') und alle nicht numerische char wird immer -1 zurück - Jeremy Ruten gepostet hat die richtige Antwort
- im Fall der ursprünglichen Frage - Fragen, speziell, wo er weiß, der char stellt eine Zahl dar - das ist die richtige Antwort
- Ich glaube nicht, dass so die ursprüngliche Frage verlangt char zu int ohne Verwendung string ersten.
InformationsquelleAutor Chad Grant
141

Dieser konvertiert es in ein int:
```
char foo = '2';
int bar = foo - '0';
```
Dies funktioniert, da jedes Zeichen wird intern durch eine Zahl dargestellt. Die Zeichen '0' bis '9' dargestellt, die von aufeinander folgenden zahlen, so ist das finden der Unterschied zwischen dem Zeichen '0' und '2' ergibt die Zahl 2.
- Noch wichtiger ist, warum war es nach unten gestimmt?
- Es funktioniert, weil 0 ist 48.
- Downvoting, denn ich kann nur sehen, Mechanismus, nicht Absicht.
- Es setzt ein gewisses Zeichen gesetzt.
- Nein ist es nicht, solange die Ziffern in Reihenfolge (die Compiler erfordern von den charset), es wird funktionieren, egal, welchen Wert Sie auf start.
- Das ist in Ordnung, außer, dass Sie immer noch müssen, tun bounds-checking erste, und an diesem Punkt bin ich mir nicht sicher, ob int.parse(foo.ToString()) ist schneller.
- Nettes kleines hack!
- Aber das ist eine sichere Annahme in C#: char ist immer UTF-16.
- Das funktioniert bei Buchstaben auch... also könnte man tun: char foo = 'b'; int bar = foo - 'a'; // jetzt können Sie sehen, dass die 'bar' ist der 2. Buchstabe (index 1), der im alphabet.
- kleiner Punkt und jetzt alt, aber in der Zeit, da Sie dies geschrieben hatten wir Kern kommen, die UTF-8 verwendet. Noch eine sichere Annahme, obwohl.
- Das ist nicht wahr, char im .Net Core ist immer noch UTF-16. Es gibt Arbeit, die getan zum hinzufügen von UTF-8-string in einer zukünftigen version .Net Core, aber auch das wird sich nicht ändern char.
- Einfach nur wow ... beeindruckend. Und ich ' ve wurden arbeiten mit char-sets den ganzen Tag lang mit schweren Konvertierung zu int / uint dezimal (d.h. numerische) Werte, die größer als / kleiner-als-Vergleiche, etc, aber nie gedacht, dass diese einfache, aber geniale Weise.
InformationsquelleAutor Jeremy Ruten
70

Hat jemand betrachtet, mit int.Parse() und int.TryParse() wie diese
```
int bar = int.Parse(foo.ToString());
```
Sogar besser wie dieser
```
int bar;
if (!int.TryParse(foo.ToString(), out bar))
{
    //Do something to correct the problem
}
```
Es ist viel sicherer und weniger fehleranfällig
- Absolut der richtige Ansatz. Wählen Sie die erste, wenn Sie wollen, nicht-int-Eingänge zu werfen, der zweite, wenn Sie möchten, etwas anderes zu tun.
- Dies ist ein guter Ansatz für eine generische Konvertierung-Methode. Nebenbei, ist ein weiteres Beispiel dafür, wie .NET fördert bloatware. (Ich meine, gehen auf und unit-test TryParse() und ToString() - Sie können es nicht, praktisch nicht).
- Nein, es ist ein Beispiel dafür, wie eine Antwort auf StackOverflow fördert bloatware. Dies ist in der Tat unnötig aufgebläht, und ich verstehe nicht, warum diese als überlegen betrachtet Subtraktion '0' aus dem char.
InformationsquelleAutor faulty
27
```
char c = '1';
int i = (int)(c-'0');
```
und Sie können erstellen Sie eine statische Methode aus:
```
static int ToInt(this char c)
{
    return (int)(c - '0');
}
```
- Dies ist, was ich suchte. Könnten Sie vielleicht erklären, was Sie tun mit den minus-null Teil.
InformationsquelleAutor sontek
8

Versuchen, Diese
```
char x = '9'; //'9' = ASCII 57

int b = x - '0'; //That is '9' - '0' = 57 - 48 = 9
```
- Dein Kommentar sagt '9', aber dein code hat 9, die nicht kompiliert wird.
InformationsquelleAutor RollerCosta
7

Standardmäßig UNICODE verwenden, so empfehle ich die Nutzung fehlerhafter Methode

int bar = int.Parse(foo.ToString());

Obwohl die numerischen Werte unter den gleichen Ziffern und basic-Latin-Zeichen.

InformationsquelleAutor Nikolay
3

Dieser wandelt einen integer und handles unicode

CharUnicodeInfo.GetDecimalDigitValue('2')

Lesen Sie mehr hier.

InformationsquelleAutor Dan Friedman
2

Prinzip:
```
char foo = '2';
int bar = foo & 15;
```
Den binären ASCII-Charaktere 0-9 ist:
```
0   -   0011 0000
1   -   0011 0001
2   -   0011 0010
3   -   0011 0011
4   -   0011 0100
5   -   0011 0101
6   -   0011 0110
7   -   0011 0111
8   -   0011 1000
9   -   0011 1001
```
wenn Sie in jedem von Ihnen die ersten 4 LSB (bitweise UND mit 8'b00001111, dass gleich 15) erhält man die tatsächliche Anzahl (0000 = 0,0001=1,0010=2,... )

Verwendung:
```
public static int CharToInt(char c)
{
    return 0b0000_1111 & (byte) c;
}
```
- Während dieses code-snippet, das die Lösung sein kann, einschließlich einer Erklärung die wirklich hilft, zu verbessern, die Qualität Ihrer post. Denken Sie daran, dass Sie die Beantwortung der Frage für den Leser in der Zukunft, und die Menschen vielleicht nicht wissen, die Gründe für deinen code-Vorschlag.
InformationsquelleAutor Tomer Wolberg
1

Der richtige Weg ist:

int theNameOfYourInt = (int).Char.GetNumericValue(theNameOfYourChar);

"theNameOfYourInt" - int Sie wollen Ihren char umgewandelt werden.

"theNameOfYourChar" - Der Char Sie verwendet werden soll, so wird es umgewandelt in ein int.

Lassen alles andere sein.

InformationsquelleAutor Normantas Stankevičius

Vergleich einiger Methoden, die sich auf das Ergebnis, wenn der Charakter sich nicht um eine ASCII-Ziffer:

char c = '\n';                              
Debug.Print($"{c & 15}");                   //10
Debug.Print($"{c ^ 48}");                   //58
Debug.Print($"{c - 48}");                   //-38
Debug.Print($"{(uint)c - 48}");             //4294967258
Debug.Print($"{char.GetNumericValue(c)}");  //-1

InformationsquelleAutor Slai

0

Ich bin mit Compact Framework 3.5, und nicht ein "char.Parse" - Methode.
Ich denke, dass ist nicht schlecht, verwenden Sie die Convert-Klasse. (Siehe " CLR via C#, Jeffrey Richter)
```
char letterA = Convert.ToChar(65);
Console.WriteLine(letterA);
letterA = 'あ';
ushort valueA = Convert.ToUInt16(letterA);
Console.WriteLine(valueA);
char japaneseA = Convert.ToChar(valueA);
Console.WriteLine(japaneseA);
```
Arbeitet mit ASCII-char-oder Unicode-char

InformationsquelleAutor antonio
0

Ich bin einverstanden mit @Chad Grant

Auch Recht, wenn Sie konvertieren zu einem string können Sie dann diesen Wert als numerischer Wert, wie gesagt, in der Frage
```
int bar = Convert.ToInt32(new string(foo, 1)); //=> gives bar=2
```
Habe ich versucht, um einen einfachen und verständlichen Beispiel
```
char v = '1';
int vv = (int)char.GetNumericValue(v); 
```
char.GetNumericValue(v) gibt an, wie Doppel-und wandelt (int)

Mehr Advenced Nutzung als array
```
int[] values = "41234".ToArray().Select(c=> (int)char.GetNumericValue(c)).ToArray();
```
InformationsquelleAutor Hamit YILDIRIM
-4

Ich habe gesehen, viele Antworten, aber Sie scheinen verwirrend für mich. Können wir nicht einfach nur die Verwendung von Type-Casting.

Für die ex:-
```
int s;
char i= '2';
s = (int) i;
```
- Dies würde die Rückkehr der ASCII-code des Zeichens 2 und nicht der Wert 2.
- Dann, wie über die Verwendung von char.GetNumericValue (Es gibt einen double-Wert) und Umwandlung zu int.
- Yup, das ist, was @Chad Grant ' s akzeptiert Antwort schlägt
InformationsquelleAutor Learner
-5

Dieser arbeitete für mich:
```
int bar = int.Parse("" + foo);
```
- Wie unterscheidet sich das von der int.Parse(foo.ToString()), außer dass Sie weniger lesbar?
InformationsquelleAutor Renán Díaz

Schreibe einen Kommentar

Du musst angemeldet sein, um einen Kommentar abzugeben.