Ошибки линковки

Я пишу односвязный список и у меня есть несколько пар функций(рекурсивные и процедурные). Хочу включать разные типы функций отдельно. При включении блока с процедурными функциями - все работает хорошо. А вот с рекурсивными - ошибки линковки

#pragma once
#include <iostream>

//#define Normal_func
#define Recurs_func

template<typename type>
class LinkedList
{
private:
    template<typename type>
    class Node
    {
    public:
        Node* pNext;
        type data;

        Node(type elem = type(), Node* pNext = nullptr)
        {
            this->data = elem;
            this->pNext = pNext;
        }

        ~Node()
        {
        }
    };

    Node<type>* head;
    unsigned int len;

public:
    LinkedList();
    ~LinkedList();



    //Перегрузка оператора вывода 
    template<typename type>
    friend std::ostream& operator<<(std::ostream&, LinkedList<type>&);

    // Удалить первый элемент
    type pop_front();

    // Добавить элемент в начало
    void push_front(const type&);

    // Получить размер списка
    unsigned int size();

    // Очистить массив
    void clear();


/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

#ifdef Recurs_func

    type& getElem(int ind, int pos = 0, Node<type>* elem = nullptr);

    type popR(int ind, Node<type>* elem = nullptr, int pos = 0);

    void insertR(const type&, int ind, Node<type>* elem = nullptr, int pos = 0);

    void push_backR(const type& elem, int pos = 0, Node<type>* tmp = nullptr);

    type pop_backR(Node<type>* elem = nullptr, int pos = 0);

    type& operator[](int ind);



#define pop popR
#define insert insertR
#define push_back push_backR
#define pop_back pop_backR

#endif 
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////


/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

#ifdef Normal_func

    type pop(int ind);

    // Вставить элемент по индексу
    void insert(const type&, int ind);


    // Добавление элемента в конец списка 
    void push_back(const type&);

    // Удаление последнего элемента списка через цикл
    type pop_back();

    // Получение элемета по индексу
    type& operator[](int n);

#define pop         pop
#define insert      insert
#define push_back   push_back
#define pop_back    pop_back

#endif 

};
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////


/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

// Описание общих функций для двух наборов
template<typename type>
std::ostream& operator<< (std::ostream& out, LinkedList<type>& d)
{
    for (size_t i = 0; i < d.len; i++)
    {
        out << d[i] << " ";
    }
    return out;
}

template<typename type>
inline type LinkedList<type>::pop_front()
{
    Node<type>* tmp = head;
    type data = tmp->data;
    head = tmp->pNext;
    delete tmp;
    len--;
    return data;
}

template<typename type>
inline void LinkedList<type>::push_front(const type& elem)
{
    head = new Node<type>(elem, head);
    len++;
}

template<typename type>
unsigned int LinkedList<type>::size() { return len; }

template<typename type>
inline void LinkedList<type>::clear()
{
    while (len != 0)
    {
        pop_front();
    }
}


/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////




/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

#ifdef Recurs_func

template<typename type>
inline type& LinkedList<type>::getElem(int ind, int pos, Node<type>* elem)
{
    if (ind == 0)
    {
        elem = head;
        return elem->data;
    }
    else if (ind == pos) return elem->data;

    if (elem == nullptr) elem = head;

    if (ind != pos)
    {
        elem = elem->pNext;
        pos++;
        getElem(ind, pos, elem);
    }
    else return elem->data;
}

template<typename type>
type& LinkedList<type>::operator[](int ind){return getElem(ind);}

template<typename type>
inline void LinkedList<type>::push_backR(const type& elem, int pos, Node<type>* tmp)
{
    if (tmp == nullptr) tmp = head;

    if (pos != len)
    {
        tmp = tmp->pNext;
        pos++;
        return push_backR(elem, pos, tmp);
    }
    else
    {
        Node<type>* NewElem = new Node<type>(elem, tmp->pNext);
        tmp->pNext = NewElem;

        len++;
        return;
    }
}

template<typename type>
inline type LinkedList<type>::pop_backR(Node<type>* elem, int pos)
{

    if (pos == 0) elem = head;


    if (pos == len - 1)
    {
        Node<type>* tmp = elem->pNext;
        type data = tmp->data;
        tmp->pNext = nullptr;

        delete tmp;
        len--;
        return data;
    }
    else
    {
        elem = elem->pNext;
        pos++;
        return pop_backR(elem, pos);
    }
}

template<typename type>
inline void LinkedList<type>::insertR(const type& elem, int ind, Node<type>* tmp, int pos)
{

    if (ind == 0) return push_front(elem);
    if (tmp == nullptr) tmp = head;

    if (pos + 1 != ind)
    {
        tmp = tmp->pNext;
        pos++;
        return insertR(elem, ind, tmp, pos);
    }
    else
    {
        Node<type>* NewElem = new Node<type>(elem, tmp->pNext);
        tmp->pNext = NewElem;

        len++;
        return;
    }
}

template<typename type>
inline type LinkedList<type>::popR(int ind, Node<type>* elem, int pos)
{
    if (ind == 0) return pop_front();
    else if (pos == 0) elem = head;


    if (ind == pos - 1 || ind == 1)
    {
        type data = elem->pNext->data;
        Node<type>* tmp = elem->pNext;

        elem->pNext = elem->pNext->pNext;
        len--;
        delete tmp;
        return data;
    }
    else
    {
        elem = elem->pNext;
        pos++;
        return popR(ind, elem, pos);
    }
}


#endif

/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

#ifdef Normal_func

template<typename type>
type& LinkedList<type>::operator[](int n)
{
    int number = 0;

    Node<type>* cur = head;
    while (cur != nullptr)
    {
        if (number == n)
        {
            return cur->data;
        }
        cur = cur->pNext;
        number++;
    }
}


template<typename type>
inline void LinkedList<type>::push_back(const type& elem)
{
    if (head == nullptr)
    {
        head = new Node<type>(elem);
    }
    else
    {
        Node<type>* current = this->head;

        while (current->pNext != nullptr)
        {
            current = current->pNext;
        }
        current->pNext = new Node<type>(elem);

    }
    len++;
}


template<typename type>
inline void LinkedList<type>::insert(const type& elem, int ind)
{

    if (ind == 0) push_front(elem);
    else
    {
        Node<type>* tmp = head;

        for (size_t i = 0; i < ind - 1; i++)
        {
            tmp = tmp->pNext;
        }

        Node<type>* NewNode = new Node<type>(elem, tmp->pNext);
        tmp->pNext = NewNode;

        len++;
    }
}


template<typename type>
inline type LinkedList<type>::pop(int ind)
{
    if (ind == 0) return pop_front();

    Node<type>* interator = head;

    for (size_t i = 0; i < ind - 1; i++)
    {
        interator = interator->pNext;
    }

    type data = interator->pNext->data;
    Node<type>* tmp = interator->pNext;

    interator->pNext = interator->pNext->pNext;
    len--;
    delete tmp;
    return data;
}


template<typename type>
LinkedList<type>::LinkedList()
{
    len = 0;
    head = nullptr;
}


template<typename type>
LinkedList<type>::~LinkedList()
{
    clear();
}

#endif

/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////