C++: Correction Forme géométrique en C et C++

 

Interface C pour les formes

Le fichier entête


#ifndef _FORMES_H_
#define _FORMES_H_

typedef enum { _carre_, _rectangle_ } type_fg;

typedef struct _carre {
  int x, y, cote;
} carre;

typedef struct _rectangle {
  int x, y, longueur, largeur;  
} rectangle;

typedef struct _forme {
  type_fg tfg;
  void * geo;
} forme;

#endif

La mise en œuvre


#include "formes.h"

void carre_creer(carre * self, int x, int y, int cote)
{
  self->x = x;
  self->y = y;
  self->cote = cote;
}

void carre_detruire(carre * self)
{
}

void carre_modifier(carre * self, int x, int y, int cote)
{
  self->x = x;
  self->y = y;
  self->cote = cote;
}

void carre_recup(carre * self, int * x, int * y, int * cote)
{
  *x = self->x;
  *y = self->y;
  *cote = self->cote;
}

void carre_afficher(carre * self)
{
  printf("CARRE(%d,%d,%d)", self->x, self->y, self->cote);
}

void carre_copier(carre * self, carre * a_copier)
{
  self->x = a_copier->x;
  self->y = a_copier->y;
  self->cote = a_copier->cote;
}

#ifdef TEST
main(int argc, char argv[])
{
  int x, y, cote;
  carre c;
  carre cptr = malloc(sizeof(carre));

  carre_creer(&c, 2, 4, 5);
  carre_creer(cptr, 1, 1, 7);

  carre_afficher(&c);
  carre_afficher(cptr);
  printf("\n");
  
  carre_modifier(&c, 3, 3, 4);
  carre_copier(cptr, &c);
  carre_afficher(&c);
  carre_afficher(cptr);
  printf("\n");
  
  carre_recup(&c, &x, &y, &cote);
  printf("Valeur récupérées : %d, %d, %d\n", x, y, cote);

  carre_detruire(&c);
  carre_detruire(cptr);
  free(cptr);
}
#endif

 

Interface C++ pour le tableau de formes

Le fichier entête


#ifndef _COLFORMES_H_
#define _COLFORMES_H_

class ColFormes {
  public:
    ColFormes();
    ~ColFormes();
    void ajouter(const forme *);
    void ajouter_carre(int x, int y, int cote);
    void ajouter_rectangle(int x, int y, int long, int larg);
    int recuperer_les_carres(const carre ** liste_dyn) const;
    const forme * recuperer(int pos) const;
    int combien() const;
    void afficher() const;
  private:
    ColFormes(const ColFormes & a_copier) { }
    void & operator = (const ColFormes & a_copier) { }
    int nb;
    forme * col;
};

#endif

La mise en œuvre


#include <assert.h>
#include "ColFormes.h"

ColFormes::
ColFormes()
{
  col = 0;
  nb = 0;
}

ColFormes::
~ColFormes()
{
  for (size_t n = 0; n < nb; n++) {
    forme_detruire(&col[n]);
  }
  delete col;
}

void ColFormes::
ajouter(const forme * f)
{
  forme * old = col;
  col = new forme [nb + 1];
  for (size_t n = 0; n < nb; n++) {
    forme_copier(&col[n], &old[n]);
  }
  forme_copier(&col[n], f);
  nb++;
}

void ColFormes::
ajouter_carre(int x, int y, int cote)
{
  carre c;
  forme f;
  carre_creer(&c, x, y, cote);
  forme_creer(&f, _carre_, &c);
  ajouter(&f);
  forme_detruire(&f);
  carre_detruire(&c);
}

void ColFormes::
ajouter_rectangle(int x, int y, int longu, int larg)
{
  rectangle r;
  forme f;
  rectangle_creer(&r, x, y, longu, larg);
  forme_creer(&f, _rectangle_, &r);
  ajouter(&f);
  forme_detruire(&f);
  rectangle_detruire(&f);
}

int ColFormes::
recuperer_les_carres(const carre ** liste_dyn) const
{
  int res = 0;
  // on compte d'abord le nombre de carres
  for (int n = 0; n < nb; n++) {
    if (col[n].tfg == _carre_) {
      res++;
    }
  }
  // on alloue la liste resultat
  *liste_dyn = new carre[res];

  // on remplie ensuite la liste
  int noc = 0;
  for (int n = 0; n < nb; n++) {
    if (col[n].tfg == _carre_) {
      carre_copier(&(*liste_dyn[noc]), col[n].geo);
      noc++;
    }
  }
  return res;
}

const forme * ColFormes::
recuperer(int pos) const
{
  assert(pos < nb);
  return &(col[pos]);
}

int ColFormes::
combien() const
{
  return nb;
}

void ColFormes::
afficher() const
{
  for (int n = 0; n < nb; n++) {
    forme_afficher(&(col[n]));
  }
}