Scrivendo a puntatore fuori limite dopo malloc () non ingenerare errori

Question

quando provo il codice qui sotto funziona benissimo. Mi sto perdendo qualcosa?

main()
{
    int *p;
    p=malloc(sizeof(int));
    printf("size of p=%d\n",sizeof(p));
    p[500]=999999;
    printf("p[0]=%d",p[500]);
    return 0;
}

ho provato con malloc (0 * sizeof (int)), o nulla, ma funziona bene. Il programma si blocca solo quando io non uso malloc affatto. Quindi, anche se io allocare 0 memoria per la matrice p, esso memorizza ancora i valori in modo corretto. Allora perché sto nemmeno preoccuparsi con malloc allora?

Answer 1

Potrebbe compare per funzionare bene, ma non è molto sicuro a tutti. Con la scrittura dei dati al di fuori del blocco allocato di memoria che si sta sovrascrivendo alcuni dati non si dovrebbe. Questa è una delle maggiori cause di segfaults e altri errori di memoria, e ciò che si sta osservando con esso appare a lavorare in questo breve programma è ciò che rende così difficile la caccia la causa principale.

questo articolo , in particolare la parte sulla corruzione della memoria, a iniziare a comprendere il problema.

Valgrind è un ottimo strumento per analizzare gli errori di memoria come quella che fornisci.

@ David ha fatto un buon commento. Confrontare i risultati dell'esecuzione il codice per l'esecuzione il seguente codice . Nota questi ultimi risultati in un errore di runtime (con praticamente uscita non utile!) Su ideone.com (clicca sul link), mentre la prima riesce come avete sperimentato.

main()
{
    int *p;
    p=malloc(sizeof(int));
    printf("size of p=%d\n",sizeof(p));
    p[500]=999999;
    printf("p[0]=%d",p[500]);
    p[500000]=42;
    printf("p[0]=%d",p[500000]);
    return 0;
}

Answer 2

Se non allocare memoria, p ha spazzatura in esso, in modo da scrivere ad esso probabilmente fallirà. Una volta che hai fatto una chiamata malloc valida, p punta alla posizione di memoria valida e si può scrivere. Stai sovrascrivendo la memoria che non si dovrebbe scrivere, ma nessuno sta andando a tenere la mano e dire a questo proposito. Se si esegue il programma e una memoria debugger come valgrind, vi dirà. Benvenuto C.

Answer 3

Scrivendo oltre la fine della vostra memoria è un comportamento indefinito ™, il che significa che tutto può happen- compreso il vostro programma di esercizio, come se quello che hai appena fatto è stato perfettamente legale. Il motivo per il vostro programma in esecuzione, come se si fosse realizzato malloc(501*sizeof(int)) sono completamente implementazione specifici, e può anzi essere specifico per qualsiasi cosa, compresa la fase della luna.

Answer 4

Questo è dovuto al fatto P sarebbe stato assegnato un certo indirizzo indipendentemente dalle dimensioni si utilizza con malloc (). Anche se, con una dimensione pari a zero si sarebbe fa riferimento memoria non valida, come la memoria non è stata assegnata, ma può essere in una posizione che non sarebbe causa crash del programma, anche se il comportamento sarà indefinito.

Ora, se non si utilizza malloc (), sarebbe puntare a una posizione rovini e cercando di accesso che rischia di crash del programma causa.

Answer 5

ho provato con malloc (0 * sizeof (int))

Secondo C99 se la dimensione passato a malloc è 0, un runtime C può restituire un puntatore nullo o l'assegnazione si comporta come se la richiesta è per non zero allocazione, tranne che il puntatore restituito non dovrebbe essere dereferenziato. Così è implementazione definita (ad esempio alcune implementazioni restituiscono un buffer di lunghezza zero) e nel tuo caso non si ottiene un back puntatore NULL, ma si utilizza un puntatore non si dovrebbe essere using.If si prova in un tempo di esecuzione diverso voi potrebbe ottenere un back puntatore NULL.

Answer 6

Quando si chiama malloc () di un piccolo pezzo di memoria è scavata una pagina più grande per te.

    malloc(sizeof(int));

realtà non alloca 4 byte su una macchina a 32 bit (l'allocatore pad fino ad una dimensione minima) + dimensione dei metadati mucchio utilizzati per monitorare il pezzo attraverso la sua vita (blocchi sono collocati in contenitori base alle loro dimensioni e marcato in uso o libero dal allocatore). hxxp: //en.wikipedia.org/wiki/Malloc o più specificatamente hxxp:. //en.wikipedia.org/wiki/Malloc#dlmalloc_and_its_derivatives se stai prove su Linux

Quindi, la scrittura oltre i limiti del tuo pezzo non significa necessariamente che si sta per bloccarsi. A p + 5000 non si sta scrivendo di fuori dei limiti della pagina allocata per quel pezzo iniziale in modo che si sta tecnicamente scrivendo a un indirizzo mappato valido. Benvenuti alla corruzione della memoria. http://www.google.com/search?sourceid=chrome&ie = UTF-8 & q = mucchio + overflow

Answer 7

La nostra CheckPointer strumento in grado di rilevare questo errore. Si sa che l'assegnazione di p era di un pezzo di 4 byte, e quindi l'assegnazione, è al di fuori dell'area per la quale è stato allocato p. Si dirà che il p [500] Assegnazione è sbagliato.