Subject:

Data Structure with C

Topic:

Strings

In this chapter we are emphasizing the reading and storing string and also manipulation
concepts through the following millstones.
The discussion starts with string concepts , strings in c programming language, input and
output functions, array of strings, string manipulation ,memory formatting and in
conclusion summarizing the overall concepts.
String Concepts
The series of character treated as a unit and string created in pascal is different
from C. In the figure 1 (a) and (b) are attempted to illustrate storing of string in the fixed
length format and further second approach is the under the variable length format, under
this there are two sub approaches. These are mainly length controlled and delimited.

Figure 1 (a) and (b): Fixed and variable length string representation
String Copy-Length Controlled
In variable length format, problems such as unequal string-array sizes can be controlled
with the string number copy function, which is strncpy. This function contains a
parameter that specifies the maximum number of characters that can be copied at a time
String concepts in C
C programming language supports the variable in length string structure and ends with
\0. A character require a memory location, where as character string require two
memory location. In fact string is not data type but it is a data structure.
Normally string stored in an array of character ends with delimiter. Character require
only one memory location but string character require two memory location. One for
data and one for delimiter. At this juncture, in our mind following doubts may ascend.
Such as, why do we need null character ? , string is not data, it is a data structure, Its

implementation is logical not physical, physical structure is the array in which data is
stored. Remedies for the doubts by addressing one by one in subsequent sections
Variable length string
In real life situations, string is mostly variable length structure. Thus we need to identify
the logical end of data within physical structure. If data length is not variable, then it is
not necessary of string data structure to store. They are easily stored in an array, end is
last element. It provides enough space for maximum length string and plus one. It is
always possible that structure will not be filled, so array will be null in the middle. In
such case part of array from beginning to the null as the string and rest will be ignored
and same concept is described through a figure 2. In other words any part of array of
character can be treated as a string as long as the string ends with null char, for example
consider character array length may be 16. It can be declared as char str[16].

Figure 2: Variable length string

String literal
Representation of string constant or literal is also equally important. Perhaps it is a
sequence of character which enclosed in doubled quotes. Let we consider an example
VTU, Data structure with C. These literal are used in a program, C compiler
automatically create an array of character. In similar way double quotes identify data
always as string value. On the other hand to store single character there are two
options, data as character literal or string literal.
Character Literal and String literal
The character literal is stored in memory with single quotes and it occupies a single
memory location. The string manipulation operations such as moving a character from
one location to another require only assignment.
The string literal used the double quotes, one additional memory location essential for
delimiter and moving string require a function call. Representation is also crucial even
though data object is absence. In other words, logically we specify space or \0
represents the absence of data in String literal. String can be empty or string can be
with no data. Consider an example a character - V , a string- V , a null string-
. The following segment of program attempted to add more information using pointer
data structure as portrayed in figure 3.
String and Pointers
{ /* Printing the string
char greeting[ ]=Hello;
char *ptr;
ptr=greeting;

while (*ptr != \0)

{
printf( %c, *ptr);
ptr++;
}
print(\n);

Figure 3: Variable length string

String Input and output functions
Generally there are two way of read and write string. First one is to Read/ Write with
formatted I/O function such as Scnaf & printf. Second is special set of string only
functions gets/ fgets and puts/ fputs for input and output operations respectively.
In the file process system operating system will encourage various operation. These
operations may be read and write from or to a file. Similar concepts are further
emphasized through a figure 4 which is logical organization of file process. Essence of
the program and data are stored in memory through a file. In order to do so input and
output functions essential and this is controlled by operating system.

Figure 4: Logical organization of file process

Formatted String I/p - Flush
In most of the time user enter too much of data with the width in the field,
such as char month [10]; and scanf (%9s, month);

examples

Here scanf will read up to nine characters then insert the null. If user accidentally inserts
more than 9 character, extra character will be left in the input output stream, it may cause
a problem. Of course it can be possible to clean the stream using FLUSH pre-processor.
FLUSH also the clean a new line, when user correctly enters data.
Formatted O/p: printf
C has three options left justify flag, width & precision flag and width used together.
Where as wiithout flag it is right justified, otherwise left justified. This can be further
elaborated through some statements of C along with outputs.
printf(|%30s|\n, This is the string);
output:
|
This is the string|
Printf(|%-30s|\n, This is the string);
output:
|This is the string
|
Printf(|%-15.14s|, 12345678901234567890);
output:
|12345678901234 |
Maximum characters are one less than the width to ensure a space between the string
and next column.
C String :gets & fgets
The set of strings functions which are read/ write string without formatting any data
These functions converts text file lines to string and string to text file. A line consist of
a string of character terminated by a newline character. These are called line-to-string
input functions

The string input functions gets converts the \n to \0 (neweline to end of string
character ). It is further highlighted through the figure 5, which is read the data from
keyboard stored in memeory.

Figure 5: function gets

The fgets function reads from std i/p file stream char *gets(char *strPtr); fgets put it in
memory the string and appends an end-of-string delimiter as shown in figure 6.

Figure 6: function fgets

It reads from stream specified from fp char *fgets(char *strPtr, int size,FILE *fp)
puts and fputs
In the similar way, output the data to outside world. These are null terminated and sting
from memory and write to file as a line. These are also called string-to-line output
functions as demonstrated in the figure 7.

Figure 7: function puts

In the figure 8 fgets function is narrated which is add the newline

Figure 8: function fgets

Array of String
We have been observing But, this approach waste the space. Ragged array common with
strings-texual
format Ragged array we create with pointer. It is much easier to create using array of
string Pointers In this way, each string is independent. Though, we can pass them as a
group of function by passing only the name of array of pointers
Array of String: print the days of Week
#include <stdio.h>
int main(void)
{
char *pDays[7];
char **pLast;
char **pWalker;
pDays[0]=Sunday; pDays[1]=Monday; pDays[2]=Tuesday;
pDays[3]=Wednesday; pDays[4]=Thursday; pDays[5]=Friday;
pDays[6]=Saturday;
printf(the days of the week\n);
pLast=pDays + 6;
for (pWalker=pDays; pWalker<= pLast; pWalker+ +)
printf(%s\n, *pWalker);
}
This is further elaborated in through figure 9.
Pointer to String

Figure 9: pointer to string

Ragged Array
Ragged array is quite productive, when size of data in array is variable. If you use 2D,
lot of memory will be wasting. Instead of doing so better create five one dimensional
arrays are joined through a array of pointers. Here, right element in each row may be
empty, It even (ragged) right border. 2D array contain only. 2 rows are full; rest will
contain 1 to 4 and it is illustrated in the figure 10.

Figure 10: ragged array

String Manipulation Function

It is not a standard type. Move individual element from source string to destination
string. C has rich set of string functions. Besides, using these functions there is an
opportunity to make efficient when operations are supported by hardware. The
following function computes the length of the given string.
String Length
new_len(char *s)
{ int length=0;
while (*s != \0)
{ length++;
s++;
}
return(length)
}
string input = VTU Edusat
Output = 10 (including null character)
Similarly, following is the C programe using built in function and it return length of
string excluding null. If string is empty return zero int strlen( const char *string);
Program to add two space to left margin at beginning of each line before writing it to a
file
#include <stdio.h>
#include <string.h>
int main(void) {
FILE *outFile; char strng[81];
If (!(outFile = fopen(p2.txt, w)))
{ printf(\ c could not open output file\n;}
while (fgets (strng,sizeof(strang),stdin) )
{
fputc( , outFile);
fputc( , outFile);
fputs(strng, outFile);
if(strng[strlen(strng-1] != \n)
fputs(\n,outFile);
fclose(outFile)
}
Due to fgets(), some data may left in the buffer, but not necessary to FLUSH it, Because
it require for write them to the file on the next line. Also fputs does not add newline when
it writes the file
String Length vs. Its Array Size

The length of a string is the count of the number of characters preceding the first NULL
character. It is important to realize that this definition differs from the size of the array.
Ex: Consider the following declarations:
1. char name[8]='
Edusat'
'
;
The array size of 8 bytes appears in brackets; but the length of the inputted string is six
characters.
2. char name[6]={'
s'
,'
a'
,'
m'
,'
\0'
,'
\0'
,'
\0'
};
The size of the array is 6 bytes; but the declared string length is three charactersare
initilized; and the first NULL character terminates the string.
3. char name[6]={'
J'
,'
h'
,'
o'
,'
\0'
,'
n'
,'
n'
};
The size of the array is 6 bytes; the string length is three characters; and the NULL
character terminates the string.
String is the name of data structure. Character array is home for string data structure.
String Copy
Two string copy functions , strcpy & strncpy. The function attempted to describe the
copy of string from source to destination and it is shown in the figure 11.
char *strcpy(char *to_strng, const char *from_strng);

Figure 11: string copy function

String number copy
Similarly, copy the string of certain length to destination and it is illustrated in the figure
12.

char *strncpy(char *to_string, const char *from_strng, int size);

Figure 12: string number copy function

newStrCpy same as strcpy( )
main()
{
char source[ ] = Edusat;
char target[20];
newStrCpy(target, source);
}
newStrCpy( char *t, char *s)
{
while(*s != \0);
{
*t=*s;
s++;
t++; }
*t = \0;
}
What would happen if s= s- 5;
*s= O;
Output: Odusat
Character searching in String
There are two string function to search a character in a string. The first one is called
strchr ; it searches for the first occurrence of a character from the beginning of the
string.
The second one is strrchr which searches the string for the first occurrence beginning at
the rear end working toward the front. In either case, if the character is located, the

function returns a pointer to it. If character is not in the string, they return NULL pointer.
It is further illustrated in figure13.

Figure 13: string search function

String Parsing
Let we consider an example of parsing. Parse sum= sum +10; The semicolon serves
as the last token in the string. Each string token separated by white space. Delimiter set
includes semicolon and blank between tokens
char *strtok( char *string, const char *delimiters);
When delimiters finds, it terminates and find returns a null pointer. The following
programme further convinces the concepts using such functions also shown in figure 14
and figure 15.
Parsing with String Token
int main (void)
{ char *strng = sum = sum+10;; char *pToken;
int tokenCount=0;
pToken = strtok(strng,;);
While (pToken)
{
tokenCount++;
printf( pToken %2d contains %s\n);
tokenCount, pToken);
pToken = strtok ( NULL, ;);
}

Figure 14: string parsing function

Parsing with String Token

Figure 15: string parsing function

String SPAN-strspn & strcspn
The strspn function helps to determines the number of characters in the string set. Where
as strcspn function stops at the first character that matches one of the characters in the

set. If none of characters in the string match the set, it returns the length of the string and
these functions are illustrated in figure 16 (a) and (b).

Figure 16: string span function

strtol- string to long function
This function assist to converts a string to long integer. It skips leading white space
characters and stops with the first non-numeric character, which is consider to be the
start of trialing string. The address of trailing string stored in the second parameters,
unless it is null pointer. A third parameter determines the base of the string number.
long strtol (char *str, char **ptr, int base)
ex: num= strtol(12345 Decimal constant :, &ptr, 0)
output: Decimal constant : 12345
num= strtol(11001 Binary constant :, &ptr, 2)
output: Binary constant : 25
num= strtol(13572 Octal constant :, &ptr, 8)
Output: Octal constant : 6010
Memory Formatting-Files in C
The C compilers treat the keyboard as an input file, called stdin. It treats the screen as an
output file, called stdout. So in C reading keyboard input is a special case of reading
from a file, while outputting on the screen is a special case of writing to a file. This is
why scanf, printf and the other file functions are in stdio header files. scanf & printf do
not read/write files rather from memory gets & puts gives more control over formatting
sscanf the i/p string.
sscanf
It is a one- to- many function and also it splits one string to many variables which is
portrayed in figure 17.

sprintf

Figure 17: sscanf function

It is a many-to-one function and also it joins many pieces data into one string
which is shown in figure 18.

Figure 18: sprintf function

Summary
We have discussed most of the string related concepts such as C string concept
String manipulation and Formatting I/O functions with relevant examples.