[C/C++]: Variabile allocata in heap o in stack?

[_sys/sid]

Stamattina mi son svegliato male dopo questo incubo:
"Come faccio a sapere se una variabile e' nello Stack o Nell'Heap?"

a una funzione passo un puntatore...

void mia_funzione (void *mio_punt) {
       if (mio_punt == NULL) {
              mio_punt = alloc_mio_punt();
              // Son Sicuro che e' nell'HEAP perche' faccio una malloc()
       } else {
              // mio_punt e' dell'Heap o dello Stack ???
       }
}

Che brutto svegliarsi cosi

[pablo1986]

bella domanda......io dico stack ma se è giusto al 70% l'ho sparato a caso

[_sys/sid]

...non posso dire che sia stata creata nello stack, perche' "l'utente" avrebbe potuto fare una malloc() da solo...
Quindi mi servirebbe un qualcosa per saperlo con precisione...

soltanto che mi serve una cosa portabile

[pablo1986]

si capisco, cmq attendo anche io una risposta esauriente
mi ha incuriosito anche a me questa cosa

[fastcoder]

Io la vedrei così:
- il puntatore mio_punt è nello stack;
- la memoria a cui punta mio_punt è allocata nell'heap per mezzo della malloc.

In pratica credo che il punto sia distinguere il puntatore dalla memoria puntata dal puntatore. Un puntatore non è altro che un handle alla memoria allocata nell'heap...e se questo fa parte di un parametro di funzione o è una variabile locale ad una funzione viene messo nello stack.

Direi inoltre che se qualcosa è allocato con malloc finisce senz'altro nell'heap.

Speriamo sia giusto

[_sys/sid]

si ok...
mio_punt puntera' a qualcosa nello stack o nell'heap...
stack e heap hanno indirizzamenti diversi, quindi si potrebbe capire da quello...
ma... dove parte l'heap e dove parte lo stack?
ed e' uguale su tutti i sistemi (NO )

non e' che magari c'e' un qualche macro messa a disposizione dai compilatori?

[fastcoder]

Sinceramente non capisco perchè ti interessi capire se mio_punt è nello stack o nell'heap.
Ho capito che se mio_punt è NULL allochi te della memoria che poi comunque devi liberare perchè il puntatore alla memoria allocata non torna al chiamante (ne come return ne come parametro perchè e' un puntatore semplice e non un doppio puntatore).
Se mio_punt non è NULL, mi viene in mente che dopo che hai elaborato mio_punt deallochi la memoria all'interno della funzione e quindi in questo caso dovresti sapere se era allocata non malloc.
Credo però che se tu stabilisci che una funzione accetta un puntatore che deve essere stato allocato con malloc e l'utilizzatore ti passa un puntatore ad una variabile nello stack allora è un pisquano e un bel segfault gli sta bene
Inoltre considera che uno ti potrebbe passare l'indirizzo di una variabile statica o di una variabile globale che non stanno nello stack.
Se proprio vuoi aiutare l'utilizzatore potresti definirti un tuo pool di memoria e richiedere che solo la memoria che proviene dal tuo pool può essere usata in mia_funzione; la verifica a questo punto la puoi fare perchè gestisci il tuo heap e quindi puoi aggiungere delle strutture di controllo per ogni porzione di memoria allocata. Magari addirittura diventa più efficente della malloc

[andbin]

Originariamente inviato da _sys/sid
Stamattina mi son svegliato male dopo questo incubo:
"Come faccio a sapere se una variabile e' nello Stack o Nell'Heap?"

Allora:

1) Tutto quello che è allocato dinamicamente con malloc, calloc, new (in c++), ecc... (e qualunque altra funzione specifica del S.O. come ad esempio la GlobalAlloc in Win32) ----> è allocato sul HEAP.

2) Tutte le variabili locali (non static) di una funzione (anche in sotto-blocchi for, if, ecc...), comprese le variabili che contengono i parametri della funzione ----> sono allocate sullo STACK.

Nota:
Se una variabile è un puntatore (con contenuto valido), è chiaro che l'area di memoria a cui punta può essere sul HEAP o sullo STACK, dipende da cosa gli è stato assegnato.


EDIT (come precisazione):
3) Le variabili globali (quelle dichiarate fuori da qualunque funzione) e le variabili locali di una funzione marcate con static, hanno durata uguale a quella del programma e sono allocate in uno spazio di memoria specifico definito dal compilatore.

[_sys/sid]

il mio problema era quello che diceva fastcoder...
(la funzioncina era un esempio scritto sul momento)

cmq il problema e' della free...
perche' non posso fare una free di un oggetto nello stack...

void mia_funzione (void *mio_punt) {
       if (mio_punt == NULL) {
              mio_punt = alloc_mio_punt();
              // Son Sicuro che e' nell'HEAP perche' faccio una malloc()
       } else {
              // mio_punt e' dell'Heap o dello Stack ???
       }

       /* ============================== */
       if (mio_punt sta' nell'heap)
              free(mio_punt);
       /* ============================== */
}

[fastcoder]

Allora direi che se vuoi essere portabile non devi dipendere da macro del compilatore e da calcoli strani sugli indirizzi. Io vedrei due soluzioni:
- passare un parametro che specifica se il puntatore e' sull'heap o no;
- definirti una tua gestione del'heap e passare istanze di questa memoria, esempio:

void *myAlloc(size_t sz)
{
  char *r = malloc(2 + sz);
  *r = 0x4E;
  *(r + 1) = 0xE4;
  return r + 2;
}

void myFree(void *ptr)
{
  char *r = (char *)ptr;
  r -= 2;
  if( (*r == 0x4E) && (*(r + 1) == 0xE4 )
  { // Allocata con myAlloc.
    free(r);
  }
  else
  { // Sullo stack o allocata con malloc.
  }
}

Poi richiedi di usare la tua myAlloc/myFree invece che la malloc/free. Se poi quello usa ancora malloc e free fatti suoi.
A questo punto:

void mia_funzione (void *mio_punt) {
       if (mio_punt == NULL) {
              mio_punt = myAlloc();
       } else {
       }

       /* ============================== */
       myFree(mio_punt);
       /* ============================== */
}

Al solito il codice non l'ho provato...e' solo una idea. Sinceramente io cambierei la funzione o meglio ristrutturerei il codice in C++ che mi darebbe più strumenti per far si che il mio codice venga usato in modo certo e come voglio io