Compile-time loop loops wrong

I just cannot seem to find why this weird behaviour.
Consider:

Code:

---

template<unsigned int N>
class Test
{
private:
        template<unsigned int Row, unsigned int Col>
        struct PropagatorLoop
        {
                void operator () () //(me_t& parent)
                {
                        //Gecode::when(parent, parent.m_Board(Col, Row), reinterpret_cast<void (*)(Gecode::Space&)>(&XNQueens::Propagator<Row, Col>), nullptr, Gecode::ICL_DEF);
                        PropagatorLoop<Row, Col + 1>()(/*parent*/);
                }
        };

        template<unsigned int Row>
        struct PropagatorLoop<Row, N>
        {
                void operator () ()// (me_t& parent)
                {
                        std::cout << N;
                        PropagatorLoop<Row + 1, 0>()(/*parent*/);
                }
        };

        template<>
        struct PropagatorLoop<N, N>
        {
                void operator () ()// (me_t& parent)
                {
                }
        };

public:
        Test() { PropagatorLoop<0, 0>()(); }
};

int main()
{
        Test<8>();
}

---

When calling PropagatorLoop<0, 0>()(),

template<unsigned int Row>
struct PropagatorLoop<Row, N>

matches instead of

template<unsigned int Row, unsigned int Col>
struct PropagatorLoop

I just cannot understand why (clearly, we are calling <0, 0>, not <0, 8>). If I replace "N" with 8, it works as expected (at least for the beginning of the loop).
I only tested on MSVC. Anyone have any insight into this behaviour?

Test with another compiler. This looks very much like a bug to me.
However, I'm pretty sure that the full specialization of PropagatorLoop isn't allowed inside the outer template by pickier compilers, and you have to move it out of Test.

I must be missing something, because I fail to see how that code would compile, let alone run.

My recollection is that an explicit template specialisation (as starts on line 25) cannot be done within scope of a class.

I don't have a compiler handy to check right now though.

That's ... weird.
Moving it outside causes the loop to run properly:

Code:

---

#include <iostream>

template<unsigned int N, unsigned int Row, unsigned int Col>
struct PropagatorLoop
{
    void operator () () //(me_t& parent)
    {
        //Gecode::when(parent, parent.m_Board(Col, Row), reinterpret_cast<void (*)(Gecode::Space&)>(&XNQueens::Propagator<Row, Col>), nullptr, Gecode::ICL_DEF);
                std::cout << "PropagatorLoop<N, Row, Col>\n";
        PropagatorLoop<N, Row, Col + 1>()(/*parent*/);
    }
};
 
template<unsigned int N, unsigned int Row>
struct PropagatorLoop<N, Row, N>
{
    void operator () ()// (me_t& parent)
    {
                std::cout << "PropagatorLoop<N, Row, N>\n";
        PropagatorLoop<N, Row + 1, 0>()(/*parent*/);
    }
};
 
template<unsigned int N>
struct PropagatorLoop<N, N, N>
{
    void operator () ()// (me_t& parent)
    {
                std::cout << "PropagatorLoop<N, N, N>\n";
    }
};
 

template<unsigned int N>
class Test
{
private:

public:
    Test() { PropagatorLoop<N, 0, 0>()(); }
};
 
int main()
{
    Test<8>();
}

---

I'm just going to do that, then.

Quote:

---

Originally Posted by grumpy

I must be missing something, because I fail to see how that code would compile, let alone run.

My recollection is that an explicit template specialisation (as starts on line 25) cannot be done within scope of a class.

I don't have a compiler handy to check right now though.

---

It may be that MSVC is lenient in this case. The compiler is very forgiving when it comes to templates, allowing stuff that really shouldn't compile.

Quote:

---

Originally Posted by Elysia

It may be that MSVC is lenient in this case. The compiler is very forgiving when it comes to templates, allowing stuff that really shouldn't compile.

---

Yes I believe that is the case.