Question

Change the class TemperatureList given in Display 11.10 by adding a member function called get_size, which takes no arguments and returns the number of temperatures on the list.

Short answer

Answer: The purpose of the get_size member function is to return the total number of temperatures stored in the TemperatureList class. It allows users to easily obtain the current number of temperatures in the list without directly accessing the underlying private data.

Step-by-step solution

Understand the existing class

First, let's analyze the given TemperatureList class. It already has methods to add temperatures, check if the list is full or empty and to display the temperatures. Our task is to add the get_size() function, which will return the current number of temperatures in the list.

Write the get_size function

To create the get_size function, no input parameters are needed as mentioned in the exercise. The function should return the total number of stored temperatures in the TemperatureList class. We can obtain this information from the current size of the list. Here's the implementation of the get_size function, which should be added inside the class: ```cpp int get_size() const { return num_temperatures; } ``` This function returns the value of the private variable, num_temperatures, which represents the current number of temperatures stored in the list.

Update the TemperatureList class

Now that we have implemented the get_size function, we need to add it to the TemperatureList class. Here's the updated class with the get_size function included: ```cpp class TemperatureList { public: TemperatureList(unsigned int size); ~TemperatureList(); bool add_temperature(double temperature); bool full() const; bool empty() const; void display(ostream& outs) const; int get_size() const; private: double *list; unsigned int max_size; unsigned int num_temperatures; }; ``` Take note of the added `int get_size() const;` line in our class definition, declaring the new member function.

Test the updated class

Once the class has been updated, it's important to test the newly-added get_size function. You can write a simple program that creates an instance of the TemperatureList class, adds a few temperatures, and then calls the get_size function to verify if it returns the correct number of stored temperatures. Here's an example test of the updated class: ```cpp #include #include "TemperatureList.h" int main() { TemperatureList tempList(3); // Adding some temperatures tempList.add_temperature(23.5); tempList.add_temperature(24.0); // Testing the get_size function std::cout << "Number of temperatures: " << tempList.get_size() << std::endl; // Expected output: 2 return 0; } ``` This demonstration should print out the correct number of stored temperatures, confirming that our get_size function has been properly implemented.

Key concepts

C++ Class Implementation

Beginning with the core concept of C++ class implementation, it's essential to grasp what a class is within the context of object-oriented programming. A class acts as a blueprint for objects, providing a template that encapsulates data and functions relevant to that data. In the case of our exercise, the class in question is a TemperatureList.

Implementing a class in C++ involves defining the attributes and behaviors that the objects created from the class should have. Attributes are represented as member variables, and behaviors are represented as member functions, or methods. The class definition starts with the keyword class followed by the class name, and then a pair of curly braces that enclose the member declarations. Within this structure, member variables and functions can be labeled as public, private, or protected, depending on how accessible they should be outside of the class itself.

The TemperatureList class includes member functions such as add_temperature, full, and empty, which allow one to manipulate and inquire about the state of a temperature list object. These functions are crucial components of the class implementation and are what make the object useful and interactive.

Member Function Addition

Adding a member function to an existing class requires understanding that class's responsibilities and how the new function will fit into its interface. In our exercise, we were tasked with adding a new member function, get_size, to the TemperatureList class.

When implementing the get_size function, we adhered to the following steps: First, we decided on the function's purpose and name, ensuring it accurately reflects its behavior. Next, since the function returns the number of temperatures, it was necessary to access the member variable representing this count, num_temperatures. As such, get_size was declared as a const member function, meaning it doesn't modify the object on which it's called.

The final step was to integrate the new function into the class by adding its declaration in the class definition and its implementation in the appropriate .cpp file. The simplicity of the function—returning the value of a private variable—underscores the significance of member functions: they serve as the interface through which an object's internal data can be safely accessed and manipulated.

Class Method Testing

Testing class methods is a critical step in validating that your implementation behaves as expected. It's effectively a way to guarantee that your class performs correctly under various circumstances. For the TemperatureList class, testing the get_size method involves crafting scenarios that challenge the method's accuracy and reliability.

The testing process starts with creating an instance of the class. You then perform actions on the instance—like adding temperatures—to simulate real-use situations. After each interaction with the object, the get_size method is called to check if it returns the correct size. A comprehensive test would also check boundary cases, such as when the list is empty or full, to ensure the method withstands all possible states of the object.

Testing can be done manually with simple print statements, as shown in the example within the solution, or with the help of automated testing frameworks. Regardless of the method, consistent testing builds confidence in the code's functionality and robustness, which is especially crucial when changes are made to the class's implementation.

Object-oriented Programming

Object-oriented programming (OOP) is a paradigm centered around objects rather than actions, and data rather than logic. The cornerstone of OOP is the class, which we encountered in the TemperatureList exercise. OOP allows for the creation of modular, reusable code and can lead to more manageable and extensible software.

In OOP, classes encapsulate data for the object and operations that can be performed on it. Encapsulation is a fundamental concept in OOP, allowing for hiding the internal state and requiring all interaction to be performed through an object's methods. This principle reduces dependencies and increases code maintainability.

There are other key principles in OOP including inheritance, where classes can inherit properties and behaviors from other classes; polymorphism, where classes can provide different implementations of methods based on an interface or base class; and abstraction, which involves exposing only the necessary details while hiding the complexity. Understanding these principles is crucial for utilizing the full power of OOP and creating well-designed software systems.