Member Functions in C++

Many programs need to represent a thing that has both data and operations on that data. A bank account has a balance, and it also needs operations that deposit and withdraw money. A list of numbers has values stored in it, and it also needs operations that report how many values it holds. C++ lets you bundle the data and the operations together in one unit called a class.

A class declaration is the C++ statement that defines a new class type. It gives the type a name and lists everything that belongs to it. Once a class type is defined, you can work with values of that type in the same way you work with built-in types such as int and double. Each value of a class type is called an object.

This article uses one running example throughout: a class named Vector. Vector is a small container that holds a sequence of double values. Its declaration shows every part a class declaration usually contains, so reading it carefully is the fastest way to learn the pattern. You will trace what each line tells you, then use the same procedure on a class of your own.

Every class declaration follows the same overall pattern. The keyword class is followed by the name of the class, and the body is enclosed in braces. The body is divided into labeled sections by the words public and private, each followed by a colon. The declaration ends with a closing brace and a semicolon. Every member declaration inside the body ends with its own semicolon.

The source also includes a free function named sqrt for comparison. It takes a double and returns a double. Its declaration has a return type, a name, and a parameter list, and it ends with a semicolon, just like the member function declarations inside Vector. The difference is where the declaration sits: a free function stands on its own, while a member function is declared inside the body of a class.

Here is a sketch with the same shape as the Vector declaration. It is an original illustration written for this article, not the source code itself. Notice the labels, the three declarations under public, and the two declarations under private.

The anatomy strip above shows the parts in order. The class name Vector appears once, right after the keyword class. Everything else inside the braces is either an access label or a member. Read top to bottom, each access label starts a new section, and the members listed beneath it belong to that section until the next label appears.

The access specifiers public and private control who can use the members that follow them. Public members are accessible from anywhere, and private members are accessible only within the class. This is the mechanism that decides which parts of a class form its outside-facing interface and which parts are hidden inside it.

An access specifier applies to every member after it, until the next specifier appears. The Vector declaration does not need a separate label on each line. The public: label covers the constructor, operator[], and size, and the private: label covers elem and sz. The access specifier is a property of the section, not of an individual declaration.

The public functions in Vector form its interface. They are the route through which code outside the class can reach the data the class holds. The private data members elem and sz hold the stored values, and they stay hidden behind that interface.

Member functions and data members are both declared inside the class body, but they play different roles. A member function is a function that is part of the class. Its job is to access and manipulate data members, and it can perform operations on class objects. A data member is a variable that is part of the class. Its job is to store data within a class object.

The two kinds of member depend on each other. The data members hold the state of an object, and the member functions are the operations that work on that state. The source notes that data members can be accessed and manipulated using member functions, which is exactly the pattern visible in Vector: the data members are private, while the member functions are public.

The source gives a procedure you can use on any class declaration. Follow the steps in order and record what you find at each one.

The source includes a comment on the elem data member: elem points to an array of sz doubles. The two data members work together. elem records where the stored doubles live, and sz records how many there are. Neither member alone describes the whole collection. A class with both data members can describe a sequence of values, and that is why Vector is a sensible running example.

The key idea for this article is the split of responsibilities. The array of doubles is the stored data, which lives in private data members. The public member functions are what outside code uses to work with that data. Outside code never needs to know how elem and sz are arranged, because the interface hides them.