C++-programmering är det bästa språket eftersom det underlättar oss med ett brett utbud av funktioner, konstruktörer, header-filer, klasser och mycket mer, vilket gör kodningen mer intressant och enklare. En av konstruktörerna i C++-programmering är 'move'-konstruktorn. 'Move'-konstruktören är en unik typ av konstruktör som gör att äganderätten till ett dynamiskt allokerat minne eller andra resurser kan överföras från ett objekt till ett annat på ett effektivt och resursmedvetet sätt.
I C++-programmering introducerades 'move'-konstruktörer för att minska dubbelarbetet och förbättra effektiviteten. Det spelar en avgörande roll för att förbättra prestandan genom att minimera kopieringsoperationerna. Den här guiden utforskar djupt om 'flytta'-konstruktorn i C++-programmering.
Exempel 1:
För att börja koden här inkluderar vi 'iostream' och 'sträng'-huvudfilerna som kommer att få vår kod att fungera perfekt eftersom många funktioner deklareras i dessa rubrikfiler. När vi måste använda 'cout'-satsen, används 'iostream'-huvudfilen eftersom denna funktion deklareras inuti denna. När vi måste arbeta med strängtypsdata är rubrikfilen 'sträng' nödvändig.
Efter detta läggs 'namespace std' till under dessa rubrikfiler. Sedan bygger vi en klass här. Klassens namn är 'Move'. Under detta läggs nyckelordet 'private' till där vi deklarerar en privat strängvariabel med namnet 'my_str'. Nu placerar vi nyckelordet 'public' där vi lägger till definitionen av standardkonstruktorn. Vi skickar 'Detta är standardsträngen här' till 'my_str' som parameter och lämnar standardkonstruktorn tom.
Efter detta kopierar vi konstruktordefinitionen och initialiserar 'my_str' till 'my_obj.my_str'. Under detta skriver vi ut en rad och placerar sedan definitionen av 'flytta'-konstruktorn. Här initialiserar vi 'my_str' igen med 'my_obj.my_str'. Vi lägger inte till något uttalande under detta; det är tomt. Efter detta deklarerar vi en funktion som heter 'displayMyObject()' av strängtyp och använder 'return str' så att den returnerar strängen.
Vi placerar den globala 'new_temp'-funktionen i typen 'move'. Under den har vi 'returtemp' som returnerar objektet rörelsetyp. Nu placerar vi drivrutinskoden 'main()' och 'new_obj1' av typen 'move' och hämtar 'move'-konstruktorn från 'rvalue'. I raden framför placerar vi 'new_obj1.displayMyObject()' för att hämta 'move'-konstruktorn från 'lvalue'. Efter detta anropar vi 'move'-konstruktorn med 'my_obj1'-objektet. Sedan överför vi ägandet av 'my_obj1' till det andra objektet som är 'my_obj2'.
Kod 1:
#include#inkludera
använder sig av namnutrymme std ;
klass Flytta
{
privat :
sträng my_str ;
offentlig :
Flytta ( ) : my_str ( 'Detta är standardsträngen här' )
{
}
Flytta ( konst Flytta & min_obj ) : my_str ( min_obj. my_str )
{
cout << 'Kopieringskonstruktören anropades, flyttningen misslyckades! \n ' ;
}
Flytta ( Flytta && min_obj ) : my_str ( flytta ( min_obj. my_str ) )
{
}
sträng displayMyObject ( )
{
lämna tillbaka my_str ;
}
} ;
Flytta new_temp ( Flytta tmp )
{
lämna tillbaka tmp ;
}
int huvud ( )
{
Flytta new_obj1 = ny_temp ( Flytta ( ) ) ;
cout << 'before move() call : new_obj1 = ' << new_obj1. displayMyObject ( ) << endl ;
Flytta new_obj2 = flytta ( new_obj1 ) ;
cout << 'efter move() konstruktoranrop: new_obj1 = ' << new_obj1. displayMyObject ( ) << endl ;
cout << 'efter move() konstruktoranrop: new_obj2 = ' << new_obj2. displayMyObject ( ) << endl ;
lämna tillbaka 0 ;
}
Produktion:
Utdata renderar att innan metoden 'move()' anropas, innehåller 'new_obj1' standardsträngen. Men efter att ha anropat 'Move'-klassen move()-metoden, innehåller 'my_obj1' en tom sträng och 'my_obj2' har standardsträngen.
Exempel 2:
Här inkluderar vi ytterligare en rubrikfil som är 'vektor'-huvudfilen. Vi inkluderar detta när vi måste manipulera operationerna på vektorerna. Klassen som vi skapar här är klassen 'Move'. Vi skapar också en 'offentlig' konstruktor här där vi deklarerar att 'int* value'-råpekaren är en klassmedlems data. Under den har vi 'public' där vi placerar 'Move'-konstruktorn och skickar 'int v1' som parameter.
Efter detta deklarerar vi objekten i en hög. Vi initialiserar 'värdet' med 'ny int' och '*värdet' med 'v1'. Placera sedan 'cout' där vi lägger till en rad som skrivs ut när vi kör koden. Under detta använder vi konstruktorn 'kopiera'. Denna 'kopiera'-konstruktor kopierar data genom att göra en djupkopia. Vi placerar 'Move'-konstruktorn och skickar 'Move&& new_source' som parameter. Under den placerar vi 'cout' som hjälper till att visa det nödvändiga uttalandet.
Vi infogar nyckelordet 'nullptr' för att avgöra om en pekare är tom innan referensen används. Nu placerar vi också '~Move()'-destruktorn där vi placerar 'if'-villkoret som verifierar om 'värdet' inte är lika med 'nullptr'. När detta villkor har verifierats exekveras uttalandet nedan. Om detta tillstånd inte verifieras, hoppar det över 'cout'-satsen som finns efter 'if'-villkoret och går mot 'annat'-delen.
Efter detta använder vi nyckelordet 'delete' som hjälper till att avallokera ett objekt eller så kan vi säga att det frigör minnet som är allokerat till objektets datakomponent. Nu anropar vi metoden 'main()' här och skapar vektorn för vår 'Move'-klass med namnet 'my_vec'. Efter detta använder vi funktionen 'push_back()' som hjälper till att infoga ett värde vid en vektors slutpunkt. 'Vektor'-huvudfilen innehåller denna funktion. Först infogar vi '39' i vektorn. Sedan infogas '57' och '91' infogas också genom att använda metoden 'push_back()'.
Kod 2:
#include#inkludera
använder sig av namnutrymme std ;
klass Flytta {
privat :
int * värde ;
offentlig :
Flytta ( int v1 )
{
värde = ny int ;
* värde = v1 ;
cout << 'Konstruktören kallas för'
<< v1 << endl ;
} ;
Flytta ( konst Flytta & ny_källa )
: Flytta { * ny_källa. värde }
{
cout << 'Copy Constructor heter -'
<< 'Djupkopia för'
<< * ny_källa. värde
<< endl ;
}
Flytta ( Flytta && ny_källa )
: värde { ny_källa. värde }
{
cout << 'Flytt konstruktör för'
<< * ny_källa. värde << endl ;
ny_källa. värde = nullptr ;
}
~ Flytta ( )
{
om ( värde ! = nullptr )
cout << 'Destructor kallas för'
<< * värde << endl ;
annan
cout << 'Destructor heter'
<< 'för nullptr'
<< endl ;
radera värde ;
}
} ;
int huvud ( )
{
vektor < Flytta > min sak ;
min sak. trycka tillbaka ( Flytta { 39 } ) ;
min sak. trycka tillbaka ( Flytta { 57 } ) ;
min sak. trycka tillbaka ( Flytta { 91 } ) ;
lämna tillbaka 0 ;
}
Produktion:
Detta visar att istället för att använda 'kopiera'-funktionen, måste vi använda 'flytta'-funktionen för att förhindra onödiga anrop till 'kopiera'-funktionen. 'Move'-konstruktorn anropas här när vi initierar objektet med ett temporärt objekt eller något objekt som kommer att förstöras. Istället för att manipulera en djup kopia av den givna datan, flyttar 'move'-konstruktorn ägandet av resurserna från ett objekt till ett annat.
Slutsats
I den här guiden utforskade vi om 'flytta'-konstruktören. Vi förklarade att 'move'-konstruktorn i C++-programmering är en unik metod för att effektivt flytta ett objekts resurser till ett annat objekt. Vi diskuterade att anrop av 'move'-konstruktorn har mindre overhead, vilket gör koden mer minneseffektiv. Vi undersökte det faktum att 'move'-konstruktorn är en kraftfull funktion i C++-programmering. Vi använde också de praktiska exemplen för att illustrera konceptet med 'move'-konstruktorn och visade prestandafördelarna med att använda 'move'-konstruktorn i C++-programmering.