Thread: pointers and arrays: my compiler complains

Hi guys...as you can see I have a lot of questions about C...
Today I was changing my functions and I got complains from the compiler. This is the question: I have a function that takes one argument, a pointer, i.e.

Code:

void foo(double *wof)

Now I want to use foo in main

Code:

int main()
{
      double array[10];
      foo(&array);
}

my compiler says " warning: passing argument 1 of ‘foo' from incompatible pointer type", but the program is working. I cannot understand why because, as far as I know, passing &array means that I am pointing at the first place of array, i.e. array[0].

"array" itself is an array and, with that, a pointer. So array itself is of type "double*" (well, strictly speaking, they are slightly different, but an array can be used as a pointer).

So you should simply use "array". Or, "&array[0]". While the two are identical, in some cases I find the latter more readable (although this would not be one of them).

solved! Usually I compile with this
gcc -std=gnu99 -shared ...
but keeping the default standard
gcc -shared ...
the compiler does not complain anymore
Actually I do not know what is the default value

Originally Posted by EVOEx

"array" itself is an array and, with that, a pointer. So array itself is of type "double*" (well, strictly speaking, they are slightly different, but an array can be used as a pointer).

So you should simply use "array". Or, "&array[0]". While the two are identical, in some cases I find the latter more readable (although this would not be one of them).

mmmhh, actually if I put array the program is working (with std=gnu99)...well I have discovered something new.
Thanks a lot!

oh, now is very clear why this "trick" is not working with scalars :-) (but actually they also have a memory address...). Thanks a lot! Now I can save a lot of lines in my codes

Code:

  foo(&array);

It's wrong even if it's working.

Originally Posted by Bayint Naung

Code:

  foo(&array);

It's wrong even if it's working.

indeed..I have changed it with foo(array) :-)

Originally Posted by violatro

I cannot understand why because, as far as I know, passing &array means that I am pointing at the first place of array, i.e. array[0].

Perhaps if you print out the locations of array and &array it might become clear

Originally Posted by itCbitC

Perhaps if you print out the locations of array and &array it might become clear

very wise suggestion!

Code:

int main()
{

	int array[2], scalar;
	printf("%p %p\n",&array,&array[0]); 
	printf("%p %p\n",array,&array);
}

thanks! now it is also clear why with scalars it is not working :-)

Originally Posted by Elysia

They will probably be the same...
array decays to double*.
However, &array is of type (double*)[10].
Different types. Strictly speaking, the only difference is when you use the ++ operator. In the first case, it will step ahead one element. In the second case, it will jump ahead one array (ie 10 elements in this case).

That would be correct in main(), but since &array is passed to foo() that takes a double* argument, it gets cast to double*.
Now when the increment / decrement operators are used in foo() the step size == sizeof(double) due to the implicit cast.

array == pointer to double
&array == pointer to an array of 10 doubles
foo(&array) --> foo((double*) &array)