en utilisant seulement une partie d'un tableau

J'ai un allouée dynamiquement tableau de float et j'ai besoin de passer ce tableau comme argument à trois fonctions différentes, mais chaque fonction doit obtenir une gamme différente de la matrice. Est-il un moyen pour que je puisse envoyer le tableau avec des éléments de 0 à 23 à une seule fonction, les éléments de 24 à 38 à l'autre, et les éléments de 39 à 64 ans pour une troisième fonction.

Dans certaines langues(comme le python, je crois), vous pouvez faire quelque chose comme ceci:

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

Cependant, je suis à l'aide de c++ et je ne suis pas au courant de toute façon de le faire en c++.

Quelqu'un sait comment faire cela?

somefunction(); est une fonction à partir d'une API donc je ne peux pas modifier les arguments qu'il faut.

Comment somefunction connaître la taille du tableau est?
somefunction(); est glTexCoordPointer(); à partir de OpenGL
si vous utilisez glTexCoordPointer() juste passer my_array + n.
Juste édité ma réponse après avoir vu vous maintenant mentionner glTexCoordPointer(). Si vous avez tout autre code pour dessiner quelque chose après le réglage de la texture que vous devez l'ajouter à votre question.

OriginalL'auteur PgrAm | 2011-12-02

arrays c++

L'exemple python est d'en faire des copies. Si c'est bon pour votre cas d'utilisation, vous pourriez faire quelque chose comme ça (je suis d'échanger votre vanille tableaux pour le std::vector):

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

sorties:

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

Mais il semble que vous ne pouvez pas utiliser std::vector, parce que somefunction() a une signature que vous ne pouvez pas changer. Heureusement, vous pouvez faire la même gymnastique juste manuellement copier des parties de la matrice, comme ci-dessous:

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

qui encore une fois sorties:

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

OriginalL'auteur Al P.

12

Si vous écrivez les fonctions de fonctionner sur une paire de itérateurs plutôt qu'un tableau, vous pouvez simplement passer comme ça:
```
somefunction1(my_array, my_array + 24);
somefunciton2(my_array + 24, my_array + 39);
somefunction3(my_array + 39, my_array + 65);
```
Les pointeurs sont avant itérateurs, et cela permettrait d'utiliser les fonctions de contrôle des parties de vecteurs, les files d'attente, ou d'autres conteneurs STL.

Si le 2ème arg représente le classique end() itérateur, n'est-ce pas par un?
ces types de fonctions d'interpréter le deuxième argument comme "un passé le dernier élément". C'est ainsi que la STL traite avec les itérateurs.
Ouais c'est ce qu'il veut dire - décalages de 24, 39, 65, par opposition à 23, 38, 64.
Je ne peux pas le faire de cette façon parce que je ne peux pas modifier somefunction();
100% correct. Modifié pour correspondre à la convention.

OriginalL'auteur Harper Shelby
6

Votre fonction est besoin d'un moyen pour déterminer la taille de la matrice de toute façon. Je vous suggère de faire la prise de fonction de début et de fin des itérateurs, dans le style de la bibliothèque standard algorithmes, comme suit:
```
template<typename I>
void somefunction(I begin, I end);
```
Ensuite, vous pouvez l'appeler avec votre tableau comme ceci:
```
somefunction(my_array, my_array + 24);
somefunction(my_array + 24, my_array + 39);
somefunction(my_array + 39, my_array + 65);
```
Je ne peux pas le faire de cette façon parce que je ne peux pas modifier somefunction();
Puis répondre à GMan de commentaire ci-dessous votre question, parce que quand vous passer un tableau à une fonction, il se désintègre à un pointeur, et la taille est perdu.
somefunction(); est glTexCoordPointer(); à partir de OpenGL

OriginalL'auteur Benjamin Lindley
4

Il y a deux moyens de le faire:
```
void useArray(int array[], size_t len) { ... }
...
useArray(myArray, 24);
useArray(&myArray[24], 15);
useArray(&myArray[39], 26);
```
OU
```
void useArray(int *start, int *end) { ... }
...
useArray(myArray, myArray + 24);
useArray(myArray + 24, myArray + 39);
useArray(myArray + 39, myArray + 65);
```
La première est plus comme en C, la deuxième plus C++. Notez que la deuxième façon, la gamme est [start, end) - end n'est pas compris dans la plage que vous voyez beaucoup en C++.

EDIT: que Vous avez édité votre post pour parler de ce que vous êtes en utilisant glTexCoordPointer(). Dans ce cas, passer le début de la matrice de glTexCoordPointer(), qui sera myArray, myArray + 24 ou myArray + 39.

La taille de la matrice a encore à être connue, bien que, et est passé à des fonctions telles que glDrawArrays ou glDrawElements(), qui va alors commencer la lecture à partir du tableau. Si vous avez été en utilisant glDrawArrays(), la longueur du tableau est passé en second argument. Donc votre code pourrait être quelque chose comme:
```
glTexCoordPointer(..., ..., ..., my_array);
...
glDrawArrays(..., 0, 24);

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

glTexCoordPointer(..., ..., ..., my_array + 39);
...
glDrawArrays(..., 0, 26);
```
+1 pour mettre en évidence qu'il n'y est plus " C++". Personnellement, je tiens à faire le premier cas compatible avec le matériel suivant: use( myarray + 0, myarray + 23 )
Je ne peux pas le faire de cette façon parce que je ne peux pas modifier somefunction();
my_array + 24); s'affiche à ne rien faire, mais la rotation de la texture
Je ne suis pas trop sûr de OpenGL trucs, mais en passant my_array + 24 le faire paraître comme si c'est le début de la matrice.

OriginalL'auteur AusCBloke
0

Il n'y a pas de limite supérieure plage de vérification, de sorte que vous avez à prendre soin de vous-même. Mais vous pouvez passer &my_array[0] à une fonction, et &my_array[24] à l'autre. Peut-être ajouter un paramètre len à votre fonction de prendre soin de la gamme supérieure.

OriginalL'auteur TJD

Vous pourriez refactoriser vos fonctions à utiliser "itérateurs": un pointeur sur le début et la fin de la matrice de-gamme qui vous intéresse:

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

Points de Bonus: si vous effectuez votre fonction d'un modèle, vous pouvez l'utiliser avec d'autres itérateurs:

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

...

Je ne peux pas le faire de cette façon parce que je ne peux pas modifier somefunction();

OriginalL'auteur xtofl

Vous devez vous connecter pour publier un commentaire.