Thread: warning: passing argument 1 of 'foo' from incompatible pointer type

I am doing experiements with code to understand pointer

Code:

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


void foo ( int *p)
{
	int *q = malloc(sizeof(*q));
	if ( q != NULL )
	{


	}	  
 }
int main ()
{


  int *p = NULL;
  
  foo (p);
  
  return 0;
}

This code compile without warning. Program pass the content of pointer p

When I change line to pass location of pointer variable P I get warnings

Code:

  foo (&p);

warnings

Code:

 hello.c:17:8: warning: passing argument 1 of 'foo' from incompatible pointer type [-Wincompatible-pointer-types]   foo (&p);
        ^
hello.c:4:6: note: expected 'int *' but argument is of type 'int **'
 void foo ( int *p)

I want to understand why this warning generates and why it resolve by declearing double pointer

Did you read the warning message?

expected 'int *' but argument is of type 'int **'

Originally Posted by G4143

Did you read the warning message?

I want to understand why this warning resolve by declearing double pointer

Think of a pointer as a normal integer variable... If you do:

Code:

void f(int x) { x = 1; }
...
int a = 3;
f(a);

a isn't modified, isn't it?

If you do:

Code:

void f(int *p) { p = malloc(4*sizeof(int)); }

And you do:

Code:

int *q;

f(q);

q won't be modified either...
But if you do:

Code:

void f( int **p )
{ *p = malloc( 4 * sizeof(int) ); }
...
int *q;

f(&q);

q is an object which holds the address of another... &q is the address of an object which holds the address of another. You are changing the address which q holds, not q it self.

In C, the address-of operator creates a pointer. That is, if you declare

Code:

    typedef ... Foo;

    Foo   foo_var;

    Foo * foo_ptr = &foo;

The last line will compile perfectly well because they type of foo_ptr is Foo *, and the combination of foo_var being type Foo and the & operator taking the address yields a Foo *.

If you tell the compiler that a function takes a pointer to some type, it doesn't care how you generate the pointer. But it does verify that what you are passing is the correct type.

You can declare a variable that holds pointers (Foo * foo_ptr) and pass the value of that variable. Or you can declare a variable that does not hold a pointer, and take the address of it (Foo foo_var; ... &foo_var ...). Or, you could declare a double-pointer and dereference it (Foo ** foo_2ptr; ... *foo_2ptr ...). You could even take something completely wrong, and (cast) it to the right type. All of those expressions produce a value that has type Foo *, which is what the compiler cares about.

Now in your example, you declared a function foo that takes an int * parameter. So you are obligated to pass in values that have type int *. You can produce the int * by any means you like. The compiler is just going to check that what you produce has the correct type.

Code:

    extern void foo(int *);

    int
    main(void)
    {
        int ival = 0;

        foo(&ival);      // take the address of an int

        int * iptr;

        foo(iptr);       // Pass an int* directly


        int **idp;

        foo(*idp);      // Dereference a double-pointer to yield a single-pointer
        foo(idp[3]);

 
        char name[] = "George";

        foo((int*)name);    // Use an explicit cast. This works, but you had better know EXACTLY what you're doing.
    }

Originally Posted by Dadu@

I am doing experiements with code to understand pointer

Code:

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


void foo ( int *p)
{
	int *q = malloc(sizeof(*q));
	if ( q != NULL )
	{


	}	  
 }
int main ()
{


  int *p = NULL;
  
  foo (p);
  
  return 0;
}

This code compile without warning. Program pass the content of pointer p

When I change line to pass location of pointer variable P I get warnings

Code:

  foo (&p);

warnings

Code:

 hello.c:17:8: warning: passing argument 1 of 'foo' from incompatible pointer type [-Wincompatible-pointer-types]   foo (&p);
        ^
hello.c:4:6: note: expected 'int *' but argument is of type 'int **'
 void foo ( int *p)

I want to understand why this warning generates and why it resolve by declearing double pointer

Please study the code below, that hopefullly will explain the error message you received:

Code:

#include <stdio.h>

// foo() is a function that takes a pointer to an int, or simply,
// the address of an int, passed by value
void foo(int *p);  // I always prototype all my functions

int main(void)
{
   int a = 123; // Always initialize all your local variables,
                // to some legitimate value, or 0!

   // ptr is a pointer varaible that will contain the address
   // of an int, in this case, the address of the variable, a.
   int *ptr = &a;

   printf("Address of a: %p\n", (void *)&a);
   printf("  Value of a: %d\n\n", a);

   printf("Address of ptr: %p\n", (void *)&ptr);
   printf("  Value of ptr: %p\n\n", (void *)ptr);

   // foo() may be called passing the address of a. An int *
   foo(&a);

   // Or foo() may be call with the pointer, ptr, or the address
   // value containd within ptr, the address of a, Also an int *
   foo(ptr);

   // foo() may NOT be called with "&ptr"!!!
   // You are attempting to pass the address of ptr, NOT the
   // address contained within ptr! &ptr is a int **,
   // A pointer to a pointer to an int!!!  Which explains the
   // warning message yopur received.
   // foo(&ptr);

   return 0;
}

void foo(int *p)
{
   printf("Inside foo(), Address of the local variable, p: %p\n", (void *)&p);
   printf("Inside foo(), Address passed through p: %p\n", (void *)p);
   printf("Inside foo(), Value of value pointed to by p: %d\n\n", *p);
}

You really need to study one of the three books I recommended to you earlier. A good up-to-date book on C will thoroughly explain pointers, the most difficult topic in learning C, along with so much more that you need to program in C! I can't emphasize this enough!