Как определить тип указателя shared_ptr<T>?

class char_int {
  public:
  char_int(int size):size_(size){
          first= new char [size]; second = new int [size];
  }
  ~char_int(){
         delete first; delete second;
  };
  int size_;
  char  *first;
  int *second;
};
 
class float_double {
  public:
  float_double(int size):size_(size){
          first= new float [size]; second = new double [size];
  }
  ~float_double(){
         delete first; delete second;
  };
  int size_;
  float  *first;
  double *second;
};
 
template<class T>
class TypeTMI_Ttype {
    public:
 
     ~TypeTMI_Ttype(){};
     TypeTMI_Ttype(int size):size_(size){
         data = boost::shared_ptr<T>(new T(size_));
     };
 
     T* get_data(void){return  data.get();}
 
     int size_;
     boost::shared_ptr<T>data;
    
};

boost::shared_ptr< TypeTMI_Ttype <char_int> > cipdata(new TypeTMI_Ttype<char_int>(MAX));
boost::shared_ptr< TypeTMI_Ttype <float_double> > fpdata(new TypeTMI_Ttype<float_double>(MAX));;

foo ( boost::shared_ptr< TypeTMI_Ttype < ??????? > > ){
    
    if(char_int){//что то делать если boost::shared_ptr< TypeTMI_Ttype <char_int> >
    
   }
  
    if(float_double){//что то делать если boost::shared_ptr< TypeTMI_Ttype <float_double> >
   }
   
}

#include <iostream>
#include <type_traits>
#include <boost/shared_ptr.hpp>
#include <boost/current_function.hpp>
 
struct A {void fooA(){std::cout << BOOST_CURRENT_FUNCTION;}};
struct B {void fooB(){std::cout << BOOST_CURRENT_FUNCTION;}};
 
template <typename T>
struct C {T member;};
 
template <typename T,
          typename std::enable_if<std::is_same<T, A>::value>::type* = nullptr>
void foo_impl(boost::shared_ptr<C<T>> sp)
{
    sp->member.fooA();
}
 
template <typename T,
          typename std::enable_if<std::is_same<T, B>::value>::type* = nullptr>
void foo_impl(boost::shared_ptr<C<T>> sp)
{
    sp->member.fooB();
}
 
template <typename T>
void foo(boost::shared_ptr<C<T>> sp)
{
    foo_impl(sp);
}
 
int main()
{
    boost::shared_ptr<C<A>> ca(new C<A>());
    boost::shared_ptr<C<B>> cb(new C<B>());
 
    foo(ca);
    std::cout << "\n";
    foo(cb);
}

template<typename T>
void funk(T t){
  char_int *ci=NULL;
  float_double *fd=NULL;
  T t_;
  t_ = t;
 
  ci = dynamic_cast<char_int*>(t_->get_data());
  fd = dynamic_cast<float_double*>(t_->get_data());
}
 
boost::shared_ptr< TypeTMI_Ttype <char_int> > cipdata(new TypeTMI_Ttype<char_int>(MAX));
boost::shared_ptr< TypeTMI_Ttype <float_double> > fpdata(new TypeTMI_Ttype<float_double>(MAX));
 
funk(fpdata);
funk(cipdata);