Copy

Your native language: with Chrome, right-click on the page and select « Translate into … »
English version:

La première question à se poser

Que se passe-t-il lorsqu’on écrit : A = B ?

Pour les types fondamentaux (int, double…) et pour la plupart des objets :

A = B copie le contenu de B vers A.

Ensuite, les deux variables évoluent indépendamment : modifier l’une ne change pas l’autre.

Note

Il existe une situation particulière lorsque les objets A et B vont partager des ressources comme un fichier ou un segment de mémoire. Dans cette configuration, l’indépendance entre ces deux objets est compromise. A notre niveau, nous éviterons cette situation car elle est source de complications.

Nous allons dans la suite tester ces différents scénarios.

Comportement pour les affectations

Pour les types fondamentaux

Veuillez exécuter le code suivant dans votre environnement préféré, puis analysez les affichages.

#include <iostream>

int main()
{
        // int type
        int x = 10;
        int y = x;
        y++;
        std::cout << x << " " << y << std::endl;

        // double type
        double d1 = 5;
        double d2 = d1;
        d2++;
        std::cout << d1 << " " << d2 << std::endl;

        // bool type
        bool flag1 = true;
        bool flag2 = flag1;
        flag2 = !flag2;
        std::cout << flag1 << " " << flag2 << std::endl;
}

Pour chaque type testé, indiquez si l’affirmation correspondante est vraie ou fausse :

L’affectation sur des variables de type entier produit une copie.

L’affectation sur des variables de type double produit une copie.

L’affectation sur des variables de type booléen produit une copie.

Pour les structures

Examinons maintenant le type structure. Veuillez exécuter le code suivant dans votre environnement préféré, analysez ensuite les affichages.

#include <iostream>

struct Vec
{
    int x;
    int y;
};

int main()
{
        // struct type
        Vec B;
        B.x = 10;
        B.y = 20;

        Vec A;
        A = B;   // the case we are interested in

        A.x += 5;
        A.y += 5;

        // output
        std::cout << B.x << " " << B.y << std::endl;
        std::cout << A.x << " " << A.y << std::endl;
}

Indiquez si l’affirmation suivante est vraie ou fausse :

L’affectation sur des variables de type structure produit une copie.

Passage d’arguments par valeur

REGLE : En C++, le passage d’arguments par valeur déclenche une copie de cet argument vers le paramètre de la fonction comme si l’on écrivait :

paramètre = argument

Ce comportement est valable pour les types fondamentaux (int, double) comme pour les structures.

Ainsi, comme pour l’écriture de A=B :

On copie le contenu de l’argument vers le paramètre de la fonction.

Ensuite, le paramètre de la fonction évolue indépendamment de l’argument d’origine ; modifier le paramètre ne change pas l’argument.

Nous allons dans la suite tester ces différents scénarios.

Cas des types fondamentaux

Nous allons vérifier ce qu’il se passe en exécutant le code suivant et en analysant les résultats.

#include <iostream>

void F(int a, double b, bool c)
{
        std::cout << "Function entry : " << a << " " << b << " " << c << std::endl;
        a += 1;
        b += 1;
        c = !c;
        std::cout << "Function exit  : " << a << " " << b << " " << c << std::endl;
}

int main()
{
        // integer, double, bool types
        int    x = 10;
        double y = 20.0;
        bool   flag = true;

        std::cout << "Before call    : " << x << " " << y << " " << flag << std::endl;
        F(x, y, flag);
        std::cout << "After call     : " << x << " " << y << " " << flag << std::endl;
}

Pour chaque type testé, indiquez si l’affirmation correspondante est vraie ou fausse :

Le passage de paramètres avec un type entier produit une copie.

Le passage de paramètres avec un type double produit une copie.

Le passage de paramètres avec un type booléen produit une copie.

Cas des structures

Veuillez exécuter le code suivant, puis analysez les résultats.

#include <iostream>

struct Vec
{
    int x;
    int y;
};

void F(Vec v)
{
    std::cout << "Function entry : " << v.x << " " << v.y << std::endl;
        v.x += 1;
        v.y += 2;
    std::cout << "Function exit  : " << v.x << " " << v.y << std::endl;
}

int main()
{
        // struct type
        Vec data;
        data.x = 10;
        data.y = 20;

        std::cout << "Before call    : " << data.x << " " << data.y << std::endl;
        F(data);
        std::cout << "After call     : " << data.x << " " << data.y << std::endl;
}

Indiquez si l’affirmation suivante est vraie ou fausse :

Le passage de paramètres avec un type structure produit une copie des informations contenues dans la structure.