Probleme de compilation code C++

Version imprimable

Bonjour à tous,

je veux créer un map de dimension 2,
le code correspondant est le suivante:
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 #include <iostream> #include <map> #include <string> template <class T> class C { public: void listAll() { for(typename std::map<std::pair<std::string, std::string>, T>::iterator i= box.begin(); i != box.end(); i++){ std::cout << i->first << " ---> " << i->second << std::endl; } } std::map<std::pair<std::string, std::string>, T> box; }; int main(int argc, char *argv[]) { C<int> c0; c0.box["abc","s"] = 123; c0.box["def","q"] = 456; c0.listAll(); return 0; }
Lors de la compilation avec gcc, il m'affiche des erreurs.
y'a t'il qq1 qui comprend où réside l'erreur.

Merci Bien pour vos reponses.
:)

Même aussi qd j'écrit:
"
c0.box["abc"]["s"] = 123;
c0.box["def"]["q"] = 456;
"
l'erreur reste le même.

01/12/2008, 11h55
ram-0000

Citation:

Envoyé par KINGINFO

...Lors de la compilation avec gcc, il m'affiche des erreurs.
y'a t'il qq1 qui comprend où réside l'erreur.

Heu ... par hasard, tu ne nous donnerais pas les messages d'erreur affichés par ton compilateur ?

ahh je m'exxuse,
voila les messages d'erreur:

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
 
test.cpp:16: error: template argument 2 is invalid
test.cpp:16: error: template argument 4 is invalid
test.cpp: In member function ‘void C::listAll()’:
test.cpp:10: error: using ‘typename’ outside of template
test.cpp:10: error: template argument 2 is invalid
test.cpp:10: error: template argument 4 is invalid
test.cpp:10: error: expected initializer before ‘i’
test.cpp:11: error: ‘i’ was not declared in this scope
test.cpp:11: error: request for member ‘end’ in ‘((C*)this)->C::box’, which is of non-class type ‘int’
test.cpp: In function ‘int main(int, char**)’:
test.cpp:23: error: assignment of read-only location
test.cpp:24: error: assignment of read-only location
test.cpp:24: warning: overflow in implicit constant conversion
bouzid@tallinn:~/Desktop$ g++ -ggdb -o test test.cpp
test.cpp: In function ‘int main(int, char**)’:
test.cpp:23: error: no match for ‘operator[]’ in ‘c0.C<int>::box["abc"]’
/usr/include/c++/4.2/bits/stl_map.h:342: note: candidates are: _Tp& std::map<_Key, _Tp, _Compare, _Alloc>::operator[](const _Key&) [with _Key = std::pair<std::basic_string<char, std::char_traits<char>, std::allocator<char> >, std::basic_string<char, std::char_traits<char>, std::allocator<char> > >, _Tp = int, _Compare = std::less<std::pair<std::basic_string<char, std::char_traits<char>, std::allocator<char> >, std::basic_string<char, std::char_traits<char>, std::allocator<char> > > >, _Alloc = std::allocator<std::pair<const std::pair<std::basic_string<char, std::char_traits<char>, std::allocator<char> >, std::basic_string<char, std::char_traits<char>, std::allocator<char> > >, int> >]
test.cpp:24: error: no match for ‘operator[]’ in ‘c0.C<int>::box["def"]’
/usr/include/c++/4.2/bits/stl_map.h:342: note: candidates are: _Tp& std::map<_Key, _Tp, _Compare, _Alloc>::operator[](const _Key&) [with _Key = std::pair<std::basic_string<char, std::char_traits<char>, std::allocator<char> >, std::basic_string<char, std::char_traits<char>, std::allocator<char> > >, _Tp = int, _Compare = std::less<std::pair<std::basic_string<char, std::char_traits<char>, std::allocator<char> >, std::basic_string<char, std::char_traits<char>, std::allocator<char> > > >, _Alloc = std::allocator<std::pair<const std::pair<std::basic_string<char, std::char_traits<char>, std::allocator<char> >, std::basic_string<char, std::char_traits<char>, std::allocator<char> > >, int> >]
test.cpp: In member function ‘void C<T>::listAll() [with T = int]’:
test.cpp:25:   instantiated from here
test.cpp:12: error: no match for ‘operator<<’ in ‘std::cout << i.std::_Rb_tree_iterator<_Tp>::operator-> [with _Tp = std::pair<const std::pair<std::basic_string<char, std::char_traits<char>, std::allocator<char> >, std::basic_string<char, std::char_traits<char>, std::allocator<char> > >, int>]()->std::pair<const std::pair<std::basic_string<char, std::char_traits<char>, std::allocator<char> >, std::basic_string<char, std::char_traits<char>, std::allocator<char> > >, int>::first’
/usr/include/c++/4.2/ostream:112: note: candidates are: std::basic_ostream<_CharT, _Traits>& std::basic_ostream<_CharT, _Traits>::operator<<(std::basic_ostream<_CharT, _Traits>& (*)(std::basic_ostream<_CharT, _Traits>&)) [with _CharT = char, _Traits = std::char_traits<char>]
/usr/include/c++/4.2/ostream:121: note:                 std::basic_ostream<_CharT, _Traits>& std::basic_ostream<_CharT, _Traits>::operator<<(std::basic_ios<_CharT, _Traits>& (*)(std::basic_ios<_CharT, _Traits>&)) [with _CharT = char, _Traits = std::char_traits<char>]
/usr/include/c++/4.2/ostream:131: note:                 std::basic_ostream<_CharT, _Traits>& std::basic_ostream<_CharT, _Traits>::operator<<(std::ios_base& (*)(std::ios_base&)) [with _CharT = char, _Traits = std::char_traits<char>]
/usr/include/c++/4.2/ostream:169: note:                 std::basic_ostream<_CharT, _Traits>& std::basic_ostream<_CharT, _Traits>::operator<<(long int) [with _CharT = char, _Traits = std::char_traits<char>]
/usr/include/c++/4.2/ostream:173: note:                 std::basic_ostream<_CharT, _Traits>& std::basic_ostream<_CharT, _Traits>::operator<<(long unsigned int) [with _CharT = char, _Traits = std::char_traits<char>]
/usr/include/c++/4.2/ostream:177: note:                 std::basic_ostream<_CharT, _Traits>& std::basic_ostream<_CharT, _Traits>::operator<<(bool) [with _CharT = char, _Traits = std::char_traits<char>]
/usr/include/c++/4.2/bits/ostream.tcc:92: note:                 std::basic_ostream<_CharT, _Traits>& std::basic_ostream<_CharT, _Traits>::operator<<(short int) [with _CharT = char, _Traits = std::char_traits<char>]
/usr/include/c++/4.2/ostream:184: note:                 std::basic_ostream<_CharT, _Traits>& std::basic_ostream<_CharT, _Traits>::operator<<(short unsigned int) [with _CharT = char, _Traits = std::char_traits<char>]
/usr/include/c++/4.2/bits/ostream.tcc:106: note:                 std::basic_ostream<_CharT, _Traits>& std::basic_ostream<_CharT, _Traits>::operator<<(int) [with _CharT = char, _Traits = std::char_traits<char>]
/usr/include/c++/4.2/ostream:195: note:                 std::basic_ostream<_CharT, _Traits>& std::basic_ostream<_CharT, _Traits>::operator<<(unsigned int) [with _CharT = char, _Traits = std::char_traits<char>]
/usr/include/c++/4.2/ostream:204: note:                 std::basic_ostream<_CharT, _Traits>& std::basic_ostream<_CharT, _Traits>::operator<<(long long int) [with _CharT = char, _Traits = std::char_traits<char>]
/usr/include/c++/4.2/ostream:208: note:                 std::basic_ostream<_CharT, _Traits>& std::basic_ostream<_CharT, _Traits>::operator<<(long long unsigned int) [with _CharT = char, _Traits = std::char_traits<char>]
/usr/include/c++/4.2/ostream:213: note:                 std::basic_ostream<_CharT, _Traits>& std::basic_ostream<_CharT, _Traits>::operator<<(double) [with _CharT = char, _Traits = std::char_traits<char>]
/usr/include/c++/4.2/ostream:217: note:                 std::basic_ostream<_CharT, _Traits>& std::basic_ostream<_CharT, _Traits>::operator<<(float) [with _CharT = char, _Traits = std::char_traits<char>]
/usr/include/c++/4.2/ostream:225: note:                 std::basic_ostream<_CharT, _Traits>& std::basic_ostream<_CharT, _Traits>::operator<<(long double) [with _CharT = char, _Traits = std::char_traits<char>]
/usr/include/c++/4.2/ostream:229: note:                 std::basic_ostream<_CharT, _Traits>& std::basic_ostream<_CharT, _Traits>::operator<<(const void*) [with _CharT = char, _Traits = std::char_traits<char>]
/usr/include/c++/4.2/bits/ostream.tcc:120: note:                 std::basic_ostream<_CharT, _Traits>& std::basic_ostream<_CharT, _Traits>::operator<<(std::basic_streambuf<_CharT, _Traits>*) [with _CharT = char, _Traits = std::char_traits<char>]

Salut,
C'est marrant, avec le même code, mon compilateur se plaint qu'il est impossible de trouver l'opérateur [] :aie:...

Ceci dit, une bonne habitude à prendre (surtout dans le cas où tu crée une clé multiple), c'est de préférer la méthode insert, associée à la fonction make_pair pour insérer des éléments dans une map...

En effet, il faut bien comprendre que la classe map est un conteneur qui contient une collection de ... std::pair, triées sur base de l'élément "first".

Or, la clé que tu décide d'utiliser dans le code que tu donnes est, justement,... une std::pair (dont first et second sont des std::string, d'ailleurs):aie:

De plus, pour t'éviter quelques risques de mauvaise transcription, il pourrait s'avérer utile de déclarer, au sein de ta liste, quelques alias de type.

Ainsi, tu pourrait modifier ta classe en

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
template <class T>
class
{
    typedef std::map<std::pair<std::string, std::string>,T> map;
    public:
        /* plutot que d'utiliser std::map<...", nous pouvons utiliser
         *  simplement"map"
         */
       map box;
       /* la méthode listAll() devrait idéalement être déclarée constante...
        * cela te donnera l'assurance qu'elle sera appelable dans n'importe
        * quelle circonstance.
        * par contre, il faudra alors utiliser un const_iterator ;) 
        */
       void listAll() const
       {
           /* ici aussi, nous pouvons utiliser simplement "map" au lieu de
            * "std::map<..."
            */
           for(map::const_iterator it=box.begin(); it !=box.end(); ++it)
           {
               /* les opérateur de flux ne savent pas gérer les std::pair, 
                * il faut donc adapter l'affichage de la clé
                */
              std::cout<<it->first.first     // la premiere chaine de la clé
                       <<<it->first.second   // la deuxieme chaine de la clé
                       <<" --> "<<it->second // la valeur
                       <<std::endl;          // le retour à la ligne
           }
       }
};

Comme je l'ai précisé plus haut, l'idéal reste le plus souvent d'utiliser la méthode insert avec la fonction make_pair, et donc, l'utilisation de la classe se rapprocherait de

Code:

1
2
3
4
5
6
7
8
9
int main()
{
 
    C<int> c0;
    c0.box.insert(std::make_pair(std::make_pair("abc","s"),123));
    c0.box.insert(std::make_pair(std::make_pair("def","q"),456));
    c0.listAll();
    return 0;
}

Cependant, on peut estimer que l'insertion d'un objet dans la collection devrait être l'un des services rendus par la classe elle-même, et que l'utilisateur ne devrait pas avoir accès à la collection d'objet...

La classe serait donc intelligemment modifiée en

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
/* il est préférable d'utiliser typename comme paramètre template
 * si l'on n'a pas l'assurance que le type en question sera effectivement
 * une classe... comme ici, nous allons utiliser un type primitif, 
 * il est donc préférable d'utiliser typename comme paramètre template ;)
 */
template<typename T>
class C
{
    /* l'alias de type peut rester privé, car il est à usage interne
     * uniquement
     * il peut être pas mal de définir d'autres alias de type
     * pour se faciliter la tache
     */
    typedef T type;
    typedef std::pair<std::string, std::string> key;
    typedef std::map<key, type> map;
    typedef typename map::const_iterator const_iterator;
    public:
       void listAll() const
       {
           for(const_iterator it=box.begin();it!=box.end();++it)
           {
                std::cout<<it->first.first
                       <<it->first.second
                       <<" --> "<<it->second
                       <<std::endl;
           }
       }
       /* la méthode qui permet d'insérer un objet à la collection */
       void insert(std::string const & f, std::string const & s, const T& v)
       {
           box.insert(std::make_pair(std::make_pair(f,s),v));
       }
    private:
        map box;
};

et l'utilisation de cette classe deviendrait

Code:

1
2
3
4
5
6
7
8
9
int main(int argc, char *argv[])
{
 
    C<int> c0;
    c0.insert("abc","s",123);
    c0.insert("def","q",456);
    c0.listAll();
    return 0;
}

[EDIT]Par la suite, il serait sans doute intéressant de définir quelques trait de politique afin de prendre en compte les particularités qui s'appliquent aux types primitifs et aux pointeurs, mais, ca, c'est une autre histoire ;)

Merci de votre reponse,

même avec ce code, j'ai des erreur suivantes lors de la compilation:

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
 
test.cpp:15: error: ISO C++ forbids declaration of ‘pair’ with no type
test.cpp:15: error: typedef name may not be a nested-name-specifier
test.cpp:15: error: expected ‘;’ before ‘<’ token
test.cpp:16: error: ISO C++ forbids declaration of ‘map’ with no type
test.cpp:16: error: typedef name may not be a nested-name-specifier
test.cpp:16: error: expected ‘;’ before ‘<’ token
test.cpp:17: error: ‘map’ has not been declared
test.cpp:30: error: ‘std::string’ has not been declared
test.cpp:30: error: ‘std::string’ has not been declared
test.cpp:35: error: ‘map’ does not name a type
test.cpp: In member function ‘void C<T>::listAll() const’:
test.cpp:21: error: ‘box’ was not declared in this scope
test.cpp:23: error: ‘cout’ is not a member of ‘std’
test.cpp:23: error: base operand of ‘->’ is not a pointer
test.cpp:24: error: base operand of ‘->’ is not a pointer
test.cpp:25: error: base operand of ‘->’ is not a pointer
test.cpp:26: error: ‘endl’ is not a member of ‘std’
test.cpp: In member function ‘void C<T>::insert(const int&, const int&, const T&)’:
test.cpp:32: error: ‘box’ was not declared in this scope
test.cpp:32: error: ‘make_pair’ is not a member of ‘std’
test.cpp:32: error: ‘make_pair’ is not a member of ‘std’
test.cpp: In function ‘int main(int, char**)’:
test.cpp:42: error: invalid conversion from ‘const char*’ to ‘int’
test.cpp:42: error:   initializing argument 1 of ‘void C<T>::insert(const int&, const int&, const T&) [with T = int]’
test.cpp:42: error: invalid conversion from ‘const char*’ to ‘int’
test.cpp:42: error:   initializing argument 2 of ‘void C<T>::insert(const int&, const int&, const T&) [with T = int]’
test.cpp:43: error: invalid conversion from ‘const char*’ to ‘int’
test.cpp:43: error:   initializing argument 1 of ‘void C<T>::insert(const int&, const int&, const T&) [with T = int]’
test.cpp:43: error: invalid conversion from ‘const char*’ to ‘int’
test.cpp:43: error:   initializing argument 2 of ‘void C<T>::insert(const int&, const int&, const T&) [with T = int]’

NB: le cmd que je l'utilise pour la compilation est : " g++ -ggdb -o test test.cpp"

01/12/2008, 14h34
koala01

As tu pensé à l'inclusion du fichier d'en-tête <map> :question:
01/12/2008, 14h54
KINGINFO

tu as raison,

je vous remercie de votre attention.

ça marche bien

Merci