Introduction to C programming
String
What are strings in C?


Strings in C are represented by arrays of characters.
The end of the string is marked with a special
character, the null character, which is simply the
character with the value 0 (or \0 ).
For example:
char name[50] = “DAVE”;
What are strings in C? (Cont)

0
char a[50] = “This is \n a string.”;
2
3
T h i
s

1
4
5
\n
6
7
a
8
9
10 11 12 13 14 15 16
s t
r
I
n g .
...
\0
printf("This is a string value. Beep! Beep! \7\7");
Conventions

0
What output of printf(a); if a is:
1
2
3
4
5
6
7
8
9
10 11 12 13 14 15 16
T h i s
\0
a
s t r I n g .
 What is the length of string a?
 What if char a[50] does not contain ‘\0’ at all?
 Are following correct, given char a[6];
a[6]=‘7’;
a[5]=“7”;
a[5]=7;
a++;
\0
...
Declarations and Initializing strings

Array of char:
char str[5] = {'l', 'i', 'n', 'u', 'x'};
char str[6] = {'l', 'i', 'n', 'u', 'x', '\0'};

Declarations
Declarations and Initializing strings
#include <stdio.h>
#include <string.h>
int main()
{
/* Example 1 */
char string1[ ] = "A string declared as an array.\n";
/* Example 2 */
char *string2 = "A string declared as a pointer.\n";
/* Example 3 */
char string3[30];
strcpy(string3, "A string constant copied in.\n");
printf (string1);
printf (string2);
printf (string3);
return 0;
}
Declarations and Initializing strings

char string1[] = "A string declared as an array.\n";
This is usually the best way to declare and initialize
a string. The character array is declared explicitly.
There is no size declaration for the array; just
enough memory is allocated for the string, because
the compiler knows how long the string constant is.
The compiler stores the string constant in the
character array and adds a null character (\0) to the
end.
Declarations and Initializing strings
char *string2 = "A string declared as a pointer.\n";
The second of these initializations is a pointer to an array
of characters. Just as in the last example, the compiler
calculates the size of the array from the string constant
and adds a null character. The compiler then assigns a
pointer to the first character of the character array to the
variable string2.
Note: Most string functions will accept strings declared in
either of these two ways.

Declarations and Initializing strings


char string3[30];
Declaring a string in this way is useful when you
don't know what the string variable will contain, but
have a general idea of the length of its contents (in
this case, the string can be a maximum of 30
characters long). The drawback is that you will
either have to use some kind of string function to
assign the variable a value, as the next line of code
does ( strcpy(string3, "A string constant copied
in.\n");), or you will have to assign the elements of
the array the hard way, character by character.
String Array

A string array is an array of strings, which, of
course, are themselves arrays of characters;
in effect, a string array is a two-dimensional
character array.
char *menu[] =
{
" -------------------------------------- ",
"|
++ MENU ++
|",
"|
~~~~~~~~~~~~
|",
" | (0) Edit Preferences
|",
" | (1) Print Charge Sheet |",
" | (2) Print Log Sheet
|",
" | (3) Calculate Bill
|",
" | (q) Quit
|",
"|
|",
"|
|",
" | Please enter ur choice. |",
"|
|",
" -------------------------------------- “
};
int main()
{
int line;
for (line = 0; line < 13; line++)
{
printf ("%s\n", menu[line]);
}
return 0;
}
Troubles

Because C has no built-in facilities for manipulating
entire arrays (copying them, comparing them, etc.), it
also has very few built-in facilities for manipulating
strings:
char firstname[50],lastname[50],fullname[100];
firstname= "Arnold"; /* Illegal */
lastname= "Schwarznegger"; /* Illegal */
fullname= "Mr"+firstname
+lastname; /* Illegal */
String library functions

The GNU C Library provides a number of
very useful functions which handle strings.
Here is a list of the more common ones. To
use the functions beginning with ato, you
must include the header file stdlib.h; to use
the functions beginning with str, you must
include the header file string.h.
String library functions(1)



int atoi(const char *nptr);
double atof(const char *nptr);
long atol(const char *nptr);
String library functions(1)
/*atof Converts an ASCII string to its floating-point equivalent; for
example, converts -23.5 to the value -23.5. */
#include <stdio.h>
#include <stdlib.h>
int main()
{
double my_value;
char my_string[] = "+1776.23";
my_value = atof(my_string);
printf("%f\n", my_value);
return 0;
}
The output from the above code is 1776.230000.
String library functions(1)
/* atoi Converts an ASCII string to its integer equivalent; for
example, converts -23.5 to the value -23. */
int my_value;
char my_string[] = "-23.5";
my_value = atoi(my_string);
printf("%d\n", my_value);
/*atol Converts an ASCII string to its long integer equivalent; for
example, converts +2000000000 to the value 2000000000. */
long my_value;
char my_string[] = "+2000000000";
my_value = atol(my_string);
printf("%ld\n", my_value);
String library functions(2)

strcpy
strcpy copies a string, including the null character terminator from the
source string to the destination. This function returns a pointer to the
destination string, or a NULL pointer on error. Its prototype is:
char *strcpy(char *dst, const char *src);

strncpy
strncpy is similar to strcpy, but it allows the number of characters to be
copied to be specified. If the source is shorter than the destination,
than the destination is padded with null characters up to the length
specified. This function returns a pointer to the destination string, or a
NULL pointer on error. Its prototype is:
char *strncpy(char *dst, const char *src, size_t len);
String library functions(2)

strcat
This function appends a source string to the end of a
destination string. This function returns a pointer to the
destination string, or a NULL pointer on error. Its prototype is:
char *strcat(char *dst, const char *src);

strncat
This function appends at most N characters from the source
string to the end of the destination string. This function returns a
pointer to the destination string, or a NULL pointer on error. Its
prototype is:
char *strncat(char *dst, const char *src, size_t N);
String library functions(2)

strcmp
This function compares two strings. If the first string is greater
than the second, it returns a number greater than zero. If the
second string is greater, it returns a number less than zero. If
the strings are equal, it returns 0. Its prototype is:
int strcmp(const char *first, const char *second);

strncmp
This function compares the first N characters of each string. If
the first string is greater than the second, it returns a number
greater than zero. If the second string is greater, it returns a
number less than zero. If the strings are equal, it returns 0. Its
prototype is:
int strncmp(const char *first, const char *second, size_t N);
String library functions(2)

The strcmp() function lexically compares the
two input strings and returns:
–
Less than zero
-- if string1 is lexically less than string2
–
Zero
-- if string1 and string2 are lexically equal
–
Greater than zero
-- if string1 is lexically greater than string2
String library functions(2)

strlen
This function returns the length of a string,
not counting the null character at the end.
That is, it returns the character count of the
string, without the terminator. Its prototype is:
size_t strlen(const char *str);
String library functions(2)


int strcasecmp(const char *s1, const char *s2)
-- case insensitive version of strcmp().
int strncasecmp(const char *s1, const char
*s2, int n) -- case insensitive version of
strncmp().
String library functions(2)

To use any of these functions in your code,
the header file "strings.h" must be included. It
is the programmer's responsibility to check
that the destination array is large enough to
hold either what is copied or appended to it.
C performs no error checking in this respect.
See the array tutorial for more details. The
data type size_t is equivalent to unsigned
integer.
String library functions(2)

The use of most of the functions is
straightforward, for example:
char *str1 = "HELLO";
char *str2;
int length;
length = strlen("HELLO"); /* length = 5 */
(void) strcpy(str2,str1);
String library functions(2)

The strncat(), strncmp,() and strncpy() copy functions
are string restricted version of their more general
counterparts. They perform a similar task but only up
to the first n characters. Note the the NULL
terminated requirement may get violated when using
these functions, for example:
char *str1 = "HELLO";
char *str2;
int length = 2;
(void) strcpy(str2,str1, length); /* str2 = "HE" */
str2 is NOT NULL TERMINATED!! -- BEWARE
String library functions(3)




char *strchr(const char *string, int c) -- Find first
occurrence of character c in string.
char *strrchr(const char *string, int c) -- Find last
occurrence of character c in string.
char *strstr(const char *s1, const char *s2) -- locates
the first occurrence of the string s2 in string s1.
char *strpbrk(const char *s1, const char *s2) -returns a pointer to the first occurrence in string s1 of
any character from string s2, or a null pointer if no
character from s2 exists in s1
String library functions(3)




size_t strspn(const char *s1, const char *s2) -- returns the
number of characters at the begining of s1 that match s2.
size_t strcspn(const char *s1, const char *s2) -- returns the
number of characters at the begining of s1 that do not match s2.
char *strtok(char *s1, const char *s2) -- break the string pointed
to by s1 into a sequence of tokens, each of which is delimited
by one or more characters from the string pointed to by s2.
char *strtok_r(char *s1, const char *s2, char **lasts) -- has the
same functionality as strtok() except that a pointer to a string
placeholder lasts must be supplied by the caller.
Memory Operations: <memory.h>





void *memchr (void *s, int c, size_t n) -- Search for a
character in a buffer .
int memcmp (void *s1, void *s2, size_t n) -- Compare
two buffers.
void *memcpy (void *dest, void *src, size_t n) -Copy one buffer into another .
void *memmove (void *dest, void *src, size_t n) -Move a number of bytes from one buffer lo another.
void *memset (void *s, int c, size_t n) -- Set all bytes
of a buffer to a given character.
String Input & Output

Output:
–

Input:
–
–
–

printf(“This is a string: %s”, str1);
scanf(“%s%ld%lf%s”, str1, &value1, &value2, str2);
gets
scanline
File operations
–
fopen, fclose, fgets…