Thread: Question about char*

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:

Code:

char name[10] = "hello";

- 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[] = "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;

- 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:

name = (char*)(malloc (sizeof(char) * 10));

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.

Hope this clears things up a little.

Code:

char *s = "hello"

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.

Originally Posted by claudiu

Code:

char *name;

- 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:

name = (char*)(malloc (sizeof(char) * 10));

That should be

Code:

name = new char[10];

And later
[code]delete [] name;

Avoid C in the C++ forum and vice versa.

Originally Posted by MK27

Code:

char *s = "hello"

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.

I am pretty sure it doesn't. It's implementation defined or even undefined from what I understand.
Regardless, on Windows and Linux, string literals are read only and thus shouldn't be changed or you WILL get an error. At runtime.

Originally Posted by MK27

Code:

char *s = "hello"

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.

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.

Originally Posted by wtaplin

char *s = "Hello"; -- declares a string that, once initialized to "Hello", cannot be changed.

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).
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.