Question

(Employee Class) Create a class called Employee that includes three pieces of information as data membersa first name (type string), a last name (type string and a monthly salary (type int). [Note: In subsequent chapters, we'll use numbers that contain decimal points (e.g., 2.75 )called floating-point valuesto represent dollar amounts.] Your class should have a constructor that initializes the three data members. Provide a set and a get function for each data member. If the monthly salary is not positive, set it to \(\theta\). Write a test program that demonstrates class Employee's capabilities. Create two Employee objects and display each object's yearly salary. Then give each Employee a 10 percent raise and display each Employee's yearly salary again.

Short answer

Define an Employee class with data members, create getter and setter methods, and test the functionality by applying raises and calculating yearly salaries.

Step-by-step solution

Define the Employee Class

Begin by defining a class named `Employee`. This class will encapsulate the data members and the methods for interacting with employee data.

Add Data Members

Inside the `Employee` class, declare the following data members: `first_name` (string), `last_name` (string), and `monthly_salary` (int). These fields will store the employee's personal information and salary.

Create the Constructor

Define a constructor for the `Employee` class that takes three parameters to initialize the data members: `first_name`, `last_name`, and `monthly_salary`. If `monthly_salary` is negative, set it to zero.

Implement Getter and Setter Methods

Provide getter and setter methods for each data member: - `get_first_name` and `set_first_name` - `get_last_name` and `set_last_name` - `get_monthly_salary` and `set_monthly_salary` (ensure monthly_salary cannot be set to a negative value).

Write a Test Program

Write a test program that: - Instantiates two `Employee` objects with sample data. - Displays each object's yearly salary by multiplying `monthly_salary` by 12.

Apply a 10% Raise to Each Employee

Calculate a 10% raise for each employee by increasing their `monthly_salary` by multiplying it by 1.10. Update the salary using the setter method.

Display Updated Yearly Salaries

Finally, display each employee's updated yearly salary after the raise. Again, compute it by multiplying the `monthly_salary` by 12.

Key concepts

Class Definition

In C++ programming, a class is a blueprint for creating objects. It groups together data and functions that work on the data, allowing for structured and organized code. For our exercise, we are creating an `Employee` class.

The class definition includes the data members (or attributes) and member functions (or methods). In our `Employee` class, we define the data members `first_name`, `last_name`, and `monthly_salary`. These attributes store essential information about an employee.

To define a class, we use the `class` keyword followed by the class name. Inside, we declare variables to hold the data and outline the functions we'll need to interact with this data. A key part of class definition is deciding which data and functions should be accessible from the outside (public) and which should be hidden (private) to ensure controlled data manipulation.

Constructors in C++

Constructors in C++ are special class functions responsible for initializing objects. When a new object of a class is created, the constructor is called, setting initial values for the object's attributes. This makes constructors crucial for setting up necessary conditions for the object right from the start.

In our `Employee` example, the constructor takes three parameters: `first_name`, `last_name`, and `monthly_salary`. The constructor initializes the corresponding data members with these input values.

One important condition is checked during this initialization: if the `monthly_salary` is negative, it is set to zero. This safety measure ensures that no employee object ends up with an invalid, negative salary, maintaining the integrity of our data.

Getter and Setter Methods

Getter and setter methods are essential parts of a class, especially when we want to adhere to the principles of data encapsulation. A "getter" method retrieves the value of an attribute, while a "setter" method updates the value of an attribute.

For the `Employee` class, we have several getter methods:

• `get_first_name()`
• `get_last_name()`
• `get_monthly_salary()`

These allow us to access the employee's first name, last name, and monthly salary.

Similarly, setter methods are:

• `set_first_name(string name)`
• `set_last_name(string name)`
• `set_monthly_salary(int salary)` - with a check to ensure salary cannot be set to a negative value.

These setter methods cater to updating an employee's information, while maintaining control over the data being assigned.

Data Encapsulation

Data encapsulation is a core principle of object-oriented programming, which helps in organizing and protecting data within our classes. It refers to the bundling of data, along with methods that operate on that data, into a single unit known as a class.

In the `Employee` class, data encapsulation is achieved by defining our data members as private. This prevents direct access from outside the class. Instead, we use public getter and setter methods to view or modify these private attributes.

This controlled access helps prevent unauthorized modifications and keeps the object's data in a valid state. For instance, the `set_monthly_salary` method ensures that a negative value cannot be assigned to `monthly_salary`, demonstrating data encapsulation by protecting data integrity while still providing necessary interaction pathways.