Linker Error with C++11 templates

using cmake/make/gcc I get this error when linking the following code

target/tests/CacheTests/NDHeapCacheTest.o:(.rodata._ZTV13CacheRefrenceISt5arrayIcLm64EEE[_ZTV13CacheRefrenceISt5arrayIcLm64EEE]+0x10):

undefined reference to `CacheRefrence >::call(std::function&)>)'

====================================================================

void test_NDHeapCache_intialize(){
  NDHeapCache<long, std::array<char, 64>> cache(3); 

  long i;
  auto array = std::array<char, 64>();
  bzero(&array, 64);

  for(i=0; i<7; i++){
    array[0] = (char)i;
    cache.insert(i, array);
  }

  NDHeapCacheRefrence<long, std::array<char, 64>> *force= new NDHeapCacheRefrence<long, std::array<char, 64>>(weak_ptr<NDHeapCacheEntry<long, std::array<char, 64>>>());
  force->call([](std::array<char, 64>& v){});


  long k = 3l;
  CacheRefrence<std::array<char, 64>>* ref = cache.find(k);
  int error = ref->call(
    [](std::array<char, 64>& v){
      if(v[0] == 3){
        cout << "yay" << endl;
      } else {
        cout << "boo" << endl;
      }
    }
  );
}

=====================================================================

template<typename T>
class CacheRefrence {
public:
  virtual int call(std::function<void(T&)> f);
};

=====================================================

template<
    typename Key
  , typename T
  , typename Hash = hash<Key>
  , typename Pred = std::equal_to<Key>
  >
class Cache {

protected:
  size_t max_size;
    size_t count;

public:
  Cache(size_t max_size) {
    this->max_size = max_size;
    this->count = 0;
  };

  size_t size(){
    return count;
  };

  virtual CacheRefrence<T>* find(Key& k) = 0;
  virtual void insert(Key& key, T& value) = 0;
};

========================================================

template<typename K, typename T>
class NDHeapCacheRefrence : public CacheRefrence<T> {
private:
  weak_ptr<NDHeapCacheEntry<K, T>> ptr;
public:

  NDHeapCacheRefrence(weak_ptr<NDHeapCacheEntry<K, T>> ptr) : ptr(ptr) {}

  int call(std::function<void(T&)> f){
    if(auto spt = ptr.lock()){
      f(spt->get());
      return 0;
    } else {
      return -1;
    }
  }
};

=======================================================

template<
    typename Key
  , typename T
  , typename Hash = hash<Key>
  , typename Pred = std::equal_to<Key>
  >
class NDHeapCache : public Cache<Key, T, Hash, Pred> {
private:
  std::vector<shared_ptr<NDHeapCacheEntry<Key, T>>> heap;
  unordered_map<Key, size_t> lookup;


public:
 NDHeapCache(unsigned short log_capacity) :
    Cache<Key, T, Hash, Pred>::Cache((size_t)std::pow(2.0, (double)log_capacity) - 1),
    heap(this->max_size)
  {}

 ~NDHeapCache() = default ;
 CacheRefrence<T>* find(Key& k){

    size_t loc, parent_loc;
    auto found = lookup.find(k);
    if(found == lookup.end()){
      return new NDHeapCacheRefrence<Key, T>(weak_ptr<NDHeapCacheEntry<Key, T>>());
    }
    loc = found->second;
    parent_loc = ((loc+1)/2) - 1;
    return new NDHeapCacheRefrence<Key, T>(weak_ptr<NDHeapCacheEntry<Key, T>>(heap[loc]));
 }

};