next »

[Crimsontide]

Did Average's suggestion about variadic templates work?

I'd love to try variadic templates, unfortunetly VC++ doesn't support them yet.  I decided to go with this solution:

Code:

template <typename T, T& F> void WrapperFunction () { /* stuff */ }
#define Wrap(X) WrapperFunction<decltype(X),X>()

Which works quite well.  Most often I want to do this sort of thing its for optimization, but here I needed the function as a template parameter because I needed it embedded in the type.

I was working on a recursive decent parser, but I wanted everything short of the actual parsing to be done with metaprogramming (mostly as an excuse to learn some new tricks/techniques).  Generally it works along the lines of:

Code:

auto digit = 0 | 1 | 2 | 3;   // ect....
auto num = +digit;
auto if = i >> f;
auto then = t >> h >> e >> n;
auto else = e >> l >> s >> e;
auto end = e >> n >> d;
auto ifelse = if >> expr >> then >> exp >> !(else >> exp) >> end;   // ! = 1 or none, expr defined elsewhere
auto p = SemanticAction(SomeFunc,ifelse);
// ect...

// parse
std::string str("stuff here to be parsed");
std::string::iterator i = str.begin();
Parse(p,i,str.end());

I needed to be able to add a semantic action, a function that would execute when a parser was recognized.  The thing here was, it needed to be a template parameter because all the parsing info is embedded in the type.

All in all it was a fun exercise, much was learned, and its nice to have something usable at the end of it all ; )

[Average Software]

Did Average's suggestion about variadic templates work?

Testing on gcc 4.4, the following works:

Code:

#include <iostream>

using std::cout;
using std::endl;

template <typename FuncType, typename... Args>
inline void Call(FuncType funk, Args... args)
{
    funk(args...);
}

void Zero()
{
    cout << "zero\n";
}

void One(int x)
{
    cout << "one: " << x << endl;
}

void Two(int x, int y)
{
    cout << "two: " << x << ' ' << y << endl;
}

int main()
{
    Call(Zero);
    Call(One, 5);
    Call(Two, 3, 10);
}

[increpare]

I like!

[Crimsontide]

Did Average's suggestion about variadic templates work?

Testing on gcc 4.4, the following works:

Code:

#include <iostream>

using std::cout;
using std::endl;

template <typename FuncType, typename... Args>
inline void Call(FuncType funk, Args... args)
{
    funk(args...);
}

void Zero()
{
    cout << "zero\n";
}

void One(int x)
{
    cout << "one: " << x << endl;
}

void Two(int x, int y)
{
    cout << "two: " << x << ' ' << y << endl;
}

int main()
{
    Call(Zero);
    Call(One, 5);
    Call(Two, 3, 10);
}

That's pretty sweet ; )

[Crimsontide]

For those who might be following this thread...  I made a really silly mistake   I can't believe it either, I really should've known better. 

So after playing around with what I thought was a fully working recursive decent parser, realized that I can't use recursion in the grammar definition, which means it isn't a true context free parser.  Its pretty much just a fancy (and hence slow) regular expression parser, which would be far better off parsed using a FSM.

The whole reason for this thread (passing functions as template arguments) still stands, but I still feel quite stupid I didn't catch such an obvious mistake FAR earlier.  Thanks for the responses anyways.

[Mikademus]

Hey, it is an interesting question nonetheless, and a good thread!

Average, good to see that we can use variadic arguments that way. Is there any way of obtaining the return type of the function so we can use that in the template declaration?

[BlueSweatshirt]

Did Average's suggestion about variadic templates work?

Testing on gcc 4.4, the following works:

Code:

#include <iostream>

using std::cout;
using std::endl;

template <typename FuncType, typename... Args>
inline void Call(FuncType funk, Args... args)
{
    funk(args...);
}

void Zero()
{
    cout << "zero\n";
}

void One(int x)
{
    cout << "one: " << x << endl;
}

void Two(int x, int y)
{
    cout << "two: " << x << ' ' << y << endl;
}

int main()
{
    Call(Zero);
    Call(One, 5);
    Call(Two, 3, 10);
}

If I knew about that whole "args..." thing, my life would have been so much easier over so many occasions. 

[EDIT]
Ahhh, it's a C++0x thing. Just found out by testing the code myself.

I just found a reason to truly love C++0x.

[Crimsontide]

Hey, it is an interesting question nonetheless, and a good thread!

Average, good to see that we can use variadic arguments that way. Is there any way of obtaining the return type of the function so we can use that in the template declaration?

I would assume (but haven't tested) you could extract them much like you do now with:

Code:

template <typename T> struct GetReturnType {};
template <typaneme TR, typename... ARGS> struct GetReturnType<TR (ARGS...)> { typedef TR type; };

I can't test it with VC++ yet (no variadic templates yet), and haven't had the time to install GCC.  So its just a guess...

[Average Software]

Hey, it is an interesting question nonetheless, and a good thread!

Average, good to see that we can use variadic arguments that way. Is there any way of obtaining the return type of the function so we can use that in the template declaration?

Yes.

Code:

#include <iostream>

using std::cout;
using std::endl;

template <typename FuncType, typename... Args>
inline auto Call(FuncType funk, Args... args) -> decltype(funk(args...))
{
    return funk(args...);
}

void Zero()
{
    cout << "zero\n";
}

void One(int x)
{
    cout << "one: " << x << endl;
}

void Two(int x, int y)
{
    cout << "two: " << x << ' ' << y << endl;
}

int RetInt()
{
    return 5;
}

float RetFloat()
{
    return 2.5;
}

int main()
{
    Call(Zero);
    Call(One, 5);
    Call(Two, 3, 7);

    cout << Call(RetInt) << endl;
    cout << Call(RetFloat) << endl;
}

[Mikademus]

Thanks! That's very high-level, and possibly highly useful!