Exercice langage C
[tab name=’Exercice langage C’]

1. Ecrivez une fonction

         void affiche(int *T, int n)

   qui affiche à l’écran un tableau d’entiers T passé en argument. La longueur du tableau n est également passée en paramètre.

2. Déclarez un tableau int T[10] dans la fonction main, et appelez la fonction que vous venez d’écrire pour l’afficher.Compilez votre programme et lancez-le. Que constatez-vous? Etes-vous surpris par les valeurs retournées par votre programme? Pouvez-vous les expliquer?
3. Déclarez un deuxième tableau T2 de 8 éléments en utilisant la fonction new que vous avez vue en cours. Utilisez également la fonction écrite au point a) pour afficher le nouveau tableau. Remarquez-vous une différence entre les deux méthodes d’initialisation de tableaux?Remarque: N’oubliez pas qu’avec cette méthode vous devez libérer la mémoire que vous avez réservée à la fin du programme.
4. Ecrivez une fonction alloue_tab qui alloue un nouveau tableau et retourne un pointeur sur ce tableau. La taille du nouveau tableau sera passée en paramètre.
5. Ecrivez une fonction statistique qui calcule le minimum, le maximum et la moyenne d’un tableau d’entiers passé en paramètre.Remplissez un des trois tableaux de valeurs aléatoires et utilisez la fonction statistique pour afficher ses minimum, maximum et moyenne.Indice: Comme une fonction ne peut retourner qu’une seule valeur, le seul moyen de retourner à la fois le minimum, le maximum et la moyenne est d’ajouter trois arguments de type pointeurs. On dit alors que ces arguments sont passés par adresse ou par réference, car on passe leur adresse et non pas leur valeur. L’avantage de cette méthode est que toutes les modifications effectuées sur ces arguments à l’intérieur de la fonction seront également répercutées à l’extérieur.

[/tab][tab name=’Correction’]

Au point 2, on remarque que lorsqu’on déclare un tableau de manière statique, il n’est pas initialisé et ses éléments possèdent donc une valeur plus ou moins aléatoire. Au contraire – au point 3 -, lorsqu’on alloue dynamiquement un tableau, la zone mémoire est mise à 0.

Pour le point 5, il faut écrire la fonction statistique en passant une partie des arguments par référence. Cela signifie que, plutôt que de déclarer des arguments de type int ou float, comme on l’a fait jusqu’ici, on va utiliser des pointeurs, de manière à passer non pas la valeur d’une variable à la fonction, mais l’adresse d’une variable.

Puisque la fonction possède l’adresse de la variable, elle peut modifier son contenu d’origine. Ceci n’aurait pas été possible avec un passage par valeur, car dans ce cas, la valeur passée est simplement copiée.

Lorsqu’on appelle la fonction statistique, il ne faut pas lui passer des variables standard, mais bien des adresses. C’est pourquoi on utilise l’opérateur &.

Exemple de passage d’arguments par valeur et par référence:

void passage_valeur(int a) {
  a = 5;
}

void passage_reference(int *b) {
  *b = 5;
}

int main(int argc, char **argv) {
  int c = 0;

  passage_valeur(c);

  passage_reference(&c);

  return 0;
}
//Lorsqu'on appelle passage_valeur(c), la valeur de c ne sera pas modifée, alors qu'après l'appel de passage_reference(&c), c sera égal à 5.

#include 
#include 

using namespace std;

void affiche(int *T, int n) {
  for (int i=0; i<n; i++)
    cout << T[i] << " ";
  cout << endl;
}

int *alloue_tab(int n) {
  return new int[n];
}

void statistique(int *T, int taille, int *min, int *max, float *moyenne) {
  *moyenne = T[0];
  *min = T[0];
  *max = T[0];
  for (int i=1; i<taille; i++) {
    (*moyenne) += T[i];
    if (T[i] > *max)
      *max = T[i];
    if (T[i] < *min)
      *min = T[i];
  }
  (*moyenne) /= taille;
}

int main(int argc, char **argv) {
  srand(time(0));

  int T[10];

  affiche(T, 10);

  int *T2 = new int[8];

  affiche(T2, 8);

  int *T3 = alloue_tab(12);

  for (int i=0; i<12; i++)
    T3[i] = rand() % 100;

  affiche(T3, 12);

  int min, max;
  float moyenne;
  statistique(T3, 12, &min, &max, &moyenne);

  cout << "Min: " << min << ", max: " << max << ", moyenne: " << moyenne << endl;

  delete [] T2;

  delete [] T3;

  return 0;
}

Exercice langage C

Cours gratuit, Cours informatique, Télécharger cours, Exercice gratuit, Exercice langage C

[/tab][end_tabset skin= »lightness » ]