Was ist der beste Weg, um ein Sub-Array aus einem bestehenden Array in C++ zu erstellen?

Question

OK, ich versuche, ein Sub-Array von einem bestehenden Array zu bekommen und ich bin mir einfach nicht sicher, wie es geht. In meinem Beispiel habe ich ein sehr großes Array, aber ich möchte ein Array aus den letzten 5 Elementen des Arrays erstellen.

Ein Beispiel von dem, was ich rede wäre:

int array1 = {1,2,3,...99,100}; 
int array2[5] = array1+95; 

Ich weiß, dass dies nicht richtig ist, aber ich bin einige Probleme, es richtig hinzubekommen. Ich möchte die Elemente 96 bis 100 in Array1 holen und sie in Array2 einfügen, aber ich möchte die Arrays nicht kopieren. Ich möchte nur, dass Array2 beim Element 96 beginnt, so dass Array1 [96] und Array2 [0] auf dieselbe Position zeigen.

Answer 1

hierfür:

"such that array1[96] and array2[0] would be pointing to the same location." 

Sie tun können:

int *arr2 = arr1 + 96; 
assert(arr2[0] == arr1[96] == 97); 

Answer 2

Sie sagten, Sie wollen nicht, um das Array zu kopieren, sondern einen Zeiger auf den letzten fünf Elemente erhalten. Sie haben es fast:

int array1[] = {1,2,3,...99,100}; 
int* array2 = &array1[95]; 

Answer 3

in C++ Sie einen int-Zeiger als int Array verwenden können, so die array2 immer auf Artikel 96 in array1 zu starten ist einfach, aber es gibt keine Möglichkeit, ein geben array2 Größenbeschränkung, so können Sie dies tun

int array2 [] = & array1 [96];

oder diese

int *array2 = &array1[96]; 

aber nicht diese

int array2[5] = &array1[96]; // this doesn't work. 

Auf der anderen Seite, C++ nicht Array-Größenbeschränkungen ohnehin erzwingen, so dass der einzige wirkliche Verlust ist, dass man‘ t Verwenden Sie sizeof, um die Anzahl der Elemente in array2 zu ermitteln.

Anmerkung: &array1[96] ist das gleiche wie array+96

edit: Korrektur - int array[] = &array[96] nicht gültig ist, können Sie nur [] als Synonym für * verwenden können, wenn eine Funktion Parameterliste deklarieren.

so ist dies

erlaubt

extern int foo(int array2[]); 
foo (&array1[96]); 

Answer 4

int array1[] = {1,2,3,...99,100}; 
int *array2 = &array1[96]; 

Answer 5

int arr[] = { 1, 2, 3, 4, 5}; 
int arr1[2]; 
copy(arr + 3, arr + 5, arr1); 
for(int i = 0; i < 2; i++) 
    cout << arr1[i] << endl; 

Der Code ist nicht sicher, wenn die Grenzen nicht richtig gehandhabt werden.

Answer 6

Ein Referenz Hack aus einem C-Programmierer bereit, das Typ-System zu untergraben, was zu bekommen funktioniert:

int (&array2)[5] = (int (&)[5])(*(array1 + 5)); 

Jetzt ein Array für alle Absichten und Zwecke array2 wird, und wird ein Sub-Array von array1 sein und wird sogar zu dieser berühmten C++ array_size Template-Funktion passierbar sein. Obwohl der beste Weg, mit diesem Hacker umzugehen, ist es, ihn mit mehr Hackerei zu verstecken!

#define make_sub_array(type, arr, off, len) (type (&)[len])(*(arr + off)); 

int (&array2)[5] = make_sub_array(int, array1, 5, 5); 

Schön. Schrecklich nach einigen Standards, aber das Endergebnis a) sieht ziemlich ordentlich aus, b) macht genau das, was Sie wollen, c) ist funktionell identisch mit einem tatsächlichen Array und d) hat auch den zusätzlichen Bonus (oder Fehlmerkmal) des Seins ein identischer Bezug zum Original, so ändern sich die beiden zusammen.

UPDATE: Wenn Sie möchten, eine Templat-Version (Art):

template <typename T, size_t M> 
T (&_make_sub_array(T (&orig)[M], size_t o))[] 
{ 
    return (T (&)[])(*(orig + o)); 
} 
#define make_sub_array(type, array, n, o) (type (&)[n])_make_sub_array(array, o) 

int (&array2)[5] = make_sub_array(int, array1, 5, 5); 

Wir haben noch den Typ zu übergeben. Da eines unserer Argumente als Teil der Besetzung verwendet werden muss, können wir das Makro nicht sauber (IMHO) vermeiden. Wir könnten dies tun:

template <typename T, size_t M, size_t N> 
T (&make_sub_array(T (&orig)[M], size_t o))[N] 
{ 
    return (T (&)[N])(*(orig + o)); 
} 

int (&array2)[5] = make_sub_array<int, 15, 5>(array1, 5); 

Aber das Ziel ist hier die Telefonvorwahl so sauber wie möglich zu machen, und dieser Anruf ist ein bisschen haarig. Die Pure-Macro-Version hat wahrscheinlich den geringsten Overhead und ist wahrscheinlich in diesem Fall am saubersten zu implementieren.

Answer 7

Für einen völlig anderen Ansatz könnten Sie etwas wie tun.

vector<int> v0(array1 + 95, array1 + 100); 

oder

vector<int> v1(array1, array1 + 100); 
vector<int> v2(v1.begin() + 95, v1.end()); 

Dies würde eine echte Kopie der Elemente des Vektors machen.

Answer 8

Sie können boost::iterator_range verwenden, um „Scheiben“ von Arrays/Container darstellen:

#include <iostream> 
#include <boost/range.hpp> 

int main() 
{ 
    int array[] = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9}; 

    // Create a "proxy" of array[5..7] 
    // The range implements the concept of a random sequence containter 
    boost::iterator_range<int*> subarray(&array[5], &array[7]+1); 

    // Output: 3 elements: 5 6 7 
    std::cout << subarray.size() << " elements: " 
       << subarray[0] << " " 
       << subarray[1] << " " 
       << subarray[2] << "\n"; 
} 

Beachten Sie, dass der Iterator Bereich „weiß“ über die Größe der Untergruppe. Es wird sogar Grenzen für Sie prüfen. Sie können diese Funktionalität nicht von einem einfachen Zeiger erhalten.

Die Nützlichkeit von Boost.Range wird deutlicher, sobald Sie etwas über STL-Container und Iteratoren erfahren.

Wenn Sie in der linearen Algebra, unterstützt Boost.uBlas Bereiche und Scheiben für seine Matrizen und Vektoren.