Hoe maak je een array met een dynamische grootte? Algemeen gebruik van dynamische arrays (misschien ook pointers)?

Ik probeer een programma te maken dat

  1. Neemt de invoer van de gebruiker (laten we zeggen dat alles intis)
  2. Sla het op in een array zonder begingrootte (d.w.z. niet -> array[5];); en dan
  3. Gebruik de informatie die in de array is opgeslagen voor welke sinistere doeleinden dan ook.

Ik vraag om hulp zodat ik kan leren hoe ik dit zo nodig zelf kan doen.

  • Hoe maak ik een dynamische array zonder een ingestelde grootte?
  • Hoe kan ik de elementen in de bovenstaande array gebruiken/toegang krijgen/bereiken?

Lezen was gewoon niet genoeg voor mij.

Ik weet dat het een erg noob-vraag is, en ja, ik ben een noob, maar om dat te veranderen heb ik wat hulp nodig.


Antwoord 1, autoriteit 100%

Voor C++:

Als je alleen een container nodig hebt, gebruik dan std:vector. Het zorgt voor alle geheugentoewijzingen die nodig zijn voor u. Als u echter uw eigen dynamische container wilt ontwikkelen (welke redenen u ook heeft), moet u zelf voor de geheugentoewijzingen zorgen. Dat wil zeggen, wanneer uw array groeit, moet u een nieuw geheugenblok toewijzen, de huidige arraywaarden naar de nieuwe geheugenlocatie kopiëren en nieuwe waarden toevoegen aan het nieuw toegewezen geheugen. Meestal verpakt men dit soort logica in een aparte klasse, b.v. GrowingArray(zoals de standaard geleverde vectorklasse)

BEWERKEN

Om mijn antwoord nader toe te lichten (aangezien je dit voor leerdoeleinden gebruikt):

opslaan in een array zonder begingrootte (d.w.z. niet -> array[5];)

Hier wil je zoiets als dit gebruiken: int * myDynamicArray;
Wanneer een gebruiker enkele waarden invoert, wijst u geheugenbrok toe waar die waarden worden opgeslagen: myDynamicArray = new int[5];met de grootte van uw initiële invoer. Ik zou net zo goed aanraden om de grootte van de array op te slaan in een variabele: int arraySize = 5;
Als u later nieuwe waarden aan uw myDynamicArraywilt toevoegen, moet u eerst een nieuwe geheugenbrok toewijzen voor volwassen array (huidige array-elementen + nieuwe array-elementen). Laten we zeggen dat er 10 nieuwe waarden komen. Dan zou je het volgende doen: int* grownArray = new int[arraySize+10];dit wijst een nieuw geheugenblok toe aan een gegroeide array. Dan wil je items van het oude geheugenblok naar het nieuwe geheugenblok kopiëren en door de gebruiker toegevoegde waarden toevoegen (ik neem aan dat je dit voor leerdoeleinden gebruikt, dus ik heb je een eenvoudige cyclus gegeven voor het kopiëren van elementen. Je zou std:copyof c zoals memcopyook):

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;

Antwoord 2, autoriteit 89%

Dit is waarschijnlijk de slimste (cryptisch overmatig STL-gebruik voor sommigen) manier…

std::vector<int> vec;
// read integers 1 at a time from the user,
// will stop when non-integer input is entered
std::copy(std::istream_iterator<int>(std::cin),
          std::istream_iterator<int>(), 
          std::back_inserter(vec));
// print out the vector
std::copy(vec.begin(), vec.end(), std::ostream_iterator<int>(std::cout, " "));

Antwoord 3, autoriteit 50%

Hier is wat code die ik in C++ heb geschreven en die de basis doet.

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

Ok, dus dit is wat er in deze code gebeurt. We vragen om de grootte van de array met std::cin en gebruiken vervolgens het nieuwe sleutelwoord om dynamisch wat geheugen voor de array toe te wijzen. Er zijn hier enkele details waardoor het in het begin een beetje raar lijkt; het is wat verwarring lijkt te veroorzaken bij veel nieuwe C++-ontwikkelaars.

Dus eerst hebben we onze dynamische array gedeclareerd met een pointer in plaats van de array-declaratie, b.v. we gebruikten int *my_dynamic_arrayin plaats van int my_dynamic_array[]. In eerste instantie lijkt dit een beetje triviaal, maar er is iets dat je moet begrijpen over wat er gaande is in C en C++.

Als je een array statisch declareert, vertel je het programma dat je dat geheugen wilt reserveren voor gebruik. Het is er eigenlijk; het is aan jou om te gaan gebruiken. Wanneer u dynamisch een array maakt, begint u met een aanwijzer. Pointers zijn slechts een verwijzing naar een bepaald geheugen. Dat geheugen is nog niet toegewezen. Als je iets probeert te benaderen met bijvoorbeeld my_dynamic_array[3], krijg je een vervelende foutmelding. Dat komt omdat er op die locatie niets in het geheugen staat (tenminste niets dat aan het programma is gegeven om te gebruiken).

Let ook op het gebruik van delete[]in plaats van delete. Zo maak je geheugen vrij als je klaar bent met de array.

Als je dit in C doet, kun je er ongeveer hetzelfde over denken, maar in plaats van newen delete[]heb je mallocen free.

Het is lastig om de subtiele verschillen tussen dynamische arrays en pointers te kennen. Het duurde even voordat ik volledig begreep wat er aan de hand was. Veel succes en blijf volhouden.


Antwoord 4, autoriteit 6%

In C kun je deze methode gebruiken.

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

Op deze manier kunt u de rest van het toegewezen geheugen vrijmaken als het aantal gewenste gehele getallen kleiner is dan het toegewezen geheugen.


Antwoord 5, autoriteit 6%

Ik heb een suggestie voor je. U kunt gelinkte lijst gebruiken in plaats van array als u gaat ontwikkelen met C

hier na een voorbeeld:

typedef struct linked_list {
    int x,
    struct linked_list *next
} linked_list;
struct linked_list *head = NULL;
void add_element(int x)
{
    struct linked_list *elem;
    elem = malloc(sizeof(struct linked_list));
    elem->x =x;
    elem->next = head;
    head = elem;
}
int main()
{
   int x;
   struct linked_list *p;
   do
   {
       printf("Enter Number : ");
       scanf("%d",&x);
       add_element(x)
       printf("Press 'q' or 'Q' to quit or any other key to continue : ");
       scanf("%c",&c);
   }while(c!='q' && c!='Q');
   for (p=head;p!=NULL;p=p->next)
   {
        printf(%d\r\n",p->x);
   }
}

Other episodes