声明 const 时模板成员函数解析失败

Question

下面的代码显示了一些有趣的行为：

#include <iostream>
using namespace std;
template<class T>
class B{
public:
  void foo(B<T> &x)const;
  template<class F> void foo(F f);
};
template<typename T> void B<T>::foo(B<T> &x)const{cout<<"foo_B"<<endl;}
template<typename T> template<typename F> void B<T>::foo(F f){cout<<"foo_F"<<endl;}
int main(){
  B<int> a;
  B<int> b;
  b.foo(a);
  b.foo([](){;});
  return(0);
}

我的预期输出是

foo_B
foo_F

但实际输出是

foo_F
foo_F

这取决于void foo(B<T> &x) 是否被声明为const。如果const 被省略，则输出符合预期。

此外，如果将const 添加到void foo(F f)，则输出也符合预期。

但是，void foo(B<T> &x) 不会更改 this，而 void foo(F f) 将更改 this。所以当前的布局是必需的。

非常感谢任何想法如何在不删除 const 的情况下解决此问题。

Answer 1

资格转换（这里：在隐式对象参数上）不是身份转换，并且在重载决议排名中具有成本

成员函数void foo(B<T>& x) const 是const-qualified，而模板成员函数template<class F> void foo(F f) 不是。这意味着后者更适合隐式对象参数为 not const 的调用，根据 [over.ics.rank]/3.2.5:

标准转换序列 S1 是比标准转换序列更好的转换序列 标准转换序列S2 if

• [...]，或者，如果不是这样，S1 和 S2 仅在其限定转换 ([conv.qual]) 上有所不同，并产生相似的类型 T1 和 T2， 分别，其中 T1 可以通过限定转换为 T2 转化。

和[over.match.best]/2.1

如果你 const-qualify 自动变量 b 在 main 中，将选择非模板重载：

// ^^^ `foo` overloads as in OP's example
B<int> a{};
B<int> const b{}
b.foo(a);  // foo_B

如果您改为const-quality 模板成员函数foo，则非模板将与模板重载相同（隐式对象参数需要 const-qualification），在这种情况下，非模板根据[over.match.best]/2.4，模板函数被选为最佳可行重载。

---

如果您不希望特定的重载参与类型谓词的重载解析：删除它

但是，b 在实际应用中不能声明为 const，归结为复制，比如 const c(b);然后使用 c.foo(a)

当模板参数的类型模板参数的模板参数是B 类模板的特化时，您可以使用特征来删除模板成员函数：

#include <iostream>
#include <type_traits>

template <class T, template <class...> class Primary>
struct is_specialization_of : std::false_type {};
template <template <class...> class Primary, class... Args>
struct is_specialization_of<Primary<Args...>, Primary> : std::true_type {};
template <class T, template <class...> class Primary>
inline constexpr bool is_specialization_of_v{is_specialization_of<T, Primary>::value};

template <class T> class B {
public:
  void foo(B<T> &x) const { std::cout << "foo_B" << std::endl; }
  template <class F, typename = std::enable_if_t<!is_specialization_of_v<F, B>>>
  void foo(F f) {
    std::cout << "foo_F" << std::endl;
  }
};

int main() {
  B<int> a;
  B<int> b;
  b.foo(a);
  b.foo([]() { ; });
  return (0);
}

我们利用了 P2098R1 的 is_specialization_of 特征（请注意，这对于作为别名模板的模板参数有实现差异 - 有点未指定的 IIRC）。

请注意，使用这种方法，对于 B 的 另一个 特化的参数（而不是隐式对象参数的参数），任何重载都不可行。

Answer 2

这里的问题是，由于 void foo(B<T> &x)const; 是 const 限定的，它必须 const 限定你正在调用函数的对象。这并不像template<class F> void foo(F f); 提供的那样完全匹配，因为它不需要进行 const 限定。这就是为什么它用于两个调用。

您也可以通过 const 限定模板版本来解决此问题，例如：

#include <iostream>
using namespace std;
template<class T>
class B{
public:
  void foo(B<T> &x)const;
  template<class F> void foo(F f)const;
};
template<typename T> void B<T>::foo(B<T> &x)const{cout<<"foo_B"<<endl;}
template<typename T> template<typename F> void B<T>::foo(F f)const{cout<<"foo_F"<<endl;}
int main(){
  B<int> a;
  B<int> b;
  b.foo(a);
  b.foo([](){;});
  return(0);
}

哪个会打印

foo_B
foo_F

---

另一种选择是使用SFINAE 来限制模板版本以排除B<T> 的版本。看起来像

#include <iostream>
using namespace std;
template<class T>
class B{
public:
  void foo(B<T> &x)const;
  template<class F, std::enable_if_t<!std::is_same_v<B<T>, F>, bool> = true> 
  void foo(F f);
};
template<typename T> void B<T>::foo(B<T> &x)const{cout<<"foo_B"<<endl;}
template<typename T> template<class F, std::enable_if_t<!std::is_same_v<B<T>, F>, bool>>  
void B<T>::foo(F f){cout<<"foo_F"<<endl;}
int main(){
  B<int> a;
  B<int> b;
  b.foo(a);
  b.foo([](){;});
  return(0);
}

并且与第一个示例具有相同的输出。

Answer 3

当你想调用 const 版本时，一个相当简单但有点冗长的方法是将对象转换为 const：

static_cast<const B<int>>(b).foo(a);

这足以让调用显示foo_B...