Welcome to Programming and Data Structures

The distanceBetween function we just wrote uses a procedural programming approach. In that approach, we solve problems by writing new functions. When we want to know how far apart p1 and p2 are, we write a function and then “ask” the function “how far is it between p1 and p2?”

However, in an object-oriented design, we would like to encapsulate this functionality within the Point class itself. Other parts of the program shouldn’t be trying to implement basic functionality of a Point like calculating the distance between two of them. That is logic that the Point class programmer is best equipped to implement.

So the object-oriented approach is to have the Point class provide methods to do this work. For the distance example, we would add a method to the Point class that allows us to “ask” a point p1 “how far is it to point p2?”. We are still going to end up doing the same math to get the answer, but we are now thinking of that math as a job that a Point object does for us instead of a job that we have to do ourselves.

Here is what the code for a Point member function distanceTo might look like (defined outside of the class):

double Point::distanceTo(const Point& other) const {
    double xdiff = other.m_x - m_x;
    double ydiff = other.m_y - m_y;
    double distance = sqrt(xdiff * xdiff + ydiff * ydiff);
    return distance;
}

To use this function we could write:

int main() {
    Point p1(3.0, 4.0);
    Point p2(6.0, 8.0);
    double distance = p1.distanceTo(p2);
}

When the distanceTo function is executing, we could diagram the memory like this:

As before, m_x implicitly means “this object’s m_x”. To specify the other object’s m_x, we need to explicitly specify that we are talking about the other object via other..

You might be surprised to see that p1 can access the private data of p2. This is allowed because they are the same class. Member code of any Point object can access not just its own private data, but also the private data of any other Point. However that would not be the case if a function in a Circle class took a Point as a parameter.

bool Circle::contains(const Point& p) const;

The contains function shown above would not be able to access private data of p. It would need to use public functions getX() and getY() to access p’s coordinates. The function belongs to the Circle class - thus it can only access private data of Circle objects, not Point objects.

bool sameAs(const Circle& c) const;

bool sameAs(const Circle& c) const;