Lists, Strings&

Multi-dimensional arrays

2

Data Storage

• Static– 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

3

Static Storage

• Examples:static int X; // initially=0static 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

4

Dynamic Storage

• Examples:int X;int Y=5; // re-initialized at each callauto 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

5

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", *X); (print the value of what X points to)

6

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

7

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

bptrfptr

data

bptrfptr

data

bptrfptr

first

8

Structure

struct dl_list { mydatatype X;

dl_list * prev;dl_list * next;

};

9

List creation

dl_list * start; // only creates a pointerstart = (*dl_list) malloc (sizeof (dl_list));

// creates a SINGLE elementstart -> prev = &start; // pt BACK to homestart -> next=NULL; // end of list// now add on a new nodestart -> next = (*dl_list) malloc (sizeof (dl_list));start -> next -> next=NULL; // new end of liststart -> next -> prev=start->next; //<- old end of list

10

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

11

Other useful operations

• Insert/Delete_First• Insert/Delete_Last• Swap_entries• Copy_List• Problematic for single-linked list having fptrs:

– Traverse_back– Reverse_List

12

Strings

13

basics

• strings are arrays– stored like arrays– accessed "like" arrays– always a collection of "char"– compiler adds the 0x00 ending IF initialized

• Examplechar * mystring = "aha"; // length=4, incl 0x00compiler allocates space, sets ptr to it

14

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)

15

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 10function 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 (1)

• Requires the use of the new operator • Syntax:

new Type [amount]

int * ptr; // a ptr to an array of int'sptr= new int[5]; // note constant sizeif (dptr==NULL) …

is better thanif (dptr==0)…

Dynamic arrays (2)

int y;cin>>y;int * ptr; // a ptr to an array of int'sptr= new int[y]; // note size determined at

//run time

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)– 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>