C++Talk.NET

Mark Snelling · Guest

I wish to typedef a templated function for readability but cannot find
the correct syntax to do so. For example:

#include <iostream>

template< int I >
void foo()
{
std::cout << I << std::endl;
}

typedef foo< 2 > foo2; // <--- I wish to do something like this

int main( int argc, char* argv[] )
{
foo< 1 >();
foo2();

return 0;
}

In the above code I want to create a typedef for the function template
foo() using the value 2 as the template parameter. Is this even
possible?

Cheers,

Mark.

[ See http://www.gotw.ca/resources/clcm.htm for info about ]
[ comp.lang.c++.moderated. First time posters: Do this! ]

Ahti Legonkov · Guest

Mark Snelling wrote:

Hyman Rosen · Guest

Mark Snelling wrote:

Thomas Maeder · Guest

"Mark Snelling" <mark.snelling (AT) gmail (DOT) com> writes:

Carl Barron · Guest

In article <1130151737.073319.10660 (AT) f14g2000cwb (DOT) googlegroups.com>, Mark
Snelling <mark.snelling (AT) gmail (DOT) com> wrote:

Dan McLeran · Guest

If you want to do something like this, you need to declare an object of
type function pointer. You can do something like this:

#include <iostream>

template< int I >
void foo()
{
std::cout << I << std::endl;

}

//typedef foo< 2 > foo2; // <--- I wish to do something like this
typedef void (*FunctionType)();//type = function with no return value
and takes no parameters

FunctionType foo2 = &foo<2>;//foo2 = object of type FunctionType

int main( int argc, char* argv[] )
{
foo< 1 >();
foo2();

return 0;
}

Also check out boost::function and boost::bind.

[ See http://www.gotw.ca/resources/clcm.htm for info about ]
[ comp.lang.c++.moderated. First time posters: Do this! ]

archerzz · Guest

I think functor may satisfy your needs. For example:

#include <iostream>

template<int i>
struct foo
{
void operator()()
{
std::cout << i << std::endl;
}
};

foo<2> foo2;
int main(int argc, char *argv[])
{
foo2();
return 0;
}
You can defined arbitary versions of foo<int i>. Is that OK?

[ See http://www.gotw.ca/resources/clcm.htm for info about ]
[ comp.lang.c++.moderated. First time posters: Do this! ]

Fhulu Lidzhade · Guest

How about

template <void (*fptr)()>
struct func_t
{
void operator()()
{
(*fptr)();
}
};

int main()
{

typedef funct_t<foo<1> > foo1;
typedef func_t<foo<2> > foo2;

//call syntax changes somewhat
foo1()();
foo2()();
}

This way you have wrapped a function with type information, but you are
not incurring any call overhead that may be associated with
boost::function or boost::bind. You can also use the same technique for
non-template functions.

Cheers,
Fhulu

[ See http://www.gotw.ca/resources/clcm.htm for info about ]
[ comp.lang.c++.moderated. First time posters: Do this! ]

Fhulu Lidzhade · Guest

actually i'm wrong, you don't have to change the call syntax:

typedef funct_t<foo<1> > foo1;
typedef funct_t<foo<1> > foo2;;

foo1 f1;
f1();

foo2 f2;
f2();

[ See http://www.gotw.ca/resources/clcm.htm for info about ]
[ comp.lang.c++.moderated. First time posters: Do this! ]

werasm · Guest

Fhulu Lidzhade wrote:

vb · Guest

The value of the topic is that the author is looking for a shorter
notation on one hand (perhaps out of practical programming needs), and
also in mix-n-match of the template/typedef keywords on the other hand
(which constitutes an unusual combination of keywords).

AFAIU, you should distinguish between TYPES and INSTANCES of those
types:

foo<2> is not a type, it's an instantiation of the type void (*)()

The below compiles under VS2003:

#include "stdafx.h"
#include <iostream>

template< int I >
void foo()
{
std::cout << I << std::endl;
}

typedef void (*TFOO)();
TFOO foo2 = foo<2>;

int _tmain(int argc, _TCHAR* argv[])
{
foo< 1 >();
foo2();

return 0;
}

[ See http://www.gotw.ca/resources/clcm.htm for info about ]
[ comp.lang.c++.moderated. First time posters: Do this! ]