Lists, Strings & Multi-dimensional arrays

Data Storage Static Dynamic compiled into the disk-image of program always takes up space on disk & RAM usage depends on program logic Dynamic requested at runtime no space taken on disk usage as needed

Static Storage Examples: static int X; // initially=0 static int Y=5; extern int Z; // initially=0 Compiler reserves space for these Location for Y contains the 5 no runtime code used to put it there All KEEP their values, even after termination of the function

Dynamic Storage Examples: int X; int Y=5; // re-initialized at each call auto int Z; // "auto" is redundant // cannot use "auto" w/specification of a value auto int Q=5; // ILLEGAL Compiler adds code in function-start to REQUEST RAM for automatic variables Location for Y contains the 5 at fcn startup runtime code IS used to put it there

Dynamic Storage - 2 int X; int * xptr; xptr = &X; //xptr points to X (holds the RAM address of X) (NOT the value of X) printf ("X=%d", *xptr); (print the value of what xptr points to)

Dynamic lists Each node is a struct Struct data elements are created at "malloc" time Rules for static & auto apply Only static, const, integer variables may be initialized in a struct do it yourself at "malloc" time

Double-linked lists Simplifies traversals Slightly slower for insert/remove No need for temp ptr for internal insert/remove Uses more storage (trivial vs. data size) data bptr fptr first

Structure struct dl_list { mydatatype X; dl_list * prev; dl_list * next; };

List creation dl_list * start; // only creates a pointer start = (*dl_list) malloc (sizeof (dl_list)); // creates a SINGLE element start -> prev = &start; // pt BACK to home start -> next=NULL; // end of list // now add on a new node start -> next = (*dl_list) malloc (sizeof (dl_list)); start -> next -> next=NULL; // new end of list start -> next -> prev=start->next; //<- old end of list

Linked List Performance (textbook's names) O(n) Clear_list deletes the whole list Delete_list deletes ONE entry (one node) Insert_list inserts ONE entry (new node) Retreive_list gets ONE value (w/o harm) Replace_list replace ONE value (destructive) O(k) CreateList ListEmpty/Full state of the list = empty (t/f) ListSize # nodes

Other useful operations Insert/Delete_First Insert/Delete_Last Swap_entries Copy_List Problematic for single-linked list having fptrs: Traverse_back Reverse_List

Strings

basics strings are arrays Example stored like arrays accessed "like" arrays always a collection of "char" compiler adds the 0x00 ending IF initialized Example char * mystring = "aha"; // length=4, incl 0x00 compiler allocates space, sets ptr to it

Library functions strcopy – copies a string strncpy – copies 'n' chars strcat – appends string 2 to end of string 1 strcmp – compares 2 strings strch – finds a char in string strlen - returns length of string (w/o 0x00)

Danger!!! You must always ensure the 0x00 is there likewise, when searching, must be careful of actual max length compiler does NOT generate protective code does NOT check for overruns but DOES do it for arrays char * Z

Multidimensional Arrays

Syntax Type name [d1][d2][d3] {init list}; int X [3] [4] [5]; Leftmost subscript varies most slowly – known as row major order

Arrays as arguments #define SIZE 10 function X (int x, int y, int a [ ] [SIZE]) ; New standard as of 1999 implemented function X (int a[ ] [SIZE]) { ... } highest dimension is required

Dynamic arrays (C) Requires the use of the malloc function Syntax: p=malloc (amount) Return space with free p; int * ptr; // a ptr to an array of int's ptr= malloc (5*sizeof(int)); // constant size if (ptr==NULL) … is better than if (ptr==0)…

Dynamic arrays (C-2) Alternately, use the calloc function Syntax: p=calloc (amount, sizeof(..)) Return space with free p; int * ptr; // a ptr to an array of int's ptr= calloc (5,sizeof(int)); // constant size if (ptr==NULL) … is better than if (ptr==0)…

Dynamic arrays (C++) Requires the use of the new operator Syntax: new Type [amount] Return space with delete p; int * ptr; // a ptr to an array of int's ptr= new int[5]; // note constant size if (ptr==NULL) … is better than if (ptr==0)…

Dynamic arrays (C++2) int y; cin>>y; int * ptr; // a ptr to an array of int's ptr= new int[y]; // note size determined at //run time Return space with delete ptr; BUT: the size of the array is still FIXED (i.e.; size does not vary during execution)

Deleting storage Given the previous array: delete ptr; // deletes a SINGLE datum the one memory loc that ptr refers to Even if it's an array (only deletes array[0]) delete [ ] ptr; // deletes the whole array

Strings C-style strings (array of char) C++ style (true) strings char *x; x=new char [n] Or Using namespace std; #include <cstring> C++ style (true) strings #include <string.h> or using namespace std; #include <string>