Vectors and Functions

What is a vector?

Essentially a resizable array, like an ArrayList in Java.

Can get the size of the vector
Can add and remove elements
Ordered

Requires header: <vector>
Example: #include <vector>

Vectors in C++ vs. Java

Feature / Operation	C++ `std::vector`	Java `Vector`	Notes / Differences
Type / Template	`std::vector<T>` (template)	`Vector<T>` (class with generics)	C++ uses templates, Java uses generics
Dynamic resizing	Yes	Yes	Both grow automatically
Add element	`v.push_back(x)`	`v.add(x)`	Method names differ
Remove last element	`v.pop_back()`	`v.remove(v.size()-1)`	C++ has direct `pop_back()`
Access element by index	`v[i]` or `v.at(i)`	`v.get(i)`	C++ allows `[]`, Java requires `get()`
Set element by index	`v[i] = value`	`v.set(i, value)`	Method names differ
Size	`v.size()`	`v.size()`	Same
Iteration	`for(int x : v)` or iterators	`for(T x : v)` or `Iterator`	C++ uses iterators or range-based for loop
Initialization	`vector<int> v = {1,2,3};`	`Vector<Integer> v = new Vector<>();` `v.add(1); v.add(2);`	C++ can use initializer lists, Java adds elements individually
Memory / Performance	Lightweight, contiguous memory	Slightly heavier object overhead	Java may involve boxing for primitives
Iterator invalidation	Insertion/removal may invalidate iterators	Insertion/removal may invalidate iterators	Both can invalidate iterators when modified

Declaring

Vectors can be declared as either

Default size
Initial size
Initial size and initial value
Initial values, determined size

vector <DATATYPE> name;

Declaring example:

Adding Elements (push_back)

push_back() is a member function of the std::vector class.
It adds (appends) a new element to the end of the vector.
The vector grows dynamically to accommodate the new element.

.pop_back() removes the element at the end of the vector.

Resizing a Vector

Resizing a vector could either expand the vector or shrink the vector, depending on the size of the vector before the .resize() is called. If you want to change the vector to size n, then...

If n is more than the current size of the vector, then the vector expands, the extra elements are appended at the end of the vector.
If n is less than the current size of the vector, then the vector shrinks, and extra elements are demolished.

Accessing Elements

You can access elements in the vector using [] or .at()

v[index] does NOT do bounds checking.
v.at(index) does do bounds checking and throwsand throws an out_of_range exception if invalid.

.front() accesses element at v.at(0) and .back() accesses the very last element.

Clearing a Vector

Reusing a vector can be done with the .clear() method
Clearing a vector does two things:

Destroys all the elements in the vector.
Changes the size of the vector to zero.

You can think of it as resizing a vector to zero.

Copying vectors

Unlike Java arrays (or ArrayLists, vectors, etc.), C++ vectors can be copies using the assignment operator.

        vector a = {1, 2, 3, 4, 5};
        vector b = a;

Calculating the Min/Max

Find the minimum and maximum values in a vector.

Solution:

Assume the first element is both the min and max.
Iterate from second element to last element.

If the element is smaller than the min, the new min is this element.
If the element is bigger than the max, the new max is this element.

sort(v.begin(), v.end());

sort() is a function in the <algorithm> library.

It sorts elements in a range in ascending order by default
syntax: sort(start_iterator, end_iterator);

v.begin() points to the first element of the vector v
v.end() points just past the last element of the vector. (not the last element itself)

So, sort(v.begin(), v.end()) sorts all elements of v from smallest to largest.

Example:

Vector of Vectors

Modularity (Functions)

Organization, Readability
Problem solving process
Debugging
Resuability