[conception]polymorphisme statique ou dynamique ?
Le problème est simple mais je ne sais quelle conception choisir.
J'ai 2 structures de données : Cube et Slice. Ces 2 structures implémentent une méthode read().
J'ai créé une classe ReadDataFile qui est chargée de lire un fichier et de remplir les structures de type Cube ou Slice.
J'ai 2 possibilités pour ReadDataFile :
1/ Soit 1 template du type :
Code:
1
2
3
4
5
6
7
8
9
| template<typename T>
class ReadDataFile
{
public:
ReadDataFile(T data, const string& filename) : data_(data) { data_.read(filename); }
private:
T& data_;
}; |
Ce qui donne à l'utilisation :
Code:
1
2
| Cube data;
ReadData<Cube> readData(data, "fichier.txt"); |
etc ...
Mais je peux aussi choisir d'utiliser l'héritage comme par exemple :
Cube et Slice qui héritent d'une classe de base Data possédant une fonction virtuelle pure read() qui est implémentée dans Cube et Slice.
A ce moment là, ReadDataFile n'aurait plus besoin d'être template, et pourrait être écrite comme suit :
Code:
1
2
3
4
5
6
7
8
| class ReadDataFile
{
public:
ReadDataFile(Data& data, const string& filename) : data_(data) { data_.read(filename); }
private:
Data& data_;
}; |
Je pense que la 2eme conception est meilleure, mais bon, je ne saurais pas trop le justifier. Qui peux me dire quelle est la meilleure des 2 conceptions dans ce cas précis ?
