La programació C++ és el millor llenguatge, ja que ens facilita una àmplia gamma de funcions, constructors, fitxers de capçalera, classes i molt més, fent que la codificació sigui més interessant i fàcil. Un dels constructors de la programació C++ és el constructor 'move'. El constructor 'moveu' és un tipus únic de constructor que permet transferir la propietat d'una memòria assignada dinàmicament o d'altres recursos d'un objecte a un altre d'una manera eficaç i conscient dels recursos.
A la programació C++, es van introduir constructors de 'movement' per reduir la duplicació i millorar l'eficiència. Té un paper crucial en la millora del rendiment minimitzant les operacions de còpia. Aquesta guia explora en profunditat el constructor 'move' a la programació C++.
Exemple 1:
Per començar el codi aquí, incloem els fitxers de capçalera 'iostream' i 'string' que faran que el nostre codi funcioni perfectament, ja que es declaren moltes funcions en aquests fitxers de capçalera. Quan hem d'utilitzar la declaració 'cout', s'utilitza el fitxer de capçalera 'iostream' ja que aquesta funció es declara dins d'aquesta. Quan hem de treballar amb les dades del tipus de cadena, és necessari el fitxer de capçalera 'cadena'.
Després d'això, s'afegeix 'namespace std' a sota d'aquests fitxers de capçalera. Aleshores, construïm una classe aquí. El nom de la classe és 'Mou'. A sota d'això, s'afegeix la paraula clau 'private' en la qual declarem una variable de cadena privada amb el nom 'my_str'. Ara, col·loquem la paraula clau 'pública' on afegim la definició del constructor predeterminat. Passem 'Aquesta és la cadena per defecte aquí' a 'my_str' com a paràmetre i deixem el constructor predeterminat buit.
Després d'això, copiem la definició del constructor i inicialitzem 'my_str' a 'my_obj.my_str'. A sota d'això, imprimim una línia i després col·loquem la definició del constructor 'move'. Aquí, tornem a inicialitzar 'my_str' amb 'my_obj.my_str'. No afegim cap afirmació per sota d'això; està buit. Després d'això, declarem una funció anomenada 'displayMyObject()' de tipus cadena i utilitzem el 'return str' perquè retorni la cadena.
Col·loquem la funció global 'new_temp' en el tipus 'move'. A sota, tenim la 'temp. de retorn' que retorna l'objecte de tipus de moviment. Ara, col·loquem el codi del controlador 'main()' i el 'new_obj1' del tipus 'move' i obtenim el constructor 'move' del 'rvalue'. A la línia següent, col·loquem el 'new_obj1.displayMyObject()' per obtenir el constructor 'move' del 'lvalue'. Després d'això, anomenem el constructor 'move' amb l'objecte 'my_obj1'. Aleshores, transferim la propietat de 'my_obj1' a l'altre objecte que és 'my_obj2'.
Codi 1:
#inclou#inclou
utilitzant espai de noms std ;
classe Mou-te
{
privat :
cadena my_str ;
públic :
Mou-te ( ) : la meva_str ( 'Aquesta és la cadena per defecte aquí' )
{
}
Mou-te ( const Mou-te & el meu_obj ) : la meva_str ( el meu_obj. la meva_str )
{
cout << 'S'ha invocat el constructor de còpia, el moviment ha fallat! \n ' ;
}
Mou-te ( Mou-te && el meu_obj ) : la meva_str ( moure's ( el meu_obj. la meva_str ) )
{
}
string displayMyObject ( )
{
tornar la meva_str ;
}
} ;
Moveu new_temp ( Mou tmp )
{
tornar tmp ;
}
int principal ( )
{
Mou el nou_obj1 = nova_temp ( Mou-te ( ) ) ;
cout << 'abans de move() crida: new_obj1 = ' << nou_obj1. mostrarMyObject ( ) << endl ;
Mou nou_obj2 = moure's ( nou_obj1 ) ;
cout << 'després de la crida del constructor move(): new_obj1 = ' << nou_obj1. mostrarMyObject ( ) << endl ;
cout << 'després de la crida del constructor move(): new_obj2 = ' << nou_obj2. mostrarMyObject ( ) << endl ;
tornar 0 ;
}
Sortida:
La sortida mostra que abans de cridar al mètode 'move()', el 'new_obj1' conté la cadena per defecte. Però després de cridar el mètode move() de la classe 'Mou', 'my_obj1' conté una cadena buida i 'my_obj2' té la cadena predeterminada.
Exemple 2:
Aquí, incloem un fitxer de capçalera més que és el fitxer de capçalera 'vector'. Això ho incloem sempre que hem de manipular les operacions sobre els vectors. La classe que creem aquí és la classe 'Mou'. També creem aquí un constructor 'públic' en el qual declarem que el punter en brut 'int* value' és les dades d'un membre de la classe. A sota, tenim el 'public' on col·loquem el constructor 'Move' i passem 'int v1' com a paràmetre.
Després d'això, declarem els objectes en un munt. Iniciem el 'valor' amb 'nou int' i el '*valor' amb 'v1'. A continuació, col·loqueu el 'cout' on afegim una línia que s'imprimeix quan executem el codi. A sota d'això, utilitzem el constructor 'copiar'. Aquest constructor de 'còpia' copia les dades fent una còpia profunda. Col·loquem el constructor “Move” i passem “Move&& new_source” com a paràmetre. A sota, col·loquem el 'cout' que ajuda a mostrar la declaració requerida.
Inseriu la paraula clau 'nullptr' per determinar si un punter està buit abans d'utilitzar la referència. Ara, també col·loquem el destructor '~Move()' en el qual col·loquem la condició 'si' que verifica si el 'valor' no és igual a 'nullptr'. Quan es verifica aquesta condició, s'executa la instrucció següent. Si aquesta condició no es verifica, s'omet la declaració 'cout' que està present després de la condició 'si' i es mou cap a la part 'else'.
Després d'això, utilitzem la paraula clau 'suprimir' que ajuda a desassignar un objecte o podem dir que allibera la memòria que s'assigna al component de dades de l'objecte. Ara, aquí invoquem el mètode 'main()' i creem el vector de la nostra classe 'Mou' amb el nom 'my_vec'. Després d'això, utilitzem la funció 'push_back()' que ajuda a inserir un valor al punt final d'un vector. El fitxer de capçalera 'vector' conté aquesta funció. Primer, inserim '39' al vector. A continuació, s'insereix '57' i també s'insereix '91' utilitzant el mètode 'push_back()'.
Codi 2:
#inclou#inclou
utilitzant espai de noms std ;
classe Mou-te {
privat :
int * valor ;
públic :
Mou-te ( int v1 )
{
valor = nou int ;
* valor = v1 ;
cout << 'El Constructor està cridat per'
<< v1 << endl ;
} ;
Mou-te ( const Mou-te & font_nova )
: Mou-te { * font_nova. valor }
{
cout << 'Copy Constructor s'anomena -'
<< 'Còpia profunda per a'
<< * font_nova. valor
<< endl ;
}
Mou-te ( Mou-te && font_nova )
: valor { font_nova. valor }
{
cout << 'Mou el constructor per a'
<< * font_nova. valor << endl ;
font_nova. valor = nullptr ;
}
~Mou ( )
{
si ( valor ! = nullptr )
cout << 'Destructor és cridat'
<< * valor << endl ;
altra cosa
cout << 'Es diu Destructor'
<< 'per nullptr'
<< endl ;
esborrar valor ;
}
} ;
int principal ( )
{
vector < Mou-te > la meva_cosa ;
la meva_cosa. fer retrocedir ( Mou-te { 39 } ) ;
la meva_cosa. fer retrocedir ( Mou-te { 57 } ) ;
la meva_cosa. fer retrocedir ( Mou-te { 91 } ) ;
tornar 0 ;
}
Sortida:
Això mostra que en comptes d'utilitzar la funció 'còpia', hem d'utilitzar la funció 'mou' per evitar la trucada innecessària a la funció 'còpia'. El constructor 'moveu' s'invoca aquí quan inicialitzem l'objecte amb un objecte temporal o algun objecte que serà destruït. En lloc de manipular una còpia profunda de les dades donades, el constructor 'move' canvia la propietat dels recursos d'un objecte a un altre.
Conclusió
En aquesta guia, hem explorat el constructor 'move'. Vam explicar que el constructor 'mouveu' a la programació C++ és un mètode únic per reubicar els recursos d'un objecte a un altre de manera eficaç. Hem comentat que cridar al constructor 'moveu' té menys sobrecàrrega, fent que el codi sigui més eficient en la memòria. Hem explorat el fet que el constructor 'move' és una característica potent en la programació C++. També vam utilitzar els exemples pràctics per il·lustrar el concepte del constructor 'movement' i vam demostrar els beneficis de rendiment d'utilitzar el constructor 'movement' a la programació C++.