Copyright 2006 Pearson Addison-Wesley, 2008, 2013 Joey Paquet 3-1 Concordia University Department of Computer Science and Software Engineering COMP345

Copyright 2006 Pearson Addison-Wesley, 2008, 2013 Joey Paquet 3-1

Concordia University

Department of Computer Science and Software Engineering

COMP345

Advanced program design with C++

Slide set 3: static and dynamic arrays


Learning Objectives

Introduction to Arrays Declaring and referencing arrays For-loops and arrays Arrays in memory

Arrays in Functions Arrays as function arguments, return values

Programming with Arrays Partially Filled Arrays, searching, sorting

Multidimensional Arrays


Introduction to Arrays

Array definition: A collection of data of same type

First "aggregate" data type Means "grouping" int, float, double, char are simple data types

Used for lists of like items Test scores, temperatures, names, etc. Avoids declaring multiple simple variables Can be manipulated as a single entity, with some restrictions


Declaring Arrays

Declare the array : allocates memoryint score[5];

Declares array of 5 integers named "score" Similar to declaring five variables:

int score[0], score[1], score[2], score[3], score[4]

Individual parts called many things: Indexed or subscripted variables “Elements” of the array Value in brackets called index or subscript

Numbered from [0] to [size – 1]


Accessing Arrays

Access using index/subscriptcout << score[3];

Note two uses of brackets: In declaration, specifies SIZE of array Anywhere else, specifies a SUBSCRIPT

Size and subscript need not be literalint score[MAX_SCORES];score[n+1] = 99;

If n is 2, identical to: score[3] However, the SIZE needs to be a CONSTANT Subscript can be any expression eventually evaluating to an

integer value (constant or not)


Array Usage

Powerful storage mechanism

Can issue command like: "Do this to ith indexed variable"

where i is computed by program "Display all elements of array score" "Fill elements of array score from user input" "Find highest value in array score" "Find lowest value in array score"


Program Using an Array (1 of 2)


Program Using an Array (2 of 2)


for-loops with Arrays

Natural counting loop Naturally works well "counting thru" elements

of an array

Example:

for (idx = 0; idx<5; idx++){

cout << score[idx] << "off by "<< max – score[idx] << endl;

}

Loop control variable (idx) counts from 0 to 5


Major Array Pitfall

Array indexes always start with zero! Zero is "first" number to computer

scientists C++ will "let" you go beyond range

Unpredictable results Compiler will not detect these errors!

Up to programmer to "stay in range"


Major Array Pitfall Example

Indexes range from 0 to (array_size – 1) Example:

double temperature[24]; // 24 is array size// Declares array of 24 double values // called temperature

They are indexed as:temperature[0], temperature[1] … temperature[23]

Common mistake:temperature[24] = 5;

Index 24 is "out of range"! No warning, possibly disastrous results


Defined Constant as Array Size

Always use defined/named constant forarray size

Example:const int NUMBER_OF_STUDENTS = 5;int score[NUMBER_OF_STUDENTS];

Improves readability

Improves versatility

Improves maintainability


Uses of Defined Constant

Use everywhere size of array is needed In for-loop for traversal:

for (idx = 0; idx < NUMBER_OF_STUDENTS; idx++){ // Manipulate array}

In calculations involving size:lastIndex = (NUMBER_OF_STUDENTS – 1);

When passing array to functions (later)

If size changes requires only ONE change in program (and recompilation)


Arrays in Memory

Recall simple variables: Allocated memory in an "address"

Array declarations allocate memory forentire array

Sequentially-allocated Means addresses allocated "back-to-back" Allows indexing calculations

Simple "addition" from array beginning (index 0)


An Array in Memory


Initializing Arrays

As simple variables can be initialized atdeclaration:int price = 0; // 0 is initial value

Arrays can as well:int children[3] = {2, 12, 1}; Equivalent to following:int children[3];children[0] = 2;children[1] = 12;children[2] = 1;


Auto-Initializing Arrays

If fewer values than size supplied: Fills from beginning Fills "rest" with zero of array base type

If array-size is left out Declares array with size required based on

number of initialization values Example:int b[] = {5, 12, 11};

Allocates array b to size 3


Arrays in Functions

As arguments to functions Indexed variables

An individual "element" of an array can be function parameter

Entire arrays All array elements can be passed as

"one entity“

As return value from function Can be done


Indexed Variables as Arguments

Indexed variable handled same as simplevariable of array base type

Given this function declaration:void myFunction(double par1);

And these declarations:int i; double n, a[10];

Can make these function calls:myFunction(i);// i is converted to doublemyFunction(a[3]);// a[3] is doublemyFunction(n);// n is double


Subtlety of Indexing

Consider: myFunction(a[i]);

Value of i is determined first It determines which indexed variable is sent

myFunction(a[i*5]); Perfectly legal, from compiler’s view Programmer responsible for staying

"in-bounds" of array


Entire Arrays as Arguments

Formal parameter can be entire array Argument then passed in function call

is array name Called "array parameter“

Send size of array as well Typically done as second parameter Simple int type formal parameter


Entire Array as Argument Example


Entire Array as Argument Example

Given previous example: In some main() function definition,

consider this call:int score[5], numberOfScores = 5;fillup(score, numberOfScores); 1st argument is entire array 2nd argument is integer value

Note no brackets in array argument!


Array as Argument: How?

What’s really passed?

Think of array as 3 "pieces" Address of first indexed variable (arrName[0]) Array base type Size of array

Only 1st piece is passed! Just the beginning address of array Very similar to "pass-by-reference"


Array Parameters

May seem strange No brackets in array argument Must send size separately

One nice property: Can use SAME function to fill any size array! Exemplifies "re-use" properties of functions Example:int score[5], time[10];fillUp(score, 5);fillUp(time, 10);


The const Parameter Modifier

Recall: array parameter actually passesaddress of 1st element Similar to pass-by-reference

Function can then modify array! Often desirable, sometimes not!

Protect array contents from modification Use "const" modifier before array parameter

Called "constant array parameter" Tells compiler to "not allow" modifications


Functions that Return an Array

Functions cannot return arrays in the same way simple types are returned

Requires use of a pointer


Programming with Arrays

Plenty of uses

Partially-filled arrays Must be declared some "max size"

Sorting

Searching


Partially-filled Arrays

Difficult to know exact array size needed

Must declare to be largest possible size Must then keep "track" of valid data in array

Additional "tracking" variable needed int numberUsed; Tracks current number of elements in array


Partially-filled Arrays Example: Partially Filled Array (1 of 5)










Global Constants vs. Parameters

Constants typically made "global" Declared above main()

Functions then have scope to arraysize constant No need to send as parameter then?

Technically yes

Why should we anyway? Function definition might be in separate file Function might be used by other programs!


Searching an Array (1 of 4)








Sorting an Array: Selection Sort

Selection Sort Algorithm


Sorting an Array (1 of 4)








Multidimensional Arrays

Arrays with more than one index char page[30][100];

Two indexes: An "array of arrays" Visualize as:page[0][0], page[0][1], …, page[0][99]page[1][0], page[1][1], …, page[1][99]…page[29][0], page[29][1], …, page[29][99]

C++ allows any number of indexes Typically no more than two


Multidimensional Array Parameters

Similar to one-dimensional array 1st dimension size not given

Provided as second parameter

2nd dimension size IS given

Example:

void displayPage(const char p[][100], int sizeDimension1){

for (int index1=0; index1<sizeDimension1; index1++){

for (int index2=0; index2 < 100; index2++)cout << p[index1][index2];

cout << endl;}

}


Summary 1

Array is collection of "same type" data

Indexed variables of array used just likeany other simple variables

for-loop "natural" way to traverse arrays

Programmer responsible for staying"in bounds" of array

Array parameter is "new" kind Similar to call-by-reference


Summary 2

Array elements stored sequentially "Contiguous" portion of memory Only address of 1st element is passed to functions

Partially-filled arrays more tracking

Constant array parameters Prevent modification of array contents

Multidimensional arrays Create "array of arrays"


Dynamic arrays and pointers


Learning Objectives

Pointers Pointer variables Memory management

Dynamic Arrays Creating and using Pointer arithmetic

Classes, Pointers, Dynamic Arrays The this pointer Destructors, copy constructors


Pointer Introduction

Pointer definition: Memory address of a variable

Recall: memory divided Numbered memory locations Addresses used as name for variable

You’ve used pointers already! Call-by-reference parameters

Address of actual argument was passed


Pointer Variables

Pointers are "typed" Can store pointer in variable Not int, double, etc.

Instead: A POINTER to int, double, etc.!

Example:double *p; p is declared a "pointer to double" variable Can hold pointers to variables of type double

Not other types!


Declaring Pointer Variables

Pointers declared like other types Add "*" before variable name Produces "pointer to" that type

"*" must be before each variable declaration

int *p1, *p2, v1, v2; p1, p2 hold pointers to int variables v1, v2 are ordinary int variables


Addresses and Numbers

Pointer is an address

Address is an integer

Pointer is NOT an integer!

C++ forces pointers be used asaddresses Cannot be used as numbers Even though it "is a" number


Pointing

Terminology, view Talk of "pointing", not "addresses" Pointer variable "points to" ordinary variable Leave "address" talk out

Makes visualization clearer "See" memory references

Arrows


Pointing to …

int *p1, *p2, v1, v2;p1 = &v1; Sets pointer variable p1 to "point to" int

variable v1

Operator, & Determines "address of" variable

Read like: "p1 equals address of v1" Or "p1 points to v1"


Pointing to …

Recall:int *p1, *p2, v1, v2;p1 = &v1;

Two ways to refer to v1 now: Variable v1 itself:cout << v1;

Via pointer p1:cout << *p1;

Dereference operator, * Pointer variable "derereferenced" Means: "Get data that p1 points to"


"Pointing to" Example

Consider:v1 = 0;p1 = &v1;*p1 = 42;cout << v1 << endl;cout << *p1 << endl;

Produces output:4242

p1 and v1 refer to same memory cell


& Operator

The "address of" operator

Also used to specify call-by-referenceparameter No coincidence! Recall: call-by-reference parameters pass

"address of" the actual argument

Operator’s two uses are closely related


Pointer Assignments

Pointer variables can be "assigned":int *p1, *p2;p2 = p1; Assigns one pointer to another "Make p2 point to where p1 points“

Do not confuse with:*p2 = *p1; Assigns "value pointed to" by p1, to "value

pointed to" by p2


Pointer Assignments Graphic: Uses of the Assignment Operator with Pointer Variables


The new Operator

Since pointers can refer to variables… No "real" need to have a standard identifier

Can dynamically allocate variables Operator new creates variables

No identifiers to refer to them Just a pointer!

p1 = new int; Creates new "nameless" variable, and

assigns p1 to "point to" it Can access its value with *p1

Use just like ordinary variable


Basic Pointer Manipulations (1 of 2)


Basic Pointer Manipulations (2 of 2)


Basic Pointer Manipulations Graphic:


More on new Operator

Creates new dynamic variable Allocated on the heap.

Returns pointer to the new variable

If type is class type: Constructor is called for new object Can invoke different constructor with

initializer arguments:MyClass *mcPtr;mcPtr = new MyClass(32.0, 17);

Can still initialize non-class types:int *n;n = new int(17); //Initializes *n to 17


Pointers and Functions

Pointers are full-fledged types Can be used just like other types

Can be function parameters

Can be returned from functions

Example:int* findOtherPointer(int* p); This function declaration:

Has "pointer to an int" parameter Returns "pointer to an int" variable


Memory Management

Heap Also called "freestore" Reserved for dynamically-allocated variables All new dynamic variables consume memory

from the freestore If too many could use all freestore memory

Future new operations will fail if freestoreis "full"


Checking new Success

Older compilers: Test if null returned by call to new:

int *p;p = new int;if (p == NULL){ cout << "Error: Insufficient memory.\n"; exit(1);}

If new succeeded, program continues


new Success – New Compiler

Newer compilers: If new operation fails:

Program terminates automatically Produces error message

Still good practice to use NULL check


Freestore Size

Varies with implementations

Typically large Most programs won’t use all memory

Memory management Still good practice Solid software engineering principle Memory IS finite

Regardless of how much there is!


delete Operator

De-allocate dynamic memory When no longer needed Returns memory to freestore Example:

int *p;p = new int(5);… //Some processing…delete p;

De-allocates dynamic memory "pointed to bypointer p"

Literally "destroys" memory content


Dangling Pointers

delete p; Destroys dynamic memory But p still points there!

Called "dangling pointer"

If p is then dereferenced ( *p ) Unpredicatable results! Often disastrous!

Avoid dangling pointers Assign pointer to NULL after delete:

delete p;p = NULL;


Dynamic and Automatic Variables

Dynamic variables Created with new operator Created and destroyed while program runs

Local variables Declared within function definition Not dynamic

Created when function is called Destroyed when function call completes

Often called "automatic" variables Properties controlled for you


Define Pointer Types

Can "name" pointer types To be able to declare pointers like other

variables Eliminate need for "*" in pointer declaration

typedef int* IntPtr; Defines a "new type" alias Consider these declarations:

IntPtr p;int *p;

The two are equivalent


Pitfall: Call-by-value Pointers

Behavior subtle and troublesome If function changes pointer parameter

itself only change is to local copy

Best illustrated with example…


A Call-by-Value Pointer Parameter (1 of 2)


A Call-by-Value Pointer Parameter (2 of 2)


Call-by-value Pointers Graphic: The Function Call sneaky(p);


Dynamic Arrays

Array variables Really pointer variables!

Standard array Fixed size

Dynamic array Size not specified at programming time Determined while program running


Array Variables

Recall: arrays stored in memoryaddresses, sequentially Array variable "refers to" first indexed variable So array variable is a kind of pointer variable!

Example:

int a[10];int * p;

a and p are both pointer variables!


Array Variables Pointers

Recall previous example:

int a[10];typedef int* IntPtr;IntPtr p;

a and p are pointer variables Can perform assignments:p = a; // Legal.

p now points where a points To first indexed variable of array a

a = p; // ILLEGAL! Array pointer is CONSTANT pointer!


Array Variables Pointers

Array variable

int a[10]; MORE than a pointer variable

const int * type Array was allocated in memory already Variable a MUST point there…always!

Cannot be changed!

In contrast to ordinary pointers Which can (and typically do) change


Dynamic Arrays

Array limitations Must specify size first May not know until program runs!

Must "estimate" maximum size needed Sometimes OK, sometimes not "Wastes" memory

Dynamic arrays Can grow and shrink as needed


Creating Dynamic Arrays

Very simple!

Use new operator Dynamically allocate with pointer variable Treat like standard arrays

Example:

typedef double * DoublePtr;DoublePtr d;d = new double[10]; //Size in brackets

Creates dynamically allocated array variable d,with ten elements, base type double


Deleting Dynamic Arrays

Allocated dynamically at run-time So should be destroyed at run-time

Simple again. Recall Example:

d = new double[10];… //Processingdelete [] d;

De-allocates all memory for dynamic array Brackets indicate "array" is there Recall: d still points there!

Should set d = NULL;


Function that Returns an Array

Array type NOT allowed as return-type of function

Example:int [] someFunction(); // ILLEGAL!

Instead return pointer to array base type:int* someFunction(); // LEGAL!


Pointer Arithmetic

Can perform arithmetic on pointers "Address" arithmetic

Example:

typedef double* DoublePtr;DoublePtr d;d = new double[10];

d contains address of d[0] d + 1 evaluates to address of d[1] d + 2 evaluates to address of d[2]

Equates to "address" at these locations


Alternative Array Manipulation

Use pointer arithmetic!

"Step thru" array without indexing:for (int i = 0; i < arraySize; i++)

cout << *(d + I) << " " ;

Equivalent to:for (int i = 0; i < arraySize; i++)

cout << d[I] << " " ;

Only addition/subtraction on pointers No multiplication, division

Can use ++ and -- on pointers


Multidimensional Dynamic Arrays

Yes we can! Recall: "arrays of arrays" Type definitions help "see it":

typedef int* IntArrayPtr;IntArrayPtr *m = new IntArrayPtr[3];

Creates array of three pointers Make each allocate array of 4 ints

for (int i = 0; i < 3; i++)m[i] = new int[4];

Results in three-by-four dynamic array!


Back to Classes The -> operator

Shorthand notation

Combines dereference operator, *, anddot operator

Specifies member of class "pointed to"by given pointer

Example:

MyClass *p;p = new MyClass;p->grade = "A"; //Equivalent to:(*p).grade = "A";


The this Pointer Member function definitions might need to refer to

calling object Use predefined this pointer

Automatically points to calling object:

class Simple{ public:

void showStuff() const; private:

int stuff;};

Two ways for member functions to access:cout << stuff;cout << this->stuff;


Overloading Assignment Operator

Assignment operator returns reference So assignment "chains" are possible e.g., a = b = c;

Sets a and b equal to c

Operator must return "same type" as it’sleft-hand side To allow chains to work The this pointer will help with this!


Overloading Assignment Operator

Recall: Assignment operator must bemember of the class It has one parameter Left-operand is calling objects1 = s2;

Think of like: s1.=(s2);

s1 = s2 = s3; Requires (s1 = s2) = s3; So (s1 = s2) must return object of s1’s type

And pass to " = s3";


Overloaded = Operator Definition

Uses string Class example:

StringClass& StringClass::operator=(const StringClass& rtSide)

{ if (this == &rtSide)// if right side same as left side return *this; else { capacity = rtSide.length;

length = rtSide.length;delete [] a; // a is a char array class member

// that stores the stringa = new char[capacity];for (int I = 0; I < length; I++) a[I] = rtSide.a[I];return *this;

}

}


Shallow and Deep Copies

Shallow copy Assignment copies only member variable

contents over Default assignment and copy constructors

Deep copy Pointers, dynamic memory involved Must dereference pointer variables to

"get to" data for copying Write your own assignment overload and

copy constructor in this case!


Destructor Need

Dynamically-allocated variables Do not go away until "deleted"

If pointers are only private member data They dynamically allocate "real" data

In constructor

Must have means to "deallocate" whenobject is destroyed

Answer: destructor!


Destructors

Opposite of constructor Automatically called when object is out-of-scope Default version only removes ordinary

variables, not dynamic variables

Defined like constructor, just add ~ MyClass::~MyClass(){

//Perform delete clean-up duties}


Copy Constructors

Automatically called when:1. Class object declared and initialized to other object

2. When function returns class type object

3. When argument of class type is "plugged in"as actual argument to call-by-value parameter

Requires "temporary copy" of object Copy constructor creates it

Default copy constructor Like default "=", performs member-wise copy

Pointers write own copy constructor!


Summary 1

Pointer is memory address Provides indirect reference to variable

Dynamic variables Created and destroyed while program runs

Freestore Memory storage for dynamic variables

Dynamically allocated arrays Size determined as program runs


Summary 2

Class destructor Special member function Automatically destroys objects

Copy constructor Single argument member function Called automatically when temp copy needed

Assignment operator Must be overloaded as member function Returns reference for chaining


Vectors


Vectors

Vector Introduction

Recall: arrays are fixed size

Vectors: "arrays that grow and shrink" During program execution

Formed from Standard Template Library(STL)

Using template class


Vector Basics

Similar to array: Has base type Stores collection of base type values

Declared differently: Syntax: vector<Base_Type>

Indicates template class Any type can be "plugged in" to Base_Type Produces "new" class for vectors with that type

Example declaration:vector<int> v;


Vector Use

vector<int> v; "v is vector of type int" Calls class default constructor

Empty vector object created

Indexed like arrays for access

But to add elements: Must call member function push_back

Member function size() Returns current number of elements


Vector Example: Using a Vector (1 of 2)


Vector Example: Using a Vector (2 of 2)


Vector Efficiency

Member function capacity() Returns memory currently allocated Not same as size() Capacity typically > size

Automatically increased as needed

If efficiency critical: Can set behaviors manually

v.reserve(32); //sets capacity to 32

v.reserve(v.size()+10); //sets capacity to 10 more than size


Summary 1

Vector classes Like: "arrays that grow and shrink"

Documents

Copyright 2006 Pearson Addison-Wesley, 2008, 2013 Joey Paquet 3-1 Concordia University Department of Computer Science and Software Engineering COMP345