Classes and Access Control

Suppose you have written a class and want other programmers to use it, but you do not want them to depend on every detail of how it works inside. A class declaration can serve that purpose. It lists what a user is allowed to do with the class and separates that list from the internal parts that make the class work. The running example in this article is a class called Vector, which holds a sequence of double values.

Read the declaration below slowly and do not try to memorize it yet. Notice that it contains two kinds of lines. Some describe things a caller can use, and others describe things kept internal to the class. The example is written for illustration and reflects the members named in the source: a constructor Vector(int s), the subscript operator operator[], and the function size() are public, while the data members elem and sz are private.

The parts that belong to a class are called class members. The Vector declaration contains two kinds. Data members store information, and in this declaration they are elem and sz. Function members perform operations, and here they are the constructor Vector(int s), the subscript operator operator[], and the function size().

Access modifiers are keywords that control which members can be reached from outside the class. Their job is to set visibility. The keyword public: opens a section whose members are visible to users, and private: opens a section whose members are hidden from them. These two keywords are the only access modifiers this declaration needs, and they are how the declaration decides which of its two jobs each member performs.

Now follow a user who wants to work with a Vector. The user does not open the class's internals. Instead, the user includes the header, creates an object, and uses only the public members. The code below is written for illustration and is not part of the source.

Notice where the program depends on the declaration. Every line that compiles against Vector uses names found in the public section. The user code never names the private members, which is exactly the separation the header is designed to create.

Compare two lines that both refer to a Vector object named v. The first line names a member from the public section. The second names a member from the private section. Only the state of the name changes between them, and that change decides whether the line is part of the interface.

Two ideas in that definition deserve attention. First, a header file holds declarations, which describe what exists and how it is used. It does not hold the full working details of the class. Second, the file is shared. A user does not copy the declaration into their own code. They include the file, so the same declaration is available to every program that needs the module.

The declarations that specify the interface to a module are usually placed in a file whose name indicates its intended use. For the Vector class, that file is named Vector.h. The name tells a reader what the file is for before they open it. A reader who wants to know how to use Vector can look for Vector.h, and a reader who sees the name can expect a declaration rather than a full implementation.

When a program misbehaves at the boundary with a class, the fault is usually found at the point where user code accesses the interface. The declaration defines what that access may legally name. A call that uses a name from the public section stays on the declared path. A call that names a private member leaves that path at the moment of access.