Dérivation de classe template == using à gogo

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:

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 ?