Question

Write a C++ class, Flower, that has three member variables of type string, int, and float, which respectively represent the name of the flower, its number of pedals, and price. Your class must include a constructor method that initializes each variable to an appropriate value, and your class should include functions for setting the value of each type, and getting the value of each type.

Short answer

Define the Flower class with a constructor and getter/setter methods for name, numPedals, and price.

Step-by-step solution

- Define the class structure

Begin by defining the `Flower` class. Inside the class, declare three private member variables: `name` of type `std::string`, `numPedals` of type `int`, and `price` of type `float`.

- Create the constructor

Write a constructor for the `Flower` class that initializes each member variable. The constructor should take three parameters and set them to the respective member variables.

- Implement setter functions

Write three public member functions to set the values of the member variables: `setName`, `setNumPedals`, and `setPrice`. Each function should take a parameter and assign it to the corresponding member variable.

- Implement getter functions

Write three public member functions to get the values of the member variables: `getName`, `getNumPedals`, and `getPrice`. Each function should return the value of the corresponding member variable.

- Putting it together

Combine all the steps to complete the `Flower` class. Below is the full implementation of the class.```cpp#include class Flower {private: std::string name; int numPedals; float price;public: // Constructor Flower(std::string n, int p, float pr) : name(n), numPedals(p), price(pr) {} // Setter functions void setName(std::string n) { name = n; } void setNumPedals(int p) { numPedals = p; } void setPrice(float pr) { price = pr; } // Getter functions std::string getName() const { return name; } int getNumPedals() const { return numPedals; } float getPrice() const { return price; }};```

Key concepts

class structure

A C++ class is a blueprint for creating objects. It allows you to define variables and functions that represent properties and behaviors of the object.
In our `Flower` class, the structure comprises three main parts:

• Private member variables
• Public constructor method
• Public member functions (setters and getters)

Private member variables are accessible only within the class. This encapsulation helps in keeping data safe from unintended modifications. The public methods serve as the interface for interacting with these member variables.

member variables

Member variables, also known as attributes or properties, are variables that belong to a class. For the `Flower` class, we have three member variables:

• `std::string name`: Represents the name of the flower
• `int numPedals`: Represents the number of petals
• `float price`: Represents the price of the flower

These variables are declared as private, meaning they can only be accessed and modified through public methods. This provides a better control of how the data is accessed and modified.

constructor method

A constructor is a special member function that is automatically called when an object of the class is created. In the `Flower` class, the constructor initializes the member variables with given values.
The `Flower` constructor is defined as:
Flower(std::string n, int p, float pr) : name(n), numPedals(p), price(pr) {}
This constructor takes three parameters and uses an initialization list to set the values of `name`, `numPedals`, and `price`. Using an initialization list is often more efficient than assigning values inside the constructor body.

setter functions

Setter functions allow you to set or modify the values of member variables from outside the class. In our `Flower` class, we have three setter functions:

• `void setName(std::string n) { name = n; }`: Sets the value of `name`
• `void setNumPedals(int p) { numPedals = p; }`: Sets the value of `numPedals`
• `void setPrice(float pr) { price = pr; }`: Sets the value of `price`

By using setter functions, we ensure that any value assignment to member variables can be validated or modified internally before being applied.

getter functions

Getter functions are used to retrieve the values of member variables from outside the class. The `Flower` class includes the following getter functions:

• `std::string getName() const { return name; }`: Returns the value of `name`
• `int getNumPedals() const { return numPedals; }`: Returns the value of `numPedals`
• `float getPrice() const { return price; }`: Returns the value of `price`

These functions are marked as `const`, meaning they do not modify the state of the class. Using getter functions provides controlled access to the attributes, ensuring that the encapsulated data remains safe and unchanged.