[jimblumberg]

When using a template class is it possible to determine what type the arguments are, inside the template class

template<class T>
T send( T &b)
{
   // do something if b is a certain type

   // do something else

}

Jim

[jjl]

This is why we use template specialization

template<class T>T send( T &B)/> //default template
{
   return b;
}

template<>int send<int>(int &B)/> //case for ints
{
   return b;
}
template<>char send<char>(char &B)/> //case for chars
{
   return b;
}

This post has been edited by ImaSexy: 18 August 2010 - 08:45 AM

[Aphex19]

using the sizeof function would give you some idea, for example.

if (sizeof(val) == 4)
    // this is an integer
else if (sizeof(val) == 2)
    // this is a short
//etc

this is far from fool proof though of course.

EDIT: ImaSexy's answer is far better.

This post has been edited by Aphex19: 18 August 2010 - 08:45 AM

[jimblumberg]

ImaSexy, on 18 August 2010 - 07:44 AM, said:

This is why we use template specialization

template<class T>T send( T &B)/> //default template
{
   return b;
}

template<>int send<int>(int &B)/> //case for ints
{
   return b;
}
template<>char send<char>(char &B)/> //case for chars
{
   return b;
}

I tried the above and get the following errors

error: explicit specialization in non-namespace scope ‘class SerialUnit’|
error: template-id ‘send<std::string>’ in declaration of primary template|

class SerialUnit : public Serial_Base
{
   public:
      template <class T>
      T send(std::string a , T &B)/>
      { 
         return(B)/>;
      }
      template<>std::string send<std::string>( std::string a,std::string &B)/>
      {
         return(B)/>;
      }

};

Jim

[jjl]

compiles fine for me, visual studio 2008

class SerialUnit// : public Serial_Base
{
   public:
      template <class T> T send(std::string a , T &B)/>
      { 
         return(B)/>;
      }
      template<> std::string send<std::string>(std::string a, std::string &B)/>
      {
         return(B)/>;
      }

};

int main()
{
      std::string a = "a", c = "c";
	  int d = 100;
	  std::cout<<send(a,c)<<std::endl
	           <<send(a,d)<<std::endl;
			   
      return 0;
}

This post has been edited by ImaSexy: 18 August 2010 - 09:30 AM

[jimblumberg]

I am compiling on Linux using gcc 4.4.4. and I get the errors mentioned.

[jjl]

isn't gcc a C compiler? and g++ a c++ compiler? Can someone else try an compile that to give us confermation?

This post has been edited by ImaSexy: 18 August 2010 - 01:12 PM

[jimblumberg]

Yes gcc is a c compilier. I meant g++ version 4.4.4.

I have it working by overloading the send() for std::string.

#include <iostream>
#include <string>

class SerialUnit// : public Serial_Base
{
   public:
      template <class T> T send(std::string a , T &B)/>
      {
         return(B)/>;
      }
      
      std::string send(const std::string a, std::string &B)/>
      { // This is to process for a string only.
         return(B)/>;
      }

};

int main()
{
   SerialUnit test;
   std::string a = "a", c = "c";
   int d = 100;
   std::cout<< test.send(a,c) << std::endl
            << test.send(a,d) << std::endl;

   return 0;
}

Jim

[jjl]

well it still doesnt make sense whey you cannot specialize the template under g++. But im glad you found an answer

[jimblumberg]

If I remove the template from the class then your code works.

#include <iostream>
#include <string>

//class SerialUnit// : public Serial_Base
//{
 //  public:
      template <class T> T send(std::string a , T &B)/>
      {
         return(B)/>;
      }
      template<>std::string send<std::string>( std::string a,std::string &B)/>
      {
         return(B)/>;
      }
/*
      std::string send(const std::string a, std::string &B)/>
      { // This is to process for a string only.
         return(B)/>;
      }
*/
//};

int main()
{
  // SerialUnit test;
   std::string a = "a", c = "c";
   int d = 100;
   std::cout<< send(a,c) << std::endl
            << send(a,d) << std::endl;

   return 0;
}

Jim

[Bench]

Template member function specialisations must be defined outside of the class body, and not inline. Always keep in mind that a template function is merely a template and not a concrete function (i.e. it doesn't 'exist' until its actually used in your code), Your compiler probably thinks that you're providing multiple declarations of the same template within your class.

#include <iostream>
#include <string>

class SerialUnit
{
   public:
      template <class T> 
      std::string send(std::string, T&);
};

template <class T>
std::string SerialUnit::send(std::string, T&)
{
    return "Send<T>";
}

template<>
std::string SerialUnit::send<std::string>(const std::string, std::string&)
{ 
    return "Send<std::string>";
}

int main()
{
   SerialUnit test;
   std::string a = "a", c = "c";
   int d = 100;
   std::cout<< test.send(a,c) << std::endl
            << test.send(a,d) << std::endl;
}

This post has been edited by Bench: 18 August 2010 - 01:57 PM

[jjl]

Ok.. i figured it out lol explicit specializations have to be within namespace scope which the class belongs too.

Quote

An explicit specialization shall be declared in the namespace of which the template is a member, or, for member templates, in the namespace of which the enclosing class or enclosing class template is a member.
An explicit specialization of a member function, member class or static data member of a class template shall be declared in the namespace of which the class template is a member.

Heres the fix

#include <iostream>
#include <string>

class SerialUnit// : public Serial_Base
{
   public:
      template <class T> T send(std::string a , T &B)/>;
};

template <class T> T SerialUnit::send(std::string a , T &B)/>
{
     return B;
}
template <> std::string SerialUnit::send<std::string>(std::string a , std::string &B)/>
{
     return B;
}

int main()
{
   SerialUnit test;
   std::string a = "a", c = "c";
   int d = 100;
   std::cout<< test.send(a,c) << std::endl
            << test.send(a,d) << std::endl;

   return 0;
}

EDIT: ninja'd

This post has been edited by ImaSexy: 18 August 2010 - 01:51 PM

[jimblumberg]

Thanks Imasexy and Bench. That answers my question and solves my problems.

Jim

[jimblumberg]

Another question, is it acceptable to put the explicit specializations in the include file or should they be in a .cpp file?

Jim

[jjl]

The down side about templates is that they must be in the include file or else you will recieve linking errors. It is possible to put template definitions in the cpp file but you have to use Template Instantiation.