C/C++ dynamická alokace paměti

[Dominátor]

Zdravím,

potřeboval bych od Vás trochu objasnit problematiku týkající se dynamického (rostoucího) pole a s tím související dynamickou alokaci paměti - malloc, realloc, případně new v C++ apod. Jde o to, že ve všech návodech, videích apod je ten postup prakticky totožný ->

1. vytvořím si pole na haldě o nějaké velikosti např. int* heapArray = (int*) malloc(3 sizeof(*heapArray));
2. poté, až kapacita tohoto pole nebude dostačovat, tak se použije realloc (data zůstanou, velikost pole se zvětší - většinou např. 2x)
3. v C++ jelikož realloc není, tak se to buď řeší buď přímo zabudovaným vectorem a nebo vytvořením druhého většího pole a zkopírováním hodnot z prvního do tohoto nově vytvořeného pole.
4. to vše samozřejmě ideálně zakomponovat do nějaké struktury která bude obsahovat další proměnné, jako kapacita, velikost apod...

Dynamické pole jsem podle kódů z návodů pochopil, ale trochu jsem si s tím hrál a vůbec jsem nepobral pár věcí. Na tyto věci (celkově 2) se ptám přímo v komentářích v první části kódu kódu - příšlo mi to přehlednější, než to vypisovat sem.

první a druhá část je oddělena hvězdičkami

v druhé části jsem se bez nutnosti používat realloc nebo vytvoření druhého pole snažil vytvořit primitivní dynamicky rostoucí pole a zdá se, že vše funguje (žádný problém jsem nezaznamenal).

#include <stdio.h>
#include <stdlib.h>

int main()
{
// alokace pole na haldě
int* heapArray = (int*) malloc(sizeof(*heapArray)); // nebo v C++ int* heapArray = new int;
heapArray[0] = 0; // *(heapArray) = 0;
heapArray[1] = 1; // *(heapArray + 1) = 1;
heapArray[2] = 2; // *(heapArray + 2) = 2;

//v pořádku
printf("%d ", heapArray[0]);
printf("%d ", heapArray[1]);
printf("%d \n", heapArray[2]);

printf("%p ", &heapArray[0]);
printf("%p ", &heapArray[1]);
printf("%p \n", &heapArray[2]);

//jakou hodnotu má dalších 7 políček a existují vůbec?
heapArray[10] = 500;

//pointerová aritmetika funguje
printf("%d ", *(heapArray+10));
printf("\n");

/*pokud funguje kód výše proč bych vůbec při alokaci pole měl udávat počet políček?
int* heapArray = (int*) malloc(pocet_policek * sizeof(*heapArray)); ? */

//*******************************************************************************//

int* heapArray2 = (int*) malloc(sizeof(*heapArray2));
int velikost_pole = 0;

printf("zadej pocatecni velikost pole: ");
scanf("%d", &velikost_pole);

//počáteční velikost
for(int x = 0; x < velikost_pole; x++){
heapArray2[x] = x;
}

for(int x = 0; x < velikost_pole; x++){
printf("%d ", heapArray2[x]);
}

printf("\n");

//rozšíření pole
for(int x = velikost_pole; x < velikost_pole*2; x++){
heapArray2[x] = x;
}

for(int x = velikost_pole; x < velikost_pole*2; x++){
printf("%d ", heapArray2[x]);
}

printf("\n");

//vypsání celého pole
for(int x = 0; x < velikost_pole*2; x++){
printf("%d ", heapArray2[x]);
}

free(heapArray2);

return 0;
}

Jelikož jsem na internetu nic podobného nenašel, tak jsem se rozhodl zeptat se zde vás.
Buď to funguje, protože to prostě fungovat může a není to spatně, a nebo je to totálně celé špatně, ale funguje to (vím, že tohle se u C/C++ stát může) .

[Reklama]

[rhsCZ]

u malloc se píše velikost, protože si rezervuje určitou velikost v paměti. jde o to, že když jsem vzal tvůj kód jak je(první a druhá část dohromady), tak mi malloc v druhé částí hodil exception, protože se snažil allokovat pamět, která neměla být allokovována prvním heapArray. Jakože jde o to, že by jsi s takhle psaným programem mohl narazit, že by jsi klidně mohl pokoušet přistupovat k paměti, kterou si allokoval jiný program. nebo by třeba jiný program také nemusel fungovat. prostě si allokuješ určitou část paměti a víš, že k ní máš behem běhu programu přístup. btw. ve vs2019 u int* heapArray = (int*)malloc(sizeof(*heapArray)); prý má range 0-0, allokovaná velikost na 1 hodnotu int.

Dodatečně přidáno po 28 vteřinách:
P.S. doufám, že jsem nenapsal nějakou kravinu

[faraon]

Dokážeš vysvětlit, co přesně dělá tenhle řádek kódu?

Kód: Vybrat vše

int* heapArray = (int*) malloc(sizeof(*heapArray));

Kolik bajtů RAM sis tím vlastně alokoval?

Pokud to úplně přesně nevíš, zkus si tohle:

Kód: Vybrat vše

printf("%d\n", sizeof(*heapArray));

A také UTFM

Činnost se může lišit v různých operačních systémech. Jeden ze způsobů je, že ti správce paměti systému při prvním požadavku přidělí celou stránku paměti, a tu si potom rozděluje správce paměti programu. Takže ty si sice alokuješ jenom 4 bajty, ale ve skutečnosti máš povolený přístup třeba do celé stránky velké například 4 KiB.

U jednoprvkového pole tak zapíšeš možná i do array[1000] a nic se nestane, nebo si přepíšeš nějaká jiná data v úplně jiné proměnné, ale program běží dál. Teprve až když se pokusíš pracovat s odkazem mimo tvojí stránku, porušíš ochranu paměti a OS tvůj program nemilosrdně sestřelí na segfault.

[Dominátor]

Děkuji všem za velmi poučné rady, které pomohly! :) nechtěl jsem se vrhat do něčeho dalšího, dokud aspoň částečně nepochopím tohle. Teď se můžu pustit do dalších pokusů.