Thread: Specializing inner template based on static const member of outer template parameter

Take for instance the following program:

Code:

#include <iostream>

class A
{
public:
    static const int N = 6;
};

template <typename AParam>
class B
{
public:
    template <int X>
    static void foo()
    {
        std::cout << "I'm X" << std::endl;
    }

    template <>
    static void foo<AParam::N>()
    {
        std::cout << "I'm the magic value" << std::endl;
    }
};

int main()
{
    B<A>::foo<1>();
    B<A>::foo<6>();
}

With Visual C++ 2010, this compiles and outputs the following, which is what I would like:

Code:

I'm X
I'm the magic value

gcc however will not compile the code:

Code:

test.cpp:20:15: error: explicit specialization in non-namespace scope 'class B<AParam>'
test.cpp:21:32: error: template-id 'foo<AParam:: N>' in declaration of primary template

Why not? Which compiler is wrong?

Why not?

You can't specialize a nested template without specializing its containing template.

[Edit]
Oh, but you can specialize the behavior through "CRTP" and indirection.

Let me know if you need an example.
[/Edit]

Which compiler is wrong?

MSVC2k10 is wrong.

In the future, try checking Comeau out at their website.

[Edit]
Oh, and the use of the nested datum from the parameter isn't the problem.
[/Edit]

Soma

Originally Posted by phantomotap

You can't specialize a nested template without specializing its containing template.

Hmm. Well, I can take <int X> off of the function and put it on class B, and specialize class B. It would have been more compact the way I have written it, but oh well.

What I'm really trying to do is refactor this:

Code:

int x = GetValue();
int y = GetValue();
if      (x == 0 && y == 0) Foo<0, 0>();
else if (x == 0 && y == 1) Foo<0, 1>();
else if (x == 0 && y == 2) Foo<0, 2>();
else if (x == 1 && y == 0) Foo<1, 0>();
else if (x == 1 && y == 1) Foo<1, 1>();
else if (x == 1 && y == 2) Foo<1, 2>();
else if (x == 2 && y == 0) Foo<2, 0>();
else if (x == 2 && y == 1) Foo<2, 1>();
else if (x == 2 && y == 2) Foo<2, 2>();

In reality the two quantities take on 8 different values, that's 64 combinations, and I don't want to hand-write the above pairings. Maybe it's not obvious how my original question fits into this, but it has to do with how I'm representing the sequence of values the specializations go through, and handling the recursion in the metaprogram through the different combinations.

If someone has a slick way of doing the above I'd love to see it.

Here's what I want to do. I have two variables, call them X and Y. They only take on values from 0 through 7. Imagine for a moment we're in crazy land and I could write something like this:

Code:

int foo(int x, int y)
{
    invoke<x, y>();
}

That expresses what I want to do, though of course I can't actually do that. But because X and Y are limited in range, I can achieve this by explicitly listing the possibilities:

Code:

int foo(int x, int y)
{
    if (x == 0 && y == 0) invoke<0, 0>();
    if (x == 0 && y == 1) invoke<0, 1>();
    if (x == 0 && y == 2) invoke<0, 2>();
    // I don't have to go on forever, because only 0 through 7 will ever occur
}

Now, that's FINE, but I want to make this generic because this pattern comes up several times. In a previous version, I used a header file to do this:

Code:

// InvokePair.h
INVOKE_PAIR(0,0)
INVOKE_PAIR(0,1)
INVOKE_PAIR(0,2)
...
// Other code
#define INVOKE_PAIR(X, Y) if(X == x && Y == y) Invoke<X, Y>();
#include "InvokePair.h"
#undef INVOKE_PAIR

But I f'ing hate that. Now I have some other script which generates InvokePair.h for me. Thus I want to solve the problem once and for all with a template recursion.

Thus I want to solve the problem once and for all with a template recursion.

Ah, so you don't actually even want what I thought.

So, before I give this any more thought, let me verify my current understanding.

1) The variables in question are truly variables, expressions involving values not known at compile time.

2) You don't mind if the tests are performed at runtime so long as the logic isn't explicitly stated for every case.

3) You don't necessarily always invoke the same function, but the relationship between the values and the target function is expressed by explicit template function invocation.

4) The values to be correlated follow a set pattern.

5) The values always have a known and limited range.

6) The values express some association unto themselves. (They are a pair or tuple of some kind.)

[Edit]
7) You realize that template recursion and iteration always involves recursion.

8) As the goal requires runtime evaluation of an expression the solution involving template recursion will necessarily involve calling a recursive function template at runtime for each value or combination of values in the target correlation every time the interface function is called.
[/Edit]

Soma

All six of your assumptions are correct.

Code:

template <template <int, int> invoke>
int foo(int x, int y)
{
    invoke<x, y>();
}

Again, I realize that's not C++ but it expresses exactly what I want. The template parameters to invoke<> are always numerically equal to the runtime variables x and y. I suppose for generality they could be functions of x and y, but that's easy to add later and unnecessary for the moment.

I also realize comparisons will be made at runtime, that's perfectly okay, I just don't want to have to spell it all out manually.

I got it working with the following:

EDIT: Your solution allows some additional flexibility that I may need later, so thanks for posting it.

Code:

#include <iostream>

template <int X, int Y>
class MyInvoke
{
public:
	static void Invoke()
	{
		std::cout << X << ", " << Y << std::endl;
	}
};

template <int X, int Y, template <int, int> class F>
class PairInvokerHelper
{
public:
	static void Invoke(int x, int y)
	{
		PairInvoker<X, Y+1, F>::Invoke(x, y);
	}
};

template <int X, template <int, int> class F>
class PairInvokerHelper<X, 7, F>
{
public:
	static void Invoke(int x, int y)
	{
		PairInvoker<X+1, 0, F>::Invoke(x, y);
	}
};

template <template <int, int> class F>
class PairInvokerHelper<7, 7, F>
{
public:
	static void Invoke(int x, int y)
	{
	}
};


template <int X, int Y, template <int, int> class F>
class PairInvoker
{
public:
	static void Invoke(int x, int y)
	{
		if (X == x && Y == y)
			F<X, Y>::Invoke();
		else
			PairInvokerHelper<X, Y, F>::Invoke(x, y);
	}
};

template <template <int, int> class F>
void PairInvoke(int x, int y)
{
	PairInvoker<0, 0, F>::Invoke(x, y);
}

int main()
{
	for (int x = 0; x < 8; ++x)
	{
		for (int y = 0; y < 8; ++y)
		{
			PairInvoke<MyInvoke>(x, y);
		}
	}
}