mit nur Teil eines Arrays

Ich habe einen dynamisch reservierten Arrays von float-und ich muss mich übergeben dieses array als argument zu drei verschiedene Funktionen, die aber jede Funktion benötigen, um einen anderen Bereich des Arrays. Gibt es eine Möglichkeit, die ich senden kann das array mit Elementen von 0 bis 23 an einer Funktion, die Elemente 24 bis 38 zum anderen, und Elemente 39 und 64, um eine Dritte Funktion.

In einigen Sprachen(wie python, denke ich), können Sie etwas wie das hier tun:

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

Jedoch bin ich mit c++ und ich kenne keine Möglichkeit, dies zu tun in c++.

Weiß jemand, wie dies zu tun?

somefunction(); ist eine Funktion von einer API, also kann ich nicht ändern, die Argumente, die es braucht.

Wie funktioniert somefunction wissen, wie groß das array ist?
somefunction(); ist glTexCoordPointer(); von OpenGL
wenn Sie mit glTexCoordPointer() nur pass my_array + n.
Nur bearbeitet meine Antwort nachdem ich es jetzt erwähnen glTexCoordPointer(). Wenn Sie alle anderen code für die Zeichnung etwas nach der Einstellung der textur, die Sie sollte hinzufügen, Sie zu Ihrer Frage.

InformationsquelleAutor PgrAm | 2011-12-02

arrays c++

Den python-Beispiel ist die Herstellung von Kopien. Wenn das in Ordnung für Ihren Fall, Sie könnte so etwas tun (ich tausche aus Ihrem Vanille-arrays für 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));
}

welche Ausgänge:

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

Aber es klingt wie Sie nicht verwenden können, std::vector, da somefunction() hat eine Signatur, die Sie nicht ändern können. Zum Glück, Sie tun können, ähnlich wie gymnastik nur manuell kopieren Teile der Reihe, wie unten:

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

die wieder-Ausgänge:

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

InformationsquelleAutor Al P.

12

Wenn Sie schreiben, die Funktionen zum Betrieb auf einem paar von forward-Iteratoren statt ein array, Sie könnten nur pass es so:
```
somefunction1(my_array, my_array + 24);
somefunciton2(my_array + 24, my_array + 39);
somefunction3(my_array + 39, my_array + 65);
```
Zeiger forward-Iteratoren, und dies würde es ermöglichen, die Funktionen verwendet werden, die über Teile von Vektoren, queues, oder anderen STL-Containern als gut.
- Wenn das 2. arg stellt die konventionelle end() iterator, bist du nicht ausschalten, indem man?
- diese Art von Funktionen interpretieren, das zweite argument als "eine Vergangenheit, die das Letzte element'. Das ist, wie die STL befasst sich mit Iteratoren.
- Yeah das ist, was er bedeutet - offsets von 24, 39, 65, im Gegensatz zu 23, 38, 64.
- Ich kann das so nicht, denn ich kann nicht ändern somefunction();
- 100% richtig. Bearbeitet übereinstimmen, übereinkommen.
InformationsquelleAutor Harper Shelby
6

Ihre Funktion gehen zu müssen einige Weg, um zu bestimmen, die Größe des Arrays sowieso. Ich schlage vor, Sie machen die Funktion take begin-und end-Iteratoren, im Stil der standard-Bibliothek algorithmen, etwa so:
```
template<typename I>
void somefunction(I begin, I end);
```
Dann rufen Sie es mit Ihrem array wie dieses:
```
somefunction(my_array, my_array + 24);
somefunction(my_array + 24, my_array + 39);
somefunction(my_array + 39, my_array + 65);
```
- Ich kann das so nicht, denn ich kann nicht ändern somefunction();
- Dann beantworten Sie GMan ' s Kommentar unten Ihre Frage, weil, wenn Sie übergeben Sie ein array an eine Funktion, es zerfällt zu einem Zeiger und der Größe verloren.
- somefunction(); ist glTexCoordPointer(); von OpenGL
InformationsquelleAutor Benjamin Lindley
4

Gibt es zwei Möglichkeiten, wie Sie es tun könnte:
```
void useArray(int array[], size_t len) { ... }
...
useArray(myArray, 24);
useArray(&myArray[24], 15);
useArray(&myArray[39], 26);
```
ODER
```
void useArray(int *start, int *end) { ... }
...
useArray(myArray, myArray + 24);
useArray(myArray + 24, myArray + 39);
useArray(myArray + 39, myArray + 65);
```
Das erste ist eher ein C-Weg, die zweite eine mehr C++ Weg. Beachten Sie, dass mit dem zweiten Weg, der Bereich ist [start, end) - end ist nicht im Lieferumfang enthalten, wie Sie sehen, eine Menge in C++.

EDIT: Sie Ihren Beitrag bearbeitet zu erwähnen, dass Sie verwenden glTexCoordPointer(). In diesem Fall übergeben Sie den Anfang des Arrays zu glTexCoordPointer(), die entweder myArray, myArray + 24 oder myArray + 39.

Die Größe des Arrays noch bekannt, obwohl, und ist an Funktionen wie glDrawArrays oder glDrawElements(), die dann beginnen, Lesen aus dem array. Wenn Sie wurden mit glDrawArrays(), die Länge des Arrays übergeben, als zweites argument. Daher könnte der code so etwas wie:
```
glTexCoordPointer(..., ..., ..., my_array);
...
glDrawArrays(..., 0, 24);

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

glTexCoordPointer(..., ..., ..., my_array + 39);
...
glDrawArrays(..., 0, 26);
```
- +1 für die Betonung, dass es ein 'mehr C++ - Weg". Persönlich mag ich den ersten Fall im Einklang mit den folgenden: use( myarray + 0, myarray + 23 )
- Ich kann das so nicht, denn ich kann nicht ändern somefunction();
- my_array + 24); scheint nichts zu tun, sondern drehen der textur
- Ich bin mir nicht sicher über die OpenGL-Sachen, aber vorbei my_array + 24 wird es scheinen, als ob der Anfang des Arrays.
InformationsquelleAutor AusCBloke
0

Gibt es keine Obere Grenze Bereich überprüfen, so müssen Sie aufpassen, dass Sie sich. Aber Sie können pass &my_array[0] zu einer Funktion, und &my_array[24] zu einem anderen. Vielleicht fügen Sie ein len-parameter an Ihre Funktion zu kümmern oberen Bereich.

InformationsquelleAutor TJD

Könnte man umgestalten Funktionen für die Verwendung von 'Iterationen': ein Zeiger auf den begin und das Ende des array-Bereichs, der Sie interessiert:

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

Bonus Punkte: wenn Sie Ihre Funktion eine Vorlage, die Sie verwenden können, es mit anderen Iteratoren zu:

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