L'inizio del linguaggio C++ risale al 1983, subito dopo quando 'Bjare Stroustrup' ha lavorato con le classi nel linguaggio C inclusivamente con alcune funzionalità aggiuntive come l'overloading degli operatori. Le estensioni di file utilizzate sono '.c' e '.cpp'. C++ è estensibile e non dipende dalla piattaforma e include STL che è l'abbreviazione di Standard Template Library. Quindi, fondamentalmente il noto linguaggio C++ è in realtà noto come un linguaggio compilato che ha il file sorgente compilato insieme per formare file oggetto, che se combinati con un linker producono un programma eseguibile.

D'altra parte, se parliamo del suo livello, è di livello medio che interpreta il vantaggio della programmazione di basso livello come driver o kernel e anche le app di livello superiore come giochi, GUI o app desktop. Ma la sintassi è quasi la stessa sia per C che per C++.

Componenti del linguaggio C++:

#includi

Questo comando è un file di intestazione che comprende il comando 'cout'. Potrebbe esserci più di un file di intestazione a seconda delle esigenze e delle preferenze dell'utente.

int principale()

Questa istruzione è la funzione del programma master che è un prerequisito per ogni programma C++, il che significa che senza questa istruzione non è possibile eseguire alcun programma C++. Qui 'int' è il tipo di dati della variabile di ritorno che indica il tipo di dati che la funzione sta restituendo.

Dichiarazione:

Le variabili vengono dichiarate e ad esse vengono assegnati dei nomi.

Dichiarazione problema:

Questo è essenziale in un programma e potrebbe essere un ciclo 'while', 'for' o qualsiasi altra condizione applicata.

Operatori:

Gli operatori vengono utilizzati nei programmi C++ e alcuni sono fondamentali perché applicati alle condizioni. Alcuni operatori importanti sono &&, ||, !, &, !=, |, &=, |=, ^, ^=.

C++ Input Output:

Ora discuteremo le capacità di input e output in C++. Tutte le librerie standard utilizzate in C++ forniscono le massime capacità di input e output che vengono eseguite sotto forma di una sequenza di byte o sono normalmente correlate ai flussi.

Flusso di input:

Nel caso in cui i byte vengano trasmessi dal dispositivo alla memoria principale, è il flusso di input.

Flusso di uscita:

Se i byte vengono trasmessi nella direzione opposta, è il flusso di output.

Un file di intestazione viene utilizzato per facilitare l'input e l'output in C++. È scritto come che fornisce metodi per esempio stufare e impostare la precisione. I comandi di input e output sono cin, cout, cerr e clog. Qui, 'cin' indica lo standard input e 'cout' indica il dispositivo di output standard utilizzato con gli operatori di inserimento del flusso (<<) per visualizzare le istruzioni sullo schermo.

Esempio:

Visualizzeremo un messaggio stringa utilizzando una stringa di tipo carattere.

Nella prima riga, stiamo includendo 'iostream' che ha quasi tutte le librerie essenziali di cui potremmo aver bisogno per l'esecuzione di un programma C++. Nella riga successiva, dichiareremo uno spazio dei nomi che fornisce l'ambito per gli identificatori. Dopo aver chiamato la funzione principale, stiamo inizializzando un array di tipi di carattere che memorizza il messaggio stringa e 'cout' lo visualizza concatenando. Stiamo usando 'cout' per visualizzare il testo sullo schermo. Inoltre, abbiamo preso una variabile 'A' con un array di tipo di dati carattere per memorizzare una stringa di caratteri e quindi abbiamo aggiunto entrambi i messaggi dell'array lungo il messaggio statico utilizzando il comando 'cout'.

L'output generato è mostrato di seguito:

Esempio:

In questo caso, rappresenteremmo l'età dell'utente in un semplice messaggio di stringa.

Nel primo passaggio includiamo la libreria. Successivamente, utilizzeremo uno spazio dei nomi che fornirebbe l'ambito per gli identificatori. Nel passaggio successivo, chiameremo il principale() funzione. Dopodiché, stiamo inizializzando age come variabile 'int'. Stiamo usando il comando 'cin' per l'input e il comando 'cout' per l'output del semplice messaggio di stringa. Il 'cin' inserisce il valore dell'età dell'utente e il 'cout' lo visualizza nell'altro messaggio statico.

Questo messaggio viene visualizzato sullo schermo dopo l'esecuzione del programma in modo che l'utente possa acquisire l'età e quindi premere INVIO.

Esempio:

Qui dimostriamo come stampare una stringa usando 'cout'.

Per stampare una stringa, includiamo inizialmente una libreria e quindi lo spazio dei nomi per gli identificatori. Il principale() viene chiamata la funzione. Inoltre, stiamo stampando un output di stringa utilizzando il comando 'cout' con l'operatore di inserimento che visualizza quindi il messaggio statico sullo schermo.

Tipi di dati C++:

I tipi di dati in C++ sono un argomento molto importante e ampiamente conosciuto perché sono alla base del linguaggio di programmazione C++. Allo stesso modo, qualsiasi variabile utilizzata deve essere di un tipo di dati specificato o identificato.

Sappiamo che per tutte le variabili, utilizziamo il tipo di dati durante la dichiarazione per limitare il tipo di dati che doveva essere ripristinato. Oppure, potremmo dire che i tipi di dati indicano sempre a una variabile il tipo di dati che sta memorizzando. Ogni volta che definiamo una variabile, il compilatore assegna la memoria in base al tipo di dati dichiarato poiché ogni tipo di dati ha una capacità di archiviazione di memoria diversa.

Il linguaggio C++ aiuta la diversità dei tipi di dati in modo che il programmatore possa selezionare il tipo di dati appropriato di cui potrebbe aver bisogno.

C++ facilita l'utilizzo dei tipi di dati indicati di seguito:

1. Tipi di dati definiti dall'utente
2. Tipi di dati derivati
3. Tipi di dati integrati

Ad esempio, le seguenti righe vengono fornite per illustrare l'importanza dei tipi di dati inizializzando alcuni tipi di dati comuni:

Di seguito sono riportati alcuni tipi di dati comuni: la dimensione specificata e il tipo di informazioni che le loro variabili memorizzeranno:

• Char: con la dimensione di un byte, memorizzerà un singolo carattere, lettera, numero o valori ASCII.
• Booleano: con la dimensione di 1 byte, memorizzerà e restituirà valori come true o false.
• Int: Con la dimensione di 2 o 4 byte, memorizzerà numeri interi senza decimali.
• Virgola mobile: con la dimensione di 4 byte, memorizzerà i numeri frazionari che hanno uno o più decimali. Questo è adeguato per memorizzare fino a 7 cifre decimali.
• Doppia virgola mobile: con la dimensione di 8 byte, memorizzerà anche i numeri frazionari che hanno uno o più decimali. Questo è adeguato per memorizzare fino a 15 cifre decimali.
• Vuoto: senza una dimensione specificata, un vuoto contiene qualcosa di senza valore. Pertanto, viene utilizzato per le funzioni che restituiscono un valore nullo.
• Carattere largo: con una dimensione maggiore di 8 bit che di solito è lungo 2 o 4 byte è rappresentato da wchar_t che è simile a char e quindi memorizza anche un valore di carattere.

La dimensione delle suddette variabili può variare a seconda dell'uso del programma o del compilatore.

Esempio:

Scriviamo semplicemente un semplice codice in C++ che produrrà le dimensioni esatte di alcuni tipi di dati descritti sopra:

In questo codice stiamo integrando la libreria . Dopo di che, stiamo usando 'spazio dei nomi'. Nella riga successiva chiameremo il principale() funzione in cui stiamo utilizzando un comando 'cout' che stamperà le dimensioni di tutti i tipi di dati specificati nel programma. Per trovare la dimensione delle variabili, dobbiamo applicare il taglia di() metodo.

L'uscita viene ricevuta in byte come mostrato in figura:

Esempio:

Qui aggiungeremo la dimensione di due diversi tipi di dati.

Innanzitutto, stiamo incorporando un file di intestazione che utilizza uno 'spazio dei nomi standard' per gli identificatori. Successivamente, il principale() viene chiamata la funzione in cui stiamo inizializzando prima la variabile 'int' e poi una variabile 'doppia' per verificare la differenza tra le dimensioni di queste due. Quindi, le loro dimensioni sono concatenate dall'uso di taglia di() funzione. L'output viene visualizzato dall'istruzione 'cout'.

C'è un altro termine che deve essere menzionato qui ed è 'Modificatori di dati' . Il nome suggerisce che i 'modificatori di dati' vengono utilizzati insieme ai tipi di dati integrati per modificare le loro lunghezze che un determinato tipo di dati può sostenere in base alla necessità o ai requisiti del compilatore.

Di seguito sono riportati i modificatori di dati accessibili in C++:

1. Firmato
2. Non firmato
3. Lungo
4. Breve

La dimensione modificata e anche l'intervallo appropriato dei tipi di dati incorporati sono indicati di seguito quando vengono combinati con i modificatori del tipo di dati:

• Short int: avendo la dimensione di 2 byte, ha un intervallo di modifiche da -32.768 a 32.767
• Unsigned short int: avendo la dimensione di 2 byte, ha un intervallo di modifiche da 0 a 65.535
• Unsigned int: avendo la dimensione di 4 byte, ha un intervallo di modifiche da 0 a 4.294.967.295
• Int: avendo la dimensione di 4 byte, ha un intervallo di modifica da -2.147.483.648 a 2.147.483.647
• Long int: avendo la dimensione di 4 byte, ha un intervallo di modifica da -2.147.483.648 a 2.147.483.647
• Unsigned long int: avendo la dimensione di 4 byte, ha un intervallo di modifiche da 0 a 4.294.967.295
• Long long int: avendo la dimensione di 8 byte, ha un intervallo di modifiche da –(2^63) a (2^63)-1
• Unsigned long long int: avendo la dimensione di 8 byte, ha un intervallo di modifiche da 0 a 18.446.744.073.709.551.615
• Carattere firmato: avendo la dimensione di 1 byte, ha un intervallo di modifiche da -128 a 127
• Carattere senza segno: avendo la dimensione di 1 byte, ha un intervallo di modifiche da 0 a 255.

Enumerazione C++:

Nel linguaggio di programmazione C++ 'enumerazione' è un tipo di dati definito dall'utente. L'enumerazione è dichiarata come ' enum' in C++. Viene utilizzato per assegnare nomi specifici a qualsiasi costante utilizzata nel programma. Migliora la leggibilità e l'usabilità del programma.

Sintassi:

Dichiariamo l'enumerazione in C++ come segue:

Vantaggi dell'enumerazione in C++:

Enum può essere utilizzato nei seguenti modi:

• Può essere usato frequentemente nelle istruzioni switch case.
• Può utilizzare costruttori, campi e metodi.
• Può solo estendere la classe 'enum', non qualsiasi altra classe.
• Può aumentare il tempo di compilazione.
• Può essere attraversato.

Svantaggi dell'enumerazione in C++:

Enum ha anche alcuni svantaggi:

Se, una volta enumerato, un nome non può essere riutilizzato nello stesso ambito.

Per esempio:

Enum non può essere dichiarato in avanti.

Per esempio:

Sembrano nomi ma sono numeri interi. Quindi, possono convertire automaticamente in qualsiasi altro tipo di dati.

Per esempio:

Esempio:

In questo esempio, vediamo l'utilizzo dell'enumerazione C++:

In questa esecuzione del codice, prima di tutto, iniziamo con #include . è una delle ricche librerie in C++. È una libreria integrata. Implica flussi di dati di Input e Output . Successivamente, utilizziamo lo spazio dei nomi Standard. Quindi, abbiamo dichiarato 'enum' un nome specifico come Soggetto e assegnato tre materie che sono matematica, inglese e urdu. Alla matematica viene assegnato il valore 1. Il nostro obiettivo è stampare i valori dell'oggetto dichiarato in enum. Quindi, invochiamo il principale() funzione. In principale() abbiamo cout<<, dove 'c' significa 'carattere' e out significa 'uscita'. 'Cout' viene utilizzato per visualizzare l'output . << indica l'operatore di inserimento. Usando 'cout<<', stampiamo i valori enum. Successivamente, utilizzeremo il comando 'restituisci 0'. Questo comando restituisce il risultato che è sotto forma di valori.

Ecco il nostro risultato del programma eseguito:

Quindi, come puoi vedere, abbiamo i valori di Soggetto: Math, Urdu, English; cioè 1,2,3.

Esempio:

Ecco un altro esempio attraverso il quale chiariamo i nostri concetti su enum:

In questo programma, iniziamo integrando il file di intestazione . È una libreria integrata. Implica flussi di dati di Input e Output. Dopodiché, dobbiamo utilizzare lo spazio dei nomi Standard. Quindi, abbiamo assegnato valori enum alle costanti che sono i giocatori. Il nostro obiettivo è mostrare di chi si trova. Successivamente, chiamiamo il nostro principale() funzione. Nel principale() funzione abbiamo assegnato due costanti: Shadab, il cui valore è 20 alla variabile enum 'bower1'; e Afridi, il cui valore è 25 per la variabile enum 'bowler2'.

Dobbiamo usare un'istruzione if-else . Abbiamo anche utilizzato l'operatore di confronto all'interno dell'istruzione 'if', il che significa che stiamo confrontando se 'bowler2' è maggiore di 'bowler1'. Quindi, il blocco 'se' viene eseguito, il che significa che è la fine di Afridi. Quindi, abbiamo inserito 'cout<<' per visualizzare l'output. Per prima cosa, stampiamo la dichiarazione 'È finita'. Quindi, il valore di 'bower2'. In caso contrario, viene invocato il blocco else, il che significa che è la fine di Shadab. Quindi, applicando il comando 'cout<<' visualizziamo l'istruzione 'It is over of'. Quindi, il valore di 'bower1'.

Secondo la dichiarazione If-else, abbiamo oltre 25 che è il valore di Afridi. Significa che il valore della variabile enum 'bowler2' è maggiore di 'bowler1', ecco perché viene eseguita l'istruzione 'if'.

C++ Se altro, cambia:

Nel linguaggio di programmazione C++, utilizziamo la 'istruzione if' e la 'istruzione switch' per modificare il flusso del programma. Queste affermazioni vengono utilizzate per fornire più insiemi di comandi per l'implementazione del programma a seconda rispettivamente del vero valore delle affermazioni menzionate. Nella maggior parte dei casi, utilizziamo gli operatori come alternative all'istruzione 'if'. Tutte queste affermazioni di cui sopra sono dichiarazioni di selezione note come dichiarazioni decisionali o condizionali.

La dichiarazione 'se':

Questa affermazione viene utilizzata per testare una determinata condizione ogni volta che si ha voglia di modificare il flusso di un programma. Qui, se una condizione è vera, il programma eseguirà le istruzioni scritte ma se la condizione è falsa, terminerà semplicemente. Consideriamo un esempio;

Questa è la semplice istruzione 'if' utilizzata, in cui stiamo inizializzando una variabile 'int' come 10. Quindi, un valore viene preso dall'utente e viene verificato nell'istruzione 'if'. Se soddisfa le condizioni applicate nell'istruzione 'if', viene visualizzato l'output.

Poiché la cifra scelta era 40, l'output è il messaggio.

L'affermazione 'Se-altro':

In un programma più complesso in cui l'istruzione 'se' di solito non collabora, utilizziamo l'istruzione 'se-altro'. Nel caso specifico, utilizziamo l'istruzione 'se-altro' per verificare le condizioni applicate.

Innanzitutto, dichiareremo una variabile di tipo di dati 'int' denominata 'x' il cui valore è preso dall'utente. Ora, viene utilizzata l'istruzione 'if' in cui è stata applicata una condizione che se il valore intero inserito dall'utente è 2. L'output sarà quello desiderato e verrà visualizzato un semplice messaggio 'NICE TRY'. In caso contrario, se il numero inserito non è 2, l'output sarebbe diverso.

Quando l'utente scrive il numero 2, viene visualizzato il seguente output.

Quando l'utente scrive qualsiasi altro numero tranne 2, l'output che otteniamo è:

L'istruzione Se-altro-se:

Le istruzioni if-else-if nidificate sono piuttosto complesse e vengono utilizzate quando sono applicate più condizioni nello stesso codice. Riflettiamo su questo usando un altro esempio:

Qui, dopo aver integrato il file di intestazione e lo spazio dei nomi, abbiamo inizializzato un valore della variabile 'm' come 200. Il valore di 'm' viene quindi preso dall'utente e quindi verificato con le condizioni multiple indicate nel programma.

Qui, l'utente ha scelto il valore 195. Questo è il motivo per cui l'output mostra che questo è il valore effettivo di 'm'.

Commutazione dichiarazione:

Un'istruzione 'switch' viene utilizzata in C++ per una variabile che deve essere verificata se è uguale a un elenco di più valori. Nella dichiarazione 'switch', identifichiamo le condizioni sotto forma di casi distinti e tutti i casi hanno un'interruzione inclusa alla fine di ogni dichiarazione del caso. A più casi vengono applicate condizioni e istruzioni appropriate con istruzioni break che terminano l'istruzione switch e passano a un'istruzione predefinita nel caso in cui nessuna condizione sia supportata.

Parola chiave 'pausa':

L'istruzione switch contiene la parola chiave 'break'. Interrompe l'esecuzione del codice nel caso successivo. L'esecuzione dell'istruzione switch termina quando il compilatore C++ incontra la parola chiave 'break' e il controllo si sposta sulla riga che segue l'istruzione switch. Non è necessario utilizzare un'istruzione break in uno switch. L'esecuzione passa al caso successivo se non viene utilizzato.

Nella prima riga del codice condiviso, includiamo la libreria. Dopo di che, stiamo aggiungendo 'spazio dei nomi'. Invochiamo il principale() funzione. Quindi, stiamo dichiarando un grado di tipo di dati di carattere come 'F'. Questo voto potrebbe essere il tuo desiderio e il risultato verrebbe mostrato rispettivamente per i casi scelti. Abbiamo applicato l'istruzione switch per ottenere il risultato.

Se scegliamo 'F' come voto, l'output è 'più fortuna la prossima volta' perché questa è l'affermazione che vogliamo venga stampata nel caso in cui il voto sia 'F'.

Cambiamo il voto in X e vediamo cosa succede. Ho scritto 'X' come voto e l'output ricevuto è mostrato di seguito:

Quindi, il caso improprio nell''interruttore' sposta automaticamente il puntatore direttamente sull'istruzione predefinita e termina il programma.

Le istruzioni If-else e switch hanno alcune caratteristiche comuni:

• Queste istruzioni vengono utilizzate per gestire il modo in cui viene eseguito il programma.
• Entrambi valutano una condizione e ciò determina come scorre il programma.
• Nonostante abbiano stili rappresentativi diversi, possono essere utilizzati per lo stesso scopo.

Le istruzioni If-else e switch differiscono in alcuni modi:

• Mentre l'utente ha definito i valori nelle istruzioni 'switch' case, mentre i vincoli determinano i valori nelle istruzioni 'if-else'.
• Ci vuole tempo per determinare dove deve essere fatto il cambiamento, è difficile modificare le affermazioni 'se-altro'. D'altra parte, le istruzioni 'switch' sono semplici da aggiornare perché possono essere modificate facilmente.
• Per includere molte espressioni, possiamo utilizzare numerose affermazioni 'se-altro'.

Cicli C++:

Ora scopriremo come utilizzare i loop nella programmazione C++. La struttura di controllo nota come 'loop' ripete una serie di affermazioni. In altre parole, si chiama struttura ripetitiva. Tutte le istruzioni vengono eseguite contemporaneamente in una struttura sequenziale . D'altra parte, a seconda dell'istruzione specificata, la struttura della condizione può eseguire o omettere un'espressione. Potrebbe essere necessario eseguire un'istruzione più di una volta in situazioni particolari.

Tipi di loop:

Esistono tre categorie di loop:

• Per ciclo
• Mentre Loop
• Fai mentre Loop

Ciclo per:

Il ciclo è qualcosa che si ripete come un ciclo e si interrompe quando non convalida la condizione fornita. Un ciclo 'for' implementa una sequenza di istruzioni numerose volte e condensa il codice che gestisce la variabile di ciclo. Questo dimostra come un ciclo 'for' sia un tipo specifico di struttura di controllo iterativa che ci consente di creare un ciclo che viene ripetuto un determinato numero di volte. Il ciclo ci consentirebbe di eseguire il numero 'N' di passaggi utilizzando solo un codice di una semplice riga. Parliamo della sintassi che utilizzeremo per eseguire un ciclo 'for' nell'applicazione software.

La sintassi dell'esecuzione del ciclo 'for':

Esempio:

Qui, utilizziamo una variabile di ciclo per regolare questo ciclo in un ciclo 'for'. Il primo passo sarebbe assegnare un valore a questa variabile che stiamo affermando come un ciclo. Dopodiché, dobbiamo definire se è minore o maggiore del valore del contatore. Ora, il corpo del ciclo deve essere eseguito e anche la variabile del ciclo viene aggiornata nel caso in cui l'istruzione restituisca true. I passaggi precedenti vengono ripetuti frequentemente fino a raggiungere la condizione di uscita.

• Espressione di inizializzazione: All'inizio, dobbiamo impostare il contatore del ciclo su qualsiasi valore iniziale in questa espressione.
• Espressione di prova : Ora, dobbiamo testare la condizione data nell'espressione data. Se i criteri sono soddisfatti, eseguiremo il corpo del ciclo 'for' e continueremo ad aggiornare l'espressione; in caso contrario, dobbiamo fermarci.
• Espressione di aggiornamento: Questa espressione aumenta o diminuisce la variabile del ciclo di un certo valore dopo che il corpo del ciclo è stato eseguito.

Esempi di programmi C++ per convalidare un ciclo 'For':

Esempio:

Questo esempio mostra la stampa di valori interi da 0 a 10.

In questo scenario, dovremmo stampare gli interi da 0 a 10. Per prima cosa, abbiamo inizializzato una variabile casuale i con un valore dato '0' e quindi il parametro condition che abbiamo già utilizzato controlla la condizione se i<=10. E quando soddisfa la condizione e diventa vera, inizia l'esecuzione del ciclo 'for'. Dopo l'esecuzione, tra i due parametri di incremento o decremento, ne verrà eseguito uno e in cui fino a quando la condizione specificata i<=10 non diventa falsa, il valore della variabile i viene incrementato.

N. di iterazioni con condizione i<10:

Esempio:

L'istanza seguente mostra il valore dell'intero:

Nel caso precedente, una variabile denominata 'a' viene inizializzata con un valore dato 50. Viene applicata una condizione in cui la variabile 'a' è minore di 70. Quindi, il valore di 'a' viene aggiornato in modo tale da essere aggiunto con 2. Il valore di 'a' viene quindi avviato da un valore iniziale che era 50 e 2 viene aggiunto contemporaneamente durante il ciclo finché la condizione non restituisce false e il valore di 'a' viene aumentato da 70 e il ciclo termina.

N. di iterazioni:

Mentre il ciclo:

Finché la condizione definita non è soddisfatta, possono essere eseguite una o più istruzioni. Quando l'iterazione è sconosciuta in anticipo, è molto utile. Innanzitutto, la condizione viene verificata e quindi entra nel corpo del ciclo per eseguire o implementare l'istruzione.

Nella prima riga, incorporiamo il file di intestazione e lo spazio dei nomi standard. Chiamiamo il principale() funzione. Qui inizializziamo una variabile 'a'. Nella riga successiva, applichiamo la condizione while. All'interno della condizione while, utilizziamo l'istruzione 'cout' per visualizzare il valore che viene scritto. Quindi, utilizziamo l'operatore di incremento per aumentare il conteggio. Nell'ultima riga, utilizziamo l'istruzione 'return 0' per terminare il programma.

Ciclo da fare:

Quando la condizione definita è soddisfatta, vengono eseguite una serie di affermazioni. Innanzitutto, viene eseguito il corpo del ciclo. Successivamente, la condizione viene verificata se è vera o meno. Pertanto, l'istruzione viene eseguita una volta. Il corpo del ciclo viene elaborato in un ciclo 'Do-while' prima di valutare la condizione. Il programma viene eseguito ogni volta che la condizione richiesta è soddisfatta. In caso contrario, quando la condizione è falsa, il programma termina.

Qui integriamo il file di intestazione . Utilizziamo il principale() funzione nel programma. Quindi, inizializziamo quattro numeri interi e utilizziamo l'istruzione 'cin', in modo che l'utente possa inserire il valore. Nella riga successiva, inizializzeremo due diversi interi. Applichiamo l'istruzione 'do'. All'interno dell'istruzione, utilizziamo due funzioni aritmetiche. In primo luogo, utilizziamo l'operatore di moltiplicazione e in secondo luogo, utilizziamo l'operatore di addizione. Quindi, applichiamo la condizione 'while' nel programma al di fuori dell'istruzione 'do'. Inoltre, aggiungiamo l'istruzione 'cout' per stampare il risultato tramite l'intero 'risultato'. Nell'ultima riga, per terminare il programma, utilizziamo i comandi return 0.

C++ Continua/Interrompi:

Dichiarazione continua C++:

L'istruzione continue viene utilizzata nel linguaggio di programmazione C++ per evitare un'incarnazione corrente di un ciclo e per spostare il controllo all'iterazione successiva. Durante il ciclo, l'istruzione continue può essere utilizzata per saltare determinate istruzioni. Viene anche utilizzato all'interno del ciclo insieme alle dichiarazioni esecutive. Se la condizione specifica è vera, tutte le istruzioni che seguono l'istruzione continue non vengono implementate.

Con ciclo for:

In questo caso, utilizziamo il 'ciclo for' con l'istruzione continue di C++ per ottenere il risultato richiesto superando alcuni requisiti specificati.

Iniziamo includendo la libreria e usando 'namespace std'. Allora chiamiamo il principale() funzione. Utilizziamo for loop. All'interno del ciclo for, dichiariamo una variabile 'k' che è considerata compresa tra 3 e 8. Utilizziamo una condizione per continuare l'iterazione anche se (k = = 5). Quindi ha utilizzato l'istruzione 'continue' dopo aver specificato la condizione. Alla fine. per mostrare l'output, utilizziamo il comando 'cout' insieme al comando 'return 0'.

Con un ciclo while:

Durante questa dimostrazione, abbiamo utilizzato sia l'istruzione 'while loop' che l'istruzione 'continue' di C++ includendo alcune condizioni per vedere quale tipo di output può essere generato.

In questo esempio, impostiamo una condizione per aggiungere numeri solo a 40. Se l'intero inserito è un numero negativo, il ciclo 'while' verrà terminato. D'altra parte, se il numero è maggiore di 40, quel numero specifico verrà saltato dall'iterazione.

Includeremo la libreria , utilizzando 'namespace std' e quindi chiameremo il file principale() funzione. Inizializziamo una variabile 's'. Un'altra variabile 'numero' viene dichiarata nel passaggio successivo. Usiamo il ciclo 'mentre'. Ora specifichiamo la condizione che il valore richiesto sia maggiore o uguale a zero. Per sommare tutti i numeri positivi, utilizziamo l'istruzione 's += numero'. Il comando 'cout' verrà applicato per mostrare il messaggio sulla console 'Inserisci un numero qualsiasi'. Otteniamo il numero intero dall'utente utilizzando l'istruzione 'cin'. Utilizziamo anche l'istruzione 'se'. Ogni volta che il numero definito è maggiore di 40, verrà visualizzato il messaggio. Quindi, abbiamo usato il comando 'continua'. Dopo tutti questi passaggi, verrà eseguita l'istruzione 'continua'. Per mostrare la somma di tutti i numeri, utilizziamo l'istruzione 'cout'.

Dichiarazione di interruzione C++:

Ogni volta che l'istruzione break viene utilizzata in un ciclo in C++, il ciclo viene terminato immediatamente e il controllo del programma viene riavviato all'istruzione dopo il ciclo. È anche possibile terminare un caso all'interno di un'istruzione 'switch'.

Con ciclo for:

Qui, utilizzeremo il ciclo 'for' con l'istruzione 'break' per osservare l'output iterando su valori diversi.

Innanzitutto, incorporiamo un file di intestazione . Successivamente, utilizziamo 'namespace std'. Dopo aver chiamato la funzione main(), abbiamo usato per il ciclo. Qui, vorremmo inizializzare la variabile 'm'. Applicheremo la condizione che il valore di 'm' sia compreso tra 10 e 20. La condizione di 'break' verrà eseguita come se (m == 17). Per stampare il risultato, abbiamo utilizzato 'cout'. Quindi, verrà applicato il comando 'restituisci 0'.

Con un ciclo while:

Utilizzeremo il ciclo 'while' insieme all'istruzione break.

Iniziamo importando la libreria . Lo 'spazio dei nomi std' sarà incluso. All'interno del metodo main(), verrebbero inizializzate due variabili 'nbr' e 'x'. Abbiamo usato il ciclo 'while' e abbiamo passato 'true' come argomento. Per ottenere valore dall'utente, utilizziamo il comando 'cin'. Successivamente, abbiamo utilizzato l'istruzione 'se'. Insieme a questo, viene applicata la condizione 'break' per specificare la condizione if (nbr < 0). Per sommare tutti i valori positivi, abbiamo utilizzato le formule 'x += nbr'. Per visualizzare questa somma, abbiamo aggiunto la dichiarazione 'cout'.

Funzioni C++:

Le funzioni vengono utilizzate per strutturare un programma già noto in più frammenti di codici che vengono eseguiti solo quando viene chiamato. Nel linguaggio di programmazione C++, una funzione è definita come un gruppo di istruzioni a cui viene assegnato un nome appropriato e richiamate da esse. L'utente può passare i dati nelle funzioni che chiamiamo parametri. Le funzioni sono responsabili dell'implementazione delle azioni quando è più probabile che il codice venga riutilizzato.

Creazione di una funzione:

Sebbene C++ offra molte funzioni predefinite come principale(), che facilita l'esecuzione del codice. Allo stesso modo, puoi creare e definire le tue funzioni in base alle tue esigenze. Proprio come tutte le normali funzioni, qui hai bisogno di un nome per la tua funzione per una dichiarazione che viene aggiunta con una parentesi dopo '()'.

Sintassi:

Void è il tipo restituito della funzione. Labor è il nome che gli viene dato e le parentesi graffe racchiudono il corpo della funzione in cui aggiungiamo il codice per l'esecuzione.

Chiamare una funzione:

Le funzioni dichiarate nel codice vengono eseguite solo quando vengono richiamate. Per chiamare una funzione, è necessario specificare il nome della funzione insieme alla parentesi seguita da un punto e virgola ';'.

Esempio:

Dichiariamo e costruiamo una funzione definita dall'utente in questa situazione.

Inizialmente, come descritto in ogni programma, ci viene assegnata una libreria e uno spazio dei nomi per supportare l'esecuzione del programma. La funzione definita dall'utente lavoro duro e faticoso() viene sempre chiamato prima di scrivere il principale() funzione. Una funzione denominata lavoro duro e faticoso() viene dichiarato dove viene visualizzato un messaggio 'Un lavoro merita rispetto!'. Nel principale() funzione con il tipo restituito intero, chiamiamo il lavoro duro e faticoso() funzione.

Questo è il semplice messaggio che è stato definito nella funzione definita dall'utente qui visualizzata con l'aiuto di principale() funzione.

Vuoto:

Nel suddetto caso, abbiamo notato che il tipo restituito della funzione definita dall'utente è void. Ciò indica che la funzione non restituisce alcun valore. Ciò rappresenta che il valore non è presente o è probabilmente nullo. Perché ogni volta che una funzione sta solo stampando i messaggi, non ha bisogno di alcun valore di ritorno.

Questo vuoto viene utilizzato in modo simile nello spazio dei parametri della funzione per affermare chiaramente che questa funzione non assume alcun valore effettivo mentre viene chiamata. Nella situazione di cui sopra, chiameremmo anche il lavoro duro e faticoso() funzionano come:

I parametri effettivi:

Si possono definire parametri per la funzione. I parametri di una funzione sono definiti nell'elenco degli argomenti della funzione che si aggiunge al nome della funzione. Ogni volta che chiamiamo la funzione, dobbiamo passare i valori autentici dei parametri per completare l'esecuzione. Questi sono conclusi come i parametri effettivi. Mentre i parametri definiti mentre la funzione è stata definita sono noti come Parametri formali.

Esempio:

In questo esempio, stiamo per scambiare o sostituire i due valori interi tramite una funzione.

All'inizio, stiamo prendendo il file di intestazione. La funzione definita dall'utente è quella dichiarata e definita denominata sub(). Questa funzione viene utilizzata per la sostituzione dei due valori interi che sono i e n. Successivamente, gli operatori aritmetici vengono utilizzati per lo scambio di questi due numeri interi. Il valore del primo intero 'i' viene memorizzato al posto del valore 'n' e il valore di n viene salvato al posto del valore di 'i'. Quindi, viene stampato il risultato dopo aver cambiato i valori. Se parliamo di principale() funzione, stiamo prendendo i valori dei due interi dall'utente e visualizzati. Nell'ultimo passaggio, la funzione definita dall'utente sub() viene chiamato e i due valori vengono scambiati.

In questo caso di sostituzione dei due numeri, possiamo vedere chiaramente che utilizzando il sub() funzione, i valori di 'i' e 'n' all'interno dell'elenco dei parametri sono i parametri formali. I parametri effettivi sono il parametro che sta passando alla fine del principale() funzione in cui viene chiamata la funzione di sostituzione.

Puntatori C++:

Il puntatore in C++ è molto più facile da imparare e ottimo da usare. Nel linguaggio C++ i puntatori sono usati perché facilitano il nostro lavoro e tutte le operazioni funzionano con grande efficienza quando sono coinvolti i puntatori. Inoltre, ci sono alcune attività che non verranno eseguite a meno che i puntatori non vengano utilizzati come l'allocazione dinamica della memoria. Parlando di puntatori, l'idea principale da comprendere è che il puntatore è solo una variabile che memorizzerà l'esatto indirizzo di memoria come suo valore. L'uso estensivo dei puntatori in C++ è dovuto ai seguenti motivi:

• Per passare una funzione all'altra.
• Per allocare i nuovi oggetti nell'heap.
• Per l'iterazione di elementi in un array

Di solito, l'operatore '&' (e commerciale) viene utilizzato per accedere all'indirizzo di qualsiasi oggetto in memoria.

Puntatori e loro tipi:

Il puntatore ha diversi tipi seguenti:

• Puntatori nulli: Si tratta di puntatori con un valore pari a zero archiviati nelle librerie C++.
• Puntatore aritmetico: Include quattro principali operatori aritmetici accessibili che sono ++, –, +, -.
• Una serie di puntatori: Sono array utilizzati per memorizzare alcuni puntatori.
• Puntatore a puntatore: È dove un puntatore viene utilizzato su un puntatore.

Esempio:

Rifletti sull'esempio successivo in cui vengono stampati gli indirizzi di alcune variabili.

Dopo aver incluso il file di intestazione e lo spazio dei nomi standard, stiamo inizializzando due variabili. Uno è un valore intero rappresentato da i' e un altro è una matrice di tipo di carattere 'I' con una dimensione di 10 caratteri. Gli indirizzi di entrambe le variabili vengono quindi visualizzati utilizzando il comando 'cout'.

L'output che abbiamo ricevuto è mostrato di seguito:

Questo risultato mostra l'indirizzo per entrambe le variabili.

D'altra parte, un puntatore è considerato una variabile il cui valore stesso è l'indirizzo di una variabile diversa. Un puntatore punta sempre a un tipo di dati che ha lo stesso tipo creato con un operatore (*).

Dichiarazione di un puntatore:

Il puntatore viene dichiarato in questo modo:

Il tipo base del puntatore è indicato da “tipo”, mentre il nome del puntatore è espresso da “var-name”. E per intitolare una variabile al puntatore viene utilizzato l'asterisco(*).

Modalità di assegnazione dei puntatori alle variabili:

Quasi sempre c'è un numero esadecimale lungo che rappresenta l'indirizzo di memoria che inizialmente è lo stesso per tutti i puntatori indipendentemente dai loro tipi di dati.

Esempio:

L'istanza seguente dimostrerebbe come i puntatori sostituiscono l'operatore '&' e memorizzano l'indirizzo delle variabili.

Integreremo il supporto delle librerie e delle directory. Quindi, invocheremmo il principale() funzione in cui prima dichiariamo e inizializziamo una variabile 'n' di tipo 'int' con il valore 55. Nella riga successiva, stiamo inizializzando una variabile puntatore denominata 'p1'. Successivamente, assegniamo l'indirizzo della variabile 'n' al puntatore 'p1' e poi mostriamo il valore della variabile 'n'. Viene visualizzato l'indirizzo di 'n' memorizzato nel puntatore 'p1'. Successivamente, il valore di '*p1' viene stampato sullo schermo utilizzando il comando 'cout'. L'uscita è la seguente:

Qui vediamo che il valore di 'n' è 55 e l'indirizzo di 'n' memorizzato nel puntatore 'p1' è mostrato come 0x6ffe14. Viene trovato il valore della variabile pointer ed è 55 che è lo stesso del valore della variabile intera. Pertanto, un puntatore memorizza l'indirizzo della variabile, e anche il puntatore *, ha il valore dell'intero memorizzato che restituirà il valore della variabile inizialmente memorizzata.

Esempio:

Consideriamo un altro esempio in cui stiamo usando un puntatore che memorizza l'indirizzo di una stringa.

In questo codice, stiamo prima aggiungendo le librerie e lo spazio dei nomi. Nel principale() funzione dobbiamo dichiarare una stringa denominata 'makeup' che contiene il valore 'Mascara'. Un puntatore di tipo stringa '*p2' viene utilizzato per memorizzare l'indirizzo della variabile makeup. Il valore della variabile 'makeup' viene quindi visualizzato sullo schermo utilizzando l'istruzione 'cout'. Successivamente viene stampato l'indirizzo della variabile 'makeup' e alla fine viene visualizzata la variabile puntatore 'p2' che mostra l'indirizzo di memoria della variabile 'makeup' con il puntatore.

L'output ricevuto dal codice sopra è il seguente:

La prima riga ha il valore della variabile 'makeup' visualizzata. La seconda riga mostra l'indirizzo della variabile 'makeup'. Nell'ultima riga viene mostrato l'indirizzo di memoria della variabile 'makeup' con l'utilizzo del puntatore.

Gestione della memoria C++:

Per una gestione efficace della memoria in C++, molte operazioni sono utili per la gestione della memoria mentre si lavora in C++. Quando utilizziamo C++, la procedura di allocazione della memoria più comunemente usata è l'allocazione dinamica della memoria in cui le memorie vengono assegnate alle variabili durante il runtime; non come altri linguaggi di programmazione in cui il compilatore potrebbe allocare la memoria alle variabili. In C++ è necessaria la deallocazione delle variabili allocate dinamicamente, in modo che la memoria venga liberata quando la variabile non è più in uso.

Per l'allocazione dinamica e la deallocazione della memoria in C++, facciamo il ' nuovo' e 'Elimina' operazioni. È fondamentale gestire la memoria in modo da non sprecare memoria. L'allocazione della memoria diventa facile ed efficace. In qualsiasi programma C++, la memoria viene utilizzata in uno dei due aspetti: come heap o come stack.

• Pila : Tutte le variabili dichiarate all'interno della funzione e ogni altro dettaglio correlato alla funzione viene memorizzato nello stack.
• Mucchio : Qualsiasi tipo di memoria inutilizzata o la parte da cui allochiamo o assegniamo la memoria dinamica durante l'esecuzione di un programma è noto come heap.

Durante l'utilizzo degli array, l'allocazione della memoria è un'attività in cui non possiamo determinare la memoria a meno che non sia il runtime. Quindi, assegniamo la memoria massima all'array, ma anche questa non è una buona pratica poiché nella maggior parte dei casi la memoria rimane inutilizzata ed è in qualche modo sprecata, il che non è una buona opzione o pratica per il tuo personal computer. Questo è il motivo per cui abbiamo alcuni operatori che vengono utilizzati per allocare memoria dall'heap durante il runtime. I due principali operatori 'nuovo' ed 'elimina' vengono utilizzati per un'allocazione e una deallocazione di memoria efficienti.

Nuovo operatore C++:

Il nuovo operatore è responsabile dell'allocazione della memoria e viene utilizzato come segue:

In questo codice, includiamo la libreria e lo spazio dei nomi. Quindi, abbiamo inizializzato un puntatore con il tipo di dati 'int'. Nella riga successiva, a questo puntatore viene assegnato l'operatore 'nuovo'.

La memoria è stata allocata correttamente alla variabile 'int' con l'utilizzo di un puntatore.

Operatore di eliminazione C++:

Ogni volta che abbiamo finito di usare una variabile, dobbiamo deallocare la memoria che una volta l'abbiamo allocata perché non è più in uso. Per questo, utilizziamo l'operatore 'cancella' per liberare la memoria.

L'esempio che esamineremo ora include entrambi gli operatori.

Stiamo calcolando la media per tre diversi valori presi dall'utente. Le variabili del puntatore vengono assegnate con l'operatore 'nuovo' per memorizzare i valori. La formula della media è implementata. Successivamente, viene utilizzato l'operatore 'cancella' che elimina i valori che erano memorizzati nelle variabili del puntatore utilizzando l'operatore 'nuovo'. Questa è l'allocazione dinamica in cui viene effettuata l'allocazione durante il runtime e quindi la deallocazione avviene subito dopo il termine del programma.

Uso dell'array per l'allocazione della memoria:

Ora vedremo come vengono utilizzati gli operatori 'nuovo' ed 'elimina' durante l'utilizzo degli array. L'allocazione dinamica avviene nello stesso modo in cui avveniva per le variabili poiché la sintassi è quasi la stessa.

In questo caso, stiamo considerando l'array di elementi il ​​cui valore è preso dall'utente. Gli elementi dell'array vengono presi e la variabile pointer viene dichiarata e quindi viene allocata la memoria. Subito dopo l'allocazione della memoria, viene avviata la procedura di input degli elementi dell'array. Successivamente, l'output per gli elementi dell'array viene mostrato utilizzando un ciclo 'for'. Questo ciclo ha la condizione di iterazione di elementi aventi una dimensione inferiore alla dimensione effettiva dell'array che è rappresentato da n.

Quando tutti gli elementi sono stati utilizzati e non è più necessario che vengano riutilizzati, la memoria assegnata agli elementi verrà deallocata utilizzando l'operatore 'cancella'.

Nell'output, potremmo vedere insiemi di valori stampati due volte. Il primo ciclo 'for' è stato utilizzato per annotare i valori degli elementi e l'altro ciclo 'for' è utilizzato per la stampa dei valori già scritti che mostrano che l'utente ha scritto questi valori per chiarezza.

vantaggi:

L'operatore 'nuovo' ed 'elimina' è sempre la priorità nel linguaggio di programmazione C++ ed è ampiamente utilizzato. Durante una discussione e una comprensione approfondite, si nota che il 'nuovo' operatore ha troppi vantaggi. I vantaggi del 'nuovo' operatore per l'allocazione della memoria sono i seguenti:

• Il nuovo operatore può essere sovraccaricato con maggiore facilità.
• Durante l'allocazione della memoria durante il runtime, ogni volta che non c'è memoria sufficiente, verrà generata un'eccezione automatica anziché solo la chiusura del programma.
• Il trambusto dell'uso della procedura di typecasting non è presente qui perché l'operatore 'nuovo' ha lo stesso tipo della memoria che abbiamo assegnato.
• L'operatore 'nuovo' rifiuta anche l'idea di utilizzare l'operatore sizeof() poiché 'nuovo' calcolerà inevitabilmente la dimensione degli oggetti.
• L'operatore 'nuovo' ci consente di inizializzare e dichiarare gli oggetti anche se sta generando lo spazio per loro spontaneamente.

Matrici C++:

Avremo una discussione approfondita su cosa sono gli array e come vengono dichiarati e implementati in un programma C++. L'array è una struttura di dati utilizzata per memorizzare più valori in una sola variabile, riducendo così il trambusto di dichiarare molte variabili in modo indipendente.

Dichiarazione di array:

Per dichiarare un array, bisogna prima definire il tipo di variabile e dare un nome appropriato all'array che viene poi aggiunto lungo le parentesi quadre. Questo conterrà il numero di elementi che mostrano la dimensione di un particolare array.

Per esempio:

Questa variabile viene dichiarata mostrando che contiene cinque stringhe in un array chiamato 'makeup'. Per identificare e illustrare i valori di questa matrice, dobbiamo utilizzare le parentesi graffe, con ciascun elemento racchiuso separatamente tra virgolette doppie, ciascuna separata da una singola virgola in mezzo.

Per esempio:

Allo stesso modo, se hai voglia di creare un altro array con un tipo di dati diverso che dovrebbe essere 'int', la procedura sarebbe la stessa, devi solo cambiare il tipo di dati della variabile come mostrato di seguito:

Durante l'assegnazione di valori interi all'array, non è necessario contenerli tra virgolette, che funzionerebbero solo per la variabile stringa. Quindi, in definitiva, un array è una raccolta di elementi di dati correlati con tipi di dati derivati ​​archiviati in essi.

Come accedono agli elementi nell'array?

A tutti gli elementi inclusi nell'array viene assegnato un numero distinto che è il loro numero di indice utilizzato per accedere a un elemento dell'array. Il valore dell'indice inizia con uno 0 fino a uno in meno rispetto alla dimensione dell'array. Il primo valore ha il valore dell'indice di 0.

Esempio:

Considera un esempio molto semplice e semplice in cui inizializzeremo le variabili in un array.

Nella prima fase, stiamo incorporando il file di intestazione , che aggiungerà automaticamente tutte le librerie necessarie nel programma. Lo spazio dei nomi 'std' fornirà l'ambito per le directory. Nella terza riga, chiamiamo il principale() funzione. La parentesi graffa indica l'inizio della funzione. Dopo essere entrati nella funzione, dichiareremo l'array di tipo 'int' chiamato 'cifre'. Contiene la dimensione di 4, il che significa che potrebbe contenere solo 4 valori interi alla volta. A ciascuno degli elementi dell'array è stata assegnata una cifra univoca e diversa separatamente. L'intero array viene quindi visualizzato con ogni elemento richiamato individualmente.

Questo è il risultato ricevuto dal codice sopra. La parola chiave 'endl' sposta automaticamente l'altro elemento alla riga successiva.

Esempio:

In questo codice, utilizziamo un ciclo 'for' per stampare gli elementi di un array.

Nell'esempio precedente, stiamo aggiungendo la libreria essenziale. Lo spazio dei nomi standard viene aggiunto. Il principale() function è la funzione in cui eseguiremo tutte le funzionalità per l'esecuzione di un particolare programma. Successivamente, stiamo dichiarando un array di tipo int chiamato 'Num', che ha una dimensione di 10. Il valore di queste dieci variabili viene preso dall'utente con l'uso del ciclo 'for'. Per la visualizzazione di questo array, viene nuovamente utilizzato un ciclo 'for'. I 10 numeri interi memorizzati nell'array vengono visualizzati con l'aiuto dell'istruzione 'cout'.

Questo è l'output che abbiamo ottenuto dall'esecuzione del codice precedente, che mostra 10 numeri interi con valori diversi.

Esempio:

In questo scenario, stiamo per scoprire il punteggio medio di uno studente e la percentuale che ha ottenuto in classe.

Innanzitutto, è necessario aggiungere una libreria che fornirà il supporto iniziale al programma C++. Successivamente, stiamo specificando la dimensione 5 dell'array denominato 'Punteggio'. Quindi, abbiamo inizializzato una variabile 'somma' del tipo di dati float. I punteggi di ogni materia sono presi manualmente dall'utente. Quindi, viene utilizzato un ciclo 'for' per scoprire la media e la percentuale di tutti i soggetti inclusi. La somma si ottiene utilizzando l'array e il ciclo 'for'. Quindi, la media viene trovata utilizzando la formula della media. Dopo aver scoperto la media, ne passiamo il valore alla percentuale che viene aggiunta alla formula per ottenere la percentuale. La media e la percentuale vengono quindi calcolate e visualizzate.

Questo è l'output finale in cui vengono presi dall'utente i punteggi per ciascuna materia individualmente e vengono calcolate rispettivamente la media e la percentuale.

Vantaggi dell'utilizzo di array:

• Gli elementi nell'array sono facilmente accessibili grazie al numero di indice loro assegnato.
• Possiamo facilmente eseguire l'operazione di ricerca su un array.
• Nel caso in cui desideri complessità nella programmazione, puoi utilizzare un array bidimensionale che caratterizzi anche le matrici.
• Per memorizzare più valori che hanno un tipo di dati simile, è possibile utilizzare facilmente un array.

Svantaggi dell'utilizzo di array:

• Gli array hanno una dimensione fissa.
• Gli array sono omogenei, il che significa che viene memorizzato solo un singolo tipo di valore.
• Gli array memorizzano i dati nella memoria fisica individualmente.
• Il processo di inserimento ed eliminazione non è facile per gli array.

Oggetti e classi C++:

C++ è un linguaggio di programmazione orientato agli oggetti, il che significa che gli oggetti svolgono un ruolo fondamentale in C++. Parlando di oggetti bisogna prima considerare cosa sono gli oggetti, quindi un oggetto è qualsiasi istanza della classe. Poiché il C++ ha a che fare con i concetti di OOP, le cose principali da discutere sono gli oggetti e le classi. Le classi sono infatti tipi di dati definiti dall'utente stesso e designati per incapsulare i membri dei dati e le funzioni accessibili solo all'istanza per la classe particolare. I membri dati sono le variabili definite all'interno della classe.

La classe in altre parole è uno schema o un progetto responsabile della definizione e dichiarazione dei membri dati e delle funzioni assegnate a tali membri dati. Ciascuno degli oggetti dichiarati nella classe sarebbe in grado di condividere tutte le caratteristiche o funzioni dimostrate dalla classe.

Supponiamo che ci sia una classe chiamata uccelli, ora inizialmente tutti gli uccelli potrebbero volare e avere le ali. Pertanto, il volo è un comportamento che questi uccelli adottano e le ali sono parte del loro corpo o una caratteristica fondamentale.

Definizione di una classe:

Per definire una classe, devi seguire la sintassi e reimpostarla in base alla tua classe. La parola chiave 'classe' viene utilizzata per definire la classe e tutti gli altri membri e funzioni di dati sono definiti all'interno delle parentesi graffe seguite dalla definizione della classe.

Dichiarare oggetti:

Subito dopo aver definito una classe, dobbiamo creare gli oggetti per accedere e definire le funzioni che sono state specificate dalla classe. Per questo, dobbiamo scrivere il nome della classe e quindi il nome dell'oggetto per la dichiarazione.

Accesso ai membri dati:

Le funzioni e i membri dei dati sono accessibili con l'aiuto di un semplice punto '.' Operatore. Con questo operatore si accede anche ai membri dei dati pubblici, ma nel caso dei membri dei dati privati ​​non è possibile accedervi direttamente. L'accesso dei membri dei dati dipende dai controlli di accesso forniti loro dai modificatori di accesso che sono privati, pubblici o protetti. Ecco uno scenario che mostra come dichiarare la classe semplice, i membri dati e le funzioni.

Esempio:

In questo esempio, definiremo alcune funzioni e accederemo alle funzioni della classe e ai membri dei dati con l'aiuto degli oggetti.

Nella prima fase, stiamo integrando la libreria, dopodiché dobbiamo includere le directory di supporto. La classe viene definita in modo esplicito prima di chiamare il principale() funzione. Questa classe è chiamata 'veicolo'. I membri dei dati erano il 'nome del veicolo e l''id' di quel veicolo, che è rispettivamente il numero di targa di quel veicolo con una stringa e il tipo di dati int. Le due funzioni sono dichiarate per questi due membri di dati. Il id() la funzione visualizza l'ID del veicolo. Poiché i membri dati della classe sono pubblici, possiamo accedervi anche al di fuori della classe. Pertanto, chiamiamo il nome() funzione al di fuori della classe e quindi prelevando il valore per 'VehicleName' dall'utente e stampandolo nel passaggio successivo. Nel principale() funzione, stiamo dichiarando un oggetto della classe richiesta che aiuterà ad accedere ai membri dati e alle funzioni dalla classe. Inoltre, stiamo inizializzando i valori per il nome del veicolo e il suo ID, solo se l'utente non fornisce il valore per il nome del veicolo.

Questo è l'output ricevuto quando l'utente fornisce il nome stesso del veicolo e le targhe sono il valore statico ad esso assegnato.

Parlando della definizione delle funzioni membro, bisogna capire che non sempre è obbligatorio definire la funzione all'interno della classe. Come puoi vedere nell'esempio sopra, stiamo definendo la funzione della classe al di fuori della classe perché i membri dei dati sono dichiarati pubblicamente e questo viene fatto con l'aiuto dell'operatore di risoluzione dell'ambito mostrato come '::' insieme al nome di la classe e il nome della funzione.

Costruttori e distruttori C++:

Avremo una visione approfondita di questo argomento con l'aiuto di esempi. L'eliminazione e la creazione degli oggetti nella programmazione C++ sono molto importanti. Per questo, ogni volta che creiamo un'istanza per una classe, in alcuni casi chiamiamo automaticamente i metodi del costruttore.

Costruttori:

Come indica il nome, un costruttore deriva dalla parola 'costruire' che specifica la creazione di qualcosa. Quindi, un costruttore è definito come una funzione derivata della classe appena creata che condivide il nome della classe. E viene utilizzato per l'inizializzazione degli oggetti inclusi nella classe. Inoltre, un costruttore non ha un valore restituito per se stesso, il che significa che il suo tipo restituito non sarà nemmeno nullo. Non è obbligatorio accettare gli argomenti, ma se necessario è possibile aggiungerli. I costruttori sono utili nell'allocazione della memoria all'oggetto di una classe e nell'impostazione del valore iniziale per le variabili membro. Il valore iniziale può essere passato sotto forma di argomenti alla funzione di costruzione una volta che l'oggetto è stato inizializzato.

Sintassi:

Tipi di Costruttori:

Costruttore parametrizzato:

Come discusso in precedenza, un costruttore non ha alcun parametro ma è possibile aggiungere un parametro a propria scelta. Questo inizializzerà il valore dell'oggetto durante la creazione. Per comprendere meglio questo concetto, si consideri il seguente esempio:

Esempio:

In questo caso, creeremo un costruttore della classe e dichiareremo i parametri.

Stiamo includendo il file di intestazione nel primo passaggio. Il passaggio successivo dell'utilizzo di uno spazio dei nomi consiste nel supportare le directory nel programma. Viene dichiarata una classe denominata 'digits' in cui prima le variabili vengono inizializzate pubblicamente in modo che possano essere accessibili in tutto il programma. Viene dichiarata una variabile denominata 'dig1' con tipo di dati intero. Successivamente, abbiamo dichiarato un costruttore il cui nome è simile al nome della classe. Questo costruttore ha una variabile intera passata come 'n' e la variabile di classe 'dig1' è impostata uguale a n. Nel principale() funzione del programma, vengono creati tre oggetti per la classe 'cifre' a cui vengono assegnati dei valori casuali. Questi oggetti vengono quindi utilizzati per richiamare le variabili di classe a cui vengono assegnati automaticamente gli stessi valori.

I valori interi vengono presentati sullo schermo come output.

Costruttore di copia:

È il tipo di costruttore che considera gli oggetti come argomenti e duplica i valori dei membri dati di un oggetto nell'altro. Pertanto, questi costruttori vengono utilizzati per dichiarare e inizializzare un oggetto dall'altro. Questo processo è chiamato inizializzazione della copia.

Esempio:

In questo caso, verrà dichiarato il costruttore della copia.

Innanzitutto, stiamo integrando la libreria e la directory. Viene dichiarata una classe denominata 'New' in cui gli interi vengono inizializzati come 'e' e 'o'. Il costruttore viene reso pubblico dove alle due variabili vengono assegnati i valori e queste variabili vengono dichiarate nella classe. Quindi, questi valori vengono visualizzati con l'aiuto di principale() funzione con 'int' come tipo restituito. Il Schermo() la funzione viene chiamata e definita in seguito in cui i numeri vengono visualizzati sullo schermo. Dentro il principale() funzione, gli oggetti vengono creati e questi oggetti assegnati vengono inizializzati con valori casuali e quindi il Schermo() viene utilizzato il metodo.

L'output ricevuto dall'utilizzo del costruttore di copia è mostrato di seguito.

cacciatorpediniere:

Come definisce il nome, i distruttori vengono utilizzati per distruggere gli oggetti creati dal costruttore. Paragonabili ai costruttori, i distruttori hanno lo stesso nome della classe ma con una tilde aggiuntiva (~) seguita.

Sintassi:

Il distruttore non accetta argomenti e non ha nemmeno alcun valore di ritorno. Il compilatore fa implicitamente appello all'uscita dal programma per l'archiviazione di pulitura che non è più accessibile.

Esempio:

In questo scenario, stiamo utilizzando un distruttore per eliminare un oggetto.

Qui viene creata una classe 'Scarpe'. Viene creato un costruttore con un nome simile a quello della classe. Nel costruttore viene visualizzato un messaggio in cui viene creato l'oggetto. Dopo il costruttore, viene creato il distruttore che elimina gli oggetti creati con il costruttore. Nel principale() funzione, viene creato un oggetto puntatore denominato 's' e viene utilizzata una parola chiave 'cancella' per eliminare questo oggetto.

Questo è l'output che abbiamo ricevuto dal programma in cui il distruttore sta cancellando e distruggendo l'oggetto creato.

Differenza tra costruttori e distruttori:

Ereditarietà C++:

Ora impareremo l'ereditarietà di C++ e il suo ambito.

L'ereditarietà è il metodo attraverso il quale una nuova classe viene generata o discende da una classe esistente. La classe attuale è definita 'classe base' o anche 'classe genitore' e la nuova classe creata è definita 'classe derivata'. Quando diciamo che una classe figlia è ereditata da una classe genitore significa che il figlio possiede tutte le proprietà della classe genitore.

L'ereditarietà si riferisce a una relazione (è a). Chiamiamo ereditarietà qualsiasi relazione se 'is-a' è usato tra due classi.

Per esempio:

• Un pappagallo è un uccello.
• Un computer è una macchina.

Sintassi:

Nella programmazione C++, usiamo o scriviamo Ereditarietà come segue:

Modalità di ereditarietà C++:

L'ereditarietà coinvolge 3 modalità per ereditare le classi:

• Pubblico: In questa modalità, se viene dichiarata una classe figlia, i membri di una classe genitore vengono ereditati dalla classe figlia come gli stessi in una classe genitore.
• Protetto: I In questa modalità, i membri pubblici della classe genitore diventano membri protetti nella classe figlia.
• Privato : in questa modalità, tutti i membri di una classe genitore diventano privati ​​nella classe figlia.

Tipi di ereditarietà C++:

Di seguito sono riportati i tipi di ereditarietà C++:

1. Ereditarietà singola:

Con questo tipo di eredità, le classi hanno avuto origine da una classe base.

Sintassi:

2. Ereditarietà multipla:

In questo tipo di eredità, una classe può discendere da classi base diverse.

Sintassi:

3. Ereditarietà multilivello:

Una classe figlio discende da un'altra classe figlio in questa forma di ereditarietà.

Sintassi:

4. Eredità gerarchica:

Diverse sottoclassi vengono create da una classe base in questo metodo di ereditarietà.

Sintassi:

5. Ereditarietà ibrida:

In questo tipo di eredità, le eredità multiple sono combinate.

Sintassi:

Esempio:

Eseguiremo il codice per dimostrare il concetto di ereditarietà multipla nella programmazione C++.

Poiché abbiamo iniziato con una libreria standard di input-output, abbiamo assegnato il nome della classe base 'Bird' e l'abbiamo resa pubblica in modo che i suoi membri possano essere accessibili. Quindi, abbiamo la classe base 'Reptile' e l'abbiamo anche resa pubblica. Quindi, abbiamo 'cout' per stampare l'output. Successivamente, abbiamo creato un 'pinguino' di classe bambino. Nel principale() funzione abbiamo creato l'oggetto della classe pinguino 'p1'. Innanzitutto, verrà eseguita la classe 'Uccello' e quindi la classe 'Rettile'.

Dopo l'esecuzione del codice in C++, otteniamo le istruzioni di output delle classi base 'Bird' e 'Reptile'. Significa che una classe 'pinguino' deriva dalle classi base 'uccello' e 'rettile' perché un pinguino è un uccello oltre che un rettile. Può volare così come gattonare. Quindi eredità multiple hanno dimostrato che una classe figlia può essere derivata da molte classi base.

Esempio:

Qui eseguiremo un programma per mostrare come utilizzare l'ereditarietà multilivello.

Abbiamo iniziato il nostro programma utilizzando Stream di input-output. Quindi, abbiamo dichiarato una classe genitore 'M' che è impostata come pubblica. Abbiamo chiamato il Schermo() funzione e il comando 'cout' per visualizzare l'istruzione. Successivamente, abbiamo creato una classe figlia 'N' che è derivata dalla classe genitore 'M'. Abbiamo una nuova classe figlia 'O' derivata dalla classe figlia 'N' e il corpo di entrambe le classi derivate è vuoto. Alla fine, invochiamo il principale() funzione in cui dobbiamo inizializzare l'oggetto della classe 'O'. Il Schermo() la funzione dell'oggetto viene utilizzata per dimostrare il risultato.

In questa figura, abbiamo il risultato della classe 'M' che è la classe genitore perché avevamo a Schermo() funzione in esso. Quindi, la classe 'N' è derivata dalla classe madre 'M' e la classe 'O' dalla classe madre 'N' che si riferisce all'ereditarietà multilivello.

Polimorfismo C++:

Il termine 'Polimorfismo' rappresenta una raccolta di due parole 'poli' e ' morfismo' . La parola 'Poly' rappresenta 'molti' e 'morfismo' rappresenta 'forme'. Polimorfismo significa che un oggetto può comportarsi in modo diverso in condizioni diverse. Consente a un programmatore di riutilizzare ed estendere il codice. Lo stesso codice agisce in modo diverso a seconda della condizione. L'emanazione di un oggetto può essere impiegata in fase di esecuzione.

Categorie di polimorfismo:

Il polimorfismo si verifica principalmente in due metodi:

1. Polimorfismo del tempo di compilazione
2. Polimorfismo a tempo di esecuzione

Spieghiamo.

6. Polimorfismo del tempo di compilazione:

Durante questo periodo, il programma immesso viene trasformato in un programma eseguibile. Prima della distribuzione del codice, vengono rilevati gli errori. Ci sono principalmente due categorie di esso.

• Sovraccarico delle funzioni
• Sovraccarico dell'operatore

Diamo un'occhiata a come utilizziamo queste due categorie.

7. Sovraccarico delle funzioni:

Significa che una funzione può eseguire diversi compiti. Le funzioni sono note come sovraccaricate quando sono presenti diverse funzioni con un nome simile ma argomenti distinti.

Per prima cosa, utilizziamo la libreria e lo spazio dei nomi standard. Quindi dichiareremmo la classe definita dall'utente 'Aggiungi'. All'interno della classe, definiamo una funzione ADD() con due parametri come public. Di nuovo, dichiara una nuova funzione all'interno del corpo della classe con lo stesso nome ma questa funzione non ha parametri. Qui inizializziamo tre stringhe. Le prime due stringhe hanno un valore e l'ultima stringa viene utilizzata per concatenare le prime due stringhe. Utilizziamo il comando 'cout' per stampare il risultato. Successivamente, chiamiamo il principale() metodo al di fuori della classe. Costruiamo un oggetto della classe richiesta 'Add'. Ora chiamiamo la prima funzione con due parametri e quindi chiamiamo anche la seconda funzione. Nell'ultimo passaggio, includiamo l'istruzione 'return 0' per terminare il programma.

Sovraccarico dell'operatore:

Il processo di definizione di più funzionalità di un operatore è chiamato sovraccarico dell'operatore.

L'esempio precedente include il file di intestazione . Quindi, abbiamo utilizzato uno spazio dei nomi standard. Definiamo la classe 'Intero'. All'interno di questa classe, specifichiamo un intero come membro privato di una classe. Successivamente, dichiariamo il costruttore Parameterized come membro pubblico e inizializziamo il valore dell'intero in esso contenuto. Definiamo un costruttore con un operatore di prefisso di overload. All'interno di questo costruttore, eseguiamo l'operazione di prefisso. Inoltre, creiamo una funzione che visualizza il valore di incremento utilizzando l'istruzione 'cout'. Intanto invochiamo il principale() funzione. Qui creiamo due oggetti di classe. Il primo oggetto passa un valore intero. Quindi, utilizzare l'istruzione 'cout' per stampare la riga 'Prima dell'incremento il valore è'. Successivamente, chiamiamo Schermo() funzione per il primo oggetto. Il secondo oggetto utilizza l'operatore di pre-incremento. Usiamo il comando 'cout' per mostrare la riga 'Dopo il pre-incremento il valore è'. Quindi, utilizziamo il Schermo() funzione per il secondo oggetto.

8. Polimorfismo in fase di esecuzione:

È l'intervallo di tempo in cui viene eseguito il codice. Dopo l'impiego del codice si possono rilevare degli errori.

Sovrascrittura della funzione:

Succede quando una classe derivata utilizza una definizione di funzione simile a una delle funzioni membro della classe base.

Nella prima riga, incorporiamo la libreria per eseguire operazioni di input e output. Inoltre, aggiungiamo lo spazio dei nomi standard. Nella riga successiva, dichiariamo una classe genitore 'Man'. All'interno della classe, definiamo una funzione con due parametri come public. Quindi, utilizziamo l'istruzione 'cout' per visualizzare il testo 'Walking'. Al di fuori della classe, creiamo una classe figlia 'Animal' che deriva dalla classe genitore. Qui creiamo una funzione con un nome simile a quello precedentemente dichiarato nella classe genitore. Quindi, utilizza la frase 'cout' per mostrare il testo 'Mangiare'. Noi usiamo il principale() funzione. Nel frattempo, creiamo un oggetto di classe 'm'. Quindi, chiamiamo la funzione della classe genitore così come la funzione della classe figlia. Usa il comando 'restituisci 0'.

Stringhe C++:

Ora scopriremo come dichiarare e inizializzare la stringa in C++. La stringa viene utilizzata per memorizzare un gruppo di caratteri nel programma. Memorizza valori alfabetici, cifre e simboli di tipo speciale nel programma. Ha riservato i caratteri come array nel programma C++. Le matrici vengono utilizzate per prenotare una raccolta o una combinazione di caratteri nella programmazione C++. Un simbolo speciale noto come carattere null viene utilizzato per terminare l'array. È rappresentato dalla sequenza di escape (\0) e viene utilizzato per specificare la fine della stringa.

Ottieni la stringa usando il comando 'cin':

Viene utilizzato per inserire una variabile stringa senza spazi vuoti. Nell'istanza data, implementiamo un programma C++ che ottiene il nome dell'utente utilizzando il comando 'cin'.

Nella prima fase, utilizziamo la libreria . Nel frattempo, abbiamo incluso lo spazio dei nomi standard. Successivamente, dichiariamo il principale() funzione. Inizializziamo una stringa di tipo carattere all'interno del corpo di principale() funzione. Quindi, utilizziamo l'istruzione 'cout' per stampare 'Inserisci il tuo nome'. Utilizziamo il comando 'cin' per chiedere la stringa all'utente. Il comando 'cout' viene applicato per stampare il nome che verrebbe scritto dall'utente. L'istruzione return 0 viene aggiunta per terminare il programma.

L'utente inserisce il nome 'Ahmed Chaudry'. Ma otteniamo solo 'Ahmed' come output piuttosto che il completo 'Ahmed Chaudry' perché il comando 'cin' non può memorizzare una stringa con uno spazio vuoto. Memorizza solo il valore prima dello spazio.

Ottieni la stringa usando la funzione cin.get():

Il ottenere() la funzione del comando cin serve per prelevare dalla tastiera la stringa che può contenere spazi vuoti.

L'esempio precedente include la libreria per eseguire operazioni di input e output. Quindi, abbiamo utilizzato uno spazio dei nomi standard. Il principale() viene chiamata la funzione. Successivamente, inizializziamo una stringa denominata 's'. Nella fase successiva, il comando 'cout' viene utilizzato per visualizzare l'istruzione 'Inserisci una stringa'. Il cin.get() viene applicato per ottenere la stringa dall'utente. Utilizzando il cin.get() funzione passiamo un valore stringa e specifichiamo la dimensione della stringa come parametro. Il comando 'cout' viene nuovamente utilizzato per visualizzare l'output del programma. Alla fine, aggiungiamo il ritorno 0.

L'utente inserisce una stringa 'My name is Ali'. Otteniamo la stringa completa 'My name is Ali' come risultato perché la funzione cin.get() accetta le stringhe che contengono gli spazi vuoti.

Utilizzo di array di stringhe 2D (bidimensionali):

In questo caso, prendiamo l'input (nome di tre città) dall'utente utilizzando un array 2D di stringhe.

Innanzitutto, integriamo il file di intestazione e uno spazio dei nomi standard. Invochiamo il principale() funzione. Quindi, inizializziamo una matrice bidimensionale di caratteri con tre righe e quindici colonne. Nel passaggio successivo, il ciclo for viene utilizzato per contare la variabile 'i' per scorrere la stringa richiesta fino a quando non viene identificato il carattere nullo. All'interno del corpo del ciclo 'for', utilizziamo il comando 'cout' per mostrare la riga 'Inserisci il nome della città'. Quindi usa l'istruzione 'cin' per ottenere il nome della città. Utilizziamo ancora un altro ciclo 'for' e 'cout' per visualizzare il nome delle città in una sequenza fino al termine del ciclo. Successivamente, viene utilizzato il comando 'restituisci 0'.

Qui, l'utente inserisce il nome di tre diverse città. Il programma utilizza un indice di riga per ottenere tre valori di stringa. Ogni valore viene mantenuto nella propria riga. La prima stringa viene memorizzata nella prima riga e così via. Ogni valore di stringa viene visualizzato allo stesso modo utilizzando l'indice di riga.

Libreria standard C++:

La libreria C++ è un cluster o un raggruppamento di molte funzioni, classi, costanti e tutti gli elementi correlati racchiusi quasi in un insieme appropriato, definendo e dichiarando sempre i file di intestazione standardizzati. L'implementazione di questi include due nuovi file di intestazione che non sono richiesti dallo standard C++ denominati e . È presente un lungo elenco di file di intestazione obbligatori che dipende dai requisiti del compilatore. I file di intestazione contengono l'elenco di intestazione che ha tutto il contenuto della libreria standard C++, inclusi i file di intestazione specifici per lo Stand Library Template (STL).

La libreria standard elimina il trambusto della riscrittura delle istruzioni durante la programmazione. Questo ha molte librerie al suo interno che hanno memorizzato codice per molte funzioni. Per fare un buon uso di queste librerie è obbligatorio collegarle con l'aiuto di file di intestazione. Quando importiamo la libreria di input o output, ciò significa che stiamo importando tutto il codice che è stato memorizzato all'interno di quella libreria ed è così che possiamo utilizzare anche le funzioni racchiuse in essa nascondendo tutto il codice sottostante che potrebbe non essere necessario vedere.

La libreria standard C++ supporta i due tipi seguenti:

• Un'implementazione ospitata che fornisce tutti i file di intestazione della libreria standard essenziali descritti dallo standard ISO C++.
• Un'implementazione autonoma che richiede solo una parte dei file di intestazione dalla libreria standard. Il sottoinsieme appropriato è:

Alcuni dei file di intestazione sono stati deplorati dall'arrivo degli ultimi 11 C++: , e .

Le differenze tra le implementazioni ospitate e indipendenti sono illustrate di seguito:

• Nell'implementazione ospitata, è necessario utilizzare una funzione globale che è la funzione principale. In un'implementazione indipendente, l'utente può dichiarare e definire autonomamente le funzioni di inizio e fine.
• Un'implementazione di hosting ha un thread obbligatorio in esecuzione al momento della corrispondenza. Considerando che, nell'implementazione indipendente, gli implementatori decideranno essi stessi se hanno bisogno del supporto del thread simultaneo nella loro libreria.

Tipi:

Sia il freestanding che l'hosted sono supportati da C++. I file di intestazione sono divisi nei seguenti due:

• Parti Iostream
• Parti C++ STL (libreria standard)

Ogni volta che scriviamo un programma per l'esecuzione in C++, chiamiamo sempre le funzioni che sono già implementate all'interno dell'STL. Queste funzioni note accettano input e output di visualizzazione utilizzando operatori identificati con efficienza.

Considerando la storia, l'STL è stato inizialmente chiamato Standard Template Library. Quindi, le parti della libreria STL sono state quindi standardizzate nella libreria standard di C++ che viene utilizzata oggigiorno. Questi includono la libreria di runtime ISO C++ e alcuni frammenti della libreria Boost comprensivi di alcune altre importanti funzionalità. Occasionalmente il STL denota i contenitori o più frequentemente gli algoritmi della libreria standard C++. Ora, questo STL o libreria di modelli standard parla interamente della nota libreria standard C++.

Lo spazio dei nomi std e i file di intestazione:

Tutte le dichiarazioni di funzioni o variabili vengono eseguite all'interno della libreria standard con l'aiuto di file di intestazione distribuiti uniformemente tra di loro. La dichiarazione non avverrebbe a meno che tu non includa i file di intestazione.

Supponiamo che qualcuno stia usando liste e stringhe, deve aggiungere i seguenti file di intestazione:

Queste parentesi angolari '<>' significano che è necessario cercare questo particolare file di intestazione nella directory che viene definita e inclusa. Si può anche aggiungere un'estensione '.h' a questa libreria che viene eseguita se necessario o desiderato. Se escludiamo la libreria '.h', abbiamo bisogno di un'aggiunta 'c' subito prima dell'inizio del nome del file, proprio come indicazione che questo file di intestazione appartiene a una libreria C. Ad esempio, puoi scrivere (#include o #include ).

Parlando dello spazio dei nomi, l'intera libreria standard C++ si trova all'interno di questo spazio dei nomi denominato std. Questo è il motivo per cui i nomi standardizzati delle biblioteche devono essere definiti in modo competente dagli utenti. Per esempio:

Vettori C++:

Esistono molti modi per archiviare dati o valori in C++. Ma per ora, stiamo cercando il modo più semplice e flessibile per memorizzare i valori mentre scriviamo i programmi nel linguaggio C++. Quindi, i vettori sono contenitori che sono correttamente sequenziati in uno schema in serie la cui dimensione varia al momento dell'esecuzione a seconda dell'inserimento e della detrazione degli elementi. Ciò significa che il programmatore può modificare la dimensione del vettore secondo il suo desiderio durante l'esecuzione del programma. Assomigliano agli array in modo tale da avere anche posizioni di archiviazione comunicabili per i loro elementi inclusi. Per la verifica del numero di valori o elementi presenti all'interno dei vettori, occorre utilizzare un ' std::count' funzione. I vettori sono inclusi nella libreria di modelli standard di C++, quindi ha un file di intestazione definito che deve essere incluso prima, ovvero:

Dichiarazione:

Di seguito è mostrata la dichiarazione di un vettore.

Qui, il vettore è la parola chiave utilizzata, il DT mostra il tipo di dati del vettore che può essere sostituito con int, float, char o qualsiasi altro tipo di dati correlato. La dichiarazione di cui sopra può essere riscritta come:

La dimensione per il vettore non è specificata perché la dimensione potrebbe aumentare o diminuire durante l'esecuzione.

Inizializzazione dei vettori:

Per l'inizializzazione dei vettori, c'è più di un modo in C++.

Tecnica numero 1:

In questa procedura, assegniamo direttamente i valori per entrambi i vettori. I valori assegnati a entrambi sono esattamente simili.

Tecnica numero 2:

In questo processo di inizializzazione, 3 sta determinando la dimensione del vettore e 15 è il dato o il valore che è stato memorizzato in esso. Viene creato un vettore di tipo di dati 'int' con la dimensione specificata di 3 che memorizza il valore 15, il che significa che il vettore 'v3' sta memorizzando quanto segue:

Operazioni principali:

Le principali operazioni che implementeremo sui vettori all'interno della classe vector sono:

• Aggiungere un valore
• Accesso a un valore
• Alterare un valore
• Eliminazione di un valore

Aggiunta e cancellazione:

L'aggiunta e la cancellazione degli elementi all'interno del vettore vengono eseguite sistematicamente. Nella maggior parte dei casi, gli elementi vengono inseriti alla fine dei contenitori vettoriali ma puoi anche aggiungere valori nella posizione desiderata che alla fine sposteranno gli altri elementi nelle loro nuove posizioni. Mentre, nella cancellazione, quando i valori vengono cancellati dall'ultima posizione, ridurrà automaticamente le dimensioni del contenitore. Ma quando i valori all'interno del contenitore vengono eliminati casualmente da una posizione particolare, le nuove posizioni vengono assegnate automaticamente agli altri valori.

Funzioni utilizzate:

Per alterare o cambiare i valori memorizzati all'interno del vettore, ci sono alcune funzioni predefinite note come modificatori. Sono i seguenti:

• Insert(): viene utilizzato per l'aggiunta di un valore all'interno di un contenitore vettoriale in una posizione particolare.
• Erase(): viene utilizzato per rimuovere o eliminare un valore all'interno di un contenitore vettoriale in una posizione particolare.
• Swap(): viene utilizzato per lo scambio dei valori all'interno di un contenitore vettoriale che appartiene allo stesso tipo di dati.
• Assign(): viene utilizzato per assegnare un nuovo valore al valore precedentemente memorizzato all'interno del contenitore del vettore.
• Begin(): viene utilizzato per restituire un iteratore all'interno di un ciclo che indirizza il primo valore del vettore all'interno del primo elemento.
• Clear(): viene utilizzato per la cancellazione di tutti i valori memorizzati all'interno di un contenitore vettoriale.
• Push_back(): Viene utilizzato per l'aggiunta di un valore alla fine del contenitore del vettore.
• Pop_back(): Viene utilizzato per la cancellazione di un valore alla fine del contenitore del vettore.

Esempio:

In questo esempio, i modificatori vengono utilizzati lungo i vettori.

Innanzitutto, stiamo includendo i file di intestazione e . Successivamente, lo spazio dei nomi std viene integrato per aggiungere le classi tutte in una volta. Per scrivere la logica dell'intero programma, chiamiamo la funzione main() in cui viene inizializzato un vettore chiamato 'digits'. L'assegnazione di questo vettore viene eseguita nel passaggio successivo in cui 'cifre' ha fornito un valore di 6 e 24, il che significa che 6 elementi sono memorizzati all'interno del contenitore del vettore, ciascuno con il valore di 24. Questi valori vengono quindi visualizzati utilizzando il 'cout ' comando. Un ciclo 'for' viene utilizzato per la funzione di modifica push_back() per l'aggiunta degli elementi all'interno del contenitore. Ora, il valore 3 viene aggiunto alle cifre alla fine. Inizializziamo una variabile 'x' per tenere traccia della dimensione del contenitore del vettore. Ora viene visualizzato il valore dell'ultimo elemento e il pop_back() funzione cancellerebbe il numero '3' memorizzato all'interno del contenitore. Per la visualizzazione di tutti gli elementi, utilizziamo di nuovo un ciclo 'for' con il inserire() modificatore che inserirà i valori. Qui, 4 verrà inserito all'inizio del contenitore del vettore e visualizzato sullo schermo. Il chiaro() modificatore cancellerà o cancellerà tutti i valori memorizzati all'interno del contenitore. La dimensione del vettore viene quindi mostrata al termine della cancellazione.

L'output è mostrato di seguito.

File C++ Input Output:

Un file è un insieme di dati correlati. In C++, un file è una sequenza di byte raccolti insieme in ordine cronologico. La maggior parte dei file esiste all'interno del disco. Ma nei file sono inclusi anche dispositivi hardware come nastri magnetici, stampanti e linee di comunicazione.

L'input e l'output nei file sono caratterizzati dalle tre classi principali:

• La classe 'istream' viene utilizzata per ricevere input.
• La classe 'ostream' viene utilizzata per visualizzare l'output.
• Per input e output, usa la classe 'iostream'.

I file vengono gestiti come flussi in C++. Quando prendiamo input e output in un file o da un file, le seguenti sono le classi che vengono utilizzate:

• Offstream: È una classe di flusso che viene utilizzata per scrivere su un file.
• Ifstream: È una classe di flusso che viene utilizzata per leggere il contenuto da un file.
• Flusso: È una classe stream utilizzata sia per leggere che per scrivere in un file o da un file.

Le classi 'istream' e 'ostream' sono gli antenati di tutte le classi sopra menzionate. I flussi di file sono facili da usare come i comandi 'cin' e 'cout', con la sola differenza di associare questi flussi di file ad altri file. Vediamo un esempio per studiare brevemente la classe 'fstream':

Esempio:

In questo caso, stiamo scrivendo i dati in un file.

Stiamo integrando il flusso di input e output nel primo passaggio. Il file di intestazione viene quindi aggiunto perché scriveremo e leggeremo i dati dal file. Successivamente, le classi vengono chiamate con l'aiuto dello spazio dei nomi. Il principale() viene chiamata per il corpo del programma in cui viene utilizzato 'ofstream' che scrive i dati in un file, il file viene creato come New_File. Nel passaggio successivo, apriremo un file di testo chiamato 'esempio' utilizzando il file aprire( ) metodo. Stiamo scrivendo un testo con l'aiuto di parentesi angolari nel file. Ogni file è destinato ad essere chiuso una volta affrontato. Questo è il motivo per cui il file viene chiuso con l'aiuto di chiudere() funzione.

Il file 'esempio' viene aperto dal personal computer e il testo scritto sul file viene stampato su questo file di testo come mostrato sopra.

Apertura di un file:

Quando un file viene aperto, è rappresentato da un flusso. Viene creato un oggetto per il file come New_File è stato creato nell'esempio precedente. Tutte le operazioni di input e output eseguite sullo stream vengono applicate automaticamente al file stesso. Per l'apertura di un file, la funzione open() viene utilizzata come:

Qui la modalità è non obbligatoria.

Chiusura di un file:

Una volta terminate tutte le operazioni di input e output, è necessario chiudere il file aperto per la modifica. Siamo tenuti ad assumere a chiudere() funzione in questa situazione.

Al termine, il file diventa non disponibile. Se in qualsiasi circostanza l'oggetto viene distrutto, pur essendo collegato al file, il distruttore chiamerà spontaneamente la funzione close().

File di testo:

I file di testo vengono utilizzati per memorizzare il testo. Pertanto, se il testo è inserito o visualizzato, dovrà presentare alcune alterazioni di formattazione. L'operazione di scrittura all'interno del file di testo è la stessa che eseguiamo con il comando 'cout'.

Esempio:

In questo scenario, stiamo scrivendo i dati nel file di testo che era già stato creato nell'illustrazione precedente.

Qui, stiamo scrivendo i dati nel file chiamato 'example' usando la funzione New_File(). Apriamo il file 'esempio' utilizzando il aprire() metodo. 'ofstream' viene utilizzato per aggiungere i dati al file. Dopo aver eseguito tutto il lavoro all'interno del file, il file richiesto viene chiuso mediante l'uso di chiudere() funzione. Se il file non si apre, viene visualizzato il messaggio di errore 'File non supportato, errore durante il caricamento del file'.

Il file si apre e il testo viene visualizzato sulla console.

Lettura di un file di testo:

La lettura di un file viene mostrata con l'aiuto dell'esempio successivo.

Esempio:

L''ifstream' viene utilizzato per leggere i dati memorizzati all'interno del file.

L'esempio include i file di intestazione principali all'inizio. Quindi, usa 'ifstream' all'interno di principale() funzione. Con l'aiuto di 'ifstream', leggeremo i dati con il file 'New_File' che mostra il testo memorizzato all'interno del file di testo 'example'. Utilizziamo il aprire() metodo per aprire il file. Successivamente, utilizzeremo il ciclo 'while'. Dopo aver letto i dati dal file di testo 'esempio', il chiudere() viene utilizzata per chiudere il file richiesto. Se il sistema non ha il file particolare, viene visualizzato il messaggio 'Impossibile aprire il file'.

Tutte le informazioni memorizzate all'interno del file di testo vengono visualizzate sullo schermo come mostrato.

Conclusione

Nella guida precedente, abbiamo appreso in dettaglio il linguaggio C++. Insieme agli esempi, ogni argomento viene dimostrato e spiegato e ogni azione viene elaborata.