Question

I realize this probably cannot be answered, but I’m looking for whether there is some sort of guidance about whether to use private members directly or public accessors inside class methods.

For example, consider the following code (in Java, but it would look very similar in C++):

public class Matrix {

    // Private Members
    private int[][] e;
    private int numRows;
    private int numCols;

    // Accessors
    public int rows(){ return this.numRows; }
    public int cols(){ return this.numCols; }

    // Class Methods
    // ...
    public void printDimensions()
    {
        // [A] Using private members
        System.out.format("Matrix[%d*%d]\n", this.numRows, this.numCols);


        // [B] Using accessors
        System.out.format("Matrix[%d*%d]\n", this.rows(), this.cols());
    }

The printDimensions() function illustrates two ways to get the same information, [A] using private members (this.numRows, this.numCols) or [B] via accessors (this.rows(), this.cols()).

On one hand, you may prefer using the accessors since there is no way you could inadvertently change the value of the private member variables. On the other, you may prefer accessing the private members directly in hopes that it would remove the unnecessary function call.

I guess my question is, is either the de-facto standard or preferred?

Answer 1

It’s a style call. I prefer to use accessors, because IMHO the function call overhead is small enough that in most cases it doesn’t matter, and this usage preserves the data abstraction. If i later want to change the way the data is stored, i only need to change the accessors, instead of hunting for all the places where i touched the variables.

I don’t feel strongly about it, though, and i would break this “rule” if i thought i had a good reason to.