Question

假设我具有以下结构MyPairType。

template<typename F, typename S>
struct MyPairType {
  F first;                                                                           
  S second;                                                                        
  MyPairType() { }
  MyPairType(F f, S s) { first = f; second = s; }
  operator F() const { return first; }
  operator S() const { return second; }
};

当我尝试使用MyPairType<A, B>（对于A和B的{{1}}类型）时，它可以正常工作。但是，当我尝试使用A != B（对于任何类型的MyPairType<T, T>）时，它会失败，因为两个转换运算符是相同的：

我发现可以使用error: ‘MyPairType<F, S>::operator S() const [with F = int; S = int]’ cannot be overloaded operator S() const { return second; } ^ error: with ‘MyPairType<F, S>::operator F() const [with F = int; S = int]’ operator F() const { return first; }和std::enable_if的组合来解决此问题，但是这需要模板化运算符功能，这是不希望的。

假设我有以下代码：

std::is_same

对于上面的代码，我希望输出为typedef int T1; typedef int T2; ... MyPairType<T1, T2> my_pair(3, 5); T1 frst = my_pair; T2 scnd = my_pair; std::cout << frst << " " << scnd << std::endl;。即使3 5和T1都是T2，转换也可以不同地发生吗？我该如何实现？

Answer 1

为它们相同的情况创建一个特殊化。注意：为避免这种情况，您可能需要执行标准库的操作，并提供用于第一个和第二个元素访问的方法，而不是提供强制转换方法。这样，即使类型相同，方法也不同，因此不会重载。

无论如何，您都可以通过在原始定义之后添加此内容来进行专门化

template<typename F>
struct MyPairType<F, F> {
  F first;                                                                           
  F second;                                                                        
  MyPairType() { }
  MyPairType(F f, F s) { first = f; second = s; }
  operator F() const { return first; }
};

此外，构造函数的名称不正确。 VPairType-> MyPairType。

编辑：刚刚意识到，这种方式将永远无法通过强制转换来访问第二个元素。您应该只提供一种F first()和F second()方法

C ++根据模板类型定义函数

1 个答案: