passando il buffer dei caratteri alle funzioni e ottenendo le dimensioni del buffer

Question

Ho impostato il buffer sulla dimensione 100. Visualizzo il buffer nella funzione principale in cui è dichiarato il buffer. Tuttavia, quando passo il buffer alla funzione e ottengo la dimensione "4", Stavo pensando che dovrebbe essere 100, poiché quella è la dimensione del buffer che io creato in principale.     produzione:     dimensione del buffer: 100     sizeof (buffer): 4

#include <string.h>
#include <stdio.h>

void load_buffer(char *buffer);

int main()
{
    char buffer[100];
    printf("buffer size: %d\n", sizeof(buffer));
    load_buffer(buffer);

    return 0;
}

void load_buffer(char *buffer)
{
    printf("sizeof(buffer): %d\n", sizeof(buffer));
}

Answer 1

Stai utilizzando la dimensione del puntatore al buffer (4 byte), piuttosto che la dimensione del buffer.

In C, devi passare le dimensioni del buffer separatamente, il che fa parte del motivo per cui i sovraccarichi del buffer si verificano così facilmente e frequentemente.

void load_buffer(char * buffer, size_t bufSize)
{    
    ...
}

Answer 2

Le risposte di Mitch Wheat e Hhafez sono assolutamente giuste e pertinenti. Mostrerò alcune informazioni aggiuntive che a volte potrebbero rivelarsi utili.

Nota che lo stesso accade se dici al compilatore che hai un array della giusta dimensione

void load_buffer(char buffer[100]) {
    /* prints 4 too! */
    printf("sizeof(buffer): %d\n", sizeof(buffer));
}

Un array come parametro sta semplicemente dichiarando un puntatore. Il compilatore lo modifica automaticamente in char * name anche se è stato dichiarato come char name [N] .

Se vuoi forzare i chiamanti a passare solo un array di dimensioni 100, puoi invece accettare l'indirizzo dell'array (e il suo tipo):

void load_buffer(char (*buffer)[100]) {
    /* prints 100 */
    printf("sizeof(buffer): %d\n", sizeof(*buffer));
}

È un puntatore all'array che hai in main, quindi devi dereference nella funzione per ottenere l'array. L'indicizzazione viene quindi eseguita da

buffer[0][N] or (*buffer)[N]

Nessuno che conosco lo stia facendo e non lo sto facendo nemmeno io, perché complica piuttosto il superamento dell'argomento. Ma è bene saperlo. Puoi chiamare la funzione in questo modo quindi

load_buffer(&buffer)

Se vuoi accettare anche altre dimensioni, sceglierei l'opzione N-passaggio che le altre due risposte raccomandano.

Answer 3

Dall'OP

void load_buffer(char *buffer)
{
    printf("sizeof(buffer): %d\n", sizeof(buffer));
}

Anche se puoi immaginare che load_buffer () abbia passato il buffer per riferimento, ciò che sta realmente accadendo è che stai passando un puntatore a char per valore. L'array effettivo non viene passato, quindi non è possibile per la funzione load_buffer () conoscere la dimensione dell'array buffer

Quindi cosa sta facendo sizeof (buffer) ? Sta semplicemente restituendo la dimensione di un puntatore al carattere. Se load_buffer () necessita della dimensione del buffer , deve essere passato con speranza.

Oppure puoi creare una nuova struttura che contiene sia una matrice di caratteri che la dimensione della matrice e passare invece un puntatore a quella struttura, in questo modo il buffer e le sue dimensioni sono sempre insieme;)

Answer 4

Quello che succede è quando si passa un array a una funzione, si passa solo l'indirizzo dell'array in memoria, non la dimensione dell'array. Quale sizeof (buffer) viene generato in load_buffer () è la dimensione del puntatore, che è di quattro byte.

Il modo migliore per mantenere la dimensione del buffer nella funzione è cambiare la funzione in:

void load_buffer(char *buffer, int length);

e la chiamata a:

load_buffer(buffer, sizeof(buffer));

e quindi utilizzare la lunghezza ogni volta che si desidera la dimensione del buffer.