Velocity Reviews - Computer Hardware Reviews

Velocity Reviews > Newsgroups > Programming > C++ > Passing pointer to template function as argument to pointer to template function

Reply
Thread Tools

Passing pointer to template function as argument to pointer to template function

 
 
Vijai Kalyan
Guest
Posts: n/a
 
      11-08-2005
I was decomposing a task into different policies. Essentially, there is
a general option obtained from a server and user options obtained from
configuration variables. The two options are complementary to one
another.

So I proceeded to decompose the tasks that deal with user options into
two functions. Each of the functions do something and towards the end
they do supplementary tasks that depend on the server option.

The whole things fits in a framework which notifies listeners before
and after the main tasks and so the notification scheme for the
listeners are separate policies as well.

The whole thing is combinatorially complex and hence my decision to
split things up using templates as policies. Here is where I run into
my question: It is exemplified by the following simple code:

#include <iostream>

// main task function
template<class FuncPtr>
void Foo(FuncPtr ptr)
{
ptr();
}

// want to pass an instance of this to Foo
template<class X>
void Bar(X x)
{
x();
}

// want to pass pointer to this to Bar
void G()
{
std::wcout << "From G!" << std::endl;
}

int main()
{
Foo(&Bar(&G)); // doesn't work, coz Bar(&G) is a call to
// function Bar with pointer to G and
// inferred template argument

Foo(&Bar<G>); // don't work becuase the compiler could
// not infer the template argument
// type for overloadl function type from
// overloaded function type

Foo< Bar<G> >( &Bar<G> ); // doesn't work I suppose because
// I should pass the template type as
// pointer to Bar<G> but the compiler
// complains as "invalid template
// argument for FuncPtr; type
// expected"

typedef void (*GPtr) ();
typedef void (*BarGPtr)(GPtr) ;
Foo< BarGPtr >( &Bar<G> ); // doesn't work; compiler complains
// that param 1 for Foo cannot be
// converted from type void(T1) to
// BarGPtr. I suppose T1 is a temporary
// type?


return 0;
}

Any ideas on this?

thanks,

-vijai.

 
Reply With Quote
 
 
 
 
mlimber
Guest
Posts: n/a
 
      11-08-2005
Vijai Kalyan wrote:
> I was decomposing a task into different policies. Essentially, there is
> a general option obtained from a server and user options obtained from
> configuration variables. The two options are complementary to one
> another.
>
> So I proceeded to decompose the tasks that deal with user options into
> two functions. Each of the functions do something and towards the end
> they do supplementary tasks that depend on the server option.
>
> The whole things fits in a framework which notifies listeners before
> and after the main tasks and so the notification scheme for the
> listeners are separate policies as well.
>
> The whole thing is combinatorially complex and hence my decision to
> split things up using templates as policies. Here is where I run into
> my question: It is exemplified by the following simple code:
>
> #include <iostream>
>
> // main task function
> template<class FuncPtr>
> void Foo(FuncPtr ptr)
> {
> ptr();
> }
>
> // want to pass an instance of this to Foo
> template<class X>
> void Bar(X x)
> {
> x();
> }
>
> // want to pass pointer to this to Bar
> void G()
> {
> std::wcout << "From G!" << std::endl;
> }
>
> int main()
> {
> Foo(&Bar(&G)); // doesn't work, coz Bar(&G) is a call to
> // function Bar with pointer to G and
> // inferred template argument
>
> Foo(&Bar<G>); // don't work becuase the compiler could
> // not infer the template argument
> // type for overloadl function type from
> // overloaded function type
>
> Foo< Bar<G> >( &Bar<G> ); // doesn't work I suppose because
> // I should pass the template type as
> // pointer to Bar<G> but the compiler
> // complains as "invalid template
> // argument for FuncPtr; type
> // expected"
>
> typedef void (*GPtr) ();
> typedef void (*BarGPtr)(GPtr) ;
> Foo< BarGPtr >( &Bar<G> ); // doesn't work; compiler complains
> // that param 1 for Foo cannot be
> // converted from type void(T1) to
> // BarGPtr. I suppose T1 is a temporary
> // type?
>
>
> return 0;
> }
>
> Any ideas on this?
>
> thanks,
>
> -vijai.


How about using a functor instead (only changed code is shown):

template<class X>
struct Bar
{
X x_;
Bar( const X& x ) : x_( x ) {}
void operator()()
{
x_();
}
};

int main()
{
typedef void (*GPtr)();
Foo( Bar<GPtr>(G) );
return 0;
}

Cheers! --M

 
Reply With Quote
 
 
 
 
Vijai Kalyan
Guest
Posts: n/a
 
      11-08-2005
Yep, I thought about a functor, but I am not sure about using it purely
from an aesthetic perspective. But thanks anyway. If nobody comes up
with something then I will use a functor, but I still hope someone will
know what the syntax is ... I googled it, but came up with pageful of
results about function templates but not of pointers to them. It sure
would be nice to know!

regards,

-vijai.

 
Reply With Quote
 
John Carson
Guest
Posts: n/a
 
      11-08-2005
"Vijai Kalyan" <(E-Mail Removed)> wrote in message
news:(E-Mail Removed) oups.com
> I was decomposing a task into different policies. Essentially, there
> is a general option obtained from a server and user options obtained
> from configuration variables. The two options are complementary to one
> another.
>
> So I proceeded to decompose the tasks that deal with user options into
> two functions. Each of the functions do something and towards the end
> they do supplementary tasks that depend on the server option.
>
> The whole things fits in a framework which notifies listeners before
> and after the main tasks and so the notification scheme for the
> listeners are separate policies as well.
>
> The whole thing is combinatorially complex and hence my decision to
> split things up using templates as policies. Here is where I run into
> my question: It is exemplified by the following simple code:
>
> #include <iostream>
>
> // main task function
> template<class FuncPtr>
> void Foo(FuncPtr ptr)
> {
> ptr();
> }
>
> // want to pass an instance of this to Foo
> template<class X>
> void Bar(X x)
> {
> x();
> }


In that case, Foo is defined wrongly. If you pass an instance of Bar to Foo,
then ptr will be &Bar<something> so

ptr();

translates into

Bar<something>();

which is wrong because Bar<something> has an X parameter. You must call:

ptr(x);

However, your Foo function isn't set up to be able to make sense of this x
argument. Try this

template<class BarFuncPtr, class GFunctPtr>
void Foo(BarFuncPtr bptr, GFunctPtr gptr)
{
bptr(gptr);
}

// want to pass an instance of this to Foo
template<class X>
void Bar(X x)
{
x();
}

// want to pass pointer to this to Bar --- via Foo
void G()
{
std::wcout << "From G!" << std::endl;
}

int main()
{
typedef void (*GPtr) ();
Foo(&Bar<GPtr>, &G);
return 0;
}


--
John Carson

 
Reply With Quote
 
Vijai Kalyan
Guest
Posts: n/a
 
      11-08-2005
That's interesting. So, this means that Foo has to have knowledge of
the type and structure of it's argument in order to understand that its
second parameter has to be passed as an argument to its first
parameter. But, that makes them strongly coupled right? What if I later
wanted to use Foo with a function that was not a template?

Anyway, this is interesting to know.

Thanks for your help ... I finally went with Functors anyway!

regards,

-vijai.

 
Reply With Quote
 
 
 
Reply

Thread Tools

Posting Rules
You may not post new threads
You may not post replies
You may not post attachments
You may not edit your posts

BB code is On
Smilies are On
[IMG] code is On
HTML code is Off
Trackbacks are On
Pingbacks are On
Refbacks are Off


Similar Threads
Thread Thread Starter Forum Replies Last Post
Function pointer as template argument - does not work for function template avasilev C++ 4 12-22-2011 02:11 PM
Template argument as template argument nw C++ 0 04-14-2008 01:36 PM
Passing a function as an argument and using the evaluated functionas an argument User1014 Javascript 1 11-30-2006 12:13 PM
Passing function pointer as argument to a function??? Charles Sullivan C Programming 17 09-21-2005 05:10 PM
Passing template struct as an argument to a template function nifsmith C++ 5 09-27-2004 02:35 PM



Advertisments