Strings in C --- arrays of `char`

String in C

Strings in C

String = a sequence of characters
Unlike Java, the C programming language does not have a String data type

Representing a string in C

There are 2 representation methods of strings:

Representing a string in C:

A string is stored in memory using consecutive memory cells and the string is terminated by the sentinel '\0' (known as the NUL character).

Example: the string "Hello" is represented as follows:

Note:

The characters (e.g. 'H', 'e', ...) are encoded using the ASCII code --- you learned this in CS170 !
So 'H' is nothing more than a small (1 byte) integer !!!

Printing a string

Conversion character for a string:

%s conversion character in printf for a string

Example:

int main(int argc, char *argv[]) { printf("Print the string `%s' here\n", "Hello" ); }

Result:

Print the string `Hello' here

Example Program: (Demo above code)
- Prog file: click here
How to run the program:

String variables in C

String variables in C

A string variable in C is just an array of char !!!

An ASCII character code is stored in the array element at the character position
The end of the string is marked by the sentinel character '\0' (NUL) (which has the ASCII code value 0)

Example: using a string variable the hard way

int main(int argc, char *argv[]) { char a[10] = { 'H', 'e', 'l', 'l', 'o', '\0' } ; // String variable // Don't forget the sentinel '\0' // that ends the string ! printf( "sizeof(a) = %d\n", sizeof(a) ); printf( "String a = %s\n", &a[0] ); // Print string starting at a[0] printf( "Strange string: %s\n", &a[3] ); // Print string starting at a[3] }

Output:

sizeof(a) = 10 String a = Hello Strange string: lo

Explanation:

The string in array a[] is as follows: a[0] a[3] a[5] +---+---+---+---+---+---+---+---+---+---+ | H | e | l | l | o | \0| ? | ? | ? | ? | +---+---+---+---+---+---+---+---+---+---+
The string starting at location a[0] is: a[0] a[3] +---+---+---+---+---+---+---+---+---+---+ | H | e | l | l | o | \0| ? | ? | ? | ? | +---+---+---+---+---+---+---+---+---+---+ So the program prints Hello
The string starting at location a[3] is: a[0] a[3] +---+---+---+---+---+---+---+---+---+---+ | H | e | l | l | o | \0| ? | ? | ? | ? | +---+---+---+---+---+---+---+---+---+---+ So the program prints lo

Note:

Because the sentinal '\0' marks the end of a string, the data inside a[6], a[7], a[8] and a[9] are ignored by the printf() function.

Example Program: (Demo above code)
- Prog file: click here
How to run the program:

Short hand assignment syntax for string variables

Short hand syntax:

char a[10] = "Hello";
is short hand for: char a[10] = { 'H', 'e', 'l', 'l', 'o', '\0' } ;

More short hand syntax:

char a[] = "Hello";
is short hand for: char a[6] = { 'H', 'e', 'l', 'l', 'o', '\0' } ; (Size of the array is determined by the number of characters in the string (including the '\0' char !) )

Example:

int main(int argc, char *argv[]) { char a[10] = "Hello"; printf( "sizeof(a) = %d\n", sizeof(a) ); printf( "String a = %s\n", &a[0] ); printf( "Strange string: %s\n", &a[3] ); }

Example Program: (Demo above code)
- Prog file: click here
How to run the program:

String: array of characters or a (char *)

We have just seen that a string in C is stored as an array of characters

Fact:

A string in C can also be declared as a value/variable of the type char * (i.e., a point to a char typed variable).

Reason:

If a is defined as an array of characters:
then a is the address of the first element in the array: a == &a[0]
The variable a[0] has the type char !!!
Therefore:
In other words:

Example: function with a string variable

#include <stdio.h> void print1( char x[] ) // Normal way to express array of string { printf( "print1: string x = %s\n", x); } void print2( char *x ) // Alternate way to express array of string { printf( "print2: string x = %s\n", x); } int main(int argc, char *argv[]) { char a[10] = "Hello"; // String print1( a ); print2( a ); }

Example Program: (Demo above code)
- Prog file: click here
How to run the program:

String constants

String constant (or string) are denoted in the same way as Java:

"......."
Example: "Hello"

Facts:
The value of a string
Example:
The data type of a string:
BTW, the data type makes sense because address 5000 is the address of a (one) char typed variable
(The fact that this char typed variable is the first one in a serie (= array) does not void the fact that it is a char typed variable)

Example: (shows the fact that a string evaluates to an address)

#include <stdio.h> int main(int argc, char *argv[]) { printf("%lu\n", "Hello"); // Show me the address printf("%s\n", (char *)(4195964) ); // Use the address to print the string printf("%s\n", (char *)(4195965) ); }

Example Program: (Demo above code)
- Prog file: click here
How to run the program:
Output:

String library

C facts:

The Standard C library contains many function for string manipulations
I will discuss some string functions in this library and expose the implementation of a few of them.

Many of the string functions access array elements - and especially character arrays - using pointer variables

The data type of a string in the library functions are often declared as: char *
(or as const char * if you are not allowed to change the characters in the string)

Exposing some of the functions will allow you to see the power of pointer arithmetic of C

Strings in C --- arrays of char

Strings in C --- arrays of `char`