Was ist der beste Weg, um erstellen Sie eine sub-array aus vorhandenen Arrays in C++?

OK, ich werde versuchen, ein sub-array aus vorhandenen Arrays und ich bin nur nicht sicher, wie es zu tun. In meinem Beispiel habe ich ein sehr großes array, aber ich möchte ein array erstellen, die aus den letzten 5 Elemente des Arrays.

Ein Beispiel von was ich spreche, wäre:

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

Ich weiß, das ist nicht richtig, aber ich habe einige Mühe, es richtig zu machen. Ich möchte die Elemente 96 und 100 in array1 und setzen Sie Sie in array2 aber ich will keine Kopie des arrays. Ich will einfach nur, array2, start an der 96-element, so dass array1[96] und array2[0] zeigt auf den gleichen Standort.

Halten Sie im Verstand, den Sie nicht technisch ein sub-array, indem Sie auf ein element.
Die 96th element array1 ist array1[95]. Wenn Sie sagen, "legen Sie Sie in array2", es heißt kopieren, wie sonst setzte Sie in array2? Es gibt keine Möglichkeit, das zu tun, was Sie wollen. Sie müssen entweder kopieren Sie die Elemente, oder haben einen Zeiger, Punkte auf die 96th element array1 oder ein array von 5 Zeigern, und den Zeiger i zeigen Sie auf das element 95+i von array1.
Sie sind richtig, von "putting Sie array2" ich wollte nicht kopieren. Es tut mir Leid für die Verwechslung in der Terminologie.
Sie sollte sich mit std::vector oder boost::array anstelle von c-style arrays.

InformationsquelleAutor | 2010-01-26

  1. 18

    :

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

    können Sie tun:

    int *arr2 = arr1 + 96;
assert(arr2[0] == arr1[96] == 97);
    Dass assert sollte ein Mathematiker behauptet, nicht in C 🙂
    dieser funktioniert! Danke!!!
    +1 für die einfache Lösung, die funktioniert.

    InformationsquelleAutor jspcal

  2. 8

    Einen Verweis hack von einem C-Programmierer bereit zu untergraben und das Typ-system zu bekommen, was funktioniert:

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

    Nun array2 wird ein array für alle Absichten und Zwecke, wird ein sub-array mit array1, und sogar passabel, die berühmte C++ array_size template-Funktion. Obwohl der beste Weg, dies zu behandeln Hack zu verstecken, mit mehr Hack!

    #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 von einigen standards, aber das Endergebnis ein) sieht Recht ordentlich aus, b) ist genau das, was Sie wollen, c) ist funktional identisch mit einer tatsächlichen array, und d) haben auch den zusätzlichen bonus (oder mis-feature), ein identischer Anlehnung an das original, also die beiden ändern zusammen.

    UPDATE: Wenn Sie möchten, eine Vorlagen-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 noch zu Durchlaufen haben, der Typ. Da einer unserer Argumente müssen verwendet werden, als Teil der Besetzung, können wir nicht sauber (IMHO) vermeiden Sie das makro. 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, um den aufrufenden code so sauber wie möglich, und das rufen ist ein wenig haarig. Die pure-makro-version hat wohl den geringsten Aufwand und ist wahrscheinlich die sauberste zu implementieren, in diesem Fall.

    Es ist so schlimm, es ist gut :-). +1.
    Danke. Es dauerte viel länger, weil ich wollte, um es Arbeit mit den tatsächlichen C++ - casting, aber irgendwann gab ich es auf und machte es Arbeit. Verbesserungen (insbesondere eine mögliche version von make_sub_array als template-Funktion - ich habe versucht, für eine Weile als auch vor dem aufgeben) willkommen.
    Meine C++-fu ist nicht so toll, ich bin eher ein C-Mensch, aber ich werde es versuchen!
    Das ist slick... er hässlich ist... ich meine, ich bin beeindruckt. Das makro hilft der Lesbarkeit, aber die Erklärung von Matrix2 ist immer noch irgendwie komisch. +1 für die fu
    Ich könnte das makro #define make_sub_array(type, orig, new, off, len) type (&new)[len] = (type (&)[len])(*(orig + off)) so, dass es heißt als eine einzige Anweisung: make_sub_array(int, array1, array2, 5, 5); aber ich würde (persönlich) lieber, um zu sehen, die Zuordnung in meinem code, so dass es klar, dass wir die Deklaration und Definition einer Variablen.

    InformationsquelleAutor Chris Lutz

  3. 3

    Für einen völlig anderen Ansatz, Sie könnten etwas tun möchten.

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

    oder

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

    Wäre dies eine echte Kopie der Elemente des Vektors.

    Sollte std::vector für pendantry. Trotzdem, +1 für die "C++" zu beantworten.

    InformationsquelleAutor lhahne

  4. 3

    Können Sie boost::iterator_range zu vertreten "Scheiben" arrays/Container:

    #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 range "weiß" über die Größe des sub-array. Es werden sogar die Grenzen der überprüfung für Sie. Sie kann nicht die Funktionen von einem einfachen Zeiger.

    Die Nützlichkeit zu Steigern.Bereich wird offensichtlicher werden, wenn Sie lernen, über STL-Containern und Iteratoren.

    Wenn Sie in der linearen algebra, Boost.uBlas unterstützt die Bereiche und Scheiben, für Ihre Matrizen und Vektoren.

    InformationsquelleAutor Emile Cormier

  5. 1

    In C++ können Sie einen int-pointer als int-array, so dass immer das array2 beginnend bei Element 96 in Matrix1 ist einfach, aber es gibt keinen Weg zu geben, array2 eine 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++ erzwingt keine array-Größe-Grenzen ohnehin, so dass die einzige wirkliche Verlust ist, dass Sie nicht verwenden können, sizeof, um die Anzahl der Elemente in array2.

    Hinweis: &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 * bei der Deklaration einer Funktion parameter-Liste.

    so ist dies erlaubt

    extern int foo(int array2[]);
foo (&array1[96]);
    Ich bekomme immer noch eine Fehlermeldung, wenn ich versuche zu geben : int array2[] = &array1[96]. Die Fehlermeldung die ich erhalte ist : cannot convert from 'int *' in 'int []'
    array2[] = &array1[96]; schlecht ist.
    Ja, int foo[] und int *foo sind austauschbar, nur als Parameter der Funktion.
    Sie sind nicht wirklich austauschbar. Vielmehr können arrays Zerfall in Zeiger, aber Sie sind nicht die gleichen.
    Sie sind austauschbar, da die Funktion Parameter (nicht Parameter). Das ist unabhängig von der decay-Sache.

    InformationsquelleAutor John Knoeller

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

    InformationsquelleAutor Judge Maygarden

  7. 0
    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;

    Den code nicht sicher ist, wenn die Grenzen nicht richtig verarbeitet.

    InformationsquelleAutor Jagannath

  8. 0

    Sagte Sie, dass Sie nicht wollen, kopieren Sie das array, sondern einen Zeiger auf die letzten fünf Elemente. Sie hatten fast:

    int array1[] = {1,2,3,...99,100};
int* array2  = &array1[95];
    als ich versuchte, bekam ich diese Fehlermeldung: cannot convert from 'int *' in 'int []'
    int array2[] = array1+95; ist illegal.
    Sollte int array1[] = {1,2,3,...99,100}; int* array2 = array1+95; man kann Sie nicht initialisieren ein array (eckige Klammern) mit einem Zeiger, die es erzählen kann, wo es beginnt, aber nicht dessen Größe.

    InformationsquelleAutor BlueRaja - Danny Pflughoeft

Schreibe einen Kommentar