In quali modi pratici è bene ricordare il modello di memoria / puntatori? [chiuso]

Molti ambienti di programmazione moderni sono ambienti gestiti : hanno gestione automatica della memoria , il che significa che non devi preoccuparti dell'allocazione della memoria e della deallocazione.

Sostituiscono il concetto di memoria e i puntatori con concetti di livello superiore come variabili locali, campi, "riferimenti", ecc. Si suppone ora di pensare a una variabile locale come ad una posizione di archiviazione astratta. Non devi più preoccuparti di dove sia la memoria in quel punto e di cosa devi fare per poterla ripulire correttamente, che è astratta, ma devi comunque preoccuparti delle proprietà di alto livello astrazione, come, per esempio, il fatto che l'assegnazione a una variabile locale cancella il suo valore precedente.

Molti programmatori esperti che comprendono molto bene l'intero sistema, hanno difficoltà a separare questo livello superiore astratto dal livello inferiore concreto. Ad esempio, potrebbero pensare direttamente a una variabile locale come a una posizione di memoria all'interno dello stackframe. Di conseguenza, percepiscono i dettagli di basso livello come più importanti di quanto non lo siano perché non possono immaginare qualcuno che usa le variabili locali senza capire lo stackframe. Personalmente ritengo che tali persone rendano la programmazione più difficile per i neofiti di quanto non sia necessario, sia complicando le spiegazioni dei concetti di livello superiore, sia aspettando che i neofiti trovino importanti i dettagli di basso livello. La programmazione riguarda l'astrazione e questa è un'astrazione molto utile. (Non aiuta l'astrazione delle variabili locali di C's / C ++ delle variabili locali che è piuttosto dispersiva, il che rende alcuni dettagli di basso livello più importanti di quanto non siano negli ambienti gestiti).

Questo non vuol dire che tutti noi possiamo dimenticare tutto ciò che sappiamo su puntatori e stackframes e non insegnarlo mai. Sicuramente se sei interessato in esso, dovresti conoscerlo e ampliare la tua comprensione. Puoi occasionalmente trarre beneficio dalle conoscenze anche quando scrivi un codice di alto livello che non lo richiede rigorosamente (ad esempio quando lo ottimizzi), e ne hai certamente bisogno se stai scrivendo la gestione della memoria stessa (ad esempio un garbage collector). Ma sicuramente non dovresti sentire che non puoi mai essere un programmatore "appropriato" senza comprendere tutti gli ultimi dettagli di basso livello. Anche le persone che capiscono lo stackframe possono dimenticare (o non sapere) che alcune variabili locali possono essere memorizzate in un registro. Anche le persone che sanno di che potrebbero non sapere del circuito fisico che costituisce un registro. Usiamo tutte le astrazioni per rendere più facile ragionare sui nostri programmi, quindi non dobbiamo andare fino in fondo agli elettroni nel silicio tutto il tempo.

Credo che la tua domanda non sia formulata in modo sensato. Penso che quello che stai veramente chiedendo sia: "È bello capire la memoria e i puntatori".

Dì in C ++ abbiamo un cane di classe.

Dog a = Dog();  // On stack
Dog *b = new Dog();  // On heap.

'a' contiene un valore che è un Cane.

'b' contiene un valore che è un indirizzo di memoria presente nell'heap (che troveremo un cane nascosto lì).

'b' occupa spazio nello stack per contenere l'indirizzo in modo che occupi solo le dimensioni di un puntatore nello stack.

'a' occupa spazio sulla pila delle dimensioni di un cane.

Diciamo che vogliamo che i cani abbaiano ora ...

a.bark();
b->bark();

Dobbiamo trattare i nostri cani in modo diverso.

b->bark();
(*b).bark(); // same as above

Dobbiamo dire: "Vai dove b vive e dillo di abbaiare". La maggior parte delle persone non fa la differenza e vuole dire.

b.bark();  // Won't work, might not even build.

Perché un puntatore è solo una posizione (che è solo un numero). E un numero non può abbaiare. ('a' is a Dog. 'b' è la posizione di un altro cane.)

// We can even change what dog b points to.
b = &a;  // b will now hold the location to dog 'a'.
         // we will also have a dog that shall be lost forever D=!
b->bark();
a.bark();  // dog 'a' has now barked twice in a row since b points to a.

Hai bisogno di capire questo? Dipende dalle lingue e dagli strumenti che usi. In linguaggi come Java e Python tutto questo è forzato su te senza che tu lo sappia, è gestito dalla lingua in modo da non notarlo.

È bello capirlo? Perché sì ... sì lo è.

Devi tenerlo attivo nella tua mente? Bene ... consente di allocare un array.

int stackArray[INT_MAX];  // Probably overflows the stack
int *heapArray = new int[INT_MAX];  // Allocates it all on the heap
                                    // or returns NULL if it cannot find the space.

Quindi sì. A volte.

(stackArray sarà in realtà un puntatore però ... alla memoria nello stack)

In Java, se si memorizza un oggetto in una variabile come

MyClass myObject = new MyClass();

Quindi myObject contiene solo un riferimento all'oggetto attuale, che risiede nella memoria. E se lo fai:

MyClass anotherObject = myObject;

Quindi anotherObject contiene il riferimento allo stesso oggetto come myObject . C'è solo un oggetto nella memoria ed entrambe le variabili puntano ad esso. Se cambi qualcosa su myObject o su anotherObject , entrambi avranno effetto sullo stesso. Quindi, anche in Java è utile tenere a mente che si tratta almeno di riferimenti.