Quote:Original post by MaulingMonkey

Quote:Original post by fpsgamer

Quote:Original post by TheTroll
Read 6.3.

"A reference to an object of type array-of-T which appears in an expression decays (with three exceptions) into a pointer to its first element; the type of the resultant pointer is pointer-to-T. "

theTroll

The key phrase in that quote is "decays to".

Indeed (emphasis added in the original quote). Decays does not mean "is", it means "is implicitly convertable to". This can be an important distinction -- for example, trying to cast a pointer to an array of int:

int array[3];int (*ptr_to_array)[3] = &array

into a pointer to a pointer to an int:

int ** ptr_to_ptr = (int**)ptr_to_array;// Note that the above won't compile without the explicit cast.

And then using that pointer yields undefined behavior. And no, I'm not talking "in theory", I'm talking about in practice almost certainly having a crash at best:

// Compiled with MSVC2008 and executed on a typical x86 box:array[0]        = 42; // This works fine, defined behaviorptr_to_array[0] = 42; // This works fine, defined behaviorptr_to_ptr[0]   = 42; // This generates an Access violation writing location 0x0000002a (42)                      // (it tried to treat the integer value stored at array[0] as an address)                      // (Yes, this statement invoked undefined behavior)

Quote:Original post by DevFred

Quote:Original post by gharen2
Personally, I wish more classes taught about pointers early.

The problem is: IMHO there are no simple examples where pointers make sense (without arrays and dynamic allocation), except for emulating pass by reference (by passing pointers by value). Maybe you have a good example?

I have seen way too many introductions to pointers using code like this:

int i = 3;int *p = &i*p = 5;assert i == 5;

And almost everyone immediately asks themselves "Why the hell would I want to do that? Why not just i = 5; ?". Poor examples like these are the reason for countless "What's the use of pointers?" threads on gamedev.

I think I am going to introduce pointers as a means to implement a swap function, although I am not completely satisfied with that.

Quote:Original post by Iftah
Actually I think there is something wrong with your second example also: you are assigning an int into an array of 3 ints.

Quote:As for the 3rd example, it will work if you wrote ptr_to_ptr[0] = (int*)42 right?

Quote:"Pointers are basically integers holding addresses.

Quote:Original post by MaulingMonkey

Quote:As for the 3rd example, it will work if you wrote ptr_to_ptr[0] = (int*)42 right?

In this case, on my platform, yes. However, since both invoke undefined behavior, it'd be entirely valid for your compiler to make your program do something different.

Quote:

Quote:"Pointers are basically integers holding addresses.

To be anal retentive, far pointers in the x86's 16-bit segmented model mode are a good counterexample of a case where pointers aren't integers at all (but rather a pair of them combined in a bizarre fashion), but I agree with the rest of your point.

Quote:Original post by Iftah
Thanks.

Quote:

Quote:As for the 3rd example, it will work if you wrote ptr_to_ptr[0] = (int*)42 right?

In this case, on my platform, yes.
Uhg, I'm really talking out of my ass tonight. On my platform, the 3rd line, with my updated snippet, behaves similarly to:

(*(int*)((*ptr_to_array)[0])) = 42;
or:
(*(int*)(array[0])) = 42;
or:
*((int*)42) = 42;
However, since both invoke undefined behavior, it'd be entirely valid for your compiler to make your program do something different.

Quote:Original post by MaulingMonkey
On my platform, the 3rd line, with my updated snippet, behaves similarly to:

(*(int*)(array[0])) = 42;
or:
(*(int*)((*ptr_to_array)[0])) = 42;

However, since both invoke undefined behavior, it'd be entirely valid for your compiler to make your program do something different.

Quote:Original post by DevFred

Quote:Original post by TheTroll
An array in C is really just a pointer to the first value of the array

No.

Quote:Original post by MadKeithV
A pointer-to-int and an array-to-int are nearly indistinguishable in memory except for the level of indirection. The array points to a memory location where integer values are stored, the pointer points to an address that points to a memory location where an integer value is stored.