template function within non template class does not link - c++

Question

I can not link template functions within non template class
I have:
class base {};
class mgr : base
{
template function a;
........
non template functions
};
template a access variables of class m
for example
static m<T>* ptr;
ptr = reinterpret_cast<m<T>*>( std::get<0>(d) );
ptr->m<T>::clear();
(m private section is friend of mgr)
in class g I want to use function a
static mgr mg;
mgr *p = &mg;
m<T> v = *( reinterpret_cast<T*>( p->a(p1,p2) );
note that func. a() return pointer to base (similar idea to void*) regardless of <T>
at the end of m.cpp I have (per specialization)
example:
template class m<string>;
at the end of mgr.cpp I have (per specialization)
example:
template pbase mgr::a<string>( ... );
hpp files used for declarations,
cpp files for definition (implementation)
watching the link map I can see that mgr linked template specialized
function a
however it failed to link it in g
any help would be appreciated
here is more code
mgr.hpp
#ifndef __mgr__mgr___
#define __mgr__mgr___
#include <iostream> // cout
#include <ostream> // cout
#include <string>
#include <vector>
#include <map>
#include <tuple>
#include <type_traits>
#include <limits>
#include <climits>
#include <exception>
using namespace std;
typedef string tInstName;
enum tInstType { Typ1 , Typ2 , Typ3 };
class mgr
{
public:
class MIObase {};
map<string,tuple<MIObase*,string,tInstType>> Imap;
template <class T> MIObase* getInstance ( const string& name , const iName& instname );
};
#endif
mgr.cpp
#include <ostream>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <errno.h>
#include <string>
#include <vector>
#include <map>
#include <set>
#include <algorithm>
#include <utility>
#include <tuple>
#include <type_traits>
#include <typeinfo>
#include <limits>
#include <climits>
#include <exception>
#include "mgr.hpp"
#include "mfunc.hpp"
using namespace std;
template<>
pMIObase mgr::getInstance<string> ( const string& filename , const string& name )
{
tuple<pMIObase,string,tInstType> d;
static mfunc<string>* ptr;
static pMIObase ptr_;
auto it = Imap.find ( instname );
if ( it != Imap.end() )
{
d=Imap[instname];
ptr = reinterpret_cast<mfunc<string>*>( std::get<0>(d) );
ptr->mfunc<string>::clear();
ptr_ = std::get<0>(d);
cout<<instname <<" already exists .......\n";
return ptr_;
}
else
{
//mfunc<string> I;
ptr = new mfunc<string>;
d = make_tuple (reinterpret_cast<pMIObase>(ptr),name,Tstr);
Imap[instname] = d;
ptr->clear();
ptr_ = reinterpret_cast<pMIObase>(ptr);
return ptr_;
}
}
template pMIObase mgr::getInstance<string>(const string& filename , const tInstName& instname);
g.cpp
#include "mgr.hpp"
using namespace std;
void g()
{
static mgr mb;
mgr *pMIO=&mb;
// this one dose not link
static mfunc<string> &v = *( reinterpret_cast<mfunc<string>*>( pMIO->mgr::getInstance<string> ( ) ));
}