避免在模板类方法隐式转换

Question

我想实现一类的运算符重载，如：

template<class T> class A{ 
public: 
    T val; 

    A<T>& operator=(const T& v) { 
     this->val = v; 
     return *this; 
    } 
} 

所以我可以做：

A<bool> obj; 
obj = true; // instead of obj.val = true 
obj = false; 

这工作得很好。

但是，如果我这样做：

A<bool> obj; 
obj = 123123; // bool is not a number! 

它仍然有效！我能以某种方式防止这种情况吗

我试图标志着超载explicit这样的：

explicit A<T>& operator=(const T& v) { ... } 

，但我得到一个错误：

error C2071: 'A<T>::operator =': illegal storage class 

它甚至有可能做到这一点？

Answer 1

正如意见建议，使该除了一个类型匹配一切delete d模板函数你想允许：

template<class T> class A 
{ 
public: 
    T val; 

    A & operator=(T const &v) { 
     val = v; 
     return *this; 
    } 

    template<class U> 
    A & operator=(U const &v) = delete; 
}; 

int main() 
{ 
    A<bool> a; 
    a = true; 
    a = 1;  // error: use of deleted function 
} 

---

如果你打算做这个有很多，你可以卸载重型提升到帮手类：

template<typename T> 
struct exact 
{ 
    T const &t; 
    exact(T const &t): t(t) {} 

    template<typename U> 
    exact(U u) = delete; 
}; 

template<class T> class A 
{ 
public: 
    T val; 

    A &operator=(exact<T> v) { 
     val = v.t; 
     return *this; 
    } 
};