Discussion :

[Captain'Flam]

Bonjour amis cépépistes !

encore une fois je me mélange les pinceaux dans les finesses du c+...

Je souhaite dériver une classe template de la stl pour la doter de petites méthodes qui m'arrangent, mais je m'aperçois que je suis obligé de garnir ma classe dérivée d'une foule de using...
Est-ce normal docteurs ?
Voici un bout de code pour illustrer tout ça

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
#include <map>
#include <string>
#include <iostream>
 
template <typename Key,typename Value> class Map : public std::map<Key,Value> // J'enrichit la classe std::map mais je reste "générique"
    {
    public:
        using typename std::map<Key,Value>::const_iterator ;  // <-- tout un tas de using dont j'aimerais bien me passer
        using std::map<Key,Value>::operator[] ;
        using std::map<Key,Value>::begin ;
        using std::map<Key,Value>::find ;
        using std::map<Key,Value>::end ;
 
        Value get ( const Key & key , const Value & def ) const
            {
            const_iterator f = find( key ) ;
            return (f == end()) ? def : f->second ;
            }
 
        friend std::ostream & operator<< ( std::ostream & out , const Map<Key,Value> & self )
            {
            for ( const_iterator i = self.begin() ; i != self.end() ; ++i ) 
                out << " " << i->first << ":" << i->second ;
            return out ;
            }
    };
 
class Dictionary : public Map<std::string,std::string> // Je spécialise ma classe pour des besoins + spécifiques
    {
    public:
        Dictionary & add ( const std::string & key , const std::string & value )  { (*this)[key] = value ; return *this ;}
    };
 
int main ()
    {
    Dictionary d ;
    d.add("0","zero").add("1","one") ;
    d["spam"] = "eggs" ; // ici, sans le using operator[], ça ne compile pas
    std::cout << d << " / 2:" << d.get("2","???") << std::endl ;
    }

J'ai l'impression qu'à chaque fois que je veux utiliser une méthode de std::map depuis Dictionary, je suis obligé d'ajouter un using dans Map.
Y a-t-il un moyen d' "importer" toutes les méthodes std::map dans Map (et dans Dictionary) d'un seul coup ?

J'en profite pour ajouter une petite question :

Y a-t-il un surcoût quelconque quand on dérive une classe à laquelle on ne fait qu'ajouter des méthode non virtuelles ?

[ternel]

En fait, tu ne veux pas hériter d'une map.

C'est un piège à ***. La bonne solution, c'est en général d'encapsuler ta map. ou au pire un héritage privé.

Le mieux, à mon goût, c'est de créer des templates libres.

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 <map>
#include <string>
#include <iostream>
 
template <typename Map>
std::ostream & operator<< ( std::ostream & out , Map const Map& m) {
    for ( typename Map::const_iterator i = m.begin() ; i != m.end() ; ++i )
        out << ' ' << i->first << ':' << i->second ;
    return out ;
}
 
template <typename Map, typename Key, typename Value>
Value get (Map const& map,  Key & key , const Value & def ) {
    auto f = map.find( key ) ;
    return (f != end()) ? f->second : def;
}
 
 
template <typename Map, typename Key, typename Value>
Value get (Map & map,  Key & key , Value value & def ) {
    auto f = map.find( key ) ;
    return (f != end()) ? map[key] : (map[key]=def);
}
 
 
//ou en moins général (pas de support pour les allocateurs et comparateurs, pas de support d'autres map que std::map)
template <typename K, typename V>
V const& search(std::map<K, V> const& map, K const& key) {
   typename std::map<K, V>::const_iterator it = map.find(key);
   if (it!=map.end()) return it->second;
   throw std::out_of_range("key not found");
}

Et ton dictionnaire n'est pas une map s'il fournit une sémantique plus grande.
Il n'a besoin que de certaines opérations, et devrait les déléguers.