如何在C++中将模板类型转换为对应目标新类型？

问题背景 #

需要在C++模板函数f()中实现类型映射逻辑：当模板参数T为A时转为AD，为B时转为BD。最初使用宏CONN通过文本拼接生成目标类型，传入具体类型（如A）时可以正常工作，但传入模板参数T时编译失败，报错如下：

$ g++ 18.cpp -o t
18.cpp: In function 'void f()':
18.cpp:49:18: error: expected type-specifier before 'TD'
   49 |   auto bd = CONN(T, 100);
      |                  ^
18.cpp:3:27: note: in definition of macro 'CONN'
    3 | #define CONN(T, data) new T##D(data)
      |                           ^

原因是宏在预处理阶段仅做文本替换，无法识别编译期才确定的模板参数类型，因此必须改用C++编译期类型处理的方案。

解决方案 #

方法一：模板特化实现类型Trait（最通用） #

定义一个类型映射模板，通过特化为每种源类型绑定对应的目标类型：

// 基础模板，未特化的类型会触发静态断言报错
template<typename T>
struct TypeMapper {
    static_assert(!std::is_same_v<T, T>, "未定义该类型的映射关系");
};

// 特化：A对应AD
template<>
struct TypeMapper<A> {
    using type = AD;
};

// 特化：B对应BD
template<>
struct TypeMapper<B> {
    using type = BD;
};

// 定义别名简化使用
template<typename T>
using TypeMapper_t = typename TypeMapper<T>::type;

修改模板函数f()，使用Trait获取目标类型：

template <typename T>
void f() {
  auto ad = new AD(100);
  ad->print();
  
  // 通过Trait获取映射后的类型
  auto bd = new TypeMapper_t<T>(100);
  bd->print();
  
  // 记得释放内存避免泄漏
  delete ad;
  delete bd;
}

方法二：C++11别名模板特化（更简洁） #

直接用别名模板实现特化，写法更紧凑：

// 默认模板，未支持的类型会编译报错
template<typename T>
using MappedType = void;

// 特化映射关系
template<>
using MappedType<A> = AD;

template<>
using MappedType<B> = BD;

函数中直接使用别名：

template <typename T>
void f() {
  auto ad = CONN(A, 100);
  ad->print();
  
  auto bd = new MappedType<T>(100);
  bd->print();
  
  delete ad;
  delete bd;
}

方法三：C++17 if constexpr（适合简单分支场景） #

如果映射关系只有少数几种，可以用编译期分支判断直接生成目标类型：

#include <type_traits>

template <typename T>
void f() {
  auto ad = CONN(A, 100);
  ad->print();
  
  if constexpr (std::is_same_v<T, A>) {
      auto bd = new AD(100);
      bd->print();
      delete bd;
  } else if constexpr (std::is_same_v<T, B>) {
      auto bd = new BD(100);
      bd->print();
      delete bd;
  } else {
      static_assert(!std::is_same_v<T, T>, "未支持该类型的映射");
  }
  
  delete ad;
}

完整可运行代码示例 #

以方法一为例，完整代码如下：

#include <iostream>
#include <type_traits>

class A {
 private:
  int m_data;

 public:
  A(int data) : m_data(data) {}
  ~A() {}
  void print() { std::cout << "A.data = " << m_data << std::endl; }
};

class AD {
 private:
  int m_data;

 public:
  AD(int data) : m_data(data) {}
  ~AD() {}
  void print() { std::cout << "AD.data = " << m_data << std::endl; }
};

class B {
 private:
  int m_data;

 public:
  B(int data) : m_data(data) {}
  ~B() {}
  void print() { std::cout << "B.data = " << m_data << std::endl; }
};

class BD {
 private:
  int m_data;

 public:
  BD(int data) : m_data(data) {}
  ~BD() {}
  void print() { std::cout << "BD.data = " << m_data << std::endl; }
};

// 类型映射Trait
template<typename T>
struct TypeMapper {
    static_assert(!std::is_same_v<T, T>, "未定义该类型的映射关系");
};

template<>
struct TypeMapper<A> {
    using type = AD;
};

template<>
struct TypeMapper<B> {
    using type = BD;
};

template<typename T>
using TypeMapper_t = typename TypeMapper<T>::type;

template <typename T>
void f() {
  auto ad = new AD(100);
  ad->print();
  
  auto bd = new TypeMapper_t<T>(100);
  bd->print();
  
  delete ad;
  delete bd;
}

int main(int argc, char const* argv[]) {
  f<B>();
  f<A>();
  return 0;
}

内容的提问来源于stack exchange，提问作者allblue lai