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) :D.