ENIB LANG-C Ex_0601 - Allocation dynamique de mémoire

{1} Première variante

D'une part, il faut déclarer et définir dans les fichiers sequence.h et sequence.c une fonction arithmeticSequence() ayant les caractéristiques suivantes :

elle attend trois paramètres count, initValue et increment de type entier,
elle fournit en résultat un tableau d'entiers alloué dynamiquement,
elle doit réclamer ce tableau dynamique pour qu'il contienne count éléments de type entier,
elle doit en initialiser le contenu de façon à ce qu'il représente une suite arithmétique de premier terme initValue et de raison increment✍
Le premier élément vaut initValue.
Le second élément vaut initValue+increment.
Le troisième élément vaut initValue+2*increment.
Le quatrième élément vaut initValue+3*increment...
.

D'autre part, il faut réaliser, dans le fichier prog_ex0601.c, cette fonction :

void
test_arithmeticSequence(void)
{
  printf("\n~~~~ %s() ~~~~\n", __func__);
  // ...
}

qui sera appelée depuis la fonction main().
Elle doit être complétée en faisant usage de la fonction arithmeticSequence() pour obtenir un tableau dynamique de taille raisonnable et en affichant explicitement chacun des éléments du tableau ainsi obtenu.
Aucune fuite mémoire ne doit avoir lieu.

{2} Deuxième variante

D'une part, il faut déclarer et définir dans les fichiers sequence.h et sequence.c une fonction geometricSequence() ayant les caractéristiques suivantes :

elle attend un paramètre count de type entier et deux paramètres initValue et factor de type réel,
elle fournit en résultat un tableau de réels alloué dynamiquement,
elle doit réclamer ce tableau dynamique pour qu'il contienne count éléments de type réel,
elle doit en initialiser le contenu de façon à ce qu'il représente une suite géométrique de premier terme initValue et de raison factor✍
Le premier élément vaut initValue.
Le second élément vaut le premier multiplié par factor.
Le troisième élément vaut le second multiplié par factor.
Le quatrième élément vaut le troisième multiplié par factor...
.

D'autre part, il faut réaliser, dans le fichier prog_ex0601.c, cette fonction :

void
test_geometricSequence(void)
{
  printf("\n~~~~ %s() ~~~~\n", __func__);
  // ...
}

qui sera appelée depuis la fonction main().
Elle doit être complétée en faisant usage de la fonction geometricSequence() pour obtenir un tableau dynamique de taille raisonnable et en affichant explicitement chacun des éléments du tableau ainsi obtenu.
Aucune fuite mémoire ne doit avoir lieu.

{3} Troisième variante

D'une part, il faut déclarer et définir dans les fichiers sequence.h et sequence.c une fonction asciiSequence() ayant les caractéristiques suivantes :

elle attend un paramètre count de type entier et un paramètre firstCode de type entier,
elle fournit en résultat un tableau de caractères alloué dynamiquement,
elle doit réclamer ce tableau dynamique pour qu'il contienne count éléments de type caractère✍
Il n'a pas vocation à servir de chaîne de caractères pour représenter un texte.
Nous le considérerons comme une séquence de caractères ASCII isolés ; il n'y a donc pas besoin de '\0' terminal.
,
elle doit en initialiser le contenu de façon à ce qu'il représente une séquence de count caractères de la table ASCII à partir de firstCode✍
Par exemple :
- si firstCode vaut 65 et count vaut 26, alors cette séquence sera 'A', 'B', 'C'... 'X', 'Y', 'Z',
- si firstCode vaut 97 et count vaut 26, alors cette séquence sera 'a', 'b', 'c'... 'x', 'y', 'z',
- si firstCode vaut 48 et count vaut 10, alors cette séquence sera '0', '1', '2'... '7', '8', '9'.
Le passage du code ASCII (un entier) vers un caractère n'est qu'une simple conversion explicite (un cast).
.

D'autre part, il faut réaliser, dans le fichier prog_ex0601.c, cette fonction :

void
test_asciiSequence(void)
{
  printf("\n~~~~ %s() ~~~~\n", __func__);
  // ...
}

qui sera appelée depuis la fonction main().
Elle doit être complétée en faisant usage de la fonction asciiSequence() pour obtenir un tableau dynamique de taille raisonnable et en affichant explicitement chacun des éléments du tableau ainsi obtenu.
Aucune fuite mémoire ne doit avoir lieu.

Les règles de mise en œuvre et d'écriture recommandées dans toutes nos réalisations doivent impérativement être respectées.
(#ifndef..., fichiers d'en-tête, programmation modulaire...)
Seule la fonction de test produit des affichages (la fonctionnalité testée rend son service silencieusement) ; un examen attentif des affichages produits doit permettre de vérifier le bon fonctionnement de la fonctionnalité testée.
L'allocation dynamique de mémoire et les précautions pour éviter les fuites de mémoire constituent l'essentiel de l'exercice ; il n'est pas question de recourir à une formulation alternative qui produirait malgré tout un résultat équivalent.

Code source résultant

Si vous suivez scrupuleusement les énoncés et les consignes, vous devez obtenir des fichiers de code source semblables à ceux-ci :

Fichier sequence.h✎

Contenu du fichier sequence.h

//----------------------------------------------------------------------------

#ifndef SEQUENCE_H
#define SEQUENCE_H

int *
arithmeticSequence(int count,
                   int initValue,
                   int increment);

double *
geometricSequence(int count,
                  double initValue,
                  double factor);

char *
asciiSequence(int count,
              int firstCode);

#endif // SEQUENCE_H

//----------------------------------------------------------------------------

Fichier sequence.c✎

Contenu du fichier sequence.c

//----------------------------------------------------------------------------

#include "sequence.h"

#include <stdlib.h>

int *
arithmeticSequence(int count,
                   int initValue,
                   int increment)
{
  int *values=(int *)malloc(count*sizeof(int));
  if(values==NULL)
  {
    abort();
  }
  for(int i=0; i<count; ++i)
  {
    values[i]=initValue+i*increment;
  }
  return values;
}

double *
geometricSequence(int count,
                  double initValue,
                  double factor)
{
  double *values=(double *)malloc(count*sizeof(double));
  if(values==NULL)
  {
    abort();
  }
  double value=initValue;
  for(int i=0; i<count; ++i)
  {
    values[i]=value;
    value*=factor;
  }
  return values;
}

char *
asciiSequence(int count,
              int firstCode)
{
  char *values=(char *)malloc(count*sizeof(char));
  if(values==NULL)
  {
    abort();
  }
  for(int i=0; i<count; ++i)
  {
    values[i]=(char)(firstCode+i);
  }
  return values;
}

//----------------------------------------------------------------------------

Fichier prog_ex0601.c✎

Contenu du fichier prog_ex0601.c

//----------------------------------------------------------------------------

#include "sequence.h"

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

void
test_arithmeticSequence(void)
{
  printf("\n~~~~ %s() ~~~~\n", __func__);
  const int count=16;
  int *seq=arithmeticSequence(count, 50, 2);
  for(int i=0; i<count; ++i)
  {
    printf(" %d", seq[i]);
  }
  printf("\n");
  free(seq);
}

void
test_geometricSequence(void)
{
  printf("\n~~~~ %s() ~~~~\n", __func__);
  const int count=8;
  double *seq=geometricSequence(count, 2.0, 1.5);
  for(int i=0; i<count; ++i)
  {
    printf(" %g", seq[i]);
  }
  printf("\n");
  free(seq);
}

void
test_asciiSequence(void)
{
  printf("\n~~~~ %s() ~~~~\n", __func__);
  const int count=26;
  char *seq=asciiSequence(count, 65);
  for(int i=0; i<count; ++i)
  {
    printf(" %c", seq[i]);
  }
  printf("\n");
  free(seq);
}

int
main(void)
{
  test_arithmeticSequence();
  test_geometricSequence();
  test_asciiSequence();
  return 0;
}

//----------------------------------------------------------------------------