如何在C++20 Concepts中手动消除部分特化的歧义？

问题场景 #

当为类模板定义两个基于不同concept的部分特化时，如果存在同时满足两个concept的类型，编译器会因特化歧义报错。例如以下代码：

#include <cstdio>

template <typename T>
concept HasBar = requires {
   typename T::Bar;
};

template <typename T>
concept HasBaz = requires {
   typename T::Baz;
};

template <typename T>
struct Foo;

template <typename T> requires(HasBar<T>)
struct Foo<T> {
    static void frobnicate() {
        fprintf(stderr, "HasBar!\n");
    }
};

template <typename T> requires(HasBaz<T>)
struct Foo<T> {
    static void frobnicate() {
        fprintf(stderr, "HasBaz!\n");
    }
};

int main() {
   struct MyFoo {
      using Bar = int;
      using Baz = float;
   };
   
   Foo<MyFoo>::frobnicate();
}

编译时会触发歧义错误：

<source>:42:15: error: ambiguous partial specializations of 'Foo<MyFoo>'
   42 |    Foo<MyFoo> foo;
      |               ^
<source>:23:8: note: partial specialization matches [with T = MyFoo]
   23 | struct Foo<T> {
      |        ^
<source>:30:8: note: partial specialization matches [with T = MyFoo]
   30 | struct Foo<T> {
      |        ^

错误的优先级尝试方案 #

尝试用优先级标签类解决歧义时，若模板参数默认值与特化不匹配，会导致所有特化都无法被匹配。例如以下代码：

#include <cstdio>

template <int N>
struct Priority : Priority<N-1> {};

template <>
struct Priority<0> {};

template <typename T>
concept HasBar = requires {
   typename T::Bar;
};

template <typename T>
concept HasBaz = requires {
   typename T::Baz;
};

template <typename T, typename Enabled = void>
struct Foo;

template <typename T> requires(HasBar<T>)
struct Foo<T, Priority<1>> {
    static void frobnicate() {
        fprintf(stderr, "HasBar!\n");
    }
};

template <typename T> requires(HasBaz<T>)
struct Foo<T, Priority<0>> {
    static void frobnicate() {
        fprintf(stderr, "HasBaz!\n");
    }
};

int main() {
   struct MyFoo {
      using Bar = int;
      using Baz = float;
   };
   
   Foo<MyFoo>::frobnicate();
}

编译报错：

<source>:42:4: error: implicit instantiation of undefined template 'Foo<MyFoo>'
   42 |    Foo<MyFoo>::frobnicate();

正确解决方法 #

方法1：通过约束互斥明确优先级 #

直接在低优先级的特化约束中排除高优先级的concept，确保同一类型只会匹配一个特化。例如让HasBaz优先级更高：

#include <cstdio>

template <typename T>
concept HasBar = requires {
   typename T::Bar;
};

template <typename T>
concept HasBaz = requires {
   typename T::Baz;
};

template <typename T>
struct Foo;

// 仅当满足HasBar但不满足HasBaz时匹配（低优先级）
template <typename T> requires(HasBar<T> && !HasBaz<T>)
struct Foo<T> {
    static void frobnicate() {
        fprintf(stderr, "HasBar!\n");
    }
};

// 只要满足HasBaz就匹配（高优先级）
template <typename T> requires(HasBaz<T>)
struct Foo<T> {
    static void frobnicate() {
        fprintf(stderr, "HasBaz!\n");
    }
};

int main() {
   struct MyFoo {
      using Bar = int;
      using Baz = float;
   };
   
   Foo<MyFoo>::frobnicate(); // 输出HasBaz!
}

这种方式逻辑直接，代码简洁，是最常用的解决方案。

方法2：正确使用优先级标签模板 #

如果需要更灵活的多优先级管理，可以修正优先级标签的使用方式，让主模板的默认参数能匹配到特化的继承链：

#include <cstdio>

// 优先级标签：数值越小，优先级越高
template <int N>
struct Priority : Priority<N-1> {};
template <> struct Priority<0> {};

template <typename T>
concept HasBar = requires {
   typename T::Bar;
};

template <typename T>
concept HasBaz = requires {
   typename T::Baz;
};

// 主模板默认使用最低优先级标签
template <typename T, typename Prio = Priority<10>>
struct Foo;

// HasBar特化：优先级1
template <typename T> requires(HasBar<T>)
struct Foo<T, Priority<1>> {
    static void frobnicate() {
        fprintf(stderr, "HasBar!\n");
    }
};

// HasBaz特化：优先级0（更高）
template <typename T> requires(HasBaz<T>)
struct Foo<T, Priority<0>> {
    static void frobnicate() {
        fprintf(stderr, "HasBaz!\n");
    }
};

// 递归推导最高优先级的匹配特化
template <typename T>
struct Foo<T, Priority<10>> : Foo<T, Priority<9>> {};
template <typename T>
struct Foo<T, Priority<9>> : Foo<T, Priority<8>> {};
template <typename T>
struct Foo<T, Priority<8>> : Foo<T, Priority<7>> {};
template <typename T>
struct Foo<T, Priority<7>> : Foo<T, Priority<6>> {};
template <typename T>
struct Foo<T, Priority<6>> : Foo<T, Priority<5>> {};
template <typename T>
struct Foo<T, Priority<5>> : Foo<T, Priority<4>> {};
template <typename T>
struct Foo<T, Priority<4>> : Foo<T, Priority<3>> {};
template <typename T>
struct Foo<T, Priority<3>> : Foo<T, Priority<2>> {};
template <typename T>
struct Foo<T, Priority<2>> : Foo<T, Priority<1>> {};
template <typename T>
struct Foo<T, Priority<1>> : Foo<T, Priority<0>> {};

// 无匹配concept时的默认实现（可选）
template <typename T>
struct Foo<T, Priority<0>> {
    static void frobnicate() {
        fprintf(stderr, "Default!\n");
    }
};

int main() {
   struct MyFoo {
      using Bar = int;
      using Baz = float;
   };
   
   Foo<MyFoo>::frobnicate(); // 输出HasBaz!
}

这种方式适合需要定义多个不同优先级特化的场景，但需要编写递归继承的辅助特化。

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