C++ Char-Datentyp mit Beispielen

Was ist Char?

Char ist ein C++-Datentyp zum Speichern von Buchstaben. Char ist ein Akronym für ein Zeichen. Es ist ein ganzzahliger Datentyp, was bedeutet, dass der Wert als ganze Zahl gespeichert wird. Ein Zeichen nimmt eine Speichergröße von 1 Byte ein. Es speichert auch ein einzelnes Zeichen.

In diesem C++-Tutorial lernen Sie:

Was ist Char?
Was ist ASCII?
Char-Deklaration
Syntax:
ASCII-Wert drucken
Zeichenwert drucken
Zeichen eingeben
Zeichen in Zeichenkette umwandeln

Was ist ASCII?

Der char-Wert wird als ASCII-Zeichen interpretiert. Dies ähnelt der Art und Weise, wie boolesche Werte als wahr oder falsch interpretiert werden. ASCII ist ein Akronym für American Standard Code for Information Interchange. Es definiert eine bestimmte Art, englische Zeichen als Zahlen darzustellen.

Die Zahlen liegen zwischen 0 und 127. Das Zeichen „a“ entspricht beispielsweise dem ASCII-Code 97.

Char-Deklaration

Um eine char-Variable in C++ zu deklarieren, verwenden wir das Schlüsselwort char. Darauf sollte der Name der Variablen folgen. Die Variable kann zum Zeitpunkt der Deklaration initialisiert werden. Der Wert der Variablen sollte in einfache Anführungszeichen gesetzt werden.

Syntax:

Hier ist die Syntax für die Zeichendeklaration in C++:

char variable-name;

Der Variablenname ist der Name, der der Variablen zugewiesen werden soll.

Wenn zum Zeitpunkt der Deklaration ein Wert zugewiesen werden soll, können Sie diese Syntax verwenden:

char variable-name = 'value';

Der Variablenname ist der Name der char-Variablen.
Der Wert ist der Wert, der der char-Variablen zugewiesen werden soll.

Beispiel 1:

#include <iostream>
using namespace std;
int main() {
	char grade = 'B';
	cout << "I scored a: "<<grade;
	return 0;
}

Ausgabe:

Hier ist ein Screenshot des Codes:

Code-Erklärung:

Einschließen der iostream-Header-Datei in unseren Code, um ihre Funktionen zu nutzen.
Einschließen des std-Namensraums in unseren Code, um seine Klassen zu verwenden, ohne ihn aufzurufen.
Aufruf der main()-Funktion. Die Programmlogik sollte innerhalb des Hauptteils dieser Funktion hinzugefügt werden.
Deklarieren Sie eine Zeichenvariable namens grade. Der Variablen wurde auch der Wert B zugewiesen. Beachten Sie, dass der Wert der Variablen in einfache Anführungszeichen eingeschlossen ist.
Drucken Sie den Wert der Variablen grade zusammen mit anderem Text auf der Konsole.
Das Programm muss nach erfolgreichem Abschluss einen Wert zurückgeben.
Ende des Hauptteils der Funktion main().

ASCII-Wert drucken

Wie oben erwähnt, wird jedes Zeichen als ASCII-Zeichen interpretiert. Es ist möglich, den ASCII-Wert eines beliebigen Zeichens zu erhalten. Sie übergeben das Zeichen einfach an die Funktion int(). Dieser Vorgang wird Type Casting genannt. Lassen Sie uns dies demonstrieren:

Beispiel 2:

#include <iostream>
using namespace std;
int main() {
	char ch;
	cout << "Enter any character: ";
	cin >> ch;
	cout << "The ASCII Value of " << ch << " is " << int(ch);
	return 0;
}

Ausgabe:

Hier ist ein Screenshot des Codes:

Code-Erklärung:

Einbinden der iostream-Header-Datei in unseren Code, um ihre Funktionen zu nutzen.
Einschließen des std-Namensraums in unseren Code, um seine Klassen zu verwenden, ohne ihn aufzurufen.
Aufruf der main()-Funktion. Die Programmlogik sollte innerhalb des Hauptteils dieser Funktion hinzugefügt werden.
Deklarieren Sie eine char-Variable namens ch.
Drucken Sie etwas Text auf der Konsole. Der Text fordert den Benutzer auf, einen Wert für die Variable ch einzugeben.
Lesen Sie die Benutzereingaben von der Tastatur und speichern Sie sie in der Variablen ch.
Drucken Sie etwas Text auf der Konsole. Der Text enthält das Zeichen, das Sie für die Variable ch eingegeben haben, den ASCII-Wert dieses Zeichens und anderen Text.
Das Programm muss nach erfolgreichem Abschluss einen Wert zurückgeben.
Ende des Hauptteils der Funktion main().

Zeichenwert drucken

Bei einem ASCII-Wert kann der C++-Compiler das entsprechende Zeichen zurückgeben. Sie deklarieren eine char-Variable und weisen ihr einen ganzzahligen Wert zu. Es wird in den entsprechenden Zeichenwert umgewandelt.

Beispiel 3:

#include <iostream>
using namespace std;
int main() {
	char x = 64, y = 66, z = 71;
	cout << x;
	cout << y;
	cout << z;
	return 0;
}

Ausgabe:

Hier ist ein Screenshot des Codes:

Code-Erklärung:

Einschließen der iostream-Header-Datei in den Code. Wir werden dann seine Funktionen verwenden, ohne Fehler zu erhalten.
Fügen Sie den std-Namespace in den Code ein. Wir werden ihre Klassen verwenden, ohne sie aufzurufen.
Aufruf der main()-Funktion. Die Programmlogik sollte in den Körper dieser Funktion gehen.
Deklarieren Sie drei char-Variablen x, y und z. Den drei wurden ganzzahlige Werte von 65, 66 und 67 zugewiesen. Diese werden als ASCII-Werte für Zeichen behandelt.
Den Wert der Variablen x auf der Konsole ausgeben. Da x als Zeichen deklariert wurde, wird das Zeichen mit dem ASCII-Wert 65 zurückgegeben, also A.
Den Wert der Variablen y auf der Konsole ausgeben. Da y als Zeichen deklariert wurde, wird das Zeichen mit dem ASCII-Wert 66 zurückgegeben, also B.
Den Wert der Variablen z auf der Konsole ausgeben. Da z als Zeichen deklariert wurde, wird das Zeichen mit dem ASCII-Wert 67 zurückgegeben, also C.
Das Programm muss nach erfolgreichem Abschluss einen Wert zurückgeben.
Das Ende des Hauptteils der Funktion main().

Zeichen eingeben

Wir können die Funktion std::cin verwenden, um ein vom Benutzer über die Tastatur eingegebenes Zeichen zu lesen. Mit std::cin können Sie viele Zeichen eingeben. Die Zeichenvariable kann jedoch nur ein Zeichen enthalten. Das bedeutet, dass nur das erste eingegebene Zeichen extrahiert und in der Zeichenvariablen gespeichert wird. Der Rest bleibt im Puffer, der von std::cin verwendet wird. Führen Sie zum Extrahieren nachfolgende Aufrufe an std::cin durch.

Beispiel 4:

#include <iostream>
using namespace std;
int main() {
	cout << "Type a sequence of characters: "; 
	char ch;
	cin >> ch; 
	cout <<"The ASCII code of "<< ch << " is "<< int(ch) << '\n';
	cin >> ch; 
	cout <<"The ASCII code of " << ch << " is "<< int(ch) << '\n';
	return 0;
}

Ausgabe:

Hier ist ein Screenshot des Codes:

Code-Erklärung:

Einschließen der iostream-Header-Datei in unseren Code, um ihre Funktionen zu nutzen.
Fügen Sie den std-Namespace in unseren Code ein, um seine Klassen zu verwenden, ohne ihn aufzurufen.
Aufruf der main()-Funktion. Die Programmlogik sollte innerhalb des Hauptteils dieser Funktion hinzugefügt werden.
Drucken Sie etwas Text auf der Konsole.
Deklarieren Sie eine Zeichenvariable namens ch.
Lesen Sie Benutzereingaben von der Tastatur. Die Eingabe wird in der Variablen ch gespeichert. Da ein Benutzer eine Zeichenfolge wie abc eingibt, wird nur das erste Zeichen, a, in der Variablen ch gespeichert.
Drucken des ersten eingegebenen Zeichens, seines ASCII-Codes und anderen Textes auf der Konsole. Der ASCII-Code wird bestimmt, indem die Zeichenvariable an die Funktion int() übergeben wird.
Lesen Sie das nächste Zeichen, das vom Benutzer eingegeben wurde. Der Benutzer muss kein neues Zeichen eingeben. Stattdessen liest es das zweite eingegebene Zeichen, also b.
Drucken des zweiten eingegebenen Zeichens, seines ASCII-Codes und anderen Textes auf der Konsole. Der ASCII-Code wird bestimmt, indem die Zeichenvariable an die Funktion int() übergeben wird.
Das Programm muss nach erfolgreichem Abschluss einen Wert zurückgeben.
Ende des Hauptteils der Funktion main().

Zeichen in Zeichenkette umwandeln

Es gibt eine Reihe von Möglichkeiten, wie wir Zeichen in Zeichenfolgen umwandeln können.

Lassen Sie uns darüber sprechen:

#1:Konstruktor verwenden, der von einer String-Klasse gegeben wird

Dies kann mit der folgenden Syntax erfolgen:

string st(int n,char x);

Der Parameter n bezeichnet die Größe des zu erzeugenden Strings.

Der Parameter x ist das Zeichen, das in einen String konvertiert werden soll.

Die Funktion gibt einen String zurück.

Beispiel 5:

#include<iostream>
#include <string>
using namespace std;
int main() {
	string st(1, 'C');
	cout << "The resulting string is : " << st;
	return 0;
}

Ausgabe:

Hier ist ein Screenshot des Codes:

Code-Erklärung:

Einschließen der iostream-Header-Datei in unseren Code, um ihre Funktionen zu nutzen.
Fügen Sie die String-Header-Datei in unseren Code ein, um ihre Funktionen zu verwenden.
Fügen Sie den std-Namespace in unseren Code ein, um seine Klassen zu verwenden, ohne ihn aufzurufen.
Aufruf der main()-Funktion. Die Programmlogik sollte innerhalb des Hauptteils dieser Funktion hinzugefügt werden.
Wandle das Zeichen „C“ in einen String der Länge 1 um und weise den resultierenden String der Variablen st zu.
Den Wert der Zeichenfolge st auf der Konsole zusammen mit anderem Text ausgeben.
Das Programm muss nach erfolgreichem Abschluss einen Wert zurückgeben.
Ende des Hauptteils der Funktion main().

#2) Verwenden der std::string-Operatoren =und +=

Die Operatoren =und +=sind bereits mit Zeichen überladen. Die beiden können verwendet werden, um ein bestimmtes Zeichen in eine Zeichenfolge umzuwandeln.

Beispiel 6:

#include<iostream>
#include <string>
using namespace std;
int main() {
	string st;
	char b = 'B';
	st = 'A';
	st += b;
	cout << "The resulting string is : " << st;
	return 0;
}

Ausgabe:

Hier ist ein Screenshot des Codes:

Code-Erklärung:

Fügen Sie die iostream-Header-Datei in unseren Code ein, um ihre Funktionen zu nutzen.
Fügen Sie die String-Header-Datei in unseren Code ein, um ihre Funktionen zu verwenden.
Fügen Sie den std-Namespace in unseren Code ein, um seine Klassen zu verwenden, ohne ihn aufzurufen.
Aufruf der main()-Funktion. Die Programmlogik sollte innerhalb des Hauptteils dieser Funktion hinzugefügt werden.
Erstellen Sie eine Zeichenfolgenvariable namens st.
Erstellen Sie ein Zeichen namens b mit dem Wert B.
Weisen Sie der Zeichenfolge namens st den Wert A zu.
Verwenden Sie den Operator +=, um Zeichen in eine Zeichenfolge umzuwandeln.
Den Wert der Zeichenfolge st auf der Konsole zusammen mit anderem Text ausgeben.
Das Programm muss nach erfolgreichem Abschluss einen Wert zurückgeben.
Ende des Hauptteils der Funktion main().

#3:Verwenden von std::string-Methoden

Die Klasse std::string enthält viele überladene Funktionen, die Ihnen helfen können, Zeichen in Zeichenfolgen umzuwandeln.

Dazu gehören:

push_back
Diese Funktion weist dem Ende einer Zeichenkette ein bestimmtes Zeichen zu. Es ist für Zeichen überladen.

Es nimmt die folgende Syntax an:
```
void push_back(char ch)
```
Der Parameter ch ist das Zeichen, das in einen String umgewandelt werden soll.
anhängen
Es weist einer Zeichenfolge viele Kopien eines bestimmten Zeichens zu.

Die Funktion nimmt die folgende Syntax an:
```
string& append(size_t n,char ch)
```
Der Parameter n gibt an, wie oft das Zeichen angehängt wird.

Der Parameter ch ist das Zeichen, das an string angehängt werden soll.
zuweisen
Diese Funktion ersetzt den aktuellen Inhalt der Zeichenfolge durch n Kopien des angegebenen Zeichens.

Es nimmt die folgende Syntax an:
```
string& assign(size_t n,char ch);
```
Der Parameter n bezeichnet die Gesamtzahl der Kopien für das Zeichen.

Der Parameter ch ist das Zeichen, das in den String kopiert werden soll.
Einfügen
Die Einfügefunktion fügt n Kopien eines Zeichens an der Anfangsposition der Zeichenfolge ein, wie in den Argumenten angegeben.

Es nimmt die folgende Syntax an:
```
string& insert(size_t p,size_t n,char ch);					
```
Der p-Parameter bezeichnet die Position von Anfang an, wo Zeichen eingefügt werden.

Der Parameter n bezeichnet die Gesamtzahl der Kopien für das Zeichen.

Der Parameter ch ist das Zeichen, das in den String eingefügt werden soll.

Beispiel 7:

#include<iostream>
#include <string>
using namespace std;
int main() {
	string st;
	st.push_back('A');
	cout << "push_back A returns : " << st << endl;
	st = "";
	st.append(1, 'C');
	cout << "append C returns : " << st << endl;
	st = "";
	st.assign(1, 'D');
	cout << "assign D returns : " << st << endl;
	st.insert(0, 1, 'E');
	cout << "insert single character returns : " << st << endl;
	return 0;
}

Ausgabe:

Hier ist ein Screenshot des Codes:

Fügen Sie die iostream-Header-Datei in unseren Code ein, um ihre Funktionen zu nutzen.
Fügen Sie die String-Header-Datei in unseren Code ein, um ihre Funktionen zu verwenden.
Fügen Sie den std-Namespace in unseren Code ein, um seine Klassen zu verwenden, ohne ihn aufzurufen.
Aufruf der main()-Funktion. Die Programmlogik sollte innerhalb des Hauptteils dieser Funktion hinzugefügt werden.
Erstellen Sie eine Zeichenfolgenvariable namens st.
Ordnen Sie dem Ende der Zeichenfolge das Zeichen A zu.
Den Wert der Zeichenfolge st auf der Konsole zusammen mit anderem Text ausgeben. Das endl (Zeile beenden) bewegt den Cursor zur nächsten Zeile.
Setzen Sie den Wert der Zeichenkette st auf leer.
Ordnen Sie der Zeichenfolge mit dem Namen st das einzelne Zeichen C zu.
Den Wert der Zeichenfolge st auf der Konsole zusammen mit anderem Text ausgeben. Das endl (Zeile beenden) bewegt den Cursor zur nächsten Zeile.
Setzen Sie den Wert der Zeichenkette st auf leer.
Ersetzen Sie den Inhalt der Zeichenfolge st durch das einzelne Zeichen D.
Den Wert der Zeichenfolge st auf der Konsole zusammen mit anderem Text ausgeben. Das endl (Zeile beenden) bewegt den Cursor zur nächsten Zeile.
Fügen Sie das einzelne Zeichen E in die Zeichenfolge namens st vom ersten Index an ein.
Den Wert der Zeichenfolge st auf der Konsole zusammen mit anderem Text ausgeben. Das endl (Zeile beenden) bewegt den Cursor zur nächsten Zeile.
Das Programm muss nach erfolgreichem Abschluss einen Wert zurückgeben.
Ende des Hauptteils der Funktion main().

#4: Mit std::stringstream

Um diese Klasse zum Konvertieren von Zeichen in eine Zeichenfolge zu verwenden, fügen Sie das Zeichen in den Stream ein.

Sie werden in den String geschrieben.

Beispiel 8:

#include<iostream>
#include <string>
#include <sstream>

using namespace std;
int main() {

	string st;

	stringstream myst;

	myst << 'A'; 
	myst >> st;

	cout << "The conversion of the single character returns the string: " << st;

	return 0;
}

Ausgabe:

Hier ist ein Screenshot des Codes:

Code-Erklärung:

Fügen Sie die iostream-Header-Datei in unseren Code ein, um ihre Funktionen zu nutzen.
Fügen Sie die String-Header-Datei in unseren Code ein, um ihre Funktionen zu verwenden.
Fügen Sie die sstream-Header-Datei in unseren Code ein, um ihre Funktionen zu nutzen.
Fügen Sie den std-Namespace in unseren Code ein, um seine Klassen zu verwenden, ohne ihn aufzurufen.
Aufruf der main()-Funktion. Die Programmlogik sollte innerhalb des Hauptteils dieser Funktion hinzugefügt werden.
Erstellen Sie eine Zeichenfolgenvariable namens st.
Erstellen Sie eine Stream-Variable namens myst.
Fügen Sie das Zeichen A in das Stream-Objekt namens myst ein.
Wandle das Stream-Objekt in einen String um.
Den Wert der Zeichenfolge st auf der Konsole zusammen mit anderem Text ausgeben. Das endl (Zeile beenden) bewegt den Cursor zur nächsten Zeile.
Das Programm muss nach erfolgreichem Abschluss einen Wert zurückgeben.
Ende des Hauptteils der Funktion main().

Zusammenfassung:

Ein char ist ein C++-Datentyp, der zum Speichern von Buchstaben verwendet wird.
C++ Char ist ein ganzzahliger Datentyp, was bedeutet, dass der Wert als ganze Zahl gespeichert wird.
Es belegt eine Speichergröße von 1 Byte.
C++ Char speichert nur einzelne Zeichen.
Zeichenwerte werden als ASCII-Zeichen interpretiert.
ASCII ist ein Akronym für American Standard Code for Information Interchange.
Es gibt eine spezielle Art an, englische Zeichen in Form von Zahlen darzustellen.
Um den ASCII-Wert eines Zeichens zu sehen, übergeben wir ihn an die Funktion int().
Um den entsprechenden Zeichenwert des ASCII-Werts zu sehen, definieren wir den ASCII-Wert als Zeichen.

C++-Zeiger mit Beispielen Umgang mit C++-Dateien:Öffnen, Schreiben, Lesen und Schließen von Dateien in C++

C Sprache