Discussion :

[kaoula ch]

Réécrire ce programme en utilisant au plus les
nouvelles possibilités du C++. Réécrire la fonction sum sans utiliser l'opérateur [].

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
26
#define MAX 10
typedef struct Duree {
unsigned int h;
unsigned int m;
} Duree;
Duree 
sum(Duree* x, int n){
int i;
unsigned int somme_h=0, somme_m=0;
Duree d;
for(i=0; i<n; i++) {
somme_h+=x[i].h;
somme_m+=x[i].m;
}
somme_h+=somme_m/60;
somme_m%=60;
d.h=somme_h;
d.m=somme_m;
return d;
}
void exercice3(){
Duree d;
Duree tab[MAX];
d=sum
(tab,5);
}

[Ehonn]

Bonjour

À priori, il faudrait utiliser l'arithmétique des pointeurs.
(En C++, on préfère utiliser std::array, std::vector et les algorithmes de la bibliothèque standard.)

[ternel]

Bonjour kaoula ch
A part recopier l'énoncé de ton exercice, pourrais-tu nous parler? Nous sommes des gens.

Je t'invite à relire notre charte, que tu as acceptée en t'inscrivant. Notamment, l'article IV-N.

Nous voulons bien t'aider à résoudre ton problème, mais quel est-il précisément?
Que n'arrives-tu à faire?


Je t'invite à relire ton cours, ou une documentation du langage.

[koala01]

Salut,

Si, vraiment, l'idée est d'utiliser au mieux les possibilités du C++, je te conseillerais déjà de réécrire ta structure Durée, car la syntaxe que tu as utilisée est spécifique au C : en C++, le simple fait de définir un type défini par l'utilisation (class, struct, union, enum) suffit à faire connaitre le type en question par le compilateur : il n'y a donc plus besoin de ce fameux typedef struct {} nomAlias;.

tu en profiterais sans doute pour rajouter l'opérateur += comme donnée membre de ta structure, histoire de pouvoir écrire un code proche de duree1+=duree2; // duree1 représente maintenant la somme de duree1 + duree2Cet opérateur n'est sans doute pas indispensable en lui-même, mais cela te permettra de "retomber" sur une implémentation classique de l'opérateur + (sans affectation).
Au final, ta structure Duree et les deux opérateurs dont je vient de parler pourraient ressembler à quelque chose comme

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
 
struct Duree{
    unsigned int h;   //NOTA: size_t aurait été sympa ici
    unsigned int m; // IDEM
    Duree & operator +=(Duree const & other){
        h+=other.h;
        m+= other.m; 
        if(m > 60){   //a priori, on n'arrivera jamais au delà de 120... à moins qu'on ait déjà fait une connerie en définissant une des deux durées
            ++h;
            m-=60;
        }
    }
};
Duree operator = (Duree const & a, Duree const & b){ //oui, je sais, a pourrait être transmis par valeur
    duree tmp{a}; // merci au compilateur de nous fournir un constructeur de copie sans qu'on ne lui demande rien
    tmp+=b;
    return tmp;
 
}

Une fois que ce sera fait, ce qui te fera vraiment passer à du C++, c'est d'utiliser les collections "qui vont bien", comme, par exemple, la classe std::vector qui est accessible par simple incluson du fichier d'en-tête <vector>.

C'est une classe permettant de maintenir "n'importe quel nombre" d'éléments (dont le type est clairement défini) de manière contigüe en mémoire, un peu à l'instar de ton tab[MAX], mais avec la limite arbiraire de MAX en moins, et qui a, en plus, le bon gout de connaitre en permanence le nombre d'éléments qu'elle contient (en plus de s'occuper de gérer la mémoire nécessaire à au maintien de tous ses éléments de manière transparente pour toi).

Cela te permettra en outre de virer cet odieux define MAX qui, non seulement ne rime à rien (il ne faut jamais placer de limites arbitraires), mais dont, en plus, la limite serait bien mieux définie sous la forme d'une énumération ou, mieux encore, sous la forme d'une constante globale constexpr.

On en profiterait pour introduire les range based loops, qui sont apparues avec C++11, si bien que, dans un premier temps, ta fonction somme pourrait ressembler à

Code :

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

1
2
3
4
5
6
7
Duree somme(std::vector<Duree> const & tab){
    Duree temp{0,0};
    for(auto const & it : tab){
        temp+=it;
    }
    return it;
}

Mais il y aurait encore mieux à faire, car la somme de plusieurs éléments est un algorithme tellement utilisé qu'il est directement fourni par la bibliothèque standard. Nous pourrions donc remplacer notre boucle par l'utilisation de cet algorithme et donner à notre fonction la forme de

Code :

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

1
2
3
4
Duree somme(std::vector<Duree> const & tab){
    Duree temp{0,0};
    return std::accumulate(tab.begin(),tab.end(),temp);
}

Et quand tu en sera venu là, tu pourras dire que ta fonction utilise effectivement les possibilités du C++

NOTA: on pourrait, d'ailleurs, encore aller "un cran plus loin" en définissant cette fonction sous la forme d'une fonction template, histoire qu'elle puisse s'adapter au différents conteneurs proposés par la bibliothèque standard... Mais je vais déjà te laisser assimiler tout cela avant d'aller plus loin