virtual und template



  • Folgender Code lässt sich compilieren unter gnu g++ 4.8.1
    Ich bin mir aber nicht sicher ob die virtual function "callFunc" so richtig ist.
    Habt ihr bessere Ideen, muss allerdings auch noch kompatible zum
    alten Borland Compiler 5.5 (glaub das 98 standard) bleiben.

    #include <algorithm>
    #include <iostream>
    #include <string>
    #include <boost/function.hpp>
    #include <boost/bind.hpp>
    
    template<typename functype,typename checktype>
    struct FunctionAndType
    {
    	functype m_CheckFunc ;
    	checktype m_Type ;
    	typedef  functype function_type ;
    	typedef  checktype check_type ;
    
    	FunctionAndType(functype aFuncType,checktype aType)
    	:m_CheckFunc(aFuncType),m_Type(aType)
    	{}
    };
    
    template<typename checktype,typename type_of_result,typename functype>
    class SimpleCheckMakerBase : public std::unary_function<const FunctionAndType<functype,checktype> &,void>
    {
    public:
    protected:
    		virtual bool callFunc(const FunctionAndType<functype,checktype> &func_and_type)=0 ;
    public:
    		void operator()(const FunctionAndType<functype,checktype> &func_and_type)
    		{
    			const bool check=callFunc(func_and_type) ;		
    			std::cout << check << "\n" ;
    		}
    };
    
    typedef typename boost::function1<bool,int> SimplecheckFunc ;
    
    template <typename checktype,typename type_of_result>
    class SimpleCheckResultMaker : public SimpleCheckMakerBase<checktype,type_of_result,SimplecheckFunc>
    {
    private:
    protected:
    	virtual bool callFunc(const FunctionAndType<SimplecheckFunc,checktype> &func_and_type)
    	{
    		return func_and_type.m_CheckFunc(1) ;
    	}	
    };
    
    typedef boost::function2<bool,int,const std::string &> SimplecheckFuncWithInputCheckdata ;
    
    template <typename checktype,typename type_of_result>
    class SimpleCheckResultMakerWithInputCheckdata : public SimpleCheckMakerBase<checktype,type_of_result,SimplecheckFuncWithInputCheckdata>
    {
    private:	
    protected:
    	virtual bool callFunc(const FunctionAndType<SimplecheckFuncWithInputCheckdata,checktype> &func_and_type)
    	{
    		return func_and_type.m_CheckFunc(1,"hello world") ;
    	}
    };
    
    bool equal1(int value)
    {
    	std::cout << value << ";" << "\n" ;
    	return value==2 ;
    }
    
    bool equal2(int value,const std::string &str)
    {
    	std::cout << value << ";" << str << "\n" ;
    	return value==1 && str=="hello world" ;
    }
    
    int main()
    {
    	typedef FunctionAndType<SimplecheckFunc,int> FunctionAndType1 ;	
    	FunctionAndType1 testfunc1(&equal1,1) ;	
    	SimpleCheckResultMaker<int,FunctionAndType1>()(testfunc1) ;
    
    	typedef FunctionAndType<SimplecheckFuncWithInputCheckdata,int> FunctionAndType2 ;	
    	FunctionAndType2 testfunc2(&equal2,1) ;	
    	SimpleCheckResultMakerWithInputCheckdata<int,FunctionAndType2>()(testfunc2) ;
    }
    


  • Es wäre außerordentlich hiflreich, wenn du uns auch die genaue Fehlermeldung deines Compilers mitteilen würdest... 😉



  • Es lässt compilieren, das ist nicht das Problem.
    Mir geht es darum die virtuelle Funktion raus zu werfen.



  • Oh sry, ich sollte heute wohl mal früher schlafen gehn... 🤡



  • Kompatibel zu Borland 5.5?
    Wir benutzen das Codegear RAD Studio 2007 (das ca. 10 Jahre jünger ist als BCC 5.5) und das unterstützt kein boost::function . Überhaupt wäre ich mit boost da sehr, sehr vorsichtig, da gilt im Zusammenhang mit BCC : kompiliert != funktioniert.



  • DocShoe schrieb:

    Kompatibel zu Borland 5.5?
    Wir benutzen das Codegear RAD Studio 2007 (das ca. 10 Jahre jünger ist als BCC 5.5) und das unterstützt kein boost::function . Überhaupt wäre ich mit boost da sehr, sehr vorsichtig, da gilt im Zusammenhang mit BCC : kompiliert != funktioniert.

    Man muss nur mit den Boostversionen aufpassen. Zu "Neue" funktionieren natürlich nicht. Mit dem C++Builder 6 funktioniert 1.33.1 problemlos = das was compiliert funktioniert auch.



  • Du hast schon recht mit dem Borland Compiler.
    Wir setzen hier eine uralt Version von boost ein, glaube ist die erste Version von Boost.
    Die Sachen aus Boost Uralt Version sind schon mit vorsichtig zu geniessen.
    Hab aber mit boost::function noch keine Probleme gehabt.
    Benutze allerdings die portable Syntax in der Form
    boost::function2<float, int,int> f;

    Die Iteratoren aus der Boost machen da mehr Probleme (filter_iterator,transform_iterator)


Log in to reply