passing function template to class template

[Ali]

The code at the end of this message works just fine with M$ VS2005 but
with g++ 4.1.3 i get this:

node.cpp: In function ‘int main()’:
node.cpp:96: error: no matching function for call to
‘bnode<cxsc::interval>::bnode(cxsc::interval*, cxsc::interval*,
<unresolved overloaded function type>)’
node.cpp:38: note: candidates are: bnode<T>::bnode(const T*, const T*,
T (*)(const T&, const T&)) [with T = cxsc::interval]
node.cpp:34: note: bnode<T>::bnode() [with T =
cxsc::interval]
node.cpp:30: note: bnode<cxsc::interval>::bnode(const
bnode<cxsc::interval>&)
node.cpp:100: error: no matching function for call to
‘bnode<cxsc::interval>::bnode(cxsc::interval*, cxsc::interval*,
<unresolved overloaded function type>)’
node.cpp:38: note: candidates are: bnode<T>::bnode(const T*, const T*,
T (*)(const T&, const T&)) [with T = cxsc::interval]
node.cpp:34: note: bnode<T>::bnode() [with T =
cxsc::interval]
node.cpp:30: note: bnode<cxsc::interval>::bnode(const
bnode<cxsc::interval>&)

The crazy thing is that this

node<interval>* presult = new unode<interval(&x, exp);
interval r = presult->evaluate();

works with g++ 4.1.3 correctly. The class interval is from C-XSC here:
http://xsc.de .

Any help is appreciated.

-------------------------------------------------------------------------
[node.cpp]

#include "interval.hpp"
#include "imath.hpp"
using namespace cxsc;

#ifdef _MSC_VER
#define _CRTDBG_MAP_ALLOC
#include <stdlib.h>
#include <crtdbg.h>
#ifdef _DEBUG
#define new new( _NORMAL_BLOCK, __FILE__, __LINE__)
#else
#define DEBUG_NEW
#endif
#endif

template <class T>
class node {

public:

virtual const T evaluate() = 0;

virtual ~node();

};

template <class Tnode<T>::~node() {}

template <class T>
class bnode : public node<T{

public:

bnode<T() : node<T() {};

bnode<T(const T* const Arg1,
const T* const Arg2,
T Bop (const T&, const T&))

: node<T(), arg1(Arg1), arg2(Arg2), bop(Bop) { };

virtual const T evaluate();

~bnode<T>() {} ;

private:

const T* arg1;
const T* arg2;
T (*bop) (const T&, const T&);
};

template <class T>
const T bnode<T>::evaluate()
{
return (bop(*arg1, *arg2));
}

template <class T>
class unode : public node<T{

public:

unode<T() : node<T() {};

unode<T(const T* const Arg, T Uop (const T& ) )

: node<T(), arg(Arg), uop(Uop) { };

virtual const T evaluate();

~unode<T>() {} ;

private:

const T* arg;
T (*uop) (const T& );
};

template <class T>
const T unode<T>::evaluate()
{
return (uop(*arg));
}
int main() {

// exp(x + y*z)
interval x(2), y(3), z(0.5);

node<interval>* pyz = new bnode<interval(&y, &z, operator*);

interval yz = pyz->evaluate();

node<interval>* px_p_yz = new bnode<interval(&x, &yz, operator+);

interval x_p_yz = px_p_yz->evaluate();

node<interval>* presult = new unode<interval(&x_p_yz, exp);

interval r = presult->evaluate();

delete pyz;
delete px_p_yz;
delete presult;

#ifdef _MSC_VER
_CrtDumpMemoryLeaks();
#endif

return 0;

}

[Ali]

The simplified code is at post 'function pointer'.