La programmation C++ est le meilleur langage car il nous offre un large éventail de fonctions, de constructeurs, de fichiers d'en-tête, de classes et bien plus encore, rendant le codage plus intéressant et plus facile. L'un des constructeurs de la programmation C++ est le constructeur « move ». Le constructeur « move » est un type unique de constructeur qui permet de transférer la propriété d'une mémoire allouée dynamiquement ou d'autres ressources d'un objet à un autre de manière efficace et soucieuse des ressources.
Dans la programmation C++, des constructeurs « move » ont été introduits pour réduire la duplication et améliorer l'efficacité. Il joue un rôle crucial dans l’amélioration des performances en minimisant les opérations de copie. Ce guide explore en profondeur le constructeur « move » dans la programmation C++.
Exemple 1:
Pour commencer le code ici, nous incluons les fichiers d'en-tête « iostream » et « string » qui permettront à notre code de fonctionner parfaitement puisque de nombreuses fonctions sont déclarées dans ces fichiers d'en-tête. Lorsque nous devons utiliser l'instruction « cout », le fichier d'en-tête « iostream » est utilisé puisque cette fonction est déclarée à l'intérieur de celui-ci. Lorsque nous devons travailler avec des données de type chaîne, le fichier d'en-tête « string » est nécessaire.
Après cela, le « namespace std » est ajouté sous ces fichiers d'en-tête. Ensuite, nous construisons une classe ici. Le nom de la classe est « Move ». En dessous, le mot-clé « private » est ajouté dans lequel nous déclarons une variable de chaîne privée avec le nom « my_str ». Maintenant, nous plaçons le mot-clé « public » où nous ajoutons la définition du constructeur par défaut. Nous passons « Ceci est la chaîne par défaut ici » à « my_str » comme paramètre et laissons le constructeur par défaut vide.
Après cela, nous copions la définition du constructeur et initialisons « my_str » à « my_obj.my_str ». En dessous, nous imprimons une ligne puis plaçons la définition du constructeur « move ». Ici, nous initialisons à nouveau « my_str » avec « my_obj.my_str ». Nous n’ajoutons aucune déclaration en dessous ; c'est vide. Après cela, nous déclarons une fonction nommée « displayMyObject() » de type chaîne et utilisons le « return str » pour qu'elle renvoie la chaîne.
On place la fonction globale « new_temp » dans le type « move ». En dessous, nous avons le « température de retour » qui renvoie l'objet de type déplacement. Maintenant, nous plaçons le code du pilote « main() » et le « new_obj1 » du type « move » et obtenons le constructeur « move » à partir de la « rvalue ». Dans la ligne suivante, nous plaçons le « new_obj1.displayMyObject() » pour obtenir le constructeur « move » de la « lvalue ». Après cela, nous appelons le constructeur « move » avec l'objet « my_obj1 ». Ensuite, nous transférons la propriété de « mon_obj1 » à l'autre objet qui est « mon_obj2 ».
Codage 1 :
#include#include
en utilisant espace de noms norme ;
classe Se déplacer
{
privé :
chaîne ma_str ;
publique :
Se déplacer ( ) : ma_str ( 'C'est la chaîne par défaut ici' )
{
}
Se déplacer ( const Se déplacer & mon_obj ) : ma_str ( mon_obj. ma_str )
{
cout << 'Constructeur de copie invoqué, échec du déplacement ! \n ' ;
}
Se déplacer ( Se déplacer && mon_obj ) : ma_str ( se déplacer ( mon_obj. ma_str ) )
{
}
chaîne displayMyObject ( )
{
retour ma_str ;
}
} ;
Déplacer new_temp ( Déplacer tmp )
{
retour tmp ;
}
int principal ( )
{
Déplacer new_obj1 = nouveau_temp ( Se déplacer ( ) ) ;
cout << 'avant l'appel de move() : new_obj1 = ' << nouveau_obj1. afficherMonObjet ( ) << fin ;
Déplacer new_obj2 = se déplacer ( nouveau_obj1 ) ;
cout << 'après l'appel du constructeur move() : new_obj1 = ' << nouveau_obj1. afficherMonObjet ( ) << fin ;
cout << 'après l'appel du constructeur move() : new_obj2 = ' << nouveau_obj2. afficherMonObjet ( ) << fin ;
retour 0 ;
}
Sortir:
La sortie indique qu'avant d'appeler la méthode « move() », le « new_obj1 » contient la chaîne par défaut. Mais après avoir appelé la méthode move() de la classe « Move », « my_obj1 » contient une chaîne vide et « my_obj2 » a la chaîne par défaut.
Exemple 2 :
Ici, nous incluons un fichier d'en-tête supplémentaire qui est le fichier d'en-tête « vectoriel ». Nous l'incluons chaque fois que nous devons manipuler les opérations sur les vecteurs. La classe que nous créons ici est la classe « Move ». Nous créons également ici un constructeur « public » dans lequel nous déclarons le pointeur brut « int* value » comme étant les données d’un membre de la classe. En dessous, nous avons le « public » dans lequel nous plaçons le constructeur « Move » et passons « int v1 » comme paramètre.
Après cela, nous déclarons les objets dans un tas. On initialise la « valeur » avec « new int » et la « *value » avec « v1 ». Ensuite, placez le « cout » où nous ajoutons une ligne qui s’imprime lorsque nous exécutons le code. En dessous, nous utilisons le constructeur « copie ». Ce constructeur de « copie » copie les données en effectuant une copie complète. Nous plaçons le constructeur « Move » et passons « Move&& new_source » comme paramètre. En dessous, nous plaçons le « cout » qui aide à afficher la déclaration requise.
Nous insérons le mot-clé « nullptr » pour déterminer si un pointeur est vide avant que la référence ne soit utilisée. Maintenant, on place également le destructeur « ~Move() » dans lequel on place la condition « if » qui vérifie si la « valeur » n'est pas égale à « nullptr ». Lorsque cette condition est vérifiée, l'instruction située en dessous est exécutée. Si cette condition n'est pas vérifiée, il saute l'instruction « cout » qui est présente après la condition « if » et se déplace vers la partie « else ».
Après cela, nous utilisons le mot-clé « delete » qui aide à désallouer un objet ou nous pouvons dire qu'il libère la mémoire allouée au composant de données de l'objet. Maintenant, nous invoquons ici la méthode « main() » et créons le vecteur de notre classe « Move » avec le nom « my_vec ». Après cela, nous utilisons la fonction « push_back() » qui permet d'insérer une valeur au point final d'un vecteur. Le fichier d'en-tête « vecteur » contient cette fonction. Tout d’abord, nous insérons « 39 » dans le vecteur. Ensuite, « 57 » est inséré et « 91 » est également inséré en utilisant la méthode « push_back() ».
Code 2 :
#include#include
en utilisant espace de noms norme ;
classe Se déplacer {
privé :
int * valeur ;
publique :
Se déplacer ( int v1 )
{
valeur = nouveau int ;
* valeur = v1 ;
cout << 'Le Constructeur est appelé à '
<< v1 << fin ;
} ;
Se déplacer ( const Se déplacer & nouvelle source )
: Se déplacer { * nouvelle source. valeur }
{
cout << 'Le constructeur de copie s'appelle -'
<< ' Copie complète pour '
<< * nouvelle source. valeur
<< fin ;
}
Se déplacer ( Se déplacer && nouvelle source )
: valeur { nouvelle source. valeur }
{
cout << 'Déplacer le constructeur pour'
<< * nouvelle source. valeur << fin ;
nouvelle source. valeur = nullptr ;
}
~Déplacer ( )
{
si ( valeur ! = nullptr )
cout << 'Le destructeur est requis'
<< * valeur << fin ;
autre
cout << 'Le destructeur est appelé'
<< ' pour nullptr '
<< fin ;
supprimer valeur ;
}
} ;
int principal ( )
{
vecteur < Se déplacer > ma chose ;
ma chose. repousser ( Se déplacer { 39 } ) ;
ma chose. repousser ( Se déplacer { 57 } ) ;
ma chose. repousser ( Se déplacer { 91 } ) ;
retour 0 ;
}
Sortir:
Cela montre qu'au lieu d'utiliser la fonction « copier », nous devons utiliser la fonction « déplacer » pour éviter l'appel inutile à la fonction « copier ». Le constructeur « move » est invoqué ici lorsque nous initialisons l'objet avec un objet temporaire ou un objet qui sera détruit. Au lieu de manipuler une copie complète des données données, le constructeur « move » transfère la propriété des ressources d'un objet à un autre.
Conclusion
Dans ce guide, nous avons exploré le constructeur « move ». Nous avons expliqué que le constructeur « move » dans la programmation C++ est une méthode unique pour déplacer efficacement les ressources d'un objet vers un autre objet. Nous avons expliqué que l'appel du constructeur « move » entraîne moins de surcharge, ce qui rend le code plus efficace en termes de mémoire. Nous avons exploré le fait que le constructeur « move » est une fonctionnalité puissante dans la programmation C++. Nous avons également utilisé les exemples pratiques pour illustrer le concept du constructeur « move » et démontré les avantages en termes de performances de l'utilisation du constructeur « move » dans la programmation C++.