ich portiere gerade ein Projekt von Linux nach Windows. Als Compiler und IDE nutze ich MSVC 2008 SP1. Nun habe ich eine Datei welche unter Linux (Ubuntu 8.04, ich glaube GCC 4.2) einwandfrei läuft, aber der MS Compiler mag sie nicht.

Er bemängelt das ein Templatebezeichner (T) in einer Nested Class nicht deklariert ist. Der Bezeichner stammt aus der äußeren Klasse.
Anbei ist ein ausführbarer Auszug auf dem problematischen Code.

VariableChildTree.hpp:

#include <iostream>
#include <boost/weak_ptr.hpp>
#include <boost/shared_ptr.hpp>

using boost::shared_ptr;
using boost::weak_ptr;

template<class T> class VariableChildTree;

template <class T>
class VariableChildTree
{
    public:
        template<class S> class VariableChildTreeIterator;
    private:
        template<class S> class VariableChildTreeNode;

    private:
        template <class S>
        class VariableChildTreeNode
        {
            friend class VariableChildTree;
            friend class VariableChildTreeIterator<S>;

            public:
				VariableChildTreeNode(shared_ptr<VariableChildTreeNode<S> > pParent);
            private:
                shared_ptr<VariableChildTreeNode<S> > m_pParent;
        }; // end class VariableChildTreeNode

    public:
        template <class S>
        class VariableChildTreeIterator
        {
            public:
                friend class VariableChildTree;
                VariableChildTreeIterator(weak_ptr<VariableChildTreeNode<S> > pWeakCurrNode, weak_ptr<VariableChildTree<T> >  pWeakTree)
				{
                	std::cout << "VariableChildTreeIterator::VariableChildTreeIterator" << std::endl;
					m_pCurrNode = pWeakCurrNode;
					m_pMyTree = pWeakTree;
				}
            private:
                weak_ptr<VariableChildTreeNode<S> >  m_pCurrNode;
                weak_ptr<VariableChildTree<S> >      m_pMyTree;
        }; // end class VariableChildTreeIterator

    public:
        friend class VariableChildTreeIterator<T>;
        friend class VariableChildTreeNode<T>;

        static  shared_ptr<VariableChildTree<T> > create();

        VariableChildTreeIterator<T> getIterator()
		{
			return VariableChildTreeIterator<T>(m_pRootDummy, m_pWeakThis);
		}

    private:
        VariableChildTree();
        weak_ptr<VariableChildTree<T> >                 m_pWeakThis; // a weak pointer to "this" tree, neccessary for weak pointer from iterator to tree
        shared_ptr<VariableChildTreeNode<T> >           m_pRootDummy; // a dummy node for the root node
}; // end class VariableChildTree

template<class T> template<class S>
VariableChildTree<T>::VariableChildTreeNode<S>::VariableChildTreeNode(shared_ptr<VariableChildTreeNode<S> > pParent)
{
    m_pParent = pParent;
}
template<class T> VariableChildTree<T>::VariableChildTree()
{
    m_pRootDummy = shared_ptr<VariableChildTreeNode<T> >(new VariableChildTreeNode<T>());
}
template<class T> shared_ptr<VariableChildTree<T> > VariableChildTree<T>::create()
{
    shared_ptr<VariableChildTree<T> > pTree(new VariableChildTree<T>());
    pTree->m_pWeakThis = pTree;
    return pTree;
}

und main.cpp:

#include "VariableChildTree.hpp"
#include <boost/shared_ptr.hpp>

int main()
{
	shared_ptr<VariableChildTree<double> > vct = VariableChildTree<double>::create();
	vct->getIterator();
	return 0;
}

Der Fehler tritt beim aufruf des Konstruktors von VariableChildTreeIterator auf.

1>d:\...\variablechildtree.hpp(37) : error C2065: 'T': nichtdeklarierter Bezeichner
1>        d:\...\variablechildtree.hpp(46): Siehe Verweis auf die Instanziierung der gerade kompilierten Klassen-template "VariableChildTree<T>::VariableChildTreeIterator<S>".
1>        d:\...\variablechildtree.hpp(63): Siehe Verweis auf die Instanziierung der gerade kompilierten Klassen-template "VariableChildTree<T>".
1>d:\...\variablechildtree.hpp(37) : error C2065: 'T': nichtdeklarierter Bezeichner

Hat vielleicht jemand eine Idee wie man diesen Code unter Windows zum laufen bringt.

Vielen Dank, sjoe.

@pumuckl
Du meinst in Zeile 37 einfach folgendes hinschreiben:

VariableChildTreeIterator(weak_ptr<VariableChildTreeNode<S> > pWeakCurrNode, weak_ptr<VariableChildTree >  pWeakTree)

Geht leider nicht. Compiler meckert das er ausgehend von Zeile 56 keinen passenden Konstuktor mehr findet.

@drakon
Hm, im Kurztest funktioniert das erstmal. Ich werde mal unter Linux testen ob das auch dort funktioniert. Dann müsste ich allerdings sehr viel Code überarbeiten. Naja, so ist das Leben, mal verliert man und mal gewinnen die anderen.

Für andere Vorschläge bin ich offen.

Grüße, sjoe.

Grüße, sjoe.

Bei Zeiten, werde ich mal im Standard nachschauen, welcher der beiden Compiler nicht standardkonform arbeitet. Aber wahrscheinlich wird das auf undefiniert hinauslaufen, obwohl ich eigentlich denke, dass das, was pumuckl meint doch auch gehen müsste..

Ggf. in der VCTree-Klasse T als value_type typedeffen bzw. VCTree<T> als tree_type typedeffen und den typedef in der Unterklasse nutzen.

Ggf. in der VCTree-Klasse T als value_type typedeffen bzw. VCTree<T> als tree_type typedeffen und den typedef in der Unterklasse nutzen.

Unglaublich. Damit funktioniert es. Mal schauen ob das auch unter Linux läuft, aber diese Kleinigkeit kann man notfalls auch per ifdef erledigen.
Vielen Dank nochmals. Der Tip erspart mir eine Menge Arbeit.

Grüße, sjoe.

friend class VariableChildTreeIterator<S>;

Ich benutze Visual C++ 2008EE.

Die Definition von VariableChildTreeIterator greift auf den in VariableChildTree private deklarierten Bezeichner VariableChildTreeNode zu, aber nur die Spezialisierung VariableChildTreeIterator<S> mit S=T ist friend von VariableChildTree<T>. Das ist möglicherweise ein Fehler, vermutlich aber nicht der Grund, weshalb der Compiler ins Stolpern gerät.

Bei der Definition dessen auf das man von der inneren Klasse aus zugreifen kann ist der 98er Standard so weit ich weiß schlampig. (Das heißt er definiert gar nichts.) Im C++0x Standard wird so weit ich das überschauen kann das GCC Verhalten vorgeschrieben.

Er schreibt nichts spezielles vor. Sprich er besagt explizit, dass dieseleben Regeln, wie sonst gelten.

11.8 Nested classes schrieb:

The members of a nested class have no special access to members of an enclosing class, nor to classes or
functions that have granted friendship to an enclosing class; the usual access rules (clause 11) shall be
obeyed. The members of an enclosing class have no special access to members of a nested class; the usual
access rules (clause 11) shall be obeyed.