Wie man ein array mit einer dynamischen Größe? Allgemeine Verwendung von dynamischen arrays (Zeiger vielleicht auch)?

Für C++:

Benötigen Sie nur einen Behälter verwenden std:vector. Es kümmern sich alle speicherreservierungen für Sie notwendig. Allerdings, wenn Sie wollen, entwickeln Sie Ihre eigenen dynamischen container (welchen Gründen auch immer Sie haben) Sie kümmern sich um aus der memory-Allokationen selbst. Das ist, wenn das array wächst, die Sie haben, um neuen Speicher chunk, kopieren präsentieren array-Werte an den neuen Speicherort, und fügen Sie neue Werte in den neu zugewiesenen Speicher. In der Regel wickelt man diese Art von Logik in eine separate Klasse, z.B. GrowingArray(wie standard zur Verfügung gestellt vector Klasse)

BEARBEITEN

Mehr erarbeiten auf meine Antwort (da Sie diese für das lernen Zweck):

speichern Sie in einem array ohne Anfangsgröße (also nicht -> array[5];)

Hier wollen Sie etwas wie dies: int * myDynamicArray;
Wenn ein Benutzer Eingaben einige Werte, die Sie reserviert Speicher, chunk, wo diese Werte gespeichert: myDynamicArray = new int[5]; mit der Größe Ihres ursprünglichen Eingang. Ich würde auch empfehlen zu sparen, die Größe des array in einigen Variablen: int arraySize = 5;
Wenn später auf Sie Anhängen möchten neue Werte an Ihre myDynamicArray zunächst müssen Sie, um neuen Speicher Stück für Erwachsene array (aktuelle array-Elemente + neue array-Elemente). Können sagen, Sie haben 10 neue Werte kommen. Dann würden Sie tun: int* grownArray = new int[arraySize+10]; diese reserviert neuen Speicher-Stück für Erwachsene-array. Dann wollen Sie kopieren Elemente aus alten Speicher-Abschnitt an die neue chunk-Speicher und Benutzer hinzufügen angehängt Werte (ich nehme an, Sie sind mit dieser für Lernzwecke so habe ich Ihnen einfach Zyklus für das kopieren Elemente. Könnten Sie std:copy oder c wie memcopy auch):

int i = 0;
for (; i < arraySize; ++i)
   {
   grownArray[i] = myDynamicArray [i];
   }
//enlarge newly allocated array:
arraySize+= 10;
for (; i < arraySize; ++i)
   {
   grownArray[i] = newValues from somewhere
   }
//release old memory
delete[] myDynamicArray;
//reassign myDynamicArray pointer to point to expanded array
myDynamicArray = gronwArray;

Hier ist etwas code, den ich schrieb, dass in C++ die grundlegenden Dinge.

#include <iostream>

int main(int argc, char *argv[])
{
    int* my_dynamic_array;

    int size;
    std::cin >> size;

    my_dynamic_array = new int[size];

    for (int k=0; k<size; k++)
        my_dynamic_array[k] = k;

    for (int k=0; k<size; k++)
        std::cout << my_dynamic_array[k] << std::endl;

    delete[] my_dynamic_array;

    return 0;
}

Okay, also hier ist was passiert in diesem code. Wir sind aufgefordert für die Größe des Arrays mit std::cin und dann mit dem new-Schlüsselwort, um die dynamische Zuordnung von Speicher für das array. Es gibt einige details hier, die machen es scheint ein wenig seltsam auf den ersten, es ist, was scheint, eine Verwechslung mit einer Vielzahl von neuen C++ - Entwickler.

Also zuerst erklärten wir unsere dynamischen Arrays mit einem Zeiger anstelle der array-Deklaration, z.B. haben wir verwendet int *my_dynamic_array statt int my_dynamic_array[]. Zunächst scheint eine Art von trivial, aber es gibt etwas, das Sie brauchen, um zu verstehen, was Los ist in C und C++.

Wenn Sie statisch deklarieren Sie ein array, sagen Sie dem Programm, dass Sie wollen beiseite, dass der Speicher für Sie zu verwenden. Es ist eigentlich da, es ist Ihnen für Sie zu verwenden zu beginnen. Wenn Sie dynamisch ein array erstellen, beginnen Sie mit einem Zeiger. Zeiger sind nur ein Verweis auf etwas Speicher. Dass der Speicher nicht zugeordnet noch. Wenn Sie versuchen, auf etwas, das in es mit, sagen wir, my_dynamic_array[3] erhalten Sie einen fiesen Fehler. Das ist, weil es gibt eigentlich nichts im Speicher an diesem Speicherort (zumindest nichts, das gegeben wurde, um das Programm zu verwenden).

Beachten Sie auch die Verwendung von delete[] statt delete. Das ist die Art und Weise Sie den Speicher, wenn Sie fertig sind mit dem array.

Wenn Sie dies tun, in C, kann man ziemlich viel denken, die gleiche Weise, aber anstatt new und delete[] Sie haben malloc und free.

Wissen, die feinen Unterschiede zwischen dynamischen arrays und Zeigern ist schwierig. Es dauerte eine Weile, bevor ich verstanden, was Los war. Viel Glück und halten Sie es.

In C können Sie diese Methode verwenden.

int i=0;
int *p;
char c;
int size; 
printf("Enter size :");
scanf("%d",&size); 
int *p=malloc(sizeof(int)*size);
do
{
 printf("Enter Number : ");
 scanf("%d",&p[i]);
 i++;
 printf("Press 'q' or 'Q' to quit or any other key to continue : ");
 scanf("%c",&c);
}
while(c!='q' && c!='Q' && i<=size);
p=realloc(p,i*sizeof(int));

Auf diese Weise können Sie kostenlos den rest des Speichers, wenn die Anzahl der zahlen, die Sie wollen, ist weniger als der Speicher.