What is the status of the instance
variables defined within a class? It seems desirable that these variables
should not be accessible externally. For instance, there should be no way to use
the variables s and t of type stack to directly manipulate the contents of
tos and thearray value
within s and t.
For, if these internal variables are accessible externally, we onceagain have to deal with the problem
of maintaining the integrity of our abstract data type!

One way to achieve
total data integrity is to make all internal data variable inaccessible from
outside. Of course, there is almost always a requirement to be able to access
the values of some or all of the variables and also modify or update them—for
example, consider thefollowing
definition:

class date {

int day, month, year;

}

where one might reasonably expect to
be able to find out what date is currently stored, as well as, perhaps, to
reset the date to a fresh value.

To meet this requirement while
keeping internal variables inaccessible, we could write functions like get_date()
and set_date(...) that provide limited, controlled access to the data stored
in the class. (Note: In object-oriented jargon, a method that reads the values
of internal variables, like get_date(), is called an accessor method and a method that updates the
values of internal variables, like set_date(...) is called a mutator method.) Using

appropriate accessor and mutator
functions, we can control very precisely the degree to which the data in the
stack can be manipulated externally.

However, probably to accommodate
lazy programmers, most object-oriented languages do permit direct external
access to variables. The syntax is similar to that for accessing members of
structures in C (or fields of records in Pascal). For example, the field tos in the stack s is designated s.tos , so we can write code like:

if (s.tos == 0){ ... }.

Once we permit this facility, we have to introduce an additional
mechanism to prevent misuse—that is, to retain data integrity. This is
typically done by adding the qualifiers public and private to each variable defined in a class. As should be clear, a
variable that is declared to be public is accessible from outside while one that is declared private is not. One would write

class stack{

private int values[100];

private int tos = 0;

...

}

to ensure that the only way to
access the stack is via push,
pop and

is_empty. Of course,
private only refers to the external world: the
functions within the class like push, pop and
is_empty

have full access to all the data
variables defined in the class.

What about methods—should all methods be accessible by default? Suppose
our language has a mechanism to request storage at run-time (like the malloc function in C). We might then incorporate a method extend_stack into our class and use it when the stack

becomes full:

class stack {...

push (int i){ /* push i onto stack */

if (stack_full){

extend_stack();

}

... /* Code to add i to stack * /

}

extend_stack(){

... /* Code to get additional space for stack data */

}

...

}

Clearly extend_stack is an implementation detail that is not intended to be
revealed outside the class. It would make sense to extend the use of the
attributes public
and private to methods as
well, making, in this case, only the methods push, pop
and is_empty public and all
other methods, including extend_stack, private.