La programmazione C++ è il linguaggio migliore in quanto ci facilita con un'ampia gamma di funzioni, costruttori, file di intestazione, classi e molto altro, rendendo la codifica più interessante e semplice. Uno dei costruttori nella programmazione C++ è il costruttore 'sposta'. Il costruttore 'spostamento' è un tipo unico di costruttore che consente il trasferimento della proprietà di una memoria allocata dinamicamente o di altre risorse da un oggetto a un altro in modo efficace e attento alle risorse.
Nella programmazione C++ sono stati introdotti i costruttori 'sposta' per ridurre la duplicazione e migliorare l'efficienza. Svolge un ruolo cruciale nel migliorare le prestazioni riducendo al minimo le operazioni di copia. Questa guida esplora in modo approfondito il costruttore 'sposta' nella programmazione C++.
Esempio 1:
Per iniziare qui il codice, includiamo i file header 'iostream' e 'string' che faranno funzionare perfettamente il nostro codice poiché molte funzioni sono dichiarate in questi file header. Quando dobbiamo utilizzare l'istruzione 'cout', viene utilizzato il file di intestazione 'iostream' poiché questa funzione è dichiarata al suo interno. Quando dobbiamo lavorare con dati di tipo stringa, è necessario il file di intestazione “string”.
Successivamente, il 'namespace std' viene aggiunto sotto questi file di intestazione. Quindi, costruiamo una classe qui. Il nome della classe è 'Sposta'. Sotto questa viene aggiunta la parola chiave 'private' in cui dichiariamo una variabile stringa privata con il nome 'my_str'. Ora inseriamo la parola chiave “public” dove aggiungiamo la definizione del costruttore predefinito. Passiamo 'Questa è la stringa predefinita qui' a 'my_str' come parametro e lasciamo vuoto il costruttore predefinito.
Successivamente, copiamo la definizione del costruttore e inizializziamo “my_str” in “my_obj.my_str”. Sotto questa, stampiamo una riga e quindi posizioniamo la definizione del costruttore “mossa”. Qui inizializziamo nuovamente “my_str” con “my_obj.my_str”. Non aggiungiamo alcuna dichiarazione sotto questa; è vuoto. Successivamente, dichiariamo una funzione denominata 'displayMyObject()' di tipo stringa e utilizziamo 'return str' in modo che restituisca la stringa.
Inseriamo la funzione globale “new_temp” nel tipo “move”. Sotto di esso, abbiamo il 'return temp' che restituisce l'oggetto di tipo spostamento. Ora inseriamo il codice del driver “main()” e il “new_obj1” del tipo “move” e otteniamo il costruttore “move” da “rvalue”. Nella riga successiva, inseriamo 'new_obj1.displayMyObject()' per ottenere il costruttore 'move' da 'lvalue'. Successivamente, chiamiamo il costruttore 'move' con l'oggetto 'my_obj1'. Quindi, trasferiamo la proprietà di “my_obj1” all'altro oggetto che è “my_obj2”.
Codice 1:
#include#include
utilizzando spazio dei nomi standard ;
classe Mossa
{
privato :
stringa mia_str ;
pubblico :
Mossa ( ) : mia_str ( 'Questa è la stringa predefinita qui' )
{
}
Mossa ( cost Mossa & mio_oggetto ) : mia_str ( mio_oggetto mia_str )
{
cout << 'Copia costruttore richiamato, spostamento fallito! \N ' ;
}
Mossa ( Mossa && mio_oggetto ) : mia_str ( mossa ( mio_oggetto mia_str ) )
{
}
stringa displayMyObject ( )
{
ritorno mia_str ;
}
} ;
Sposta new_temp ( Sposta tmp )
{
ritorno tmp ;
}
int principale ( )
{
Sposta nuovo_oggetto1 = nuova_temp ( Mossa ( ) ) ;
cout << 'prima della chiamata move(): new_obj1 = ' << nuovo_oggetto1. displayMyObject ( ) << fine ;
Sposta new_obj2 = mossa ( nuovo_oggetto1 ) ;
cout << 'dopo la chiamata del costruttore move(): new_obj1 = ' << nuovo_oggetto1. displayMyObject ( ) << fine ;
cout << 'dopo la chiamata del costruttore move(): new_obj2 = ' << nuovo_oggetto2. displayMyObject ( ) << fine ;
ritorno 0 ;
}
Produzione:
L'output mostra che prima di chiamare il metodo 'move()', 'new_obj1' contiene la stringa predefinita. Ma dopo aver chiamato il metodo move() della classe “Move”, “my_obj1” contiene una stringa vuota e “my_obj2” ha la stringa predefinita.
Esempio 2:
Qui includiamo un altro file di intestazione che è il file di intestazione 'vettore'. Lo includiamo ogni volta che dobbiamo manipolare le operazioni sui vettori. La classe che creiamo qui è la classe 'Move'. Creiamo anche un costruttore 'pubblico' in cui dichiariamo che il puntatore grezzo 'int* value' è i dati di un membro della classe. Sotto di esso, abbiamo il 'public' in cui posizioniamo il costruttore 'Move' e passiamo 'int v1' come parametro.
Successivamente, dichiariamo gli oggetti in un heap. Inizializziamo il “valore” con “new int” e il “*valore” con “v1”. Quindi, posiziona il 'cout' dove aggiungiamo una riga che viene stampata quando eseguiamo il codice. Al di sotto di questo, utilizziamo il costruttore “copia”. Questo costruttore di 'copia' copia i dati eseguendo una copia profonda. Inseriamo il costruttore 'Move' e passiamo 'Move&& new_source' come parametro. Sotto di esso, posizioniamo il 'cout' che aiuta a visualizzare l'affermazione richiesta.
Inseriamo la parola chiave 'nullptr' per determinare se un puntatore è vuoto prima che venga utilizzato il riferimento. Ora posizioniamo anche il distruttore “~Move()” in cui posizioniamo la condizione “if” che verifica se il “valore” non è uguale a “nullptr”. Quando questa condizione è verificata, viene eseguita l'istruzione seguente. Se questa condizione non è verificata, salta l'istruzione “cout” che è presente dopo la condizione “if” e si sposta verso la parte “else”.
Successivamente, utilizziamo la parola chiave 'delete' che aiuta a deallocare un oggetto o possiamo dire che rilascia la memoria allocata al componente dati dell'oggetto. Ora invochiamo qui il metodo 'main()' e creiamo il vettore della nostra classe 'Move' con il nome 'my_vec'. Successivamente, utilizziamo la funzione “push_back()” che aiuta a inserire un valore nel punto finale di un vettore. Il file di intestazione 'vettore' contiene questa funzione. Per prima cosa inseriamo “39” nel vettore. Quindi, viene inserito '57' e viene inserito anche '91' utilizzando il metodo 'push_back()'.
Codice 2:
#include#include
utilizzando spazio dei nomi standard ;
classe Mossa {
privato :
int * valore ;
pubblico :
Mossa ( int v1 )
{
valore = nuovo int ;
* valore = v1 ;
cout << 'Il Costruttore è chiamato'
<< v1 << fine ;
} ;
Mossa ( cost Mossa & nuova_fonte )
: Mossa { * nuova_fonte. valore }
{
cout << 'Il costruttore della copia si chiama -'
<< 'Copia approfondita per'
<< * nuova_fonte. valore
<< fine ;
}
Mossa ( Mossa && nuova_fonte )
: valore { nuova_fonte. valore }
{
cout << 'Sposta costruttore per'
<< * nuova_fonte. valore << fine ;
nuova_fonte. valore = nullptr ;
}
~Muoviti ( )
{
Se ( valore ! = nullptr )
cout << 'È richiesto il distruttore'
<< * valore << fine ;
altro
cout << 'Si chiama il distruttore'
<< ' per nullptr '
<< fine ;
eliminare valore ;
}
} ;
int principale ( )
{
vettore < Mossa > mia_cosa ;
mia_cosa. respingere ( Mossa { 39 } ) ;
mia_cosa. respingere ( Mossa { 57 } ) ;
mia_cosa. respingere ( Mossa { 91 } ) ;
ritorno 0 ;
}
Produzione:
Ciò dimostra che invece di utilizzare la funzione “copia”, dobbiamo utilizzare la funzione “sposta” per evitare la chiamata inutile alla funzione “copia”. Il costruttore “move” viene invocato qui quando inizializziamo l'oggetto con un oggetto temporaneo o con un oggetto che verrà distrutto. Invece di manipolare una copia profonda dei dati forniti, il costruttore “move” sposta la proprietà delle risorse da un oggetto a un altro.
Conclusione
In questa guida, abbiamo esplorato il costruttore 'sposta'. Abbiamo spiegato che il costruttore 'sposta' nella programmazione C++ è un metodo unico per trasferire in modo efficace le risorse di un oggetto su un altro oggetto. Abbiamo discusso del fatto che chiamare il costruttore “move” comporta un minor sovraccarico, rendendo il codice più efficiente in termini di memoria. Abbiamo esplorato il fatto che il costruttore 'sposta' è una funzionalità potente nella programmazione C++. Abbiamo inoltre utilizzato gli esempi pratici per illustrare il concetto del costruttore “move” e dimostrato i vantaggi in termini di prestazioni derivanti dall'utilizzo del costruttore “move” nella programmazione C++.