In C, string literals are constant sequences of characters enclosed in double quotes ("). They are used to represent fixed strings in your code and can be assigned to string variables or used directly in functions. String literals are stored in read-only memory, which means they cannot be modified after creation.

Key Concepts of String Literals

1. Definition:

   • A string literal is a series of characters enclosed in double quotes, followed by an implicit null terminator ('\0') that marks the end of the string.

   Example:

   "Hello, World!" // This is a string literal
   

2. Type:

   • The type of a string literal is char[], which is an array of characters.

3. Initialization:

   • String literals can be assigned to character arrays or pointers. When assigned to a character array, the size must accommodate the string and the null terminator.

   Example:

   char str1[] = "Hello";  // Size is automatically determined (size = 6)
   const char *str2 = "World"; // Pointer to a string literal
   

4. Read-Only Nature:

   • Modifying a string literal leads to undefined behavior, as they are stored in read-only memory. Always use character arrays if you need to modify the string.

   Example of Undefined Behavior:

   char *str = "Hello";
   str[0] = 'h'; // Undefined behavior, as str points to a string literal
   

5. Escape Sequences:

   • String literals can include escape sequences to represent special characters, such as newline (\n), tab (\t), backslash (\\), and quotes (\").

   Example:

   char str[] = "Hello,\nWorld!"; // Contains a newline character
   

6. Concatenation:

   • String literals can be concatenated simply by placing them next to each other. The compiler automatically merges them into a single string.

   Example:

   char str[] = "Hello, " "World!"; // Equivalent to "Hello, World!"
   

Example Usage of String Literals

Here’s a simple example demonstrating the use of string literals in C:

#include <stdio.h>

int main() {
    // Using string literals
    const char *greeting = "Hello, World!";
    char message[50] = "The message is: ";

    // Concatenating string literals
    strcat(message, greeting); // Requires #include <string.h>

    // Printing the string literals and concatenated string
    printf("%s\n", greeting);
    printf("%s\n", message);

    return 0;
}

Explanation of the Example

1. String Literal Initialization:

   • The pointer greeting points to the string literal "Hello, World!", while message is a character array initialized with another string literal.

2. Concatenation:

   • The strcat() function is used to concatenate greeting to message. Note that message has enough space to hold the combined string.

3. Output:

   • The printf() function prints both the string literal and the concatenated message.

Important Points About String Literals

1. Storage:

   • String literals are typically stored in a read-only section of memory, which prevents accidental modifications.

2. Null Terminator:

   • Each string literal is automatically null-terminated. This is crucial for functions that work with strings to know where the string ends.

3. Lifetime:

   • The lifetime of a string literal lasts for the duration of the program. They are automatically deallocated when the program terminates.

4. Compiler Optimization:

   • The compiler may optimize string literals, sharing them across multiple uses in the code to save memory.

5. Multiple Lines:

   • String literals cannot span multiple lines directly. To create a multi-line string, you can use escape sequences or concatenate multiple string literals.

   Example:

   char *multiLine = "This is the first line.\n"
                     "This is the second line.";