c++ - 对于二维矩阵，它在 C++11 中是否与 C11 中的函数类似？

Question

我注意到在 gcc C11 中，您可以将任何矩阵传递给函数 fn(int row, int col, int array[row][col])。如何将我在下面放置的(在指向另一个 stackoverflow 答案的链接中)C11 中的程序转换为 C++11 中的程序？

C - allocating a matrix in a function

如您所见，我可以在 C11 中将静态和动态分配的数组传递给函数。在 C++11 中可能吗？

我已经根据不同的 stackoverflow 答案制作了一个示例程序，但是所有函数都适用于 array1 而没有一个适用于 array2，其中 double array1[ROW][COL] = { { } } 和 auto array2 = new double[ROW][COL]() ?

如何像 C11 中那样为两个数组创建一个函数 fn(int row, int col, int array[row][col])?

#include <iostream>
#include <utility>
#include <type_traits>
#include <typeinfo>
#include <cxxabi.h>
using namespace std;

const int ROW=2;
const int COL=2;

template <size_t row, size_t col>
void process_2d_array_template(double (&array)[row][col])
{
    cout << __func__ << endl;
    for (size_t i = 0; i < row; ++i)
    {
        cout << i << ": ";
        for (size_t j = 0; j < col; ++j)
            cout << array[i][j] << '\t';
        cout << endl;
    }
}

void process_2d_array_pointer(double (*array)[ROW][COL])
{
    cout << __func__ << endl;
    for (size_t i = 0; i < ROW; ++i)
    {
        cout << i << ": ";
        for (size_t j = 0; j < COL; ++j)
            cout << (*array)[i][j] << '\t';
        cout << endl;
    }
}

// int array[][10] is just fancy notation for the same thing
void process_2d_array(double (*array)[COL], size_t row)
{
    cout << __func__ << endl;
    for (size_t i = 0; i < row; ++i)
    {
        cout << i << ": ";
        for (size_t j = 0; j < COL; ++j)
            cout << array[i][j] << '\t';
        cout << endl;
    }
}

// int *array[10] is just fancy notation for the same thing
void process_pointer_2_pointer(double **array, size_t row, size_t col)
{
    cout << __func__ << endl;
    for (size_t i = 0; i < row; ++i)
    {
        cout << i << ": ";
        for (size_t j = 0; j < col; ++j)
            cout << array[i][j] << '\t';
        cout << endl;
    }
}

int main()
{
    double array1[ROW][COL] = { { } };
    process_2d_array_template(array1);
    process_2d_array_pointer(&array1);    // <-- notice the unusual usage of addressof (&) operator on an array
    process_2d_array(array1, ROW);
    // works since a's first dimension decays into a pointer thereby becoming int (*)[COL]

    double *b[ROW];  // surrogate
    for (size_t i = 0; i < ROW; ++i)
    {
        b[i] = array1[i];
    }
    process_pointer_2_pointer(b, ROW, COL);


    // allocate (with initialization by parentheses () )
    auto array2 = new double[ROW][COL]();

    // pollute the memory
    array2[0][0] = 2;
    array2[1][0] = 3;
    array2[0][1] = 4;
    array2[1][1] = 5;

    // show the memory is initialized
    for(int r = 0; r < ROW; r++)
    {
        for(int c = 0; c < COL; c++)
            cout << array2[r][c] << " ";
        cout << endl;
    }

    //process_2d_array_pointer(array2);
    //process_pointer_2_pointer(array2,2,2);

    int info;
    cout << abi::__cxa_demangle(typeid(array1).name(),0,0,&info) << endl;
    cout << abi::__cxa_demangle(typeid(array2).name(),0,0,&info) << endl;

    return 0;
}

Answer 1

您在 C11 中使用的功能是在 C99 中引入的，专门设计用于高效轻松地处理多维数组。

虽然 C++ 在(多维)数组方面与 C 共享基本语法，但数组类型在 C++ 中的功能要弱得多:在 C++ 中，数组类型的大小必须是编译时常量。下面是几个例子:

void foo(int a, int b) {
    int foo[2][3];     //legal C++, 2 and 3 are constant
    int bar[a][3];     //Not C++, proposed for C++17: first dimension of an array may be variable
    int baz[a][b];     //Not C++, legal in C99

    int (*fooPtr)[2][3];    //legal C++
    int (*barPtr)[a][3];    //Not C++, legal in C99
    int (*bazPtr)[a][b];    //Not C++, legal in C99

    typedef int (*fooType)[2][3];    //legal C++
    typedef int (*barType)[a][3];    //Not C++, legal in C99
    typedef int (*bazType)[a][b];    //Not C++, legal in C99

    int (*dynamicFoo)[3] = new int[2][3];    //legal C++
    int (*dynamicBar)[3] = new int[a][3];    //legal C++
    int (*dynamicBar)[b] = new int[a][b];    //Not C++
}

如您所见，几乎所有在 C 语言中使用动态大小数组可能实现的功能在 C++ 中都是不可能的。即使是为下一个 C++ 标准提议的 VLA 扩展也无济于事:它仅限于数组的第一维。

在 C++ 中，你必须使用 std::vector<>实现您可以使用 C99 可变长度数组实现的目标。所有的后果:

• std::vector<std::vector<> > 中的数据在内存中不连续。您的缓存可能不喜欢这样。

• 不保证 std::vector<std::vector<> >所有线阵列具有相同的长度。这可能是有用的，也可能是痛苦的，具体取决于您的用例。

• 如果你有一个指向 std::vector<std::vector<> > 中元素的迭代器, 你不能将它推进到下一行中的相应元素。