1. Advanced Program Design with C++
COMP Advanced Program Design with C++
Advanced Program Design with C++
Static arrays
Dynamic arrays
STL containers
Joey Paquet,

2. Simple aggregate data type Used for lists of related items
COMP Advanced Program Design with C++
Arrays
Array definition:
A collection of data elements of same type
Identified by a sequential index
Simple aggregate data type
Can create arrays of elements of any type
Used for lists of related items
Test scores, temperatures, names, etc.
Avoids declaring multiple simple variables
Can be manipulated as a single entity, with some restrictions
Joey Paquet,

3. Declaring an array allocates memory on the stack: int score[5];
COMP Advanced Program Design with C++
Declaring an array
Declaring an array allocates memory on the stack:
int 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 are often called using different terms:
Indexed or subscripted variables
Elements of the array
Value in brackets called index or subscript
Numbered from [0] to [size – 1]
Joey Paquet,

4. Access using index/subscript Note two different uses of brackets:
COMP Advanced Program Design with C++
Accessing an array
Access using index/subscript
cout << score[3];
Note two different uses of brackets:
In declaration, specifies the size of the array
Anywhere else, specifies an index
Size and subscript need not be literal
int score[MAX_SCORES];
score[n+1] = 99;
If n is 2, identical to: score[3]
However, the size needs to be a constant expression
A constant expression is an expression that is composed of only constant components.
Why? The compiler needs to know what is the size of the array in order to allocate memory to it at compile time.
Subscript can be any expression eventually evaluating to an integer value (constant or not)
Joey Paquet,

5. Simple program using an array
COMP Advanced Program Design with C++
Simple program using an array
Joey Paquet,

6. Simple program using an array
COMP Advanced Program Design with C++
Simple program using an array
Joey Paquet,

7. Arrays and loops Example:
COMP Advanced Program Design with C++
Arrays and loops
Arrays and loops
Loop constructs naturally works well for "counting through" elements of an array
Example:
for (int idx = 0; idx<5; idx++) { cout << score[idx] << "off by " << max – score[idx] << endl; }
Loop control variable idx counts from 0 to 4
Joey Paquet,

8. C++ will let you go beyond range
COMP Advanced Program Design with C++
Index range
Valid range:
Start with zero
Zero is the first number in natural numbers
Index is used to compute offset of value in the array
End with size -1
C++ will let you go beyond range
Unpredictable results
Neither the compiler nor the runtime system will detect these errors!
In many cases, execution will continue as if nothing wrong happened
Up to programmer to stay in range
Major source of bugs
A major feature in the toolbox of malicious programmers…
Joey Paquet,

9. Always use defined/named constant for array size
COMP Advanced Program Design with C++
Use of constant as size
Always use defined/named constant for array size
Example: const int NUMBER_OF_STUDENTS = 5; int score[NUMBER_OF_STUDENTS];
Improves readability
Improves versatility
Improves maintainability
Joey Paquet,

10. Use everywhere size of array is needed
COMP Advanced Program Design with C++
Use of constant as size
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).
If not, need to track required changes in many places, which is very error-prone.
Indicative of the limitations of static arrays, which leads to rather inflexible code.
Joey Paquet,

11. Arrays in memory Array are stored as a contiguous block of memory.
COMP Advanced Program Design with C++
Arrays in memory
Array are stored as a contiguous block of memory.
Arrays are implicitly managed using pointers and pointer arithmetics. Given:
int a[4];
int b;
The elements of a are of type int.
However, a itself is implicitly a pointer to the first element of a.
Given an index, the compiler calculates an address offset that now points to the proper array element.
It will not check whether this points outside of the array.
Joey Paquet,

12. As simple variables can be initialized at declaration: int price1 = 0;
COMP Advanced Program Design with C++
Array initialization
As simple variables can be initialized at declaration: int price1 = 0;
int price2 {0};
Arrays can be initialized as well: int children[3] = {2, 12, 1};
Equivalent to following: int children[3]; children[0] = 2; children[1] = 12; children[2] = 1;
If the number of elements in the initialization list is greater than the size of the array, it generates a compile-time error.
If the number of elements in the initialization list is lesser than the size of the array, all missing elements are initialized to 0.
If the size is not specified, the size is assumed to be equal to the number of elements in the initialization list.
Joey Paquet,

13. COMP 345 - Advanced Program Design with C++
Size of a static array
As a static array is statically allocated on the stack, its size is known at compile time and thus one can use the sizeof() function to return their size:
Such a convenient feature does not exist for dynamically allocated arrays, or anything that is a pointer.
int intstatarr[3] = { 1, 2, 3 };
cout << "sizeof(intstatarr) [3]: " << sizeof(intstatarr) << endl;
int int2dstatarr[2][2] = { 1, 2, 3, 4 };
cout << "sizeof(int2dstatarr) [4]: " << sizeof(int2dstatarr) << endl;
double doublestatarr[3] = { 1.2, 2.3, 3.4 };
cout << "sizeof(doublestatarr) [3]: " << sizeof(doublestatarr) << endl;
1> sizeof(intstatarr) [3]: 12
1> sizeof(int2dstatarr) [4]: 16
1> sizeof(doublestatarr) [3]: 24
Joey Paquet,

14. Passing arrays as parameters
COMP Advanced Program Design with C++
Passing arrays as parameters
Arrays can be passed as parameters to functions.
In order to compile and do processing on an array in functions receiving an array as parameter, three things are needed:
Address of array: to generate offsets during compilation of the code to refer to the proper addresses where each array element resides.
Array base type: for type checking during compilation.
Size of array: To know how many elements there are in the array, e.g. to implement a loop over the entire array.
Syntax allows to pass an array as a parameter:
int myfunc(int p[]);
However, what is really happening if you use that, is that only a pointer to p is passed as value.
myfunc operates on the original array
myfunc is not aware of the size of the array passed
Joey Paquet,

15. Requires use of a pointer.
COMP Advanced Program Design with C++
Returning an array
Functions cannot return static arrays in the same way simple types are returned.
Requires use of a pointer.
The reason behind this is the same reason as for passing arrays as pointers: efficiency.
Passing an array as value, or returning an array from a function, or having array assignment would assume that arrays are copied as they are passed around and manipulated, leading to increased memory consumption and execution time.
C/C++ are designed for efficiency.
Joey Paquet,

16. multidimensional static arrays
COMP Advanced Program Design with C++
multidimensional static arrays
Joey Paquet,

17. Multidimensional static arrays
COMP Advanced Program Design with C++
Multidimensional static 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
Joey Paquet,

18. Multidimensional arrays
COMP Advanced Program Design with C++
Multidimensional arrays
A one-dimensional array is stored as a pointer to an array of data elements.
A two-dimensional array is stored as a pointer to an array of arrays of data elements.
And so on and so forth…
int a[3][4];
Joey Paquet,

19. Passing multidimensional arrays as a parameter
COMP Advanced Program Design with C++
Passing multidimensional arrays as a parameter
Similar to one-dimensional array
1st dimension size not given
Provided as second parameter
2nd dimension, and succeeding size is given though
Why?
The compiler needs to know the sizes of the dimensions in order to calculate the offsets when accessing array element, as each row is of a fixed size specified by the number of elements in the array.
This restriction greatly limits the usefulness of static multidimensional arrays as parameters.
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; } }
Joey Paquet,

20. Multidimensional arrays
COMP Advanced Program Design with C++
Multidimensional arrays
As the array is also stored in contiguous memory space, pointer arithmetic can still be used.
However, each row needs to be entirely skipped if referring to an element of further rows.
Joey Paquet,

21. Multidimensional arrays
COMP Advanced Program Design with C++
Multidimensional arrays
Joey Paquet,

22. dynamically allocated arrays
COMP Advanced Program Design with C++
dynamically allocated arrays
Joey Paquet,

23. Dynamically allocated arrays
COMP Advanced Program Design with C++
Dynamically allocated arrays
Static array limitations.
Must specify size first as a constant.
Very limited in its application, as in many cases the number of elements may not be known until the program runs.
May use partially filled arrays (see lab slides) for more flexibility.
Must estimate maximum size needed.
Wastes memory.
Dynamic arrays
Can grow and shrink as needed.
Implemented as a pointer to a dynamically allocated static array.
Joey Paquet,

24. Initializing a dynamically allocated array
COMP Advanced Program Design with C++
Initializing a dynamically allocated array
Use new operator
Create a pointer variable to the base type of the array elements.
Dynamically allocate an array using new.
Make the pointer variable point to the newly allocated array.
Then treat just like a standard array.
If size needs to be changed, just create a new one of different size, and copy the elements into the newly created one.
Example: double *d; d = new double[10];
Creates dynamically allocated array variable d, with ten elements of base type double.
The new operator for arrays does not restrict the size to be a constant.
Stored using the same model as a static array, except that the arrays of elements is stored on the heap instead of the stack, and thus each need to be pointed to by a pointer and carefully managed.
Joey Paquet,

25. Deallocating a dynamically allocated array
COMP Advanced Program Design with C++
Deallocating a dynamically allocated array
Allocated dynamically at run-time.
So should be destroyed explicitly at run-time.
double *d; d = new double[10]; … //Processing delete [] d;
delete [] de-allocates all memory for a dynamic array
Brackets indicate array is pointed to
Recall: d still points there!
Should set d = NULL; to avoid dangling pointer problems.
How does it know the size of what was pointed to?
When call new double[10] is called, the run-time system actually stores the size of the array that it is allocating.
It then uses this information when you call delete [] d
Joey Paquet,

26. multidimensional dynamically allocated arrays
COMP Advanced Program Design with C++
multidimensional dynamically allocated arrays
Joey Paquet,

27. Multidimensional dynamically allocated array
COMP Advanced Program Design with C++
Multidimensional dynamically allocated array
Can also be done by explicitly creating a nested array using pointers similar to a static array.
For example, to create a 3x4 array of integers:
First, create the array of 3 pointers that will eventually point to the 3 arrays of 4 integers, create a pointer variable that points to it (which is thus a pointer to a pointer to an int):
int** a = new int*[3];
Then use a loop to allocate 3 arrays of integers and have the pointers point to them:
for (int i = 0; i < 3; i++) a[i] = new int[4];
Results in three-by-four dynamic array
Joey Paquet,

28. Multidimensional dynamically allocated array
COMP Advanced Program Design with C++
Multidimensional dynamically allocated array
Results in three-by-four dynamic array
Not same structure as an equivalent static array:
Requires an additional pointer redirection level for each additional dimension.
Allocated on the heap, which cannot be assumed to be allocated contiguously.
Hence, the same simple pointer arithmetic does not apply.
Joey Paquet,

29. Multidimensional dynamically allocated array
COMP Advanced Program Design with C++
Multidimensional dynamically allocated array
As it was dynamically allocated, it then needs to be explicitly deallocated.
Each sub-array element has to be explicitly deallocated:
First, delete the arrays of integers:
for (int i = 0; i < 3; i++) delete [] a[i];
Then delete the array of pointers:
delete [] a;
One more embedded for loop for each additional dimension.
If we want to change the size of the dimensions, we need to create a new array structure and copy the existing data in the new array.
Tedious and careful memory management is required.
Joey Paquet,

30. other solutions COMP 345 - Advanced Program Design with C++
Joey Paquet,

31. COMP 345 - Advanced Program Design with C++
Static array classes
The Boost library also has an array class that implements a simple class embedding a static array and that stores its own size, making it much more practical than C++ basic static arrays.
The std::array class is (as of C++11) part of the C++ standard. The differences between boost::array and std::array are minimal.
Both these solutions still result in a static array whose size cannot be changed.
Joey Paquet,

32. COMP 345 - Advanced Program Design with C++
Static array classes
These can be manipulated using iterators and container manipulation algorithms
For multidimensional arrays, one needs to declare/use an array of such arrays.
Joey Paquet,

33. However, such features come with a certain cost:
COMP Advanced Program Design with C++
STL containers
Some say that one should always use STL containers such as vector instead of dynamically allocated arrays.
These are less error-prone than basic C++ arrays, as they provide features such as bounds checking and embed memory allocation/deallocation mechanisms.
STL containers allows automatic resizing of the container if necessary.
However, such features come with a certain cost:
Additional data is required to manage the container’s mechanism.
Computation time is required to manage the container’s mechanism.
In many cases, the overhead is negligible.
Joey Paquet,

34. STL containers COMP 345 - Advanced Program Design with C++
Joey Paquet,

35. COMP 345 - Advanced Program Design with C++
STL containers
Enables the use of iterators and dynamically sized arrays.
Multidimensional vectors:
Can also use operator[]:
Joey Paquet,

36. COMP 345 - Advanced Program Design with C++
STL containers
Creation/destruction: STL containers are templates (covered later). Each template defines constructors (including a copy constructor) and destructors appropriate to the type of values stored in the container.
Assignment: the assignment operator is overloaded for all STL templates.
Iterators: Iterators are variables used to refer to elements of a container. They can then be incremented and compared to other elements of the container (e.g. begin(), end()) as loop bounds.
Joey Paquet,

37. COMP 345 - Advanced Program Design with C++
STL containers
Access: the elements of an STL container can be accessed in different ways
The at() member function can be used to refer to an element of an STL container at a specific index. This function implements boundary checking.
The[]operator is overloaded for all STL container, which can be used to refer to specific elements using an index. This operator does not implement boundary checking.
Sequence containers also provide front() and back() method to directly access the first and last element of the container.
Capacity: All STL containers embed a mechanism to grow/shrink their size dynamically as the container is used. This is a definite advantage of STL containers (though it comes with a slight space/time overhead)
size(): returns the number of elements in the container.
capacity(): returns the size of the storage space currently allocated for the container. When this capacity is exhausted and more is needed, it is automatically expanded by the container (reallocating it storage space).
Capacity is not guaranteed to decrease as elements are removed.
All containers have a maximal capacity (max_size()).
Joey Paquet,

38. COMP 345 - Advanced Program Design with C++
STL containers
modifiers: the content of STL containers can be done using a variety of methods
insert(): inserts a value in the container in a specific index.
erase(): removes a specific element from the container, using begin(), end()or an iterator to identify the element. Can also be used to erase a portion of the container (only for ordered containers).
push_back(), push_front(): insert elements either at the front or back of the container.
pop_back(), pop_front(): removes the first or last element of the container.
clear(): erases all elements from the container.
swap(): exchanges the elements of a container with the elements current container.
Joey Paquet,

39. STL containers COMP 345 - Advanced Program Design with C++
Joey Paquet,

40. COMP 345 - Advanced Program Design with C++
References
Y. Daniel Liang, Introduction to Programming with C++ (Chapter 7, 11), Peason, 2014, ISBN-13:
Walter Savitch, Absolute C++ (Chapter 5, 7, 10, 19), Addison-Wesley, 2005, ISBN-13:
Bjarne Stroustrup, The C++ Programming Language (Chapter 6, 7, 11), Addison-Wesley, 2013, ISBN-13:
cppreference.com. std::array.
cplusplus.com. STL containers.
Joey Paquet,