[C++ & STL]

[liquid_ice]

Ik ben een getemplatiseerde class aan het maken met een multimap erin.
De multimap moet een pointer bewaren en het getemplatiseerde type.

dit staat er in de header file:

code:

template <typename T>
class CTheSubject
{
private:
  typedef std::multimap<IObserver<T>*, T const *> TObsContainer;
  TObsContainer iObservers;
public:
  //virtual ~CTheSubject();
  bool Attach(IObserver<T>* aObserver, T const &d)
  {
    std::multimap<char, char>::iterator pos;
    std::multimap<char, void*>::iterator pos1;
    std::multimap<char, T>::iterator pos2;
    // Bovenstaande regel levert de error:
    // In member function &#8216;bool CTheSubject<T>::Attach(IObserver<T>*, const T&)&#8217;:
    // error: expected `;' before &#8216;pos2&#8217; 
    return true
  };

Nou heb ik een class die erft van de IObserver<T> base class en als template type een void* heeft.
Bij de aanroep van de Attach() functie is als volgd: Attach(this,NULL);

waarom mag dit niet?

Ik heb al een tijdje gegoogled, maar gezien maps en multimaps al templated zijn vind ik hier weinig over.

[.oisyn]

Je moet typename gebruiken om aan de compiler duidelijk te maken dat de nested types in multimap daadwerkelijk types zijn en geen functies of variabelen e.d..
Dus zo:

C++:

typename std::multimap<char, T>::iterator pos2;

Dat is omdat het een zogenaamde dependent type is. Bij het parsen van je functie weet hij nog niet wat T is. De daadwerkelijke betekenis van std::multimap<char, T>::iterator hangt namelijk van T af - het zou zomaar kunnen zijn dat multimap is gespecialiseerd voor een specifieke T, waardoor iterator wellicht geen type meer is. De compiler maakt dan maar gewoon de assumptie dat het idd geen type is, en om aan te geven dat dat wel het geval is moet je typename gebruiken.

Bij de twee regels erboven in je code hoeft dat niet omdat hij dan al meteen op kan zoeken wat 'iterator' voor ding is in multimap<char, char> en multimap<char, void*> - dat hangt niet van T af en dus zijn ze niet dependent.

C++:

template<class T> struct Foo
{
    typedef int bar;
};

template<> struct Foo<char>
{
    static int bar() { return 3; }
};

void nontemplatefunc()
{
    Foo<int>::bar a; // een type
    Foo<char>::bar(); // een functie
}

template<class T>
void templatefunc()
{
    Foo<T>::bar(); // maar wat nu?
}

[ Voor 225% gewijzigd door .oisyn op 14-07-2009 02:02 ]

[liquid_ice]

Thnx, dat werkt