如果我定义了两个概念，并对每个概念都有一个类的部分特化，那么很明显，如果我有一个类型满足这两个概念，我就有一个二义性：

#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> {
      |        ^

型
如果我从Foo中删除Baz类型，那么一切都会按照计划进行，它会打印HasBar!
当专门化像这样模糊不清时，我想手动指定一个优先级。我想我可以用一堆标签类型来做，较低的值代表较高的优先级：

#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();

型
在新的C++20概念世界中应该如何做到这一点？