Classes and User-Defined Types

Imagine you are designing a program that tracks customer orders. You could describe the work as a series of steps, such as checking a price or updating a running total. Or you could describe the work in terms of the things involved, such as an order, a customer, and a price list. C++ gives you tools for both views. The first view is expressed through functions, and the second is expressed through classes. This article begins with the first view and then turns to the second, because the classes are what give a program's computations their structure.

A useful idea in a program's design can live in several places, and each place is less reliable than the one after it. First, the idea exists only in the designer's head. Second, it may be written down in a design document. Third, it may appear as comments next to the code. None of these three places is checked by the compiler, so the idea can drift away from what the program actually does. The recommended move is to take the idea one step further and represent it as a class in the program itself, so the idea is present in the code where the compiler and other programmers can read and use it.

The source puts the emphasis on the programmer's choice. When the design contains a useful concept, idea, or entity, the advice is to represent it as a class so that it appears in the code rather than remaining in a separate document or in comments. The class is therefore the tool that turns a problem's concept into a type the compiler can check.

A program built from a well-chosen set of classes is easier to understand and get right than one built only from built-in types. A reader who sees a class named for a concept such as an order does not have to rebuild that concept from scattered variables and loose operations. Instead, the reader holds one named idea in mind and looks inside it only when needed. The fewer loose pieces a reader must track at once, the easier the program is to follow.

The source also explains that much of the language exists to support classes. Apart from the fundamental types, operators, and statements, almost every other language facility exists to help define better classes or to use them more conveniently. The goals it names for those facilities are being more correct, easier to maintain, more efficient, more elegant, easier to use, easier to read, and easier to reason about.

The passage that introduces this topic says that computations on user-defined and built-in types are represented as functions. Those functions are sometimes generalized to template functions and function objects. Templates, which parameterize types and algorithms with other types and algorithms, are the subject of the following chapter. The introductory passage does not develop functions in detail, so the discussion in this material concentrates on the class, which is treated as the central language feature of C++ and the main tool for representing concepts.

The source lists three kinds of classes that it treats as foundational: concrete classes, abstract classes, and classes in class hierarchies. These three kinds are variations of one concept, the class, rather than unrelated topics. The source claims that a very large share of useful classes belong to one of these three kinds, and that even more classes can be treated as simple variants of them or as implemented by combining the techniques used for them.

At this stage the goal is only to recognize the three names and see how they fit together. The source gives each kind a cross-reference to later sections, which develop each one in detail. Concrete classes, abstract classes, and classes in class hierarchies are the three kinds to keep in mind as the rest of the material unfolds.

The source explains that programmers have very different needs and preferences. Because of that variety, support for classes is extensive, and the material narrows its focus to the basic support for the three kinds above. The class and related facilities are described as the language support for two named programming styles, both of which C++ supports.

The abstract idea of a style becomes concrete in later chapters, which present standard-library facilities and show how they are used. Until then, it is enough to know that classes are the common foundation for both styles.