使用头文件和源文件的模板化类

经过大量的研究，我明白了为什么模板类传统上不能分为头文件和源文件。

然而，这(为什么模板只能在头文件中实现?)似乎暗示你仍然可以有一种伪分离编译过程，通过在头文件的末尾包括实现文件，如下所示:

// Foo.h
template <typename T>
struct Foo
{
    void doSomething(T param);
};
#include "Foo.tpp"
// Foo.tpp
template <typename T>
void Foo<T>::doSomething(T param)
{
    //implementation
}

的解释是:"一个常见的解决方案是在头文件中编写模板声明，然后在实现文件(例如。tpp)中实现类，并将该实现文件包含在头文件的末尾。"

然而，当我这样做时，我得到多个错误，说明它是一个构造函数/方法/函数的重新定义。我已经能够通过在.cpp文件上放置include守卫来防止这种情况，这似乎是一种糟糕的做法。

我的主要问题是:

1. 什么是正确的方法来做到这一点与实现包括在头文件的底部?

2. 我的。cpp文件上的包含保护是否会阻止编译器为其他类型创建模板类/函数，因为它现在只能包含一次?

3. 首先使用头文件的部分原因是为了防止每次包含代码时都被复制，以保持较短的编译时间?那么，模板化函数(因为它们必须在头文件中定义)与简单地重载函数/类的性能影响是什么?什么时候应该使用它们?

下面是我自己的简单Node结构体代码的删节版本:

// Node.hpp
#ifndef NODES_H
#define NODES_H
#include <functional>
namespace nodes
{
    template<class Object>
    struct Node
    {
    public:
        Node(Object value, Node* link = nullptr);
        void append(Node tail);
        Object data;
        Node* next;
    };
    template<class Object> void prepend(Node<Object>*& headptr, Node<Object> newHead);
}
// Forward 'declaration' for hash specialization
namespace std
{
    template <typename Object>
    struct hash<nodes::Node<Object>>;
}
#include "Node.cpp"
#endif
// Node.cpp
// #ifndef NODE_CPP
// #define NODE_CPP
#include "Node.hpp"
template<class Object>
nodes::Node<Object>::Node(Object value, Node* link): data(value), next(link) {}
template<class Object>
void nodes::Node<Object>::append(Node tail) {
    Node* current = this;
    while (current->next != nullptr) {
        current = current->next;
    }
    current->next = &tail;
}
template<class Object>
void nodes::prepend(Node<Object>*& headptr, Node<Object> newHead) {
    Node<Object>* newHeadPtr = &newHead;
    Node<Object>* temporary = newHeadPtr;
    while (temporary->next != nullptr) {
        temporary = temporary->next;
    }
    temporary->next = headptr;
    headptr = newHeadPtr;
}
namespace std
{
    template <typename Object>
    struct hash<nodes::Node<Object>>
    {
        size_t operator()(nodes::Node<Object>& node) const
        {
            return hash<Object>()(node.data);
        }
    };
}
// #endif