Is there any real argument for getters/setters instead of public member variables in a simple Point class?

Question

I have two simple classes for working with 3d geometry Point and Vector. They both have 3 coordinates as public member variables and define some operators like +, -, * ....

class Point
{
public:
    double x, y, z;
    // ctor and some operators   
}


class Vector
{
public:
    double x, y, z;
    // ctor and some operators   
}

Is there any real argument against making the coordiantes public? I will never change double to any other type. I do not want to restrict the values of x, y, z to a special range and I do not want to check anything when setting the coordinates.

The classes are in a library which will be used by other projects.

Update:
For me a big disadanvtage of setters/getters would be to have to write/read code like this:

myVec.setX(myVec.x() + 1.0);

instead of

myVec.x += 1.0;

Upadate 2:
Qt uses getters/setters in QPoint but with no benefit

Answer 1

In C++, I will add setters and getters if only to conform to the Uniform Access Principle; why should the caller have to keep track of what is stored and what is computed?

When it comes to basic data types, where the only invariant is scope, I will happily admit that the extra effort might not be worth it. But something like a Range type (with .high, .low, .distance) where there is an invariant to be maintained (hight >= low, distance = high - low) then it's a necessity. Otherwise, all the clients of the type end up having to maintain the invariant when that should be the job of the type itself.

Answer 2

While at first it appears that there is no clear advantage to restrict visibility of class members, it may happen in the future.

For example, if in some future extension you want to add some attribute to the class whose value depend on the x,y,... values, it would be very valuable to have them in a private scope, so that it can get automatically re-computed.

Also, as @vandensh suggest, accessing data members through "getters" and "setters" can help detecting illegal values (see std::isnan ).

There cannot be a clear answer, it really depends on the use case.