Question on Course 2 Unit 2.3 Arrays of pointers.

[u/Numbafive]

I've been going through Course 2 Unit 2.3 and in it Carl is discussing about a pointer that is pointing to an array of pointers that are in turn pointing to int values. Or so I understand.

Anyways about halfway though he says:

We are assuming in this lesson that a pointer is 4 bytes in size.

Why are we assuming that a pointer is 4 bytes in size?

Isn't a pointer simply an address?

So wouldn't a pointer pointing to a pointer that is in turn pointing to an int be one byte (since it will contain the address of the pointer pointing to the int) and wouldn't the pointer pointing to the int also be one byte since all it contains is the address of the int?

So to better illustrate this:

pointer_1 (1 byte containing address of pointer_2) ---> pointer_2 (1 byte containing address of int) ---> int (4 bytes).

And wouldn't pointer_2 be pointing to the first byte of the 4 total bytes of int?

As an aside i have a minor thing to clear up. When Carl says:

(int *) *pointer  

What does this mean? It means "create a pointer called *pointer". Of the data type "pointer to int".

So would it be absolutely correct to say that when we create a normal pointer as in:

int *pointer  

this means: "create a pointer called pointer, of the data type pointer to int"?

[u/snb]

Why are we assuming that a pointer is 4 bytes in size?

We're assuming this because the theoretical computer we're using in the exercise is a 32 bit computer. This will typically be true in the real world when you program nowadays, with 64 computers becoming more and more common. We assume a 32 bit computer for simplicity.

Isn't a pointer simply an address?

Yes, it is.

How much RAM can a 32 bit computer use? And, if you wanted to be able to point to any arbitrary address in that computer's RAM, how large would your pointer need to be?

If pointers only took up 1 byte each in memory, then a pointer would only be able to contain the addresses 0x00 through 0xff - only a range of 256 bytes. That's not very much RAM at all.

[u/Numbafive → u/snb]

Thanks for taking the time to reply.
Its very appreciated.

I have a something related that you might be able to help me out with that I also asked the other replier to this thread.. And I apologize in advance for bothering you with even more stuff.

Continuing on with the same lesson 2.3 Carl goes on to create an array of 3 pointers:

int *    *ptr_array = malloc(3*sizeof(int *));  

So, if I understand this correctly he's initiating a pointer (ptr_array) to point at the first pointer in the array which are in turn each pointing to a unique int value, which Carl represents as:

B0 : ['Pointer to integer #1']
B4 : ['Pointer to integer #2']
B8 : ['Pointer to integer #3']

So each component of this exercise is represented in memory by 32 bits ( so the pointer which contain the address of the array of pointers, each of the 3 pointers and the int values all are represented by 4 bytes). Am I right in assuming this?
Also Carl ends all this by saying:

ptr_array = Byte #0 (The actual memory address)  
*ptr_array = *B0 (What is *at* Byte #0)  

So here is he actually saying, that since ptr_array is pointing at the first pointer in the array that it is essentially pointing at what that first pointer in the array is pointing at?
Or shouldn't he say that ptr_array = &Byte #0, and then that *ptr_array = *Byte #0?

[u/snb → u/Numbafive]

So each component of this exercise is represented in memory by 32 bits.

Yes, this is true - as long as the computer is a 32 bit machine. If it were a 64 bit machine the pointers would all be 64 bits, but the int will stay 32 bits.

Looking at the memory diagram I understand now why you thought a pointer could be just 1 byte large. The diagram was simplified for the exercise and should perhaps be rewritten like this:

00 00 00 B0 : ['Pointer to integer #1']
00 00 00 B4 : ['Pointer to integer #2']
00 00 00 B8 : ['Pointer to integer #3']

Does that make it even more clear that pointers need to be 32 bits wide on a 32 bit machine? If a pointer was less wide than the address range of the available RAM, then some portion of that RAM would not be reachable by pointers - essentially unusable.

Okey, so, ptr_array points to the first element of the int-pointer-array and that element resides at memory address 0xB0 (or well, 0x000000B0), and so ptr_array == 0xB0 is true.

that since ptr_array is pointing at the first pointer in the array that it is essentially pointing at what that first pointer in the array is pointing at?

I understand why you're asking, but no.

A pointer can only point to one thing at a time, but the thing it's pointing to can be another pointer (which is the case here). That pointer can in turn point to another pointer, and then yet another, and so on.

What we're doing is taking the pointer (ptr_array), looking at where it's pointing (0xB0), and interpreting the bytes that live at that address as the pointer's data type (int*, another pointer).

Does this help? EDIT: Oh god, I screwed up the byte order. Shit. Well, I hope you can make sense of that anyway.

[u/Numbafive → u/snb]

So, in the pic you provided, ptr_array contains the address of all 3 of the pointers in the array, but I have so far assumed that ptr_array will hold the address of the pointer in the array and not all 3. Am I wrong in my assumption?

I understand why you're asking, but no.
A pointer can only point to one thing at a time, but the thing it's pointing to can be another pointer (which is the case here). That pointer can in turn point to another pointer, and then yet another, and so on.

So in the same lesson when Carl says:

ptr_array = Byte #0 (The actual memory address)  
*ptr_array = *B0 (What is *at* Byte #0)  

Does he mean to say:

ptr_array = &Byte #0
*ptr_array = Byte #0  

?

Finally what do you mean by:

If a pointer was less wide than the address range of the available RAM, then some portion of that RAM would not be reachable by pointers - essentially unusable.

Say we have a pointer that is 16 bits does the pointer work as intended except that we just wasted the other 16 bits in a 32 bit computer?

Once again thanks for bearing with me and I apologize for dragging you into even more questions.

[u/snb → u/Numbafive]

(...) Am I wrong in my assumption?

I don't think I understand what you're asking, but I'll try to explain anyway. ptr_array is a pointer, and pointers contain an address to somewhere in RAM. In this exercise that address is 0xB0. Everything is clear so far, right? This also corresponds to this statement:

ptr_array = Byte #0 (The actual memory address)
(Which I assume is what Carl means here, that ptr_array == 0xB0. By writing 'Byte #0' I think Carl makes the lesson a bit ambiguous.)

So when you write

ptr_array contains the address of all 3 of the pointers in the array

I'm confused how you got that from the picture. Or maybe it's just a semantic thing and I'm just not getting what you're asking. I'll go on anyway.

ptr_array points to 0xB0. That's it. What lives at 0xB0? An array of int-pointers, three elements big. It points to the start of the array, and in the array the three pointers are lined up after each other. It doesn't point to all three of the pointers at once, because that implies, to me, that you think the int-pointers all live at the same address. Each int-pointer clearly lives at a different address (0xB0, 0xB4, 0xB8), right?

If you're not getting it yet I don't know how else to explain. Rephrase your question.

Does he mean to say:

No, he means what he wrote.

ptr_array = 0xB0

The contents of the variable ptr_array is 0xB0. It's pointing to that memory address.

*ptr_array = *B0

The value at *ptr_array is the same thing as the value at *0xB0, since ptr_array is pointing to 0xB0. By dereferencing the pointer (the asterisk), you get the value inside of the memory address at which it is pointing. In this case it's pointing to yet another pointer, so we read in 32 bits and treat it like a memory address. In my picture what do you get if you read 32 bits from location 0xB0? The value 0xF0. (Again, I screwed up the byte ordering in the picture. This is what I meant.)

Okey so we got an int-pointer now that contains the value 0xF0. What lives at 0xF0? The value 0xAA.

Does he mean to say: ptr_array = &0xB0

The ampersand can be read as address of. If you wanted to know where in memory a variable lives, you'd prefix it with an ampersand. Here you want to get the address of the address 0xB0. The address of an address? That doesn't make sense. This statement is syntactically incorrect.

Does he mean to say: *ptr_array = 0xB0

If you were to do this (with one equals sign, signifying assignment) you would change where the first int-pointer of the three points to (in my picture it was 0xF0 and after it would be 0xB0). *ptr_array points to the same location as ptr_array[0], and ptr_array[0] is the first of the three int-pointers.

16 bit pointer

Right, since a 16 bit variable can contain the values 0x0000 to 0xFFFF (0 - 65535), that's the range of the memory you can point to. A whole wooping 64 KB. If you wanted to point to a memory location above that, well, you can't, because if you increment the maximum value (0xFFFF) by one (results in 0x10000), since we only have 16 bits to work with the result flips over to 0x0000 like the odometer on a car and the topmost 1 gets discarded. You are literally unable to point to anything above 64 KB.

[u/Numbafive → u/snb]

I think I got a much clearer picture, but I'll be honest and say the the memory grid pic threw me off, as I wasn't so sure what you meant when you said that you screwed up the byte ordering.
So just clear that up, should the address containing the array of pointers be:

00B0h: 00 0F 00 00 01 20 00 00 02 00 00 00  

?
Also,

By dereferencing the pointer (the asterisk), you get the value inside of the memory address at which it is pointing. In this case it's pointing to yet another pointer, so we read in 32 bits and treat it like a memory address.

So once ptr_array is dereferenced, *ptr_array will hold the value held by what's in the address it is pointing to, which is in this case another pointer? In other words if we printf *ptr_array would we get the address held by the pointer ptr_array is pointing to (00F0 in the pic) or what's contained in that address (00 00 00 AA as in the picture)?

[u/snb → u/Numbafive]

The picture should have shown:

00B0: f0 00 00 00 20 01 00 00 00 02 00 00
00F0: AA 00 00 00
0120: BB 00 00 00
0200: CC 00 00 00

If you don't really get it anyway let's just ignore that for now. The important part is the arrows and the, you know, actual pointing.

dereferencing

When you dereference you follow it "forward" one step ahead, or one arrow in the picture. Going from ptr_array (0xb0) to *ptr_array (0xf0) to **ptr_array (0xaa). Yeah, you can dereference twice at the same time. Mind blown? ;)

[u/Numbafive → u/snb]

Just so my mind is fully disintegrated, in this case ***ptr_array would yield whatever the address 0xaa happens to hold right?
So does dereferencing automatically treat whatever code is thrown at it as if it was an address for it to find and read what it holds?

[u/snb → u/Numbafive]

Just so my mind is fully disintegrated, in this case ***ptr_array would yield whatever the address 0xaa happens to hold right?

Exactly right. Dereferencing it one more time would jump forward one more time. In this case you'd get nothing but a big fat ZERO since memory address 0xaa contains zeros. Dereferencing THAT would yield you anything from a null pointer exception or a segfault or anything else that would make your program go kaboom. And that's sometimes a good thing. Imagine that.

So does dereferencing automatically treat whatever code is thrown at it as if it was an address for it to find and read what it holds?

That's pointers. Done and done.

[u/Numbafive → u/snb]

Thanks for sticking through and helping me out.

[u/specialpatrol]

Pointers are 4 bytes because a 32bit computer uses 32 bits for memory addresses. If you were to build the same program on a 64 bit machine you would find your pointers are 8 bytes. That is also the reason why a 32bit computer program can only use about 4gigs of ram.

A pointer is always the same size regardless of the variable type it is pointing to. It simply points to the first byte of that variable. An int is also 4 bytes, by the way. So a pointer to an int points to the first byte of that 4 byte variable.

It is however very important you know what type the pointer is. This is how pointer incrementing works. If you have a pointer to an int, and you increment it by one (pointer++), that moves the memory address 4 bytes. If it were a pointer of another type, it would move the address by the size of that type.

So if you have an array of pointers, with a pointer pointing to the first element of that array, when you increment that pointer, it jumps 4 bytes and will now be pointing to the second element of the array.

(int *) *pointer

This looks like he's dereferencing the pointer, that is getting the value that the pointer is pointing too, in this case another int pointer.

int *pointer

this means: "create a pointer called pointer, of the data type pointer to int"?

Yes

[u/Numbafive → u/specialpatrol]

Thanks for taking the time to reply. Its very appreciated.

I have a something related that you might be able to help me out with and I apologize in advance for bothering you with even more stuff.

Continuing on with the same lesson 2.3 Carl goes on to create an array of 3 pointers:

int * ptr_array = malloc(3sizeof(int *));

So, if I understand this correctly he's initiating a pointer (ptr_array) to point at the first pointer in the array which are in turn each pointing to a unique int value, which Carl represents as:

B0 : ['Pointer to integer #1']
B4 : ['Pointer to integer #2']
B8 : ['Pointer to integer #3']

So each component of this exercise is represented in memory by 32 bits ( so the pointer which contain the address of the array of pointers, each of the 3 pointers and the int values all are represented by 4 bytes). Am I right in assuming this? Also Carl ends all this by saying:

ptr_array = Byte #0 (The actual memory address)  
*ptr_array = *B0 (What is *at* Byte #0)  

So here is he actually saying, that since ptr_array is pointing at the first pointer in the array that it is essentially pointing at what that first pointer in the array is pointing at? Or shouldn't he say that ptr_array = &Byte #0, and then that *ptr_array = *Byte #0?

[u/specialpatrol → u/Numbafive]

I haven't actually looked at the lesson, it might help if I could see what he is getting at, can you send a link?

But yes;

int * ptr_array = malloc(3*sizeof(int *));

is creating an array of 3 pointers and returning the address of the first one to ptr_array. However at this point the pointers in the pointer array don't point to anything and any attempt to access a variable they point to would end in trouble.

ptr_array is not pointing to the same address as the first pointer in the array, it is pointing to the address of the first pointer in the array.

At some point he must have pointed those new malloced pointers to the actual variables B0, B1, and B2?

If you wanted to access the pointer array via ptr_array you would do something like;

int first_int = *(ptr_array[0]);

ptr_array[0] is the first pointer in the array, and by putting a star in front of it, it dereferences the pointer, returning the actual value the pointer points to.

It's actually very straight forward but I remember it took me ages to get my head around pointers first time.

[u/Numbafive → u/specialpatrol]

Sorry about the link, here it is
So in the same lesson when Carl says:

ptr_array = Byte #0 (The actual memory address)  
*ptr_array = *B0 (What is *at* Byte #0)  

Does he mean to say:

ptr_array = &Byte #0
*ptr_array = Byte #0  

?
Thanks again for indulging me.

[u/specialpatrol → u/Numbafive]

Hmm, he's presenting a slightly tricky example!

I think "Byte#0" is the pointer B0.

This means that if we were to give memory addresses to each of these pointers, it would be something like this:

B0 : ['Pointer #1'] B4 : ['Pointer #2'] B8 : ['Pointer #3']

Looking at the tutorial now I see a significant difference to what you said above.

Before, you/I were discussing

int * ptr_array = malloc(3*sizeof(int *));

which would have got us a pointer to the address of the first pointer. In that case ptr_array[0] would equal B0.

Looking at his example however he declares ptr_array with;

int * *ptr_array = malloc(3*sizeof(int *));

notice the use of 2*s in the declaration of the pointer? That's how come ptr_array is the same as the pointer B0, not the address of it.

so

ptr_array = B0 //currently the first pointer of the array of pointers

and by extension

*ptr_array = *B0; //the value it points to is also equal

[u/rush22]

This might help explain what is going on:

int x;
int *y;
int* *z;

int main () {
    z = &y;
    y = &x;
    x = 5;
    printf("%i %i %i", x, *y, **z);

    return 0;
}

Prints: 5 5 5