utilizzo Asterisk in Objective-C: questioni relative

Question

Ho avuto un paio di domande relative a questo: utilizzo Asterisk in Objective-C

  

array NSArray; in un ambito locale sarebbe un oggetto "allocato" in pila. NSArray * array; indica un oggetto supportato da un pezzo di memoria, tipicamente allocata dall'heap.

Come si fa a sapere quando qualcosa è allocato sullo stack e sul mucchio? Sono tutte le variabili locali sullo stack e sono tutti i puntatori nel mucchio?

  

Perché non si dereferenziazione il puntatore all'oggetto e che puntatore all'oggetto è fondamentale all'interno della implementazione del metodo stesso. Quando si dice ...

Eh

Answer 1

  

Come si fa a sapere quando qualcosa è allocato sullo stack e sul mucchio? Sono tutte le variabili locali nello stack ...

Non importa. Lo stack e heap sono dettagli di implementazione; i linguaggi C e Objective-C non sapere su di loro, e non dovrebbero generalmente avere alcun motivo di preoccuparsi se qualcosa è in pila o sul mucchio.

In Mac OS X, le variabili locali sono in pila. Ma, per quasi tutti gli scopi, questo non ha alcuna importanza. Non ti preoccupare.

  

... e sono tutti i puntatori nel mucchio?

No. I puntatori sono indirizzi di memoria; questo è tutto.

Pointer variabili possono essere ovunque tutte le altre variabili possono, vale a dire, ovunque (fatte salve le limitazioni di implementazione definita che non è necessario preoccuparsi, come osservato in precedenza).

mio puntatore esercitazione per ulteriori informazioni.

  

    

Perché non si dereferenziazione il puntatore all'oggetto e che puntatore all'oggetto è fondamentale all'interno della implementazione del metodo stesso. Quando si dice ...

  

     

Eh

Un puntatore è un indirizzo di memoria. Come tale, si riferisce alla memoria a quell'indirizzo. Dereferenziazione il puntatore sta accedendo che la memoria.

Si accede mai, mai direttamente la memoria di un oggetto di cacao riprende. Hai solo inviarlo messaggi, a uno è chiedere domande o dirgli di fare le cose. Così, non hai mai dereference il puntatore.

“... che puntatore all'oggetto è critica ai implementazione del metodo stesso.” Indica che l'oggetto, nelle implementazioni del metodo, avrà bisogno di un proprio puntatore. E 'possibile solo per inviare un messaggio a un puntatore ad un oggetto (questo dettaglio è di solito eliso). Se avete tirato in qualche modo fuori questo, il destinatario del messaggio (cioè l'oggetto che si messaged) avrebbe non dispone di un proprio puntatore.

Supponiamo che fosse possibile inviare un messaggio a un oggetto Dereferenced. La norma è ancora per inviare messaggi ai puntatori agli oggetti, quindi con ogni probabilità, l'oggetto sarà ancora bisogno di quel puntatore a se stesso, rendendo questa ipotetica capacità di un oggetto messaggio Dereferenced inutile.

Dal momento che è inutile, lo hanno lasciato del tutto. L'oggetto avrà bisogno di un proprio puntatore (il puntatore è fondamentale per le implementazioni di metodo dell'oggetto), in modo da poter solo inviare un messaggio a suo puntatore.

Answer 2

Il * è l'operatore dereference per C, C ++ e Objective-C. Capire l'operatore dereference, e la gestione della memoria, in generale, è di gran lunga più ampio di Objective-C. Questa è una competenza fondamentale per qualsiasi sviluppatore C / C ++ / Objective-C. Dai un'occhiata alla moltitudine di intro C tutorial in rete per saperne di più.

Modifica: qualsiasi tutorial su c puntatori farà. Come questo http://home.netcom.com/~tjensen/ptr/pointers htm

Answer 3

In Cocoa, non verrà mai usata pila oggetti allocati; TUTTI gli oggetti saranno preceduti da un * (ricordiamo che il tipo di "id" è davvero un'altra parola per "puntatore ad un oggetto") e ha creato sul mucchio.

Avrai sempre questo:

NSArray     *myArray;

e mai in questo modo:

NSArray     myArray;

È possibile ignorare il secondo pezzo, dal momento che si sta sempre dereferencing il puntatore.

Answer 4

Spero che questi esempi di giocattoli ingenui possono aiutare.

In C, in una funzione,

int x; // x is a variable of type int in stack
int *xp; // xp is a variable of type int * (pointer to int) in stack
int *xp2 = (int *) malloc(sizeof(int)); // xp2 is a variable in stack, it points to a memory location(size is of int) in heap
xp = &x; // xp can point to x
xp = xp2; // xp can also point to what xp2 points to
free(xp2); // now xp and xp2 point to a freed memory, BAD to use xp and xp2 now.
int **y; // y is a variable in stack, type is int **
y = (int **) malloc(sizeof(int *)); // allocate a piece of memory in heap, to hold a pointer to int(int *)
*y = (int *) malloc(sizeof(int)); // allocate a piece of memory in heap, to hold an int
**y = 100; // now we can use it
free(*y);
free(y);

In C ++, in una funzione funzione o organo (metodo),

SomeClass a1; // a1 is an object of type SomeClass in stack
SomeClass *a2 = new SomeClass(); // a2 is a pointer(in stack) pointing to an object(of type SomeClass) located in heap
delete a2;

Quindi, in C ++, gli oggetti possono esistere in pila o heap

In Java, in una funzione o un metodo,

SomeClass b1; // b1 is just a reference, no object exists yet
b1 = new SomeClass(); // in java, objects can only exist in heap
int x; // however, primitive types are in stack, 

In Objective-C, in una funzione o metodo,

SomeClass c1; // you can't do this.
SomeClass *c2 = [[SomeClass alloca] init]; // c1 is a pointer in stack, pointing to an object in heap
[c2 release];