Lors du renvoi d'un objet nommé par valeur en C , la règle de déplacement implicite s'applique-t-elle ?

Renvoi d'un objet nommé par valeur et règle de déplacement implicite

En C , un objet peut être renvoyé à partir d'une fonction soit par référence, soit par valeur. Lors d'un retour par valeur, l'objet est copié ou déplacé, selon le contexte. La règle de déplacement implicite est appliquée lors du renvoi d'un objet par valeur à partir d'une fonction où l'objet est temporaire.

Exemple 1 : Constructeur de déplacement

Considérez l'exemple ci-dessous :

<code class="cpp">class test {
public:
    test(int y) {
        printf("test(int y)\n");
    }
    test() {
        printf("test()\n");
    }
    test(const test& z) {
        printf("test(const test&z)\n");
    }
    test(test&& s)noexcept{
            printf("test(test&& s)\n");          
    }
    test& operator=(test e) {
        printf("test& operator=(test e)\n");
        return *this;
    }
};
test Some_thing() {
    test i;
    return i;
}
int main()
{
    Some_thing();
    return 0;
}</code>

Cet exemple renvoie un objet de type test par valeur avec les constructeurs suivants :

• test(int) : constructeur qui accepte un argument entier
• test () : constructeur par défaut
• test(const test&) : constructeur de copie
• test(test&&) : constructeur de déplacement

Lorsque la fonction Some_thing est appelée, une instance de test est créé par défaut dans la fonction puis renvoyé. La règle de déplacement implicite est appliquée et le constructeur de déplacement test(test&&) est utilisé pour déplacer l'objet temporaire dans l'objet renvoyé par la fonction.

Par conséquent, la sortie affiche les étapes suivantes :

• test()
• test(test&& s)

Exemple 2 : Copier le constructeur

Maintenant, considérons ceci modifié exemple :

<code class="cpp">class test {
public:
    test(int y) {
        printf("test(int y)\n");
    }
    test() {
        printf("test()\n");
    }
    test(test& z) {
        printf("test(test&z)\n");
    }
    test& operator=(test e) {
        printf("test& operator=(test e)\n");
        return *this;
    }
};
test Some_thing() {
    test i;
    return i;
}
int main()
{
    Some_thing();
    return 0;
}</code>

Dans ce cas, le constructeur de déplacement test(test&&) n'est pas disponible. Au lieu de cela, le constructeur de copie test(test&) est utilisé pour copier l'objet temporaire renvoyé par la fonction dans l'objet créé sur la pile dans main.

La sortie montre les étapes suivantes :

• test()
• test(test&z)

Exemple 3 : Constructeur de déplacement supprimé

Enfin, si nous supprimons explicitement le déplacement constructeur comme celui-ci :

<code class="cpp">class test {
public:
    test(test&& z) = delete;
    test(int y) {
        printf("test(int y)\n");
    }
    test() {
        printf("test()\n");
    }
    test(const test& z) {
        printf("test(test&z)\n");
    }
    test& operator=(test e) {
        printf("test& operator=(test e)\n");
        return *this;
    }
};
test Some_thing() {
    test i;
    return i;
}
int main()
{
    Some_thing();
    return 0;
}</code>

Le constructeur de déplacement ne peut pas être utilisé et la compilation échouera car il n'y a pas de constructeur viable à utiliser pour la valeur de retour.

En conclusion, le déplacement implicite La règle est appliquée lors du retour d'un objet d'une classe par valeur à partir d'une fonction où l'objet est temporaire. Si un constructeur de déplacement est disponible, il sera utilisé, mais sinon, le constructeur de copie sera utilisé à la place. Si le constructeur de déplacement est explicitement supprimé, la compilation échouera.

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!