Costruttori e distruttori C ++
Destructor è anche una funzione di una classe in C++. Come il costruttore distruttore ha anche alcune caratteristiche speciali. Ora discutiamo sia del costruttore che del distruttore nel nostro argomento.
Caratteristiche di base del costruttore:
- Il costruttore ha una caratteristica univoca: sia il nome della classe che il nome del costruttore devono essere lo stesso.
- Il costruttore non ha alcun tipo di ritorno come funzione normale. Quindi non possiamo usare alcuna parola chiave di ritorno all'interno del costruttore.
- Il costruttore si comporta come una funzione, ma differisce da una funzione normale.
Ora scriviamo un programma, come creare un costruttore in una classe.
Esempio di programmazione 1:
#includere
Utilizzo dello spazio dei nomi std;
complesso di classe
Privato:
int x, y;
pubblico:
Complesso () // crea un costruttore all'interno della classe.
cout<< “ Example of a Constructor \n ” ;
;
int main ()
Com complesso;
restituzione 0;
Produzione:
Spiegazione:
Qui creiamo una classe chiamata complesso. Dichiariamo due variabili, xey, sotto il modificatore di accesso privato. Quindi creiamo un costruttore in un modificatore pubblico simile al nome della classe. Qui non scriviamo alcuna parola chiave di ritorno per il costruttore.
Il costruttore è chiamato implicitamente. Quando un oggetto sta ottenendo un costruttore di memoria verrà eseguito per impostazione predefinita.
Classificazione del costruttore:
Esistono tre tipi di costruttori disponibili in C++. Sono
- Predefinito.
- Parametrizzato.
- copia.
UN. Costruttore predefinito:
Ogni volta che non creiamo alcun costruttore per una classe e creiamo un oggetto per quella classe, il costruttore viene implicitamente chiamato dal compilatore. Quel tipo di costruttore è chiamato costruttore predefinito. Ha una caratteristica speciale. Non esiste un codice all'interno del suo corpo e non richiede parametri.
Esempio di programmazione 2:
#includere
Utilizzo dello spazio dei nomi std;
complesso di classe
Privato:
int a, b;
pubblico:
;
void main ()
Com complesso;
Produzione:
Poiché questo programma non ha alcuna istruzione di output, non ha alcun output.
Spiegazione:
Qui creiamo un complesso di classe. All'interno della classe complessa, non creiamo alcun costruttore. Ma all'interno del principale (), quando creiamo un oggetto chiamato com, il compilatore crea un costruttore predefinito nel file dell'oggetto. Si chiama costruttore predefinito. Questo tipo di costruttore non ha alcuna codifica all'interno del suo corpo.
B. Costruttore parametrizzato:
Se vogliamo passare alcuni argomenti all'interno del costruttore, si chiama costruttore parametrizzato.
Esempio di programmazione 3:
#includere
Utilizzo dello spazio dei nomi std;
complesso di classe
Privato:
int a, b;
pubblico:
Complesso (int x, int y) // crea un costruttore parametrizzato.
a = x;
b = y;
cout<< “ The values of a and b are”
<;
int main ()
Complesso com (3, 4);
restituzione 0;
Produzione:
Spiegazione:
Il codice sopra è un esempio di costruttore parametrizzato. Qui passiamo due numeri interi come argomenti xey all'interno del costruttore complesso. Se passiamo alcuni valori come 3 e 4 all'interno dell'oggetto COM come com (3, 4) dalla funzione principale, quel valore va al costruttore.
C. Copia costruttore:
Quando un oggetto di classe viene copiato su un altro oggetto della stessa classe, viene chiamato un costruttore di copie. Significa che entrambi gli oggetti hanno lo stesso valore della stessa classe.
Esempio di programmazione 4:
#includere
Esempio di classe
int x, y;
pubblico:
Esempio (int a, int b) // crea un costruttore all'interno della classe.
x = a;
y = b;
vuoto display ()
cout << “ The values are : ”
<< x << “ and” << y ;
;
void main ()
Esempio Ex1 (50, 60);
Esempio ex2 = com1;
ex2.Schermo() ;
Produzione:
Spiegazione:
Qui creiamo un complesso di nomi di costruttori parametrizzati. ex1 è un oggetto dell'esempio di classe. Attraverso l'oggetto EX1, passiamo due valori, 50 e 60. In Display (), l'uscita verrà mostrata a 50 e 60.
Ora copriamo il valore di Ex1 su un altro oggetto, ex2. Il risultato sarà lo stesso se chiamiamo la funzione Display () tramite l'oggetto EX2.
Distruttore:
Un distruttore è un'altra caratteristica potente come il costruttore di una classe. Il suo nome sarà lo stesso del nome della classe come abbiamo visto nel costruttore in precedenza. Ma un simbolo chiamato tilde (~) è separato un distruttore da un costruttore nella codifica.
Inoltre non ha un tipo di ritorno come costruttore e non può mai essere statico.
La differenza principale tra costruttore e distruttore è che il distruttore non prende argomenti come il costruttore. Significa che il sovraccarico non è possibile nel caso di un distruttore.
Esempio di programmazione 5:
#includere
Utilizzo dello spazio dei nomi std;
complesso di classe
Privato:
int a, b;
pubblico:
~ Complesso () // crea un distruttore all'interno della classe.
cout<< “ Example of a Destructor\n ” ;
;
vuoto divertente ()
DES complesso; // creando l'oggetto della classe
int main ()
divertimento() ;
restituzione 0;
Produzione:
Spiegazione:
Qui creiamo un complesso di nomi di distruttori sotto la classe complessa. Ora dobbiamo sapere qual è il motivo per cui usiamo il distruttore. Destructor è invocato implicitamente dal compilatore quando un oggetto distruggerà. È un malinteso che i distruttori distruggono la memoria dell'oggetto. Il fatto è che il distruttore è l'ultimo metodo che funziona. Dopo che quell'oggetto sarà sicuramente distrutto, il che significa in main () quando viene eseguito il divertimento (), l'oggetto deve essere distrutto.
Conclusione:
Dopo aver discusso il concetto di costruttore e distruttore, concluderemo che il costruttore e il distruttore sono importanti funzioni membri della classe in C++. Sia il costruttore che il distruttore migliorano le caratteristiche della classe in modo molto efficiente.