/* 

CS 203. Correction de la feuille 4

Credit : certains des programmes presentes ont ete realises par Pierre Cohort

*/

#include <stdio.h>
#include <stdlib.h>

/* exercice I */

/* commentaire : il faut passer l'adresse de lamdba et mu pour que la fonction
   puisse modifier effectivement ces variables. */

void LameLambdaMu(double Young, double Poisson, double* Lambda_Ptr, double* Mu_Ptr)
     /* Calcul de Lambda et Mu a partir de Young et Poisson
	ENTREE : Young et Poisson
	SORTIE : un pointeur vers Lambda et un pointeur vers Mu
        Il faut passer l'adresse de lamdba et mu pour que la fonction  puisse 
	modifier effectivement ces variables. 
     */
{
  *Lambda_Ptr=Young*Poisson/((1.+Poisson)*(1.-2.*Poisson));
  *Mu_Ptr=Young/(2.*(1.+Poisson));
}

int main_exercice1() {
  double E=1.0, nu=0.7, lambda, mu;

  LameLambdaMu(E,nu,&lambda,&mu);
  printf("Lamdba=%f Mu=%f\n",lambda,mu);
  return(0);
}



/* exercice II */
int main_exercice2() {
  int a=-1, b=1, c, *P, **Q, ***R;
  P=&a; /* P pointe vers a */
  Q=&P; /* Q pointe vers P (qui pointe vers a) */
  R=&Q; /* R pointe vers Q (qui pointe vers P qui pointe vers a) */
  b=***R; 
  /* b recoit ce qui est pointe par ce qui est pointe par ce qui est pointe par R
     c'est a dire a qui vaut -1, on a donc b=-1 */
  a=0; /* a recoit 0 */
  printf("[1] b=%d\n",b); /* on affiche [1]  b=-1 */
  c=9; /* c recoit 9 */
  P=&c; /* P pointe maintenant vers c */
  printf("[2] a=%d\n",a); /* on affiche [2]  a=0, car a n'a pas ete affecte */
  b=**Q;   
  /* b recoit ce qui est pointe par ce qui est pointe par Q, c'est-a-dire
     ce qui est pointe par P, c'est-a-dire c qui vaut 9, on a donc b=9 */
  printf("[3] b=%d\n",b); /* on affiche [1]  b=9 */
  return 0;
}



/* exercice III */

int main_exercice3_question1()
{
  int x, *y, **z;
  x=1;
  y=&x; /* y pointe vers x */
  z=(int**)malloc(2*sizeof(int*));
  z[0]=y; /* Le premiere case du tableau z pointe vers un pointeur vers x */
  x=2; /* maintenant x vaut 2 donc *y=2 et x[0] pointe vers un pointeur vers 2 */
  z[1]=y; /* La deuxieme case du tableau z pointe vers un pointeur vers x */
  printf("%d %d\n",*(z[0]),*(z[1])); /* Affichage de x deux fois soit 2 et 2 */
  return(0);
}

int main_exercice3_question2()
{
  int x, y, *T;
  x=1;
  y=2;
  T=(int*)malloc(2*sizeof(int));
  T[0]=++x; /* La premiere case de T recoit 2 car x est incremente avant l'affectation */
  T[1]=y; /* La deuxieme case de T recoit 2 */
  x+=5; /* les modifications sur x et y n'affecteront pas T */
  y--;
  printf("%d %d\n",T[0],T[1]); /* Affichage de 2 et 2 */
  return(0);
}

int main_exercice3_question3()
{
  int i, a, *tab, *b;
  tab=(int*)malloc(10*sizeof(int));
  a=1;
  for(i=0;i<10;i++)
    tab[i]=a*i;
  /* le contenu du tableau tab est 0 1 2 3 4 5 6 7 8 9 */
  a++;
  /* La commande a++; n'affecte pas le tableau, en revanche la variable a
   contient desormais 2. */
  for(i=0;i<9;i++)
    tab[i]=tab[i+1];
  /* le contenu du tableau tab est 1 2 3 4 5 6 7 8 9 9.
     A la ligne suivante b pointe sur la deuxieme case du tableau. */
  b=&(tab[1]);
  *b=--a;    
  /*  La commande *b=--a; est une affectation a ce qui est pointe
      par b, donc une affectation a la la deuxieme case du
      tableau.  La valeur affectee est a decrementee de 1, soit
      2-1=1. Le tableau tab devient 1 1 3 4 5 6 7 8 9 9. */
  for(i=0;i<10;i++)
    printf("%d\n",tab[i]);
  /* affiche les cases du tableau en colonne, en passant a la
     ligne apres chaque case. */
  return(0);
}



/* main */

int main()
{
  int n;

  printf("Feuille d'exercices 4\n");
  printf("Choix de l'exercice (entrer 31 pour exercice 3 question 1) : ");
  scanf("%d",&n);

  switch (n) {
  case 1:  main_exercice1(); break;
  case 2:  main_exercice2(); break;
  case 31: main_exercice3_question1(); break;
  case 32: main_exercice3_question2(); break;
  case 33: main_exercice3_question3(); break;
  }

  return 0;
}