W C++ możemy deklarować i inicjować tablice różnych typów danych, takich jak int, string, char itp. Tablica to zmienna, która może przechowywać kilka wartości podobnego typu danych. „Tablica znaków” służy do przechowywania kolekcji postaci i znajdujących się w niej ciągów znaków. „Tablica char” jest podobna do „tablicy int”. Ponieważ tablica int przechowuje wartości liczbowe, tak „tablica char” przechowuje kolekcję znaków lub ciągów znaków w programowaniu w C++. W tym przewodniku zainicjujemy tablicę znaków w C++ w naszych kodach.
Przykład 1:
Zacznijmy kod C++ od dołączenia plików nagłówkowych. Pierwszym plikiem nagłówkowym w tym przykładzie jest „iostream”. W tym pliku nagłówkowym zadeklarowano niektóre funkcje, takie jak „cin” lub „cout”, których potrzebujemy w tym kodzie. Drugi plik nagłówkowy to „string.h”, który jest tutaj dodawany, ponieważ zdefiniowanych jest w nim wiele funkcji potrzebnych do manipulowania charakterem tablicy. W tym kodzie dodano także przestrzeń nazw „std”. Następnie wywołujemy tutaj metodę „main()”.
Aby zainicjować tablicę znaków, umieszczamy słowo kluczowe „char”. Następnie wpisuje się tutaj nazwę tablicy. Nazwa tablicy znaków to „new_Array”, której rozmiar jest dostosowany do „50”. Następnie inicjujemy tę tablicę znaków linią. Linia, którą tutaj dołączymy, aby zainicjować tablicę znaków, to „Moja pierwsza tablica znaków jest tutaj!”. Teraz chcemy wydrukować te tablice znaków, więc umieszczamy „new_Array” w „cout”. To renderuje tablicę znaków na konsoli.
Kod 1:
#include
#include
używając przestrzeni nazw std;
int główny ( )
{
char nowa_tablica [ pięćdziesiąt ] = „Mój pierwszy zestaw znaków jest tutaj!” ;
cout << nowy_Array << koniec;
powrót 0 ;
}
Wyjście:
Tablica znaków, którą zainicjowaliśmy w kodzie, jest wyświetlana tutaj w danym wyniku. Wszystkie dane, których użyliśmy do zainicjowania tablicy znaków, są renderowane w następujący sposób:
Przykład 2:
Znajdują się tutaj pliki nagłówkowe „iostream” i „string.h”. Poniżej dodajemy przestrzeń nazw „std”. Następnie po wywołaniu funkcji „main()” inicjujemy tablicę znaków nazwą „Arr_1”. Umieszczamy typ danych „char”, a następnie podajemy nazwę tablicy znaków.
Następnie przypisujemy znaki do tej tablicy lub możemy powiedzieć, że inicjujemy tutaj tę tablicę tymi znakami. Wstawiamy znaki do tej tablicy, a następnie wykorzystujemy znajdującą się poniżej pętlę „for”, ponieważ chcemy wyświetlić wszystkie te znaki osobno. Następnie używamy „cout” i dodajemy „Arr_1[i]” w tym cout, który wyświetla wszystkie znaki tablicy char.
Kod 2:
#include#include
używając przestrzeni nazw std;
int główny ( )
{
znak Arr_1 [ 10 ] = { 'A' , 'To jest' , 'I' , „O” , 'W' , 'N' , 'z' , 'B' , 'w' , 'X' } ;
Do ( int ja = 0 ; I < rozmiar ( Arr_1 ) / rozmiar ( Arr_1 [ 0 ] ) ; ja++ )
{
cout << „Znak tablicy to ” << Arr_1 [ I ] << koniec;
}
powrót 0 ;
}
Wyjście:
Wszystkie znaki tablicy char są teraz wyświetlane tutaj. Wstawiamy te znaki podczas inicjowania tablicy w dostarczonym przez nas kodzie, a następnie je renderujemy.
Przykład 3:
Dołączamy pliki nagłówkowe „iostream” i „string.h”, ponieważ musimy pracować z funkcjami w nich zdefiniowanymi, a następnie umieścić pod nimi przestrzeń nazw „std”.
Następnie inicjujemy tablicę znaków o nazwie „a” po wywołaniu funkcji „main()”. Rozmiar tej tablicy „a” wynosi „12”. Teraz możemy wstawić nazwę tablicy znaków po ustawieniu typu danych na „char”. Następnie inicjujemy znaki w tej tablicy „char”. Aby wyświetlić każdy znak z osobna, najpierw dodajemy je do tej tablicy, a następnie używamy pętli „for”. Następnie dodaliśmy „a[i]” do tego cout za pomocą funkcji „cout”, która wyświetla wszystkie znaki tej tablicy „char”.
Kod 3:
#include#include
używając przestrzeni nazw std;
int główny ( )
{
char a [ 12 ] = { 'A' , „@” , „#” , „%” , „!” , „^” , „&” , „*” , „” , 'z' , „@” } ;
Do ( int ja = 0 ; I < rozmiar ( A ) / rozmiar ( A [ 0 ] ) ; ja++ )
{
cout << „Postać jest” << A [ I ] << koniec;
}
powrót 0 ;
}
Wyjście:
To teraz pokazuje każdy znak tablicy „char”. W podanym kodzie zainicjowaliśmy tablicę i dodaliśmy te znaki, renderując je tutaj.
Przykład 4:
Musimy pracować z funkcjami zdefiniowanymi w plikach nagłówkowych „iostream” i „string.h”; dołączamy je jako pierwsze, po których następuje przestrzeń nazw „std”. Następnie używamy nazwy „myCharArray” do inicjacji tablicy znaków po wspomnianym wcześniej wywołaniu funkcji „main()”. Rozmiar „myCharArray” jest dostosowywany do „20” i inicjujemy go za pomocą „Character Array”.
Teraz chcemy wyświetlić tę tablicę znaków. Używamy „cout”, do którego dodajemy „myCharArray”, aby wyświetlić zbiór znaków, które dodaliśmy do tej tablicy. Tablica znaków jest następnie inicjowana nazwą „myCharArray2”. Tutaj tablica „myCharArray2″ ma rozmiar „5”. Pozostało tylko ustawić typ danych na „char” i wstawić nazwę tablicy znaków.
Znaki są następnie inicjowane w tej tablicy „char”. Najpierw wstawiamy znaki do tej tablicy, a następnie używamy poniższej pętli „for”, aby pokazać każdy znak osobno. Następnie używamy funkcji „cout”, aby dodać „myCharArray2[a]” do tego cout, wyświetlając wszystkie znaki w tej tablicy znaków.
Kod 4:
#include#include
używając przestrzeni nazw std;
int główny ( )
{
char myCharArray [ 20 ] = „Tablica znaków” ;
cout << mojaArray << koniec;
char myCharArray2 [ 5 ] = { 'A' , 'B' , 'C' , 'D' , 'To jest' } ;
Do ( int a = 0 ; A < rozmiar ( myCharArray2 ) / rozmiar ( myCharArray2 [ 0 ] ) ; a++ )
{
cout << myCharArray2 [ A ] << koniec;
}
powrót 0 ;
}
Wyjście:
Obie wartości tablic znaków są wyświetlane poniżej. Najpierw wyrenderowaliśmy pełny ciąg znaków, który dodaliśmy w pierwszej tablicy znaków. Następnie wyświetla się druga tablica char, w której wstawiliśmy znaki i wyświetliliśmy je osobno w jednej linii.
Przykład 5:
Po dodaniu przestrzeni nazw „iostream” i „std” wywołujemy tutaj funkcję „main()”, a następnie inicjujemy „c_array” typu danych „char” o rozmiarze „100”. Następnie wyświetlamy komunikat, w którym dodajemy „Wprowadź dane w tablicy znaków tutaj”, aby użytkownik mógł wprowadzić znaki po wydrukowaniu tej linii.
Funkcja „cin” służy do pobrania znaku z tablicy „char” od użytkownika. Umieszczamy „c_array” po „cin”, aby dane wprowadzane przez użytkownika były zapisywane w tej „c_array”. Teraz wypisujemy znaki tablicy za pomocą „cout” wstawiając w niej „c_array”.
Następnie pojawia się komunikat, do którego dodaliśmy: „Teraz ponownie wprowadź dane w znaku Array”. Użytkownik wprowadza znaki w tym obszarze podczas drukowania tego wiersza. Aby pobrać od użytkownika znak do wykorzystania w tablicy „char”, używamy funkcji „cin”. Teraz używamy „cout”, aby wydrukować znaki z tablicy, wprowadzając do niej „c_array”.
Kod 5:
#includeużywając przestrzeni nazw std;
int główny ( )
{
char c_array [ 100 ] ;
cout <> c_tablica;
cout << 'Wszedłeś: ' << c_tablica << koniec;
cout <> c_tablica;
cout << 'Wszedłeś: ' << c_tablica << koniec;
powrót 0 ;
}
Wyjście:
Tutaj wprowadziliśmy „Komputer” w pierwszej tablicy „char”. Następnie wyświetli się w kolejnej linijce po naciśnięciu „Enter”. Następnie w drugiej „tablicy znaków” wpisaliśmy „Science”. Jest to również renderowane poniżej po ponownym naciśnięciu „Enter”.
Wniosek
Koncepcja inicjowania programowania w C++ „tablicą znaków” została szczegółowo wyjaśniona tutaj. Omówiliśmy, że „tablica znaków” służy do przechowywania kolekcji znaków i ciągów znaków w C++. Zainicjowaliśmy wiele „tablic znaków” i wyświetliliśmy je w naszych kodach. Zainicjowaliśmy także „tablicę znaków”, aby pobrać znaki użytkownika w naszym ostatnim kodzie w tym przewodniku. Wszystkie przykłady zostały tutaj dokładnie wyjaśnione.