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()); }