Statische array versus dynamische array in C++

Wat is het verschil tussen een statische array en een dynamische array in C++?

Ik moet een opdracht voor mijn klas doen en er staat dat ik geen statische arrays mag gebruiken, alleen dynamische arrays. Ik heb in het boek en online gekeken, maar ik schijn het niet te begrijpen.

Ik dacht dat statisch werd gemaakt tijdens het compileren en dynamisch tijdens runtime, maar ik zou dit kunnen verwarren met geheugentoewijzing.

Kun je het verschil uitleggen tussen statische array en dynamische array in C++?

Antwoord 1, autoriteit 100%

Lokale arrays worden op de stapel gemaakt en hebben een automatische opslagduur — u hoeft het geheugen niet handmatig te beheren, maar ze worden vernietigd wanneer de functie waarin ze zich bevinden eindigt. Ze hebben noodzakelijkerwijs een vaste maat:

int foo[10];

Arrays die zijn gemaakt met operator new[]hebben een dynamische opslagduur en worden op de heap opgeslagen (technisch gezien de “gratis winkel”). Ze kunnen elke grootte hebben, maar je moet ze zelf toewijzen en vrijmaken omdat ze geen deel uitmaken van het stapelframe:

int* foo = new int[10];
delete[] foo;

Antwoord 2, autoriteit 32%

static is een sleutelwoord in C en C++, dus in plaats van een algemene beschrijvende term, heeft static een heel specifieke betekenis wanneer toegepast op een variabele of array. Om de verwarring nog groter te maken, heeft het drie verschillende betekenissen binnen afzonderlijke contexten. Hierdoor kan een statische array vast of dynamisch zijn.

Laat me uitleggen:

De eerste is C++-specifiek:

• Een statische klasse lid is een waarde die niet wordt geconcretiseerd met de aannemer of verwijderd met de destructor. Dit betekent het element moet worden geïnitialiseerd en onderhouden anderszins. statische lid kan pointers geïnitialiseerd op nul en vervolgens toegewezen aan de eerste keer dat een constructeur wordt genoemd. (Ja, dat zou statisch en dynamisch)

Twee worden overgenomen van C:

• binnen een functie, een statische variabele wiens geheugenplaats wordt tussen het functieaanroepen. Het is statisch, dat slechts eenmaal wordt geïnitialiseerd en behoudt zijn waarde tussen functieaanroepen (gebruik maakt van statische funktie niet-reentrant, d.w.z. niet thread)

• statische variabelen gedeclareerd buiten functies zijn globale variabelen die alleen kan worden benaderd vanuit dezelfde module (broncode-bestand met een ander # onder andere)

De vraag (denk ik) je bedoeld om te vragen is wat het verschil tussen dynamische arrays en vaste of compile-time arrays. Dat is makkelijker te beantwoorden, compileren arrays worden vooraf bepaald (wanneer het programma wordt gecompileerd) en zijn onderdeel van een functie stackframe. Ze worden toegewezen vóór de hoofdfunctie runs. dynamische arrays worden toegewezen tijdens runtime met de “nieuwe” trefwoord (of malloc familie van C) en hun grootte is niet vooraf bekend. dynamische toewijzingen worden niet automatisch opgeschoond totdat het programma stopt.

Antwoord 3, Autoriteit 10%

Ik denk dat de semantiek wordt gebruikt in je klas zijn verwarrend. Wat is waarschijnlijk bedoeld met ‘statische’ is gewoon “constant formaat”, en wat is waarschijnlijk bedoeld met “dynamische” is “variabele grootte”. In dat geval is dan kan een constante grootte serie er als volgt uitzien:

int x[10];

en een “dynamic” zou gewoon elke vorm van structuur zijn die de onderliggende opslag mogelijk maakt om te verhogen of af te draaien bij runtime. Meestal zal de std::vectorklasse uit de C++ standaard bibliotheek volstaan. Gebruik het als volgt:

std::vector<int> x(10); // this starts with 10 elements, but the vector can be resized.

std::vectorheeft operator[]gedefinieerd, zodat u deze met dezelfde semantiek als array kunt gebruiken.

Antwoord 4, Autoriteit 9%

Het is belangrijk om duidelijke definities te hebben van wat voorwaarden betekenen. Helaas lijkt er meerdere definities te zijn van welke statische en dynamische arrays gemiddelde.

statische variabelen zijn variabelen gedefinieerd met behulp van statische geheugentoewijzing . Dit is een algemeen concept dat onafhankelijk is van C / C++. In C / C++ kunnen we statische variabelen maken met Global, File of Local Scope als deze:

int x[10]; //static array with global scope
static int y[10]; //static array with file scope
foo() {
    static int z[10]; //static array with local scope

automatische variabelen worden meestal geïmplementeerd met Stack-gebaseerde geheugentoewijzing . Een automatische array kan worden gemaakt in C / C++ als deze:

foo() {
    int w[10]; //automatic array

Wat deze arrays , x, y, zen wgemeen hebben, is dat de grootte voor elk van hen vast is en tijdens het compileren wordt gedefinieerd.

Een van de redenen waarom het belangrijk is om het onderscheid tussen een automatische array en een statische array te begrijpen, is dat statische opslag meestal wordt geïmplementeerd in de gegevenssectie(of BSS-sectie) van een objectbestand en de compiler kan absolute adressen gebruiken om toegang te krijgen tot de arrayswat onmogelijk is met op stapels gebaseerde opslag.

Wat gewoonlijk wordt bedoeld met een dynamische arrayis niet een array waarvan de grootte kan worden aangepast, maar die wordt geïmplementeerd met dynamische geheugentoewijzingmet een vaste grootte die tijdens runtime wordt bepaald. In C++ wordt dit gedaan met behulp van de newoperator.

foo() {
   int *d = new int[n]; //dynamically allocated array with size n     

Maar het is mogelijk om een automatische array te maken met een fixesgrootte die tijdens runtime is gedefinieerd met behulp van alloca:

foo() {
    int *s = (int*)alloca(n*sizeof(int))

Voor een echte dynamische array zou men iets als std::vectorin C++ moeten gebruiken (of een variabele lengte array in C).

Wat was bedoeld voor de opdracht in de OP-vraag? Ik denk dat het duidelijk is dat wat niet gewenst was een statische of automatische array was, maar een die ofwel dynamische geheugentoewijzing gebruikte met behulp van de newoperator of een niet-vaste array met behulp van b.v. std::vector.

Antwoord 5, autoriteit 8%

Statische arrays krijgen tijdens het compileren geheugen toegewezen en het geheugen wordt toegewezen aan de stapel. Terwijl aan de dynamische arrays tijdens runtime geheugen wordt toegewezen en het geheugen wordt toegewezen vanaf heap.

int arr[] = { 1, 3, 4 }; // static integer array.   
int* arr = new int[3]; // dynamic integer array.

Antwoord 6, autoriteit 3%

Ik denk dat het in deze context betekent dat het statisch is in de zin dat de grootte vast is.
Gebruik std::vector. Het heeft een resize() functie.

Antwoord 7, autoriteit 2%

Je zou een pseudo-dynamische array kunnen hebben waarvan de grootte tijdens runtime door de gebruiker wordt ingesteld, maar daarna wordt vastgesteld.

int size;
cin >> size;
int dynamicArray[size];

Antwoord 8

Statische matrix:

1. Statische arrays krijgen tijdens het compileren geheugen toegewezen.
2. Grootte is vast.
3. Bevindt zich in de geheugenruimte van de stapel.
4. Bijv. : int-array [10]; //array van maat 10

Dynamische matrix:

1. Geheugen wordt toegewezen tijdens runtime.
2. Grootte staat niet vast.
3. Bevindt zich in Heap-geheugenruimte.
4. Bijv. : int* array = nieuwe int[10];

Antwoord 9

Ja, de statische array wordt gemaakt tijdens het compileren, terwijl de dynamische array tijdens de runtime wordt gemaakt. Waar het verschil betreft met hun geheugenlocaties, bevinden de statische gegevens zich op de stapel en de dynamiek op de heap. Alles wat zich op heap bevindt, heeft geheugenbeheer nodig totdat en tenzij garbage collector zoals in het geval van .net-framework aanwezig is, anders bestaat het risico op geheugenlek.

Antwoord 10

Statische array: efficiëntie. Er is geen dynamische toewijzing of deallocatie vereist.

Arrays gedeclareerd in C, C++ in functie inclusief statische modifier zijn statisch.
Voorbeeld: static int foo[5];

Antwoord 11

statische array betekent het geven van elementen aan de zijkant van de array

dynamische array betekent zonder elementen in de array op te geven

voorbeeld:

    char a[10]; //static array
       char a[];  //dynamic array