在编译期间检查模板类型参数以进行特定于类型的操作

Question

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.

Answer 1

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.
}

Answer 2

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);

}

Answer 3

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