Bonjour à tous,

je suis à la recherche de solution par rapport à un petit problème que j'ai dans un TP....

en gros, j'ai une classe définit à l'intérieur d'une autre classe (IteratorPrefixe) qui elle même est définit dans un fichier header pour templates... (euh... me suivez vous encore, parce que je suis pas sur d'être très clair :S)

donc.... voici le header
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
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
 
#ifndef TRIE_HPP
#define TRIE_HPP
#include <utility>
#include <vector>
#include <string>
#include <stdexcept>
using namespace std;
#define NBLETTRESMAX 26
#define LETTREMIN 'a'
 
template <typename T> class Trie {
    friend class IteratorPrefixe;
    public:
        // Cree un trie basé sur un alphabet de nblettres, ou nblettres doit avoir une valeur comprise
        // entre 1 et NBLETTRESMAX inclusivement
        Trie(unsigned nblettres) throw(runtime_error);
        // Ajoute un élément dont la clé est donnée en premier argument et le contenu en second argument
        // Le contenu doit être défini (pointeur différent de NULL)
        // La clé doit être composée de lettres valides (soit les lettres comprises entre a inclusivement et a+nblettres exclusivement
        //      par exemple :   si nblettres vaut 3, a, b et c sont les seuls caractères autorisés;
        //                      si nblettres vaut 15, seules les lettres entre a et o inclusivement sont autorisées.
        // Renvoie true si l'insertion a pu se faire, renvoie false sinon.
        bool ajouteElement(string, T*) throw(runtime_error);
        // Supprime un élément dont la clé est donnée en argument et renvoie le contenu du noeud supprimé
        // La clé doit être composée de lettres valides (voir ci-dessus)
        // Peut egalement supprimer en meme temps des ancetres du noeud mentionne, si ces ancetres sont devenus inutiles
        // Renvoie NULL si l'élément a supprimer n'existe pas
        T* supprimeElement(string cle) throw(runtime_error);
        // Cherche un élément dont la clé est donnée en argument et renvoie le contenu associé
        // La clé doit être composée de lettres valides (voir ci-dessus)
        // Renvoie NULL si la clé n'existe pas
        T* chercheElement(string cle) throw();
        // Classe d'itérateur permettant de parcourir le trie en profondeur en mode préfixe
        class IteratorPrefixe;
        // Renvoie un itérateur pointant sur le premier élément du parcours du trie en profondeur en mode préfixe
        IteratorPrefixe pbegin() throw(runtime_error);
        // Renvoie un itérateur pointant au-delà du dernier élément du parcours du trie en profondeur en mode préfixe
        IteratorPrefixe pend() throw();
    private:
        unsigned nbLettres;
        T* element;
        vector<Trie<T> *> enfants;
        Trie<T> * parent;
        // Cette fonction supprime un noeud et ses ancêtres devenus inutiles. Elle fait essentiellement le meme travail
        // que supprimeElement : c'est la façon de désigner le noeud a supprimer qui change. De plus, contrairement a
        // supprimeElement, elle ne retourne aucune information sur le noeud supprimé.
        void supprime(Trie<T> * noeud) throw();
        // Cette fonction cherche un noeud en fonction d'une clé donnée. Elle fait essentiellement le meme travail
        // que chercheElement mais renvoie une référence au noeud trouvé (ou NULL si le noeud n'existe pas)
        // La clé doit être composée de lettres valides (voir ci-dessus)
        Trie<T>* cherche(string cle) throw(runtime_error);
};
template <typename T> class Trie<T>::IteratorPrefixe{
    friend class Trie<T>;
    public:
        IteratorPrefixe() : arbre(NULL), noeudCourant(NULL), cleCourante("") {};
        pair<string, T*> operator*() {return make_pair(cleCourante, noeudCourant -> element);} ;
        IteratorPrefixe operator++()throw(runtime_error);
        void operator=(IteratorPrefixe iter) {arbre = iter.arbre; noeudCourant = iter.noeudCourant; cleCourante = iter.cleCourante;};
        bool operator==(IteratorPrefixe iter) {return arbre == iter.arbre && noeudCourant == iter.noeudCourant;};
        bool operator!=(IteratorPrefixe iter) {return arbre != iter.arbre || noeudCourant != iter.noeudCourant;};
    private:
        Trie<T> * arbre;
        Trie<T> * noeudCourant;
        string cleCourante;
};
#endif /* TRIE_HPP */
et voici le code problématique du cpp associé
(il faut remarqué que le header est séparé du cpp malgré le fait que ce soit des templates.... spécifications du tp ... )

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
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
 
#include "Trie.hpp"
#include <iostream>
#define POSITIONA 97
static bool checkCle(string cle, int nblettres);
template<typename T>
Trie<T>::Trie(unsigned nblettres) throw(runtime_error) {
    if (nblettres > NBLETTRESMAX || nblettres < 1)
        throw runtime_error("Trie() : nombre de lettres hors-bornes!");
    nbLettres = nblettres;
    element = NULL;
}
 
template<typename T>
bool Trie<T>::ajouteElement(string uneCle, T* unElement) throw(runtime_error) {
    int noCle;
    if (unElement == NULL)
        throw runtime_error ("ajouteElement() : Insertion d'élement 'null'");
    if (!checkCle(uneCle, nbLettres))
        throw runtime_error ("ajouteElement() : Cle invalide.");
    noCle = tolower(uneCle[0])-POSITIONA;
    if (uneCle.length() == 0) {
        element = unElement;
        return true;
    } else {
        if (enfants.size() == 0) {
            for (int x=0; x<nbLettres; x++) {
                enfants.push_back(NULL);
            }
        }
        if (enfants[noCle] == NULL)
            enfants[noCle] = new Trie<T>(nbLettres);
        return enfants[noCle]->ajouteElement(uneCle.substr(1,(uneCle.length()-1)), unElement);
    }
}
template<typename T>
T* Trie<T>::supprimeElement(string uneCle) throw(runtime_error) {
    int noCle;
    T* returnElement;
    if (!checkCle(uneCle, nbLettres))
        throw runtime_error ("supprimeElement() : Cle invalide.");
    noCle = tolower(uneCle[0])-POSITIONA;
    if (chercheElement(uneCle) != NULL) {
        if (uneCle.length() > 0) {
            returnElement = enfants[noCle]->supprimeElement(uneCle.substr(1,(uneCle.length()-1)));
            if (uneCle.length() == 1)
                enfants[noCle] = NULL;
        }
        else {
            returnElement = element;
            element = NULL;
        }
    } else {
        returnElement = NULL;
    }
    return returnElement;
}
template<typename T>
T* Trie<T>::chercheElement(string uneCle) throw() {
    int noCle;
    noCle = tolower(uneCle[0])-POSITIONA;
    if (enfants.size() > 0 && uneCle.size() > 0)
        if (enfants[noCle] != NULL)
            return enfants[noCle]->chercheElement(uneCle.substr(1,(uneCle.length()-1)));
        else
            return NULL;
    else
        if (enfants.size() == 0 && uneCle.size() > 0)
            return NULL;
        else
            return element;
}
 
IteratorPrefixe pbegin() throw(runtime_error)
{
}
le problème dans ce code est à la fin (IteratorPrefixe pbegin()...)
cela me crée une erreur :
error: 'IteratorPrefixe' does not name a type

Donc, c'est là que je suis bloqué

Merci d'avance
FadeOut