Question

我有一个动态分配的float数组，我需要将这个数组作为参数传递给三个不同的函数，但每个函数需要获得不同的数组范围。有什么方法可以将元素0到23的数组发送到一个函数，将元素24到38发送到另一个函数，将元素39到64发送到第三个函数。

在某些语言中（我认为像python一样）你可以这样做：

somefunction(my_array[0:23]);
somefunction(my_array[24:38]);
somefunction(my_array[39:64]);

但是我使用的是c ++，我不知道在c ++中有什么办法。

有人知道怎么做吗？

somefunction（）;是一个来自API的函数，所以我无法修改它所需的参数。

Answer 1

如果编写函数来操作一对正向迭代器而不是数组，你可以像这样传递它：

somefunction1(my_array, my_array + 24);
somefunciton2(my_array + 24, my_array + 39);
somefunction3(my_array + 39, my_array + 65);

指针是前向迭代器，这样就可以在部分向量，队列或其他STL容器上使用这些函数。

Answer 2

无论如何，你的函数需要一些方法来确定数组的大小。我建议你按照标准库算法的方式使函数采用开始和结束迭代器，如下所示：

template<typename I>
void somefunction(I begin, I end);

然后，您可以使用您的数组调用它：

somefunction(my_array, my_array + 24);
somefunction(my_array + 24, my_array + 39);
somefunction(my_array + 39, my_array + 65);

Answer 3

python示例正在制作副本。如果你的用例没问题，你可以这样做（我正在为std :: vector换掉你的vanilla数组）：

#include <iostream>
#include <vector>

void somefunction(std::vector<int> v) {
    std::cout << "vector has " << v.size() << " elements,"
        << " first value is " << *v.begin() << ","
        << " last value is " << *(v.end()-1) << std::endl;
}

int main() {
    std::vector<int> a;
    for (int i=0; i<65; i++) {
        a.push_back(i);
    }
    somefunction(std::vector<int>(a.begin(),a.begin()+23));
    somefunction(std::vector<int>(a.begin()+24,a.begin()+38));
    somefunction(std::vector<int>(a.begin()+39,a.begin()+65));
}

输出：

vector has 23 elements, first value is 0, last value is 22
vector has 15 elements, first value is 23, last value is 37
vector has 27 elements, first value is 38, last value is 64

但听起来你不能使用std :: vector，因为somefunction（）有一个你无法改变的签名。幸运的是，您只需手动复制阵列的某些部分就可以进行类似的体操，如下所示：

#include <iostream>
#include <string.h>

void somefunction(int v[], int len) {
    std::cout << "vector has " << len << " elements,"
        << " first value is " << v[0] << ","
        << " last value is " << v[len-1] << std::endl;
}

int main() {
    int a[65];
    for (int i=0; i<65; i++) {
        a[i] = i;
    }
    int b[23];
    memcpy(b, a, 23*sizeof(int));
    somefunction(b, 23);
    int c[15];
    memcpy(c, a+23, 15*sizeof(int));
    somefunction(c, 15);
    int d[27];
    memcpy(d, a+38, 27*sizeof(int));
    somefunction(d, 27);
}

再次输出：

vector has 23 elements, first value is 0, last value is 22
vector has 15 elements, first value is 23, last value is 37
vector has 27 elements, first value is 38, last value is 64

Answer 4

有两种方法可以做到：

void useArray(int array[], size_t len) { ... }
...
useArray(myArray, 24);
useArray(&myArray[24], 15);
useArray(&myArray[39], 26);

OR

void useArray(int *start, int *end) { ... }
...
useArray(myArray, myArray + 24);
useArray(myArray + 24, myArray + 39);
useArray(myArray + 39, myArray + 65);

第一种是C语言，第二种是C ++方式。请注意，使用第二种方式，范围为[start, end) - end未包含在范围内，因为您在C ++中看到很多。

编辑：您修改了帖子，提到您正在使用glTexCoordPointer()。在这种情况下，将数组的开头传递给glTexCoordPointer()，myArray，myArray + 24或myArray + 39。

但仍然需要知道数组的大小，并将其传递给glDrawArrays或glDrawElements()等函数，然后这些函数将从数组开始读取。如果您使用glDrawArrays()，则数组的长度将作为第二个参数传递。因此，您的代码可能类似于：

glTexCoordPointer(..., ..., ..., my_array);
...
glDrawArrays(..., 0, 24);

glTexCoordPointer(..., ..., ..., my_array + 24);
...
glDrawArrays(..., 0, 15);

glTexCoordPointer(..., ..., ..., my_array + 39);
...
glDrawArrays(..., 0, 26);

Answer 5

没有上限范围检查，所以你必须自己处理。但是你可以将＆amp; my_array [0]传递给一个函数，将＆amp; my_array [24]传递给另一个函数。也许在你的函数中添加一个len参数来处理上限。

Answer 6

你可以重构你的函数来使用'iterators'：指向你感兴趣的数组范围的开头和结尾的指针：

 void somefunction( int* begin, int* end ) {
    for( int* i=begin; i != end; ++i ) {
       //stuff with *i
    }
 }


 // usage:
 somefunction( my_array+0, my_array+23 );
 somefunction( my_array+24, my_array+38 );
 somefunction( my_array+39, my_array+64 );

奖励积分：如果你将你的函数作为模板，你也可以将它与其他迭代器一起使用：

 template<typename T>
 void somefunction( T begin, T end ) {
    for( T i=begin; i != end; ++i ) {
       //stuff with *i
    }
 }

 vector<int> values(100);
 somefunction( values.begin(), values.end() );
 somefunction( values.rbegin(), values.rend() );

...

Answer 7

我会返回或执行类似 std::pair<pointer_type, pointer_type> 之类的操作，其中包含 {Begin_Pointer, End_Pointer} 因此，如果我们需要使用特定部分/块对原始数组（在 C/C++ 中只是一个指针）进行切片。我会回来采取类似的东西

pointer_type element_begin = raw_array+begin;
pointer_type element_end = raw_array+end;
std::pair<pointer_type, pointer_type> = std::make_pair(element_begin, element_end);

我将有一个方便的函数，我给这些 begin 和 end 非负值，它会返回一个 std::pair

仅使用数组的一部分

7 个答案: