The document discusses strings and character processing in C. It covers: 1) Strings can be statically or dynamically allocated and functions like strlen() operate on both. Character classification functions like islower() test properties of characters. 2) Strings passed to functions can be represented as char*, char[] or char[X] and functions operate on the string regardless. Only static/dynamically allocated strings can be returned. 3) Common string functions include strlen(), strcpy(), strcat(), strcmp() for operations like copying, appending, comparing strings. strtok() extracts tokens from strings.

1. Strings
● A string is an array of characters, terminated by a NULL character ('0').
● Static allocation:
– char[] myString = “Hello, world!”; /* Guaranteed allocation; same
as char[14] myString = “…” */
– myString[0] = 'h'; /* Immutable ! */
● Dynamic allocation:
– char * myString = malloc (14); /* Has to be initialized; mutable!
*/
– if (NULL == myString) { /* must check before use! */ }
– myString[0] = 'h';
● No slicing!

2. Character Processing Functions
● Classification:
– int islower (int);
– int isupper (int);
– int isalnum (int);
– int isalpha (int);
– int isdigit (int);
– int isxdigit (int); /* 0—9A—F */
– int isodigit (int); /* 0—7; error in the book! */
– int isprint (int);
– int isgraph (int); /* printable, but not space */
– int isspace (int);
– int ispunct (int);
● Conversion:
– int tolower (int);
– int toupper (int);

3. Strings and Functions
● Any string can be passed to a function either as char* or char[] or char[X]:
– char foo[] = “Foo”;
– char *bar = “Bar”;
– char foobar[7] = “Foobar”; /* Add one byte for the NULL! */
– …
– int getLength (char *s) { return strlen (s); }
– …
– getLength (foo);
– getLength (bar);
– getLength (foobar);
● char foo[], not char[] foo!

4. Strings and Functions
● Only dynamically allocated or static strings can be returned from a function (as char* or
char[]):
– char *stringFactory (int len) {
– return malloc (len + 1);
– }
–
– char *getError (int index) {
– static const int N_MESSAGES = 10;
– static char *messages[N_MESSAGES] = { /* Array of pointers */
– “Sleepy programmer”,
– “Programmer out of mind”,
– ...
– }
– if (index >= 0 && index < N_MESSAGES)
– return messages[index];
– else
– return NULL; /* Typical for string functions */
– }

5. Demystifying main()
● The second parameter to main() is an array of strings:
– int main (int argc, char *argv[]) { … }
– int main (int argc, char **argv) { … }
– int main (int argc, char argv[][]) { … }

6. String Functions (1)
● String length
– #include <string.h> /* That's where they all live! */
– size_t strlen (const char *s);
● Copying: the destination must exist and have enough space!
– char *strcpy (char *dest, const char *src);
– char *strncpy (char *dest, const char *src, size_t n);
– char *strdup (const char *src); /* This function allocates memory
and may lead to memory leaks! */
● Appending to an existing string (there must be enough space for the combined string!):
– char *strcat (char *dest, const char *src);
– char *strncat (char *dest, const char *src, size_t n);
● String I/O: just like scanf() and printf(), but from/to string

7. String Functions (2)
● Comparison
– int strcmp (const char *s1, const char *s2); /* neg, 0 or pos */
– int strncmp (const char *s1, const char *s2, size_t n);
● Search
– char *strchr (const char *s, int c); /* pointer to the first
occurrence of c—or NULL */
– char *strrchr (const char *s, int c); /* pointer to the last
occurrence of c—or NULL */
– chat *strstr (const char *haystack, const char *needle); /*
pointer to the first occurrence of str—or NULL */
● Extract tokens (the original string is mutated):
– char *strtok (char *str, const char *separator); /* return a
pointer to the first token—or NULL */
– char *strtok (NULL, const char *separator); /* return a pointer
to the next pointer from the same string—or NULL */

8. String-to-Number and Back
● String-to-number (UNSAFE: return 0 both when s is a 0 and when s is not a number)
– int atoi (const char *s);
– long atol (const char *s);
– double atof (const char *s);
● String-to-number, safe; **p is a pointer to the remainder of the string that was not
converted to a number; if the whole string is a number, then **p==0.
– long strtol (const char *s, char **p, int base);
– unsigned long strtoul (…);
– double strtod (const char *s, char **p);
● Example:
– char *leftover;
– double d = strtod (“3.14159foobar”, &leftover);
– if (*leftover != '0') { … /* not a number */ }
● Number-to-string: sprintf()
– #include <math.h>
– char pi[8];
– sprintf (pi, “%7.5f”, MATH_PI);

9. Standard Error Handling
● Most standard library functions set the error status through the global variable “int
errno” (available after #include <errno.h>)
● The error message can be constructed using either of the following functions:
– char *strerror (int errnum);
– void perror (const char *detail);
● perror() reports errors directly to stderr.
● Do not report errors from your own functions using perror, unless they correctly set
errno.

10. Arrays
● Statically declared arrays cannot change size; the size at declaration cannot be a
variable:
– int counts[100];
– int grades[] = {1, 2, 4, 5, }; /* a trailing comma is allowed */
– int foos[n]; /* size must be a constant */
● The size of dynamically allocated arrays can be changed by realloc():
– double *speeds = malloc (sizeof (double) * 100); /* Must check
the return value! */
– …
– speeds = realloc (speeds, sizeof (double) * 200);
● Dynamic array size is NOT known to the C program at runtime! It's the programmer's
responsibility to remember it.
● Static array length can be calculated by dividing the array size by the size of the first
element:
– size_t len = sizeof (grades) / sizeof (grades[0]);
● After an array of type T is declared, T* and T[] are equivalent for any type (except void).
The size
– int add_grades (int *g);
– add_grades (grades, len); /* without len, cannot tell how many
elements! */

11. Arrays == Pointers
● For any array p, its name is equivalent to the pointer to its first element:
– p == &p[0]
– *p == p[0]
– *(p+1) == p[1]
● Arrays cannot be copied: q=p means that q is also pointing to p.

12. Structures
● Structures—classs with no methods and protection
– struct point {
– int x, y;
– chsr cid;
– };
– …
– struct point start = {4, 5, 'Y'}, end, middle;
– end.x = 10;
– end.y = 1;
– end.c = 'N';
– …
– printf (“%fn”,
– sqrt (pow (start.x - end.x, 2) + pow (start.y – end.y, 2)));
● Structures can be copied elementwise:
– middle = end;

13. typedef + struct
● Use type synonyms to get better readability:
– typedef struct point {
– int x, y;
– chsr id;
– } point_t;
– …
– point_t start = {4, 5, 'Y'}, end, middle;
● How about a pointer to a structure?
– typedef struct point *point_tp;
– …
– point_tp current = &middle;

14. Nested Structures
● A structure may have another structure as a field:
– typedef struct line {
– point_t a, b;
– } line_t;
–
– line_t myLine = {start, end};
– printf (“Line from %c to %cn”, myLine.a.id, myLine.b.id);
● Any structure used as a part of structure S, must be defined before the definition of S.
However, S may contain a pointer to another structure Q that is defined after S—given
that a partial definition of Q precedes the definition of S:
– struct branch; /* to be defined later */
– struct subtree {
– struct branch *left, *right;
– };
– struct branch { /* Actual definition of the structure */
– fruit_t fruit;
– struct subtree *subtree;
– };

15. Accessing Fields
● Structure given by value:
– point_t center;
– center.x = 12;
● Structure given by pointer:
– pointer_tp current = &middle;
– current->x = 12;

16. Simple Linked List
● Data structure:
– typedef struct node {
– payload_t payload;
– node_tp next;
– } node_t, *node_tp;
● List head:
– node_tp head = NULL; /* No list yet */
● Insert a node:
– node_tp insert (node_tp list, payload_p payload) {
– node_tp newNode = malloc (sizeof (node_t));
– if (newNode == NULL) return NULL;
– newNode->payload = payload;
– newNode->next = list;
– return newNode;
– }
– …
– head = insert (head, …);

17. Array of Structures
● Same as array of scalars.
● Static:
– point_t polygon[256];
– point_t triangle[] = {start, end, middle};
– point_t segment = {{1, 2, 'A'}, {4, -3, 'Z'}}
● Dynamic:
– point_tp mesh;
– mesh = malloc (sizeof (point_t) * 1024);
– if (!mesh) …
– mesh[0] = triangle[0];

18. Enumerated Data Types
● Different from Java enum (not class-specific)
● Internally represented as integer numbers
– typedef enum {SUNDAY, MONDAY, ...} day_t;
– day_t today = TUESDAY, tomorrow;
– if (today == 2) { /* true! */
– tomorrow = 3; /* works!  */
– }
● The representing numbers may be explicitly defined;
– typedef enum { ADD=0, DEL/*=1*/, SUB/*=2*/, MUL=10} opcodes;

19. Bitwise Operations
● Work on individual bits of numbers
– unsigned x, y;
– x & y; /* bitwise AND: 0110 & 1100 → 0100 */
– x | y; /* bitwise OR: 0110 | 1100 → 1110 */
– a ^ y; /* bitwise XOR: 0110 ^ 1100 → 1010 */
– ~x; /* one's complement: ~0110 → 1001 */
– x << y; /* left shift by y: 0110 << 1 → 1100 */
– x >> y; /* right shift by y: 0110 >> 1 → 0011 */

20. Bitvectors
● A bitvector is an integer number used to store individual bits
● Define a bitvector:
– unsigned flags = 0;
● Clear the whole vector:
– flags = 0;
● Set the whole vector:
– flags = ~0;
● Set the ith
bit:
– flags |= (1 << (i – 1));
●
Clear the ith
bit:
– flags &= ~(1 << (i – 1));
●
Extract the ith
bit nondestructively:
– (flags & (1 << (i – 1))) != 0

21. EOF