C++ Char-Datentyp mit Beispielen

Was ist ASCII?

Der Zeichenwert wird als ASCII-Zeichen interpretiert. Dies ist vergleichbar mit der Interpretation von booleschen Werten als wahr oder falsch. ASCII ist die Abkürzung für American Standard. Code für den Informationsaustausch. Es definiert eine spezifische Art der Darstellung englischer Zeichen als Zahlen.

Der Zahlenbereich liegt zwischen 0 und 127. Beispielsweise entspricht das Zeichen „a“ dem ASCII-Code 97.

Char-Erklärung

Um a zu erklären char-Variable in C++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 eingeschlossen 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;
}

Ausgang:

Hier ist ein Screenshot des Codes:

Code Erläuterung:

1. Einbinden der iostream-Header-Datei in unseren Code, um ihre Funktionen zu nutzen.
2. Einbinden des std-Namespace in unseren Code, um seine Klassen zu verwenden, ohne ihn aufzurufen.
3. Aufruf der Funktion main(). Die Programmlogik sollte im Hauptteil dieser Funktion hinzugefügt werden.
4. Deklarieren Sie eine Zeichenvariable mit dem Namen grade. Der Variablen wurde außerdem der Wert B zugewiesen. Beachten Sie, dass der Wert der Variablen in einfache Anführungszeichen gesetzt ist.
5. Drucken Sie den Wert der variablen Note zusammen mit anderem Text auf der Konsole aus.
6. Das Programm muss bei erfolgreichem Abschluss einen Wert zurückgeben.
7. Ende des Hauptteils der main()-Funktion.

ASCII-Wert drucken

Wie oben erwähnt, wird jedes Zeichen als ASCII-Zeichen interpretiert. Es ist möglich, den ASCII-Wert eines beliebigen Zeichens abzurufen. Sie übergeben das Zeichen einfach an die Funktion int(). Dieser Vorgang wird als Typguss bezeichnet. Lassen Sie uns das 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;
}

Ausgang:

Hier ist ein Screenshot des Codes:

Code Erläuterung:

1. Einbindung der iostream-Header-Datei in unseren Code, um deren Funktionen zu nutzen.
2. Einbinden des std-Namespace in unseren Code, um seine Klassen zu verwenden, ohne ihn aufzurufen.
3. Aufruf der Funktion main(). Die Programmlogik sollte im Hauptteil dieser Funktion hinzugefügt werden.
4. Deklarieren Sie eine char-Variable mit dem Namen ch.
5. Drucken Sie einen Text auf der Konsole. Der Text fordert den Benutzer auf, einen Wert für die Variable ch einzugeben.
6. Lesen Sie die Benutzereingaben von der Tastatur und speichern Sie sie in der Variablen ch.
7. Drucken Sie einen 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.
8. Das Programm muss bei erfolgreichem Abschluss einen Wert zurückgeben.
9. Ende des Hauptteils der main()-Funktion.

Zeichenwert drucken

Bei einem ASCII-Wert wird der C++ Der Compiler kann das entsprechende Zeichen zurückgeben. Sie deklarieren eine char-Variable und weisen ihr einen Integer-Wert zu. Dieser 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;
}

Ausgang:

Hier ist ein Screenshot des Codes:

Code Erläuterung:

1. Einbinden der iostream-Header-Datei in den Code. Wir werden dann seine Funktionen nutzen, ohne dass Fehler auftreten.
2. Fügen Sie den std-Namespace in den Code ein. Wir werden seine Klassen verwenden, ohne sie aufzurufen.
3. Aufruf der Funktion main(). Die Programmlogik sollte in den Hauptteil dieser Funktion einfließen.
4. Deklarieren Sie drei char-Variablen x, y und z. Den drei wurden Ganzzahlwerte von 65, 66 und 67 zugewiesen. Diese werden als ASCII-Werte für Zeichen behandelt.
5. Geben Sie den Wert der Variablen x auf der Konsole aus. Da x als Zeichen deklariert wurde, wird das Zeichen mit dem ASCII-Wert 65 zurückgegeben, also A.
6. Geben Sie den Wert der Variablen y auf der Konsole aus. Da y als char deklariert wurde, wird das char mit dem ASCII-Wert 66 zurückgegeben, also B.
7. Geben Sie den Wert der Variablen z auf der Konsole aus. Da z als char deklariert wurde, wird das char mit dem ASCII-Wert 67 zurückgegeben, also C.
8. Das Programm muss bei erfolgreichem Abschluss einen Wert zurückgeben.
9. Das Ende des Hauptteils der main()-Funktion.

Eingabe von Zeichen

Mit der Funktion `std::cin` können wir ein vom Benutzer über die Tastatur eingegebenes Zeichen einlesen. `std::cin` ermöglicht die Eingabe mehrerer Zeichen. Die Variable `character` kann jedoch nur ein Zeichen speichern. Das bedeutet, dass nur das erste eingegebene Zeichen gelesen wird.tracDer Inhalt wird in der Zeichenvariablen gespeichert. Der Rest verbleibt im Puffer, der von std::cin verwendet wird.tract it, mache nachfolgende Aufrufe an std::cin.

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

Ausgang:

Hier ist ein Screenshot des Codes:

Code Erläuterung:

1. Einbinden der iostream-Header-Datei in unseren Code, um ihre Funktionen zu nutzen.
2. Fügen Sie den std-Namespace in unseren Code ein, um seine Klassen zu verwenden, ohne ihn aufzurufen.
3. Aufruf der Funktion main(). Die Programmlogik sollte im Hauptteil dieser Funktion hinzugefügt werden.
4. Drucken Sie einen Text auf der Konsole.
5. Deklarieren Sie eine Zeichenvariable mit dem Namen ch.
6. 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.
7. Drucken des ersten eingegebenen Zeichens, seines ASCII-Codes und anderen Textes auf der Konsole. Der ASCII-Code wird ermittelt, indem die Zeichenvariable an die Funktion int() übergeben wird.
8. Lesen Sie das nächste vom Benutzer eingegebene Zeichen. Der Benutzer muss kein neues Zeichen eingeben. Stattdessen wird das zweite eingegebene Zeichen gelesen, also b.
9. Drucken des zweiten eingegebenen Zeichens, seines ASCII-Codes und anderen Textes auf der Konsole. Der ASCII-Code wird ermittelt, indem die Zeichenvariable an die Funktion int() übergeben wird.
10. Das Programm muss bei erfolgreichem Abschluss einen Wert zurückgeben.
11. Ende des Hauptteils der main()-Funktion.

Konvertieren von Zeichen in Zeichenfolgen

Es gibt eine Reihe von Möglichkeiten, mit denen wir Zeichen konvertieren können Streicher.

Lassen Sie uns darüber diskutieren:

#1: Verwenden des von einer String-Klasse gegebenen Konstruktors

Dies kann mit der folgenden Syntax erfolgen:

string st(int n,char x);

Der Parameter n gibt die Größe des Strings an, der generiert werden soll.

Der Parameter x ist das Zeichen, das in eine Zeichenfolge umgewandelt 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;
}

Ausgang:

Hier ist ein Screenshot des Codes:

Code Erläuterung:

1. Einbinden der iostream-Header-Datei in unseren Code, um ihre Funktionen zu nutzen.
2. Fügen Sie die String-Header-Datei in unseren Code ein, um ihre Funktionen zu nutzen.
3. Fügen Sie den std-Namespace in unseren Code ein, um seine Klassen zu verwenden, ohne ihn aufzurufen.
4. Aufruf der Funktion main(). Die Programmlogik sollte im Hauptteil dieser Funktion hinzugefügt werden.
5. Konvertieren Sie das Zeichen „C“ in einen String der Länge 1 und weisen Sie den resultierenden String der Variablen st zu.
6. Geben Sie den Wert der Zeichenfolge st zusammen mit anderem Text auf der Konsole aus.
7. Das Programm muss bei erfolgreichem Abschluss einen Wert zurückgeben.
8. Ende des Hauptteils der main()-Funktion.

#2) Verwendung des std::string Operators = und +=

Die Operatoren = und += sind bereits mit Zeichen überladen. Mit beiden kann ein bestimmtes Zeichen in eine Zeichenfolge umgewandelt werden.

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

Ausgang:

Hier ist ein Screenshot des Codes:

Code Erläuterung:

1. Fügen Sie die iostream-Header-Datei in unseren Code ein, um ihre Funktionen zu nutzen.
2. Fügen Sie die String-Header-Datei in unseren Code ein, um ihre Funktionen zu nutzen.
3. Fügen Sie den std-Namespace in unseren Code ein, um seine Klassen zu verwenden, ohne ihn aufzurufen.
4. Aufruf der Funktion main(). Die Programmlogik sollte im Hauptteil dieser Funktion hinzugefügt werden.
5. Erstellen Sie eine String-Variable mit dem Namen st.
6. Erstellen Sie einen Charakter namens b mit dem Wert B.
7. Weisen Sie der Zeichenfolge mit dem Namen st den Wert A zu.
8. Verwenden Sie den Operator +=, um Zeichen in eine Zeichenfolge umzuwandeln.
9. Geben Sie den Wert der Zeichenfolge st zusammen mit anderem Text auf der Konsole aus.
10. Das Programm muss bei erfolgreichem Abschluss einen Wert zurückgeben.
11. Ende des Hauptteils der main()-Funktion.

#3: Verwendung von std::string-Methoden

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

Die Zertifizierungen umfassen im Einzelnen:

• push_back Diese Funktion weist einem String ein bestimmtes Zeichen zu. Sie ist für Zeichen überladen. Sie verwendet die folgende Syntax:

  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 hat die folgende Syntax:

  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 die Zeichenfolge angehängt werden soll.

• zuweisen Diese Funktion ersetzt den aktuellen Inhalt der Zeichenfolge durch n Kopien des angegebenen Zeichens. Sie verwendet die folgende Syntax:

  string& assign(size_t n,char ch);

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

  Der Parameter ch ist das Zeichen, das in die Zeichenfolge kopiert werden soll.

• einfügen Die Funktion insert fügt n Kopien eines Zeichens an der Startposition der Zeichenfolge ein, wie in den Argumenten angegeben. Sie verwendet die folgende Syntax:

  string& insert(size_t p,size_t n,char ch);

  Der p-Parameter gibt die Position vom Anfang an an, an der Zeichen eingefügt werden.

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

  Der Parameter ch ist das Zeichen, das in die Zeichenfolge 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;
}

Ausgang:

Hier ist ein Screenshot des Codes:

1. Fügen Sie die iostream-Header-Datei in unseren Code ein, um ihre Funktionen zu nutzen.
2. Fügen Sie die String-Header-Datei in unseren Code ein, um ihre Funktionen zu nutzen.
3. Fügen Sie den std-Namespace in unseren Code ein, um seine Klassen zu verwenden, ohne ihn aufzurufen.
4. Aufruf der Funktion main(). Die Programmlogik sollte im Hauptteil dieser Funktion hinzugefügt werden.
5. Erstellen Sie eine String-Variable mit dem Namen st.
6. Weisen Sie dem Ende der Zeichenfolge das Zeichen A zu.
7. Geben Sie den Wert der Zeichenfolge st zusammen mit anderem Text auf der Konsole aus. Das endl (Endzeile) bewegt den Cursor zur nächsten Zeile.
8. Setzen Sie den Wert der Zeichenfolge st auf leer.
9. Weisen Sie der Zeichenfolge mit dem Namen st das einzelne Zeichen C zu.
10. Geben Sie den Wert der Zeichenfolge st zusammen mit anderem Text auf der Konsole aus. Das endl (Endzeile) bewegt den Cursor zur nächsten Zeile.
11. Setzen Sie den Wert der Zeichenfolge st auf leer.
12. Ersetzen Sie den Inhalt der Zeichenfolge st durch das Einzelzeichen D.
13. Geben Sie den Wert der Zeichenfolge st zusammen mit anderem Text auf der Konsole aus. Das endl (Endzeile) bewegt den Cursor zur nächsten Zeile.
14. Fügen Sie das einzelne Zeichen E ab dem ersten Index in die Zeichenfolge mit dem Namen st ein.
15. Geben Sie den Wert der Zeichenfolge st zusammen mit anderem Text auf der Konsole aus. Das endl (Endzeile) bewegt den Cursor zur nächsten Zeile.
16. Das Programm muss bei erfolgreichem Abschluss einen Wert zurückgeben.
17. Ende des Hauptteils der main()-Funktion.

#4: Verwendung von 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 die Zeichenfolge 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;
}

Ausgang:

Hier ist ein Screenshot des Codes:

Code Erläuterung:

1. Fügen Sie die iostream-Header-Datei in unseren Code ein, um ihre Funktionen zu nutzen.
2. Fügen Sie die String-Header-Datei in unseren Code ein, um ihre Funktionen zu nutzen.
3. Fügen Sie die Sstream-Header-Datei in unseren Code ein, um ihre Funktionen zu nutzen.
4. Fügen Sie den std-Namespace in unseren Code ein, um seine Klassen zu verwenden, ohne ihn aufzurufen.
5. Aufruf der Funktion main(). Die Programmlogik sollte im Hauptteil dieser Funktion hinzugefügt werden.
6. Erstellen Sie eine String-Variable mit dem Namen st.
7. Erstellen Sie eine Stream-Variable mit dem Namen myst.
8. Fügen Sie das Zeichen A in das Stream-Objekt namens myst ein.
9. Konvertieren Sie das Stream-Objekt in einen String.
10. Geben Sie den Wert der Zeichenfolge st zusammen mit anderem Text auf der Konsole aus. Das endl (Endzeile) bewegt den Cursor zur nächsten Zeile.
11. Das Programm muss bei erfolgreichem Abschluss einen Wert zurückgeben.
12. Ende des Hauptteils der main()-Funktion.

Häufig gestellte Fragen