Sono molto confuso su malloc() e calloc() su C

Question

ho sempre programmato in Java, che è probabilmente il motivo per cui sono così confuso su questo:

In Java dichiaro un puntatore:

int[] array 

e inizializzare o assegnarlo qualche ricordo:

int[] array = {0,1,0} 
int[] array = new int[3] 

Ora, in C, è tutto così confuso. In un primo momento ho pensato che fosse facile come dichiarandolo:

int array[] 

e l'inizializzazione o assegnandolo qualche ricordo:

int array[] = {0,1,0} 
int array[] = malloc(3*sizeof(int)) 
int array[] = calloc(3,sizeof(int)) 

A meno che non mi sbaglio, tutto quanto sopra è equivalente Java-C , destra?

Poi, oggi ho incontrato un codice in cui ho trovato il seguente:

pthread_t tid[MAX_OPS]; 

e alcune righe sotto, senza alcun tipo di inizializzazione ...

pthread_create(&tid[0],NULL,mou_usuari,(void *) 0); 

Sorprendentemente (almeno a io), il codice funziona! Almeno in Java, ciò restituirebbe una bella "NullPointerException"!

Così, al fine di:

1. Sono corretto con tutte le "traduzioni" Java-C?

2. Perché funziona il codice?

3. C'è qualche differenza tra l'utilizzo di malloc(n*sizeof(int)) e calloc(n,sizeof(int))?

Grazie in anticipo

Answer 1

Non è possibile assegnare memoria a un array. Un array ha una dimensione fissa, per l'intera durata della vita. Un array non può mai essere nullo. Un array non è un puntatore.

malloc restituisce l'indirizzo in un blocco di memoria che è riservato per il programma. Non è possibile "assegnare" quello (essendo il blocco di memoria) a un array, ma è possibile memorizzare l'indirizzo di questo blocco di memoria in un puntatore: fortunatamente, la sottoscrizione dell'array viene definita tramite puntatori, quindi è possibile "utilizzare puntatori come array" , per esempio

int *ptr = malloc(5 * sizeof *ptr); 
ptr[2] = 5; // access the third element "of ptr" 
free(ptr); // always free at the end 

Quando si dichiara una matrice senza dimensione (cioè array[]), significa semplicemente la dimensione della matrice è determinata dalla lista di inizializzazione. Questo è

int array[] = {1, 2, 3, 4, 5}; // is equal to 
int array[5] = {1, 2, 3, 4, 5}; 

Provare a dichiarare un array senza una dimensione e senza un inizializzatore è un errore.

---

Il codice pthread_t tid[MAX_OPS]; dichiara un array chiamato tid di tipo pthread_t e di dimensioni MAX_OPS.

Se la matrice ha memoria automatica (vale a dire la dichiarazione è all'interno di una funzione e non statica, non globale), quindi ogni elemento di array ha un valore indeterminato (e causerebbe un comportamento non definito che tenta di leggere tale valore). Fortunatamente, tutto ciò che la chiamata alla funzione fa è che prende l'indirizzo del primo elemento dell'array come primo parametro e probabilmente lo inizializza (l'elemento) all'interno della funzione.

---

La differenza di calloc e malloc è che il blocco di memoria che calloc rendimenti è inizializzato a zero.Questo è;

int *ptr = calloc(5, sizeof *ptr); 
// is somewhat equal to 
int *ptr = malloc(5 * sizeof *ptr); 
memset(ptr, 0, 5 * sizeof *ptr); 

La differenza tra

int *ptr = malloc(5 * sizeof *ptr); 
// and 
int array[5]; 

è che array ha memorizzazione automatica, (viene memorizzato sulla pila), ed è "pubblicato" dopo che passa nell'ambito. ptr, tuttavia, (viene memorizzato su heap), viene assegnato dinamicamente e deve essere free d dal programmatore.

Answer 2

Trovo utile quando si sta programmando in C (al contrario di C++) per indicare * array esplicitamente, per ricordare che c'è un puntatore che può essere spostato. Quindi vorrei iniziare da riformulare il vostro esempio come:

int array[] = {0,1,2}; 
int *array = malloc(3*sizeof(int)); 
int *array = calloc(3,sizeof(int)); 

La prima rende chiaro che c'è qualcosa che si chiama serie, che punta a un blocco di memoria che contiene una matrice 0, 1 e 2. puo' essere spostato da qualche parte.

Il tuo prossimo codice: pthread_t tid [MAX_OPS];

In effetti causa un array con sizeof (pthread_t) * MAX_OPS da allocare. Ma non alloca un puntatore chiamato * tid. C'è un indirizzo della base dell'array, ma non puoi spostarlo altrove.

Il tipo ptherad_t è in realtà una copertina per un puntatore. Quindi tid sopra è in realtà una matrice di puntatori. E sono tutti allocati staticamente ma non sono inizializzati.

Il pthread_create prende la posizione all'inizio dell'array (&tid[0]), che è un puntatore, e assegna un blocco di memoria per contenere la struttura di dati pthread. Il puntatore è impostato per puntare alla nuova struttura dati e la struttura dati è allocata.

L'ultima domanda --- la differenza tra malloc(n*sizeof(int)) e calloc(n,sizeof(int)) è che il successivo inizializza ogni byte su 0, mentre il primo no.

Answer 3

2 - Questa dichiarazione di matrice è statica:

pthread_t tid[MAX_OPS]; 

Non abbiamo bisogno di allocare blocco di memoria, invece di allocazione dinamica:

pthread_t *tid = (pthread_t *)malloc(MAX_OPS * sizeof(pthread_t)); 

Non dimenticare di liberare la memoria:

3 - La differenza tra malloc e calloc è calloc allocare un blocco di memoria per un array e inizializza tutti i bit a 0.

Answer 4

C offre allocazione di memoria statica e dinamica: è possibile allocare gli array dallo stack o nella memoria eseguibile (gestita dal compilatore). Questo è proprio come in Java, puoi allocare un int nello stack o un intero sullo heap. Le matrici in C sono come qualsiasi altra variabile dello stack: vanno fuori ambito, ecc. Nel C99 possono anche avere una dimensione variabile, sebbene non possano essere ridimensionate.

La differenza principale tra {} e malloc/calloc è che gli array {} sono allocati staticamente (non hanno bisogno di essere liberati) e automaticamente inizializzati per te, mentre gli array malloc/calloc devono essere liberati esplicitamente e devi inizializzarli in modo esplicito. Ma naturalmente, gli array malloc/calloc non escono dal campo di applicazione e puoi (a volte) realloc().

Answer 5

Ti manca tre molto semplice e serrare argomenti C (e fuorviante!):

• la differenza tra array e puntatori
• la differenza tra l'allocazione statica e dinamica
• la differenza dalle variabili che dichiarano sullo stack o sul mucchio

Se si scrive int array[] = malloc(3*sizeof(int)); si otterrebbe un errore di compilazione (qualcosa come 'identificatore': l'inizializzazione dell'array richiede le parentesi graffe).

Ciò significa che dichiara una matrice permette di inizializzazione solo statico:

• int array[] = {1,2,3}; che riserva 3 interi contigui in pila;
• int array[3] = {1,2,3}; che è lo stesso del precedente;
• int array[3]; che riserva ancora 3 interi contigui sullo stack, ma non li (il contenuto sarà spazzatura casuale)
• int array[4] = {1,2,3}; quando la lista di inizializzazione non inizializzare tutti gli elementi, il resto sono impostato su 0 (non inizializza C99 §6.7.8/19): in questo caso si otterrà 1,2,3,0

si noti che in tutti questi casi non si è allocazione nuova memoria, si sta solo utilizzando la memoria già impegnato in pila. Si verificherebbe un problema solo se lo stack è pieno (suppongo che sarebbe uno stack over ). Per questo motivo dichiarare int array[]; sarebbe sbagliato e privo di significato.

Per utilizzare malloc è necessario dichiarare un puntatore: int* array.

Quando si scrive int* array = malloc(3*sizeof(int)); si sta effettivamente facendo tre operazioni:

1. int* array dice al compilatore di riservare un puntatore sullo stack (una variabile intera che contiene un indirizzo di memoria)
2. malloc(3*sizeof(int)) assegna sul mucchio 3 interi contigui e restituisce l'indirizzo del primo
3. = assegna copie che restituiscono il valore (l'indirizzo del primo intero che hai assegnato) alla variabile del puntatore

Quindi, per tornare alla tua domanda:

pthread_t tid[MAX_OPS]; 

è un array in pila, in modo che non ha bisogno di essere assegnati (se MAX_OPS è, diciamo, 16 poi sullo stack sarà essere riservato il numero di byte contigui necessari per adattarsi a 16 pthread_t). Il contenuto di questa memoria sarà inutile (le variabili di stack non vengono inizializzate a zero), ma pthread_create restituisce un valore nel suo primo parametro (un puntatore a una variabile pthread_t) e ignora qualsiasi contenuto precedente, quindi il codice è corretto.