Understanding the Difference Between char s[] and char *s in C

C String Char Constants

When working with strings in the C programming language, you have the option to use either char s[] or char *s to store and manipulate string values. While both constructs allow you to work with strings, there are important differences in their behavior and usage. In this article, we will explore the difference between char s[] and char *s in terms of storage duration, both at compile time and run time.

Understanding char s[]

When you declare a string using char s[] = "hello";, you are creating an array of characters with an explicitly defined size. In this case, the size of the array is determined by the length of the string literal "hello". The characters of the string are stored in consecutive memory locations, with an extra element for the null-terminator character (\0) at the end.

This means that when you declare char s[] = "hello";, the compiler allocates memory for the characters in the string literal, including the null-terminator, and stores them in the array. The array itself has automatic storage duration, meaning it is allocated on the stack and its memory is released when it goes out of scope.

Here is an example to illustrate this:


#include 

int main() {
    char s[] = "hello";
    printf("%s\n", s);
    return 0;
}

In this example, the string "hello" is stored in the s array, which has automatic storage duration. The contents of the array can be modified, allowing you to change the characters of the string if needed. However, the size of the array is fixed and cannot be changed.

Understanding char *s

On the other hand, when you declare a string using char *s = "hello";, you are creating a pointer to a string literal. The string literal "hello" is stored in the read-only data segment of the program, and the pointer s is initialized to point to this memory location.

Unlike char s[], the char *s declaration does not allocate any memory for the string itself. Instead, it simply points to the memory location where the string literal is stored.

Here is an example:


#include 

int main() {
    char *s = "hello";
    printf("%s\n", s);
    return 0;
}

In this example, the pointer s is pointing to the string literal "hello" in the read-only data segment. Since the string literal is read-only, you cannot modify the characters of the string using the char *s declaration.

Difference in Memory Usage

The key difference between char s[] and char *s is how they handle memory usage. char s[] allocates memory for the string itself, allowing you to modify its contents, but the size of the array is fixed. char *s, on the other hand, does not allocate any memory for the string and can only point to read-only string literals.

It's important to note that if you attempt to modify a string pointed to by char *s, it will likely result in undefined behavior and can lead to program crashes or unexpected results. To avoid this issue, you can use char s[] when you need to modify the string, or you can allocate memory dynamically using functions like malloc() and assign the pointer to the dynamically allocated memory.

Conclusion

In summary, the difference between char s[] and char *s lies in how they handle memory usage and the ability to modify the string. char s[] allocates memory for the string and allows modifications, while char *s only points to read-only string literals. Understanding these differences helps you choose the right approach based on your needs.

Remember to consider the storage duration, possible modifications, and memory usage when deciding between char s[] and char *s in your C programs.

Related Questions