Как можно переопределить <обобщенный аргумент> в обобщенном классе

                        
//                                                  
//
#ifndef Print_HPP
#define Print_HPP
 
 
 
    template <class T> 
    class Print 
 
        {
            public: 
                 //----------- Declaration of Constructors -----------//
                 Print();
        
 
                 //----------- Declaration of Calculator(s) (additional functionality) member(s) function -----------//
                
        
                 //----------- Declaration of Overloaded Operator(s) -----------//
                
                 void Print_Object  ( T& ObjPrint) ; 
 
 
                 // Throw an exception if the two arrays have not the same size.
        };
 
    #ifndef Print_cpp 
 
        #include "Print.cpp"
 
    #endif //#ifndef NumericArray_cpp is CLOSED
 
#endif //NumericArray_hpp is closed

                                                        
//                                              
//  
    #ifndef Print_cpp
    #define Print_cpp
 
#include "Print.hpp"
#include <iostream>
#include <exception>
#include "boost/shared_ptr.hpp"
 
 
using namespace std; 
 
    template <class T>
    Print<T>::Print()
        {
                
        }
    
    
        template<class T>
     void  Print<T>::Print_Object  ( T& ObjPrint) 
         {
                  cout <<"ObjPrint:" <<  ObjPrint; 
         }
     
 
 
 
#endif //NumericArray_cpp is closed

#include <iostream>
#include "Print.hpp"
#include <sstream>
 
using namespace std; 
 
 
 
 
class A
{
public   : 
    int x; 
    int y ; 
 
public : 
    
    A(){};
    A(int new_x, int new_y) : x(new_x), y (new_y){}; 
 
        int  calc ()
    {
    return x*y; 
    }
 
     void   takethis(Print<int>& objT )  
        {
     
     
     }
 
    friend std::ostream& operator << (std::ostream& out ,const  A& objA)
    {
        
        return  out  << "x: "<<  objA.x<< "y:" <<  objA.y; 
        
    }
 
 
};
 
 
 
string  get_type( std::string& obj_string)
{
 
    return obj_string; 
    
 
}
 
 
 
int main ()
 
{
 
 
 
    string bb = "A"; 
 
    
 
    A aa(5,6); 
    cout <<"\n "<<  aa; 
 
     get_type(bb); 
     cout <<"\n "; 
     cout <<  get_type(bb); 
 
    //Print< get_type(bb)> p ; 
    //p.Print_Object(aa); 
 
    
    cout <<"\n "; 
    cout <<"\n "; 
    
return 0 ;
}

#ifndef Print_HPP
#define Print_HPP
 
template <class T> 
class Print {
public: 
    Print();
    void Print_Object( T& ObjPrint ); 
};
 
#endif

#include <iostream>
#include "print.hpp"
 
using namespace std; 
 
template <class T>
Print<T>::Print()
{
}
 
template <class T>
void Print<T>::Print_Object( T& ObjPrint ) 
{
    cout <<"ObjPrint:" <<  ObjPrint; 
}

#include <iostream>
#include <sstream>
#include "print.hpp"
 
using namespace std; 
 
class A {
public:
    int x; 
    int y; 
 
    A() {};
    A( int new_x, int new_y ) : x(new_x), y (new_y) {}; 
 
    int calc() {
        return x * y; 
    }
 
    void takethis( Print <int>& objT ) {}
 
    friend std::ostream& operator << ( std::ostream& out, const A& objA ) {
        return out  << "x: "<<  objA.x<< "y:" <<  objA.y; 
    }
};
 
string get_type( std::string& obj_string )
{
    return obj_string; 
}
 
int main()
{
    string bb = "A"; 
 
    A aa( 5, 6 ); 
    cout <<"\n "<< aa; 
 
    get_type( bb ); 
    cout <<"\n "; 
    cout <<  get_type( bb ); 
 
    cout <<"\n "; 
    cout <<"\n "; 
    
    return 0;
}

#include <iostream>
#include <sstream>
#include "print.hpp"
 
using namespace std; 
 
class A {
public:
    int x; 
    int y; 
 
    A() {};
    A( int new_x, int new_y ) : x(new_x), y (new_y) {}; 
 
    int calc() {
        return x * y; 
    }
 
    void takethis( Print <int>& objT ) {}
    void takethis( Print <double>& objT ) {}
 
    friend std::ostream& operator << ( std::ostream& out, const A& objA ) {
        return out  << "x: "<<  objA.x<< "y:" <<  objA.y; 
    }
};
 
string get_type( std::string& obj_string )
{
    return obj_string; 
}
 
int main()
{
    string bb = "A"; 
 
    A aa( 5, 6 ); 
    cout << "\n" << aa;
 
    get_type( bb ); 
    cout <<"\n "; 
    cout <<  get_type( bb ); 
 
    cout <<"\n "; 
    cout <<"\n "; 
    
    return 0 ;
}

#ifndef FOO
#define FOO
 
template <class A>
class Foo {
  A value;
public:
  Foo();
  Foo(const A &val);
  A get() const;
};
 
#endif

#include "foo.h"
 
template <class A>
Foo<A>::Foo() {}
 
template <class A>
Foo<A>::Foo(const A &val) : value(val) {}
 
template <class A>
A Foo<A>::get() const
{
  return value;
}

#include <iostream>
 
#include "foo.h"
 
int main()
{
  Foo<int> x(10);
  std::cout << x.get();
}