CODEWITHSUNDEEP
c++c++11templates
RamBo
RamBo

Reputation: 35

Check for template type parameter, during compile time, for type specific operation

First of all, the code is restricted to C++11, so I cannot make use of if constexpr

Following is my sample code snippet:

class A{
 public:
    int a;
    int b;
}

class B{
 public:
    int key;
    int val;
}

class C{
 public:
    int n1;
    int n2;
}

class D{
 public:
    int n1;
    int n2;
}

class E{
 public:
    int n1;
    int n2;
}

template<typename T>
void func1(T data) {
   if (T == type(A)) {             // Just pseudo template-check code
    std::cout<<data.a<<data.b;              //<------1
   } else if (T == type (B)) {    // Just pseudo template-check code
    std::cout<<data.key<<data.val;          //<------2
   } else {
    std::cout<<data.n1<<data.n2;            //<------3
}


int main() {
A a;
B b;
C c;
D d;
E e;

func1(a);
func1(b);
func1(c);
func1(d);
func1(e);

return 0;
}

Currently, I get a compile-time error at,

1: B,D,E,F has no member a & b
 & 
2: A,D,E,F has no member key & val
 &
3. A, B has no member n1 & n2

I tried using is_same() & also this, but I get same compile time error every time.

  1. I cannot make use of C++14/C++17
  2. How could I make use of specialized template functions?

Edited the code to highlight the need of a template.

Upvotes: 0

Views: 427

Answers (3)

Marek R
Marek R

Reputation: 38112

Simple overload does the job.

template <typename T>
void func1(T data)
{
    std::cout << data.n1 << data.n2;
}

void func1(A data)
{
    std::cout << data.a << data.b;
}

void func1(B data)
{
    std::cout << data.key << data.val;
}

https://godbolt.org/z/r7Ee6E
Tweaked a bit: https://godbolt.org/z/xxPWaE

Upvotes: 1

R Sahu
R Sahu

Reputation: 206717

You can use a function overload and avoid the function template altogether.

void func1(A a)
{
   // Type dependent code.
}

void func1(B a)
{
   // Type dependent code.
}

A function template makes sense only if there is common code for all the types for which the function call is made. If you have some code that is common to all types and some code that are type dependent, then you can use:

void func1(A a)
{
   // Type dependent code.
}

void func1(B a)
{
   // Type dependent code.
}

template <typename T>
void func2(T t)
{
   // Type independent code.
}

template <typename T>
void func(T obj)
{
   func1(obj);   // Call function that uses type dependent code.
   func2(obj);   // Call function that uses type independent code.
}

Upvotes: 2

gerum
gerum

Reputation: 1134

You must write specializations of the function for the two types your want to use it with.

#include<iostream>

class A{
 public:
    int a;
    int b;
};

class B{
 public:
    int key;
    int val;
};

template<typename T>
void func1(T);

template<>
void func1<A>(A arg) {
    std::cout<<"A"<<std::endl;
    std::cout<<arg.a<<arg.b;
}

template<>
void func1<B>(B arg) {
    std::cout<<"B"<<std::endl;
    std::cout<<arg.key<<arg.val;
}

int main(){
A a;
func1(a);

B b;
func1(b);

}

Upvotes: 1

Related Questions