Kurze umrissen, es geht um ein Strategy-Pattern das die Funktionalität des Threads kapseln soll. Das erste was ich nicht verstanden habe ist, wieso muss ich bei der "friend class"-Deklaration die Typen des Templates mit angeben? Bzw in meine Fall hab ich jetzt die StartInfos-Klasse auch mit TemplateParameter versehen.

Und beim 2ten Problem versteh ich das auftrettene Problem beim MinGW (gcc under Windows) nicht. Beim Visual C++ 2010 (unmanaged) kann ich es ohne Probleme übersetzten im Gcc kommen immer diese 4 Fehlermeldungen:

[...]\Task.h|63|error: explicit specialization in non-namespace scope `class Task<Action, Thread>'|
[...]\Task.h|63|error: enclosing class templates are not explicitly specialized|
[...]\Task.h|64|error: `PrepareThread' is not a function template|
[...]\Task.h|64|error: invalid function declaration|

In dem unten folgenden Code entspricht die Zeile 63 der 38.

Und hier der Code dazu:

// Vorwaertsdeklaration
      template <typename Action, typename Thread>
      class Task;
      class CWinThread;
      class ThreadPool;

      // Klasse zur Zwischenspeicherung
      template <typename Action, typename Thread>
      class StartInfos {
            friend class Task<Action, Thread>; // Dies hier war das erste Problem
            friend class ThreadPool;

         private:
            StartInfos( void*f, void* p ) : _function(f), _parameter(p) {};
            void* _function;
            void* _parameter;
      };

      // Das Strategy-Pattern
      template <typename Action, typename Thread>
      class Task {
         public:
            Task() {}
            virtual ~Task() {}

            void operator () ( Action *action, void* param ) {
               m_Action = action;
			   Thread *w = NULL:
               PrepereThread( w, param );
            }
         protected:
         private:
            template <typename W>
            void PrepareThread( W* w, void* parameter ) {
               StartInfos<Action, Thread>* infos = new StartInfos<Action, Thread>( m_Action, parameter );
               W::CreateThread( StartFunctionFunc, infos );
            }
            template <> //Und dies hier das 2te
            void PrepareThread<CWinThread>( CWinThread* w, void* parameter ) {
               StartInfos<Action, Thread>* infos = new StartInfos<Action, Thread>( m_Action, parameter );
               w = AfxBeginThread( StartFunctionFuncAfx, infos )
            }

            static void StartFunctionFunc( void* param ) {
               StartInfos<Action, Thread>* infos = static_cast<StartInfos<Action, Thread>*>( param );
               Action& action = *static_cast<Action*>( infos->_function );
               action( infos->_parameter );
               delete infos;
            }

            static unsigned int StartFunctionFuncAfx( void* param ) {
               StartInfos<Action, Thread>* infos = static_cast<StartInfos<Action, Thread>*>( param );
               Action& action = *static_cast<Action*>( infos->_function );
               action( infos->_parameter );
               delete infos;
               return 0;
            }

            Action* m_Action;
      };

Vielen Dank für die Hilfe.
Mfg Marco

Das erste was ich nicht verstanden habe ist, wieso muss ich bei der "friend class"-Deklaration die Typen des Templates mit angeben?

weil man nur konkrete klassen und funktionen zum friend erklären kann, nicht aber eine ganze klassen-familie.

Und beim 2ten Problem versteh ich das auftrettene Problem beim MinGW (gcc under Windows) nicht. Beim Visual C++ 2010 (unmanaged) kann ich es ohne Probleme übersetzten im Gcc kommen immer diese 4 Fehlermeldungen:

der c++-standard erlaubt es schlicht nicht, ein nested template zu spezialisieren, ohne die umgebenden template-parameter ebenfalls zu spezifizieren. wenn vc++2010 es erlaubt, dann ist das eine erweiterung des standards (versuch's mal mit vc++2010 und deaktivierten erweiterungen).

ausweg aus der situation bietet folgendes pattern:
http://stackoverflow.com/questions/568046/nested-template-specialization

ru,
cirion

Hat sehr geholfen, jetzt schaut der Code zwar sehr STL-Mässig aus aber scheint zu funktionieren

Mfg Marco