surcharger l'opérateur [ ]

**waldner77** · 16/10/2009, 18h02

bonjour,
je suis débutant mais de chez débutant en c++.
voila je suis entrain de réaliser un Modèle de base de la classe CNotes.
Mon but de ce programme est de m'afficher ceci:
math : 2 notes, moy. = 11
physique : 3 notes, moy. = 10
anglais : 3 notes, moy. = 13
francais : 3 notes, moy. = 8.66667

voici mes codes:
Cnotes.cpp

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
27
28
29
30
31
32
33
34
 
#include "cnotes.h"
CNotes::~CNotes()
{
      pElem p = prem ;
      while ( prem != NULL ) {
            p = p->suiv ; delete prem ; prem = p ;
      }
      prem = dern = NULL ;
      nbElem = 0 ;
}
void CNotes::Ajoute(double v )
{
      pElem p = new CElem ; //pointeur de maillon
      p->note = v ; p->suiv = NULL ;
      if ( prem == NULL )     prem = dern = p ;
      else {
            dern->suiv = p ; dern = dern->suiv ;
      }
      nbElem++ ;
}
 
double CNotes::Moyenne() const
{
        int i;
        pElem p = prem;
        double total;
        for (i = 0; i < nbNotes() ;i++){
                total += p ->note;
                p = p -> suiv;
 
        }
        return total/nbElem ;
}

Cnotes.h

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
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
 
#ifndef CNOTES_H
#define CNOTES_H
#include <iostream>
#include <string>
 
 
using namespace std ;            
 
class CElem ;
 
typedef CElem* pElem ;
class CElem {
  public :
      double note ;
      pElem suiv ;
} ;
class CNotes {
      pElem prem , dern ;
      int         nbElem ;
  public :
      CNotes(double n = -1 )
            : prem(NULL) , dern(NULL) , nbElem(0) {
            if ( n != -1 )    Ajoute(n) ;
      }
      ~CNotes() ;
      int nbNotes() const { return nbElem ; }
      void Ajoute(double v ) ;
      double Moyenne() const ;
      CNotes& operator += (double c) {
 
		Ajoute(c);
 
		return *this;
 
	}
      CNotes& operator [] (int T){
 
 
      }
 
} ;
#endif

main.cpp

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
27
28
29
30
31
32
 
#include <iostream>
#include <string>
#include "cnotes.h"
void affiche(const string& m, const CNotes& c )
{
      cout << m << " : " << c.nbNotes() << " note" ;
      if ( c.nbNotes() > 1 ) cout << 's' ;
      cout << ", moy. = " << c.Moyenne() << endl ;
}
int main(void)
{
      CNotes math ;                     // constructeur par défaut
      CNotes physique(7) ;             // constructeur avec argument
      CNotes francais(12) ;
      CNotes anglais ;
 
      math.Ajoute(12) ;                // méthode Ajoute()
      math.Ajoute(10) ;
      physique += 13 ;                 // opérateur += avec arg. double
      physique += 10 ;
      anglais[0] = 11 ;                // opérateur d'accès direct []
      anglais[1] = 15 ;
      anglais = anglais + 13 ;         // opérateur + avec arg. double
                                              // op. = sur même objet CNotes
      francais[2] = 14 ;               // devoir d'indice 1 non rendu !
 
      affiche("math     ", math ) ;
      affiche("physique", physique ) ;
      affiche("anglais ", anglais ) ;
      affiche("francais", francais ) ;
}

mon problème c'est que je ne c'est pas comment faire pour Surcharger l'opérateur [ ] de manière à proposer un accès direct en lecture et en écriture sur une
note de la liste. Si l'indice demandé est incorrect, la méthode doit créer les maillons manquants avec des notes nulles... .

bonne journée a vous

**bacelar** · 16/10/2009, 22h37

Vous utilisez déjà la STL, donc utilisez ses contnairs qui implémentent eux l'opérateur [] comme vector.
http://www.cplusplus.com/reference/stl/vector/

Pour les maillons manquant vous n'aurait qu'à faire des "push_back(0)".

P.S.: même sans la STL, je ne vois pas le problème. Vous utilisez une variable qui s'incrémente à chaque indirection "suiv", vous n'avez qu'à la comparer :
à l'arrache. Avec un constructeur de note qui prend un double

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
 
CElem& operator [] (int index){
    if(index>=0)
    {
        pElem p = prem;
        for(int i = 0 ; i<index; i++)
        {
            if(p == NULL)
            {
                p = new CElem;
                p->note = 0 ; p->suiv = NULL ;
            }
            p = p->suiv;
        }
        return CElem(p.note);
    }
    else
    {
    //thrower une exeption
    }
}