Strings
Strings are defined as an array of characters. The difference between a character array
and a string is the string is terminated with a special character ‘\0’.
Declaration of strings:
Declaring a string is as simple as declaring a one dimensional array. Below is the basic
syntax for declaring a string.
char str_name[size];
In the above syntax str_name is any name given to the string variable and size is used
define the length of the string, i.e the number of characters strings will store. Please
keep in mind that there is an extra terminating character which is the Null character (‘\0’)
used to indicate termination of string which differs strings from normal character arrays.
Initializing a String:
A string can be initialized in different ways. We will explain this with the help of an
example. Below is an example to declare a string with name as str and initialize it with
“HelloHiHello”.
1. char str[] = "HelloHiHello";
2. char str[50] = "HelloHiHello";
3. char str[] = {'H','e','l','l','o','H','i','H','e','l','l','o','\0'};
4. char str[14] = {'H','e','l','l','o','H','i','H','e','l','l','o','\0'};
Below is the memory representation of a string “Hello”.
0 1 2 3 4 5
Str H e l l o \0
Address 12345 12346 12347 12348 12349 12350
Let us now look at a sample program to get a clear understanding of declaring and
initializing a string in C and also how to print a string.
// C program to illustrate strings
#include<stdio.h>
int main()
{
// declare and initialize string
char str[] = "Hello";
// print string
printf("%s",str);
return 0;
}
Output:
Hello
We can see in the above program that strings can be printed using a normal printf
statements just like we print any other variable. Unlike arrays we do not need to print a
string, character by character. The C language does not provide an inbuilt data type for
strings but it has an access specifier “%s” which can be used to directly print and read
strings.
Below is a sample program to read a string from user:
// C program to read strings
#include<stdio.h>
int main()
{
// declaring string
char str[50];
// reading string
scanf("%s",str);
// print string
printf("%s",str);
return 0;
}
You can see in the above program that string can also be read using a single scanf
statement. Also you might be thinking that why we have not used the ‘&’ sign with string
name ‘str’ in scanf statement! To understand this you will have to recall your knowledge
of scanf. We know that the ‘&’ sign is used to provide the address of the variable to the
scanf() function to store the value read in memory. As str[] is a character array so using
str without braces ‘[‘ and ‘]’ will give the base address of this string. That’s why we have
not used ‘&’ in this case as we are already providing the base address of the string to
scanf.
Passing strings to function:
As strings are character arrays, so we can pass strings to function in a same way we
pass an array to a function. Below is a sample program to do this:
// C program to illustrate how to
// pass string to functions
#include<stdio.h>
void printStr(char str[])
{
printf("String is : %s",str);
}
int main()
{
// declare and initialize string
char str[] = "HelloHiHello";
// print string by passing string
// to a different function
printStr(str);
return 0;
}
Output:
String is : HelloHiHello
String handling Functions:
Few commonly used string handling functions are discussed below:
Functio
Working
n
strlen() Calculates the length of string
strcpy() Copies a string to another string
strcat() Concatenates(joins) two strings
strcmp() Compares two string
strlwr() Converts string to lowercase
strupr() Converts string to uppercase
Strings handling functions are defined under "string.h" header file.
#include <string.h>
Note: You have to include the code below to run string handling functions.
gets() and puts()
Functions gets() and puts() are two string functions to take string input from the user
and display it respectively as mentioned in the previous chapter.
#include<stdio.h>
int main()
{
char name[30];
printf("Enter name: ");
gets(name); //Function to read string from user.
printf("Name: ");
puts(name); //Function to display string.
return 0;
Note: Though, gets() and puts() function handle strings, both these functions are defined
in "stdio.h" header file.
C String function – strlen
Syntax:
size_t strlen(const char *str)
size_t represents unsigned short
It returns the length of the string without including end character (terminating char ‘\0’).
Example of strlen:
#include <stdio.h>
#include <string.h>
int main()
char str1[20] = "BeginnersBook";
printf("Length of string str1: %d", strlen(str1));
return 0;
}
Output: Length of string str1: 13
strlen vs sizeof
strlen returns you the length of the string stored in array, however sizeof returns the
total allocated size assigned to the array. So if I consider the above example again then
the following statements would return the below values.
strlen(str1) returned value 13.
sizeof(str1) would return value 20 as the array size is 20 (see the first statement in main
function).
C String function – strnlen
Syntax:
size_t strnlen(const char *str, size_t maxlen)
size_t represents unsigned short
It returns length of the string if it is less than the value specified for maxlen (maximum
length) otherwise it returns maxlen value.
Example of strnlen:
#include <stdio.h>
#include <string.h>
int main()
char str1[20] = "BeginnersBook";
printf("Length of string str1 when maxlen is 30: %d", strnlen(str1, 30));
printf("Length of string str1 when maxlen is 10: %d", strnlen(str1, 10));
return 0;
}
Output:
Length of string str1 when maxlen is 30: 13
Length of string str1 when maxlen is 10: 10
Have you noticed the output of second printf statement, even though the string length
was 13 it returned only 10 because the maxlen was 10.
C String function – strcmp
int strcmp(const char *str1, const char *str2)
It compares the two strings and returns an integer value. If both the strings are same
(equal) then this function would return 0 otherwise it may return a negative or positive
value based on the comparison.
If string1 < string2 OR string1 is a substring of string2 then it would result in a negative
value. If string1 > string2 then it would return positive value.
If string1 == string2 then you would get 0(zero) when you use this function for compare
strings.
Example of strcmp:
#include <stdio.h>
#include <string.h>
int main()
char s1[20] = "BeginnersBook";
char s2[20] = "[Link]";
if (strcmp(s1, s2) ==0)
{
printf("string 1 and string 2 are equal");
}else
printf("string 1 and 2 are different");
return 0;
Output:
string 1 and 2 are different
C String function – strncmp
int strncmp(const char *str1, const char *str2, size_t n)
size_t is for unassigned short
It compares both the string till n characters or in other words it compares first n
characters of both the strings.
Example of strncmp:
#include <stdio.h>
#include <string.h>
int main()
char s1[20] = "BeginnersBook";
char s2[20] = "[Link]";
/* below it is comparing first 8 characters of s1 and s2*/
if (strncmp(s1, s2, 8) ==0)
printf("string 1 and string 2 are equal");
}else
printf("string 1 and 2 are different");
return 0;
Output:
string1 and string 2 are equal
C String function – strcat
char *strcat(char *str1, char *str2)
It concatenates two strings and returns the concatenated string.
Example of strcat:
#include <stdio.h>
#include <string.h>
int main()
{
char s1[10] = "Hello";
char s2[10] = "World";
strcat(s1,s2);
printf("Output string after concatenation: %s", s1);
return 0;
Output:
Output string after concatenation: HelloWorld
C String function – strncat
char *strncat(char *str1, char *str2, int n)
It concatenates n characters of str2 to string str1. A terminator char (‘\0’) will always be
appended at the end of the concatenated string.
Example of strncat:
#include <stdio.h>
#include <string.h>
int main()
char s1[10] = "Hello";
char s2[10] = "World";
strncat(s1,s2, 3);
printf("Concatenation using strncat: %s", s1);
return 0;
Output:
Concatenation using strncat: HelloWor
C String function – strcpy
char *strcpy( char *str1, char *str2)
It copies the string str2 into string str1, including the end character (terminator char ‘\0’).
Example of strcpy:
#include <stdio.h>
#include <string.h>
int main()
char s1[30] = "string 1";
char s2[30] = "string 2 : I’m gonna copied into s1";
/* this function has copied s2 into s1*/
strcpy(s1,s2);
printf("String s1 is: %s", s1);
return 0;
}
Output:
String s1 is: string 2: I’m gonna copied into s1
C String function – strncpy
char *strncpy( char *str1, char *str2, size_t n)
size_t is unassigned short and n is a number.
Case1: If length of str2 > n then it just copies first n characters of str2 into str1.
Case2: If length of str2 < n then it copies all the characters of str2 into str1 and appends
several terminator chars(‘\0’) to accumulate the length of str1 to make it n.
Example of strncpy:
#include <stdio.h>
#include <string.h>
int main()
char first[30] = "string 1";
char second[30] = "string 2: I’m using strncpy now";
/* this function has copied first 10 chars of s2 into s1*/
strncpy(s1,s2, 12);
printf("String s1 is: %s", s1);
return 0;
Output:
String s1 is: string 2: I’m
C String function – strchr
char *strchr(char *str, int ch)
It searches string str for character ch (you may be wondering that in above definition I
have given data type of ch as int, don’t worry I didn’t make any mistake it should be int
only. The thing is when we give any character while using strchr then it internally gets
converted into integer for better searching.
Example of strchr:
#include <stdio.h>
#include <string.h>
int main()
char mystr[30] = "I’m an example of function strchr";
printf ("%s", strchr(mystr, 'f'));
return 0;
Output:
f function strchr
C String function – Strrchr
char *strrchr(char *str, int ch)
It is similar to the function strchr, the only difference is that it searches the string in
reverse order, now you would have understood why we have extra r in strrchr, yes you
guessed it correct, it is for reverse only.
Now let’s take the same above example:
#include <stdio.h>
#include <string.h>
int main()
char mystr[30] = "I’m an example of function strchr";
printf ("%s", strrchr(mystr, 'f'));
return 0;
Output:
function strchr
Why output is different than strchr? It is because it started searching from the end of the
string and found the first ‘f’ in function instead of ‘of’.
C String function – strstr
char *strstr(char *str, char *srch_term)
It is similar to strchr, except that it searches for string srch_term instead of a single char.
Example of strstr:
#include <stdio.h>
#include <string.h>
int main()
{
char inputstr[70] = "String Function in C at [Link]";
printf ("Output string is: %s", strstr(inputstr, 'Begi'));
return 0;
Output:
Output string is: [Link]
You can also use this function in place of strchr as you are allowed to give single char
also in place of search_term string.
Passing String to Functions:
Simplest Solution
The simplest solution to whatever problem you’re encountering is to declare that string
as a global variable, but I’m guessing you won’t be satisfied with that answer, so here
goes!
In C, a string is declared as a character array. So if you want to declare a string globally
(as stated above) you can do so in the following manner:
#define SIZE 200
char s[SIZE];
/* you can also define it as a character pointer i.e. as char *s, they behave identically*/
Passing a string to a method
But in order to pass the string a.k.a the character array to a function, you need to
specify the array name in the parameter list (and maybe a few additional parameters as
well). Take note that you should only mention the name of the array without the square
brackets, in the parameter list of the function calling statement. However, you must
keep the square brackets in the function signature, so that the compiler can understand
an array will be passed. Typically, a sample code would look somewhat like this:
#define SIZE 200
void pass_string(char s[]) //keep square brackets in signature
printf("%s",s);
int main()
char a[SIZE];
pass_string(a); //specify only function name in calling statement
return 0;
Returning a string from a method
In order to return a string from a function, you’d need to declare the function return type
as a character pointer. Note that in the comment in the first code sample I’ve mentioned
that the character pointer and a character array behaves identically in C. The fact is,
that in C every array is created in the memory by allocating the base address to the
variable name, implicitly. As a result, when you define a character array as
char s_check[SIZE];
The compiler associates a base address to the variable s_check. From this address,
any index in the entire array can be accessed. It almost behaves as if it is a pointer
variable.
Judging from what I said above, I think you’ve got the reason to specify the return type
of the function as a character pointer. A sample code is given below.
#define SIZE 200
#include <stdio.h>
char* return_string()
{
static char s[SIZE]="My name is X";
return s;
int main()
printf("%s", return_string());
return 0;
I am accessing the string returned in the printf statement and printing it. That is how you
can return a string to a function.
Passing and returning a string together
Of course, you can have multiple combinations of the techniques, and the one most
frequently required is that you need to pass a string to a function and return a string as
well. In that case, you’d need to specify the return type as character pointer and put a
character pointer in the parameter list of the function declaration prototype as well,
somewhat like this:
char *return_and_pass(char s[]) // OR char return_and_pass(char *s)
s[0]='A'; //modify passed string
return s; //return it
int main()
char a[]="Hello!";
printf("%s",return_and_pass(a));
return 0;