Vector Operations in C++ -- Part 3

In the last post, we implemented the searching procedure followed in the Employee Register. Now we will discuss the CRUD operations on the vector with Employee class.

To go to the previous two posts,
Vector Operations in C++ -- Part 1 and
Vector Operations in C++ -- Part 2

For adding an employee, we need to first check if another employee of the same employee ID exists in the vector. If it exists, we should give the relevant message to the user. Since we know that adding or deleting the employees at the ends is done very quickly, we have used the function "push_back" to add the new employee to the end.

void EmployeeRegister::addEmployee(Employee emp) { // Add the record to emp_records vector and the ID to emp_id_records emp_records.push_back(emp); emp_id_records.push_back(emp.getId()); cout<<"\n\n\n---------------------------------------------------------"; cout<<"\n Employee successfully added with the following details"; cout<<"\n---------------------------------------------------------"; cout<<"\n Employee ID: \t\t"<<emp.getId(); cout<<"\n Employee Name: \t"<<emp.getName(); cout<<"\n---------------------------------------------------------"; cout<<"\n\n"; }

For displaying the employee details, we must first check if the vector is empty. If it is empty, we need not traverse through the vector.

void EmployeeRegister::displayEmployees() { // First check if the employee vector is empty if(isEmpty()) { cout<<"\n No Employee records to display"; return; } // If the vector has some elements, print them in a tabular format cout<<"\n\n\n\n--------------------------------------------------------------"; cout<<"\n Employee ID \t | \t Employee Name"; cout<<"\n--------------------------------------------------------------"; for(int i=0;i<emp_records.size();i++) { cout<<"\n "<<emp_records[i].getId()<<" \t\t | \t "<<emp_records[i].getName(); } cout<<"\n--------------------------------------------------------------\n\n\n"; }

For deleting and updating an employee details, we need to check if the employee with the given ID exists. If it does not exist, the relevant message must be displayed.

int EmployeeRegister::updateEmployee(int id,Employee emp) { // Before updating, first check whether the employee with the given ID exists or not. // If employee with the given ID does not exist, return -1 if(searchEmployee(id)==-1) return -1; else { // Update the employee details in the index to the newly entered details emp_records[searchEmployee(id)]=emp; cout<<"\n\n\n---------------------------------------------------------"; cout<<"\n Employee successfully updated to the following"; cout<<"\n---------------------------------------------------------"; cout<<"\n Employee ID: \t\t"<<emp.getId(); cout<<"\n Employee Name: \t"<<emp.getName(); cout<<"\n---------------------------------------------------------"; cout<<"\n\n"; return 1; } } int EmployeeRegister::deleteEmployee(int id) { // Before deleting, first check whether the employee with the given ID exists or not. // If employee with the given ID does not exist, return -1 if(searchEmployee(id)==-1) return -1; else { // Delete the record from emp_records vector and the ID from emp_id_records emp_records.erase(emp_records.begin()+searchEmployee(id)); emp_id_records.erase(emp_id_records.begin()+searchEmployee(id)); cout<<"\n Employee with employee ID "<<id<<" is successfully deleted\n\n"; return 1; } }

Till now we have done all the operations required for manipulating or displaying the employee data. But a good user interface which is easily understandable by the user is equally important. Thus, we will have a menu with all the above discussed operations. To take numerical and string input from the user, we use two member functions in the class "EmployeeDisplay". Validation to the complete extent is not done for numerical and string inputs.

Compiling and running the case study:

Compiling:

g++ -o EmployeeRegister main.cpp Display.cpp Employee.cpp EmployeeRegister.cpp

Running the executable:

./EmployeeRegister

Sample Output for an add operation in the following menu is given below.

****************************************************************** ****************WELCOME TO THE EMPLOYEE REGISTER****************** ****************************************************************** 1. Add an employee 2. Delete an employee 3. Display Employees list 4. Update an employee 5. Exit Enter the choice: 1 Enter the Employee ID of the employee to be added: 1 Enter the Employee name of the employee to be added: Sai Ravi Kiran --------------------------------------------------------- Employee successfully added with the following details --------------------------------------------------------- Employee ID: 1 Employee Name: Sai Ravi Kiran ---------------------------------------------------------

I have uploaded the entire project at the following link: Vector Operations Case Study. You can download the "Employee Register.zip" from this link.

Vector Operations in C++ -- Part 2

Have some information about vectors and want to implement the vector operations?? You have come to the correct place.

In the last post, we have discussed about the operations in vectors and the functions that can be used in vectors. If you do not know about vectors in C++, then refer this page. In this post, we will see the practical implementation of vectors by using a case study.

We are building an employee register in which an employee has two attributes -- a unique Employee ID and the Employee Name. If you want more attributes such as Date of Birth, Work experience, Designations etc., you can add them. But I thought of keeping it simple. So, I have included only two attributes for an employee. I am not linking this case study to any database programming. But I am sure this case study would be very useful in many of the applications based on CRUD and can be used in applications which include database programming. The following actions are done in this case study:

1. Add a new employee
2. Display the existing employees
3. Delete an employee details
4. Update an employee details

We will have a total of three classes:

1. Employee class  -- To define the basic attributes of Employee
2. EmployeeRegister class  -- To do the vector operations on Employee class
3. EmployeeDisplay class --  Created for User Interface programming

To ensure data abstraction, the header files are separated from the actual implementation. In the header files, the declarations of the variables, classes and methods will be present, while the implementation is covered in the corresponding CPP source files.

First let us see what Employee class has. The following piece of code is Employee.h which declares the variables and the member functions of Employee class.

#ifndef _EMPLOYEE_H #define _EMPLOYEE_H #include <iostream> using namespace std; class Employee { private: int id; char* name; public: Employee(); Employee(int,char*); void setId(int); int getId(); void setName(char*); char* getName(); }; #endif

The implementation of the Employee class are given below. The getters and setters are defined so as to access the member variables in the Employee class.

#include "Employee.h" using namespace std; Employee::Employee(){} Employee::Employee(int id,char* name) { this->id=id; this->name=name; } void Employee::setId(int id) { this->id=id; } void Employee::setName(char* name) { this->name=name; } int Employee::getId() { return id; } char* Employee::getName() { return name; }

The implementation of EmployeeRegister class has the following operations:

1. Adding, Deleting and Updating an employee.
2. Displaying the current employee details.
3. Searching for an element in the vector.
4. Checking whether the vector for Employee class is empty.

We can check if the vector is empty by using the boolean function "empty()" used in vector STL.

bool EmployeeRegister::isEmpty() { if(emp_records.empty()) return true; else return false; }

Searching is an important operation and will be used by almost all other functions. Imagine you have large number of employee records and you need to search for a record which is the last in the vector. By using linear search, the search process will consume more time. For binary search to be implemented, we need to have the elements in the vector in an increasing order which is not the case here. They can be any possible order. Thus, due to all these factors, the STL algorithm "find" is used to find the position of an element in the vector. For this function to be used, we need to create another vector of integers "emp_id_records". This vector should have all the employee ID's exactly in the same order as that of the emp_records. So, if we can get the position of an element in one vector, we can the index of the other too. 

int EmployeeRegister::searchEmployee(int id) { vector<int>::iterator id_it; id_it=find(emp_id_records.begin(),emp_id_records.end(),id); // If employee details are not found return FAILURE -1 if(id_it==emp_id_records.end()) return -1; // Otherwise return the position of the record else return (int)(id_it-emp_id_records.begin()); }

Vector Operations in C++ -- Part 1

At the end of this series of posts, you will understand the working of vectors, the functions used in vectors. In addition to this, you will be able to do the basic CRUD operations on the vectors.

Vector is a type of sequence container in C++ and is implemented like a dynamic array. Vectors are very similar to arrays except that the arrays have a constant size while vectors can be extended or contracted as needed. However, the size of vector can also be fixed and resized. Once the storage of a vector is exhausted, it grows automatically in size. The storage space they have been allocated can be either equal or greater than the actual size. The extra amount of storage allocated is not used, but is reserved for the vector to be used in case it grows. Thus, the vector does not have to re-allocate storage on each occasion it grows or a new element is inserted.

Similar to arrays, we can access a given element in a vector easily with the index. The elements of vectors are stored in contiguous memory locations just like in the case of arrays. We can iterate over a vector by using its index or by using iterators used in vectors.

Adding or removing the elements from the vector at the ends is done very well as far as the time complexity is concerned. However, the performance of insertion/deletion at positions other than the ends is worse than that of the other sequence containers in C++ (deques and lists).

Constructors for the vector class are as follows:

Constructor Name	Syntax	Example	Description
Default Constructor	vector<T> vector_name;	vector<int> a;	Creates a vector with no elements
Repetitive sequence Constructor	vector<T> vector_name(No. of Elements to be repeated, Value to be assigned);	vector<int> b(4,100);	Creates a vector of 4 elements with value 100.
Iterator constructor	vector<T> vector_name (Beginning of another vector, End of another vector);	vector<int> c (a.begin(),a.end());	Creates a vector with elements from vector “a”. Can also create a vector by copying only a part of the vector “a”.
Copy constructor	vector<T> vector_name(another_vector);	vector<int> d(c);	Creates a vector by copying the vector “c” into vector “d”.

Accessing an element in a vector:
An element in a Vector can be accessed in two ways:
1. vector_name[index]     (or)
2. vector_name.at(index)

Iterating over a vector using an iterator:

We can iterate over a vector using a normal for loop with the initialization variable from 0 to the vector's maximum size (vector.size( )). But here is another method to explore all the elements in a vector:

vector<int> vector_name;

vector::iterator it;

for(it=vector_name.begin();it < vector_name.end(); it++)

      cout<<*it;

This piece of code will print all the elements one by one in the vector. Similar to iterator, there is also reverse iterator, which iterates over the vector from right to left.

Functions in Vector:

Function	Syntax	Description
push_back	vector.push_back(element)	Inserts the element at the end of the vector
pop_back	vector.pop_back()	Deletes the last element in the vector and returns the same
erase	vector.erase(position)	Deletes the element from the vector in the specified position/index
insert	vector.insert(element,position)	Inserts an element (1st argument) into the position (2nd argument)

In the next post, we will apply this concept of vectors in our case study, which involves the basic CRUD operations.