Discussion :

[Ulmo]

Bonjour,
Pouvez vous m'expliquer pourquoi le code suivant ne compile pas ?

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
#include <list>
 
template<class T>
struct A {
    T t;
};
 
template<class T>
struct B {
    std::list<A<T> >::iterator i;
};

Ce n'est probablement pas une question nouvelle, mais je n'ai aucune idée de quelle recherche faire. Ce serait une seconde question.

Merci d'avance

[Médinoc]

Je n'ai pas testé, mais ceci devrait compiler:

Code C++ :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
#include <list>
 
template<class T>
struct A {
    T t;
};
 
template<class T>
struct B {
    typename std::list<A<T> >::iterator i;
};

[Goten]

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

typename std::list<A<T> >::iterator i;

Sinon le compilo ne sait pas que A est un type .

edit : grilled... et puis bien :p

[Ulmo]

Hmm, A est pourtant défini juste au dessus.
Qu'est ce cela pose comme problème au compilateur ?

Si c'est A qui pose problème, pourquoi ceci marche-t-il ?

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
template<class T>
struct B {
    std::list<A<int> >::iterator i;
};

[3DArchi]

C'est la norme :

A name used in a template declaration or definition and that is dependent on a template-parameter is assumed not to name a type unless the applicable name lookup finds a type name or the nam is qualified by the keyword typename

Dans ton dernier exemple, tu n'utilises pas ton paramètre template pour instancier ton itérateur de liste.

P.S.: j'ai toujours des craintes quand je vois un iterateur membre d'une classe. Es-tu sûr de ta conception ?

[loufoque]

std::list<T>::iterator peut être un type mais std::list<U>::iterator peut être une variable.
Les instanciations de templates sont totalement indépendantes car spécialisables.

C'est pour ça qu'il faut mettre typename.

[3DArchi]

std::list<T>::iterator peut être un type mais std::list<U>::iterator peut être une variable.
Les instanciations de templates sont totalement indépendantes car spécialisables.

C'est pour ça qu'il faut mettre typename.

D'ailleurs, j'ai trouvé un truc comme ça dans Boost.Scope Exit, que j'ai mis quand même un bout de temps avant de comprendre :

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
41
 
namespace boost { namespace scope_exit { namespace aux {
 
    template<int> struct declare;
 
    typedef void* declared;
    struct undeclared { declared dummy[2]; };
 
    template<>
    struct declare<sizeof(undeclared)>
    {
        template<int>
        struct apply
        {
            declared value;
            friend void operator>(bool, const apply&) {}
        };
    };
 
    template<>
    struct declare<sizeof(declared)>
    {
        static const int apply = 0;
    };
} } }
 
extern boost::scope_exit::aux::undeclared boost_scope_exit_args; 
 
// ... 
// bloc d'une méthode/fonction :
{
   //....
   boost::scope_exit::aux::declare<sizeof(boost_scope_exit_args)> ::apply<0> boost_scope_exit_args; 
// ici boost::scope_exit::aux::declare<sizeof(boost_scope_exit_args)> ::apply désigne un type
// celui de declare<sizeof(undeclared)>
 
   //...
   boost::scope_exit::aux::declare<sizeof(boost_scope_exit_args)> ::apply<0> boost_scope_exit_args; 
// ici boost::scope_exit::aux::declare<sizeof(boost_scope_exit_args)> ::apply désigne un membre
// celle de declare<sizeof(declared)>
}

[Ulmo]

C'est la norme :

[...]la norme[...]

Dans ton dernier exemple, tu n'utilises pas ton paramètre template pour instancier ton itérateur de liste.

P.S.: j'ai toujours des craintes quand je vois un iterateur membre d'une classe. Es-tu sûr de ta conception ?

Merci pour la citation.

Et pas d'inquiétude, j'utilise bien l'itérateur dans une boucle, c'était juste pour donner un exemple minimal.

[...]std::list<U>::iterator peut être une variable.[...]

Toujours pas très clair. "iterator" pourrait être le nom d'une variable de std::list<U>, qui cacherait le type défini dans std::list<> ?

[3DArchi]

Merci pour la citation.

Et pas d'inquiétude, j'utilise bien l'itérateur dans une boucle, c'était juste pour donner un exemple minimal.



Toujours pas très clair. "iterator" pourrait être le nom d'une variable de std::list<U>, qui cacherait le type défini dans std::list<> ?

Rien ne t'empêche d'écrire quelque chose comme ç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
 
struct A{};
#include <list>
namespace std{
   template<>
struct list<A>
{
   static const int const_iterator=0;
};
}
 
int main()
{
   return std::list<A>::const_iterator;
}

Certes c'est très douteux comme code, mais ici std::list<A>::const_iterator désigne une variable ...

[Ulmo]

OK, amusant.

Merci pour vos réponses.

[koala01]

Salut,

Quand on sait que la forme canonique pour créer une boucle est

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

for( < <type> nom = valeur_de_depart>;<nom comparaison valeur_arrivee>; <pas>)

on remarque que la manière "classique" de créer une boucle sur une des collections de la STL te montre bel et bien qu'il s'agit d'un type:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
for(std::collection<type>::iterator it=col.begin(); it!=col.end();++it)
    (*it).doSomething

(ou collection est le type de structure "dynamique" utilisée)