Discussion :

[monsrhf]

Bonsoir,
je travaille sur un exercice c++, que je n'ai pas pu résoudre, qui demande de concevoir une classe qui manipule des ensembles d'entiers allouées dynamiquement dans un tableau. le livre où je travail propose comme solution à l'exercice veuillez voir ci-dessous.
ma question svp c'est l'explication du comportement des méthodes ajoute() et appartient()
merci

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
/* fichier SETINT1.H */
/* déclaration de la classe set_int */
class set_int
{
int * adval ; // adresse du tableau des valeurs
int nmax ; // nombre maxi d'éléments
int nelem ; // nombre courant d'éléments
public :
set_int (int = 20) ; // constructeur
~set_int () ; // destructeur
void ajoute (int) ; // ajout d'un élément
int appartient (int) ; // appartenance d'un élément
int cardinal () ; // cardinal de l'ensemble
} ;

Voici la définition de notre classe :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
#include "setint1.h"
set_int::set_int (int dim)
{ adval = new int [nmax = dim] ; // allocation tableau de valeurs
nelem = 0 ;
}
set_int::~set_int ()
{ delete adval ; // libération tableau de valeurs
}
void set_int::ajoute (int nb)
{ // on examine si nb appartient déjà à l'ensemble
// en utilisant la fonction membre appartient
// s'il n'y appartient pas et si l'ensemble n'est pas plein
// on l'ajoute
if (!appartient (nb) && (nelem<nmax)) adval [nelem++] = nb ;
}
int set_int::appartient (int nb)
{ int i=0 ;
// on examine si nb appartient déjà à l'ensemble
// (si ce n'est pas le cas, i vaudra nele en fin de boucle)
while ( (i<nelem) && (adval[i] != nb) ) i++ ;
return (i<nelem) ;
}
int set_int::cardinal ()
{ return nelem ;
}

[foetus]

Le code ne fonctionne pas en l'état

• Comment est-initialisé l'attribut nmax ? (Édit : voir ci-dessous)
• Dans le destructeur c'est delete[] puisqu'on désalloue un tableau

Sinon pour tes questions, il y a une tartine de commentaires en français qui explique bien.
D'ailleurs le prof a fait du code très concis avec lequel il faut être un chouïa attentif

Édit : La méthode set_int::ajoute est mal faite :

• Il faut déjà faire le test des bornes avant de lancer le parcours de la collection pour tester l'appartenance.
• Il faut retourner un état, parce que si la collection est pleine ou si l'élément est déjà présent, la méthode ne fait rien mais cela on ne le sait pas

[Bousk]

Comment est-initialisé l'attribut nmax ?

D'une manière peu conventionnelle et un peu caché mais il est initialisé adval = new int [nmax = dim] ..

Avec la tonne de commentaires, que ne comprends-tu pas ? Ce que fait ta fonction ajoute est over-détaillée dans son implémentation
Sinon pour utiliser un set, il existe std::set. Et si tu veux une collection d'un set avec un nombre d'élément maximum, tu peux très bien composer un vrai set dans ta classe au lieu d'utiliser de l'allocation dynamique.
Ca manque de const-correctness, le code est pas du tout aéré et très peu lisible et en C++ on a inventé le type bool.

[foetus]

D'une manière peu conventionnelle et un peu caché mais il est initialisé adval = new int [nmax = dim]

Ce trouage, j'avais vu un signe moins

C'est ce que j'appelle la persistance métier : à force de voir tout le temps les mêmes choses, à un moment on les voie de façon inconsciente.

[monsrhf]

Ce que je n'ai pas compris c'est cet écriture : while ( (i<nelem) && (adval[i] != nb) ) i++ ; return (i<nelem) ;
nelem est initialisé à 0 alors pourquoi écrire i<nelem et je n'ai pas compris compris ce que fait cette boucle while. En plus je ne suis pas habitué à voir cette return (i<nelem).
merci de prendre du temps pour m'expliquer. Car je suis un débutant.

[foetus]

nelem est initialisé à 0 alors pourquoi écrire i<nelem

Réfléchis : ici on veut parcourir le tableau pour savoir si l'élément est présent.
L'attribut nelem est le nombre d'éléments que contient le tableau.

C'est un test de bornes. Et en plus en C/ C++ les index commencent à zéro, ce qui est pratique et on met un signe inférieur strict.
Donc c'est un test qui veut dire "tant qu'on est pas arrivé au dernier élément + 1"

Si ton tableau n'a aucun élément, alors le test est faux est on sort de la boucle while tout de suite : c'est logique.

je n'ai pas compris ce que fait cette boucle while.

On peut la remplacer par

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
    int i;
    bool is_found = false;
 
    for(i=0; (!is_found  && (i < nelem)); ++i) {
        if (adval[i] == nb) {
            is_found  = true;
        }
    }
 
    return is_found;

En plus je ne suis pas habitué à voir cette return (i<nelem).

Ici on retourne un booléen (TRUE - FALSE) et c'est pour tester si on a parcouru tout le tableau

C'est logique : Si on a parcouru tout le tableau cela veut forcément dire qu'on n'a pas trouvé l'élément.
Après ici, on retourne TRUE si on a trouvé l'élément (donc si on s'est arrêté avant la fin du tableau)

[monsrhf]

L'attribut nelem est le nombre d'éléments que contient le tableau.

Oui merci j'ai compris tout ça, c'est très claire. Mais "nelem" pour pour quel soit le nombre des éléments effectifs dans le tableau il doit subir un traitement, genre incrémentation ou autre chose. alors l'attribut nelem est initialisé à 0 à la construction de l'objet et point final.
Donc comment dire que "nelem" est le nombre d'élément que contient le tableau ?
merci !!

[foetus]

L'attribut nelem est incrémenté dans la méthode set_int::ajoute avec une post-incrémentation : ce qui est logique
Lorsqu'on ajoute un élément dans le tableau on teste 1) s'il reste de la place dans le tableau 2) si l'élément n'est pas présent
Si les 2 tests sont vrais alors on ajoute l'élément et on incrémente l'attribut nelem.
D'ailleurs, il y a toujours mes 2 remarques sur cette méthode dans mon 1er message ci-dessus


Mais en aucun cas cet attribut ne doit être incrémenté dans la méthode set_int::appartient
Si tu incrémentes ton nombre d'éléments à chaque test d'appartenance, tu flingues ta collection en un rien de temps


J'ai l'impression qu'il te manque de la logique, de l'algorithmie, et de la compréhension syntaxe C++
Essaye de comprendre ce qu'on te demande et déroule les algos "à la main" (ou avec le débogueur) avec plusieurs cas.

[koala01]

Salut,

Une petite remarque en passant... Elle ne s'adresse pas à toi, mais à ton prof (si tu pouvais la lui transmettre, ce serait sympa ) :

C et C++ permettent, grâce à différents sucres syntaxiques, d'écrire du code particulièrement concis. Mais la concision d'un code est souvent inversement proportionnelle à la facilité avec laquelle il sera lu, sans *** forcément *** en améliorer les performances.

Cette concision était nécessaire dans les "vertes années" de l'informatique, car chaque caractère dans un code coutait littéralement la "peau du cul". Mais, à l'heure actuelle, nous ne sommes plus à 100, 1 000 ou même 10 000 caractères dans le code, d'autant plus que la plupart n'apparaitront purement et simplement pas dans le résultat exécutable final.

Ton prof devrais donc essayer de travailler dans un ordre logique, à savoir:

1. faire du code qui fonctionne et qui soit compréhensible par ses élève
2. si, après benchmark, il se rend compte que l'élément est effectivement développé est effectivement plus performant grâce à la concision que permettent les sucres syntaxique (et seulement dans ce cas là), proposer une adaptation du code

Il y aurait bien d'autres remarques à faire sur ces 39 lignes de code. La plupart ont déjà été faites par mes confrères.

Je vais juste en ajouter deux pour enfoncer le clou:

1. les listes d'initialisation dans le constructeur, c'est pas fait pour les chiens;
2. Quid si on essaye de créer une instance de taille ... 0