Oggetti in smalltalk e c ++ [chiuso]

In nessun linguaggio ogni oggetto richiede il proprio stack. Non in Smalltalk. Non in C ++. Non in un'altra lingua di uso comune.

L'unica eccezione degna di nota a questo sarebbe gli oggetti thread o gli oggetti che altrimenti incorporano il contesto di concorrenza. Ogni thread di esecuzione richiede il proprio stack di chiamate . Questo è vero indipendentemente dal linguaggio usato - Smalltalk, C ++, Python o whathaveyou.

NB Alcuni linguaggi o ambienti cercano di raggiungere la concorrenza (l'effetto di "multi-threading") senza stack per thread per ridurre il sovraccarico. Tali discussioni verdi o "greenlets" sono piuttosto utili e sempre più comuni. La concorrenza in vai , ad esempio, è incentrata su questa idea. Ma anche se i thread verdi sono chiamati "thread", si comportano più vicino a coroutine dei thread veri. Quelli che sono "stackless" stanno simulando la concorrenza multi-thread, non implementandola completamente.

Non so nulla di smalltalk, quindi parlerò solo di C ++. In C ++ (e AFAIK in Java e C #), ogni thread ha il proprio stack. Se non sai cos'è un thread, ti suggerisco di leggerlo. Lo descriverò qui come l'autobus su cui sta andando il tuo codice. Ma ti suggerisco di imparare più di questa orribile analogia (Inoltre, non tutti i runtime sono multithread, quindi potrebbe esserci solo un thread, ma probabilmente non ne tratterai).

Se dichiari qualcosa all'interno di una funzione come questa:

void foo() {
  MyObject a;
}

Quindi la nuova istanza MyObject è presente nello stack. Se hai 2 oggetti:

void foo() {
  MyObject a;
  MyOtherObject b;
}

Entrambi vivono nello stack (lo stesso stack). Se si utilizza new / malloc / HeapAlloc / qualunque altra routine di allocazione dell'heap della propria piattaforma:

void foo() {
  MyObject* a = new MyObject();
}

Quindi la nuova istanza dell'oggetto viene allocata nell'heap, che è una cosa diversa, che non descriverò poiché probabilmente è fuori ambito.

In breve, la risposta è no. Ogni oggetto non ha il proprio stack.

Non posso parlare per Smalltalk, ma per C ++, lo stack è usato dall'intero programma. Ogni oggetto nel programma condivide lo stack, in base a quando vengono utilizzati. Gli oggetti nello stack sono gestiti dal sistema operativo e vengono cancellati quando cadono "fuori ambito" in C ++. Ad esempio, considera il seguente codice:

// Global declarations and function prototypes
int x, y;
void someFunction();

int main()
{
    someFunction();
    // w and x are deleted here
}

void someFunction()
{
    int w, x;
}

Le variabili x e y rimarranno nello stack finché il programma non si chiude perché sono globali. Le variabili w e x verranno dichiarate e quindi "crescono" lo stack quando il programma immette someFunction() in modo che possano essere utilizzate e quindi verranno eliminate e quindi "riducono" lo stack quando someFunction() viene chiuso.

Anche gli oggetti come le classi non hanno il proprio stack, perché alla fine usano lo stack quando vengono istanziati e vengono distrutti quando cadono fuori dall'ambito del distruttore.

Un modo migliore per dire che ogni programma ottiene il proprio stack, ma gli oggetti in esso non lo fanno.