incompatible pointer type warning

Question

I have a C program like the one below. I am trying to write a wrapper on top of malloc with the signature int myAlloc(). This wrapper should return 1 on a successful memory allocation or return 0 if memory allocation fails.

#include <stdio.h>
#include <stdlib.h>

int myAlloc(void **ptr, int size)
{
    *ptr = malloc(size);

    if (!ptr)
        return 0;
    else
        return 1;
}

void main()
{
    int *p = NULL;
    myAlloc(&p, sizeof(int));
    printf("%d\n", *p);
}

When I compile this I get a warning saying "incompatible pointer type". How can I make it possible for this function to be called with any possible pointer type without receiving the warning?

Is it possible to remove the casting operation from the actual function call?

Update

I found the answer. Here is corrected code:

#include <stdio.h>
#include <stdlib.h>

int myAlloc(void *ptr,int size)
{
    *(void **)ptr = malloc(size);

    if (!ptr)
        return 0;
    else
        return 1;

}

int main()
{
    int *p = NULL;
    myAlloc(&p, sizeof(int));
    *p = 5;
    printf("%d\n", *p);

    return 1;
}

Answer 1

your function, myMalloc takes a pointer to a pointer to void, or void** you are passing it the address of a pointer to an int, or int**

You need to cast the pointer you pass to be void eg

myAlloc((void**)&p,sizeof(int));

Answer 2

The actual error I see -- which may not be the same as yours; we can't know, since you neglected to show us the actual output -- looks like this:

src.c: In function ‘main’:
src.c:15:17: warning: passing argument 1 of ‘myAlloc’ from incompatible pointer type [enabled by default]
src.c:4:5: note: expected ‘void **’ but argument is of type ‘int **’

You're passing your myAlloc function an int ** variable, but your function is written to accept a void ** variable. You can cast the pointer type in the function call like this:

myAlloc((void **)&p,sizeof(int));

And now it compiles without warnings.

You may want to read the pointers section of The C Book, especially section 5.3.5, which explicitly addresses some of the issues raised here.

Answer 3

This may seem interesting academically, but isn't your internal code in the wrapper doing the same type of boolean check?

void *ptr;
if( (ptr = malloc(1000)) )
{
  /* Do stuff with ptr */
}
else
{
  /* throw a tantrum */
}

Do you really need the int return code with the extra parameter complexity?

Answer 4

In C, there is a void* type for general pointer, but there is not a type for general pointer to pointer. Even worse, the size of different types of pointers may not be equal. Hence, if your function doesn't know what type of pointer it should assign, it cannot just "put the data in the address", because the size of the right pointer may be different from the size of the pointer it assign.

For example, your code may crash (and is UB) if sizeof(int*)<sizeof(void*).

Because of this, I think that it's impossible to write a wrapper like you want.

Answer 5

There's no way to write such a function in standards-compliant C as int * and void * are not compatible types.

A (mostly) equivalent macro definition could look like this:

#define myAlloc(PTR, SIZE) (!!(PTR = malloc(SIZE)))

Answer 6

#include <stdio.h>
#include <stdlib.h>

int myAlloc(void *ptr,int size)
{
    *(void **)ptr=malloc(size);
    if(!ptr) return 0;
    else return 1;

}

int main()
{
    int *p=NULL;
    myAlloc(&p,sizeof(int));
    *p=5;
    printf("%d\n",*p);
    return 1;
}

Answer 7

p is type int*, while your function accepts void**.

myAlloc((void **)&p,sizeof(int));

Answer 8

As per the signature of myAlloc, you should call it with myAlloc((void**)&p,sizeof(int)) since p is int* (ptr to int) and not void* (ptr to void).

Answer 9

OT: There is a bug in your code. You probably want:

   if(!(*ptr)) return 0;