String C and Data Structures Baojian Hua

What ’ s a String? A string is a sequence of characters: Every character ci (0 ≤ i<n) is taken from some character set (say the ASCII or the UniCode) Ex: “hello, world”, “string1\tstring2\n” Essentially, a string is a linear list But different operations

Isn ’ t String a “ char* ” ? C ’ s convention for string representation C has no built-in string type Every string is a char array (char *) terminated with char ‘\0’ Operations are available in standard library (see the library ): char *strcpy (char *s, const char *ct); char *strcat (char *s, const char *ct); … Operations are array-based and thus efficient

Problems with C String? Weakness of C ’ s “ char * ” string: Most strings are constants See demo of C’s “char *”… Why? May be space-consuming why? Operations may be too slow strcmp (char *, char *);

Problems with C String? Some operations are dangerous: Ex: strcpy (“ab”, “1234”) Notorious source of bugs it’s programmers’ duty to prevent these Some viruses take advantage this… Morris’s worm in 1988 the world’s first wide-spread See demo for this…

“ String_t ” ADT We want an ADT “String_t”: hides the concrete representation of string offers more flexible operations and cures security problems To keep compatible with C, ‘\0’ is reserved as terminator

Interface // in file “string.h” #ifndef STRING_H #define STRING_H #define T String_t typedef char *T; // CDT. Why? T String_new (char *s); int String_size (T s); int String_isEmpty (T s); int String_nth (T s, int n); T String_concat (T s1, T s2); #undef T #endif

Array-based Implementation // in file “string.c” #include “string.h” // Basic idea is to heap-allocate arrays \0 0 n str

Operations: “ new ” String_t String_new (char *s) { int len = strlen (s); String_t p = malloc ((len+1) * sizeof(*p)); while (*p++ = *s++) ; return p; } \0 0 n p

Operations int String_size (String_t s) { return strlen (s); } int String_nth (String_t s, int n) { return s[n]; } // Recall the definition typdef char *String_t; // do we really need these functions? size

Operations: “ concat ” \0 s1 \0 s2 p \0

Operations: “ concat ” String_t String_concat (String_t s1, String_t s2) { int n1 = strlen (s1); int n2 = strlen (s2); Strint_t p = malloc ((n1+n2+1) *sizeof(*p)); // copy both s1 and s2 to p, leave to you …; return p; }

Summary so far The string representation discussed so far is functional style again: functional==data never change we always make new data from older ones Java and ML also have functional strings But for some operations, buffer may be used for efficiency purpose

Problem? It may be too slow: consider how to implement this: int strcmp(char *dst, char *src); It may be too space consuming: e.g., these two calls generate two strings: String_new ( “ hello ” ); So, we need a high-level “ string ” to resolve these

Interface // in file “str.h” #ifndef STR_H #define STR_H #define T Str_t typedef struct T *T; // ADT! T Str_new (char *s); int Str_size (T s); int Str_isEmpty (T s); int Str_nth (T s, int n); T Str_concat (T s1, T s2); #undef T #endif

Array-based Implementation // in file “str.c” #include “string.h” #include “str.h” struct Str_t { char *s; int size; int hashCode; // omitted for now }; // maintain an internal // cache of all “str”! List_t allStrs = 0; \0 0 n s size str

Operations: “ new ” Str_t Str_new (char *s) { // #1: search the “allStrs” list to try to find // “s” // #2: if #1 succeeds, then return the result // #3: else cook a new node, put it to “allStr” // and return it return p; } data next data next data next l …

Operations: “ new ” Str_t Str_new (char *s) { // we only write #3 here: Str_t temp = malloc (sizeof (*temp)); temp->str = s; temp->size = strlen (s)+1; List_insertHead (allStrs, temp); return p; } data next data next data next l …

Operations: “ equals ” int Str_equals (Str_t s1, Str_t s2) { return s1==s2; // Fast! } data next data next data next l …

Summary For fast string comparison and less memory usage, we modify the data structure of string a technique called memoization Interplay between DS and algorithm again