c++ - std::enable_if 在传递给它的错误类型(double)而不是 std::complex 时无法执行

Question

我想让我的数组类从 double 复制数据数组到 std::complex<double> (或任何 U 到 std::complex)带有 operator= 的数组.为此，我使用了 std::enable_if .但是，它未能检测到不应使用它。

下面的函数，如果输入T我想被调用是什么复杂的东西。所以我使用了条件 std::is_same<T, std::complex<typename T::value_type> ，因为 std::complex在 ::value_type 中存储它使用的类型.这是函数的定义:

template <typename T, int S>
typename std::enable_if<std::is_same<T, std::complex<typename T::value_type> >::value, MyArray<T,S>& >::type
MyArray<T,S>::operator=(const typename std::enable_if<std::is_scalar<typename T::value_type>::value, MyArray<typename T::value_type>&, S >::type rhs)

但是，如果我尝试复制 MyArray<double>，则会出现以下错误.所以显然它没有检测到 double不是`

error: 'double' is not a class, struct, or union type MyArray::operator=(const typename std::enable_if::value, MyArray&, S >::type rhs)

我在这里做错了什么？

---

更新:

我想弄清楚我想要实现的目标，因为(抱歉)有太多的困惑。

我需要这个操作成为可能:

MyArray<double> d;
MyArray<std::complex<double>> cd;
cd = d;

Answer 1

不确定是否理解但是......如果你想启用你的operator=()仅当传入MyArray<T>与 T 一起那是一个std::complex<U> ，你为什么不简单地写

   template <typename F>
     MyArray & operator= (MyArray<std::complex<F>> const & rhs)
      { return *this }

--编辑--

I want to assign U to std::complex<U>, so MyArray<std::complex<U>> = MyArray<U>.

所以你想要的恰恰相反。

我想你可以做类似的事情

#include <complex>
#include <type_traits>

template <typename T>
struct MyArray
 {
   template <typename U>
   typename std::enable_if<std::is_same<T, std::complex<U>>::value,
         MyArray &>::type 
      operator= (MyArray<U> const & rhs)
       { return *this; }
 };

int main()
 {
   MyArray<double> d;
   MyArray<std::complex<double>> cd;
   cd = d;
 }

-- 编辑 2 --

but there's a second template parameter that I removed in the original question, thinking that I'm simplifying the issue for readability. But it was wrong of me to do that, because partial specializations of functions are not allowed in C++. So my template is template , not template , which is very different

我不认为这是必要的偏特化

#include <complex>
#include <type_traits>

template <typename T, int S>
struct MyArray
 {
   template <typename U>
   typename std::enable_if<std::is_same<T, std::complex<U>>::value,
        MyArray &>::type 
    operator= (MyArray<U, S> const & rhs)
     { return *this; }
 };

int main()
 {
   MyArray<double, 3> d;
   MyArray<std::complex<double>, 3> cd;
   cd = d;
 }

如果问题出在定义operator()在类的主体之外，我提出以下修改示例

#include <complex>
#include <type_traits>

template <typename T, int S>
struct MyArray
 {
   template <typename U>
   typename std::enable_if<std::is_same<T, std::complex<U>>::value,
        MyArray &>::type 
    operator= (MyArray<U, S> const & rhs);
 };

template <typename T, int S>
template <typename U>
typename std::enable_if<std::is_same<T, std::complex<U>>::value,
      MyArray<T, S> &>::type 
   MyArray<T, S>::operator= (MyArray<U, S> const & rhs)
      { return *this; }

int main()
 {
   MyArray<double, 3> d;
   MyArray<std::complex<double>, 3> cd;
   cd = d;
 }

-- 编辑 3 --

Is there a way to do the same with the copy constructor? [...] It's quite tricky and seems impossible because there's no return type.

是的，有办法

#include <complex>
#include <type_traits>

template <typename T, int S>
struct MyArray
 {
   template <typename U>
   typename std::enable_if<std::is_same<T, std::complex<U>>::value,
         MyArray &>::type 
      operator= (MyArray<U, S> const & rhs)
       { return *this; }

   template <typename U,
            typename = typename std::enable_if<std::is_same<T,
                           std::complex<U>>::value>::type>
   MyArray (MyArray<U, S> const & rhs)
    { }

   MyArray() = default;
   MyArray(MyArray const &) = default;
   MyArray(MyArray &&) = default;
   ~MyArray() = default;
 };

int main()
 {
   MyArray<double, 3> d;                      // need MyArray() = default
   MyArray<double, 3> d2(d);                  // OK
   MyArray<float, 3> f;                       // OK
   MyArray<std::complex<double>, 3> cd(d);    // OK
   //MyArray<std::complex<double>, 3> cd2(f); // error!
   cd = d;

 }

观察 = default添加行；没有第一个(我不知道其他三个是否有用)代码无法编译，因为(如果我理解正确的话)SFINAE 复制构造函数禁用(删除)默认复制构造函数因此删除其他默认构造函数和默认析构函数。