C++有没有办法禁止两个类型通过第三方类型调用==运算？

Croper

最近，我正在尝试自行实现一个variant类型，
在实现operator==的重载时，我希望能实现如果variant的两个底层类型之间如果能够调用==运算符时，
能调用==运算符，不能时，输出false，就像下面这样的效果

1. 
   
2.     variant(1)==variant("hello world") //false
   
3.     variant(1)==variant(3.14) //false
   
4.     variant(1)==variant(1.0)  //true
   

复制代码

为了判断两个类型是否能调用==运算符，我使用了这段代码
检测两个类型是否能进行"=="运算。

1. 
   
2. template <typename T1, typename T2>
   
3. struct CanEqual {
   
4. private:
   
5.         template <typename = decltype(declval<T1>() == declval<T2>())>
   
6.         constexpr static auto answer(int) { return true; };
   
7.         constexpr static auto answer(...) { return false; };
   
8. public:
   
9.         constexpr operator bool() {
   
10.                 return answer(0);
    
11.         }
    
12. };
    

复制代码

本来一切实现得很完美，两个底层类型不能==运算就输出false，能就输出==运算的结果。

但是调式时，发现在variant实现operator==运算后，两个底层类型在判断能否进行==运算时，会将他们俩都转换成varaint。

然后就死循环了。。。

这让我很纠结，因为我并不想把构造函数声明成explicit的

参考了下boost库，发现boost库下的variant根本没考虑这一点，variant(1)==variant(1.0)的结果是false的。

所以，这个问题有没有什么好点的解决方法？

人造人

把你现在的代码发上来，我调试一下
注意是现在的代码，然后加上注释，尽量说明问题，突出问题，这样更有利于我调试

Croper

完整代码快千行了，我丢在guthub的：https://github.com/CroperShen/variant

我还是弄个简化版的把- -

Croper

首先看这一段代码：
你可以单步调试跟踪，不能调用==的变量和能调用==的变量进入的分支是不同的：

1. template <typename T1,typename T2,typename=decltype(declval<T1>()==declval<T2>())>
   
2. bool Equal(const T1& t1, const T2& t2) {          //能调用==的变量进入这个分支
   
3.         return t1 == t2;
   
4. }
   
5. bool Equal(...) {            //不能调用==的变量进入这个分支
   
6.         return false;
   
7. }
   
8. 
   
9. 
   
10. int main() {
    
11.         bool a = Equal(1, 1.000);
    
12.         bool b = Equal(0, string());
    
13.         system("pause");
    
14. }

复制代码

Croper

.....我想我解决这个问题了。。。

Croper

我把刚才的说完把。。现在在这个代码里加入一个类，
拥有int和string的构造函数，并且重载了operator==

1. struct A {
   
2.         A(int) {};
   
3.         A(string) {};
   
4. };
   
5. bool operator ==(const A&, const A&)
   
6. {
   
7.         return true;
   
8. };
   
9. template <typename T1,typename T2,typename=decltype(declval<T1>()==declval<T2>())>
   
10. bool Equal(const T1& t1, const T2& t2) {          //能调用==的变量进入这个分支
    
11.         return t1 == t2;
    
12. }
    
13. bool Equal(...) {            //不能调用==的变量进入这个分支
    
14.         return false;
    
15. }
    
16. 
    
17. 
    
18. int main() {
    
19.         bool a = Equal(1, 1.000);
    
20.         bool b = Equal(0, string());
    
21.         system("pause");
    
22. }

复制代码

这个时候Equal(0,string())就变成true了。。因为Erqual和string都转换成了A，单步调式可以看出来的。

Croper

解决这个问题只要把operator==写成成员函数就好

1. struct A {
   
2.         A(int) {};
   
3.         A(string) {};
   
4.         bool operator ==(const A&) { return true; };
   
5. };

复制代码

这样就不会出现全局的转换了。。

Croper

我之前写出来是因为写成成员函数的话，
vecotr<A>的相等就不能直接使用==了

1. struct A {
   
2.         A(int) {};
   
3.         A(string) {};
   
4.         bool operator ==(const A&) { return true; };
   
5. ...
   
6. vector<A>()==vector<A>(); //编译不通过：未能找到匹配的重载函数。。
   
7. };

复制代码

而写出来就可以了

1. struct A {
   
2.         A(int) {};
   
3.         A(string) {};
   
4. };
   
5. 
   
6. bool operator ==(const A&,const A&) { return true; };
   
7. ...
   
8. vector<A>()==vector<A>() ;//能够编译通过。

复制代码

Croper

我以前一直认为写在成员函数里的运算符重载和写在外面的运算符重载没多大区别。。。没想到区别这么大。。

C++的坑真心多。。。

相比起这个问题，我还是自己写vector相等的判定把。。。毕竟重载个equal_to就够，简单得多。。