C: Función que regresa a través de void *

Question

Viniendo de Java, estoy confundido por el uso de Void que permite un valor de retorno en lo siguiente:

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

¿Esto devuelve un puntero a una tirada de memoria asignada?

Answer 1

Sí, lo es. Un puntero nulo * es básicamente un puntero genérico a una dirección de memoria, que luego podría ser tipificado al tipo que realmente se desea.

Answer 2

Su pregunta indica que está leyendo mal el tipo de retorno de la función. Hay una gran diferencia entre:

void foo( void ) {}

y

void *bar( void ) {}

foo () no toma argumentos y no devuelve un valor, mientras que bar () no toma argumentos y devuelve un puntero genérico. En C, la palabra clave void se usa para indicar un puntero genérico, y un objeto de tipo void * se puede convertir a cualquier otro tipo de puntero de objeto sin pérdida de información.

Answer 3

Sí, esta función está devolviendo un puntero a la memoria asignada de un tamaño especificado. Es diferente en malloc en el sentido de que está garantizado que devolverá un puntero. Si falla, saldrá de la aplicación.

Answer 4

Sí void * significa puntero a algo, pero de ningún tipo en particular.

Answer 5

void significa esencialmente ningún tipo, entonces si tenemos void * p; p es un indicador de algo, pero no hemos dicho qué.

void sin puntero no es nada, por lo tanto void foo (void) es una función que no toma argumentos y no devuelve nada.

Y sí, malloc devuelve un puntero a un trozo de memoria, malloc no sabe ni le importa qué tipo tiene esa memoria, por lo que su tipo de retorno es nulo *

Answer 6

En Java no hay aritmética de puntero. Piensa que esto es lo que estás preguntando. Por ejemplo, imagine que malloc devuelve un puntero de tipo int

int* malloc(size_t size)
{
    //
}

Posiblemente recibiría el puntero, que es básicamente un puntero a un array . Luego lo indexaría como matrices regulares.

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

El problema es que C no tiene funciones de sobrecarga. Entonces, tenemos que encontrar una manera de escribir un malloc genérico. De lo contrario, terminaría con un malloc diferente para cada tipo. La solución es enviar la cantidad requerida de bytes que necesita. Luego, puede indexarlo como desee. Esto proporciona una mayor flexibilidad y una solución para todos.

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)

Entonces, la idea es que no importa cómo indexamos la memoria que obtuvimos de malloc . Todo lo que tenemos que hacer es especificar el tipo de matriz recién creada para indexarla correctamente. void * significa que este es un puntero para colocar en la memoria que no hemos especificado cómo indexar.