surcharger l'opérateur [ ]

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:

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:

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:

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

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:

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 } }

désoler mais il ne marche pas

http://www.developpez.net/forums/m1298902-7/

sa marche mais je l'ai simplifier, il est en 4lignes maintenant merci quand même

Citation:

Envoyé par waldner77

sa marche mais je l'ai simplifier, il est en 4lignes maintenant merci quand même

A titre d'information, peux-tu nous montrer comment tu as fait ?

Code:

1
2
3
4
5
6
double& operator [](int index){
       while ( nbElem <= index) Ajoute(0);
       pElem p= prem;
       while ( index--) p = p->suiv;
       return p->note;
}