2

我已经实现了一个带有移动分配的 Matrix 类

template <typename OutType>
class Matrix
{
    public:
        int Rows_;                      // number of Rows
        int Columns_;                   // number of Columns
        OutType *data_;                 // row Major order allocation

    // STUFF

        Matrix<OutType> & operator=(Matrix<float>&& other) {
            swap(other);
            return *this;
        }

        void swap(Matrix<float>& other) {
            int t_Rows_ = Rows_;        Rows_ = other.Rows_;        other.Rows_ = t_Rows_;
            int t_Columns_ = Columns_;  Columns_ = other.Columns_;  other.Columns_ = t_Columns_;
            float* t_ptr = data_;
            data_ = other.data_;
            other.data_ = t_ptr; }      
}

为了实现B=f(A);语法，如建议的那样

C++：实现 B=f(A)，B 和 A 数组以及 B 已经定义

作为可能的功能，我正在考虑 FFT，实现为

Matrix<float> FFT(const Matrix<float> &in)
{
    Matrix<float> out(in.GetRows(),in.GetColumns());

    // STUFF

    return out;
}

有没有进一步提高效率的空间？是否有任何进一步的技巧可以改进，例如移动分配或swap功能？

编辑：康拉德·鲁道夫评论后的新解决方案

        Matrix & operator=(Matrix&& other) {
            std::swap(Rows_, other.Rows_);
            std::swap(Columns_, other.Columns_);
            std::swap(data_, other.data_); 
            std::cout << "move assigned \n";
            return *this;
        }
4

1 回答 1

0

我建议为您的班级实施移动分配和移动构造：

Matrix( Matrix<OutType> &&that ) noexcept
    : Rows_(that.Rows_)
    , Cols_(that.Cols_)
    , data_(that.data_)
{
    that.Rows_ = that.Cols_ = 0;
    that.data_ = nullptr;
}
Matrix<OutType> &operator=( Matrix<OutType> &&that ) noexcept {
     using std::swap;
     swap( Rows_, that.Rows_ );
     swap( Cols_, that.Cols_ );
     swap( data_, that.data_ );
     return *this;
}

如果你像这样实现移动操作（构造和赋值），std::swap应该对你的代码很有用，你不需要提供你自己的。如果您确实想提供自己的 实现swap，我建议将其作为两个参数的friend函数提供，以便可以通过 Argument Dependent Look-up 找到它。我还建议swap在没有命名空间限定的情况下调用（和所有其他函数），如上所示，这样 ADL 就不会被抑制（除非出于某种原因，您确实需要准确指定调用哪个函数，以及为特定类型定制的重载会错的）。ADL 在处理模板化代码时特别有价值。如果你打电话std::swap给std::限定符，您显着减少了用户定义类型提供更有效交换实现的机会。

于 2013-04-29T22:41:57.567 回答