Discussion :

[b Oo]

Bonjour à tous,
j'ai un petit problème pour redéfinir l'opérateur []. Je vous donne le code qui ne fonctionne pas :

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
 
class B
{
  public :
   B(B**);
   ...
   void getVal() const { return _valeur; }
 
  private:
   int _valeur;
   B ** _p;
};
 
B::B(A * p=0):_valeur(0), _p(p)
{
}

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
 
class A
{
  public :
   A();
   ...
   B * operator[](int i) { return tab[i]; }
 
  private :
   B* tab[81];
};
 
 
A::A()
{
   for (int i = 0; i < 81; ++i)
     tab[i] = new B(tab+i);
}

Code :

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

1
2
3
4
5
6
7
8
9
10
11
 
...
int main()
{
  A a;
  A * pa = &a;
  cout << pa[0] << endl; // pas valide à mon avis
  cout << (*pa)[0] << endl; // valide à mon avis
 
  ...
};

J'aimerais savoir comment définir l'opérateur [] pour que pa[0] soit valide et que a[0] soit valide aussi, si cela est possible.

Edit :
Question reformulée.

Merci d'avance.

b Oo

[Luc Hermitte]

Ce me parait bizarre. De même que

Code :

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

tab[i] = new B(tab[i]);

qui :
- ne devrait pas compiler vu tes déclarations
- t'aurait exposé à la figure vu que la valeur de tab[i] n'est pas déterminée au moment de l'appel (en supposant qu'il y ait un constructeur B(B*)). Cela passerait avec un B(*&), mais comment dire que je te déconseille fortement une telle chose.

[reggae]

Te manque un point-virgule à la fin de ta classe A.

[b Oo]

Oui Luc, il n'y avait pas de problème à la compilation avec g++ version 4.03.

En fait ce qui ce passait avant que j'edit le post, c'est que lorsque je crée mon tableau, chaque élément est défini et pointe sur n'importe quoi.
tab[i] est donc "déterminé" mais il ne possède pas ce que je veux.

Donc maintenant, j'ai ma classe A qui contient 81 cases qui chacune pointe sur un objet B, et chaque objet B pointe sur la case du tableau où il a été construit et a une valeur de 0.
Maintenant je pense que le code est moins "bizarre".

Par contre pour l'opérateur [], je voudrais savoir si on peut faire cela :

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
 
class A
{
  public :
   A();
   ...
   int * operator[](int i) { return tab[i]; }
 
  private :
   int * tab[81];
}; 
 
int main()
{
   A a;
   A * pa = &a;
   cout << pa[0] << endl; // pas valide à mon avis
   cout << (*pa)[0] << endl; // valide à mon avis 
  ...
}

J'aimerais savoir comment définir l'opérateur [] pour que pa[0] soit valide et que a[0] soit valide aussi, si cela est possible.

Merci.

b Oo

[narkhor]

en disant "que pa[0] soit valide et que a[0] soit valide aussi" je suppose que tu veux dire qu'il devrai avoir le même effet.

si c'est le cas, je ne pense pas que se soit une bonne idée.
pa est un A*, quand tu utilise l'opérateur [i] dessus, je m'imagine plutot que tu essai d'accéder au ième élement, d'un tableau de A; tableau nommée pa.
en voulant changé cet opérateur, le code risque d'être difficilement compréhensible par une autre personne.

deux choses que je croit vrai mais qu'il faudrai vérifier:
- (*pa)[i] est équivalent à *pa[i]

- le moyen de quand même surcharger ton opérateur serai d'écrire cette fonction ces 2 fonctions:

Code :

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

1
2
3
4
5
6
7
8
9
10
 
class A{
  public:
    int operator[](int i);
  ...
};
 
int operator[](A* a, int i){
  return a->operator[](i);
}

je reste quand même convaincu que ce n'est pas une bonne idée.

[Médinoc]

tu es sûr que ça marcherait ? ni A* ni int ne sont des types utilisateur: Je crois que pour surcharger un opérateur, une des opérandes au moins doit être d'un typê utilisateur...

[narkhor]

comme je l'ai dit, je ne suis pas sur, ce serai à vérifier.

[b Oo]

en disant "que pa[0] soit valide et que a[0] soit valide aussi" je suppose que tu veux dire qu'il devrai avoir le même effet.

si c'est le cas, je ne pense pas que se soit une bonne idée.
pa est un A*, quand tu utilise l'opérateur [i] dessus, je m'imagine plutot que tu essai d'accéder au ième élement, d'un tableau de A; tableau nommée pa.
en voulant changé cet opérateur, le code risque d'être difficilement compréhensible par une autre personne.

Salut narkhor,
ce que je voulais faire c'était un peu comme ceci:

Code :

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

1
2
3
4
5
 
int tab[10];
int * ptab = tab;
cout << tab[1] << endl;
cout << ptab[1] << endl;

sauf que je voulais le faire avec ma classe A.

Je croyais que le fait de définir l'opérateur[] me permettrait de faire A[] avec A qui aurait pu être un pointeur ou non.
Cela n'est pas conseillé comme tu l'as dit.

En fait je considérais mon A comme un tableau (donc un pointeur) et je ne voyais pas pourquoi mon code ne fonctionnait pas et aussi car this (le paramètre "caché" qui est passé dans operator[](int i)) est un pointeur.
Et dans ma tête je croyais que lorsque je faisais :

Code :

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

1
2
3
4
5
 
A a;
A * pa = &a;
cout << pa[i]; // ne fais pas ce que j'attends
cout << a[i];

cela faisait :

Code :

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

1
2
3
 
cout << pa->operator[](i); // fait ce que j'attends
cout << a.operator[](i);

donc pour moi il n'y avait pas d'erreur dans mon code, mais ceci n'est pas possible car les deux écritures ne sont pas gérées de la même manière.

Le premier code me donnera l'adresse de a si i =0 et ne fonctionnera pas sinon.

Le deuxième code devrait fonctionner pour ce que j'attends (ie me retourner l'élément contenu à la position i dans a).

J'apporte une précision sur ce que tu as dit narkhor qui n'est pas du tout équivalent :

deux choses que je croit vrai mais qu'il faudrai vérifier:
- (*pa)[i] est équivalent à *pa[i]

(*pa)[i] est équivalent à : a[i] avec pa qui pointe sur a
*pa[i] est équivalent à : *(pa+i) donc si i=0, (pa+i) est l'adresse de a ie *(pa+i) est équivalent à a, sinon cela fait quelque chose d'indéterminé.