时间戳

首页 > 解决方案 > 将多个数组传递给函数

c++ - 将多个数组传递给函数

问题描述

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

    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

这就是我缺乏编程知识的地方，因为我不知道如何做到这一点。

标签： c++

解决方案

(int* array, int arrayLen)

所以我们有三个ints数组：

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。整数向量的向量（或使用 C++20 中的 std::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上测试。

推荐阅读