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;
        }
    }

其结果是：

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

但是现在我想构建这些单独数组的序列（序列的长度不是常数，可以是2到5个单独数组）：

。。。并且能够把它传递给一个函数，这个函数也会这样做。但是，如果没有每个数组的长度，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;
            }
        }
    }

---

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

< P>在C和C++中，你把一个数组作为打印机传递给第一个元素。被叫人不知道大小。正如您所注意到的，必须沿指针传递大小。另一种方法是在数组的最后一个元素传递一个特殊值。这就是以零结尾的字符串的工作方式。另一种方法是保留前几个元素来存储数组大小。或者将数组嵌入到一个结构中，该结构也开始调整大小

在C++ STL中，这都是由向量类来解决的，它包括数组、管理器的大小、增长和减小数组的大小和其他关注点。 P>因此，C++中不使用裸原始数组，而是使用向量。

(int* array, int arrayLen)

因此我们有三个

int

s数组：

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)

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);

并将其传递给我们的职能部门：

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)

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);

void processSequences2（span*span，大小\u t spanscnt）{
//迭代数组中的元素
对于（尺寸i=0；iSTD:：CUT结构…我恐怕我需要这么做。特殊字符…HRM，也许。我必须做一些测试。谢谢！有没有一个特殊的原因你不想使用向量？毕竟使用C++没有STL有点挫败了使用C++的观点。我唯一能想象的是你想在细节或需要中学习语言。为一些非常有限的平台进行构建。无论如何，Kamil Cuk已经给出了一个非常详细的答案，并提供了很好的示例。啊，你一针见血。在我进入不同的概念之前，我确实想详细学习该语言。好的，我能够通过使用方法1和指针数组或方法1获得我期望的结果2使用结构。感谢您给出这两个示例。这使我能够确定我更喜欢哪种样式。但现在我陷入了下一步（这将是本项目的最后一步）-随机化，如随机选择其中一个（有数百个数组/结构）我将首先尝试找出它…然后如果我找不到它，我将发布另一个线程。再次感谢！Nvm，我的内存不足，因为有一个大数组可以保存random（）的所有序列从中挑选。这是在一台只有2k SRAM的ATmega328p上完成的。嗯，回到广场…嗯…3？其他一切都正常！
// 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);

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);
}