Question

我注意到在gcc C11中你可以将任何矩阵传递给函数fn(int row, int col, int array[row][col])。如何将我在C11中的下面（在另一个stackoverflow答案的链接中）程序转换为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

C ++ does not have VLA。它是针对C ++ 17提出的，但还有很多工作要做，因为它对类型系统来说是一个很大的变化，而且无论如何使用C风格的数组都是无视的。

如您所见，您可以在编译时知道大小时使用模板。如果在编译时不知道大小，那么最好的办法是使用一个包含在类中的单维vector，以便以您希望的方式访问它。

vector的{{1}}当然也是可能的;描述锯齿状数组。您是否更喜欢单个大内存块取决于各种事物（编码的复杂性，运行时速度/内存使用注意事项等）。

Answer 2

您在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<> >中元素的迭代器，则无法将其前进到下一行中的相应元素。

在C ++ 11中它是否与C11中的二维矩阵类似？

2 个答案: