Printable View
Some recent experimentation has lead me to believe that the following two declarations are the same:
Is this true? I used the following code to check:Code:char str[];
char *str;
The string was outputed, which means that an address must have been stored in str, which makes it a pointer. Am I correct?Code:char str[]="Hello World!";
char *ptr=str;
cout << ptr << endl;
A pointer only points to it so yes they would be the same thing but you risk overwriting other variables I believe.... the pointer will give you a larger space and the declaration with th [] has a set space.... kinda like if I were using assembly.... and i told it i wanted a Data byte(used for strings) at DS = 100 and another data byte at ds = 105 if the first string over lapped the second then you would have hellohello world assuming both strings were hello world to begin with.
I think I'll stick with pointers. Much more straight forward.
You still have the possibility to overwrite your strings with pointers.... thats the main reason I dont use them unless I really need to.... at least with declaring it with the [] you can make sure that the space is there tho it will limit the size of the string.... ex.
char name[10];
name = "Jimbo Jones"
when it was couted you would have jimbo jone the s would be dropped off because of the null at the end of the string.
not really...........
if you write this by itself:
compiler will flag an error b/c when you declare an array like this (on the stack) you ought to give it it's capacity...Code:
char str[];
and whether you declrare an array statically (as above) or dynamically, once you set its size you can't really change it...
to be o.k. on the terminallogy, by writing the following:
you have declared an array of 6 characters, b/c by enclosing the word (hello) in double quotes (" "), implicitly you include the terminating character (\0) which signifies the end of the C-style string...Code:
char str[] = "hello";
and now when you write:
you must understand that the the name of your array (str) IS THE POINTER TO THE FIRST CHARACTER IN YOUR ARRAY, so in reality you are assigning (ptr) to be pointing to the same address as (str) is, which of course in this case is the first character in the array ( first character also being accessed by: str[0] )Code:
char *ptr = str;
keep in mind that if your character array wouldn't be initialized in double quotes, meaning it would not carry the terminating character at the end (\0) then you only would see the FIRST character on the screen, not the entire string...
for example:
hope that makes things a lot clearer...Code:
char str[] = { 'h', 'e', 'l', 'l', 'o'};
char *ptr = str;
cout << ptr << endl; // prints to screen only letter h...
keep up the good work...
................
matheo917
So, let's recap.
The compiler allocates 6 bytes on the local stack, puts the null-terminated string into those bytes, then puts the address of the first byte in str.Code:char str[]="Hello";
Does this mean that a string enclosed in double quotes is not always stored somewhere else in the executable, but is sometimes entered byte-by-byte into an array?
No, it wouldn't just display the first character -- It would keep displaying until it came to a byte in memory which was set to the value 0. You'd actually end up printing AT LEAST hello but mostlikely more than that as well. It will never, however, only print out an h.Quote:
Originally posted by matheo917
keep in mind that if your character array wouldn't be initialized in double quotes, meaning it would not carry the terminating character at the end (\0) then you only would see the FIRST character on the screen, not the entire string...
for example:
hope that makes things a lot clearer...Code:
char str[] = { 'h', 'e', 'l', 'l', 'o'};
char *ptr = str;
cout << ptr << endl; // prints to screen only letter h...
i don't think i quite understand your question, please rephrase...???????????Quote:
Does this mean that a string enclosed in double quotes is not always stored somewhere else in the executable, but is sometimes entered byte-by-byte into an array?
note: declaring an array (statically) happens during compilation time, declaring an array (dynamically - on the heap) happens during the run-time, while the "executable" file is running...
Well, I have been under the impression that a string enclosed in double quotes is stored as a sort-of resource in the executable. So:
Those 6 bytes are stored in the resource section of the executable, and "Hello" is replaced with a pointer to the string.Code:char *str="Hello";
That's what I thought happened. I'm pretty sure I read it somewhere.
sorry i'm not really clear on the terminology of "resource in the executable" -------------> that's the first time i've seen such terminology.........
maybe someone else can help you out with this..........
ohhh yeah.........i made a mistake on the previous post, Polymorphic was correct..........
thanx Polymorphic
.....................
matheo917
Yup.Quote:
Originally posted by bennyandthejets
Well, I have been under the impression that a string enclosed in double quotes is stored as a sort-of resource in the executable. So:
Those 6 bytes are stored in the resource section of the executable, and "Hello" is replaced with a pointer to the string.Code:char *str="Hello";
That's what I thought happened. I'm pretty sure I read it somewhere.
The "Hello" is put in the text area of the program while in memory (which is usually made unwritable at runtime) and str points to the H.
Good. At least I got something right for once.
Right.
char * s = "I live in the .exe, itself";
char t[] = "Not me, I live on the stack.";
's' is a static variable.
't' will be destroyed when it goes out of scope.
Of course,
char * s;
char t[] = "I live on the stack.";
s = t;
In this case, 's' is not a static variable.