初始化列表的赋值

Question

下面的代码是我的问题的一个最小示例。我创建了一个包含固定大小数组的简单模板类，并重载了赋值运算符以接受定义方法size() 和begin() 的任何类（例如initializer_lists）。我不明白为什么 g++ 无法解析我对该运算符的调用（我使用的是 gcc 4.6）：

***.cpp: In function ‘int main()’:
***.cpp:46:22: error: no match for ‘operator=’ in ‘a = {42, -1.0e+0, 3.14158999999999988261834005243144929409027099609375e+0}’
***.cpp:46:22: note: candidates are:
***.cpp:23:8: note: template<class U> A<T, N>::self& A::operator=(const U&) [with U = U, T = double, unsigned int N = 3u, A<T, N>::self = A<double, 3u>]
***.cpp:8:7: note: A<double, 3u>& A<double, 3u>::operator=(const A<double, 3u>&)
***.cpp:8:7: note:   no known conversion for argument 1 from ‘<brace-enclosed initialiser list>’ to ‘const A<double, 3u>&’
***.cpp:8:7: note: A<double, 3u>& A<double, 3u>::operator=(A<double, 3u>&&)
***.cpp:8:7: note:   no known conversion for argument 1 from ‘<brace-enclosed initialiser list>’ to ‘A<double, 3u>&&’

第一个候选者被正确列出，但没有相关的错误消息。代码如下：

#include <iostream>
#include <algorithm>
#include <initializer_list>

// ------------------------------------------------------------------------

template <typename T, unsigned N>
class A
{
public:

    typedef A<T,N> self;

    // Default ctor
    A() {}

    // Copy ctor
    template <typename U>
    A( const U& other ) { operator=(other); }

    // Assignemnt
    template <typename U>
    self& operator= ( const U& other )
    {
        if ( other.size() == N )
            std::copy_n( other.begin(), N, m_data );
            return *this;
    }

    // Display contents
    void print() const
    {
        for ( unsigned i = 0; i < N; ++i )
            std::cout << m_data[i] << " ";
        std::cout << std::endl;
    }

private:
    T m_data[N];
};

// ------------------------------------------------------------------------

int main()
{
    A<double,3> a;
    a = {42,-1.0,3.14159};
    a.print();
}

有谁知道为什么这可能是模棱两可的，或者我做错了什么？

---

注意：理想情况下，我什至想用一个 A<double,3> a = {42,-1.0,3.14159}; 替换 main 的前两行，但我不确定如何，我目前收到以下错误：

***: In function ‘int main()’:
***:45:34: error: could not convert ‘{42, -1.0e+0, 3.14158999999999988261834005243144929409027099609375e+0}’ from ‘<brace-enclosed initialiser list>’ to ‘A<double, 3u>’

Answer 1

与auto 不同，将花括号初始化列表推导出为initializer_list，模板实参推导将其视为非推导上下文，除非存在initializer_list<T> 类型的相应参数，其中可以推导出T的情况。

来自 §14.8.2.1/1 [temp.deduct.call]（已添加重点）

模板参数推导是通过将每个函数模板参数类型（称为P）与调用的相应参数类型（称为A）进行比较来完成的，如下所述。如果从 P 中删除引用和 cv 限定符会为某些 P0 提供 std::initializer_list<P0> 并且参数是初始化器 list (8.5.4)，然后对初始化列表的每个元素执行推导，将P0 作为函数模板参数类型，并将初始化元素作为其参数。 否则，初始化列表参数会导致参数被视为非推导上下文 (14.8.2.5)。

因此，operator= 的参数不会被推断为initializer_list<double>。要使代码正常工作，您必须定义一个带有 initializer_list 参数的 operator=。

template <typename U>
self& operator= ( const std::initializer_list<T>& other )
{
    if ( other.size() == N )
        std::copy_n( other.begin(), N, m_data );
    return *this;
}

Answer 2

大括号括起来的初始化器列表不一定具有std::initializer_list<T> 类型，因此您需要指定赋值运算符模板需要std::initializer_list：

  template <typename U>
  A& operator=(std::initializer_list<U> other )
  {
    if ( other.size() == N )
      std::copy_n( other.begin(), N, m_data );
    return *this;
  }

或

  A& operator=(std::initializer_list<double> other )
  {
    if ( other.size() == N )
      std::copy_n( other.begin(), N, m_data );
    return *this;
  }

我必须说，如果大小不匹配，赋值运算符会静默失败，这似乎不是一个好主意。

Answer 3

我会说是这样的：

A<double,3> a;
a = {42,-1.0,3.14159};

您正在使用默认构造函数初始化 a，然后尝试在已初始化的对象上使用初始化列表 - 它抱怨缺少适当的 operator= 重载。而是尝试：

A<double,3> a = {42,-1.0,3.14159};

编辑：

你也没有定义必需的构造函数：

template <typename T, unsigned N>
class A
{
public:
    A(std::initializer_list list) : m_data(list) {}

//...
}