Each program (the source code .cpp file) should be submitted through Blackboard (Course Materials > Lab).

You can submit all your programs at the end of the lab session in one submission. This way, we can hopefully avoid the situation when you are quickly writing your program, immediately uploading it to Blackboard, but then, say 10 minutes later, realizing that there is a bug in it.

Basically, submit when you are sure that it will be your final version.

Each program should start with a comment that contains your name and a short program description, for example:

```
/*
Author: Your Name
Description: Lab 1. Task 1. Hello world
*/
```

You can submit incomplete programs, but their “incomplete” status must be clearly mentioned in the comment to the program. In this case, also briefly describe what is implemented, and what is not.

`vector<T>`

is a **template class** that works essentially like an array, but with many improvements.

**Constructors:**

`vector<int> v;`

makes an empty vector of integers (contains no elements),`vector<double> v(10);`

makes a vector of double-precision floating point numbers with 10 elements.

**Accessing the elements of a vector**

The elements of a vector are accessed the same way as the elements of a simple array:

```
vector<char> v(5);
v[0] = 'A';
v[4] = 'E';
```

**Some member functions:**

`v.push_back(x)`

adds element`x`

at the end of the vector (since vectors are essentailly extensible arrays, it’s common to create an empty vector, and sequetially add elements to the vector using this function).`v.size()`

returns the number of elements in the vector`v`

,

To read more about the class `vector<T>`

, please refer to this article
(in particular, read until the section *Iterators*).

**A box is a container that may contain other boxes**. And there may be many levels of nested boxes inside …

There is only one condition: all boxes placed inside another box must be either all arranged horizontally, or all arranged vertically. Schematically, it is shown in the figure below.

**How can we implement such a class Box?**

`Box`

is a very simple class that has two private member variables:

- a vector of the boxes that are put inside, called
`children`

, and - the direction the children are arranged, called
`dir`

.

```
enum Direction { HORIZONTAL, VERTICAL };
class Box {
private:
Direction dir;
std::vector<Box> children;
public:
...
};
```

In your opinion, why do you think we could not use an array for storing internal boxes?

**In this lab, we will be writing constructors for this class that make particular arrangements of boxes.**

You are provided with a function `print`

for printing a box and all other boxes it contains.

An empty box (with no children) would look like:

```
+-+
| |
+-+
```

A box with two empty boxes arranged horizontally would be

```
+------+
|+-++-+|
|| || ||
|+-++-+|
+------+
```

and so on.

>> **Download the source code** <<

This is not a part of the assignment, but it is worth mentioning that the printing function works using the public methods of the
class `Box`

that compute the width and the height of a box. This computation is done recursively:

The **base case is the empty box**, it has *width = 3* (in characters), and *height = 3*.

To compute the **width** of a bigger box, assuming that the child boxes are placed horizontally,
the total width **is the sum** the widths of the children *+2* for margins. Similarly, the **height
is the max** of the heights of the children *+2* for margins.

(And of course, if the child boxes are arranged in the vertical direction,
then the total width is the max, and the total height is the sum).

Another example of a complex arrangement of nested boxes:

Take the source code (boxes.cpp). Run the program, make a few boxes using two available constructors and print them out.

`Box(Direction d, int num)`

.Add a constructor `Box(Direction d, int num)`

that creates a box with `num`

empty boxes
arranged in the direction specified by the parameter `d`

.

To test your implementation, write a `main`

function similar to

```
int main() {
Box b1(HORIZONTAL, 0);
Box b2(HORIZONTAL, 1);
Box b3(VERTICAL, 3);
Box b4(HORIZONTAL, 5);
print(b1);
print(b2);
print(b3);
print(b4);
}
```

`Box(int width, int height)`

.Add a constructor `Box(int width, int height)`

that creates a box with
`height`

-many narrow boxes arranged vertically. And each of those child boxes
should contain `width`

-many empty boxes arranged horizontally.

For example, `Box b(4,3)`

should create a box like this:

Write a `main`

function to test the program. Test that the constructor works for various values of `width`

and `height`

greater or equal to 1.
(You may assume that these two parameters cannot be smaller than 1.)

`Box(vector<int>)`

.Add another constructor `Box(vector<int> v)`

that creates a box where the internal boxes are arranged horizontally, and
each internal box itself contains `v[i]`

-many children. As a result, we obtain something similar to a bar chart with
the bars going down.

**Example:**

When the vector contains *{ 1, 4, 2, 0, 3, 1 }*, the box should look like:

Write a `main`

function to verify that the constructor works correctly.

`Box(int)`

.As we know, Fibonacci numbers are defined recursively as

*F(0) = 1,*

*F(1) = 1,*

*F(n) = F(n-1) + F(n-2)* for all *n > 1*.

Similarly, we can define *Fibonacci boxes*, *FB(n)*:

When the paramenter *n* is equal to 0 or 1, it is an empty box.
Otherwise, when *n > 1*, a Fibonacci box *FB(n)* is a made of two smaller boxes *FB(n-1)* and *FB(n-2)* composed horizontally:

Add (or edit) a constructor `Box(int n)`

that generates such Fibonacci boxes. Also write a `main`

function that
prints out the Fibonacci boxes for *n = 0*, *1*, *2*, *3*, *4*, and *5*.