模板的复制的构造失败的具体模板类型

Question

正如我的一些代码所需的隐含之间的转换矩阵的不同类型(例如 Matrix<int> 要 Matrix<double>)，我定义的一个模板构造复制 Matrix<T>::Matrix(Matrix<U> const&) 而不是标准 Matrix<T>::Matrix(Matrix<T> const&):

template <typename T> class Matrix {
public:
    // ...
    template <typename U> Matrix(Matrix<U> const&);
    // ...
private
    unsigned int m_rows, m_cols;
    T *m_data;
    // ...
};

有一个适当的定型加以复制的构造，这种方法完美之间转换矩阵的不同类型。令人惊奇的是，它未能与一个malloc错误在非常的情况是，一个简单的复制的构造将功能：哪里 U == T.确保有足够，超载复制的构造与默认 Matrix<T>::Matrix(Matrix<T> const&) 签署解决的问题。

这是一个贫穷的解决方案，因为它的结果在批发工作重复的副本构造代码(字面上的一个不变的复制和粘贴)。更重要的是，我不明白为什么有双免费的 malloc 错误而没有重复代码。此外，为什么是非常详细 template <typename T> template <typename U> 语法要求此作为反对标准，和更为简洁， template <typename T, typename U>?

全源模板的方法，编制使用克++v4。0.1在Mac OS10.5.

template <typename T> template <typename U> Matrix<T>::Matrix(Matrix<U> const& obj) {
    m_rows = obj.GetNumRows();
    m_cols = obj.GetNumCols();
    m_data = new T[m_rows * m_cols];

    for (unsigned int r = 0; r < m_rows; ++r) {
        for (unsigned int c = 0; c < m_cols; ++c) {
            m_data[m_rows * r + c] = static_cast<T>(obj(r, c));
        }
    }
}

Answer 1

它失败，因为一个模板不抑制了隐性声明的副本构造。它将作为一个简单的转换的构造，可用于复制目的时过载决议选择。

现在，你可能复制了你的矩阵的地方，这将使用的隐含的定义的复制的构造不平面副本。然后，复制的矩阵和复制会在其析构中删除的相同的指针。

此外，为什么是非常详细 template <typename T> template <typename U> 句法要求的

因为有两个模板：该矩阵，这是一类的模板和转换的构造模板。每个模板应该得到其自己的模板条款，有其自己的参数。

你应该摆脱的 <T> 在你的第一线，通过这种方式。这样的事情不时出现确定一个模板。

这是一个贫穷的解决方案，因为它的结果在批发工作重复的副本构造代码

你可以定义件功能的模板，该模板将做的工作，并将从两个转换的构造和复制构造。这样的代码不是重复的。

---

理查德有了一个良好的点评论，这让我修改了我的答案。如果候选人的功能产生的模板是一个更好的匹配比隐含的声明的副本构造，然后该模板"胜利"，并将它称为。这里有两个常见的例子：

struct A {
  template<typename T>
  A(T&) { std::cout << "A(T&)"; }
  A() { }
};

int main() {
  A a;
  A b(a); // template wins:
          //   A<A>(A&)  -- specialization
          //   A(A const&); -- implicit copy constructor
          // (prefer less qualification)

  A const a1;
  A b1(a1); // implicit copy constructor wins: 
            //   A(A const&) -- specialization
            //   A(A const&) -- implicit copy constructor
            // (prefer non-template)
}

一个复制的构造可以有一个非常量基准参数，如果其任何成员都有

struct B { B(B&) { } B() { } };
struct A {
  template<typename T>
  A(T&) { std::cout << "A(T&)"; }
  A() { }
  B b;
};

int main() {
  A a;
  A b(a); // implicit copy constructor wins:
          //   A<A>(A&)  -- specialization
          //   A(A&); -- implicit copy constructor
          // (prefer non-template)

  A const a1;
  A b1(a1); // template wins: 
            //   A(A const&) -- specialization
            // (implicit copy constructor not viable)
}

Answer 2

我不完全清楚自己的问题，但我怀疑发生了什么是默认的复制的构造(这不会员复制仅)正在使用的是在一些地方在你的代码。记住，不仅是代码实际上，你写使用复制的构造-编译器使用它了。