Mit jelent ez a warning C-ben?

Nem, ez azt jelenti, hogy a verem csordul túl.

Mivel ez nem dinamikusan foglalt memória, így eléggé limitált méretű, úgy látom 65535 bájtban limitálva. Ha ilyen nagy tömb kell neked, foglalj dinamikusan memóriát (malloc függvény), és majd a végén szabadítsd fel.

Dinamikus helyfoglalás:

double* arrdbl;

if ( (arrdbl = (double*)malloc(sizeof(double)*100000))==null ) {/*hibakezelés*/ return;}

..

free(arrdbl);

Amúgy nem biztos, hogy túlcsordul, mert ez egy fordítási warning lehet. És nem "C-ben", hanem egy konkrét C fordító figyelmeztetése, szóval hogy mit jelent, az fordítótól függ.

Ha verembe akarod létrehozni, akkor inkább ne. Dinamikusan foglald le.

if ((arrdbl = (double*)malloc(sizeof(double)*100000))==null ) {/*hibakezelés*/ return;}

sizeof( t )

Operátor (nem függvény), ami visszaadja az adott t típus méretét bájtban. (Fordításkor értékelődik ki!)

sizeof(double)

A double típus mérete. Ha minden igaz, 8 bájt.

sizeof(double)*100000

100000 darab double változó össze mérete bájtban. (Merthogy egy változó mérete * 100000)

malloc( x )

x bájt méretű memóriát foglal le, pontosabban az operációs rendszertől kér.

Ez void pointert, típus nélküli mutatót ad vissza, ami a lefoglalt memória elejére mutat, vagy null pointert, ha nem sikerült a foglalás.

malloc(sizeof(double)*100000)

100000 db double típusú változóhoz szükséges memóriát foglal le, cím-folytonosan (tehát egy "darabban").

(double*) valami

A valami nevű pointer típusát kényszeríti, hogy double* típusú legyen, tehát double változóra tudjon mutatni. Ez a változó kiolvasásakor fontos, mert nem mindegy, hogy a progi majd hogyan értelmezi az ott lévő adatokat.

arrdbl = (double*)malloc(sizeof(double)*100000)

Ez így memóriát foglal, és az eredmény void pointert double* pointerré kényszeríti. Ezután ezt letároljuk az arrdbl pointerben.

(változó = érték) == null

A C-ben az értékadás is egy kifejezés, van értéke. Tehát egy változóba értéket teszünk, és ennek az értékadásnak az értéket (ami itt az "érték" lesz) rögtön megvizsgáljuk, hogy egyenlő-e null-lal.

Ez így néz ki szétszedve, ez lesz az if feltétele:

(

__arrdbl = (double*)malloc(sizeof(double)*100000) /* <--értékadás */

) == null

Vagyis:

if (

__( arrdbl = (double*)malloc(sizeof(double)*100000) ) == null

) {...}

Tehát kértünk adott méretű dinamikus memóriát, az oda mutató pointer típusát átalakítottuk, hogy valóban double-ra mutasson, eltároltuk a double* típusú változónkban, ezt rögtön megvizsgáltuk, hogy null-e, és ha igen, akkor nem sikerült a foglalás, tehát lefut a hibakezelés, nem engedi tovább futni a kódot.

Ezután használható az arrdbl[x] kifejezés, mert a lefoglalt terület tuképpen egy tömb.

A munka végén fel kell szabadítani a lefoglalt memóriát:

free(arrdbl)

Ha valamit elnéztem, remélem javítanak. :)