how to create diffrent class implemantations based off template

Let's say I have this template class declared in my animal.hpp file:

enum class ANIMAL_TYPE{
     DOG,
     CAT,
};

template <ANIMAL_TYPE T>
class animal{
public:
    void makeSound();
    };

Pretty classic example used in explanations of interfaces and inheritance, but I want it to be known at compile time, and not be a virtual function, so I implemented it like this in the animal.cpp file:

template <>
class Animal<ANIMAL_TYPE::DOG>{
public:
    void makeSound(){
         std::cout << "woof";
    }
};

template <>
class Animal<ANIMAL_TYPE::CAT>{
public:
    void makeSound(){
         std::cout << "MEOW";
    }
};

template class Animal<ANIMAL_TYPE::DOG>;
template class Animal<ANIMAL_TYPE::CAT>;

And this in the main file:

#include <animal.hpp>


int main(){
    Animal<ANIMAL_TYPE::DOG> doggy;
    doggy.makeSound();
    return 0;
}

But when I compile and link this, I get an error during linking "undefined reference to Animal<(ANIMAL_TYPE)0>::makeSound"

Instead of instantiating the classes themselves, you should be instantiating the methods. In other words, instead of doing this:

template <>
class Animal<ANIMAL_TYPE::DOG>{
public:
    void makeSound(){
         std::cout << "woof";
    }
};

template <>
class Animal<ANIMAL_TYPE::CAT>{
public:
    void makeSound(){
         std::cout << "MEOW";
    }
};

You should be doing this:

template <>
void Animal<ANIMAL_TYPE::DOG>::makeSound()
{
    std::cout << "woof";
}

template <>
void Animal<ANIMAL_TYPE::CAT>::makeSound()
{
    std::cout << "MEOW";
}

Also, I've noticed that you have this at the bottom of animal.cpp.

template class Animal<ANIMAL_TYPE::DOG>;
template class Animal<ANIMAL_TYPE::CAT>;

Those have no effect in this case, you can just remove them.

EDIT: Okay, so if you want to have two template arguments, one of which is a type, and one that is not a type, you will need to directly instantiate the class, in the header because it's still a template, not a complete instantiation.

For example, let's say that the Animal class from before takes in a type argument.

template <ANIMAL_TYPE T, typename R>
class Animal{
    public:
    void makeSound(R foo);
};

You will have to instantiate it like this (Remember to put this in the header file, as it is still a template and not a complete instantiation).

template <typename R>
class Animal<ANIMAL_TYPE::DOG, R>{
    public:
    void makeSound(R foo)
    {
        std::cout << "woof";
    }
};

template <typename R>
class Animal<ANIMAL_TYPE::CAT, R>{
    public:
    void makeSound(R foo)
    {
        std::cout << "MEOW";
    }
};

Hopefully, this is helpful.