C: Função retornando via void *

Question

Vindo de Java Eu estou confuso com o uso de vácuo permitindo um valor de retorno da seguinte:

void *emalloc(size_t s) {  
    void *result = malloc(s);  
    if (NULL == result) {  
        fprintf(stderr, "MEMORY ALLOCATION FAILURE\n");  
    exit( EXIT_FAILURE );  
    }  
    return result;  
}  

É este retornando um ponteiro para um mandril de alocada de memória?

Answer 1

Sim, é. Um ponteiro void * é basicamente um ponteiro genérico para um endereço de memória, que poderia então ser tipicamente typecast para qualquer tipo foi realmente desejado.

Answer 2

Sua pergunta indica que você está interpretando mal tipo de retorno da função. Há uma grande diferença entre:

void foo( void ) {}

e

void *bar( void ) {}

foo () não tem argumentos e não retorna um valor, enquanto bar () não tem argumentos e retorna um ponteiro genérico. Em C, a palavra-chave void é usado para indicar um ponteiro genérico, e um objeto do tipo * vazio pode ser convertido para qualquer outro tipo de ponteiro objeto sem perda de informação.

Answer 3

Sim, esta função está retornando um ponteiro para a memória alocada de um tamanho especificado. É diferente em malloc no sentido de que é garantido para retornar um ponteiro. Em caso de falha que vai sair do aplicativo.

Answer 4

Sim. void* significando ponteiro para alguma coisa, mas de nenhum tipo particular.

Answer 5

meio vazios essencialmente nenhum tipo, por isso, se temos void * p; p é um ponteiro para alguma coisa, mas não disse o quê.

vazio sem um ponteiro não é nada foo daí void (void) sendo uma função que não recebe argumentos e retorna nada.

E retorna sim malloc um ponteiro para alguns pedaço de memória, malloc não sabe ou cuidado que tipo de que a memória tem, por isso é tipo de retorno é void *

Answer 6

Em Java não há aritmética de ponteiro. Ele acha que isso é o que você está perguntando. Por exemplo, imagine que malloc retorna um ponteiro do tipo int

int* malloc(size_t size)
{
    //
}

Você possivelmente iria receber o ponteiro, que é basicamente um ponteiro para um array. Então você teria que posicioná-lo como matrizes regulares.

int* arr = malloc(10 * sizeof(int)); // 10 contiguous int(s).

O problema é que C não tem funções de sobrecarga. Então, nós temos que encontrar uma maneira de escrever uma malloc genérico. Caso contrário, você iria acabar com um malloc diferente para cada tipo. A solução, é enviar o número necessário de bytes que você precisa. Depois, você pode posicioná-lo como quiser. Isto dá uma flexibilidade maior e um para toda a solução.

int*  i = (int*)malloc(10 * sizeof(int)); // 40 bytes if int = 4 bytes
char* c = (char*)malloc(10 * sizeof(char)); // 10 bytes if char = 1 byte

int  thirdElement = i[3]; // third element. 12 bytes away from (*i)
char secondElement = c[2]; // second element. 2 bytes away from (*c)

Assim, a idéia é que não importa como indexamos a memória que temos a partir malloc. Tudo o que temos a fazer é especificar o tipo da matriz recém-criado para posicioná-lo corretamente. meios void* que este é um ponteiro para o local na memória que não tenha especificado como índice.