Question

Explain why a class might provide a set function and a get function for a data member (Modifying Class GradeBook) Modify class GradeBook (Figs. 3.113 .12 ) as follows: a. Include a second string data member that represents the course instructor's name. b. Provide a set function to change the instructor's name and a get function to retrieve it. c. Modify the constructor to specify two parametersone for the course name and one for the instructor's name. d. Modify member function displaymessage such that it first outputs the welcome message and course name, then outputs "This course is presented by: " followed by the instructor's name.

Short answer

Set and get functions control access to the data member, allowing updates and secure retrieval, protecting data integrity.

Step-by-step solution

Understand the Class Structure

To solve this exercise, we first need to know that a class is a blueprint for creating objects in programming. Each class typically contains variables known as data members, and functions known as methods to operate on these data members. The `GradeBook` class structure involves a course name and it's required to add an instructor's name.

Add a Data Member

Include a second string data member in the `GradeBook` class to store the course instructor's name. This can be declared similarly to the course name as a private variable, ensuring encapsulation. ```cpp private: std::string instructorName; ```

Create a Set Function

Provide a set function in the class to update the instructor's name. ```cpp void setInstructorName(std::string name) { instructorName = name; } ``` This function allows the class user to change the instructor's name.

Create a Get Function

Provide a get function to retrieve the instructor's name. ```cpp std::string getInstructorName() const { return instructorName; } ``` This function allows the retrieval of the instructor's name, but not modification.

Modify the Constructor

Update the constructor to include parameters for both the course name and the instructor's name. Ensure it initializes both data members. ```cpp GradeBook(std::string course, std::string instructor) : courseName(course), instructorName(instructor) {} ```

Update the Display Message Function

Modify the `displayMessage` function to show the course name and then output the instructor's name. ```cpp void displayMessage() const { std::cout << "Welcome to the grade book for " << courseName << "!" << std::endl; std::cout << "This course is presented by: " << instructorName << std::endl; } ```

Explanation of Set and Get Functions

The set and get functions provide controlled access to the private data member `instructorName`. The set function allows for updating, while the get function allows for safe retrieval, maintaining encapsulation and protecting data integrity.

Key concepts

Encapsulation

Encapsulation is a core concept in C++ and Object-Oriented Programming that involves bundling the data (variables or data members) and the functions (methods) that manipulate the data into a single unit called a class. This concept helps protect the internal states of the objects from unintended interference and misuse, ensuring that object interactions are well-defined and safe.

In the context of the GradeBook class mentioned, encapsulation is achieved by defining data members, like the course name and instructor's name, as private. This means they can only be accessed or modified using designated methods provided by the class. By doing this, other parts of the program can't directly alter these data members, reducing the risk of accidental corruption.

Moreover, encapsulation contributes to modularity in code. Developers can change the internal implementation of a class without affecting the users of that class, as long as the interface (public methods) remains unchanged.
By carefully controlling access through set and get functions, encapsulation keeps the data secure and maintains its integrity.

Data Members

In C++, data members are variables that belong to a class. They hold the data pertinent to each object created from the class. For our GradeBook class example, the data members include the course name and the instructor's name.

These pieces of information are specific to each instance of GradeBook and define its state. Data members are typically declared as private to follow encapsulation principles. This restriction ensures they cannot be directly accessed or modified from outside the class. By hiding the data members, the class owner can control how they're accessed and manipulated through public member functions like set and get functions. This safeguarding mechanism helps maintain consistency and correctness in the object's behavior. To declare a data member, you define it within the class scope and specify the data type. For example, a string data member for the instructor's name might be declared as: ```cpp private: std::string instructorName; ``` Through thoughtful use of data members, each object tracks its state, and operations can be performed in a controlled manner.

Get and Set Functions

Get and set functions are special types of member functions in a class. They offer a controlled way to access and modify private data members, which are not accessible directly due to encapsulation. These functions help maintain the integrity and encapsulation of the data.

The set function allows for modification of the data member. In the GradeBook class, you might use a set function to change the instructor's name when needed. Here's how it looks: ```cpp void setInstructorName(std::string name) { instructorName = name; } ``` This function allows users of the class to provide new values for instructorName while ensuring any necessary checks or transformations can take place inside the method. The get function, on the other hand, provides read-only access to the value of the data member. It is safe and used purely for retrieving the current value without any risk of modifying it. ```cpp std::string getInstructorName() const { return instructorName; } ``` Through this approach, a program can interact with a class's private data in a safe, predictable manner. It ensures the inward-facing aspects of the class are not exposed, thereby adhering to object-oriented design principles.

Class Constructor

The class constructor is a special member function in C++ that is automatically invoked when an object of the class is created. Its primary role is to initialize the object. For the GradeBook class, the constructor initializes both the course name and instructor's name.

Constructors can take parameters that allow for dynamic initialization of the data members. This means you can create objects with different states right from the start. Here’s an example of a constructor for the GradeBook class: ```cpp GradeBook(std::string course, std::string instructor) : courseName(course), instructorName(instructor) {} ``` This constructor takes two string arguments and uses them to initialize the courseName and instructorName. Using constructors properly is crucial for ensuring your objects are always in a valid, predictable state after they are created. Constructors can also help in enforcing certain rules or constraints about how objects should be initialized. By providing constructors that meaningfully initialize all relevant data members, C++ classes set the stage for robust and reliable use in code applications.