TD1

25 février 2022 et 7 mars 2022

1. Ne compile pas à la ligne 6, la fonction main tente d’accéder à atr qui est un membre privé de la classe A.
  Par défaut tout membre d’une classe définie avec Class est privé.
2. Le code compile à la différence du 1 car il y a l’instruction public en début de classe donc atr est un membre publique donc pas d’erreur.
  N’affiche rien.
1. Le code compile, il affiche :
```
Bonjour
Au revoir
```
Le constructeur A(void) est appellé à la construction de l’objet ob. Le destructeur ~A(void) est appelé lorsque l’objet ob détruit à la fin de la fonction main().
2. Le code compile, il affiche :
```
Bonjour
Bonjour
Bonjour
Au revoir
Bonjour
Au revoir
Bonjour
Au revoir
Au revoir
```
Dans ce cas, fuite de mémoire, l’objet créer manuellement ligne 16 n’a pas été détruit par un delete.
3. Ce code compile, il affiche :
```
Construction A1
Construction A2
Construction A3
Construction A3 (grâce au cast int en float)
```
Si on décommente la ligne 10, pour le compilateur, c’est une déclaration de fonction.
\Rightarrow il faut donc penser à mettre des void pour bien faire la distinction, et il faut utiliser
les accolades car avec il n’y a aucune ambiguïté.
Si on décommente la ligne 15, le programme ne compile pas car erreur car il n’y a pas de constructeur défini pour un seul int, il sait pas s’il doit cast en long ou en float.
4. Ce code compile, il affiche :
```
Construction A1
Construction B
Construction C2
Construction A2
Construction C1
```
Lors de la construction d’un objet A, les constructeurs des attriuts sont avant (et dans l’ordre) le constructeur de l’objet A. Pour choisir explicitement ces constructeurs on peut les indiquer dans la liste d’initalisation, exemple :

C(int a) : atrA(a) {
atrA(a) est la liste d’initalisation.
1. Ce code ne compile pas.
  La ligne 5 devrait faire appel au constructeur sans paramètre de la classe A car la classe A ne possède pas de constructeur sans paramètre, donc erreur.
  
  Remarque : Le constructeur sans paramètre implicite n’est pas automatiquement généré car la classe A possède un constructeur explicite : A(int) ligne 3.
2. Ce code ne compile pas.
  new A[20]; doit réserver de la place et appelé un constructeur pour chaque case, mais il n’y a pas de constructeur adéquat (il a besoin d’un constructeur sans paramètre) \Rightarrow ça revient au même problème que dans la question 5.
3. Ce code compile, il n’affiche rien mais il y a une fuite de mémoire car on ne delete[] pas point. Il faudrait écrire une déstruction qui libère la mémoire.
  
  Exemple : ~A(void) { delete[] point; }
4. Ce code compile, il affiche :
```
Appel du constructeur
Appel du constructeur de copie
Appel de f
Appel de g
```
Il y a appel du constructeur de recopie car on donne a à la fonction f.
La fonction g fonctionne différement et n’appelle pas le constructeur de recopie car on demande la référénce de a (modification de l’objet original à travers la fonction).
1. Ce code ne compile pas.
  f() n’est pas const, alors que l’objet obj l’est, cet objet ne peux que lancer des méthodes avec le mot-clé const. Le const fait parti de la signature de la méthode. Pour faire fonctionner le programme il faudrait soit void f(void) const { ... } (l. 3), soit A obj; (l. 5).
2. Ce code ne compile pas car une fonction const (f) modifie la valeur d’un attribut (a) de la struct.
3. Ce code compile, il n’affiche rien car il n’y a rien dans le main, la variable modifié dans la méthode const est déclaré comme mutable, alors ça fonctionne.
4. Ce code compile, il affiche :
```
Je suis la methode f const
Je suis la methode f
Je suis la fonction g(A)
```
Si on décommente la ligne 14, on aurait la fonction g(&A) qui serait appelée.