Theory

• Classes are an expanded concept of data structures: like data structures, they can contain data members, but they can also contain functions as members.
• An object is an instantiation of a class. In terms of variables, a class would be the type, and an object would be the variable.
• Classes are defined using either keyword class or keyword struct, with the following syntax:

class class_name {
  access_specifier_1:
    member1;
  access_specifier_2:
    member2;
  ...
} object_names;

Where class_name is a valid identifier for the class, object_names is an optional list of names for objects of this class. The body of the declaration can contain members, which can either be data or function declarations, and optionally access specifiers.

• C++ classes encapsulate data and associated functionality into an object:



// C++ class: class Cube { public: double getVolume(); // ... private: double length_; };

// C++ class: class Cube { public: double getVolume(); // ... private: double length_; };

• Thus, Classes have the same format as plain data structures, except that they can also include functions and have these new things called access specifiers. An access specifier is one of the following three keywords: private, public or protected. These specifiers modify the access rights for the members that follow them.
• Encapsulation encloses data and functionality into a single unit (called a class)
• In C++, data and functionality are separated into two separate protections: public and private.

The protection level determines the access that «client code» has to the member data or functionality:

• Public members can be accessed by client code. So, public members are accessible from anywhere where the object is visible. protected members are accessible from other members of the same class (or from their «friends»), but also from members of their derived classes.
• Private members cannot be accessed by client code (only used within the class itself). So, private members of a class are accessible only from within other members of the same class (or from their «friends»).

Example of header-file code (Cube.h):

#pragma once class Cube { public: double getVolume(); double getSurfaceArea(); void setLength(double length); private: double length_; };

#pragma once class Cube { public: double getVolume(); double getSurfaceArea(); void setLength(double length); private: double length_; };

Example of implementation-file code (Cube.cpp):

#include "Cube.h" double Cube::getVolume() { return length_ * length_ * length_; } double Cube::getSurfaceArea() { return 6 * length_ * length_; } void Cube::setLength (double length) { length_ = length; }

#include "Cube.h" double Cube::getVolume() { return length_ * length_ * length_; } double Cube::getSurfaceArea() { return 6 * length_ * length_; } void Cube::setLength (double length) { length_ = length; }

Example of main-file code (main.cpp):

#include "Cube.h" int main() { Cube c; c.setLength(3.48); double volume = c.getVolume(); std::cout << "Volume: " << volume << std::endl; return 0; }

#include "Cube.h" int main() { Cube c; c.setLength(3.48); double volume = c.getVolume(); std::cout << "Volume: " << volume << std::endl; return 0; }

Arguments passed by …

Identical to storage, arguments can be passed to functions in three different ways:
• Pass by value (default)
• Pass by pointer (modified with *)
• Pass by reference (modified with &, acts as an alias)

Values returned by …

Similarly, values can be returned all three ways as well:

• Return by value (default)
• Return by pointer (modified with *)
• Return by reference (modified with &, acts as an alias)

Class destructor

• When an instance of a class is cleaned up, the class destructor is the last call in a class’s lifecycle.
• An automatic default destructor is added to your class if no other destructor is defined.
• The only action of the automatic default destructor is to call the default destructor of all member objects.
• An destructor should never be called directly. Instead, it is automatically called when the object’s memory is being reclaimed by the system:
• If the object is on the stack, when the function returns
• If the object is on the heap, when delete is used
• To add custom behavior to the end-of-life of the function, a custom destructor can be defined as:
• A custom destructor is a member function.
• The function’s destructor is the name of the class, preceded by a tilde ~.
• All destructors have zero arguments and no return type.

Cube::~Cube(); // Custom destructor

Cube::~Cube(); // Custom destructor

Labs and tasks

Lab 1:
To do: Create a Rectangle class and an object (i.e., a variable) of this class, called rect.
1) The class should contain four members:
— two data members of type int (member width and member height) with private access,
— and two member functions with public access: the functions set_values and area.

2) Define two member functions: set_values function should set the variables width and height to the values; are function should return width*height.

3) Create a Custom default constructor to have the initial values for width and height (set them to 5).

4) Set the width and height values for the rect object and print out the information about this object.

Expected output:

Lab 1:
please, enter width:
>> 20
please, enter height:
>> 2
rect area: 40

✍ Algorithm:

• To do the lab create empty console application with a name Lesson9. Add files: mainLab1.cpp, ImpLab1.cpp, HeaderLab1.h.
• Include all the needed libraries and files.

1.Create a Rectangle class:

• The class must be defined inside a header file. So, open the header file and add the code to define the class with two private data members, they are width and height; and two member functions with public access, they are set_values and area.

class Rectangle { private: int width, height; public: void set_values(int, int); int area(void); } ;

class Rectangle { private: int width, height; public: void set_values(int, int); int area(void); } ;

Here Rectangle is the class name (i.e., the type).
The functions set_values and area have a public access, it means that they can be accessed from inside the main function by simply inserting a dot (.) between object name and member name (e.g. rect.set_values…).
width and height members cannot be accessed from outside the class, since they have private access and they can only be referred to from within other members of that same class.
2. Define two member functions:
Since members width and height have private access, access to them from outside the class is not allowed. So, we should define a member function to set values for those members within the object: the member function set_values.
Let’s create the definition of set_values member function. We’re going to have a member of a class outside the class itself, so, we have to use scope operator (::, two colons). You should create the definition of the function inside the implementation file:
void Rectangle::set_values(int x, int y) { width = x; height = y; }
void Rectangle::set_values(int x, int y) { width = x; height = y; }
The scope operator (::) specifies the class to which the member being defined belongs, granting exactly the same scope properties as if this function definition was directly included within the class definition. For example, the function set_values has access to the variables width and height, which are private members of class Rectangle, and thus only accessible from other members of the class, such as this.
The second member function, that is area function, we’re going to have inside the class itself, just to try different ways of definition. So, return to the header file and add the definition inside the class next to int area(void) statement:
int area() {return width*height;}
int area() {return width*height;}
The function is automatically considered an inline member function by the compiler.
3) Create a Custom default constructor to have the initial values for width and height (set them to 5).
Add the declaration of a Custom default constructor inside the public access of the class (header file):
public: // you had this code Rectangle(); void set_values(int, int); // you had this code //...
public: // you had this code Rectangle(); void set_values(int, int); // you had this code //...
Open your implementation file to add the definition of that constructor:
Rectangle::Rectangle() { width = 5; height = 5; }
Rectangle::Rectangle() { width = 5; height = 5; }
4) Set the width and height values for the rect object and print out the information about this object:
Open a main file in the editor window. You should create an object (i.e., a variable) of the Rectangle class, called rect. And after this, ask user to input the width and height values. Call the set_values function and output the result:
int main() { Rectangle rect; int w, h; cout << "please, enter width:\n"; cin >> w; cout << "please, enter height:\n"; cin >> h; rect.set_values(w, h); cout << "rect area: " << rect.area() << endl; system("pause"); return 0; }
int main() { Rectangle rect; int w, h; cout << "please, enter width:\n"; cin >> w; cout << "please, enter height:\n"; cin >> h; rect.set_values(w, h); cout << "rect area: " << rect.area() << endl; system("pause"); return 0; }
Run the program and check the output.
Task 1:

To do: Create a LessonDate class to output the date of a lesson.

1) The class should contain the following members:
— three data members of type int with private access, they are day, month and year;
— and two member functions with public access:
void setDate(int, int, int); to set the date for the next lesson and
void getDate(); to print out the date of the lesson.

2) Create a three argument constructor to have the initial values for date; in the constructor body call the setDate function to set the date.

3) Inside the main function create an object (i.e., a variable) of this class, called objLesson. Set the values of three parameters — day, month and year. Print out the information about this object.

Expected output:

Task 1:
Lesson date: 11.11.2021
Please, enter day, then month and year of the next lesson
28
12
2020
Lesson date: 28.12.2020

[Solution and Project name: Lesson_9task1, file name L9Task1main.cpp, L9Task1imp.cpp, L9Task1.h]

Lab 2:
To do: Create a Cube class.
1) The class should contain four members:
— length_ data member of type double with private access,
— three member functions with public access: the functions double getVolume(); , double getSurfaceArea(); and void setLength(double length);.

2) Give the definitions (implementations) of those functions:
getVolume() function have to calculate a volume of the cube: length_ * length_ * length_;
getSurfaceArea() function have to calculate a Surface Area of the cube: 6 * length_ * length_;;
setLength(double length) function have to set the value for the cube length.

3) Create a Custom default constructor to have the initial values for length_ (set it to 1).

4) Inside the main cpp file create double cube_on_stack() function to create an object (i.e., a variable) of this class and get volume of it. This object will be in a stack memory. Also, inside the main function create a new cube of length 10 which is going to be in heap memory. Set the values. Print out the information about those objects.

5) Create a custom destructor to delete an information about the cube.

Expected output:

Lab 2:
Volume of c cube:
Destructor called for cube with length 2
Volume of c cube in the heap memory: 27
Destructor called for cube with length 3

✍ Algorithm:

• To do the lab create an empty console application with a name Lesson9Lab2. Create new files: mainLab2.cpp, ImpLab2.cpp, HeaderLab2.h.
• Include all the needed libraries and files.

1.The class should contain four members:

• The interface of the class must be inside a header file. So, open the header file and add the code to define the class with one private data member, it is length_ of a cube; and three member functions with public access, they are getVolume(), getSurfaceArea() and setLength(double length).

class Cube { public: double getVolume(); double getSurfaceArea(); void setLength(double length); private: double length_; };

class Cube { public: double getVolume(); double getSurfaceArea(); void setLength(double length); private: double length_; };

Here Cube is the class name (i.e., the type.
The functions getVolume(), getSurfaceArea() and setLength(double length) have a public access, it means that they can be accessed from anywhere where the object is visible.
length_ member cannot be accessed from outside the class, since it has a private access and it can only be accesses from within the class itself.
2. Give the definitions (implementations) of the functions:
Let’s create the definition of setLength member function. We’re going to have a member of a class outside the class itself, so, we have to use scope operator (::, two colons). You should create the definition of the function inside the implementation cpp file:
void Cube::setLength(double length) { length_ = length; }
void Cube::setLength(double length) { length_ = length; }
The scope operator (::) specifies the class to which the member being defined belongs, granting exactly the same scope properties as if this function definition was directly included within the class definition. For example, the function setLength has access to the variable length_, which is a private member of the class Cube, and thus only accessible from other members of the class, such as this.
The second and th third member functions are getVolume and getSurfaceArea function, we’re going to have them inside the implementation file too:
double Cube::getVolume() { return length_ * length_ * length_; } double Cube::getSurfaceArea() { return 6 * length_ * length_; }
double Cube::getVolume() { return length_ * length_ * length_; } double Cube::getSurfaceArea() { return 6 * length_ * length_; }
The getVolume function will return the volume of that cube, for which this function will be called.
The getSurfaceArea function will return the surface area of that cube, for which this function will be called.
3) Create a custom default constructor to have the initial values for length_ (set it to 1).
Add the declaration of a custom default constructor inside the public access of the class (header file):
public: // you had this code Cube(); //...
public: // you had this code Cube(); //...
Open your implementation file to add the definition of that constructor:
Cube::Cube() { length_ = 1; }
Cube::Cube() { length_ = 1; }
4) Inside the main cpp file create double cube_on_stack() function to create an object (i.e., a variable) of this class and get volume of it:
Open a main file in the editor window. Before the main function add the code to create cube_on_stack() which will create the object of Cube class and return the volume of this object:
double cube_on_stack() { Cube c; c.setLength(2); return c.getVolume(); } int main() { // ... }
double cube_on_stack() { Cube c; c.setLength(2); return c.getVolume(); } int main() { // ... }
Inside the main function ptint out the message and call that function:
int main() { cout << "Volume of first cube: " << endl; cube_on_stack(); }
int main() { cout << "Volume of first cube: " << endl; cube_on_stack(); }
Also, inside the main function create a new cube of length 10 which is going to be in heap memory. Set the values. Print out the information about those objects.
Then, inside the main function you should create a new cube of length 10 which is going to be in heap memory:
Cube * pcube = new Cube; pcube->setLength(3); cout << "Volume of c cube in the heap memory: " << pcube->getVolume() << endl;
Cube * pcube = new Cube; pcube->setLength(3); cout << "Volume of c cube in the heap memory: " << pcube->getVolume() << endl;
To have an object to be stored in the heap memory you should use star (*) sign. Such objects or instances to the objects can be used together with arrow operator to access their members.
5) Create a custom destructor to delete an information about the cube.
Open header file to declare a class destructor, which will be called to clean up the instance of the class. Add it right after the class constructor to the public protection level:
~Cube();
~Cube();
Add the implementation for that destructor inside implementation file:
Cube::~Cube(){ cout << "Destroyed cube with length " << length_; }
Cube::~Cube(){ cout << "Destroyed cube with length " << length_; }
Return to the main file and add the delete keyword to clean up the memory of the pcube object:
// ... delete pcube;
// ... delete pcube;
If the object is on the heap, the destructor is only called when that delete keyword is used, to reclaim that memory that the object was using.
Run the program and check the output.
Task 2:

To do: Create a Student class to output information about the students.

1) The class should contain the following members:
— two data members of type string with private access, they are name and surname, and one data member of type int — age;
— and two member functions with public access:
void set_info(string, string, int); to set the information about the student
and void get_info(void); to print out the information.

2) Create a three argument constructor to have the initial values for student.

3) Inside the main cpp file create void student_on_stack() function to create an object (i.e., a variable) of this class and get volume of it. This object will be in a stack memory. Also, inside the main function create a new student with some info about, which is going to be in a heap memory. Print out the information about those objects.

4) create a custom destructor to delete an information about student.

Expected output:

Task 2:
info about student1: name: Johnsurname: Ivanovage: 20
Destructor called for Student Ivanov
info about student2: name: Petersurname: Panage: 17
Destructor called for Student Pan

[Solution and Project name: Lesson_9task2, file name L9Task2main.cpp, L9Task2imp.cpp, L9Task2.h]

Task 3:

To do: Create a BookShop class to store and output an information about the selling books.

1) The class should contain the following members:
data members with private access:
— title_ (a title of a book) of type string;
— author_ (an author of a book) of type string;
— _price (a price of a book) of type double;
— _discount (a discount for a price of a book) of type int.
data members with public access:
— void getInfo() function to print out the information about the book;
— void set_info(string title, string author, double price, int discount) function to set the information about the book;
— double getTotalPrice() function calculate the price of a book considering the discount (price — (price * discount)).

2) Create a four argument constructor to have the initial values for books.

3) Create two objects and print out the information about those objects. Print out the info about the price considering the discount.

Expected output:

Task 3:
// book 1 info:
Dostoevsky Demons 205 roubles, discount 0.05, total price 194,75 roubles
// book 2 info:
Kuprin Duel 125 roubles, discount 0.1, total price 112,5 roubles

[Solution and Project name: Lesson_9task3, file name L9Task3main.cpp, L9Task3imp.cpp, L9Task3.h]

Back
Menu
Go ahead

Theory

Forward_list or singly-linked lists

• Forward lists are sequence containers that allow constant time insert and erase operations anywhere within the sequence.

template < class T, class Alloc = allocator > class forward_list;

T — Type of the elements.
Aliased as member type forward_list::value_type.
Alloc — Type of the allocator object used to define the storage allocation model. By default, the allocator class template is used, which defines the simplest memory allocation model and is value-independent. Aliased as member type forward_list::allocator_type.

• Forward lists are implemented as singly-linked lists; Singly linked lists can store each of the elements they contain in different and unrelated storage locations. The ordering is kept by the association to each element of a link to the next element in the sequence.
• Forward list keeps internally only a link to the next element.
• Links lack direct access to the elements by their position; For example, to access the sixth element in a forward_list one has to iterate from the beginning to that position, which takes linear time in the distance between these. They also consume some extra memory to keep the linking information associated to each element

Sequence

• Elements in sequence containers are ordered in a strict linear sequence. Individual elements are accessed by their position in this sequence.

Linked list

• Each element keeps information on how to locate the next element, allowing constant time insert and erase operations after a specific element (even of entire ranges), but no direct random access.
Construct forward_list object

// forward_list constructors #include <iostream> #include <forward_list>   int main () {   std::forward_list<int> first; // (1) default: empty std::forward_list<int> second (3,77); // (2) fill: 3 seventy-sevens std::forward_list<int> third (second.begin(), second.end()); // (3) range initialization std::forward_list<int> fourth (third); // (4) copy constructor std::forward_list<int> fifth (std::move(fourth)); // (5) move ctor. (fourth wasted) std::forward_list<int> sixth = {3, 52, 25, 90}; // (6) initializer_list constructor   std::cout << "first:" ; for (int& x: first) std::cout << " " << x; std::cout << '\n'; std::cout << "second:"; for (int& x: second) std::cout << " " << x; std::cout << '\n'; std::cout << "third:"; for (int& x: third) std::cout << " " << x; std::cout << '\n'; std::cout << "fourth:"; for (int& x: fourth) std::cout << " " << x; std::cout << '\n'; std::cout << "fifth:"; for (int& x: fifth) std::cout << " " << x; std::cout << '\n'; std::cout << "sixth:"; for (int& x: sixth) std::cout << " " << x; std::cout << '\n';   return 0; }

// forward_list constructors #include <iostream> #include <forward_list> int main () { std::forward_list<int> first; // (1) default: empty std::forward_list<int> second (3,77); // (2) fill: 3 seventy-sevens std::forward_list<int> third (second.begin(), second.end()); // (3) range initialization std::forward_list<int> fourth (third); // (4) copy constructor std::forward_list<int> fifth (std::move(fourth)); // (5) move ctor. (fourth wasted) std::forward_list<int> sixth = {3, 52, 25, 90}; // (6) initializer_list constructor std::cout << "first:" ; for (int& x: first) std::cout << " " << x; std::cout << '\n'; std::cout << "second:"; for (int& x: second) std::cout << " " << x; std::cout << '\n'; std::cout << "third:"; for (int& x: third) std::cout << " " << x; std::cout << '\n'; std::cout << "fourth:"; for (int& x: fourth) std::cout << " " << x; std::cout << '\n'; std::cout << "fifth:"; for (int& x: fifth) std::cout << " " << x; std::cout << '\n'; std::cout << "sixth:"; for (int& x: sixth) std::cout << " " << x; std::cout << '\n'; return 0; }

Expected output:

first:
second: 77 77 77
third: 77 77 77
fourth:
fifth: 77 77 77
sixth: 3 52 25 90

(1) — default — Constructs an empty container, with no elements.
(2) — fill constructor — Constructs a container with n elements. Each element is a copy of val (if provided).
(3) — range constructor — Constructs a container with as many elements as the range [first,last), with each element emplace-constructed from its corresponding element in that range, in the same order.
(4) — copy constructor (and copying with allocator) — Constructs a container with a copy of each of the elements in fwdlst, in the same order.
(5) — move constructor (and moving with allocator) — Constructs a container that acquires the elements of fwdlst. If alloc is specified and is different from fwdlst‘s allocator, the elements are moved. Otherwise, no elements are constructed (their ownership is directly transferred). fwdlst is left in an unspecified but valid state.
(6) — initializer list constructor — Constructs a container with a copy of each of the elements in il, in the same order.

Syntax:
range (1)

template 
void assign (InputIterator first, InputIterator last);

fill (2)

void assign (size_type n, const value_type& val);

initializer list (3)

void assign (initializer_list il);

Any elements held in the container before the call are destroyed and replaced by newly constructed elements (no assignments of elements take place).
Parameters:
first, last
Input iterators to the initial and final positions in a sequence. The range used is [first,last), which includes all the elements between first and last, including the element pointed by first but not the element pointed by last.
The function template argument InputIterator shall be an input iterator type that points to elements of a type from which value_type objects can be constructed.
n
New size for the container.
Member type size_type is an unsigned integral type.
val
Value to fill the container with. Each of the n elements in the container will be initialized to a copy of this value.
Member type value_type is the type of the elements in the container, defined in forward_list as an alias of its first template parameter (T).
il
An initializer_list object. The compiler will automatically construct such objects from initializer list declarators. Member type value_type is the type of the elements in the container, defined in forward_list as an alias of its first template parameter (T).
Example:

#include <iostream>
#include <forward_list>
 
int main ()
{
  std::forward_list<int> first;
  std::forward_list<int> second;
 
  first.assign (4,15);                           // 15 15 15 15
 
  second.assign (first.begin(),first.end());     // 15 15 15 15
 
  first.assign ( {77, 2, 16} );                  // 77 2 16
 
  std::cout << "first contains: ";
  for (int& x : first) std::cout << ' ' << x;
  std::cout << '\n';
 
  std::cout << "second contains: ";
  for (int& x : second) std::cout << ' ' << x;
  std::cout << '\n';
 
  return 0;
}

Output:

first contains: 77 2 16
second contains: 15 15 15 15

Syntax:
copy (1)

forward_list& operator= (const forward_list& fwdlst);

move (2)

forward_list& operator= (forward_list&& fwdlst);

initializer list(3)

forward_list& operator= (initializer_list il);

Assigns new contents to the container, replacing its current contents.

The container preserves its current allocator, except if the allocator traits indicate fwdlst’s allocator should propagate. This allocator is used (through its traits) to allocate or deallocate if there are changes in storage requirements, and to construct or destroy elements, if needed.
Parameters:
fwdlst
A forward_list object of the same type (i.e., with the same template parameters, T and Alloc).
il
An initializer_list object. The compiler will automatically construct such objects from initializer list declarators. Member type value_type is the type of the elements in the container, defined in forward_list as an alias of its first template parameter (T).
Example:

#include <iostream>
#include <forward_list>
 
template<class Container>
Container by_two (const Container& x) {
  Container temp(x); 
  for (auto& x:temp) 
      x*=2;
  return temp;
}
 
int main ()
{
  std::forward_list<int> first (4);      // 4 ints
  std::forward_list<int> second (3,5);   // 3 ints with value 5
 
  first = second;                        // copy assignment
  second = by_two(first);                // move assignment
 
  std::cout << "first: ";
  for (int& x : first) std::cout << ' ' << x;
  std::cout << '\n';
 
  std::cout << "second: ";
  for (int& x : second) std::cout << ' ' << x;
  std::cout << '\n';
 
  return 0;
}

In the first assignment, second is an lvalue: the copy assignment function is called.
In the second assignment, the value returned by by_two(first) is an rvalue: the move assignment function is called.
Output:

first: 5 5 5
second: 10 10 10

void resize (size_type n);
void resize (size_type n, const value_type& val);

Resizes the container to contain n elements.
If n is smaller than the current number of elements in the container, the content is trimmed to contain only its first n elements, removing those beyonf (and destroying them).
If n is greater than the current number of elements in the container, the content is expanded by inserting at the end as many elements as needed to reach a size of n elements. If val is specified, the new elements are initialized as copies of val, otherwise, they are value-initialized.
Example

// resizing forward_list
#include <iostream>
#include <forward_list>
 
int main ()
{
  std::forward_list<int> mylist = {10, 20, 30, 40, 50};
                                // 10 20 30 40 50
  mylist.resize(3);             // 10 20 30
  mylist.resize(5,100);         // 10 20 30 100 100
 
  std::cout << "mylist contains:";
  for (int& x: mylist) std::cout << ' ' << x;
  std::cout << '\n';
 
  return 0;
}

mylist contains: 10 20 30 100 100

Example

// forward_list::insert_after
#include <iostream>
#include <array>
#include <forward_list>
 
int main ()
{
  std::array<int,3> myarray = { 11, 22, 33 };
  std::forward_list<int> mylist;
  std::forward_list<int>::iterator it;
 
  it = mylist.insert_after ( mylist.before_begin(), 10 );          // 10
                                                                   //  ^  <- it
  it = mylist.insert_after ( it, 2, 20 );                          // 10 20 20
                                                                   //        ^
  it = mylist.insert_after ( it, myarray.begin(), myarray.end() ); // 10 20 20 11 22 33
                                                                   //                 ^
  it = mylist.begin();                                             //  ^
  it = mylist.insert_after ( it, {1,2,3} );                        // 10 1 2 3 20 20 11 22 33
                                                                   //        ^
 
  std::cout << "mylist contains:";
  for (int& x: mylist) std::cout << ' ' << x;
  std::cout << '\n';
  return 0;
}

Output:

mylist contains: 10 1 2 3 20 20 11 22 33

Doubly linked lists

• Lists are sequence containers that allow constant time insert and erase operations anywhere within the sequence, and iteration in both directions.

template < class T, class Alloc = allocator > class list;

• List containers are implemented as doubly-linked lists.
• Doubly linked lists can store each of the elements they contain in different and unrelated storage locations. The ordering is kept internally by the association to each element of a link to the element preceding it and a link to the element following it.
• Doubly linked list keeps two links per element: one pointing to the next element and one to the preceding one, allowing efficient iteration in both directions, but consuming additional storage per element and with a slight higher time overhead inserting and removing elements.
• Compared to other base standard sequence containers (array, vector and deque), forward_list perform generally better in inserting, extracting and moving elements in any position within the container, and therefore also in algorithms that make intensive use of these, like sorting algorithms.

* Information has taken from: http://www.cplusplus.com/reference/forward_list/forward_list/.

Labs and tasks