Printable View
Why is the size of c being read as the size of a 32bit pointer instead of the size of the buffer it points to? What is different about the pointers?
Code:#include <stdio.h>
int main() {
char a[] = "kiera";
char b[69] = "kiera haha";
char* c = "keira rules";
printf("a = %d, b = %d, c = %d c_string = %s\n", sizeof(a), sizeof(b), sizeof(c), c);
return 0;
}
/** OUTPUT **
*
* a = 6, b = 69, c = 4, c_string = "keira rules"
*
*/
Because c is a pointer and the size of a pointer is the size of the pointer and not the size(length) of the data it happens to point to. a and b are character arrays and therefore the size returned is the length of those arrays. If you wanted the length of the data pointed to by c to be output you'd have to print the return value of strlen(c).
i misunderstood...
That's pretty confusing... I'm pretty sure that in memory a character array is stored as contiguous bytes, and the pointer could be anywhere in memory and points to the first byte of that array. So what you said doesn't seem pertinent.Quote:
think about data as vertically aligned arrays [ this->(| | | |) not this-> (-- -- -- --) ], size is the height of this conceptual data model and length is its vector... coincidentally vectors are the names of dynamic arrays! hah...
so 32 bit value is "height" (size), 10 items in an array its "length" (vector).
Also, I don't think you guys understand what I'm asking. I'm asking how does sizeof() know the lengths of the buffers allocated with the syntax char buffer[length], and not the syntax char* buffer = "some string".
Personally, I think the reason is that sizeof is kind of like a preprocessor directive. I don't think there is a difference between the pointers at all, but the sizeof() command sees the pointers as different because of how they were declared. Could someone explain more?
keira, i didn't say that memory wasn't stored as contiguous bytes did i? i told you to imagine something to sort out two aspects, length and size. but i misunderstood your problem to begin with so never mind what i said.
I don't know how I can say it other than: a and b are not pointers, they are arrays. sizeof an array is the length of the array, sizeof a pointer is the size of the pointer and not the length of the data being pointed to. sizeof is a unary operator and not a preprocessor directive.Quote:
Originally Posted by keira
See: http://en.wikipedia.org/wiki/Sizeof
i'm curious...
how exactly does a computer manage an "array"?
int hi[5], is the 5 stored somewhere in memory? and the the fact that "5" points to an int stored somewhere? and then what value each 5 int's point to contained by "hi"? how is all this information managed by only 1 keyword to reference the information, via "hi" ?
int is what, 32bit value, and 5 of them, so the computer allocates 5*32 bits of space right?, so then how is the information about the array stored in memory?
i'm a little confused... it seems that declaring an array is actually something like... an obscure data type.
how does an array -actually- work... ? or am i over thinking it?
or since you declare int, it just picks up every 32bit value, puts it in to an int for you, but how does the program know there's a const value attached to it (the size of the array declared)?
can this value be mapped to the array name via some other variable? and can this be a work around for passing arrays through functions without needing two inputs, a pointer to the first item and size?
For a static array:Address of myArr is the first item of 20 sequential items in memory. (myArr + 2) is address of the third item and so on. myArr[1] is equal to *(myArr + 1) so it is the second item.Code:int myArr[20];
For a pointermyPtr points to the first item of 20 sequential items in memory. Note that myPtr has an address, but we don't need it. myPtr[1] is equal to *(myPtr + 1) means the second item.Code:int* myPtr = new int[20];
You can see that pointer and array are used in the same way. But remember that they are completely different.
It will be strored as 5 int after each other. Means 5*32 bits.Quote:
int is what, 32bit value, and 5 of them, so the computer allocates 5*32 bits of space right?, so then how is the information about the array stored in memory?
Compiler knows the size of each array item. So for myArr[3] it will be myArr + 3 * sizeof(int) and means forth item.
5 is not stored anywhere.Quote:
int hi[5], is the 5 stored somewhere in memory?
It just increases the stack size (for local automatic arrays) by sizeof(*array) * size bytes. If it's a char array, sizeof(*array) will be 1 (the size of one element of the array). If it's an int array, sizeof(*array) will be 4 (for 32-bit ints). The actual size of the array isn't stored in the executable or memory anywhere.
I don't see why you'd think a bunch of information about the array would need to be stored anywhere. During compile time, the compiler knows the type of array, so it can handle all the memory adjustments it needs to. The executable just simply moves around in memory according to the instructions the compiler laid out. The finished executable doesn't even know an array existed. It just knows "I need to go to this memory location".
You can also read this in cplusplus in my articles. And here is another:
The question is "Are these two statements equal?"
I think it is obvious that they are not! First one is a static array and the second one is a dynamic array and a pointer that points to it.Code:int var[20];
int *var = new int[20];
So why we can use these two statement for both?
Because C/C++ lets you to do so. But the mechanism to calculate effective address is a little bit different. For static array: executive file knows the address of var[0] and knows the size of each array element. So Effective Address = Address of var[0] + (12 * sizeof(var[0]) )Code:var[12];
*(var + 12);
But for the pointer and dynamic array: executive file does not know the address of the dynamic array's first element (var[0]) in the memory. But it knows the address of a pointer (pointer is a variable that holds a memory address) that points to the first element of the dynamic array. The formula for calculating effective address is:
Effective Address = Address of var[0] + (12 * sizeof(var[0]) )
So where is the difference? It is in getting address of var[0].
In the case of pointer, Executive file does not know the address of var[0], it needs to look into the pointer to find that address. Look at the assembly codes for int a = var[12]:
For static array:
For dynamic array:Code:mov eax,dword ptr [ebp-20h] //20h = 32
mov dword ptr [ebp-54h],eax //54h = 84
ebp is the start of stack and have the value of 1245040. The stack will be filled like the picture:<<>>Code:mov eax,dword ptr [ebp-4]
mov ecx,dword ptr [eax+30h] //30h = 48
mov dword ptr [ebp-8],ecx
In our example program we have only one array and a variable 'a' in the stack. The first element of array is placed in the address ebp – 80 = ebp - (4 * 20) (Each integer is four bytes and the array has twenty elements) address of variable 'a' is ebp - "size of the whole array" - "size of int" = ebp - 80 – 4 = ebp - 84
For calculating address of var[12] we should subtract 48 from 80 that gives 32 and then minus it from ebp. So it is ebp – 32.
[] means "the value that this address points to" it is like dereferencing sign in C/C++ (astrix "*").
First line says place the value which is placed in memory address "ebp - 32" in the eax register (Registers are some small memories in the CPU used for proccessing operations).
Now we have var[12] in eax. Then it moves it into variable 'a': In the second line as it says place the value of eax in the memory address "ebp - 84" which is the address of 'a' as we calculated above.
Now for the dynamic array case 'a' and 'var' are two local variables placed in the stack both are 32 bits (= 4 bytes). 'a' is an integer and 'var' is a pointer. In my compiler int is four bytes and in my machine pointers are 4 bytes too.
The var is the first variable in the stack. Its address is "ebp - 4". The 'a' is placed right after it so has the address "ebp – 8". In the first line, it picks the value of the var (ebp - 4) which is the address of allocated memory returned by new operator. Then puts the address in eax register. After this it needs the value of var[12]. To calculate its address, it adds 48 to eax. Which means adding 48 (= 4 * 12) to address of allocated memory ([ebp - 4]). In the second line it puts the value of var[12] in ecx register. At last in the third line it puts the value of ecx in the 'a' (which has the address ebp - 8).
You may ask why in the case of static array it subtract the offset from base address while for dynamic array it adds the offset to base address. Well, this is because of the way that stack and heap memory are managed and is out of scope.
The static arrays are placed in the stack portion of memory while dynamic arrays are in the heap portion.
I disagree. a and b are pointers. Arrays are an abstract concept unbeknownst to the instruction set. If the compiler treats a and b differently from c, than that is it's own prerogative, however, c IS THE SAME AS A AND B. (lol sorry for yelling but slavosh started it!)Quote:
I don't know how I can say it other than: a and b are not pointers, they are arrays
a and b are arrays.
http://c-faq.com/aryptr/index.html
> however, c IS THE SAME AS A AND B.
No they're not.
c = a;
is allowed.
a = c;
is not.
Also, the different answers for sizeof tell you that they have to be different.
There are a couple of really important exceptions to the "arrays just become pointers to the first element" rule, as explained by the c.l.c FAQ.
However, this is not machine language or assembly language. This is C. Arrays are a programming concept present in C. As such, a and b are arrays, not pointers.Quote:
I disagree. a and b are pointers. Arrays are an abstract concept unbeknownst to the instruction set. If the compiler treats a and b differently from c, than that is it's own prerogative, however, c IS THE SAME AS A AND B.
Does this differ in C++? In C++ are arrays not glorified pointers?
To demonstrate:
Code:#include <iostream>
int main() {
char pointer[] = "keira";
char* otherPointer = pointer;
std::cout << otherPointer << std::endl;
return 0;
}
/** OUTPUT **
*
* keira
*
*/
I don't understand where you got the idea that I was comparing dynamically allocated memory with local memory...Quote:
Because C/C++ lets you to do so. But the mechanism to calculate effective address is a little bit different. For static array: executive file knows the address of var[0] and knows the size of each array element. So Effective Address = Address of var[0] + (12 * sizeof(var[0]) )
But for the pointer and dynamic array: executive file does not know the address of the dynamic array's first element (var[0]) in the memory. But it knows the address of a pointer (pointer is a variable that holds a memory address) that points to the first element of the dynamic array. The formula for calculating effective address is:
Effective Address = Address of var[0] + (12 * sizeof(var[0]) )
So where is the difference? It is in getting address of var[0].
In the case of pointer, Executive file does not know the address of var[0], it needs to look into the pointer to find that address. Look at the assembly codes for int a = var[12]:
For static array:
Code:
mov eax,dword ptr [ebp-20h] //20h = 32
mov dword ptr [ebp-54h],eax //54h = 84
For dynamic array:
Code:
mov eax,dword ptr [ebp-4]
mov ecx,dword ptr [eax+30h] //30h = 48
mov dword ptr [ebp-8],ecx
ebp is the start of stack and have the value of 1245040. The stack will be filled like the picture:<<>>
In our example program we have only one array and a variable 'a' in the stack. The first element of array is placed in the address ebp – 80 = ebp - (4 * 20) (Each integer is four bytes and the array has twenty elements) address of variable 'a' is ebp - "size of the whole array" - "size of int" = ebp - 80 – 4 = ebp - 84
For calculating address of var[12] we should subtract 48 from 80 that gives 32 and then minus it from ebp. So it is ebp – 32.
[] means "the value that this address points to" it is like dereferencing sign in C/C++ (astrix "*").
First line says place the value which is placed in memory address "ebp - 32" in the eax register (Registers are some small memories in the CPU used for proccessing operations).
Now we have var[12] in eax. Then it moves it into variable 'a': In the second line as it says place the value of eax in the memory address "ebp - 84" which is the address of 'a' as we calculated above.
Now for the dynamic array case 'a' and 'var' are two local variables placed in the stack both are 32 bits (= 4 bytes). 'a' is an integer and 'var' is a pointer. In my compiler int is four bytes and in my machine pointers are 4 bytes too.
The var is the first variable in the stack. Its address is "ebp - 4". The 'a' is placed right after it so has the address "ebp – 8". In the first line, it picks the value of the var (ebp - 4) which is the address of allocated memory returned by new operator. Then puts the address in eax register. After this it needs the value of var[12]. To calculate its address, it adds 48 to eax. Which means adding 48 (= 4 * 12) to address of allocated memory ([ebp - 4]). In the second line it puts the value of var[12] in ecx register. At last in the third line it puts the value of ecx in the 'a' (which has the address ebp - 8).
You may ask why in the case of static array it subtract the offset from base address while for dynamic array it adds the offset to base address. Well, this is because of the way that stack and heap memory are managed and is out of scope.
The static arrays are placed in the stack portion of memory while dynamic arrays are in the heap portion.
I am simply saying that 4 bytes of memory whose value is an address that is the first element of what we call an array is the same thing as a pointer.
I didn't know the C compiler treated arrays differently and I will look into that, thanks guys.
I was hoping you would demonstrate the difference yourself using sizeof as was mentioned earlier, but you did not :pQuote:
Does this differ in C++? In C++ are arrays not glorified pointers?
To demonstrate:
To demonstrate:
On my system, the output is "6 4". Basically, C++ has the same distinction between arrays and pointers as C.Code:#include <iostream>
int main() {
char pointer[] = "keira";
char* otherPointer = pointer;
std::cout << sizeof(pointer) << " " << sizeof(otherPointer) << std::endl;
return 0;
}
Alright thank you for your help everyone and sorry I'm so thick headed... This is a concept I thought I had completely locked down after spending many months in assembly and C++.
Nothing is different. c is a pointer. Therefore sizeof(c) is the size of the pointer. Why would you expect anything different?Quote:
Originally Posted by keira
When you use pointer you usually use dynamically allocated memory. What is the local memory then? You mean arrays?Quote:
I don't understand where you got the idea that I was comparing dynamically allocated memory with local memory...
Local would be stack memory, dynamic would be heap memory.
The expression: char* string = "keira"; Creates both the pointer string and the consecutive ordering of bytes that translate to "keira" on the stack.
Basically to answer my original question, this was what i was looking for: (taken from http://c-faq.com/aryptr/aryptrequiv.html)
That is, whenever an array appears in an expression, the compiler implicitly generates a pointer to the array's first element, just as if the programmer had written &a[0]. (The exceptions are when the array is the operand of a sizeof or & operator, or is a string literal initializer for a character array. [footnote] See questions 6.23, 6.12, and 1.32, respectively.)