Programarea C++ este cel mai bun limbaj, deoarece ne oferă o gamă largă de funcții, constructori, fișiere antet, clase și multe altele, făcând codarea mai interesantă și mai ușoară. Unul dintre constructorii din programarea C++ este constructorul „mutare”. Constructorul „mutare” este un tip unic de constructor care permite ca proprietatea asupra unei memorie alocate dinamic sau a altor resurse să fie transferate de la un obiect la altul într-o manieră eficientă și conștientă de resurse.
În programarea C++, au fost introduși constructori de „mutare” pentru a reduce dublarea și pentru a spori eficiența. Joacă un rol crucial în îmbunătățirea performanței prin reducerea la minimum a operațiunilor de copiere. Acest ghid explorează în profunzime constructorul „mutare” în programarea C++.
Exemplul 1:
Pentru a începe codul aici, includem fișierele antet „iostream” și „string” care vor face codul nostru să ruleze perfect, deoarece multe funcții sunt declarate în aceste fișiere antet. Când trebuie să folosim declarația „cout”, fișierul antet „iostream” este utilizat deoarece această funcție este declarată în interiorul acesteia. Când trebuie să lucrăm cu datele de tip șir, este necesar fișierul antet „șir”.
După aceasta, „namespace std” este adăugat sub aceste fișiere de antet. Apoi, construim o clasă aici. Numele clasei este „Mutare”. Sub acesta, se adaugă cuvântul cheie „privat” în care declarăm o variabilă șir privată cu numele „my_str”. Acum, plasăm cuvântul cheie „public” unde adăugăm definiția constructorului implicit. Trecem „Acesta este șirul implicit aici” la „my_str” ca parametru și lăsăm constructorul implicit gol.
După aceasta, copiem definiția constructorului și inițializam „my_str” la „my_obj.my_str”. Sub aceasta, tipărim o linie și apoi plasăm definiția constructorului „mutare”. Aici, inițializam „my_str” din nou cu „my_obj.my_str”. Nu adăugăm nicio declarație sub aceasta; este gol. După aceasta, declarăm o funcție numită „displayMyObject()” de tip șir și utilizăm „return str” astfel încât să returneze șirul.
Am plasat funcția globală „new_temp” în tipul „mutare”. Sub ea, avem „temp de retur” care returnează obiectul de tip mutare. Acum, plasăm codul driverului „main()” și „new_obj1” de tipul „move” și obținem constructorul „move” din „rvalue”. În linia din față, plasăm „new_obj1.displayMyObject()” pentru a obține constructorul „move” din „lvalue”. După aceasta, numim constructorul „mutare” cu obiectul „my_obj1”. Apoi, transferăm dreptul de proprietate asupra „my_obj1” celuilalt obiect care este „my_obj2”.
Cod 1:
#include#include <șir>
folosind spatiu de nume std ;
clasă Mișcare
{
privat :
șir my_str ;
public :
Mișcare ( ) : my_str ( „Acesta este șirul implicit aici” )
{
}
Mișcare ( const Mișcare & my_obj ) : my_str ( my_obj. my_str )
{
cout << „A fost invocat constructorul de copiere, mutarea a eșuat! \n ' ;
}
Mișcare ( Mișcare && my_obj ) : my_str ( mișcare ( my_obj. my_str ) )
{
}
șir afișaMyObject ( )
{
întoarcere my_str ;
}
} ;
Mută new_temp ( Mutați tmp )
{
întoarcere tmp ;
}
int principal ( )
{
Mută new_obj1 = nou_temp ( Mișcare ( ) ) ;
cout << 'înainte de apelul mutarii (): new_obj1 = ' << nou_obj1. displayMyObject ( ) << endl ;
Mută new_obj2 = mișcare ( nou_obj1 ) ;
cout << 'după apelul constructorului move(): new_obj1 = ' << nou_obj1. displayMyObject ( ) << endl ;
cout << 'după apelul constructorului move(): new_obj2 = ' << nou_obj2. displayMyObject ( ) << endl ;
întoarcere 0 ;
}
Ieșire:
Ieșirea arată că înainte de a apela metoda „move()”, „new_obj1” conține șirul implicit. Dar, după apelarea metodei clasei „Move” move(), „my_obj1” conține un șir gol, iar „my_obj2” are șirul implicit.
Exemplul 2:
Aici, includem încă un fișier antet, care este fișierul antet „vector”. Includem acest lucru ori de câte ori trebuie să manipulăm operațiile pe vectori. Clasa pe care o creăm aici este clasa „Mutare”. De asemenea, creăm aici un constructor „public” în care declarăm indicatorul brut „int* value” ca fiind datele unui membru al clasei. Sub acesta, avem „publicul” în care plasăm constructorul „Mutare” și trecem „int v1” ca parametru.
După aceasta, declarăm obiectele într-o grămadă. Inițializam „valoarea” cu „new int” și „*value” cu „v1”. Apoi, plasați „cout” unde adăugăm o linie care se tipărește atunci când executăm codul. Sub aceasta, folosim constructorul „copiere”. Acest constructor „copiere” copiază datele făcând o copie profundă. Plasăm constructorul „Mutare” și trecem „Move&& new_source” ca parametru. Sub acesta, plasăm „cout” care ajută la afișarea declarației necesare.
Inserăm cuvântul cheie „nullptr” pentru a determina dacă un indicator este gol înainte ca referința să fie utilizată. Acum, plasăm și destructorul „~Move()” în care plasăm condiția „dacă” care verifică dacă „valoarea” nu este egală cu „nullptr”. Când această condiție este verificată, instrucțiunea de mai jos este executată. Dacă această condiție nu este verificată, omite declarația „cout” care este prezentă după condiția „dacă” și se deplasează către partea „altfel”.
După aceasta, folosim cuvântul cheie „șterge” care ajută la dealocarea unui obiect sau putem spune că eliberează memoria care este alocată componentei de date a obiectului. Acum, invocăm aici metoda „main()” și creăm vectorul clasei noastre „Mutare” cu numele „my_vec”. După aceasta, folosim funcția „push_back()” care ajută la inserarea unei valori la punctul final al unui vector. Fișierul antet „vector” conține această funcție. Mai întâi, inserăm „39” în vector. Apoi, „57” este inserat și „91” este de asemenea inserat utilizând metoda „push_back()”.
Cod 2:
#include#include
folosind spatiu de nume std ;
clasă Mișcare {
privat :
int * valoare ;
public :
Mișcare ( int v1 )
{
valoare = nou int ;
* valoare = v1 ;
cout << „Constructorul este chemat pentru”
<< v1 << endl ;
} ;
Mișcare ( const Mișcare & sursă_nouă )
: Mișcare { * sursă_nouă. valoare }
{
cout << „Copy Constructor se numește -”
<< „Copie profundă pentru”
<< * sursă_nouă. valoare
<< endl ;
}
Mișcare ( Mișcare && sursă_nouă )
: valoare { sursă_nouă. valoare }
{
cout << „Mutați constructorul pentru”
<< * sursă_nouă. valoare << endl ;
sursă_nouă. valoare = nullptr ;
}
~ Mișcă-te ( )
{
dacă ( valoare ! = nullptr )
cout << 'Destructorul este chemat pentru'
<< * valoare << endl ;
altfel
cout << „Destructorul se numește”
<< 'pentru nullptr'
<< endl ;
șterge valoare ;
}
} ;
int principal ( )
{
vector < Mișcare > obiectul meu ;
obiectul meu. împinge înapoi ( Mișcare { 39 } ) ;
obiectul meu. împinge înapoi ( Mișcare { 57 } ) ;
obiectul meu. împinge înapoi ( Mișcare { 91 } ) ;
întoarcere 0 ;
}
Ieșire:
Acest lucru arată că în loc să folosim funcția „copiere”, trebuie să utilizăm funcția „mutare” pentru a preveni apelul inutil la funcția „copiere”. Constructorul „mutare” este invocat aici atunci când inițializam obiectul cu un obiect temporar sau cu un obiect care va fi distrus. În loc să manipuleze o copie profundă a datelor date, constructorul „mutare” schimbă dreptul de proprietate asupra resurselor de la un obiect la altul.
Concluzie
În acest ghid, am explorat despre constructorul „mutare”. Am explicat că constructorul „mutare” în programarea C++ este o metodă unică de a reloca resursele unui obiect într-un alt obiect în mod eficient. Am discutat că apelarea constructorului „mutare” are o suprasarcină mai mică, făcând codul mai eficient din punct de vedere al memoriei. Am explorat faptul că constructorul „mutare” este o caracteristică puternică în programarea C++. De asemenea, am folosit exemplele practice pentru a ilustra conceptul de constructor „mutare” și am demonstrat beneficiile de performanță ale utilizării constructorului „mutare” în programarea C++.