Ich versuche gerade das Intercepting Filters Pattern (siehe http://www.nullskull.com/articles/20060609.asp) für C++ nachzuimplementieren.
Das Pattern nutzt Templates um Daten jeglichen Typs verarbeiten zu können.

Ein zentrales Element in diesem Pattern ist das Instanzieren von Klassen via Strings. Da das in C++ nicht so einfach klappt wie in C# habe ich folgende Lösung von hier (http://stackoverflow.com/questions/582331/is-there-a-way-to-instantiate-objects-from-a-string-holding-their-class-name) versucht nzu nutzen und in das Pattern zu integrieren.

Allerdings laufe ich jetzt auf Grund meiner geringen Programmiererfahrung mit Templates in ein Problem. Zunächst mal der relevante SourceCode:

//File: abstractfilter.hpp
#ifndef ABSTRACTFILTER_H
#define ABSTRACTFILTER_H

#include <boost/unordered_map.hpp>
#include <boost/foreach.hpp>

#include "ifilter.h"

namespace ccns
{
    namespace util
    {
        template<typename TF>
        class AbstractFilter : public IFilter<TF>
        {
        public:
            template<typename T> IFilter<TF>* createTemplate() {return new T;}

            struct FilterFactory
            {
                typedef boost::unordered_map<std::string, IFilter<TF>*(*)()> FilterMap;

                static IFilter<TF>* createFilterInstance(const std::string &name)
                {
                    BOOST_FOREACH(FilterMap entry, getMap())
                        {
                            if(name.compare(entry.first) == 0)
                                return entry.second;
                        }
                    return NULL;
                }

            protected:
                static FilterMap* getMap()
                {
                    if(filters != NULL)
                        filters = new FilterMap;
                    return filters;
                }

            private:
                static FilterMap *filters;
            };

            template<typename T>
            struct FilterRegister : FilterFactory
            {
                FilterRegister(const std::string& name)
                {
                    FilterFactory::getMap()->insert(typename FilterFactory::FilterMap::value_type(name, &createTemplate<T>));
                }
            };

            virtual bool process(TF){return true;}

        protected:
        };
    }
}

#endif // ABSTRACTFILTER_H

In dieser Zeile:

FilterFactory::getMap()->insert(typename FilterFactory::FilterMap::value_type(name, &createTemplate<T>));

tritt nun folgender Compile-Error auf:

In file included from samplefilter.h:6:0,
from samplefilter.cc:1:
abstractfilter.hpp: In constructor ‘ccns::util::AbstractFilter<TF>::FilterRegister<T>::FilterRegister(const string&) [with T = ccns::util::SampleFilter, TF = std::basic_string<char>, std::string = std::basic_string<char>]’:
samplefilter.cc:5:125: instantiated from here
abstractfilter.hpp:53:21: error: no matching function for call to ‘std::pair<const std::basic_string<char>, ccns::util::IFilter<std::basic_string<char> >* ()()>::pair(const string&, <unresolved overloaded function type>)’
abstractfilter.hpp:53:21: note: candidates are:
/usr/include/c++/4.6/bits/stl_pair.h:108:21: note: template<class _U1, class _U2> std::pair::pair(const std::pair<_U1, _U2>&)
/usr/include/c++/4.6/bits/stl_pair.h:103:26: note: std::pair<_T1, _T2>::pair(const _T1&, const _T2&) [with _T1 = const std::basic_string<char>, _T2 = ccns::util::IFilter<std::basic_string<char> > ()()]
/usr/include/c++/4.6/bits/stl_pair.h:103:26: note: no known conversion for argument 2 from ‘<unresolved overloaded function type>’ to ‘ccns::util::IFilter<std::basic_string<char> > (* const&)()’
/usr/include/c++/4.6/bits/stl_pair.h:99:26: note: std::pair<_T1, _T2>::pair() [with _T1 = const std::basic_string<char>, _T2 = ccns::util::IFilter<std::basic_string<char> >* ()()]
/usr/include/c++/4.6/bits/stl_pair.h:99:26: note: candidate expects 0 arguments, 2 provided
/usr/include/c++/4.6/bits/stl_pair.h:87:12: note: std::pair<const std::basic_string<char>, ccns::util::IFilter<std::basic_string<char> > ()()>::pair(const std::pair<const std::basic_string<char>, ccns::util::IFilter<std::basic_string<char> > (*)()>&)
/usr/include/c++/4.6/bits/stl_pair.h:87:12: note: candidate expects 1 argument, 2 provided

Soweit ich die Fehlermeldung verstehe ist der Typ von &createTemplate<T> den Compiler unbekannt.

Meine Fragen dazu:

1. Wieso ist das so?
2. Wie kann ich das Problem lösen?

LG
Daniel

2. createTemplate soll vermutlich static sein

template<typename T> static IFilter<TF>* createTemplate() {return new T;}

Ich schau mir diese mal genau an und wenn ich nicht weiter komme melde ich mich nochmal.

LG
Daniel