如何特化std::common_type<A,B> 使其天然满足交换性？

方案1：通过统一顺序的辅助元函数避免重复特化（通用场景） #

这是可维护性最高、适用所有复杂约束场景的方案，核心思路是把所有输入的类型对先按固定规则排序，只需要写一次固定顺序的特化逻辑，倒序的输入自动交换顺序后复用同一份逻辑。
步骤如下：

1. 首先在自定义命名空间实现辅助元函数，定义你的排序规则和单份特化逻辑：

namespace my_utils {
// 自定义类型判断的辅助变量，按需修改
template <typename T> constexpr bool is_custom_type_a_v = /* 判断T是否是你的第一类自定义类型 */;
template <typename T> constexpr bool is_custom_type_b_v = /* 判断T是否是你的第二类自定义类型 */;

// 仅处理固定顺序的特化逻辑，只需要写一次
template <typename T, typename U, typename = void>
struct ordered_common_type_impl {};

// 示例特化：仅处理顺序为<TypeA, TypeB>的情况，所有约束和逻辑只写一遍
template <typename T, typename U>
requires /* 你的复杂约束，不需要对称，只要符合TypeA在前的场景 */
struct ordered_common_type_impl<CustomTypeA<T>, CustomTypeB<U>> {
    using type = /* 你的公共类型定义 */;
};

// 统一入口：自动调整类型对顺序后转发到实现
template <typename T, typename U>
struct ordered_common_type {
    // 排序规则：如果是TypeB在前、TypeA在后的情况，交换顺序，否则保持原顺序
    using adjusted_pair = std::conditional_t<
        is_custom_type_b_v<T> && is_custom_type_a_v<U>,
        std::pair<U, T>,
        std::pair<T, U>
    >;
    using type = typename ordered_common_type_impl<typename adjusted_pair::first_type, typename adjusted_pair::second_type>::type;
};
}

2. 仅需要写一次std::common_type的特化，直接转发到上面的辅助入口：

namespace std {
template <typename T, typename U>
requires requires { typename my_utils::ordered_common_type<T, U>::type; }
struct common_type<T, U> {
    using type = typename my_utils::ordered_common_type<T, U>::type;
};
}

这种方案下不管输入common_type<CustomTypeA<int>, CustomTypeB<float>>还是倒序的参数，都会自动调整为固定顺序计算，天然满足交换性，完全不需要写两份重复的特化逻辑。

方案2：利用原生默认推导（简单场景） #

如果你的两种自定义类型支持双向隐式转换到同一个公共类型，不需要额外写任何特化：std::common_type的默认实现会推导三元表达式true ? declval<T>() : declval<U>()的类型，这个推导天然是交换对称的，会自动得到正确的公共类型。

注意事项 #

• 仅可以对包含至少一个用户自定义类型的组合特化std::common_type，特化全为标准库类型的组合属于未定义行为。
• 多参数的std::common_type<T1, T2, T3...>不需要额外适配，标准库实现会递归两两计算，只要两两特化满足交换性，多参数结果自然一致。

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