Использование шаблона класса в другом классе с++

Question

Добрый день! Хочу использовать шаблон класса стек в другом классе, в котором мне нужны будут стек для int и стек для char. Получаю ошибку линковщика:

Undefined symbols for architecture x86_64: "Stack::pop()", referenced from: StringParser::calculateOperator(char) in StringParser.o "Stack::push(int const&)", referenced from: StringParser::calculateOperator(char) in StringParser.o "Stack::Stack()", referenced from: StringParser::StringParser() in StringParser.o StringParser::StringParser(String&) in StringParser.o "Stack::~Stack()", referenced from: StringParser::~StringParser() in StringParser.o ld: symbol(s) not found for architecture x86_64 clang: error: linker command failed with exit code 1 (use -v to see invocation)

Подскажите, пожалуйста, в чем дело.

Stack.cpp

#include "Stack.hpp"

template <typename Type>
Stack<Type>::Stack()
{
    stackData = new Type[stackSize];
    top = -1;
}

template <typename Type>
Stack<Type>::Stack(const Stack& otherStack)
{
    stackData = new Type[stackSize];
    top = otherStack.getTop();
    for (int i = 0; i < top; i++) {
        stackData[i] = otherStack.getPtr()[i];
    }
}

template <typename Type>
Stack<Type>::~Stack()
{
    cout << "delete stack" << endl;
    delete [] stackData;
}

template <typename Type>
void Stack<Type>::printStack()
{
    for (int i = top; i >= 0; i--) {
        cout << stackData[i] << " ";
    }
    cout << endl;
}

template <typename Type>
void Stack<Type>::push(const Type& value)
{
    if (top < stackSize)
    {
        stackData[++top] = value;
    }
}

template <typename Type>
Type Stack<Type>::pop()
{
    if (top > -1)
    {
        return stackData[top--];
    }
    else return 'Z';

}

template <typename Type>
int Stack<Type>::getTop() const
{
    return top;
}

template <typename Type>
Type* Stack<Type>::getPtr() const
{
    return stackData;
}

template <typename Type>
Stack<Type>& Stack<Type>::operator=(const Stack& otherStack)
{
    if (this != &otherStack)
    {
        delete [] this->stackData;
        this->stackData = new Type[stackSize];
        this->top = otherStack.getTop();

        for (int i = 0; i < this->top; i++)
        {
            this->stackData[i] = otherStack.stackData[i];
        }
    }
    return *this;
}

template <typename Type>
Type Stack<Type>::operator[](int index)
{
    return stackData[index];
}

template <typename Type>
Type Stack<Type>::getHead()
{
    return stackData[top];
}

StringParser.cpp

#include "StringParser.hpp"

StringParser::StringParser()
{
    resultString = new String;
    tempStack = new Stack <int>;
    parsingString = new String;
}

StringParser::StringParser(String& initString)
{
    resultString = new String;
    tempStack = new Stack <int>;
    parsingString = new String;
    *parsingString = initString;
}

StringParser::~StringParser()
{
    cout << "delete parser" << endl;
    delete resultString;
    delete tempStack;
    delete parsingString;
}

bool StringParser::parsingIsOver(char* symbol) const
{
    return *symbol == '\0';
}

char* StringParser::getChar(int index)
{
    return &parsingString->getStringPtr()[index];
}


void StringParser::calculateOperator(char oper)
{
    int left = tempStack->pop();
    int right = tempStack->pop();
    switch (oper) {
        case '+':
            tempStack->push(left + right);
            break;
        case '-':
            tempStack->push(left - right);
            break;
        case '*':
            tempStack->push(left *right);
            break;
        case '/':
            tempStack->push(left/right);
            break;
        default:
            break;
    }
}