Problem mit Template: <unresolved overloaded function type>



  • Hallo,

    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


  • Mod

    1. AbstractFilter<TF>::createTemplate<T> ist eine nichtstatische Memberfunktion. Zeiger auf Memberfunktionen sind keine Funktionszeiger (und also inkompatibel mit IFilter<TF>()()), außerdem können sie stets nur über einen qualifizierten Bezeichner erzeugt werden.

    2. createTemplate soll vermutlich static sein

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


  • Hey Danke! Jetzt kommt der Compiler schon ein Stück weiter. Alledings bekomme ich immer noch Fehlermeldungen die sehr kryptisch sind 😞

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

    LG
    Daniel


Log in to reply