Examine the program named CLAS.CPP for our first example of a program with a little information hiding contained in it. This program is identical to the last one except for the way it does a few of its operations. We will take the differences one at a time and explain what is happening here. Keep in mind that this is a trivial program and the safeguards built into it are not needed for such a simple program but are used here to illustrate how to use these techniques in a larger much more complicated program.

The first difference is that we have a class instead of a structure beginning in line 4 of this program. The only difference between a class and a structure is that a class begins with a private
section whereas a structure has no private section automatically defined. The keyword class is used to declare a class as illustrated here.

The class named one_datum is composed of the single variable named data_store and two functions, one named set() and the other named get_value(). A more complete definition of a class is a group of variables and one or more functions that can operate on that data. Stay with us, we will tie this all together in a meaningful and useful way very soon.


A private section of a class is a section of data which cannot be accessed outside of the class, it is hidden from any outside access. Thus, the variable named data_store which is a part of the object (an object will be defined completely later) named dog1declared in line 23 is not available for use anywhere in the main

program. It is as if we have built a “brick wall” around the variables to protect them from accidental corruption by outside programming influences. It seems a little dumb to declare a variable in the main program that we cannot use, but that is exactly what we did.

Figure 5-1 is a graphical representation of the class with its”brick wall” built around the data to protect it. You will notice the small peep holes we have opened up to allow the user to gain access to the functions. The peep holes were opened by declaring the functions in the public section of the class.


A new keyword, public, is introduced in line 6 which states that anything following this keyword can be accessed from outside of this class. Because the two functions are defined following the keyword public, they are both public and available for use in the calling function or any other function that is within the scope of the calling function. This opens two small peepholes in the solid wall of protection. You should keep in mind that the private variable is not available to the calling program. Thus, we can only use the variable by calling one of the two functions defined as a part of the class. These are called member functions because they are members of the class.

Since we have declared two functions, we need to define them by saying what each function will actually do. This is done in lines11 through 19 where they are each defined in the normal way, except that the class name is perpended onto the function name and separated from it by a double colon. These two function definitions are called the implementation of the functions. The class name is required because we can use the same function name in other classes and the compiler must know with which class to associate each function implementation.

One of the key points to be made here is that the private data contained within the class is available within the implementation of the member functions of the class for modification or reading in the normal manner. You can do anything with the private data within the function implementations which are a part of that class,but the private data of other classes is hidden and not available within the member functions of this class. This is the reason we must perpend the class name to the function names of this class when defining them.

It would be well to mention at this point that it is legal to include variables and functions in the private part and additional variables and functions in the public part. In most practical situations, variables are included in only the private part and functions are included in only the public part of a class definition. Occasionally, variables or functions are used in the

other part. This sometimes leads to a very practical solution to a particular problem, but in general, the entities are used only in the places mentioned.

In C++ we have three scopes of variables, local, file and class.Local variables are localized to a single function and file variables are available anywhere in a file following their definition. A variable with class scope is available anywhere within the scope of a class and nowhere else.

You must be very confused by this point since we have given a lot of rules but few reasons for doing all of this. Stay with us and you will soon see that there are very practical reasons for doing all of this.