Printable View
I'm a little confused about the difference between using something like:
andCode:char s[] = "hello"
I understand that the first is an array of char, and the second is a pointer. I'm just confused on what situations to use one or the other. They seem to accomplish the same thing. Also, something like:Code:char *s = "hello"
I was wondering why it seems to be a combination of the two and what that accomplishes. Thanks for any answers : )Code:char *argv[]
First of all, I recommend you take a look at this:
C Strings (Arrays vs. Pointers)
It describes the exact thing you are looking for, although in a course designed to teach C++. However, the part you are interested in is readable for someone with no experience in C++.
In short when you say:
- you are allocating memory on the STACK for a string of 10 characters (including the string termination character \0) out of which only 6 characters are used ('h','e','l','l','o','\0')Code:char name[10] = "hello";
- you are allocating memory on the STACK for a string which is IMPLICITLY as long as the string you are assigning to it (i.e. 6 characters (hello + \0)Code:char name[] = "hello";
- you are declaring a pointer to a string which can be allocated on the HEAP. For example, a ten character string can be allocated on the HEAP using the name pointer as such:Code:char *name;
If you are not familiar with the difference between STACK and HEAP memory you should look it up. It is an important aspect of programming in general, particularly in C.Code:name = (char*)(malloc (sizeof(char) * 10));
Hope this clears things up a little.
is a string literal. It's like a "even stronger" const and cannot be changed -- I think the standard forces an error on changing a literal.Code:char *s = "hello"
Ahh ok, I think I'm starting to grasp the concept. The book I'm going through hasn't introduced stack and heap memory yet, but now that I've looked it up it's starting to come together. At first glance it seemed the author was randomly choosing string declarations, I can see there's a method now. Thanks guys!
Avoid C in the C++ forum and vice versa.Quote:
Originally Posted by claudiu
I am pretty sure it doesn't. It's implementation defined or even undefined from what I understand.Quote:
Originally Posted by MK27
Regardless, on Windows and Linux, string literals are read only and thus shouldn't be changed or you WILL get an error. At runtime.
Not quite. The string literal is actually const. The "char *s = "hello";" usage is a hangover from old pre-standard versions of C (which did not support the const keyword) and allows a non-const pointer to point at the (first character of) a string literal. Any attempt to change the contents of that string literal (eg s[0] = 'b'; ) gives undefined behaviour. No error is required but a common observed effect is a run-time error.Quote:
Originally Posted by MK27
it's comin' togehter I think. char s[] = "Hello"; -- declares a string array that only leaves enough space for "Hello" and a null. char s[10] = "Hello"; -- declares a string array that has enough space for "Hello", a null character, and 4 additional bytes. char *s = "Hello"; -- declares a string that, once initialized to "Hello", cannot be changed. One thing that was throwing me off was the use of something like char *s in function arguments, but now I see it's there because it's telling the function to expect an address of char type and not the actual char.
Not quite. It actually just declares a pointer, and then initialises that pointer with a value that happens to point to the data segment of your program where the characters 'H', 'e', 'l', 'l', 'o', '\0' are stored sequenially (and cannot bechanged).Quote:
Originally Posted by wtaplin
You can verify the differences between these by using 'sizeof'.
char name1[10] = "hello";
int s1 = sizeof(name1); // s1 is 10
char name2[] = "hello";
int s2 = sizeof(name2); // s2 is 6
char *name3 = "hello";
int s3 = sizeof(name3); // s3 is 4 (assuming 32-bit pointers)
About: "char *argv[]" read type declarations from right to left. This is an array (unknown length), of pointers to char. Each one of those pointers can point to any number of characters it likes. the array of pointers is as long as argc says it is.
Something that you may also find interesting is that in the case of jsut declaring a pointer, where the actual characters live in the data segment, the compiler is free to overlap and reuse portions of the data segment because it can assume that it is never modified. E.g. if your code contained pointers to the strings: "world", "d", "hello world", and "ld", even if some of those appeared numerous times, then the data segment could get away with just storing:
'h', 'e', 'l', 'l', 'o', ' ', 'w', 'o', 'r', 'l', 'd', '\0',
You'll notice that all the shorter strings appear within this data, followed by the nul-character, and pointers to those strings can simply point to the appropriate characters inside this data. The string "hello" would need to be stored separately because it is followed by a '\0' whereas in the above is followed by a space.
Gettin' clearer now. Essentially, using char *s = "hello" puts "hello\0" out there in the computer's memory with 's' providing a way to find it and refer to it. The right to left tip really simplifies things too. Very interesting how the compiler can recognize and store data more efficiently : ) Thank you to everyone who gave me an answer. I apologize if I'm beating this question to death, it helps me get it straight in my head lol.Quote:
Originally Posted by iMalc