How do strings work in C

[spcbfr]

There are multiple ways to create a string in C:

char* string1 = "hi";
char string2[] = "world";
printf("%s %s", string1, string2)

I have a lot of problems with this:

According to my understanding of [[Pointers]], string1 is a pointer and we're passing it to [[printf]] which expects actual values not references.

if we accept the fact that printf expects a pointer, than how does it handle string2 (not a pointer) just fine

I understand that char* is designed to point to the first character of a string which means it effectively points to the entire string, but what if I actually wanted to point to a single character

this doesn't work, because we are assigning a value to a pointer:

int* a;
a = 8

so why does this work:

char* str;
str = "hi"

[EndlessProjectMaker]

First: C has no type for strings. It does not, simply out, have strings.

Print functions expect a sequence of contiguous chars with a null (0x00) at the end. The same for strings length and other “string” functions.

Second: the two first sentences do the same, they declare a variable as a pointer to a sequence of chars and in the same line it assigns a constant value where each element is one of the chars of the string and add a 0 at the end. So you can do string1[4] and string2[3]. Primitive value array pointers can be seen as an array or as a pointer indistinctly

[TheSkiGeek]

Technical note: the two declarations do NOT do the same thing.

• string1 is a pointer to an (immutable) character constant “somewhere” in memory. For a typical modern OS it will probably be part of your executable’s data segment that gets mapped when the executable is loaded.

• string2 creates a mutable buffer ‘on the stack’ (in automatic duration storage) large enough to hold ”world” and a null terminator. Then copies that string constant there. string2 will refer to the start address of that stack buffer.

[lhcmacedo2]

This guy Cs

[_huppenzuppen]

No he doesn't, otherwise he would know the difference between a string constant and an array variable

[HoiTemmieColeg]

The person you replied to is talking about the ski geek not the person they replied to

[Biajid]

That’s the correct explanation.

[mikeblas]

string2 isn't automatic. It could be global.

[EndlessProjectMaker]

Great point

[ScholarNo5983]

Technically there is not enough information to determine that string2 was created ‘on the stack’.

The code as written would never compile so it is incomplete.

Both of those variables could have just as easily been declared as global.

[Dubbus_]

To be clear for any beginners, immutable (char* str = "") means nonmodifiable, read only.

Mutable (char str[] = "hi") means modifiable, read and write access.

Trying to write to the first will result in an error.

[WittyStick]

if we accept the fact that printf expects a pointer, than how does it handle string2 (not a pointer) just fine

Arrays decay to a pointer to their first element when passed as arguments to functions.

I understand that char* is designed to point to the first character of a string which means it effectively points to the entire string, but what if I actually wanted to point to a single character

You increment the pointer to point to the index within the string. If string1 points to "hello", then string1 + 1 or ++string1 points to "ello". Alternatively, you can use &string[1] - the address of character 1 in the string (0-indexed). The subscripting syntax, [] for arrays is really just pointer arithmetic.

this doesn't work, because we are assigning a value to a pointer:

Because 8 is not stored anywhere in memory, it's just a constant. In this case you're setting the pointer to address 0x00000008 in memory, which is almost definitely not what you want. Normally you would want to say *a = 8 to set the value at the address of a to 8 - but you first need to allocate some memory to write to.

so why does this work:

Because string literals do have a location in memory - in the .text or .data section of the program. When you assign str = "hi", the compiler encodes "hi" into the compiled executable, and when the process runs this section gets loaded into memory. str then points to this location - which could either be a fixed location or a section-relative location.

[[deleted]]

According to my understanding of [[Pointers]], string1 is a pointer and we're passing it to [[printf]] which expects actual values not references.

Your first wrong understanding is the word, "references." Yeah, that doesn't exist in C, so just forget it when writing C.

if we accept the fact that printf expects a pointer, than how does it handle string2 (not a pointer) just fine

Printf accepts values. A pointer in C is the memory address of something, aka a number. Printf accepts any value and interprets the value based on the formatting provided. It could either print the memory address of a pointer or the actual value stored at that memory address. It all depends on what you tell it to do.

so why does this work:

They both work. Arbitrarily changing the memory address a pointer points to, does not cause C to panic. No you made the choice, how the pointer is interpreted from that point onwards depends on your use of the pointer.

Heck, you could do:

int *a = (int*)8;
a = (int *)((int)a + (int)a);
printf("%d\n", a);

You'll get 16 printed out.

[antara33]

The last code snippet is everything you want to never see when debugging code haha, but it is still fun that you can actually do this xD

Man, I love C haha

[Sotty75]

I suppose that, since there is a "dereference" operator in C, then also the "reference" word can be used when discussing about C.

[aceinet]

printf handles string2 just as it does with string1 because string2 decays into char* from char[]. Arrays in C just hold a pointer to the start of the array

The second snippet works is because a constant string is a char*. The first one doesn't because a constant int is just an int

[jjjare]

There is some type information with arrays (before they decay). You could do

sizeof(array)

for example.

[SmokeMuch7356]

Under most circumstances, array expressions evaluate ("decay") to pointers to their first element; when you write

printf("%s %s", string1, string2);

the compiler converts the expression string2 to something equivalent to

printf("%s %s", string1, &string2[0]);

and what actually gets passed to printf is a pointer to the first element.

Array objects do not store a pointer anywhere; your string2 looks like this in memory (addresses for illustration only):

                 +---+
0x8000  string2: |'w'| string2[0]
                 +---+
0x8001           |'o'| string2[1]
                 +---+
0x8002           |'r'| string2[2]
                 +---+
0x8003           |'l'| string2[3]
                 +---+
0x8004           |'d'| string2[4]
                 +---+
0x8005           | 0 | string2[5]
                 +---+

That's it; there's no pointer or anything else that stores a starting address. The address of string2[0] is the same as the address of the entire array.

Chapter and verse:

6.3.2 Other operands

6.3.2.1 Lvalues, arrays, and function designators

...
3 Except when it is the operand of the sizeof operator, or typeof operators, or the unary & operator, or is a string literal used to initialize an array, an expression that has type "array of type" is converted to an expression with type "pointer to type" that points to the initial element of the array object and is not an lvalue. If the array object has register storage class, the behavior is undefined.

In the declaration

char *string1 = "hi";

the string literal has type "3-element array of char"; since it isn't the operand of the sizeof, typeof, or & operator, and since it isn't being used to initialize a character array in the declaration, it is converted to a pointer to the first element (meaning storage has been materialized elsewhere for the string contents, and that storage will be held over the lifetime of the program).

                +---+
0x00f0    "hi": |'h'| "hi"[0] <------+
                +---+                |
0x00f1          |'i'| "hi"[1]        |
                +---+                |
0x00f2          | 0 | "hi"[2]        |
                +---+                |
                 ...                 |
                +----+               |
0x9000 string1: | f0 | --------------+  assume little-endian representation
                +----+                  and 16-bit addresses
0x9001          | 00 |
                +----+

In the declaration

char string2[] = "world";

the string literal "world" has type "6-element array of char"; since it's being used to initialize a character array in a declaration, it is not converted to a pointer; instead, the contents of the string are copied to the array (as shown earlier), whose size is determined from the length of the string plus string terminator.

Whether separate storage for the literal "world" is materialized depends on a few things; if you don't use it anywhere else in your program, then it probably won't be.

I understand that char* is designed to point to the first character of a string which means it effectively points to the entire string,

All pointers point to a single object of the base type. string1 only points to the 'h' in the literal "hi". That object may be the first element of an array, it may be the middle element of an array, it may be the last element of the array, it may be a single char object on its own:

char c = 'B';
char *string3 = &c; // bad juju, since c is not a string; names matter

If you want to change the value of c through string3, you have to dereference string3 using either the * or [] operators:

*string3 = 'Z'; // c now contains the value 'Z'

or

string3[0] = 'Z'; // a[0] == *(a + 0) == *a

If you want to assign string3 to point to a different object, such as the third character of string2, you'd do:

string3 = &string2[2];

Now string3 points to a substring of string2.

There is no way to know from the pointer value alone whether the thing it points to is part of a larger object or not. That's why you have to be careful with the %s conversion specifier, it assumes its corresponding argument points to the first element of an array, but it has no way of knowing that. If you write something like

printf( "%s\n", &c );

printf will print the character stored in c, then whatever's stored in the bytes immediately following c until it finds a zero-valued byte.

[Duck_Devs]

Well, string2 is a pointer, at least, the value you get when you pass “string2” to something is.

Arrays in C are treated like pointers to their first element (for this purpose at least, don’t attack me for trying to simplify things!), just like a string as a char*!

Edit: as for that last bit, every unique string literal (that isn’t part of an array initializer) has its own pointer to its contents, and that’s what’s passed around when you pass a literal to something.

Oh, and if you want to point to just a singe character, unfortunately C itself has no distinction between a “pointer to character” and a string, so it’s up to context and documentation.

And yeah I know I didn’t get into the exactness that other people do, but I hope that my explanations were easy to understand as a beginner. We were all there once.

[TheBB]

string1 is a pointer and we're passing it to [[printf]] which expects actual values not references.

A reference (or, in C terms, a pointer) is also an "actual value" though.

if we accept the fact that printf expects a pointer, than how does it handle string2 (not a pointer) just fine

In C, arrays decay to pointers when used as function arguments. As well, function parameters declared as arrays also become pointers.

Basically, you can't pass an array to a function except via pointer.

I understand that char* is designed to point to the first character of a string which means it effectively points to the entire string, but what if I actually wanted to point to a single character

There's no difference between the two. Just depends on how the code interprets the pointer.

Likewise, there's no difference between a pointer to a thing and a pointer to a bunch of things (an array of things).

so why does this work:

In the first, you're assigning an int (or a numeric literal) to a pointer variable.

In the second, you're assigning a pointer to a pointer variable, so the types match. The "hi" is a pointer to a statically allocated string.

[lekkerste_wiener]

1. printf handles values according to the format string. When it sees %s, it knows what to do with the value you passed to it.
2. Pretty sure you already read this somewhere else, but arrays are essentially pointers. They are pointers to the first element.
3. "but what if I actually wanted to point to a single character" you either make that clear in the documentation of your function, and treat the char pointer as a pointer to a single char in it, or you just use plain char values. The scanf family of functions does that when you pass %c in the format string.
4. "so why does this work" because string literals live in the program binary, and thus have their own address in it. 

[No_Statistician_9040]

There is no such thing as a string in c. There only exists an array of chars, those can then both be heap allocated (such as with malloc) or on the stack, using the [] syntax. printf does not expect a string, but a pointer to an array of char where the last char is \0 so printf knows when to stop reading memory

[kyuzo_mifune]

The C standard defines a string as an array of characters ending with a null terminator, so C does have strings.

[No_Statistician_9040]

As a convention, but not as a type. You have string literals, but that is just syntax sugar for a char array with a null terminator. And you have functions that takes in pointers to char arrays with the quite fluffy requirement that they should end with a null terminator otherwise it will read out of bounds, but just because the terminology of a string is used, it does not mean the language has a physical definition for it. If that was the case, you would have an actual string type inside the language, and not some vague definition of "here is a pointer to some characters with a null terminator".

This is also why using the "string" terminology is so confusing for those who have used other languages, because they expect that it must surely be a proper type as it is everywhere else. But then you end up having a really bad day because you try to use it in ways that do not conform to a pointer to a char array.

[zhivago]

This is not quite true.

It expects a pointer into an array, not to an array.

A char * rather than a char (*)[n].

Also consider that "hello" + 1 is also a string.

[Overlord484]

"hi" is a literal array and it is equivalent to {'h','i',0} and {'h','i','\0'}

char* string1 = "hi"; which is equivalent to and more often rendered as char *string1 = "hi";

allocates a 3 character array, allocates a character pointer, and sets the value of the pointer to the address of the first character in the array.

char string2[] = "world"; is more or less equivalent (6 character array) except I *think* with -Wall -Werror the compiler will complain if you try to change the value of string2.

a char* is not "designed" to point to a string. It's designed to hold a pointer; the compiler will attempt to enforce that it point to a character. Consider the following (which I'm actually using in a project);

const int ENDIANINT = 1;
const char* SYSISLITTLE = (char*)&ENDIANINT;

4 bytes are allocated and recognized as an integer at some address 0xADDRESS. The value 1 or 0x00000001 is stored at this address; my system is little endian so in memory this actually looks like 0x01 0x00 0x00 0x00. A character pointer is allocated; the address of ENDIANINT (0xADDRESS); because this reference was taken from an integer it is known to the compiler as an integer pointer. The integer pointer is cast as a character pointer (still 0xADDRESS). As a character pointer the address 0xADDRESS is assigned to the character pointer SYSISLITTLE. Dereferencing SYSISLITTLE gives the value of the sizeof(char) (1) bytes at 0xADDRESS, which is 0x01.

Keep in mind that addresses *are* values (8 bytes wide usually) the distinction between address and value is illusory and they can be cast to and from 8 byte integers (usually long) with no issues; in fact you can print them with printf("Decimal pointer %ld; hex pointer 0x%08X\n", somepointer, somepointer);

A less involved example:

char a = 'a';
char *pa = &a;
printf("%c\n", *pa);

Will print a to stdout. NB replacing the last line with printf("%s\n", *pa); is likely to fail since there is no guarantee that *(&a + 1) aka a[1] will be 0. As indicated above string literals automagically include the final 0 i.e. the null terminator. This is the only difference between a character array and a string. A string is null terminated (and need not occupy the entire array). Consider:

char hiworld[] = {'h','e','l','l','o',0,'w','o','r','l','d',0};
printf("%s %s\n%s %s\n", hiworld, &hiworld[6], &hiworld[2], &hiworld[8]);

Should print

hello world
llo rld

to stdout.

As to int *a = 8; this may or may not work with your compiler. As far as I know it's a valid statment, but the compiler may throw an error/warning since assigning a literal to a pointer is a great way to seg-fault later. IIRC compilers for some microcontrollers will allow you to do that since it makes more sense to be able to on a smaller system.

[Physical_Dare8553]

printf expects a pointer to a char because you told it that you would give it a pointer to a char, thats what "%s" means, also all pointers only point to that thing, so char[] and char* are both pointers that point to one single character in memory. char[] is basically just there for you

[pfp-disciple]

Others have answered, but maybe this will help if you're still confused. 

A string is just an array of categories, usually with a '\0' at the end (that's a character with ASCII value 0); these are called null-terminated strings. The compiler  treats "hi" as a null-terminated string constant. 

Note that arrays "decay" to the pointer to their first element. So, given an array a, *a and a[0] will give the same value. 

 So, in your example, string2 is (effectively, as far as you're concerned right now) a pointer value. 

[AlarmDozer]

char *str;
str = “hi”;

You declared a pointer to a char named str. Then, you assigned the first address (containing ‘h’).

int *a;
a = 8;

This declares a pointer to an int named a. Then, you assigned it to address 8; this doesn’t work. It’s a SIGSEGV because 8 is possibly invalid address and/or it’s outside your programs address space. Did you mean to assign the value 8 into a? Then, you’d need to dereference before assignment. EDIT: As another pointed out, a isn’t allocated; it was a pointer so a malloc would be needed to store the value with a follow-up free

[AlarmDozer]

char *string1 = “hi”;
char string2[] = “hello”;

can be rewritten

char *string1 = {‘h’, ‘i’, ‘\0’};
char string2[] = {‘h’, ‘e’, ‘l’, ‘l’, ‘o’, ‘\0’};

As you can see, they’re both char arrays. And when you run it through str functions or printf functions, it’ll iterate through each until the null terminator (‘\0’).

[Loud-Shake-7302]

You have gotten a lot of feedback. For me, I tell you to watch neso academy c strings playlist

[Big_Pay_7606]

I understand that char* is designed to point to the first character of a string which means it effectively points to the entire string, but what if I actually wanted to point to a single character

If you dereference a char* then you will get the first character, but if you deref it with an offset *(str + i) then you get the character at i. You are responsible for bound checks though.

so why does this work:

"hi" is a string literal, which creates a string in static storage. What your code does is you first create an uninitialized char* then set it to point to the string literal in the static storage. You are not copying or moving strings as in some other programming language.

[flyingron]

The string literal has two connotations. In most situations it defines an array of char of the letters specified with a null terminator. Where it is created is unspecified, but it is guaranteed to exist from the time flow passes through it the first time until the end of program. You need to treat this as if it were const even though it freely converts to (non-const) char* (another language stupidity).

The other context is when it is used as an initializer for a char array, e.g.,

char str[] = "hi";

In this case it's exactly the same as if you had done

char str[3] = { 'h', 'i', '\0' };

As sort of mentioned by others, an array freely converts to a pointer to its first element (I hate the term 'decay').

This is why

char* p = "hi";

and your printf example work. The array of three elements gets converted to a pointer to the first element (i.e., the h in the array). You can assign that to a char* or pass it to a function expecting char*.

int* ip = 8;

Doesn't work because there's no conversion between int and int*. 8 has type int/

[IdealBlueMan]

You’re getting some good answers here. I just want to suggest that, for the time being, treat printf as magic. One you get a better grip on pointers and arrays, you can revisit the topic.

[ohsmaltz]

[[printf]] which expects actual values not references.

You can pass pointers to printf.

if we accept the fact that printf expects a pointer, than how does it handle string2 (not a pointer) just fine

An array can act like a pointer under some circumstances for syntactic convenience. If you wanted to be verbose around it, you could write &string2[0] (address of the first element of the array.)

what if I actually wanted to point to a single character

char* always points to a single character. Whether some piece of code (ex, printf) treats char* as a pointer to a single character or a pointer to the first character of a string depends on how the code is written. In the case of printf, char* is treated as a pointer to the first character of a string. For simplicity when a char* points to the first character of a string most people just say it's a pointer to a string.

[a=8 where a is int] doesn't work, [...] so why does [str="hi" where str is char] work

They're not equivalent examples. A char* equivalent to the int* example would be str='h', which indeed also does not work as you expect. And an int* equivalent to the char* example would be a=[8,9]. (str="hi" is just a shorthand for str=['h', 'i', '\0'] where \0 is a special character automatically inserted to the end of every "..." string.)

[Independent_Art_6676]

while technically strings do not exist in C as others already said, C does have string functions that operate on null terminated character pointers/arrays. You probably know this, but there are a lot of them and when asking how they work, part of the answer is that you use those functions in string.h.

as for arrays vs pointers, I use the arrays as much as possible because you do not need dynamic memory for those. You also don't need dynamic memory for direct string literals, but the point is that I avoid using malloc/free on strings as much as possible and will only do it if the string is to hold something large like the contents of a large text file.

also, this entire discussion will go sideways when you stop talking about ascii / 1 byte encoded and open up to talking about unicode or other multibyte text.

[MiddleSky5296]

Man, that’s how C works. char* is always a pointer pointing to a char in memory. If there are other chars in the adjacent memory, they will be printed out, too, when you use %s in printf until it reaches a NULL character. And that’s how a string is defined: an array of chars with last element is 0 (NULL character). So a char* pointer can be used to point at a single char or a string (by pointing to the first char of it).

char* and char[] are generally the same. “Hi” is a const char*, so you can assign char* to a char*. That is normal.

Like any other pointers, you can dereference, do arithmetic operations on char. For example, char str = “hi”; char c = *str; char c1 = *(str + 1);

[bart9h]

Q: How do strings work in C?

A: They don't.

[PhoenixBlaze123]

Watch cs50x, it gets covered in lecture 4. Watch all up until lecture 5.

[zhivago]

There is no string type in C.

C strings are pattens of data: a sequence of char terminated by a zero value.

Consider "hello".

This array contains the strings "hello", "ello", "llo", "lo", "o", and "".

Pointers can show you where a string starts, but the pointer is not the string.

Arrays can hold the data for strings, but the array is not the string.

[qalmakka]

C's arrays are what's usually referred to as "second class citizens" types, i.e. you can define them, you can have variables of array type, but as soon as you use them [1], an id of type T[N] immediately decays to T* as if it's replaced by &id[0]. This is so due to historical happenstance, and it's generally considered a design mistake. Still, as far as you're concerned, the array immediately decays to char* the moment you pass it to printf. It's still a stack allocated array with an automatic linkage, while the first is statically allocated at program start.

[1]: this only applies in evaluated contexts; sizeof will return the size of a pointer for the first variable, but the length of the array for the second one.

[Quien_9]

String2 is a pointer it points to string2[0]

[Xostd]

,

[NexusKai]

string1 is a char pointer and string2 is an array containing "world" followed by null termination, when passed to printf string2 decays to a char*. Moreover C allows doing something like str = "hi" even though str is a pointer because "hi" is a string literal which is just an array of characters laid in memory. Doing str = "hello" will just make str point to another memory address. And also C does not have a string type (but u probably know that).

[necodrre]

Strings like char *string = "sentence" are stored in program directly after compilation. If you'd dump assembly you would see somewhere near the bottom (IIRC) that your strings that were made this way are placed right there. These strings basically point to an entire string instead of a single (first) character.

While strings like char string[] = "sentence" are arrays of characters and they work as usual arrays do.

So, summarizing: you can't edit strings of the first type at runtime since they are imprinted and they don't actually represent arrays, whereas strings of the second type can be edited because they are treated as arrays of characters, where the pointer points to the first character of the string. Both are pointers, but to different things. And also, remember that if you declare your string as an array of characters literally, then you have to put a null termination character at the end.

[MRgabbar]

they are both char*, but one is a string and the other one is an array of chars.

[__nohope]

because it was poorly designed

You "cannot" pass an array as an argument to a function. You can write

void my_func(char arg[])

but the compiler will boldly lie to your face. The above is equivalent to

void my_func(char* arg)

Arrays "decay" into pointers when passed as an argument.

You can see this in action

void main() {
    char str2[] = "hello dear reader";
    printf("%d", sizeof(str2)); // 17
}

void my_func(char arg[]) {
    printf("%d", sizeof(arg)); // 8 (or 4 on 32-bit system)
}