passando char buffer para funções e obter o tamanho da memória intermédia

Question

Tenho posto o tampão ao tamanho 100. I exibir o tampão na função principal onde o tampão é declarada. No entanto, quando eu passar o buffer para a função e obter o sizeof '4', Eu estava pensando que deve ser de 100, como é que o tamanho do buffer que eu criado em principal. resultado: tamanho da memória intermédia: 100 sizeof (tampão): 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

Está usando o tamanho do ponteiro para o tampão de bytes (4), em vez do que o tamanho do tampão.

Em C, você tem que passar o tamanho do buffer separadamente, o que é parte da razão estouros de buffer acontecer tão facilmente e com frequência.

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

Answer 2

As respostas por Mitch Trigo e hhafez está completamente certo e direto ao ponto. Vou mostrar alguma informação adicional que pode ser, por vezes úteis.

Note que o mesmo acontece se você dizer ao compilador que você tem uma matriz do tamanho certo

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

Uma matriz como parâmetro é apenas declarando um ponteiro. O compilador muda automaticamente que a char *name mesmo se ele foi declarado como char name[N].

Se você quiser forçar o interlocutor para passar uma matriz de tamanho único 100, você pode aceitar o endereço da matriz (e do tipo de que) em vez disso:

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

É um ponteiro para a matriz que você tem em principal, então você precisa excluir a referência na função para obter o array. Indexação, em seguida, é feito por

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

Ninguém que eu conheça está fazendo isso e eu estou nem fazendo isso sozinho, porque em vez complica a passagem do argumento. Mas é bom saber sobre isso. Você pode chamar a função como esta, em seguida,

load_buffer(&buffer)

Se você quiser aceitar outros tamanhos também, eu iria com a opção passing-N as outras duas respostas recomendar.

Answer 3

A partir do OP

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

Mesmo que você pode imaginar que load_buffer() é passado o buffer por refrence, o que realmente está acontecendo é que você está passando um ponteiro para char por valor. A matriz real não é passado por isso não há maneira para a função load_buffer() conhecer o tamanho da matriz de tampão

Então, o que é sizeof(buffer) fazendo? É simplesmente devolver o tamanho de um ponteiro para caractere. Se load_buffer() precisa o tamanho do buffer ele precisa ser passado speratly.

Ou você pode criar uma nova estrutura que contém uma matriz de char eo tamanho da matriz, e passar um ponteiro para esse struct em vez disso, dessa forma o buffer e o seu tamanho são sempre juntos;)

Answer 4

O que acontece, é quando você passar um array para uma função, você só passar o endereço da matriz na memória, e não o tamanho da matriz. O sizeof (tampão) é a saída em load_buffer () representa o tamanho do ponteiro, o qual é de quatro bytes.

A melhor maneira de manter o tamanho do buffer na função é mudar a função para:

void load_buffer(char *buffer, int length);

e a chamada para:

load_buffer(buffer, sizeof(buffer));

e, em seguida, usar comprimento sempre que você quer o tamanho do buffer.