Principles of Programming

Chapter 8: Character & String

 In this chapter, you’ll learn about;

 Fundamentals of Strings and Characters
 The difference between an integer digit and a
character digit
 Character handling library
 String conversion functions
 Standard input/output library functions
 String manipulation functions

NI S1 2009/10
1
 Principles of Programming

Fundamentals of Characters and

Strings
 Characters in C consist of any printable or
nonprintable character in the computer’s
character set including lowercase letters,
uppercase letters, decimal digits, special
characters and escape sequences.
 A character is usually stored in the computer
as an 8-bits (1 byte) integer.
 The integer value stored for a character
depends on the character set used by the
computer on which the program is running.

2
 Principles of Programming

Fundamentals of Characters and Strings

 There are two commonly used character sets:

 ASCII (American Standard Code for Information
Interchange)
 EBCDIC (Extended Binary Coded Decimal Interchange
Code)

3
 Principles of Programming

Difference between an integer digit and a character digit

 char num = 1 and char num = ‘1’ are not the

same.
 char num = 1 is represented in the computer
as 00000001.
 char num = ‘1’ on the other hand is number
49 according to the ASCII character set.
Therefore, it is represented in the computer
as 00110001.

4
 Principles of Programming

Example: ASCII character

#include <stdio.h> ASCII value for A is 65
ASCII value for Z is 90
int main(void) ASCII value for a is 97
{ ASCII value for z is 122
char my_A = 'A';
char my_Z = 'Z'; 65 in ASCII represents A
char my_a = 'a'; 90 in ASCII represents Z
97 in ASCII represents a
char my_z = 'z';
122 in ASCII represents z
printf("\nASCII value for A is %d", my_A);
printf("\nASCII value for Z is %d",my_Z);
printf("\nASCII value for a is %d", my_a);
printf("\nASCII value for z is %d",my_z);

printf("\n");
printf("\n65 in ASCII represents %c",65);
printf("\n90 in ASCII represents %c",90);
printf("\n97 in ASCII represents %c",97);
printf("\n122 in ASCII represents %c",122);

return(0);
}

5
 Principles of Programming

Example cont…
#include <stdio.h> #include <stdio.h>
   
void main(void) void main(void)
{ {
char ch; char ch;
   
printf("enter a character: "); printf("enter a character: ");
scanf("%c", &ch); scanf("%c", &ch);
   
if (ch >= 'A' && ch <= 'Z') if (ch >= 65 && ch <= (65+26))
{ {
printf("\ncapital letter\n"); printf("\ncapital letter\n");
} }
return (0); return (0);
} }

equivalent to
6
 Principles of Programming

Character Handling Library

 Character handling library includes several function
that perform useful tests and manipulation of character
data.
 Each function receives a character, represented as an
int or EOF, as an argument.
 When using functions from the character handling
library, the header file <ctype.h> needs to be included.
 Characters in these functions are manipulated as
integers (since a character is basically a 1 byte
integer).

7
 Prototype Function Descriptions

int isdigit(int c) Returns a true if value c is a digit, and 0 (false) otherwise.

int isalpha(int c) Returns a true if value c is a letter, and 0 otherwise.
int isalnum(int c) Returns a true if value c is a digit or a letter, and 0 otherwise.
int isxdigit(int c) Returns a true value if c is a hexadecimal digit character, and 0 otherwise.
int islower(int c) Returns a true value if c is a lowercase letter, and 0 otherwise.
int isupper(int c) Returns a true value if c is an uppercase letter, and 0 otherwise.
int tolower(int c) If c is an uppercase letter, tolower returns c as a lowercase letter. Otherwise,
tolower returns the argument unchanged.
int toupper(int c) If c is a lowercase letter, toupper returns c as an uppercase letter. Otherwise
toupper returns the argument unchanged.
int isspace(int c) Returns true if c is a white space character – newline (‘\n’), space (‘ ’), form feed
(‘\f’), carriage return (‘\r’), horizontal tab (‘\t’) or vertical tab (‘\v’) – and 0
otherwise.
int iscntrl(int c) Returns a true if c is a control character, and 0 otherwise.
int ispunct(int c) Returns a true if c is a printing character other than a space, a digit or a letter, and
0 otherwise.
int isprint(int c) Returns a true value if c is a printing character including space (‘ ’), and 0
otherwise.
int isgraph(int c) Returns a true value if c is a printing character other than space (‘ ’), and 0
otherwise.
8
 Principles of Programming

Example
#include <stdio.h>
#include <ctype.h>

int main(void)
{
char loop = 'y';
char my_char;

while (loop == 'y' || loop == 'Y')

{
fflush(stdin);
printf("Enter a character: ");
my_char = getchar();

if (isalpha(my_char))
{
printf("The character is an alphabet\n");

if (islower(my_char))
printf("and it is also a lower case alphabet\n");
if (isupper(my_char))
printf("and it is also an upper case alphabet\n");
}
if (isdigit(my_char))
printf("The character is a digit\n");

if (ispunct(my_char))
printf("The character is a punctuator\n");

fflush(stdin);
printf("\nanother character? [y = yes, n = no]: ");
loop = getchar();
printf("\n");
} return (0); 9
}
 Principles of Programming

Example
#include <stdio.h>
#include <ctype.h>
#include <string.h>

int main(void)
{
char string[50];
int length, i, alpha = 0, digit = 0, space = 0;
printf("Enter a string: ");
gets(string);

length = strlen(string);
for (i = 0; i < length; i++)
{
if (isalpha(string[i]))
alpha++;
if (isdigit(string[i]))
digit++;
if (isspace(string[i]))
space++;
}

printf("%s has %d alphabet, %d digit and %d space \n",string,alpha,digit,space);

return(0);
}

10
 Principles of Programming

Fundamentals of Characters and Strings

 A string in C is an array of characters ending
with the null character (‘\0’). It is written inside
a double quotation mark (“ ”)
 A string may be assigned (in a declaration) to
either a char array or to a char pointer:
 char color[] = “green”; OR
 char *color = “green”;

11
 Principles of Programming

Fundamentals of Characters and Strings

 A string can also be defined by specifying the

individual characters:
 char color[ ] = {‘g’, ‘r’, ‘e’, ‘e’, ‘n’, ‘\0’};
 A string is accessed via a pointer to the first
character in the string.
 In memory, these are the characters stored:

g r e e n \0

12
 Principles of Programming

Fundamentals of Characters and Strings

 Notice that even though there are only five
characters in the word ‘green’, six characters are
stored in the computer. The last character, the
character ‘\0’, is the NULL character which
indicates the end of the string.
 Therefore, if an array of characters is to be used
to store a string, the array must be large enough
to store the string and its terminating NULL
character.
char color[6] = “green”;

The minimum size of a string

must at least the ‘total no of char
in the string + 1’

13
 Principles of Programming

Briefly review about strings :

 We can initialize string variables at compile
time such as;
 char name[10] = “Arris”;
 This initialization creates the following spaces in
storage :

A r r i s \0 \0 \0 \0 \0
[0] [1] [2] [3] [4] [5] [6] [7] [8] [9]

14
 Principles of Programming

Fundamentals of Characters and

Strings
 If we happen to declare a string like this:
char my_drink[3] = “tea”;

 We will get the following syntax error:

error C2117: 'tea' : array bounds overflow

 Instead, we need to at least declare the array

with (the size of the string + 1) to accommodate
the null terminating character ‘\0’.
char my_drink[4] = “tea”;

15
 Principles of Programming

Example: string and ‘\0’

#include <stdio.h>

int main(void) /* a program that counts the number of characters in a string */

{

char sentence[20] = "I love Malaysia";

int i, count = 0;

for (i = 0; sentence[i] != '\0'; i++)

{
count++;
}

printf(“%s has %d characters including the whitespace", sentence, count);

return (0);
} Sample output:
I love Malaysia has 15 characters including the whitespace
16
 Principles of Programming

Briefly review about strings :

 Standard Functions Input
 scanf( )
 gets( )
 Standard Functions Output
 printf( )
 puts( )
 Use scanf function together with the format specifier
%s for interactive input string. (no whitespace
character)
 If the string to be read as an input has embedded
whitespace characters, use standard gets function.

17
 Principles of Programming

Example: gets/puts and scanf/printf

#include <stdio.h>
int main(void)
{
char string1[50];
char string2[50];
printf("Enter a string less than 50 characters with spaces: \n ");
gets(string1);
printf("\nYou have entered: ");
puts(string1);
printf("\Enter a string less than 50 characters, with spaces: \n");
scanf("%s",string2);
printf("\nYou have entered: %s\n", string2);
return(0);
} Enter a string less than 50 characters with spaces:
hello world

You have entered: hello world

Enter a string less than 50 characters, with spaces:

hello world

You have entered: hello

18
 Principles of Programming

String Conversion Functions

 These functions convert strings of digits to integer and
floating-point values.
 To use these functions, the general utilities library
<stdlib.h>, needs to be included.
 Note that these functions take a constant value as
their argument. This means that we can only pass a
constant string to the functions. For example:
 atoi (“1234”);
 const char *hello = “9999”;
atoi(hello);

19
 Function Prototype Function Description

double atof (const char *nPtr) Converts the sting nPtr to double.
int atoi (const char *nPtr) Converts the string nPtr to int.
long atol (const char *nPtr) Converts the string nPtr to long int.
double strtod (const char *nPtr, Converts the string nPtr to double.
char **endptr)
long strtol (const char *nPtr, char Converts the string nPtr long.
**endptr, int base)
unsigned long strtoul (const char Converts the string nPtr to unsigned long.
*nPtr, char **endptr, int base)

nPtr - The pointer to the string to be converted.

endptr - The pointer to which the remainder of the string will be
assigned after the conversion. We can pass a NULL if the remaining
string is to be ignored.
base - Indicates the format (base) of the string to be converted. If
0 is given, that means the value to be converted can be in octal (base
8), decimal (base 10) or hexadecimal (base 16).
Principles of Programming - 20
NI2005
 Principles of Programming

Example
/*1. Converting a String Into an int Using atoi. */
#include <stdio.h>
#include <stdlib.h>
int main(void)
{
char str1[ ] = "124z3yu87";
char str2[ ] = "-3.4";
char *str3 = "e24";
printf("str1: %d\n", atoi(str1));
printf("str2: %d\n", atoi(str2));
printf("str3: %d\n", atoi(str3));
return(0);
}

Output:
str1: 124
str2: -3
str3: 0

21
 Principles of Programming

Standard Input/Output Library Functions

 Include <stdio.h> to use these functions.

Function Prototype Function Description
int getchar(void) Get the next character from the standard input and return it as an integer
char *gets(char *s) Get characters from the standard input into the array s until a newline or
end-of-file character is encountered. A terminating NULL character is
appended to the array.
int putchar(int c) Print the character stored in c
int puts(const char *s) Print the string s followed by a newline character
int sprintf(char *s, const char Equivalent to printf except that the output is stored in the array s instead
*format, …) of printing on the screen
int sscanf(char *s, const char Equivalent to scanf except that the input is read from the array s instead
*format, …) of reading from the keyboard

22
 Principles of Programming

String Manipulation Functions

 Include <string.h> to use these functions.

Function Prototype Function Description

char *strcpy (char *s1, const char *s2) Copies the string s2 into the array s1. The value of s1 is returned
char *strncpy (char *s1, const char Copies at most n characters of the string s2 into the array s1. The
*s2, size_t n) value of s1 is returned.
char *strcat (char *s1, const char *s2) Appends the string s2 to the array s1. The first character of s2
overwrites the terminating NULL character of s1. The value of s1
is returned.
char *strncat (char *s1, const char *s2, Appends at most n characters of string s2 to array s1. The first
size_t n) character of s2 overwrites the terminating NULL character of s1.
The value of s1 is returned.

23
 Principles of Programming

String Comparison Functions

 Include <string.h> to use these functions

Function Prototype Function Description
int strcmp (const char *s1, const char *s2) Compares the string s1 to the string s2. The function returns
0, less than 0 (negative value), or greater than 0 if s1 is equal
to, less than or greater than s2 respectively.
int strncmp (const char *s1, const char *s2, Compares up to n characters of the string s1 to the string s2.
size_t n) The function returns 0, less than 0, or greater than 0 if s1 is
equal to, less than or greater than s2 respectively.

24
 Principles of Programming

strcmp

 int strcmp ( const char *s1, const char *s2 );

 strcmp will accept two strings. It will return an
integer. This integer will either be:
 Negative if s1 is less than s2.
 Zero if s1 and s2 are equal.
 Positive if s1 is greater than s2.
 strcmp is case sensitive.
 strcmp also passes the address of the
character array to the function to allow it to be
accessed.

25
 Principles of Programming

Example: strcmp
#include <stdio.h>
#include <string.h>
int main(void)
{
char name[20] = "eddie";
char guess[20];
int correct = 1;

while(correct==1)
{
printf("Enter a name: ");
gets(guess);

if(strcmp(name, guess)==0) /*both string are indentical */

{
printf("Correct!\n");
correct = 0;
}
else
printf("Try again: \n\n");
}
return(0);
} 26
 Principles of Programming

strcat

 char *strcat ( char *dest, const char *src );

 strcat is short for string concatenate, which means
to add to the end, or append.
 It adds the second string to the first string.
 It returns a pointer to the concatenated string.
 Make sure that the size of dest is large enough to
hold the entire contents of src as well as its own
contents.

27
 Principles of Programming

Example 1: strcat
/* Concatenating Strings Using strcat */
#include <stdio.h>
#include <string.h>
str1: Hello World
int main(void) Press any key to continue
{
char str1[50] = "Hello ";
char str2[15] = "World";
strcat(str1, str2);
printf("str1: %s\n", str1);
return(0);
}

Note : This only works if you've defined the str1 array to be large
enough to hold the characters of the new string. If you don't
specify a size, the program will crash.

28
 Principles of Programming

Example 2: strcat
/* Concatenating Strings Using strcat */
#include <stdio.h>
#include <string.h>
str2: WorldHello
int main(void) Press any key to continue
{
char str1[50] = "Hello ";
char str2[15] = "World";
strcat(str2, str1);
printf("str2: %s\n", str2);
return(0);
}

Note : This only works if you've defined the str1 array to be large
enough to hold the characters of the new string. If you don't
specify a size, the program will crash.

29
 Principles of Programming

Example 3: strcat
/* Concatenating Strings Using strcat */
#include <stdio.h>
#include <string.h>

int main(void) str2: WorldHello

Press any key to continue
{
char str1[50] = "Hello ";
char str2[7] = "World";
strcat(str2, str1);
printf("str2: %s\n", str2);
return(0);
}
since the destination string has not enough space to hold the combined
string, an error message is generated.

30
 Principles of Programming

strncat
 char *strncat ( char *dest, const char *src, size_t n );
 strncat adds n characters from the second string to the
first string.
 It returns a pointer to the concatenated string.
 Make sure that the size of dest is large enough to hold the
entire contents of src as well as its own contents.

31
 Principles of Programming

Example: strncat
/* Concatenating Strings Using strncat */
#include <stdio.h>
#include <string.h>
str1: Hello Wo
int main(void) Press any key to continue
{
char str1[50] = "Hello ";
char str2[15] = "World";
strncat(str1, str2, 2);
printf("str1: %s\n", str1);
return(0);
}

32
 Principles of Programming

strcpy
 char *strcpy ( char *dest, const char *src );
 strcpy is short for string copy, which means it
copies the entire contents of src into dest. The
contents of dest after strcpy will be exactly the
same as src.

33
 Principles of Programming

Example 1: strcpy
#include <stdio.h>
#include <string.h>

int main(void)
{
char string1[100] = “Malaysia";
char string2[50] = “Gemilang”;
strcpy(string1,string2);
printf(“string1: %s\n", string1);
printf(“string2: %s\n", string2);
return(0);
} string1: Gemilang
string2: Gemilang
Press any key to continue

34
 Principles of Programming

Example 2: strcpy
#include <stdio.h>
#include <string.h> string2 has less
character than string1
int main(void)
{
char string1[100] = “Malaysia";
char string2[50] = “Boleh”;
strcpy(string1,string2);
printf(“string1: %s\n", string1);
printf(“string2: %s\n", string2);
return(0);
} string1: Boleh
string2: Boleh
Press any key to continue

35
 Principles of Programming

Example 3: strcpy
#include <stdio.h>
#include <string.h> string1 has more
character than string2
int main(void)
{
char string1[100] = “Semenanjung ";
char string2[50] = “Malaysia”;
strcpy(string1,string2);
printf(“string1: %s\n", string1);
printf(“string2: %s\n", string2);
return(0);
}
string1: Malaysia
string2: Malaysia
Press any key to continue

36
 Principles of Programming

strncpy
 char *strcpy ( char *dest, const char *src, size_t n );
 Strncpy copies the first n characters from the src into dest.

37
 Principles of Programming

Example: strncpy
#include <stdio.h>
#include <string.h>

int main(void)
{
char string1[100] = "Malaysia";
char string2[50] = "Gemilang";

strncpy(string1, string2, 4);

printf(“string1: %s\n", string1);

return(0);
}
string1: Gemiysia

Press any key to continue

38
 Principles of Programming

strlen
 size_t strlen ( const char *s );
 strlen will return the length of a string, minus the
null character ('\0'). The size_t is nothing to worry
about. Just treat it as an integer that cannot be
negative, which it is.

39
 Principles of Programming

Example 1: strlen
#include <stdio.h>
#include <string.h>

int main(void)
{
char sentence[50] = "I love malaysia";

int i, count = 0;

count = strlen(sentence);
printf("%s has %d characters including the whitespace",
sentence, count);

return(0);
}

I love Malaysia has 15 characters including the whitespace

Press any key to continue

40
 Principles of Programming

Example 2: strlen
#include <stdio.h>
#include <ctype.h>
#include <string.h>

int main(void)
{
char string[50];
int length, i, alpha = 0, digit = 0, space = 0;
printf("Enter a string: ");
gets(string);

length = strlen(string);
for (i = 0; i < length; i++)
{
if (isalpha(string[i]))
alpha++;
if (isdigit(string[i]))
digit++;
if (isspace(string[i]))
space++;
}

printf("%s has %d alphabet, %d digit and %d space \n",string,alpha,digit,space);

return(0);
}

41
 Principles of Programming

String Search Functions

 Include <string.h> to use these functions.
Function Prototype Function Description
char *strchr (const char *s, int c) Locates the first occurrence of character c in string s. If c is found, s
pointer to c is returned. Otherwise a NULL pointer is returned.
size_t strcspn (const char *s1, const Determines and returns the length of the initial segment of string s1
char *s2) consisting of characters not found in string s2.
size_t strspn (const char *s1, const Determines and returns the length of the initial segment of string s1
char *s2) consisting only of characters contained in string s2.
char *strpbrk (const char *s1, const Locates the first occurrence of string s1 of any character in string
char *s2) s2. If a character from string s2 is found, a pointer to the character
in string s1 is returned. Otherwise a NULL pointer is returned.
char *strrchr (const char *s, int c) Locates the last occurrence of c in string s. If c is found, a pointer to
c in string s is returned. Otherwise a NULL pointer is returned.
char *strstr (const char *s1, const Locates the first occurrence in string s1 of string s2. If the string is
char *s2) found, a pointer to the string in s1 is returned. Otherwise a NULL
pointer is returned.
char *strtok (char *s1, const char A sequence call to strtok breaks string s1 into “tokens” – logical
*s2) pieces such as words in a line of text – separated by characters
contained in strnig s2. The first call contains s1 as the first
argument, and subsequent calls to continue tokenizing the same
string contain NULL as the first argument. A pointer to the current
token is returned by each call. If there are no more tokens when the
function is called, NULL is returned.
42
 Principles of Programming

SUMMARY
 C has a standard character-handling library that
includes some useful functions for testing types of
characters and for converting letters to uppercase
and lowercase.
 String is another structured data type. C does not
support strings as a data type. But we can use
character arrays to represent strings.
 Standard functions printf, puts
 Standard functions scanf, gets
 String manipulation functions => to copy strings, to
compare, to compute length, to concatenate

T.H.E E.N.D

43