Kann ich bestimmen die Größe/Länge eines Arrays in C++ die zimmerreserviereung, ohne das hartcodieren?

Ich bin im Grunde auf der Suche nach einer Art "dynamischen" Weg der Größe/Länge eines Arrays an eine Funktion.

Habe ich versucht:

void printArray(int arrayName[])
{
    for(int i = 0 ; i < sizeof(arrayName); ++i)
    {
        cout << arrayName[i] << ' ';
    }
}

Aber ich erkannte, dass es nur der Auffassung Ihrer Bytegröße und nicht, wie viele Elemente im array.

Und auch:

void printArray(int *arrayName)
{
    while (*arrayName)
    {
        cout << *arrayName << ' ';
        *arrayName++;    
    }
}

Dieser hat zumindest mir alles, was gedruckt, aber mehr als das, was ich erwartet hatte, so dass es nicht wirklich funktionieren, wie ich es mir vorstelle.
Ich denke, es ist weil ich nicht genau sagen, wie groß ich brauche es so ist, spielt es "sicher" und wirft mir einige große Größe und schließlich beginnt mit dem drucken mich sehr ungeraden zahlen nach meinem letzten element im array.

So, ich habe endlich dieses umgehen, doch glaube ich, dass es etwas besseres gibt!:

void printArray(int *arrayName)
{
    while (*arrayName)
    {
        if (*arrayName == -858993460)
        {
            break;
        }
        cout << *arrayName << ' ';
        *arrayName++;
    }
    cout << '\n';
}

Nach läuft das Programm ein paar mal erkannte ich den Wert nach dem letzten element des Arrays, dass ich input ist immer: -858993460, also machte ich es brechen die while-Schleife ab, sobald dieser Wert festgestellt wird.

include <iostream>
include <conio.h>

using namespace std;

    //functions prototypes
void printArray (int arrayName[], int lengthArray);

    //global variables

    //main
int main ()
{
    int firstArray[] = {5, 10, 15};
    int secondArray[] = {2, 4, 6, 8, 10};
    printArray (firstArray,3);
    printArray (secondArray,5);

    //end of program
    _getch();
    return 0;
}

    //functions definitions
void printArray(int arrayName[], int lengthArray) 
{
    for (int i=0; i<lengthArray; i++)
    {
        cout << arrayName[i] << " ";
    }
    cout << "\n";
}

Danke Ihnen sehr.

  • Dein grundlegendes Missverständnis ist, dass die Funktion erhält ein array, wenn in Wirklichkeit, es erhält einen Zeiger. Arrays übergeben werden können, um Funktionen (oder zurück von Ihnen). Bauen Sie auf Zeiger.
  • Ich denke ich bekomme es. Also, wenn ich ein array erstellen, das ist eine Ansiedlung irgendwo in den Speicher. Wenn ich will, zu "benutzen", das array, um es zu übergeben, um eine Funktion, ich bin tatsächlich an der Funktion eine Adresse, wo dieses array kann man in der Erinnerung, die von sich selbst weit überlegene Speicher-Weise, als wäre es die übergabe eines tatsächlichen array?
InformationsquelleAutor Hugo Santos | 2013-05-19
  1. 4

    1st try

    Wenn arrays an Funktionen übergeben werden, Sie zerfallen zu Zeigern. Normalerweise, mit sizeof auf ein array geben würde Sie Ihre Größe in bytes, die könnte man dann geteilt durch die Größe in bytes der einzelnen Elemente und erhalten die Anzahl der Elemente. Aber jetzt, da du einen pointer statt einem array aufrufen sizeof nur gibt Sie die Größe des Mauszeigers (in der Regel 4 oder 8 bytes), nicht das array selbst und das ist, warum dies nicht gelingt.

    2. Versuch

    Die while-Schleife in diesem Beispiel wird davon ausgegangen, dass das array endet mit einer null, und das ist sehr schlecht (es sei denn, man hat wirklich verwenden Sie eine null als terminator wie null-terminierte strings zum Beispiel). Wenn dein array nicht mit null enden, könnten Sie den Zugriff auf Speicher, die nicht verkaufen und daher aufrufen zu undefiniertem Verhalten. Eine andere Sache, die passieren könnte, ist, dass dein array hat eine null-element in der Mitte würde dann nur drucken, die ersten paar Elemente.

    3. versuchen Sie,

    Dieser Besondere Wert, den Sie gefunden lauern am Ende der Arrays jederzeit ändern können. Dieser Wert war nur zufällig dort an diesem Punkt, und es könnte anders sein, ein anderes mal so hardcoding es ist sehr gefährlich, denn Sie könnte end up Zugriff auf Speicher, die nicht verkaufen.

    Ihre endgültige code -

    Dieser code ist korrekt, und übergeben Sie die Länge des Arrays zusammen mit dem array selbst ist etwas, was Häufig getan (vor allem in den APIs in C geschrieben). Dieser code sollte keine Probleme verursachen, solange Sie sich nicht über eine Länge, die größer als die tatsächliche Länge des Arrays, und dies kann manchmal passieren so ist es auch fehleranfällig.

    Eine andere Lösung

    Andere Lösung wäre die Verwendung std::vector einem Behälter, die zusammen mit verfolgen, von Ihrer Größe, können Sie auch hinzufügen, wie viele Elemente, wie Sie wollen, d.h. die Größe muss nicht bekannt sein, zur Laufzeit. So konnte man etwas wie das hier tun:

    #include <iostream>
#include <vector>
#include <cstddef>

void print_vec(const std::vector<int>& v)
{
    std::size_t len = v.size();

    for (std::size_t i = 0; i < len; ++i)
    {
        std::cout << v[i] << std::endl;
    }
}

int main()
{
    std::vector<int> elements;

    elements.push_back(5);
    elements.push_back(4);
    elements.push_back(3);
    elements.push_back(2);
    elements.push_back(1);

    print_vec(elements);

    return 0;
}

    Nützliche links lohnt sich

    Undefiniertes Verhalten: Undefinierten, unbestimmten und Implementierung-definiert das Verhalten

    Array decay: Was ist array verfallenden?

    std::vector: http://en.cppreference.com/w/cpp/container/vector

    • Danke Tonnen! Ich könnte verstehen, Ihre Erklärungen, warum ich es Tat falsch. Dann wieder, ich habe kaum Kenntnis von C++.
    • Ich bin froh, dass du verstanden was ich geschrieben habe. Ich werde Bearbeiten Sie die Frage in ein bisschen ein paar nützliche links. Wenn Sie fühlen, wie diese Antwort befriedigt Ihre Bedürfnisse, nehmen Sie es als eine Antwort, denn das ist, wie es funktioniert auf ALSO. 🙂
    • Das Antwort-system ist so unfair. Jeder hat mir geholfen, zu verstehen, die Frage hatte ich noch kann ich nur mit "Stimme" für eine person?
    • Sie müssen nicht sorgen zu machen über die fairness: nehmen Sie einfach die Antwort, die Sie am meisten hilfreich. Besucher können bis Sie Ihre Stimme (oder Stimmen) als gut.
    InformationsquelleAutor Tuntuni
  2. 11

    TL;DR-Antwort: verwenden Sie std::vector.

    Aber ich erkannte, dass es [sizeof()] nur die Auffassung Ihrer Bytegröße und nicht, wie viele Elemente im array.

    Wäre das nicht ein problem in sich: Sie könnten sich trotzdem die Größe des Arrays mit sizeof(array) /sizeof(array[0]), aber das problem ist, dass, wenn an eine Funktion übergeben, arrays Zerfall in einen Zeiger auf Ihr erstes element, so dass alle Sie bekommen können sizeof(T *) (T ist dabei der Typ eines Elements im array).

    Über *arrayName++:

    Dieser hat zumindest mir alles, was gedruckt, aber mehr als das, was ich erwartet

    Ich gar nicht verstehen, was hat Sie dazu inspiriert, berechnen Sie die Größe des array in dieser Art und Weise. Alles, was dieser code tut, ist die Inkrementierung der das erste Objekt in das array, bis es null.

    Nach läuft das Programm ein paar mal erkannte ich den Wert nach dem letzten element des Arrays, dass ich input ist immer: -858993460

    Das ist eine schreckliche Annahme, und es stützt sich auch auf nicht definiertes Verhalten. Sie können nicht wirklich sicher sein, was in der Erinnerung nach das erste element des array, sollten Sie nicht selbst Zugriff darauf haben.

    Grundsätzlich in C++, wenn Sie wollen, um zu wissen, die Größe einer raw-array innerhalb einer Funktion, dann musst du den überblick behalten manuell (e. g. hinzufügen eines zusätzlichen size_t size argument), weil der Weg arrays werden an Funktionen übergeben (Sie erinnern sich, "Zerfall in ein" Zeiger). Wenn Sie etwas flexibler sind, sollten Sie die Verwendung std::vector<int> (oder was auch immer Art von Objekten, die Sie speichern möchten) aus der C++ standard Bibliothek-es hat eine size() Methode, die genau das tut, was Sie wollen.

    • sizeof ist nicht eine Funktion.
    • Wann/wo habe ich behaupten es war ein?
    • Oh! Das heißt, ich würde multiplizieren Sie die Bytegröße einer int von, wie viele int-Werte, die ich auf dem array?
    • Wenn Sie sagte but the problem is that when passed to a function, arrays decay into a pointer to their first element, so all you can get is sizeof(T *), was T[] zerfällt, wenn an die sizeof "Funktion".
    • Ich sehe nicht, dass eine Implikation. Ich sehe eine explizite Aussage, dass die Matrix zerfällt zu einem Zeiger , wenn an eine Funktion übergeben wird, wie es in dem Beispiel von der OP
    • Recht. Meine schlechte..
    • das hat er nicht. Er deutete an, dass das array übergeben wurde, als ein Zeiger auf die Funktion, und im inneren, dass die Funktion sizeof Werke auf diesen Zeiger.
    • Ja, aber auch nicht, dass die (im Grunde sizeof() funktioniert einwandfrei auf array nur, bevor Sie an die Funktion übergeben. In der Funktion, die Sie nicht haben eine Reihe mehr).

    InformationsquelleAutor
  3. 3

    Als all die anderen Antworten sagen, sollten Sie std::vector oder, als Sie bereits haben, übergeben Sie die Anzahl der Elemente des Arrays, um die drucken-Funktion.

    Einen anderen Weg, dies zu tun ist, indem Sie ein sentinel-element (ein Wert, den Sie sind sicher, es wird nicht im array) an das Ende des Arrays. In der Druck-Funktion Sie können mit dem Rad dann durch die Elemente, und wenn Sie den sentinel-Sie stoppen.

    • Mit einer sentinel-element ist das der richtige Ansatz? Oder sollte ich den Fokus auf das lernen, std::vector?
    • Ich denke, Sie sollten lernen, std::vector, aber manchmal sentinel-Elemente können sehr hilfreich sein (für die verknüpften Listen, zum Beispiel)
    • Es gibt keinen "richtigen" Ansatz, mehr als es eine "richtige" tool für jeden job. Manchmal braucht man einen hammer, manchmal braucht man einen Schraubendreher. Wenn Sie in C++ Programmieren mit std::vector ist wahrscheinlich der bessere Ansatz ist, und die, die Sie berücksichtigen sollten, bevor irgendetwas anderes beim Umgang mit dynamisch dimensionierte arrays.
    InformationsquelleAutor Luke Morgan
  4. 3

    Eine mögliche Lösung: Sie können eine Vorlage verwenden, um Rückschlüsse auf die array-Länge:

    template <typename T, int N>
int array_length(T (&array)[N]) {
    return N;
}

    Beachten Sie, dass Sie haben, dies zu tun vor das array zerfällt zu einem Zeiger, aber Sie können die Technik direkt oder in einem wrapper.

    Zum Beispiel, wenn Sie nichts dagegen haben, Ihre eigenen Rollen-array-wrapper:

    template <typename T>
struct array {
    T *a_;
    int n_;

    template <int N> array(T (&a)[N]) : a_(a), n_(N) {}
};

    Können Sie dies tun:

    void printArray(array<int> a)
{
    for (int i = 0 ; i < a.n_; ++i)
        cout << a.a_[i] << ' ';
}

    - und nennen es wie

    int firstArray[] = {5, 10, 15};
int secondArray[] = {2, 4, 6, 8, 10};
printArray (firstArray);
printArray (secondArray);

    Der Schlüssel ist, dass die Vorlagen-Konstruktor ist nicht explicit also dein array umgewandelt werden können, um eine Instanz, die Erfassung der Größe, vor verfallenden einem Zeiger.

    NB. Der wrapper gezeigt, ist nicht geeignet für den Besitz und dynamisch-sized arrays, nur für den Umgang mit statisch dimensionierten arrays bequem. Es fehlen auch verschiedene Operatoren und ein Standard-Konstruktor, der Kürze halber. Im Allgemeinen bevorzugen std::vector oder std::array statt für den Allgemeinen Gebrauch.

    ... OP ' s eigene versuche sind komplett an eine andere Stelle adressiert ...

    • Die Lösung mit templates ist ordentlich, muss ich zugeben.
    InformationsquelleAutor Useless
  5. 2

    Mithilfe der -858993460 Wert ist höchst unzuverlässig und, in der Tat falsch.

    Können Sie ein Länge des Arrays in zwei Möglichkeiten: übergeben wird ein zusätzlicher parameter (sagen size_t length) an Ihre Funktion, oder legen einen besonderen Wert an das Ende von array. Der erste Weg ist vorzuziehen, aber die zweite wird verwendet, zum Beispiel für die übergabe von strings durch char*.

    • Danke! Ich denke, ich werde mit einem zweiten parameter.
    • nur zur Ergänzung: die -858993460 Wert (hex 0xCCCCCCCC) ist ein fast sicher, spezieller Wert, der debug - version Ihrer compiler verwendet, um zu füllen nicht-initialisierten Variablen in einer Bemühung zu helfen, erkennt den Zugriff auf Variablen, bevor Sie zugeordnet sind, einen Wert oder Erkennung von Pufferüberläufen.
    InformationsquelleAutor nullptr
  6. 0

    In C/C++ ist es nicht möglich, zu wissen, die Größe eines Arrays zur Laufzeit. Sie könnte erwägen, einen std::vector Klasse, wenn Sie das brauchen, und es hat auch andere Vorteile.

    • -1 Das ist völlig falsch. sizeof(some_array) / sizeof(some_array[0]) gibt die Größe eines Arrays. Die OP ' s problem ist, dass er denkt, er hat ein array, wenn er tatsächlich ein Zeiger.
    • Technisch, das ist eine compile-Zeit-Berechnung, zumindest in C++. (In C, der Berechnung passieren könnte, zur Laufzeit, sondern, dass die Funktion von C (VLA) ist nicht Teil von C++.)
    • Ja, sizeof ist eine compile-Zeit-Berechnung, und die arrays nicht abgeschätzt werden kann, zur Laufzeit. Also ich glaube, ich sollte gesagt haben, irreführend statt. Die Antwort ist nicht hilfreich aber. Die OP braucht, um zu verstehen, wenn ein array ist ein array und wenn es ein Zeiger in der Verkleidung (wie im Beispiel)
    • Ein array ist immer ein Zeiger. Die Verwendung von Klammern ist nur ein syntatical Bequemlichkeit.
    • Nein, Nein, Sie sind nicht. Wirklich, ein array ist nie einen Zeiger. aber es kann degradieren zu einem in bestimmten Situationen. Sie sind völlig verschiedene Dinge. Sollten Sie gehen, studieren, ein wenig auf das Thema, diese Art von Kommentar hilft nur, um eine weitere Irreführung von Anfängern, die denken, dass Zeiger und arrays sind ein und dasselbe.
    • Hier: lysator.liu.se/c/c-faq/c-2.html
    • Danke für deine Antwort, wie ich schon sagte, ich bin ein total Anfänger, ich kaum verstehen, einige Dinge, die du sagst, aber ich werde auf jeden Fall versuchen zu lernen, zu benutzen, std::vector-Klasse dann.
    • Danke für den link.
    • Ein Zeiger ist dann nur die Adressierung der Funktion auf das array ohne tatsächlich an das array? Sorry für die Befragung so viel.
    • Ja. Deshalb sagte ich oben, dass ein array ist immer ein pointer, der nicht 100% richtig als solche. Wenn Sie geben Sie es herum, es ist in der Regel obwohl.
    • Es ist 0% richtig und 100% irreführend.

    InformationsquelleAutor Devolus
  7. 0

    Wenn Sie übergeben Sie die Länge des Arrays zu printArray verwenden, können Sie sizeof(array) /sizeof(array[0]), das heißt die Größe in bytes) des gesamten Arrays dividiert durch die Größe in Byte für ein einzelnes element gibt man die Größe in Elemente des array selbst.

    Mehr auf den Punkt, in C++ können Sie finden es zu Ihrem Vorteil, zu lernen, über std::vector und std::array und bevorzugen diese über raw-arrays—es sei denn natürlich du machst eine Hausaufgabe, die erfordert, dass Sie lernen, über die raw-arrays. Die size() member-Funktion geben Sie die Anzahl der Elemente in einem Vektor.

    • Danke, aber Frage, bei der Berechnung: int arraySize = sizeof(arrayName) / sizeof(arrayName[0]); in main() bekomme ich die richtige Größe der Elemente im array, wenn ich es in die Funktion, die es sagt mir etwas anderes.
    • Ja, in der Funktion ein pointer, kein array. Sie produzieren verschiedene sizeof Werte. Ohne allzu sehr ins detail, wird ein Zeiger in der Regel 4 Byte auf einem 32-bit system und 8 Byte auf einem 64-bit-system. Sie würde sehen, das Ergebnis, dass der Wert geteilt durch sizeof(int).
    • Richtig! Es bekam. Erstaunlich, schade, ich habe kein rep überhaupt in der Lage sein, um upvote Sie! Danke.
    InformationsquelleAutor Jon Purdy
  8. 0

    In C/C++, native arrays abbauen Zeiger, sobald Sie an Funktionen übergeben werden. Als solche, die "length" - parameter übergeben werden, als parameter für die Funktion.

    C++ bietet die std::vector collection-Klasse. Stellen Sie sicher, dass, wenn Sie übergeben es an eine Funktion übergeben Sie es als Referenz oder als Zeiger (um zu vermeiden, dass eine Kopie des Arrays, wie es übergeben wird).

    #include <vector>
#include <string>

void printArray(std::vector<std::string> &arrayName)
{
    size_t length = arrayName.size();
    for(size_t i = 0 ; i < length; ++i)
    {
        cout << arrayName[i] << ' ';
    }
}

int main()
{
    std::vector<std::string> arrayOfNames;
    arrayOfNames.push_back(std::string("Stack"));
    arrayOfNames.push_back(std::string("Overflow"));
    printArray(arrayOfNames);

    ...
}
    InformationsquelleAutor selbie
Schreibe einen Kommentar