Description

During this lab you will:

1. Work with a class that contains a 2d vector representing pixels.
2. Read files and store the content in the 2d vector of your class objects.
3. Practice overloading operators.
4. Create a tarball.

In this lab, you will to process several ascii files, combine them together using simple arithmetic operation, and output the result to the terminal.

Part I – Reading from the file

The file reading process is no different than what you  have done in the previous labs. Today, you need to read file line by line, then convert each char of the string into integer and store it into a 2d vector. The conversion can be done this way:

Part II – 2d vector, vector<vector<int>>

In this lab all files contain integers for your class, and a 2d vector of type vector<vector<int>> should be included.

Vectors are known as dynamic arrays with the ability to resize themselves automatically when an element is inserted or deleted, with their storage being handled automatically by the container.

Vector of Vectors is a two-dimensional vector with a variable number of rows where each row is also a vector. Each index of vector stores a vector which can be traversed and accessed using iterators. It is similar to an Array of Vectors but with dynamic properties.

Below is the example to demonstrate insertion into a vector of vectors.

Part III – Operator Overloading

In this lab, you need to overload 3 operators, +,  – ,  and << .

Overloading operator+

The meaning of an operator is always the same for variables of basic types, such as int, float, double, etc. For example: to add two integers, + operator is used.

However, for user-defined types, like objects, you can redefine the way operator works. For example, if there are two objects that contains string as its data member, you can redefine the meaning of + operator and use it to concatenate these strings.

This feature in C++ programming that allows programmer to redefine the meaning of an operator (when they operate on class objects) is known as operator overloading.

Below is an example of two forms of overloading operator+ . Overloading operator- will be similar.

Important: 

The Box class in the above example contains only doubles, however, in your class the data member is vector<vector<int>>, if you do not allocate memory for your 2d vector, you cannot use [ ][ ] to assign new value, instead, you need manually call the push_back() function to put the new value into your 2d array.

Overloading operator<<

Overloading operator<< is similar to overloading operator+ (they are both binary operators), except that the parameter types are different.

Consider the expression std::cout << box. If the operator is <<, what are the operands? The left operand is the std::cout object, and the right operand is your Point class object. std::cout is actually an object of type std::ostream. Therefore, our overloaded function will look like this:

1. // std::ostream is the type for object std::cout
2. friend std::ostream& operator<< (std::ostream &out, const Box &box);

Implementation of operator<< for Box class is fairly straightforward, because C++ already knows how to output doubles using operator<<, and our members are all doubles, we can simply use operator<< to output the member variables of box. Here is the above Box class with the overloaded operator<<.

 Part IV- Lab assignment. 

In this lab you will do the following

1. Download the starter kit archive lab10.zip. The files h and driver.cpp are provided, and you do not need to modify them. File pixelArt.cpp is provided, but the methods are missing their bodies.

2. Implement the missing methods and overload the operators for the pixelArt class.

3. Run your driver and send the output to the terminal. The file named result is provided for reference in the starter kit as well. Your output to the screen should look exactly the same.