Linker error with templates

I'm having a problem with the following scheme. If everything is in one source file, it compiles and links fine:

Code:

#include <iostream>

enum Type {TYPE_A, TYPE_B};

class Test
{
    public:
    template <Type N>
    void foo();
    
    void a();
    void b();
};

void Test::a()
{
    std::cout << "A\n";
}

void Test::b()
{
    std::cout << "B\n";
}

template <>
void Test::foo<TYPE_A>()
{
    a();
}

template <>
void Test::foo<TYPE_B>()
{
    b();
}

int main()
{
    Test t;
    t.foo<TYPE_A>();
    t.foo<TYPE_B>();
    std::cin.get();
}

However, when I try to break this up into multiple files (as follows), I get multiple definition of Test::foo<>. What am I missing?

Code:

//type.h
#ifndef TYPE_H
#define TYPE_H

enum Type {TYPE_A, TYPE_B};
#endif

//test.h
#ifndef TEST_H
#define TEST_H

#include "type.h"

class Test
{
    public:
    template <Type N>
    void foo();
    
    void a();
    void b();
};
#include "foo.cpp"
#endif

//test.cpp
#include "test.h"
#include <iostream>

void Test::a()
{
    std::cout << "A\n";
}

void Test::b()
{
    std::cout << "B\n";
}

//foo.cpp
template <>
void Test::foo<TYPE_A>()
{
    a();
}

template <>
void Test::foo<TYPE_B>()
{
    b();
}

//main.cpp
#include "test.h"
#include "type.h"
#include <iostream>
int main()
{
    Test t;
    t.foo<TYPE_A>();
    t.foo<TYPE_B>();
    std::cin.get();
}

(foo.cpp is not compiled separately.)

>> template <Type N>
Is that even proper syntax?

It looks ok to me, but if that's not the actual code then there might be something else different.

This is actual code.

template <Type N> is supposed to be a non-type template (Type is an enum) and I'm trying to create a specialization for each enum identifier.

Both main.cpp and test.cpp #include "test.h", which will #include "foo.cpp". So each has a copy?

[edit]Don't #include "foo.cpp" from test.h and instead do this?

Code:

//main.cpp
#include "test.h"
#include "type.h"
#include "foo.cpp"

[edit=2]And sorry for my now deleted trigger-happy first reply if you saw it.

My only guess is that you could be splitting up a template declaration from it's implementation, which would confuse the linker. I don't think that's the problem though.

Well, Dave's suggestion works but this seems to be going to give so much trouble that I'll just do with normal function parameters. I can't see now what kind of advantage I was hoping from templates.

Thanks

All my experience with Templates & splitting them into .h & .cpp files so far leaves me with the simple conclusion: Don't do that!
Template declaration & definition should be kept together in the .h file.

The problem is that placing all the code that is currently in foo.cpp inside the test.h header will cause the same error, so placing it inside the header file doesn't help.

I don't know what the problem is, but I expect it has something to do with template specializations for member functions. I know that there are extra restrictions on those.

Actually, marking the functions as inline seems to solve the problem on VC++ 7.1.