Question

我编写了一个简单的Matrix类，以便更轻松地访问各个数据数组元素。它将信息保存在标准数组中，并通过重载括号operator（）返回单个元素，但是，类对象上的overloaded（）运算符似乎比数据数组上的standard []调用慢得多。帖子底部的类代码。

我认为重载的运算符（i，j）与在数据数组上调用[i * ncols + j]相同，但是，在运行一些测试之后，它大约慢了三倍。我已经在两个简单的函数上测试了这个理论：

void square_array(double * data_array, int nrows, int ncols)
{
    for (int i = 0; i < nrows; i++)
    for (int j = 0; j < ncols; j++)
    {
        data_array[i * ncols + j] = data_array[i * ncols + j] * data_array[i * ncols + j];
    }
}

void square_mymatrix(MyMatrix & data_mymatrix, int nrows, int ncols)
{
    for (int i = 0; i < nrows; i++)
    for (int j = 0; j < ncols; j++)
    {
        data_mymatrix(i, j) = data_mymatrix(i, j) * data_mymatrix(i, j);
    }
}

通过使用1000x1000阵列调用它们

// Define and fill data_array
square_array(data_array, rowsN, colsN);

// Define and fill data_mymatrix
square_mymatrix(data_mymatrix, rowsN, colsN);

第二个函数调用的时间是第一个函数的三倍（~4.1ms vs~11.9ms）。为什么通过括号运算符访问数据比使用[]慢得多？我在代码中某处犯了错误吗？

以下是MyMatrix类的代码。

class MyMatrix
{
    double * data;
    int nrows;
    int ncols;

    public:
        // Standard constructur prividing a pre-existant array
        MyMatrix(double * data_array, int rows, int cols)
        {
            this->nrows = rows;
            this->ncols = cols;
            this->data = data_array;
        }
        //Empty constructor
        MyMatrix() {}

        //Simple functions to obtain rows and cols of the matrix
        int get_nrows() {return this->nrows;}
        int get_ncols() {return this->ncols;}

        // Overloaded bracket operator to access the values
        double & operator()(int i, int j) {return data[i * ncols + j];}

        // Overloaded bracket operator for constant objects:
        const double & operator()(int i, int j) const {return data[i * ncols + j];}
};

Answer 1

使用-O2或-O3以更高的优化级别调用GCC。这应该正确地内联函数调用operator()并生成等于直接访问数据的二进制代码。

重载运算符，用于访问cpp：performance中的成员数组元素

1 个答案: