1. What’s Left in the Course
Arrays and vectors (Chapter 8)
including searching and sorting (partially Chapter 11)
Recursion, scope rules, global and static variables
partially Chapter 10

2. structs (7.4) Used as data aggregates for an entity
can be different types of data
e.g. for student
id, name, GPA, address, ...
Similar to classes, but everything is public
structs can have constructors
structs can have member functions
we will not deal with constructors and member functions for structs unless they are necessary
mostly we will use structs for combining data for an entity into a single structure

3. Structs Example: struct for student
First struct must be defined by giving it a name and its fields (data)
struct student // student is struct name {
unsigned int id; // fields of student struct
string name, lastname;
double gpa;
}; // dont forget ; at the end
Then variables of that type are declared and used.
dot operator is used to refer fields of a struct variable
student stu;
stu.name = "Ali";
cout << stu.gpa;
See structdemo.cpp (not in book)

4. What can and can’t be done with structs
Structs can be passed to functions as parameters
use const-reference if not changing (using value parameter is syntactically OK, but not preferred due to performance reasons)
use reference parameter if changing
struct fields behave as variables/objects of field type
id is an integer
name is a string
You may read, write, use as operands in operations, etc.
However, processing the entire struct variable is restrictive
cannot read or write (using >> and <<) structs unless those operators are specially defined for that struct
cannot use operators between two structs unless those operators are specially defined for that struct
see for operator definitions for structs, but not responsible
structs are useful mostly in vectors (arrays)

5. Vectors and Arrays
Arrays are collections of several elements of the same type
E.g. 100 integers, 20 strings, 125 students, 12 dates, etc.
Single name is given to the entire array
But each element is accessed separately
Any element of an array can be accessed just as quickly as any other element (this is called “random access” but do not get confused with RandGen type of randomness)
In C/C++ there is a built-in array type
We will see it, but later
Vectors are a class-based version of arrays
First we will see vectors.
We’re using the class vector
need #include <vector>
vector is the standard C++ class vector

6. Why do we need arrays/vectors?
Consider the following example (not in the book):
pick n random numbers between 0 and 6 and count total number of occurrences of all outcomes (0, 1, 2, 3, 4, 5, 6)
n is an input
we need 7 counters
7 declarations
7 initializations
7 conditions to increment after each occurrence
7 cout statements to display the result
Fortunately, we have shorter way: ARRAYS/VECTORS
We can use vectors to store counters for all possible outcomes of the random numbers under a single name
easier processing in loops
see next slide for the program

7. Example Previous example using vectors - see randnums.cpp randStats
int num;
int k;
RandGen random;
vector<int> randStats(7); // vector for counters
int n = PromptRange("how many random numbers",1,20000);
for(k=0; k <= 6; k++) // initialize counters to zero
{ randStats[k] = 0; }
for(k=0; k < n; k++) // pick all random numbers
{ num = random.RandInt(7); // between 0 and 6
randStats[num] = randStats[num] + 1; // and increment
// corresponding counter
cout << "number\t\t# of occurrences" << endl;
for(k=0; k <= 6; k++)
{ cout << k << "\t\t" << randStats[k] << endl;
randStats

8. Vector/Array basics Vectors/Arrays are homogeneous
each item (sometimes called element) has the same type
that type must be specified at declaration
Items in a vector/array are numbered (e.g. 1st, 3rd, or 105th)
those are called index or subscript
numbering starts with 0
we have to use the index value to refer an element in a vector/array
Example definition and use of vectors (array definition is a bit different)
vector<int> ivals(10); // ivals can store 10 ints
ivals[0] = 3; // 0th element becomes 3
vector<string> svals(20); // svals can store 20 strings
svals[4] = "cs201"; // 4th element contains "cs201"

9. Vector basics Syntax of vector declaration
vector is a class, its declaration is construction
3 different methods
vector<type> variable_name;
empty vector (will see later)
vector<type> variable_name (size_expression);
vector with size_expression elements in it
vector<type> variable_name (size_expression, init_value);
vector with all size_expression elements initialized to init_value

10. Vector basics
size_expression can be any expression of type integer (or cast into integer)
not necessarily a constant value (this is actually a very important flexibility as compared to built-in arrays)
examples:
vector <int> letters (int('Z')-int('A') + 1);
creates a vector of 26 integer elements and name it letters
cin >> num;
vector <double> counters (num);
creates a vector of doubles; total number of elements is input
Index value starts with 0 and ends with size-1
type is type of the vector elements
can be built-in types (int, double, ...) or user defined types or classes or structs (string and date are class examples; student is struct example)
classes must have default constructors to be used in vector definition as element type

11. Defining vector objects
Can specify # elements in a vector, optionally an initial value
vector<int> counts(300); //300 ints, values not initialized
vector<int> nums(200, -1); // 200 ints, all -1
vector<double> d(10, 3.14); // 10 doubles, all pi
vector<string> w(10, "cs"); // 10 strings, all "cs“
vector<string> words(10); // 10 strings, all ""
If the vector type is a class, then this class must have a default constructor
Default constructor is the one without parameters
Cannot define vector<Dice> cubes(10); since Dice doesn’t have default constructor
Vectors of classes are initialized with the default constructor
that is why all words are "" (empty string)
Vectors with built-in types are not initialized (unless explicitly initialized with the second argument of vector definition)

12. Example vector definitions
vector<int> counter(9, 0);
each element is an integer (all initialized to 0)
counter
vector<char> letters(18);
each element is a char (not initialized yet)
letters
vector<Date> holidays(6);
each element is a date object
that contains todays date
holidays 12
2016 12
2016 12
2016 12
2016 12
2016 12
2016 4

13. How to reach a single vector/array element
specify the index value within square brackets after the vector/array name
var_name [index_expr]
the value of index expression must be between 0 and (vector size – 1)
Examples
vector<int> nums(9);
nums[5] = 102;
nums[0] = nums[5]*2-1;
nums[nums[5]/20-3] = 55;
nums[10] = 5; // error
nums
203 55
102

14. Passing vectors to functions as parameters
Vectors can be passed as parameters to functions
Pass by reference (if function changes the vector)
void Count (vector<int> & counts);
Pass by const-reference (if no changes made).
void Print(const vector<int> & counts);
Passing by value makes a copy, requires time and space, so not preferred
IMPORTANT!!! Vector size cannot be given in parameter definition. Three solutions to this problem:
the size may be passed as another parameter
the size may be fixed and known
vector has a member function, size, to return the size of a vector

15. Example Counting letters of a file
display number of occurrences of each letter at the end
counting is case insensitive
see letters.cpp (the one in book is a bit different)

16. vector as a return type Vector can be return type of a function
vector<int> Count (istream & input, int & total);
Example: modify letters.cpp such that count returns the vector (not as reference parameter)
see letters2.cpp

17. Vectors of structs We can define vectors of structs struct student {
1250 id
gpa
name
lastname
We can define vectors of structs
struct student {
unsigned int id;
string name, lastname;
double gpa; };
vector<student> class(11);
// a vector with 11 students
class[1].gpa = 3.2;
for (i = 0; i <= 10; i++)
class[i].id = i ;
1251 id
3.2
gpa
name
lastname 1
1260 id
gpa
name
lastname 10

18. shuffle.cpp program

19. Vectors as lists
The “vector as counters” example constructs and initializes a vector with a specific number of elements
Other uses of vector require the vector to “grow” to accommodate new elements
Consider reading words from a text file, storing them in a vector
How big should we define vector initially? What are potential problems?
When a vector is used as a list, we’ll use a different method for adding elements to the vector so that the vector can “grow”

20. Reading words into a vector (problematic version)
vector<string> words(1000);
string w;
int i = 0;
string filename = PromptString("enter file name: ");
ifstream input(filename.c_str());
while (input >> w) {
words[i]=w;
i++; }
cout << "read " << i << " words" << endl;
What is the problem?
there might be more than 1000 words in the file
in this case index runs out of range

21. Reading words into a vector (with index range control but still problematic)
vector<string> words(1000);
string w;
int i = 0;
string filename = PromptString("enter file name: ");
ifstream input(filename.c_str());
while ((input >> w) && (i < 1000)) {
words[i]=w;
i++; }
cout << "read " << i << " words" << endl;
What is the problem?
works fine if there are no more than 1000 words
but if there are more than 1000 words, the rest is not read

22. Reading words into a vector (no problems)
One method would be to pass over the file two times
one to find out number of words
second to read the words into array
Another method is to benefit from vector class utilities as in the following code
vector<string> words; //create empty vector
string w;
string filename = PromptString("enter file name: ");
ifstream input(filename.c_str());
while (input >> w) {
words.push_back(w); //adds the next word to the vector
//also increases the size if necessary }
cout << "read " << words.size() << " words" << endl;

23. Using vector::push_back
The method push_back adds new objects to the “end” of a vector,
Internally, the vector keeps track of its capacity
If there is capacity, then there is no problem; the new item is added to the end of the vector
When the capacity is reached and push_back attempts to add a new element to the vector, then the vector automatically “grows” by adding half of the current capacity to the capacity
0, 1, 2, 3, 4, 6, 9, 13, 19, 28, ... n+(n/2) …
If you want to use push_back mechanism, then the vector should be defined initially without specifying a size
empty vector (zero size)

24. Size versus Capacity Capacity is the allocated size of the vector
Size is how many elements are in the vector so far
They are not the same concepts, but related as described in the previous slide and illustrated below
vector<string> names; // size is 0, capacity is 0
names.push_back("Ali"); // size is 1, capacity is 1
names.push_back("Husnu"); // size is 2, capacity is 2
names.push_back("Ayse"); // size is 3, capacity is 3
names.push_back("Cem"); // size is 4, capacity is 4
names.push_back("Jale"); // size is 5, capacity is 6
names.push_back("Hale"); // size is 6, capacity is 6
names.push_back("Veli"); // size is 7, capacity is 9
names.push_back("Gonca"); // size is 8, capacity is 9
names.push_back("Fatma"); // size is 9, capacity is 9
names.push_back("Yesim"); //size is 10, capacity is 13

25. size()member function
size() member function basically returns the number of elements in the vector
When a vector is defined with no initial capacity, and push_back is used to add elements, size() member function returns the number of elements exist in the vector
This is the number of calls of push_back() if no elements are deleted
If elements deleted using pop_back(), size updated too (decremented)
If a non-empty vector is created, then the capacity and the size is set to the number of elements of the vector. This capacity is considered full, so the first push_back increases the capacity.
What about size() in case the vector is created as a non-empty one ?
returns the size specified during declaration if no push_back() is used
returns the size specified during declaration + the number push_back()’s, if push_back() is used

26. Vector Processing Examples – 1 (vectorproc.cpp – not in book)
write a function that takes a vector of integers as parameter and returns the maximum of numbers in it
process all array elements – for loop from 0 to vector’s size - 1
int max (const vector<int> & v)
//pre: vector v is not empty
//post: return max of elements in v {
int i, max_so_far = INT_MIN;
for (i=0; i < v.size(); i++)
if (v[i] > max_so_far)
max_so_far = v[i]; }
return max_so_far;

27. Vector Processing Examples – 2 (vectorproc.cpp – not in book)
Write a function that takes a vector of integers as parameter and returns true if the vector is sorted in ascending manner, false otherwise
may not process all vector elements
In this type of rule-checking applications, a possible method is to assume that the rule is satisfied before the loop and find a counterexample in the loop
bool issorted (const vector<int> & v)
//post: returns true if the array is acsending sorted {
bool s = true; // initially assume that array is sorted
//in the function try to break this assumption
int i =1;
while (i < v.size() && s == true)
{ //check until the end of array or until a counterexample is found
if (v[i-1] > v[i]) // if not sorted
s = false; // counterexample is found
i++; }
return s;