In C++, possiamo dichiarare e inizializzare gli array di diversi tipi di dati come int, string, char, ecc. Un array è una variabile che può contenere diversi valori di un tipo di dati simile. Il 'char array' viene utilizzato per memorizzare la raccolta del carattere e le stringhe in esso contenute. L''array di caratteri' è simile all''array int'. Poiché l'array int memorizza i valori numerici, l'array 'char' memorizza la raccolta di caratteri o stringhe nella programmazione C++. In questa guida inizializzeremo l'array di caratteri in C++ nei nostri codici.
Esempio 1:
Iniziamo il codice C++ includendo i file header. Il primo file di intestazione in questo esempio è 'iostream'. Alcune funzioni come 'cin' o 'cout' sono dichiarate in questo file di intestazione di cui abbiamo bisogno in questo codice. Il secondo file di intestazione è 'string.h' che viene aggiunto qui poiché in esso sono definite molte funzioni di cui abbiamo bisogno per manipolare il carattere dell'array. In questo codice viene aggiunto anche lo spazio dei nomi 'std'. Quindi, invochiamo qui il metodo “main()”.
Per inizializzare l'array di caratteri, inseriamo la parola chiave 'char'. Quindi, il nome dell'array viene digitato qui. Il nome dell'array di caratteri è 'new_Array' la cui dimensione è regolata su '50'. Quindi, inizializziamo questo array di caratteri con la riga. La riga che includiamo qui per inizializzare l'array di caratteri è 'Il mio primo array di caratteri è qui!'. Ora vogliamo stampare questi array di caratteri, quindi inseriamo 'new_Array' in 'cout'. Ciò esegue il rendering dell'array di caratteri sulla console.
Codice 1:
#include
#include
utilizzando lo spazio dei nomi std;
int principale ( )
{
char new_Array [ cinquanta ] = 'Il mio primo array di personaggi è qui!' ;
cout << nuovo_Array << fine;
ritorno 0 ;
}
Produzione:
L'array di caratteri che abbiamo inizializzato nel codice viene visualizzato qui nel risultato fornito. Tutti i dati che abbiamo utilizzato per inizializzare l'array di caratteri vengono visualizzati come segue:
Esempio 2:
I file header 'iostream' e 'string.h' sono inclusi qui. Sotto questo, aggiungiamo lo spazio dei nomi “std”. Quindi, dopo aver chiamato 'main()', inizializziamo l'array di caratteri con il nome 'Arr_1'. Inseriamo il tipo di dati 'char' e quindi inseriamo il nome dell'array di caratteri.
Quindi, assegniamo i caratteri a questo array, oppure possiamo dire che inizializziamo questo array qui con i caratteri. Inseriamo i caratteri in questo array e quindi utilizziamo il ciclo 'for' sottostante perché vogliamo visualizzare tutti questi caratteri separatamente. Quindi, utilizziamo 'cout' e aggiungiamo 'Arr_1[i]' in questo cout che visualizza tutti i caratteri dell'array di caratteri.
Codice 2:
#include#include
utilizzando lo spazio dei nomi std;
int principale ( )
{
carattere Arr_1 [ 10 ] = { 'UN' , 'È' , 'io' , 'O' , 'In' , 'N' , 'Con' , 'B' , 'In' , 'X' } ;
per ( int io = 0 ; io < taglia di ( Arr_1 ) / taglia di ( Arr_1 [ 0 ] ) ; i++ )
{
cout << 'Il carattere di Array è ' << Arr_1 [ io ] << fine;
}
ritorno 0 ;
}
Produzione:
Tutti i caratteri dell'array di caratteri vengono ora visualizzati qui. Inseriamo questi caratteri durante l'inizializzazione dell'array nel codice fornito e quindi li rendiamo.
Esempio 3:
Includiamo i file di intestazione 'iostream' e 'string.h' perché dobbiamo lavorare con le funzioni definite in essi e quindi inserire lo spazio dei nomi 'std' sotto di essi.
Successivamente, inizializziamo l'array di caratteri con il nome 'a' dopo aver invocato la funzione 'main()'. La dimensione di questo array 'a' è '12'. Ora, ciò che facciamo è inserire il nome dell'array di caratteri dopo aver impostato il tipo di dati su 'char'. Successivamente, inizializziamo i caratteri su questo array 'char'. Per visualizzare ogni carattere individualmente, prima aggiungiamo i caratteri a questo array e poi utilizziamo il ciclo 'for'. Successivamente, abbiamo aggiunto 'a[i]' a questo cout utilizzando la funzione 'cout' che visualizza tutti i caratteri di questo array 'char'.
Codice 3:
#include#include
utilizzando lo spazio dei nomi std;
int principale ( )
{
carattere a [ 12 ] = { 'UN' , '@' , '#' , '%' , '!' , '^' , '&' , '*' , '' , 'Con' , '@' } ;
per ( int io = 0 ; io < taglia di ( UN ) / taglia di ( UN [ 0 ] ) ; i++ )
{
cout << 'Il personaggio è ' << UN [ io ] << fine;
}
ritorno 0 ;
}
Produzione:
Ora vengono mostrati tutti i caratteri dell'array 'char'. Nel codice fornito, abbiamo inizializzato l'array e aggiunto questi caratteri, visualizzandoli qui.
Esempio 4:
Dobbiamo lavorare con le funzioni definite nei file header “iostream” e “string.h”; includiamo questi per primi, seguiti dallo spazio dei nomi “std”. Utilizziamo quindi il nome 'myCharArray' per inizializzare l'array di caratteri seguendo la suddetta chiamata alla funzione 'main()'. La dimensione di 'myCharArray' viene regolata su '20' e la inizializziamo con 'Character Array'.
Ora vogliamo visualizzare questo array di caratteri. Usiamo 'cout' dove aggiungiamo 'myCharArray' per visualizzare la raccolta di caratteri che abbiamo aggiunto a questo array. L'array di caratteri viene quindi inizializzato con il nome 'myCharArray2'. Qui, l'array 'myCharArray2' ha una dimensione di '5'. Tutto ciò che resta da fare è impostare il tipo di dati su “char” e inserire il nome dell'array di caratteri.
I caratteri vengono quindi inizializzati in questo array 'char'. Inseriamo prima i caratteri in questo array, quindi utilizziamo il ciclo 'for' riportato di seguito per mostrare ciascun carattere separatamente. Successivamente, utilizziamo la funzione 'cout' per aggiungere 'myCharArray2[a]' a questo cout, visualizzando tutti i caratteri in questo array di caratteri.
Codice 4:
#include#include
utilizzando lo spazio dei nomi std;
int principale ( )
{
char myCharArray [ venti ] = 'Array di caratteri' ;
cout << myCharArray << fine;
char myCharArray2 [ 5 ] = { 'UN' , 'B' , 'C' , 'D' , 'È' } ;
per ( int a = 0 ; UN < taglia di ( myCharArray2 ) / taglia di ( myCharArray2 [ 0 ] ) ; a++ )
{
cout << myCharArray2 [ UN ] << fine;
}
ritorno 0 ;
}
Produzione:
Entrambi i valori degli array di caratteri vengono visualizzati di seguito. Per prima cosa abbiamo renderizzato la stringa completa che abbiamo aggiunto nel primo array di caratteri. Quindi, viene visualizzato il secondo array di caratteri in cui abbiamo inserito i caratteri e li abbiamo visualizzati separatamente in un'unica riga.
Esempio 5:
Dopo aver aggiunto lo spazio dei nomi “iostream” e “std”, chiamiamo qui “main()” e quindi inizializziamo il “c_array” del tipo di dati “char” con la dimensione di “100”. Quindi, visualizziamo un messaggio in cui aggiungiamo 'Inserisci qui i dati nell'array di caratteri' in modo che l'utente immetta i caratteri quando questa riga viene stampata.
La funzione 'cin' viene utilizzata per ottenere il carattere nell'array 'char' dall'utente. Inseriamo 'c_array' dopo 'cin' in modo che i dati immessi dall'utente vengano salvati in questo 'c_array'. Ora stampiamo i caratteri dell'array con l'aiuto di 'cout' inserendovi 'c_array'.
Successivamente, viene visualizzato un messaggio al quale abbiamo aggiunto: 'Ora di nuovo, inserisci i dati nell'array di caratteri'. L'utente immette i caratteri in quest'area quando viene stampata questa riga. Per recuperare dall'utente un carattere da utilizzare nell'array “char”, utilizziamo la funzione “cin”. Ora usiamo 'cout' per stampare i caratteri dall'array inserendovi 'c_array'.
Codice 5:
#includeutilizzando lo spazio dei nomi std;
int principale ( )
{
char c_array [ 100 ] ;
cout <> c_array;
cout << 'Sei entrato: ' << c_array << fine;
cout <> c_array;
cout << 'Sei entrato: ' << c_array << fine;
ritorno 0 ;
}
Produzione:
Qui abbiamo inserito 'Computer' nel primo array 'char'. Quindi, viene visualizzato nella riga successiva dopo aver premuto 'Invio'. Successivamente, abbiamo inserito 'Scienza' nel secondo 'array di caratteri'. Questo viene visualizzato anche di seguito dopo aver premuto nuovamente 'Invio'.
Conclusione
Il concetto di inizializzazione della programmazione C++ “char array” è spiegato in dettaglio qui. Abbiamo discusso del fatto che l ''array di caratteri' viene utilizzato per archiviare la raccolta di caratteri e la stringa in C++. Abbiamo inizializzato più 'array di caratteri' e li abbiamo visualizzati nei nostri codici. Abbiamo anche inizializzato un 'array di caratteri' per ottenere i caratteri dall'utente nel nostro ultimo codice in questa guida. Tutti gli esempi sono spiegati dettagliatamente qui.