Thread: & operator

Hello,

I have the following program and I observe that the f function prints different values on its two calls. The correct result is the second one.
Can anyone explain me please, exactly what the & operator does?

Thank you

Code:

#include <stdio.h>
int m[5][5];

void f(int** v){
	printf("*v=%p v=%p\n",*v,v);
}

int main(){
	printf("m[4]=%p\n",m[4]);
	f(&m[4]);
	int*ptr = m[4];
	f(&ptr);
	return 0;
}

Originally Posted by DeadPlanet

& is the address-of operator. Is supplies the address of the variable that it prefixes.

All variables are held in memory somewhere, so the & operator returns that address.

Please run the program first. I know what the & operator should do, but it fails in this case and I wonder why.
I suppose this happens because m[4] is a kind of a constant, and doesn't have an address. So &m[4] returns m[4] instead of it's address.
However it doesn't sound like a complete explanation.

PS It could be useful to mention that I compiled this program using gcc.

Wait, what's that?! Oh look, the SUN machines here at work here return the offset, and not the address when I use the & operator!

Ok, my apologies. I'm man enough to admit when I am wrong. Nothing like a little humility though.

EDIT: For clarification, I know that EVOEx also proved me wrong, the 'tone' of that post just didn't seem to require a reply.

Originally Posted by stef8803

Please run the program first. I know what the & operator should do, but it fails in this case and I wonder why.
I suppose this happens because m[4] is a kind of a constant, and doesn't have an address. So &m[4] returns m[4] instead of it's address.
However it doesn't sound like a complete explanation.

PS It could be useful to mention that I compiled this program using gcc.

Without reposting what you wrote, you did this

Code:

void*ptr = m[4];

In C, m is declared as an array of arrays so the type of m[4] is actually int[5]. If the above statement did not trigger a complaint from the compiler it is because the expression m[4] idecayed to a pointer type from its array type. I'm actually not sure if this is proper C, but in any event, your function call f(&ptr); worked because you created a temporary pointer. You could do probably also do this.

Code:

f( (void**)&m[4] );

Or, you might also be able to change the pointer type to int (*v)[5] in function f.

Code:

int main (void)
{
   int m[5][5] = { {0, } };
   int (*v)[5] = &m[4];
   printf ("address of v is %p\n" , (void*)v);
   /*..*/
   return 0;
}

Also %p is the format specifier for pointer addresses. Technically speaking, %x is for hex values even if it's the same difference.

Originally Posted by DeadPlanet

Ok, my apologies. I'm man enough to admit when I am wrong. Nothing like a little humility though.

You're not wrong about unary & being the address-of operator though. The offset that Overworked_PhD mentions is an address with respect to C.

Originally Posted by stef8803

I can't understand why &m[4] doesn't get the address of m[4].
As you can observe, when calling f(&m[4]), v is equal to m[4] and not *v, as it should be in my opinion.

If you are talking about the original snippet that you posted, then you should take note of what whiteflags stated: the type of &m[4] is not int**, but int (*)[5].

Originally Posted by Overworked_PhD

There are some platforms at work where the offset really isn't the address. And yes, these are conforming C compilers since the ANSI/ISO standard speaks of pointers in terms of objects and not addresses.

What the standard speaks is:

Originally Posted by C99 Section 6.5.3.2 Paragraph 3

The unary & operator returns the address of its operand.

But as I said, this is just from the perspective of C, so you are otherwise correct.