Notes

Getters and Setters in C++

In object-oriented programming, getters and setters are essential methods used to control access to the private attributes of a class. These methods are used to implement the concept of abstraction, which is one of the core principles of object-oriented programming (OOP). Abstraction hides the internal workings of a class and only exposes what is necessary to the outside world, keeping the internal state of an object secure and protected from direct modification.

Purpose of Getters and Setters

Getters:

A getter (also known as an accessor method) is a function that allows you to retrieve (or “get”) the value of a private attribute in a class. It provides read-only access to private data.
Setters:

A setter (also known as a mutator method) is a function that allows you to modify (or “set”) the value of a private attribute in a class. It provides write access to private data. Setters can also include validation or constraints before modifying the value.

Why Use Getters and Setters?

Encapsulation: Getters and setters allow a class to control how its data is accessed and modified. This is a key part of the encapsulation principle in OOP, which ensures that an object’s data is protected from unintended interference and misuse by external code.
Data Integrity: By using setters, you can include logic to validate or modify the values being set, ensuring that the object always maintains a valid state. For example, a setter might prevent negative temperatures on a stove or restrict an age to be within a certain range.
Security: Making attributes private and only accessible through getters and setters allows the class to hide its internal state and prevent external access that might corrupt it.

Example: Stove Class with Getters and Setters

Here is a detailed breakdown of how getters and setters are used with a Stove class:

class Stove {
private:
    int temperature;  // Private attribute (hidden from outside access)
 
public:
    // Getter for temperature: allows reading the temperature
    int getTemperature() {
        return temperature;
    }
 
    // Setter for temperature: allows setting the temperature with validation
    void setTemperature(int temp) {
        if (temp < 0) {
            temperature = 0;  // Minimum temperature (0 degrees)
        }
        else if (temp > 10) {
            temperature = 10; // Maximum temperature (10 degrees)
        }
        else {
            temperature = temp;  // Valid temperature range [0, 10]
        }
    }
 
    // Constructor to initialize temperature via setter
    Stove(int temp) {
        setTemperature(temp);  // Invoke the setter to set the temperature with validation
    }
};

Explanation:

Private Attribute (temperature):

The temperature attribute is declared as private, which means it is not directly accessible from outside the Stove class. This ensures that no one can arbitrarily change its value.
Getter Method (getTemperature):

The getTemperature method allows outside code to read the current temperature. It returns the value of temperature. By calling stove.getTemperature(), you can access the temperature, but not modify it directly.
Setter Method (setTemperature):

The setTemperature method allows outside code to change the value of temperature, but it also enforces constraints:
- If a temperature less than 0 is passed in, it sets the temperature to 0 (the stove can’t have negative temperatures).
- If a temperature greater than 10 is passed in, it sets the temperature to 10 (the stove has a max setting of 10).
- Otherwise, it assigns the given value to the temperature.
Constructor:

The constructor accepts an initial temperature value and uses the setTemperature method to initialize the temperature attribute. This ensures that even when an object is created, the temperature is validated right from the start.

Usage Example:

Stove stove1(25);  // The temperature will be set to 10 since it's out of range (greater than 10)
std::cout << "Stove1 temperature: " << stove1.getTemperature() << std::endl;  // Output: 10
 
Stove stove2(-5);  // The temperature will be set to 0 since it's less than 0
std::cout << "Stove2 temperature: " << stove2.getTemperature() << std::endl;  // Output: 0
 
stove1.setTemperature(8);  // Setting a valid temperature
std::cout << "Stove1 new temperature: " << stove1.getTemperature() << std::endl;  // Output: 8

Key Points:

Abstraction: Using private attributes and exposing them through getters and setters ensures that we only expose what is necessary and keep the internal state safe.
Validation: Setters can be used to enforce rules (e.g., only allow temperatures in the range of 0 to 10).
Control: Getters and setters give control over how and when attributes are accessed or modified, providing flexibility to add checks or transformations before accessing or modifying data.

Best Practices:

Use Setters for Validation: Always use setters when you need to add validation or constraints to ensure the object’s data remains in a valid state.
Consistency: Keep attribute names and method names consistent. For example, if your attribute is named temperature, your getter should be getTemperature() and your setter should be setTemperature().
Encapsulation: Prefer using private attributes and expose them only through public getters and setters to follow the principle of encapsulation.

Conclusion:

In C++, getters and setters are essential for protecting the internal state of an object, maintaining data integrity, and ensuring that only valid data is set. By using these methods, you provide controlled access to private data, which is a core concept in abstraction and encapsulation in object-oriented design.

References

Video

Quartz 4

Explorer

C++ GETTERS & SETTERS explained easy 🔒