ICS103: Programming in C

8: Strings

Muhamed F. Mudawar
OUTLINE
 String Constants and Variables

 String Input and Output

 Character Related Functions

 String Library Functions

 Arrays of Strings and Arrays of Pointers

2
WHAT IS A STRING CONSTANT?
A sequence of characters enclosed in double quotes

Example: "Hello World"

 Can be used in a printf statement:

printf("Average = %.2f\n", avg);

 Can also appear in #define directive, such as:

#define ERR_MSG "Error message: "

3
WHAT IS A STRING VARIABLE?
 In C, a string variable is an array of type char
 We can declare a string variable as follows:
char string_var[20]; /* Array of char */
 We can initialize a string variable as follows:
/* A list of chars terminated by '\0' */
char str[16] = {'H','e','l','l','o',' ',
'W','o','r','l','d','\0'};
/* A string enclosed between double quotes */
char str[16] = "Hello World";

0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15
4
H e l l o W o r l d \0 ? ? ? ?
array str[16]
STRING VARIABLES (CONT'D)
 We can omit the string (array) size as follows:
char str2[] = "Hello World"; /* 12 chars */
Only 12 characters are allocated (including '\0')
0 1 2 3 4 5 6 7 8 9 10 11
H e l l o W o r l d \0
array str2[]
 We can also declare a pointer to a string as follows:
char *ptr = "Hello World";

ptr 0 1 2 3 4 5 6 7 8 9 10 11
H e l l o W o r l d \0 5

string constant
THE NULL CHARACTER '\0'
 It is a byte that has the value zero
 Used to mark the end of a string in C
 A string constant is always ended with '\0'
 For example: "Hello World" has 12 chars (not 11)
0 1 2 3 4 5 6 7 8 9 10 11
H e l l o W o r l d \0

 C functions use '\0' to compute the string length

 To avoid passing the size of a string to a function
 A string variable must also terminate with a NULL char
6
 The empty string "" stores the NULL char '\0'
NEXT . . .
 String Constants and Variables

 String Input and Output

 Character Related Functions

 String Library Functions

 Arrays of Strings and Arrays of Pointers

7
INPUT A STRING WITH scanf
 To input a string, the placeholder must be %s
char str[16];
/* str length must not exceed 15 chars */
scanf("%s", str);
/* when reading a string, scanf skips white */
/* space such as blanks, newlines, and tabs */
/* It stops reading at first white space */
/* It inserts '\0' at end of str */
scanf("%15s", str);
/* prevents reading more than 15 chars */
 Notice that there is no need for & before str 8

 Because str is an array, and it is passed by address

OUTPUT A STRING WITH printf
 To print a string, the placeholder must also be %s
 Example of string input and output:
char str[16]; /* must not exceed 15 chars */
printf("Enter your first name: ");
scanf("%15s", str);
printf("Hello %s\n", str);

 If
printf displays a string that does not end with
9
'\0' then it causes a run-time error
EXAMPLE OF STRING INPUT / OUTPUT
#include <stdio.h>
int main(void) {
char dept[8], days[8];
int course_num, time;
printf("Enter course code, number, days, and time\n");
printf("Similar to this: MATH 101 UTR 1100\n");
printf("\n> ");
scanf("%s%d%s%d", dept, &course_num, days, &time);
printf("%s %d meets %s at %d\n", dept, course_num,
days, time);
return 0;
}
10
PLACEHOLDERS USED WITH printf
Value Placeholder Output (  is blank)
'a' %c a
%3c a
%-3c a
-10 %d -10
%6d -10
%-6d -10
49.76 %.3f 49.760
%9.1f 49.8
%9.2e 4.98e+01
"fantastic" %s fantastic
%12s fantastic 11
%-12s fantastic
THE gets AND puts FUNCTIONS
Aproblem with scanf it that it stops reading a string
when it encounters a blank (or any whitespace).
 Blanksare natural separators between numeric data
values, but it is a valid character in a string.
 Toread a full line, the gets function continues
reading until the newline char (Enter key) is read.
 The'\n' character representing the Enter key is
not stored in the string. It is replaced with '\0'.
 The puts function is used to print a string. 12

 puts automatically prints '\n' at end of the string.

EXAMPLE OF gets AND puts
char line[80];
printf("Type anything: ");
gets(line);
printf("You typed: ");
puts(line);

13
FILE INPUT WITH fgets
 For data files, the stdio library provides the fgets
function that works similar to gets
char * fgets(char str[], int n, FILE *infile);
 fgets reads characters from infile into str, until
it reads'\n' or n-1 chars, whichever comes first.
 fgets inserts '\0' at end of str
 Unlike gets, fgets reads the '\n' char into str
 fgets returns the address of str as its result value
 If fgets cannot read from infile (End-Of-File 14

or some error) then it returns the NULL pointer

FILE OUTPUT WITH fputs
 In addition, the stdio library provides the fputs
function that works similar to puts
int fputs(char str[], FILE *outfile);
 fputs outputs str to outfile
 Unlike puts, fputs does not output an extra
newline character to outfile
 fputs returns 0 if the file operation is successful
15
 It returns -1 if it cannot write to outfile
EXAMPLE OF fgets AND fputs
#include <stdio.h>
#define L_SIZE 100 /* line size */
#define N_SIZE 40 /* name size */

int main() {
char line[L_SIZE], inname[N_SIZE], outname[N_SIZE];

printf("Enter the name of input file: ");

scanf("%s", inname);
FILE *infile = fopen(inname, "r");
if (infile == NULL) {
printf("Can't open %s", inname);
return 1; /* terminate program */
}
16
printf("Enter the name of output file: ");
scanf("%s", outname);
EXAMPLE OF fgets AND fputs
FILE *outfile = fopen(outname, "w");
if (outfile == NULL) {
printf("Can't open %s", outname);
return 1; /* terminate program */
}

char *status = fgets(line, L_SIZE, infile);

while (status != NULL) {
fputs(line, outfile);
status = fgets(line, L_SIZE, infile);
}

fclose(infile);
fclose(outfile);
17
return 0;
}
SAMPLE RUN . . .

18
NEXT . . .
 String Constants and Variables

 String Input and Output

 Character Related Functions

 String Library Functions

 Arrays of Strings and Arrays of Pointers

19
CHARACTER RELATED FUNCTIONS
 In
addition to the string library functions, C provides
functions that facilitate character handling.
 To use these functions #include <ctype.h>
Function Description
int isalnum(ch); true if ch is alphanumeric
int isalpha(ch); true if ch is alphabetic
int isdigit(ch); true if ch is digit
int isupper(ch); true if ch is uppercase letter
int islower(ch); true if ch is lowercase letter
int isspace(ch); true if ch is whitespace
int iscntrl(ch); true if ch is a control character
int ispunct(ch); true if ch is a punctuation character
20
int toupper(ch); convert ch to uppercase
int tolower(ch); convert ch to lowercase
CONVERTING A STRING TO UPPERCASE
#include <stdio.h>
#include <ctype.h>
int main() {
char s[] = "ICS 103: Computer Programming in C";
int i;
for (i=0; s[i] != '\0'; i++)
s[i] = toupper(s[i]);
puts(s);
printf("The digits in the string are: ");
for (i=0; s[i] != '\0'; i++)
if (isdigit(s[i])) printf("%c", s[i]);
printf("\n");
return 0; 21

}
COUNTING LETTERS, DIGITS, SPACES, . . .
#include <stdio.h>
#include <ctype.h>

int main() {
char line[100];
int letters=0, digits=0, spaces=0, puncts=0, others=0;
int i, total=0;

printf("Type anything on the next line . . .\n");

gets(line);

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

total++;
if (isalpha(line[i])) letters++;
else if (isdigit(line[i])) digits++; 22
COUNTING LETTERS, DIGITS, SPACES, . . .
else if (isspace(line[i])) spaces++;
else if (ispunct(line[i])) puncts++;
else others++;
}

printf("\nYou typed %d chars\n", total);

printf("The count of letters = %d\n", letters);
printf("The count of digits = %d\n", digits);
printf("The count of spaces = %d\n", spaces);
printf("Punctuation chars = %d\n", puncts);
printf("Other characters = %d\n", others);
return 0;
23
}
SAMPLE RUN . . .

24
COUNTING VOWELS
#include <stdio.h>
int isvowel(char ch); /* Function Prototype */
int main( ) {
char line[100];
int i, vowels=0;

printf("Type anything on the next line . . .\n");

gets(line);

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

if (isvowel(line[i])) vowels++;

printf("\nNumber of vowels = %d\n", vowels);

return 0; 25

}
FUNCTION isvowel
/* Returns true if character ch is a vowel */
int isvowel(char ch) {
return (ch == 'a' || ch == 'A' ||
ch == 'e' || ch == 'E' ||
ch == 'i' || ch == 'I' ||
ch == 'o' || ch == 'O' ||
ch == 'u' || ch == 'U') ;
}

26
NEXT . . .
 String Constants and Variables

 String Input and Output

 Character Related Functions

 String Library Functions

 Arrays of Strings and Arrays of Pointers

27
STRING LIBRARY FUNCTIONS
 The standard C library contains useful string functions
 Can be used by including the following header file:
#include <string.h>
 Here, we look at few string library functions:
strcpy, strlen, strcmp, strcat, strtok, strchr, strstr

 The full list is available in appendix B

 The string library functions expects all strings to be
terminated with the null character '\0' 28
STRING COPY: strcpy
 We typically use = to copy data into a variable
char c, t[16], s[16] = "Example string";
c = 'a'; /* this is ok */
t = "Test string"; /* this does not work */
t = s; /* this does not work */
 We can use = to initialize a string, but not to assign
 To assign a string, use the string copy function
 strcpy copies the src string into the dest string:
char *strcpy(char dest[], char src[]);
strcpy copies all characters in the src string up 29

to and including the null char into the dest string

EXAMPLES: strcpy
char t[16], s[16] = "Example string";
0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15
E x a m p l e s t r i n g \0 ?
array s[16]

strcpy(t, "Test string");

0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15
T e s t s t r i n g \0 ? ? ? ?
array t[16]

strcpy(t, s);
0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15
E x a m p l e s t r i n g \0 ? 30

array t[16]
STRING LENGTH: strlen
 strlen counts the number of characters in a string
that appear before the null character '\0'
int strlen(char s[]);
 The null character is NOT counted
 Theempty string "" that starts with a null character
has a strlen equal to 0
 Examples:

char s1[20] = "", s2[20] = "KFUPM, Dhahran"

int len1 = strlen(s1); /* returns 0 */ 31

int len2 = strlen(s2); /* returns 14 */

STRING COMPARISON: strcmp
 Characters are represented by numeric codes
 We can compare characters using relational operators
 For example: if (ch1 < ch2) { . . . }

 However, if str1 and str2 are arrays of characters

 We cannot compare strings like this: (str1 < str2)
 To compare two strings, we use the strcmp function

int strcmp(char str1[], char str2[]);

 Compares the two strings alphabetically (ASCII codes)
 Returns 0 if str1 is equal to str2
 Returns -1 if str1 is less than str2 32

 Returns +1 if str1 is greater than str2

EXAMPLES: strcmp
char s1[16] = "Long string";
char s2[16] = "Short";
char s3[16] = "short";
char s4[16] = "";
printf("%d ", strcmp(s1, s2));
printf("%d ", strcmp(s2, s3));
printf("%d ", strcmp(s3, s4));
printf("%d ", strcmp(s4, s4));
33
STRING CONCATENATION: strcat
 Concatenation means appending a source string at
the end of a destination string to make it longer.
char * strcat(char dest[], char src[]);
 The src string is copied at the end of the dest string
 The position of the null char in the dest string is set
after the appended copy of the src string.
 Overflow is possible if the dest string does not have
sufficient space to append the src string.
 Ifoverflow happens, other variables can be 34
overwritten, which might cause a runtime error
EXAMPLE: strcat
#include <stdio.h>
#include <string.h>
int main(void) {
char first[20], last[20], full[40];
printf("Enter your first name: ");
gets(first);
printf("Enter your last name: ");
gets(last);
strcpy(full, first);
strcat(full, " ");
strcat(full, last);
printf("Your full name is: ");
puts(full);
return 0;
35
}
STRING TOKENIZATION: strtok
 Tokenizationmeans splitting a string into parts called
tokens based on a specified set of delimiters.
char * strtok(char str[], char delims[]);
 The first call to strtok should have str point to the
string to be tokenized
 Subsequent calls to strtok must use NULL as str
 The strtok function returns a pointer to the next
token in str that ends with a delimiter in delims
 It modifies str by replacing delimiters with '\0'
36

 It returns NULL when tokens are exhausted

EXAMPLE: strtok
#include <stdio.h>
#include <string.h>
int main(void) {
char date[20];
printf("Enter a date like this: May 5, 2014\n> ");
gets(date);
char *month = strtok(date, " ,"); /* first call */
char *day = strtok(NULL, " ,"); /* subsequent call */
char *year = strtok(NULL, " ,"); /* subsequent call */
puts(month); month day year
puts(day);
puts(year); \ \ \ \
J a n u a r y 0 2 5 0
, 0 0 ? ?
2 0 1 9 ,
37
return 0;
} array date[20]
SEARCHING A STRING
 Two functions for searching a string:

char * strchr(char str[], char target);

char * strstr(char str[], char target[]);

 strchr returns a pointer to the first occurrence of

target char in str, or NULL if target is not found

 strstr returns a pointer to the first occurrence of

target string in str, or NULL if no match is found
38
EXAMPLE OF strstr
#include<stdio.h>
#include<string.h>

int main(void) {
char sentence[100], word[40], *result;

printf("Enter a sentence: ");

gets(sentence);
printf("Enter a word to search: ");
gets(word);

result = strstr(sentence, word);

if (result != NULL) printf("%s was found\n", word);
else printf("%s was not found\n", word);
39
return 0;
}
NEXT . . .
 String Constants and Variables

 String Input and Output

 Character Related Functions

 String Library Functions

 Arrays of Strings and Arrays of Pointers

40
ARRAYS OF STRINGS
 An array of strings is a 2D array of characters
 The first dimension represents the number of strings
 The second dimension represents the string itself
 Example: declare an array to store up to 30 names,
each of size 20 chars (including null character)
#define MAX_NAMES 30
#define NAME_SIZE 20
. . .
41
char names[MAX_NAMES][NAME_SIZE];
ARRAYS OF POINTERS
 An array of pointers is a 1D array of addresses
char *ptr[30]; /* array of 30 pointers */
 Initializing an array of strings:
char month[12][10] = {"January", "February",
"March", "April", "May", "June", "July",
"August", "September", "October",
"November", "December" };
 Initializing an array of pointers:
char *month[12] = { "January", "February",
"March", "April", "May", "June", "July",
"August", "September", "October", 42

"November", "December" };
ARRAY OF STRINGS VERSUS POINTERS
char month[12][10] char *month[12]
J a n u a r y \0 "January"
F e b r u a r y \0 "February"
M a r c h \0 "March"
A p r i l \0 "April"
M a y \0 "May"
J u n e \0 "June"
J u l y \0 "July"
A u g u s t \0 "August"
S e p t e m b e r \0 "September"
O c t o b e r \0 "October"
N o v e m b e r \0 "November"
43
D e c e m b e r \0 "December"
SORTING AN ARRAY OF NAMES (1 OF 4)
/* Sort an array of names alphabetically */
#include <stdio.h>
#include <string.h>

#define MAX_NAMES 30 /* maximum number of names */

#define NAME_SIZE 20 /* maximum name size */

/* read n names into array of strings */

void read_names(char array[][NAME_SIZE], int n);

/* print an array of n names */

void print_names(char array[][NAME_SIZE], int n);

/* sort an array of n names alphabetically */ 44

void sort_names(char array[][NAME_SIZE], int n);
SORTING AN ARRAY OF NAMES (2 OF 4)
/* main function */
int main() {
int total;
char name[MAX_NAMES][NAME_SIZE];

printf("Enter total number of names: ");

scanf("%d", &total);

read_names(name, total);
sort_names(name, total);
printf("\nAlphabetical sorting of names\n\n");
print_names(name, total);

return 0; 45

}
SORTING AN ARRAY OF NAMES (3 OF 4)
/* read n names into array of strings */
void read_names(char array[][NAME_SIZE], int n) {
int i;
for (i=0; i<n; i++) {
printf("Enter name[%d]: ", i);
scanf("%s", array[i]);
}
}

/* print an array of n names */

void print_names(char array[][NAME_SIZE], int n) {
int i;
for (i=0; i<n; i++) puts(array[i]); 46
}
SORTING AN ARRAY OF NAMES (4 OF 4)
void sort_names(char array[][NAME_SIZE], int n) {
int fill, index_min, j;
char temp_name[NAME_SIZE]; /* temporary name */
for (fill=0; fill < n-1; fill++) {
index_min = fill;
for (j=fill+1; j<n; j++) {
if (strcmp(array[j], array[index_min]) < 0)
index_min = j; /* found a new min */
}
strcpy(temp_name, array[fill]);
strcpy(array[fill], array[index_min]);
strcpy(array[index_min], temp_name);
47
}
}
SAMPLE RUN . . .

48