Question

我定义了多个长度各不相同的数组：

    int arr1[] = {1, 2, 3, 4};
    int arr2[] = {1, 3, 5, 7, 9};
    int arr3[] = {6, 8, 11, 5, 2, 3, 6};

我将这些传递给一个函数，该函数将对数组中的每个元素进行处理：

    void procesArr(int* array, int arrayLen) {
        for (int i = 0; i < arrayLen; i++) {
            // Do something, like print the value
            cout << "array[" << i << "]: " << array[i] << endl;
        }
    }

然后我可以做：

    processArr(arr1);

这将导致：

    array[0]: 1
    array[1]: 2
    array[2]: 3
    array[3]: 4

但是现在我要构建一个由单个数组组成的序列（序列的长度不是恒定的，可以是2到5个单个数组）：

    int seq1[] = {*arr1, *arr2, ..., *arrN};

...并能够将其传递给将执行相同操作的函数。但是，如果没有每个数组的长度，for循环将不知道每个数组的上限是什么。

我想要的最终结果是一个将序列作为参数的函数，然后分离并分别处理每个单独的数组。本质上是这样的：

    processSequence(seq1) {  // I think I need to include sizeof(seq1) here
        for (int s = 1; s < [length of seq1]; s++;) {
            // process each individual array
            for (int a = 1; a < [length of individual array]; a++) {
                cout << "seq1[" << s << "][" << a << "]: " << seq[s][a] << endl;
            }
        }
    }

然后它会产生类似的内容：

    // First array
    seq1[0][0] = 1
    seq1[0][1] = 2
    seq1[0][2] = 3
    seq1[0][3] = 4
    // Second array
    seq1[1][0] = 1
    seq1[1][1] = 3
    seq1[1][2] = 5
    seq1[1][3] = 7
    seq1[1][4] = 9

这是我缺乏编程知识的地方，因为我不知道该怎么做。

Answer 1

(int* array, int arrayLen)

因此，我们有三个int数组：

int arr1[] = {1, 2, 3, 4};
int arr2[] = {1, 3, 5, 7, 9};
int arr3[] = {6, 8, 11, 5, 2, 3, 6};

那么我们可以：

// Create an array of pointers to these arrays
// "Array of type" is implicitly converted to "pointer to type"
// Type `int[X]` is implicitly converted to `int*`
int *arrs[] = { arr1, arr2, arr3, };

// Create an array of lengths of the arrays inside
size_t arrslenin[] = { 4, 5, 7 };

// And we have the array of pointers has the length itself
size_t arrslen = 3;

然后我们可以将其全部传递给我们的函数：

void processSequences1(int **arrs, size_t *arrslenin, size_t arrslen) {
    // iterate over elements in arrs
    for (size_t i = 0; i < arrslen; ++i) {
        // iterate over elements of the arrays inside arrs
        for (size_t j = 0; j < arrslenin[i]; ++j) {
            // print
            std::cout << "seq1[" << i << "][" << j << "]: " << arrs[i][j] << std::endl;
         }
     }
}

// call
processSequences(arrs, arrslenin, arrslen)

我们可以对不同的结构执行相同的操作-即将长度与指针存储在一起的对象。然后将这些对象的数组传递给我们的函数。例如我们可以声明一个“ span”对象，该对象代表一个跨度，即内存中的一个区域：

// it begs to write template<typename T> here
struct span {
    int *pnt;
    size_t len;

    // get size from type
    template<size_t N>
    span(int (&p)[N]) : pnt(p), len(N) {}

    // accessors
    size_t size() const { return len; }
    int* data() { return pnt; }
    int& operator[](size_t x) { return pnt[x]; }
};

然后创建一个跨度数组：

span spans[3] = { span(arr1), span(arr2), span(arr3), };
size_t spanscnt = 3;

并将其传递给我们的函数：

void processSequences2(span *spans, size_t spanscnt) {
     // iterate over elements in spans array
     for (size_t i = 0; i < spanscnt; ++i) {
        // iterate over elements in the array inside spans[i]
        for (size_t j = 0; j < spans[i].size(); ++j) {
            // print
            std::cout << "seq1[" << i << "][" << j << "]: " << spans[i][j] << std::endl;
         }
     }
}

// call
processSequences(spans, spanscnt);

或使用STL并创建ex。向量int的向量（或使用C ++ 20中的std :: span（如果可用，并使用span的向量））。下面我使用向量向量：

void processSequences3(std::vector<std::vector<int>> &v) {
     for (size_t i = 0; i < v.size(); ++i) {
        for (size_t j = 0; j < v[i].size(); ++j) {
            std::cout << "seq1[" << i << "][" << j << "]: " << v[i][j] << std::endl;
         }
     }
}

void f() {
    // note that values inside the arrays will be copied to vector
    std::vector<std::vector<int>> v = {
        std::vector<int>(arr1, arr1 + 4),
        std::vector<int>(arr2, arr2 + 5),
        std::vector<int>(arr3, arr3 + 7),
    };
    processSequences3(v);
}

在tutorialspoint上进行了测试。

Answer 2

在c和c ++中，将数组作为打印机传递给第一个元素。被呼叫者不知道大小。如您所见，您必须沿指针传递大小。另一种方法是在数组的最后一个元素处传递一个特殊值。这是零终止字符串的工作方式。还有一种方法是保留前几个元素来存储数组大小。或将数组嵌入结构中，该结构也可以确定大小。

在c ++ stl中，所有这些都由vector类解决，vector类包装了数组，管理了数组的大小，增大和减小了数组的大小以及其他问题。

因此，在c ++中，不要使用裸露的原始数组，而要使用向量。

将多个数组传递给一个函数

2 个答案: