c++ why can't class template hide its implementation in cpp file?

类似的问题还有： why can't class template use Handle Class Pattern to hide its implementation? || why there are linker problems (undefined reference) to my class template?

我出现问题的源码（见main.cpp,Stack.h,Stack.cpp）（本来是准备用来展示Handle Class Pattern如何实现implementation-hiding），报错如下：

问题的本质&解决办法：

http://stackoverflow.com/questions/8752837/undefined-reference-to-template-class-constructor

http://www.parashift.com/c++-faq-lite/templates-defn-vs-decl.html

http://stackoverflow.com/questions/5417465/separating-template-interface-and-implementation-in-c

http://stackoverflow.com/questions/18121071/hiding-template-implementation-details-from-doxygen

方法1：Explicitly instantiate the template, and its member definitions

方法2：Copy the implemtation code of the class template into its header file

总结：

虽然有2种解决办法，但是方法一显然“太笨”，而且“太不灵活”

So, if you plan to create your own class template, then you just don't need to consider enforcing implementation hiding as you do to normal classes, the only way to hide the implementation of  a class template is not to provide its header. 

On the other hand, if you decide to design something to be a class template, you must be sure there's nothing need to be hidden for that template, for example: encryption algorithm or other sensitive stuff.

Insight Comment：

The very goal of template is to create a "pattern" so that the compiler can generate classes and functions for a multitude of unrelated types. If you hide this pattern, how do you expect the compiler to be able to generate those classes and functions ?

代码：

main.cpp

#include "Stack.h"

#include <iostream>

using namespace std;

class Box {
public:
    Box():data(0), ID(num++) { cout << "Box" << ID << " cons" << endl; }
    Box(const Box &copy): data(copy.data), ID(num++) { cout << "Box" << ID << " copy cons" << endl; }
    ~Box() { cout << "Box" << ID << " des" << endl; }
    int data;
private:
    static int num;
    const int ID;
};

int Box::num = 1;

int main()
{
    Box b1,b2,b3;
    Stack<Box> bstack;
    bstack.push(b1);
    bstack.push(b2);
    bstack.push(b3);
    return 0;
}

Stack.h

#ifndef STACK_H
#define STACK_H

#include <cstddef>

template <typename T>
class StackImpl; // Stack implementation (hidden), private part
                // will not be seen by clients

template <typename T>
class Stack
{
    public:
        Stack();
        ~Stack();
        /**
            Inserts a new element at the top of the stack,
            above its current top element.
            The content of this new element is
            initialized to a copy of val.
            @param val value to which the inserted element is initialized
        */
        void push(const T &val);
        /**
            @return a reference to the top element in the stack
        */
        T& top();
        /**
            @return a const reference to the top element in the stack
        */
        const T& top() const;
        /**
            Removes the element on top of the stack.
            This calls the removed element's destructor.
        */
        void pop();
        /**
            @return the number of elements in the stack.
        */
        size_t size();
    private:

        StackImpl<T> *impl; // Stack implementation (hidden), private part
                            // will not be seen by clients

};

#endif // STACK_H

Stack.cpp

#include "Stack.h"

#include <stdexcept>

using namespace std;

template <typename T>
class Link {
    public:

        T data;
        Link *next;

        Link(const T &_data): data(_data), next(NULL) {}
        Link(const T &_data, Link *_next): data(_data), next(_next) {}
        ~Link() {
            next = NULL;
        }

};

template <typename T>
class StackImpl {
    public: // even though they're public, but they're not in the header, thus it's safe

        Link<T> *head;

        size_t size;

        StackImpl(): head(NULL) {}
        ~StackImpl() {
            Link<T> *ptr = head;
            while (ptr != NULL) {
                ptr = head->next;
                delete head;
                head = ptr;
            }
            size = 0;
        }
};

template <typename T>
Stack<T>::Stack(): impl(new StackImpl<T>()) {}

template <typename T>
Stack<T>::~Stack() {
    if (impl != NULL)
        delete impl;
}
/**
    Inserts a new element at the top of the stack,
    above its current top element.
    The content of this new element is
    initialized to a copy of val.
    @param val value to which the inserted element is initialized
*/
template <typename T>
void Stack<T>::push(const T &val)
{
    impl->head = new Link<T>(val, impl->head);
    ++(impl->size);
}
/**
    @return a reference to the top element in the stack
*/
template <typename T>
T& Stack<T>::top()
{
    if (impl->head == NULL)
        throw runtime_error("empty stack");
    return impl->head->data;

}
/**
    @return a const reference to the top element in the stack
*/
template <typename T>
const T& Stack<T>::top() const
{
    if (impl->head == NULL)
        throw runtime_error("empty stack");
    return impl->head->data;
}
/**
    Removes the element on top of the stack.
    This calls the removed element's destructor.
*/
template <typename T>
void Stack<T>::pop()
{
    if (impl->head == NULL)
        throw runtime_error("empty stack");
    Link<T> *ptr = impl->head->next;
    delete impl->head;
    impl->head = ptr;
    --(impl->size);
}

/**
    @return the number of elements in the stack.
*/
template <typename T>
size_t Stack<T>::size() {
    return impl->size;
}