Copy
****

.. include:: ../BoutonGoogleTrad.rst


La première question à se poser
===============================

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

.. panels::

	:column: col-lg-10 p-2
	
	 	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.

.. code-block:: cpp

	#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;
	}

	
.. quiz:: affectationTypeFond
	:title: Affectations et types fondamentaux

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

	.. csv-table::
		:widths: 10 
		:delim: !

		:quiz:`{"type":"TF","answer":"T"}`   L'affectation sur des variables de type entier produit une copie.
		:quiz:`{"type":"TF","answer":"T"}`   L'affectation sur des variables de type double produit une copie.   		 
		:quiz:`{"type":"TF","answer":"T"}`   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.



.. code-block:: cpp

	#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;
	}


.. quiz:: affectationStruct
	:title: Affectations et structure
	
	Indiquez si l'affirmation suivante est vraie ou fausse :

	.. csv-table::
		:widths: 10 
		:delim: !
		
		:quiz:`{"type":"TF","answer":"T"}`   L'affectation sur des variables de type structure produit une copie.


Passage d'arguments par valeur
==============================




.. panels::
  
    :column: col-lg-10 p-2
    
	**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.



.. code-block:: cpp
 
		
	#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;
	}

.. quiz:: FondParamFnt
	:title: Passage de paramètres et types fondamentaux

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

	.. csv-table::
		:widths: 10 
		:delim: !

		:quiz:`{"type":"TF","answer":"T"}`   Le passage de paramètres avec un type entier produit une copie.
		:quiz:`{"type":"TF","answer":"T"}`   Le passage de paramètres avec un type double produit une copie.   		 
		:quiz:`{"type":"TF","answer":"T"}`   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.


 

.. code-block:: cpp

	#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;
	}
	
.. quiz:: ParamStruct
	:title: Passage de paramètres et structure
	
	Indiquez si l'affirmation suivante est vraie ou fausse :

	.. csv-table::
		:widths: 10 
		:delim: !
		
		:quiz:`{"type":"TF","answer":"T"}`   Le passage de paramètres avec un type structure produit une copie des informations contenues dans la structure.