ENIB LANG-C Ex_0702 - Structure de données maintenant une ressource

{1} Première variante

D'une part, il faut déclarer et définir dans les fichiers complexTypes.h et complexTypes.c :

un type DataSet matérialisé par une structure composée d'un membre count de type entier et d'un membre data de type pointeur sur réel,
(à terme, data servira à désigner un très grand tableau de count réels alloué dynamiquement)

une fonction DataSet_create()

qui reçoit en paramètre un entier count,

dont le rôle est de renvoyer une structure de type DataSet initialisée avec count et la variable data renseignée de cette façon :

double *data=(double *)malloc(count*sizeof(double));
if(data==NULL)
{
  abort();
}
srand((unsigned int)(size_t)&count); // rely on ASLR for randomisation
for(int i=0; i<count; ++i)
{
  data[i]=0.01*(rand()%100);
}

une fonction DataSet_destroy()
- qui reçoit en paramètre une structure de type DataSet transmise par pointeur,
- dont le rôle est de libérer le tableau dynamique data de cette structure du contexte appelant et de réinitialiser ses membres à 0 et NULL,
une fonction DataSet_mean()
- qui reçoit en paramètre une structure de type DataSet transmise par pointeur,
- dont le rôle est de renvoyer la moyenne (un réel) des valeurs mémorisées dans la structure,
  (le calcul se résume à la somme des count éléments du tableau dynamique data, divisée par ce nombre d'éléments)
une fonction DataSet_scale()
- qui reçoit en paramètres une structure de type Dataset transmise par pointeur et un réel factor,
- dont le rôle est de multiplier par factor les count éléments du tableau dynamique data de la structure.

Le pointeur utilisé pour passer le paramètre qui désigne une structure devra montrer clairement l'intention de modifier ou consulter la structure en question.

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

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

qui sera appelée depuis la fonction main().
Elle doit être complétée en créant une structure DataSet initialisée avec la fonction DataSet_create() de façon à maintenir plusieurs milliers de valeurs.
Il faudra afficher le résultat de la fonction DataSet_mean() avant et après l'usage de la fonction DataSet_scale() sur cette structure afin d'en constater l'effet.
La fonction DataSet_destroy() assurera qu'aucune fuite mémoire n'ait lieu.

{2} Deuxième variante

D'une part, il faut déclarer et définir dans les fichiers complexTypes.h et complexTypes.c :

un type Gene matérialisé par une structure composée d'un membre length de type entier et d'un membre nucleotides de type pointeur sur caractères,
(à terme, nucleotides servira à désigner un très grand tableau de length lettres alloué dynamiquement✍
Il n'a pas vocation à servir de chaîne de caractères pour représenter un texte.
Nous le considérerons comme une longue séquence de lettres isolées ; il n'y a donc pas de '\0' terminal.
)

une fonction Gene_create()

qui reçoit en paramètre un entier length,

dont le rôle est de renvoyer une structure de type Gene initialisée avec length et la variable nucleotides renseignée de cette façon :

char *nucleotides=(char *)malloc(length*sizeof(char));
if(nucleotides==NULL)
{
  abort();
}
const char *AGCT="AGCT";
srand((unsigned int)(size_t)&length); // rely on ASLR for randomisation
for(int i=0; i<length; ++i)
{
  nucleotides[i]=AGCT[rand()%4];
}

une fonction Gene_destroy()
- qui reçoit en paramètre une structure de type Gene transmise par pointeur,
- dont le rôle est de libérer le tableau dynamique nucleotides de cette structure du contexte appelant et de réinitialiser ses membres à 0 et NULL,
une fonction Gene_dnaToRna()
- qui reçoit en paramètre une structure de type Gene transmise par pointeur,
- dont le rôle est de remplacer par la lettre 'U' chaque lettre 'T' parmi les length lettres mémorisées dans le tableau dynamique nucleotides de la structure,
une fonction Gene_count()
- qui reçoit en paramètres une structure de type Gene transmise par pointeur et un caractère nucleotide,
- dont le rôle est de renvoyer le nombre des lettres mémorisées dans la structure qui sont égales au paramètre nucleotide.
  (le calcul se résume à la visite des length éléments du tableau dynamique nucleotides en incrémentant un compteur à chaque correspondance trouvée)

Le pointeur utilisé pour passer le paramètre qui désigne une structure devra montrer clairement l'intention de modifier ou consulter la structure en question.

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

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

qui sera appelée depuis la fonction main().
Elle doit être complétée en créant une structure Gene initialisée avec la fonction Gene_create() de façon à maintenir plusieurs milliers de lettres (nucléotides).
Il faudra afficher le résultat de la fonction Gene_count() pour les lettres 'T' et 'U' avant et après l'usage de la fonction Gene_dnaToRna() sur cette structure afin d'en constater l'effet.
La fonction Gene_destroy() assurera qu'aucune fuite mémoire n'ait lieu.

{3} Troisième variante

D'une part, il faut déclarer et définir dans les fichiers complexTypes.h et complexTypes.c :

un type UserBase matérialisé par une structure composée d'un membre size de type entier et d'un membre identifiers de type pointeur sur entier,
(à terme, identifiers servira à désigner un très grand tableau de size entiers alloué dynamiquement)

une fonction UserBase_create()

qui reçoit en paramètre un entier size,

dont le rôle est de renvoyer une structure de type UserBase initialisée avec size et la variable identifiers renseignée de cette façon :

int *identifiers=(int *)malloc(size*sizeof(int));
if(identifiers==NULL)
{
  abort();
}
srand((unsigned int)(size_t)&size); // rely on ASLR for randomisation
for(int i=0; i<size; ++i)
{
  identifiers[i]=rand()%1000;
}

une fonction UserBase_destroy()
- qui reçoit en paramètre une structure de type UserBase transmise par pointeur,
- dont le rôle est de libérer le tableau dynamique identifiers de cette structure du contexte appelant et de réinitialiser ses membres à 0 et NULL,
une fonction UserBase_privileged()
- qui reçoit en paramètre une structure de type UserBase transmise par pointeur,
- dont le rôle est de renvoyer le nombre (un entier) d'identifiants mémorisés dans la structure dont la valeur est comprise entre 0 (inclus) et 100 (exclus),
  (le calcul se résume à la visite des size éléments du tableau dynamique identifiers en incrémentant un compteur à chaque fois qu'un élément répond au critère)
une fonction UserBase_revoque()
- qui reçoit en paramètres une structure de type UserBase transmise par pointeur,
- dont le rôle est de remplacer par -1 chaque identifiant mémorisé dans la structure dont la valeur est inférieure (strictement) à 100.

Le pointeur utilisé pour passer le paramètre qui désigne une structure devra montrer clairement l'intention de modifier ou consulter la structure en question.

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

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

qui sera appelée depuis la fonction main().
Elle doit être complétée en créant une structure UserBase initialisée avec la fonction UserBase_create() de façon à maintenir plusieurs milliers d'identifiants.
Il faudra afficher le résultat de la fonction UserBase_privileged() avant et après l'usage de la fonction UserBase_revoque() sur cette structure afin d'en constater l'effet.
La fonction UserBase_destroy() assurera qu'aucune fuite mémoire n'ait lieu.

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 complexTypes.h✎

Fichier complexTypes.c✎

Contenu du fichier complexTypes.c

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

#include "complexTypes.h"

#include <stdlib.h>

DataSet
DataSet_create(int count)
{
  double *data=(double *)malloc(count*sizeof(double));
  if(data==NULL)
  {
    abort();
  }
  srand((unsigned int)(size_t)&count); // rely on ASLR for randomisation
  for(int i=0; i<count; ++i)
  {
    data[i]=0.01*(rand()%100);
  }
  DataSet ds={count, data};
  return ds;
}

void
DataSet_destroy(DataSet *ds)
{
  free(ds->data);
  ds->count=0;
  ds->data=NULL;
}

double
DataSet_mean(const DataSet *ds)
{
  double sum=0.0;
  const int count=ds->count;
  const double *data=ds->data;
  for(int i=0; i<count; ++i)
  {
    sum+=data[i];
  }
  return sum/count;
}

void
DataSet_scale(DataSet *ds,
              double factor)
{
  const int count=ds->count;
  double *data=ds->data;
  for(int i=0; i<count; ++i)
  {
    data[i]*=factor;
  }
}

Gene
Gene_create(int length)
{
  char *nucleotides=(char *)malloc(length*sizeof(char));
  if(nucleotides==NULL)
  {
    abort();
  }
  const char *AGCT="AGCT";
  srand((unsigned int)(size_t)&length); // rely on ASLR for randomisation
  for(int i=0; i<length; ++i)
  {
    nucleotides[i]=AGCT[rand()%4];
  }
  Gene g={length, nucleotides};
  return g;
}

void
Gene_destroy(Gene *g)
{
  free(g->nucleotides);
  g->length=0;
  g->nucleotides=NULL;
}

void
Gene_dnaToRna(Gene *g)
{
  const int length=g->length;
  char *nucleotides=g->nucleotides;
  for(int i=0; i<length; ++i)
  {
    if(nucleotides[i]=='T')
    {
      nucleotides[i]='U';
    }
  }
}

int
Gene_count(const Gene *g,
           char nucleotide)
{
  int count=0;
  const int length=g->length;
  const char *nucleotides=g->nucleotides;
  for(int i=0; i<length; ++i)
  {
    if(nucleotides[i]==nucleotide)
    {
      ++count;
    }
  }
  return count;
}

UserBase
UserBase_create(int size)
{
  int *identifiers=(int *)malloc(size*sizeof(int));
  if(identifiers==NULL)
  {
    abort();
  }
  srand((unsigned int)(size_t)&size); // rely on ASLR for randomisation
  for(int i=0; i<size; ++i)
  {
    identifiers[i]=rand()%1000;
  }
  UserBase ub={size, identifiers};
  return ub;
}

void
UserBase_destroy(UserBase *ub)
{
  free(ub->identifiers);
  ub->size=0;
  ub->identifiers=NULL;
}

void
UserBase_revoque(UserBase *ub)
{
  const int size=ub->size;
  int *identifiers=ub->identifiers;
  for(int i=0; i<size; ++i)
  {
    if(identifiers[i]<100)
    {
      identifiers[i]=-1;
    }
  }
}

int
UserBase_privileged(const UserBase *ub)
{
  int count=0;
  const int size=ub->size;
  const int *identifiers=ub->identifiers;
  for(int i=0; i<size; ++i)
  {
    const int id=identifiers[i];
    if((id>=0)&&(id<100))
    {
      ++count;
    }
  }
  return count;
}

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

Fichier prog_ex0702.c✎