In C++ können wir Arrays verschiedener Datentypen wie int, string, char usw. deklarieren und initialisieren. Ein Array ist eine Variable, die mehrere Werte eines ähnlichen Datentyps enthalten kann. Das „char-Array“ wird zum Speichern der Zeichensammlung und der darin enthaltenen Zeichenfolgen verwendet. Das „char-Array“ ähnelt dem „int-Array“. Während das int-Array die numerischen Werte speichert, speichert das „char-Array“ die Sammlung von Zeichen oder Zeichenfolgen in der C++-Programmierung. In dieser Anleitung initialisieren wir das char-Array in C++ in unseren Codes.
Beispiel 1:
Beginnen wir den C++-Code mit dem Einfügen der Header-Dateien. Die erste Header-Datei in diesem Beispiel ist „iostream“. Einige Funktionen wie „cin“ oder „cout“ werden in dieser Header-Datei deklariert, die wir in diesem Code benötigen. Die zweite Header-Datei ist „string.h“, die hier hinzugefügt wird, da darin viele Funktionen definiert sind, die wir zum Bearbeiten des Zeichens des Arrays benötigen. In diesem Code wird auch der Namespace „std“ hinzugefügt. Dann rufen wir hier die Methode „main()“ auf.
Um das Zeichenarray zu initialisieren, platzieren wir das Schlüsselwort „char“. Anschließend wird hier der Name des Arrays eingegeben. Der Name des Zeichenarrays lautet „new_Array“, dessen Größe auf „50“ angepasst ist. Dann initialisieren wir dieses Zeichenarray mit der Zeile. Die Zeile, die wir hier einfügen, um das Zeichen-Array zu initialisieren, lautet „Mein erstes Zeichen-Array ist da!“. Jetzt wollen wir diese Zeichenarrays drucken, also platzieren wir das „new_Array“ im „cout“. Dadurch wird das Zeichenarray auf der Konsole gerendert.
Code 1:
#include
#include
Verwenden des Namensraums std;
int main ( )
{
char new_Array [ fünfzig ] = „Mein erstes Character Array ist da!“ ;
cout << neues_Array << endl;
zurückkehren 0 ;
}
Ausgabe:
Das Zeichenarray, das wir im Code initialisiert haben, wird hier im angegebenen Ergebnis angezeigt. Alle Daten, die wir zum Initialisieren des Zeichenarrays verwendet haben, werden im Folgenden gerendert:
Beispiel 2:
Die Header-Dateien „iostream“ und „string.h“ sind hier enthalten. Darunter fügen wir den Namensraum „std“ hinzu. Dann initialisieren wir nach dem Aufruf von „main()“ das Zeichenarray mit dem Namen „Arr_1“. Wir platzieren den Datentyp „char“ und geben dann den Namen des Zeichenarrays ein.
Dann weisen wir diesem Array die Zeichen zu, oder wir können sagen, dass wir dieses Array hier mit den Zeichen initialisieren. Wir fügen die Zeichen in dieses Array ein und verwenden dann die „for“-Schleife darunter, da wir alle diese Zeichen separat anzeigen möchten. Dann verwenden wir den „cout“ und fügen „Arr_1[i]“ in diesen cout ein, der alle Zeichen des char-Arrays anzeigt.
Code 2:
#include#include
Verwenden des Namensraums std;
int main ( )
{
char Arr_1 [ 10 ] = { 'A' , 'Es ist' , 'ich' , 'Ö' , 'In' , 'N' , 'Mit' , 'B' , 'In' , 'X' } ;
für ( int i = 0 ; ich < Größe von ( Arr_1 ) / Größe von ( Arr_1 [ 0 ] ) ; i++ )
{
cout << „Der Charakter von Array ist “ << Arr_1 [ ich ] << endl;
}
zurückkehren 0 ;
}
Ausgabe:
Hier werden nun alle Zeichen des char-Arrays angezeigt. Wir fügen diese Zeichen ein, während wir das Array in unserem bereitgestellten Code initialisieren, und rendern sie dann.
Beispiel 3:
Wir fügen die Header-Dateien „iostream“ und „string.h“ hinzu, da wir mit den darin definierten Funktionen arbeiten müssen, und fügen dann den Namespace „std“ darunter ein.
Als nächstes initialisieren wir das Zeichenarray mit dem Namen „a“, nachdem wir die Funktion „main()“ aufgerufen haben. Die Größe dieses „a“-Arrays beträgt „12“. Nun fügen wir den Namen des Zeichenarrays ein, nachdem wir den Datentyp auf „char“ gesetzt haben. Danach initialisieren wir die Zeichen in diesem „char“-Array. Um jedes Zeichen einzeln anzuzeigen, fügen wir die Zeichen zunächst zu diesem Array hinzu und verwenden dann die „for“-Schleife. Als nächstes haben wir „a[i]“ an diesen cout angehängt, indem wir die Funktion „cout“ verwendet haben, die alle Zeichen dieses „char“-Arrays anzeigt.
Code 3:
#include#include
Verwenden des Namensraums std;
int main ( )
{
char a [ 12 ] = { 'A' , '@' , '#' , '%' , '!' , '^' , '&' , '*' , '' , 'Mit' , '@' } ;
für ( int i = 0 ; ich < Größe von ( A ) / Größe von ( A [ 0 ] ) ; i++ )
{
cout << „Der Charakter ist “ << A [ ich ] << endl;
}
zurückkehren 0 ;
}
Ausgabe:
Dies zeigt jetzt jedes Zeichen des „char“-Arrays. Im angegebenen Code haben wir das Array initialisiert und diese Zeichen hinzugefügt, um sie hier darzustellen.
Beispiel 4:
Wir müssen mit den Funktionen arbeiten, die in den Header-Dateien „iostream“ und „string.h“ definiert sind; Wir fügen diese zuerst ein, gefolgt vom Namensraum „std“. Anschließend verwenden wir den Namen „myCharArray“, um das Zeichenarray nach dem oben genannten Funktionsaufruf „main()“ zu initialisieren. Die Größe des „myCharArray“ wird auf „20“ angepasst und wir initialisieren es mit „Character Array“.
Jetzt wollen wir dieses Zeichenarray anzeigen. Wir verwenden „cout“, wo wir „myCharArray“ hinzufügen, um die Sammlung von Zeichen anzuzeigen, die wir diesem Array hinzugefügt haben. Das Zeichenarray wird dann mit dem Namen „myCharArray2“ initialisiert. Hier hat das Array „myCharArray2“ eine Größe von „5“. Jetzt müssen Sie nur noch den Datentyp auf „char“ setzen und den Namen des Zeichenarrays einfügen.
Die Zeichen werden dann in diesem „char“-Array initialisiert. Wir fügen die Zeichen zuerst in dieses Array ein und verwenden dann die „for“-Schleife unten, um jedes Zeichen separat anzuzeigen. Als nächstes verwenden wir die Funktion „cout“, um „myCharArray2[a]“ an diesen cout anzuhängen und alle Zeichen in diesem char-Array anzuzeigen.
Code 4:
#include#include
Verwenden des Namensraums std;
int main ( )
{
char myCharArray [ zwanzig ] = „Zeichen-Array“ ;
cout << myCharArray << endl;
char myCharArray2 [ 5 ] = { 'A' , 'B' , 'C' , 'D' , 'Es ist' } ;
für ( int a = 0 ; A < Größe von ( myCharArray2 ) / Größe von ( myCharArray2 [ 0 ] ) ; a++ )
{
cout << myCharArray2 [ A ] << endl;
}
zurückkehren 0 ;
}
Ausgabe:
Im Folgenden werden beide Werte der Zeichenfelder angezeigt. Zuerst haben wir die vollständige Zeichenfolge gerendert, die wir im ersten char-Array hinzugefügt haben. Dann wird das zweite char-Array angezeigt, in das wir die Zeichen eingefügt und separat in einer einzigen Zeile angezeigt haben.
Beispiel 5:
Nachdem wir den Namespace „iostream“ und „std“ hinzugefügt haben, rufen wir hier „main()“ auf und initialisieren dann das „c_array“ des Datentyps „char“ mit der Größe „100“. Dann zeigen wir eine Meldung an, in der wir „Hier Daten in das Zeichenarray eingeben“ hinzufügen, damit der Benutzer die Zeichen eingibt, wenn diese Zeile gedruckt wird.
Die Funktion „cin“ wird verwendet, um das Zeichen im Array „char“ vom Benutzer abzurufen. Wir platzieren das „c_array“ nach „cin“, damit die vom Benutzer eingegebenen Daten in diesem „c_array“ gespeichert werden. Jetzt drucken wir die Zeichen des Arrays mit Hilfe von „cout“, indem wir „c_array“ hineingeben.
Als nächstes wird eine Meldung angezeigt, zu der wir hinzugefügt haben: „Geben Sie nun erneut Daten in das Zeichen-Array ein.“ Der Benutzer gibt die Zeichen in diesem Bereich ein, wenn diese Zeile gedruckt wird. Um ein Zeichen vom Benutzer abzurufen, um es im Array „char“ zu verwenden, verwenden wir die Funktion „cin“. Jetzt verwenden wir „cout“, um die Zeichen aus dem Array zu drucken, indem wir „c_array“ hineingeben.
Code 5:
#includeVerwenden des Namensraums std;
int main ( )
{
char c_array [ 100 ] ;
cout <> c_array;
cout << 'Du bist eingetreten: ' << c_array << endl;
cout <> c_array;
cout << 'Du bist eingetreten: ' << c_array << endl;
zurückkehren 0 ;
}
Ausgabe:
Hier haben wir „Computer“ in das erste „char“-Array eingegeben. Anschließend wird es in der nächsten Zeile angezeigt, nachdem Sie die Eingabetaste gedrückt haben. Danach haben wir im zweiten „char-Array“ „Science“ eingegeben. Dies wird im Folgenden auch nach erneutem Drücken der „Enter“-Taste wiedergegeben.
Abschluss
Das Konzept der Initialisierung des „char array“ in der C++-Programmierung wird hier ausführlich erläutert. Wir haben besprochen, dass das „char-Array“ zum Speichern der Sammlung von Zeichen und der Zeichenfolge in C++ verwendet wird. Wir haben mehrere „char-Arrays“ initialisiert und in unseren Codes angezeigt. In unserem letzten Code in diesem Handbuch haben wir außerdem ein „char-Array“ initialisiert, um die Zeichen vom Benutzer abzurufen. Alle Beispiele werden hier ausführlich erklärt.