Getters And Setters

Getters

Getters give public access to private data. They may also make a small modification of the returned result.

Let's look the following example:

#include <string> #include <iostream> using namespace std; class Square { private: // default value for side double side = 1; public: // getter function: double getSide() { return side; } }; void main() { Square sampeSquareObj; // cout << sampeSquareObj.side; cout << sampeSquareObj.getSide(); }

Output:

1

There are 2 things to notice in the code:

• If we uncomment line 23 the code will not compile. That's because a private member (declared at lines 10) cannot be directly accessed outside the class body.
• At line 24 a private member is accessed outside the class body. That's not done directly (like in line 23) but through a public function - a getter. This is how a private member can be accessed outside the class body.

Let's add more stuff:

#include <string> #include <iostream> using namespace std; class Square { private: // default value for side double side = 2.5; public: double getSide() { return side; } double getPerimeter() { return side * 4; } double getArea() { return side * side; } }; void main() { Square square; cout << "Side = " << square.getSide() << endl; cout << "Perimeter = " << square.getPerimeter() << endl; cout << "Area = " << square.getArea() << endl; }

Output:

Side = 2.5 Perimeter = 10 Area = 6.25

The only things that were added are 2 getters - getPerimeter and getArea. Simply they are getters that return a private member with a small modification.

Setters

Setters allow for a private variable to be modified. They are important since they can provide validation before a value is set.

Let's look at the following example:

#include <string> #include <iostream> using namespace std; class Person { private: string name; int age; public: string getName() { return name; } int getAge() { return age; } // basic setter function: void setName(string nameNewValue) { name = nameNewValue; } // setter function with validation: void setAge(int ageNewValue) { if (ageNewValue < 0) { throw "Age cannot be negative."; } // set the new value age = ageNewValue; } void printData() { cout << "Name: " << name << endl; cout << "Age: " << age << endl; } }; void main() { Person person; person.setName("Emily"); person.setAge(20); // person.setAge(-1); person.printData(); }

Output:

Name: Emily Age: 20

Explanation:

• Value of the private member name member is modified at line 25 without any validation.
• At lines 30 - 38 is defined a setter that has validation. If the validation fails an error is thrown at line 33. If validation passes (age >= 0) then the new value is set (line 37).
• If we uncomment line 52 an error will be thrown when the code executes. That's due to the validation at line 32.

Why using getters and setters?

Because private members can have validation before modification (setter) and controlled access (getter).

It seems easier to have only public members. This way there is no need for getters and setters. It's a better practice to have private members that are accessed with getter and modified through setter. This way a validation can be provided in a setter and the public access can be done only to some members - those which have getters.