分别依赖于模板参数的多个默认模板参数案例

如果是唯一可以使用的特殊情况：A<X,..>std::conditional_t

#include <type_traits>

template <typename T1,typename T2>
class A_impl {};

struct X {};

template<typename T1>
using A = A_impl<T1,std::conditional_t< std::is_same_v<T1,X>, int,T1>>;


int main(){
    A<X> a;     // shall construct an instance of A<X,int>
    A<float> b; // shall construct an instance of A<float,float>
}

我试图用 2 个模板参数保持您的完整。实际上，如果可能的话，我会放弃第二个参数，而是使用成员别名来表示何时总是从：AT2T2T1

#include <type_traits>

struct X {};

template<typename T1>
struct A {
    using T2 = std::conditional_t< std::is_same_v<T1,X>, int,T1>;
};


int main(){
    A<X> a;     // shall construct an instance of A<X,int>
    A<float> b; // shall construct an instance of A<float,float>
}

什么时候不是你仍然可以使用的唯一特殊情况，但它会很快变得毛茸茸的。对于从 到 的一般映射，我宁愿定义一个可以相应地专门化的特征：A<X,...>std::conditionalT1T2T2_from_T1_t

template<typename T1>
struct A {
    using T2 = T2_from_T1_t<T1>;
};

您可以使用模板专用化来帮助您推断第二个参数的类型（这也可以很容易地扩展到其他专用化）：

#include <type_traits>

namespace details
{
    // in allmost all cases we want to imply type int for the second argument
    template<typename type_t>
    struct deduced_second_arg_t_helper
    {
        using type = int;
    };

    // except for float, so use a template specialization to deduce a float
    template<>
    struct deduced_second_arg_t_helper<float>
    {
        using type = float;
    };

    // shorthand like 
    template<typename type_t>
    using deduced_second_arg_t = typename deduced_second_arg_t_helper<type_t>::type;
}

// now the second argument can be deduced from the first
template<typename type_t, typename second_arg_t = details::deduced_second_arg_t<type_t>>
struct A
{
    second_arg_t some_value;
};

// or simplified, we use the deduced type internally
template<typename type_t>
struct B
{
    using some_value_t = details::deduced_second_arg_t<type_t>;
    some_value_t some_value;
};

struct X
{
};

int main()
{
    A<X> a_x;
    A<float> a_f;
    static_assert(std::is_same_v<decltype(a_x.some_value), int>);
    static_assert(std::is_same_v<decltype(a_f.some_value), float>);

    B<X> b_x;
    B<float> b_f;
    static_assert(std::is_same_v<decltype(b_x.some_value), int>);
    static_assert(std::is_same_v<decltype(b_f.some_value), float>);

    return 0;
}

根据 @463035818_is_not_an_ai 接受的答案，我看到可以通过将条件直接写入默认模板参数语法来缩短它：

struct X;

template<typename T1, typename T2 = std::is_same_v<X,T1>, int,T1> >
class A{
    // ...
};

int main(){
    A<X> a;     // shall construct an instance of A<X,int>
    A<float> b; // shall construct an instance of A<float,float>
}