Problème de compréhension d'une partie de [Bj.Str. : C++ 4th ed]
Bonjour !
Je lis (et relis) le libre de Bjarne Stroutrup The C++ programming language 4th Edition et j'ai un sérieux problème de compréhension de la section 27.4.1 Composing Data Structures p 782.
Bjarne me dit :
Citation:
Consider writing a balanced binary tree library. Since we are providing a library to be used by
many different users, we can’t build the type of the user’s (application’s) data into our tree nodes.
We have many alternatives:
Bon ça ok, c'est juste pour mettre dans le contexte.
Des trois alternatives qu'il propose ensuite, seule la première me pose problème :
Première alternative :
Citation:
We could put the user’s data in a derived class and access it using virtual functions. But (...) our interface to the user’s data is not expressed in terms of the user’s type, so we still need to use casts to access it.
Ce que j'ai compris en première lecture c'est qu'il faisait référence à quelque chose du genre :
Code:
1
2
3
4
5
6
7
|
class Node {
Node* fils_droit, *fils_gauche;
Data* val;
public :
Data* getVal(){ return val;}
}; |
En demandant à l'utilisateur de faire :
Code:
1
2
3
4
|
class Val_double : public Data {
double val;
} |
Mais alors ce serait à l'utilisateur de faire des cast et de toutes façons il me semble que c'est en fait la troisième alternative que propose Bjarne :
Citation:
We could put a Data∗ into our nodes, where Data is a ‘‘universal base class’’ for our data structures. That would solve the type-checking problem(...)
Du coup j'ai imaginé qu'il voulait dire quelque chose du genre :
Code:
1
2
3
4
5
6
7
8
9
10
11
|
class Node{
Node* fils_gauche;
Node* fils_droit;
public :
Node();
//Code Mystèrieux pour moi comprenant
// Des méthodes virtuelles pour accéder à la 'valeur' du nœud mais
// Je ne vois pas du tout comment ici sans connaitre le type de la valeur du nœud
// même en castant (vers quoi ??)
}; |
Et que l'on demanderait à l'utilisateur de faire quelque chose du genre :
Code:
1
2
3
4
5
|
class Tree_double : public Node{
double val;
//.....
}; |
Pour palier à mon problème de code mystère, j'ai donc imaginé qu'on ferait plutôt quelque chose du genre :
Code:
1
2
3
4
5
6
7
8
|
template <typename T> class Node{
Node* fils_gauche;
Node* fils_droit;
public :
Node();
virtual T getVal() const = 0;
}; |
Et l'utilisateur :
Code:
1
2
3
4
5
6
|
class Tree_double : public Node<double> {
double val;
public :
double getVal() const {return val;}
}; |
Mais alors, je ne vois plus du tout à quel cast mon ami Bjarne fait référence...
Bref : je suis paumé.
P.S. : J'ai d'autres problèmes dans la même section mais j'y viendrai après sinon mon post risque de faire 10 pages.
