Strings in C

A string is an array of characters terminated by a special character '\0' (null character). This null character marks the end of the string and is essential for proper string manipulation.

Unlike many modern languages, C does not have a built-in string data type. Instead, strings are implemented as arrays of char.

#include <stdio.h>

int main() {
    
    // declaring and initializing a string
    char str[] = "Geeks";

    // printing the string
    printf("The string is: %s\n", str);

    return 0;
}

The string is: Geeks

• char str[] = "Geeks";
  This line declares a character array str and initializes it with the string "Hello World!". Internally, this creates an array like:
  { 'G', 'e', 'e', 'k', 's', '\0'}
  The null character '\0' is automatically added at the end to terminate the string.
• printf("The string is: %s\n", str);
%s is the format specifier used to print a string. printf starts at the memory location of str and prints each character until it finds the terminating null character '\0'.

Declaration

Declaring a string is as simple as declaring a one-dimensional array of character type. Below is the syntax for declaring a string.

char string_name[size];

In the above syntax string_name is any name given to the string variable and size is used to define the length of the string, i.e. the number of characters strings will store.

Like array, we can skip the size in the above statement:

char array_name[];

Initialization

We can initialize a string either by specifying the list of characters or string literal.

// Using character list
char str[] = {'G', 'e', 'e', 'k', 's', '\0'};

// Using string literal
char str[] = "Geeks";

Note: When a Sequence of characters enclosed in the double quotation marks is encountered by the compiler, a null character '\0' is appended at the end of the string by default.

Accessing

We can access any character of the string by providing the position of the character, like in array. We pass the index inside square brackets [] with the name of the string.

Example:

#include <stdio.h>

int main() {
    
    char str[] = "Geeks";
    
    // Access first character
    // of string
    printf("%c", str[0]);
    return 0;
}

Update

Updating a character in a string is also possible. We can update any character of a string by using the index of that character.

Example:

#include <stdio.h>

int main() {
    char str[] = "Geeks";
    
    // Update the first
    // character of string
    str[0] = 'R';
    printf("%c", str[0]);
    return 0;
}

R

String Length

To find the length of a string in C, you need to iterate through each character until you reach the null terminator '\0', which marks the end of the string. This process is handled efficiently by the strlen() function from the C standard library.

Example:

#include <stdio.h>

int main() {
    char str[] = "Geeks";
    
    printf("%d", strlen(str));
    return 0;
}

5

In this example, strlen() returns the length of the string "Geeks", which is 5, excluding the null character.

C language also provides several other useful string library functions to perform operations like copying, comparing, and concatenating strings. You can refer to standard string functions for more details.

String Input

In C, reading a string from the user can be done using different functions, and depending on the use case, one method might be chosen over another. Below, the common methods of reading strings in C will be discussed, including how to handle whitespace, and concepts will be clarified to better understand how string input works.

Using scanf()

The simplest way to read a string in C is by using the scanf() function.

Example:

#include<stdio.h>
  
int main() {
    char str[5];
      
    // Read string
    // from the user
    scanf("%s",str);
      
    // Print the string
    printf("%s",str);
    return 0;
}

Output

Geeks (Enter by user)
Geeks

In the above program, the string is taken as input using the scanf() function and is also printed. However, there is a limitation with the scanf() function. scanf() will stop reading input as soon as it encounters a whitespace (space, tab, or newline).

Using scanf() with a Scanset

We can also use scanf() to read strings with spaces by utilizing a scanset. A scanset in scanf() allows specifying the characters to include or exclude from the input.

Example:

#include <stdio.h>

int main() {
    char str[20];

    // Using scanset in scanf 
    // to read until newline
    scanf("%[^\n]s", str);

    // Printing the read string
    printf("%s", str);

    return 0;
}

Output

Geeks For Geeks (Enter by user)
Geeks For Geeks

Using fgets()

If someone wants to read a complete string, including spaces, they should use the fgets() function. Unlike scanf(), fgets() reads the entire line, including spaces, until it encounters a newline.

Example:

#include <stdio.h>

int main() {
    char str[20];

    // Reading the string 
    // (with spaces) using fgets
    fgets(str, 20, stdin);

    // Displaying the string using puts
    printf("%s", str);
    return 0;
}

Output

Geeks For Geeks (Enter by user)
Geeks For Geeks

Passing Strings to Function

As strings are character arrays, we can pass strings to functions in the same way we pass an array to a function. Below is a sample program to do this: 

#include <stdio.h>

void printStr(char str[]) {
    printf("%s", str);
}

int main() {
    char str[] = "GeeksforGeeks";

    // Passing string to a 
    // function
    printStr(str);
    return 0;
}

GeeksforGeeks

Strings and Pointers in C

Similar to arrays, In C, we can create a character pointer to a string that points to the starting address of the string which is the first character of the string. The string can be accessed with the help of pointers as shown in the below example.

#include <stdio.h>

int main(){

    char str[20] = "Geeks";

    // Pointer variable which stores
    // the starting address of
    // the character array str
    char* ptr = str;

    // While loop will run till 
    // the character value is not
    // equal to null character
    while (*ptr != '\0') {
        printf("%c", *ptr);
        ptr++;
    }
    return 0;
}

Geeks

So far, we've seen how to declare and use strings as character arrays. But in C, strings can also be represented using string literals, which offer a simpler way to initialize strings directly in the code. Let's understand what string literals are and how they work.

Strings Literals

A string literal is a sequence of characters enclosed in double quotes, like "Hello" or "1234". Internally, it is stored as a constant character array terminated by a null character '\0'.

#include <stdio.h>

int main() {
    
    // pointer to a string literal
    const char *str = "Hello World";

    printf("%s\n", str);

    return 0;
}

Hello World

• "Hello World" is a string literal. It is stored in a read-only section of memory.
• const char *str = "Hello World";
  This creates a pointer to the string literal. Using const is important because string literals should not be modified.
• printf("%s\n", str); prints the string starting from the address stored in str.

Key Points

• String literals are automatically null-terminated.
• They are typically stored in read-only memory, so modifying them causes undefined behavior.
• You can assign string literals to char*, but it's recommended to use const char* for safety.