Séance du 25 octobre.

C10.1.c

@@ -0,0 +1,15 @@
+int main()
+{
+  // Le mot `register` est réservé par C est ne doit pas être utilisé comme nom de variable.
+  int my_account, register_v = 1, amount = 0, dest, succeed = 0;
+  // On peut imaginer qu'ici il faut demander son compte à l'utilisateur ou le récupéréer dans un fichier de config du programme.
+  if(my_account == dest)
+  {
+    amount+=register_v;
+    succeed = 1;
+  }
+  //Values of succeed + amount
+  // succeed undefined (car on n'est pas rentré dans le if)
+  // amount 0 (car non modifié)
+  return 0;
+}

C10.10.c

@@ -0,0 +1,28 @@
+int x = 0;
+
+int g()
+{
+  return ++x;
+}
+
+int h()
+{
+   return x++;
+}
+
+int f(int a, int b)
+{
+  if(a+b == 2)
+    return a+x;
+  else
+    return b+x;
+}
+
+
+int main()
+{
+  int v = f(g(), h());
+  //Value of v
+  // v=4
+  // Je ne sais pas ce que le développeur voulait faire avec ce code ...
+}

C10.2.c

@@ -0,0 +1,12 @@
+int main()
+{
+  int a = 1,b;
+  // L'opérateur `=` est un opérateur d'assignation (qui renvoie la valeur assigné, donc ici, 1)
+  // L'opérateur d'égalité est `==`
+  if(a==1)
+    b = 10;
+  else
+    b = 5;
+  //Value of a + b = 11 car a==1.
+  return 0;
+}

C10.3.c

@@ -0,0 +1,12 @@
+#include<stdio.h>
+int main()
+{
+  // On ne peut nommer des variable en commencant par un chiffre.
+  int _x=5,y=0, _1tmp = 3;
+  _x++;
+  y = _x++;
+  y = ++_x; // Oubli du point-virgule
+  _1tmp = (y > _x);
+  //Value of _x, y and 1tmp
+  // 8, 8 et 0 (_x est incrémenté trois fois, y prend la valeur de _x après son troiséme incrémentation et 1tmp est «faux» car x==y)
+}

C10.4.c

@@ -0,0 +1,18 @@
+int main()
+{
+  int i , j = 2, k, l = 1;
+  for(i = 0; i< 100; ++i)// Le point-virgule qui était ici «annule» le for.
+  {
+    int j = 0;
+    for(k=2*i; k > 0; k=k-2, l += 8)
+    {
+      k++;
+      j++;
+    }
+  }
+  //Valeur de i, j, k, l
+  // i=100 car incrémenté jusqu'à ce que i<100 soit faux
+  // j=2 car n'a pas été modifié (c'est un autre j à l'interieur de la boucle)
+  // k=0 a pris sa valeur à la dernière boucle (i=99), initialisé à 198 et décrémenté de un (-2 +1) jusqu'à se que k>0 soit faux.
+  // l = 79201 car incrémenté de huit dès que la boucle interne faisait une itération. soit l= 1 +sum(i=0..99, 2i)*8 = 16*99*50 +1
+}

C10.5.c

@@ -0,0 +1,12 @@
+#include<stdio.h>
+// Il manquait la directive afin de définir printf
+int main()
+{
+  int i=0;
+  while(i < 100){ // Si le bloc contient plusieurs lignes, il faut utiliser des crochets, l'indentation est «inutile» car inexistance du point de vue du compilateur.
+    printf("%i", i);
+    i++;
+  }
+  //Valeur de i
+  // i = 100, première valeur de i telle que (i<100) soit faux.
+}

C10.6.c

@@ -0,0 +1,17 @@
+int main()
+{
+  //new version of the code
+  int a=0, b= 1;
+  /* We modify a */
+  a += a+b;
+
+  //old version of the code (now commented)
+  /*
+  int a=0, b= 1;
+  // We modify a
+  a = a+b;*/
+  // Il n'est pas possible de faire des commentaires en bloc imbriqués, puisque la pause du préprocesseur s'arrêtera au premier */ croisé.
+
+  //Valeur de a
+  //a=1 (car 0 + (0+1) = 1)
+}

C10.7.c

@@ -0,0 +1,18 @@
+int x = 0;
+
+int f(int* x)
+{
+  return (*x)++; // Ne sert pas à grand chose, int x est passé en valeur. Il faut utiliser la référence ici.
+}
+
+void g(int b)
+{
+  x = x+1; // Ici pas de problème puisqu'on utilise la variable globale.
+}
+
+int main()
+{
+  g(f(&x));
+  //Value of x
+  // x=2 car incrémenté deux fois.
+}

C10.8.c

@@ -0,0 +1,12 @@
+//Polymorphic mul
+// Les noms de macro sont sensibles à la casse, donc il faut respecter une convension (ici, j'ai choisi les minuscules).
+// Attention aussi, une macro, c'est idiot, il faut mieux isoler les paramètre dans des parenthèses.
+#define mul(a,b) (a)*(b)
+
+int main()
+{
+  // Ici, la macro créait la séquence «3+4*4+3» étant mal compris à cause de la précédence plus élevée du *.
+  int x = mul(3+4, 4+3);
+  //Value of x
+  // x=49 (des maths: (3+4)*(4+3) = 49)
+}

C10.9.c

@@ -0,0 +1,28 @@
+//Error codes
+#define DIV_0 1
+#define OVERFLOW 2
+#define NO_ERROR 0
+#define MAXI_ERROR 10
+#define INTERMEDIATE_ERROR 5
+
+int check_error(int a, /*Il faut préciser le type de chaque paramètre */ int b)
+{
+  if(b == 0)
+    return DIV_0;
+  if(a > 100000 && b > 100000) // Double esperluette pour le et logique
+    return OVERFLOW;
+  else
+    return NO_ERROR;
+}
+
+
+int main()
+{
+  if(check_error(1000000, 1000000) && check_error(5, 0)) // double esperluette pour le et logique
+    return MAXI_ERROR;
+  else if(check_error(1000000, 1000000))
+    return INTERMEDIATE_ERROR;
+  return NO_ERROR;
+  //Value returned by main
+  // 10 = MAXI_ERROR car les deux condition créent une erreur.
+}