对于只有几种可能类型的场景，可以使用std::conditional。

#include <type_traits>

struct A {};
struct B {};

template<int N>
class M {
public:
    std::conditional_t<N == 0, A, B> _x;
};

这可能吗？
是的。也不是太难。

template<int N>
class C{
    typename c_member<N>::type _x;
}

其中

struct A {};
struct B {};

template <int N> struct c_member
{
   using type = B;
};

template <> struct c_member<0>
{
   using type = A;
};

如果需要，可以添加更多的c_member专门化。

有很多方法可以做到这一点。我喜欢重载，因为它允许容易的扩展性。

template<int N>using int_t=std::integral_constant<int,N>;
template<class T>struct tag_t{
  using type=T;
  constexpr tag_t()=default;
};
template<class Tag>
using type_t=typename Tag::type;

struct A{};
struct B{};

inline tag_t<A> something(int_t<0>){return {};}
template<int x>
inline tag_t<B> something(int_t<x>){return {};}

现在我们只是：

template<int N>
class M {
public:
  type_t<decltype(something(int_t<N>{}))> _x;
};

唯一的优点是你可以利用重载解析的全部功能来选择类型，而且你不需要搞砸模板的特殊化，也不需要创建一个复杂的条件来覆盖很多情况。
如果你用简单的逻辑在两种类型之间挑选，这就是矫枉过正了。