String in C Language

 In C, a string is an array of characters terminated by a null character (`'\0'`). Strings in C are commonly represented as character arrays and provide a way to work with sequences of characters. Here's an example of working with strings in C:

```c
#include <stdio.h>

int main() {
    // Declaring and initializing a string
    char name[] = "John";

    // Printing the string
    printf("Name: %s\n", name);

    // Accessing individual characters
    printf("First character: %c\n", name[0]);
    printf("Second character: %c\n", name[1]);

    // Modifying characters
    name[2] = 'y';
    printf("Modified string: %s\n", name);

    // String input from the user
    char city[20];
    printf("Enter your city: ");
    scanf("%s", city);
    printf("City: %s\n", city);

    return 0;
}
```

Output:
```
Name: John
First character: J
Second character: o
Modified string: Jyhn
Enter your city: New York
City: New
```

In the above example:

- We declared and initialized a string `name` using double quotes. The null character is automatically appended to the end of the string.
- Individual characters of the string can be accessed using the index within square brackets (`[]`).
- We modified the third character of the string `name` to `'y'`.
- A string `city` was created to store user input using the `scanf` function. Note that `scanf` reads only until it encounters whitespace, so the input "New York" results in only "New" being stored in the `city` variable.

C does not provide a built-in string data type like some higher-level languages. Instead, strings are represented as character arrays. Several string manipulation functions, such as `strlen`, `strcpy`, `strcat`, `strcmp`, etc., are available in the `string.h` library to perform various operations on strings.

When working with strings in C, it is important to consider the size of the character array to avoid buffer overflow issues. It is recommended to use functions like `fgets` for reading strings from user input, as they provide better control over the input length.

Remember that strings in C are terminated by a null character, so the character array must have enough space to accommodate the string characters plus the null character at the end.