我如何检查特定的模板参数是相同的

Question

我有一个带有三个模板参数的类：

template<typename A, typename B, typename C>
class Unit;

然后，我有一个代表此类及其专业化的概念：

template <typename T>
struct is_unit : std::false_type {};

template<typename A, typename B, typename C>
struct is_unit<Unit<A, B, C>> : std::true_type {};

template <typename T>
constexpr bool is_unit_v = is_unit<T>::value;

template <typename T>
concept Unit_T = is_unit_v<T>;

在单位类的定义中，我想要一个函数，该函数返回一个具有不同专业化的单元，该功能与该功能所为的函数不同称为。我希望用户提供所需的返回类型。到目前为止，我的工作正常：

template<typename A, typename B, typename C>
class Unit {
public:
    // Other member stuff...

    template<Unit_T U>
    U as() { return U(*this); }
}

Unit<MyType, long double, MyOtherType> unit;
// Do stuff to unit.
auto unit2 = unit.as<Unit<MyType, long int, AnotherType>();

所有这些都按预期工作。但是，还有一个要求，我无法弄清楚如何实施。所需类型的第一个模板参数必须匹配所调用类型的第一个模板参数。因此：

Unit<MyType, long double, MyOtherType> unit;
// Do stuff to unit.
auto unit2 = unit.as<Unit<YetAnotherType, long int, AnotherType>();

不应该编译。

我认为正确的方法看起来像：

template<typename A, typename B, typename C>
class Unit {
public:
    // Other member stuff...

    template<Unit_T U>
    requires std::is_same_v<U<D>, D>
    // or maybe std::is_same_V<U::D, D> ?
    U as() { return U(*this); }
}

但这是行不通的。而且，据我了解，即使这是正确的模板参数为正确类型的正确方法，我也无法进一步限制概念。

我尝试为具有特定第一个模板参数的单元编写另一个概念：

template<typename U, typename D>
concept UnitFirstType = is_unit_v<U> && std::is_same_v<U<D> /* or U::D */, D>;

但这是行不通的。

问题似乎在于我如何使用std :: is_same_v。我只是不知道如何使用模板参数使用它。

因此，实现这一目标的正确方法是什么：

Unit<MyType, long double, MyOtherType> unit;
auto unit2 = unit.as<Unit<MyType, long int, AnotherType>(); // will compile
// auto unit3 = unit.as<Unit<YetAnotherType, long int, AnotherType>(); // should not compile

Answer 1

这可能是您想要的

template<typename A, typename B, typename C>
class Unit;

template<typename U, typename A>
constexpr bool unit_first_type = false;

template<typename A, typename B, typename C>
constexpr bool unit_first_type<Unit<A, B, C>, A> = true;

template<typename U, typename A>
concept UnitFirstType = unit_first_type<U, A>;

template<typename A, typename B, typename C>
class Unit {
 public:
  // Other member stuff...
  template<UnitFirstType<A> U>
  U as();
};

demo

Answer 2

我想您可以使用良好的老年人（C ++ 20）sfinae。

例如，给定一个自定义类型特征如下所示，

template <typename, typename>
struct firstEqual : public std::false_type
{};

template <typename A, typename B1, typename C1, typename B2, typename C2>
struct firstEqual<Unit<A, B1, C1> const, Unit<A, B2, C2> const>
   : public std::true_type
{};

/disable 为（）

template <typename U>
std::enable_if_t<firstEqual<Unit<A, B, C> const, U const>::value, U>
   as() { return U{}; }

您可以启用 具有不同的constness，但相同的第一个模板参数...以防万一您想要什么。

还观察到您不再需要unit_t概念。

以下是一个完整的汇编示例

#include <type_traits>

template<typename A, typename B, typename C>
class Unit;

template <typename, typename>
struct firstEqual : public std::false_type
{};

template <typename A, typename B1, typename C1, typename B2, typename C2>
struct firstEqual<Unit<A, B1, C1> const, Unit<A, B2, C2> const>
   : public std::true_type
{};

template <typename A, typename B, typename C>
class Unit {
  public:
    // Other member stuff...

    template <typename U>
    std::enable_if_t<firstEqual<Unit<A, B, C> const, U const>::value, U>
       as() { return U{}; }
};



int main()
{
  Unit<int, long double, void> unit;

  auto unit2 = unit.as<Unit<int, long, float>>();  // compile
  //auto unit3 = unit.as<Unit<char, long, float>>(); // compilation error
}