Question

Write the definition of a class that has the following properties: a. The name of the class is secretType. b. The class secretType has four member variables: name of type string, age and weight of type int, and height of type double. c. The class secretType has the following member functions. (Make each accessor function constant.) print—outputs the data stored in the member variables with the appropriate titles setName—function to set the name setAge—function to set the age setWeight—function to set the weight setHeight—function to set the height getName—value-returning function to return the name getAge—value-returning function to return the age getWeight—value-returning function to return the weight getHeight—value-returning function to return the height constructor—with default parameters: The default value of name is the empty string " ", and the default values of age, weight, and height are 0. d. Write the definition of the member functions of the class secretType, as described in Part c.

Short answer

Define the class "secretType" with member variables and functions, implementing each function as described.

Step-by-step solution

Define Class Structure

Start by defining the class `secretType` and include its member variables. The class has four private member variables: `name` (of type `std::string`), `age` (of type `int`), `weight` (of type `int`), and `height` (of type `double`).

Declare Member Functions

Declare the member functions in the public section of the class. These include the constructor, setters (`setName`, `setAge`, `setWeight`, `setHeight`), getters (`getName`, `getAge`, `getWeight`, `getHeight`), and the function `print` to output member variables.

Define Constructor

Define the constructor to initialize member variables with their default values: an empty string for `name`, and `0` for `age`, `weight`, and `height`. This is done by specifying default parameter values.

Implement Setter Functions

Implement the setter functions to assign values to the member variables. For example, `setName` should assign a given string to `name`, and similarly for other attributes.

Implement Getter Functions

Implement the constant getter functions to return the current value of each member variable. These functions do not modify the class and should include the `const` keyword after the function definition.

Implement Print Function

Define the `print` function to output the values of member variables along with appropriate titles. Use `std::cout` to display each variable on the console with labels like 'Name: ', 'Age: ', 'Weight: ', and 'Height: '.

Key concepts

Object-Oriented Programming

Object-Oriented Programming (OOP) is a programming paradigm centered around objects rather than actions. Objects are instances of classes, which act as blueprints. Each object can contain data, in the form of fields or member variables, and code, in the form of member functions, methods, or routines.

In OOP, classes are fundamental structures that encapsulate data and the functions that operate on that data. This approach promotes organization through:

• Encapsulation: grouping related data and functions together.
• Inheritance: deriving new classes from existing ones.
• Polymorphism: allowing methods to act differently based on the class instance that is calling them.

In our class `secretType`, we define a structured datatype that holds multiple values. By using this class, we can organize information, such as a person's `name`, `age`, `weight`, and `height`, into a single unit that can be manipulated as a whole.

Member Functions

Member functions are the actions that can be performed on or by objects of a class. They are defined within the class and operate on the data contained in objects of that class.

In our `secretType` class, member functions include:

• `setName`, `setAge`, `setWeight`, `setHeight`: setter functions to assign values to private member variables.
• `getName`, `getAge`, `getWeight`, `getHeight`: getter functions to retrieve current values of the member variables.
• `print`: a function to display the stored data with appropriate labels.

These functions help maintain control over how data is accessed and modified. The member functions, such as setters, allow information to be changed while ensuring constraints or validations can be applied. At the same time, getter functions provide controlled access to internal data.

Constructors in C++

Constructors are special member functions used to initialize objects of a class. They have the same name as the class itself and do not have a return type.

In C++, constructors are invoked automatically when an object of the class is created. This allows the object to be set up with initial values. Constructors can take parameters, allowing various ways to initialize objects.

In the `secretType` class, the constructor is defined with default parameters: an empty string (`""`) for `name` and `0` for `age`, `weight`, and `height`. This means when a `secretType` object is created, it starts with default values, unless specified otherwise. Here is an example of how you might declare and define a constructor in the class: ```cpp secretType(std::string name = "", int age = 0, int weight = 0, double height = 0) : name(name), age(age), weight(weight), height(height) {} ``` This constructor assigns provided values, or default values when no specific values are given.

Accessor Methods

Accessor methods, also called getter methods, provide a way to retrieve the value of private member variables. In C++, these methods are typically defined with the keyword `const` at the end, indicating that they do not alter the object's state.

In the `secretType` class, accessor methods include `getName`, `getAge`, `getWeight`, and `getHeight`. Each of these returns the current value of a respective data member.

Accessor methods are crucial because they allow safe access to an object’s data components while enforcing encapsulation, meaning data can be read but not modified unexpectedly. Here's a typical format of an accessor method in C++: ```cpp std::string getName() const { return name; } ``` In this example, the getter for `name` returns the `name` value while ensuring it cannot change the object's state.