In C programming, a string is defined as a sequence of characters terminated with a null character ('\0'). Unlike a regular character array, the presence of this unique terminator distinguishes a C string from other arrays. This design is fundamental in handling text within C programs.
Understanding C strings is essential since they are employed in everything from basic text output to complex data manipulation. This guide explains how to declare, initialize, and manipulate C strings using practical examples.
C String Declaration Syntax
Declaring a string in C is as simple as declaring a one-dimensional array. The basic syntax is:
char string_name[size];
In this syntax, string_name is the identifier you choose, and size indicates the total number of characters that the string can store. It is crucial to reserve one extra slot for the null terminator ('\0'), which signals the end of the string.
C String Initialization
C strings can be initialized in various ways. Below are four common methods demonstrated with the string “cnhuadong”:
-
Assigning a String Literal without Specifying Size:
When you assign a string literal directly, the array size is determined automatically (including the null terminator).
char str[] = "cnhuadong"; -
Assigning a String Literal with a Predefined Size:
You can declare a string with a fixed size. Always remember to reserve one extra slot for the null character.
char str[50] = "cnhuadong"; -
Assigning Character by Character with Size:
A string may be initialized by assigning each character individually while ensuring the sequence ends with
'\0'.char str[10] = { 'c','n','h','u','a','d','o','n','g','\0' }; -
Assigning Character by Character without Specifying Size:
In this method, the compiler automatically determines the array size based on the characters provided.
char str[] = { 'c','n','h','u','a','d','o','n','g','\0' };
Note: When a sequence of characters is enclosed in double quotes, the compiler appends the null character ('\0') at the end automatically.
Example: Declaring, Initializing, and Printing a String
The following example illustrates how to declare a string, initialize it, and print both the string and its length using standard C functions:
// C program to illustrate string declaration, initialization, and printing
#include <stdio.h>
#include <string.h>
int main() {
// Declare and initialize a string
char str[] = "cnhuadong";
// Print the string
printf("%s\n", str);
// Calculate and print the length of the string using strlen()
int length = strlen(str);
printf("Length of string str is %d\n", length);
return 0;
}
In this example, the printf() function outputs the string “cnhuadong”, and strlen() calculates its length (excluding the null terminator).
Reading a String Input from the User
C allows you to read string input using various functions. A common method is to use scanf(), which reads input until a whitespace is encountered.
// C program to read a string using scanf()
#include <stdio.h>
int main() {
char str[50];
// Read string input from the user
scanf("%s", str);
// Print the input string
printf("%s", str);
return 0;
}
Note that scanf() stops reading when it encounters whitespace. To capture an entire line (including spaces), you can use fgets() or a scanset with scanf().
Using fgets() to Read a Full Line
// C program to read a string with spaces using fgets()
#include <stdio.h>
#define MAX 50
int main() {
char str[MAX];
// Read a line of input including whitespaces
fgets(str, MAX, stdin);
printf("String is:\n%s", str);
return 0;
}
Using Scanset in scanf() to Read a Full Line
// C program to read a full line using scanset in scanf()
#include <stdio.h>
int main() {
char str[50];
// Read input until a newline character is encountered
scanf("%[^\n]s", str);
printf("%s", str);
return 0;
}
Passing Strings to Functions
Since C strings are essentially character arrays, they can be passed to functions just like any other array. The function receives the address of the first element, which allows it to process the entire string.
// C program to illustrate passing a string to a function
#include <stdio.h>
void printStr(char str[]) {
printf("String is: %s", str);
}
int main() {
char str[] = "cnhuadong";
printStr(str);
return 0;
}
Strings and Pointers in C
In C, the name of an array represents the address of its first element. This allows you to use pointers to access and manipulate strings. The pointer starts at the first character and is incremented until the null terminator is reached.
// C program to print a string using pointers
#include <stdio.h>
int main() {
char str[20] = "cnhuadong";
char *ptr = str; // Pointer to the first element of str
// Traverse and print each character until the null terminator
while (*ptr != '\0') {
printf("%c", *ptr);
ptr++;
}
return 0;
}
Standard C Library – string.h Functions
The C language includes the string.h header, which provides various functions to facilitate string manipulation. Key functions include:
| Function | Description |
|---|---|
strlen(string_name) |
Returns the length of the string (number of characters before the null terminator). |
strcpy(s1, s2) |
Copies the contents of string s2 into s1, including the null terminator. |
strcmp(str1, str2) |
Compares two strings lexicographically; returns 0 if they are identical. |
strcat(s1, s2) |
Concatenates string s2 to the end of string s1. |
strlwr() |
Converts all uppercase characters in a string to lowercase. |
strupr() |
Converts all lowercase characters in a string to uppercase. |
strstr(s1, s2) |
Finds the first occurrence of string s2 within s1. |
Always ensure that destination arrays have sufficient capacity when using functions like strcpy() and strcat() to prevent buffer overflows.
C String Example
// C program to illustrate strings
#include <stdio.h>
#include <string.h>
int main()
{
// declare and initialize string
char str[] = "Geeks";
// print string
printf("%s\n", str);
int length = 0;
length = strlen(str);
// displaying the length of string
printf("Length of string str is %d", length);
return 0;
}
Output:
Geeks Length of string str is 5
Reading a String Input from the User
The next example shows how to use scanf() to read a string from the user. Note that scanf() reads input only until a whitespace is encountered.
// C program to read a string from the user using scanf()
#include <stdio.h>
int main() {
char str[50];
// Read string input from the user (input stops at the first whitespace)
scanf("%s", str);
// Print the input string
printf("%s\n", str);
return 0;
}
/* If the user types:
cnhuadong for testing
Expected Output:
cnhuadong
(Only the first word "cnhuadong" is read.)
*/
Reading a String Containing Whitespaces
To read an entire line (including spaces), you can use either fgets() or a scanset with scanf().
Using fgets()
// C program to read a full line using fgets()
#include <stdio.h>
#define MAX 50
int main() {
char str[MAX];
// Read a line of text (including spaces) from standard input
fgets(str, MAX, stdin);
printf("The string is:\n%s", str);
return 0;
}
/* Example:
Input: cnhuadong is awesome
Expected Output:
The string is:
cnhuadong is awesome
*/
Using Scanset with scanf()
// C program to read a full line using scanset in scanf()
#include <stdio.h>
int main() {
char str[50];
// Read input until a newline is encountered
scanf("%[^\n]s", str);
printf("%s\n", str);
return 0;
}
/* Example:
Input: cnhuadong is awesome
Expected Output:
cnhuadong is awesome
*/
Calculating the Length of a C String
The length of a C string is the number of characters before the null terminator ('\0'). You can easily determine this length using a loop or the strlen() function.
// C program to calculate the length of a string using strlen()
#include <stdio.h>
#include <string.h>
int main() {
char str[] = "cnhuadong";
printf("Length: %zu\n", strlen(str));
return 0;
}
/* Expected Output:
Length: 9
*/
Passing Strings to Functions
Since strings in C are essentially arrays of characters, they can be passed to functions in the same way as arrays. The following example shows how to pass a string to a function for printing.
// C program to demonstrate passing a string to a function
#include <stdio.h>
void printStr(char str[]) {
printf("The string is: %s\n", str);
}
int main() {
char str[] = "cnhuadong";
printStr(str);
return 0;
}
/* Expected Output:
The string is: cnhuadong
*/
Practical Applications and Takeaways
C strings are a core component of C programming. They provide the flexibility and control necessary for efficient text processing, but they require careful memory management and attention to detail—especially regarding the null terminator.
In this guide, we demonstrated various methods for declaring and initializing strings, safe input techniques, and standard library functions that facilitate string manipulation. Whether you are passing strings to functions or working with pointers, the techniques covered here will help you avoid common pitfalls like buffer overflows and memory leaks.
Mastering these concepts will enable you to build robust, efficient applications, and give you a deeper understanding of how textual data is managed at a low level.
Frequently Asked Questions (FAQ)
1. How do I determine the length of a C string?
You can use the strlen() function from the string.h library. This function counts the number of characters in a string until it reaches the null terminator.
#include <stdio.h>
#include <string.h>
int main() {
char str[] = "cnhuadong";
printf("Length: %zu\n", strlen(str));
return 0;
}
2. Why must I reserve an extra slot for the null terminator?
The null terminator ('\0') signals the end of a string. Without it, functions that process strings (like printf or strlen) would continue reading memory past the intended end, which can lead to undefined behavior.
3. How can I safely copy one string to another?
Use strncpy() to copy a specified number of characters, ensuring that the destination array is not overflowed. Always manually set the last character of the destination array to '\0' if necessary.
#include <stdio.h>
#include <string.h>
int main() {
char source[] = "cnhuadong";
char destination[20];
strncpy(destination, source, sizeof(destination) - 1);
destination[sizeof(destination) - 1] = '\0';
printf("Copied: %s\n", destination);
return 0;
}
4. How do I read a string with spaces from user input?
To read a full line of text (including spaces), use fgets() or a scanset with scanf().
// Using fgets():
#include <stdio.h>
#define MAX 50
int main() {
char str[MAX];
fgets(str, MAX, stdin);
printf("Input: %s", str);
return 0;
}
5. Can I modify a string literal?
No, string literals are stored in read-only memory. If you need to modify a string, declare it as a character array.
#include <stdio.h>
int main() {
char str[] = "modifiable";
str[0] = 'M'; // This is safe because str is a character array
printf("%s\n", str);
return 0;
}