9.1. Classes And Objects

"Object-oriented modeling and design is a way of thinking about problems using models organized around real-world concepts. The fundamental construct is the object, which combines both data structure and behavior in a single entity" (Rumbaugh et al., 1991, p. 1). Rumbaugh's first sentence underscores one of the many strengths of the object-oriented paradigm: it is both a way of looking at software problems and a way of implementing software solutions to those problems. Today, object-oriented practitioners typically call the data structure and behavior attributes and operations, respectively. The language of object-orientation forms a bridge that spans the entire software development process, joining together analysis, design, and programming (often abbreviated OOA, OOD, and OOP, respectively.)

The object-oriented paradigm or model is based on three essential concepts: encapsulation, inheritance, and polymorphism. We'll study the latter two in subsequent chapters. But encapsulation is just a synonym for an object, and Rumbaugh's second sentence provides our initial definition:

Classes describe objects with the same attributes and operations. A common metaphor is to think of a class as a cookie cutter and the individual objects as the cookies. The cookie cutter defines each cookie's size, shape, and decoration. We can use the cookie cutter to stamp out as many cookies as we want, and each cookie will have the same size, shape, and decorations as the others. However, we eat the cookies but not the cookie cutter; similarly, objects do the work in a program. Rumbaugh et al. (1991) collectively refer to attributes and operations as features. Encapsulation, the first defining characteristic of the object-oriented paradigm, combines attributes and operations into an object that controls the visibility and access to those features.

C++ programmers call attributes and operations member¹ variables and functions, respectively. Like all variables, member variables have a type and a name. Similarly, member functions have a name, a parameter list (that might be empty), and (except constructor functions) a return type.

Attributes

Attributes are the values saved in an object. Ideally, each attribute is a quality or characteristic inherent in something - some aspect whose value helps distinguish between different class instances. For example, a class named Person might have the attributes:

• string name;
• double height;
• int weight;

Operations

Operations represent the services an object can provide to an object-oriented program. Operations correspond to member functions in a C++ program. Recall that C++ is a hybrid language, meaning it supports "regular" functions unrelated to classes and functions that are part of a class. Fortunately, everything we have learned about functions applies to member functions: they have a header (the return value type, the function name, and the argument list) and a body. Of course, member functions also have properties related to object orientation, which we will discover in this chapter.

Classes can define four kinds of operations (or functions in C++)

1. Constructors and destructors (create and destroy objects)
2. Access (gets or sets private data values)
3. Algorithmic (performs useful calculations with an object's data)
4. Helper (often private, implements common operations from other member functions)

Class Responsibilities

Ward Cunningham introduced CRC cards (class-responsibility-collaboration) in the early days of industrial object-oriented software development. (See Fowler, 2004, pp. 62-63.) CRC cards consist of index cards on which the developers write the name of a class, its responsibilities, and the names of other classes with which it collaborates. Moving the cards around while discussing various ways a program can use a class helps the developers determine where (in which class) to place attributes and operations. By placing an attribute or operation in a class, developers make the class responsible for maintaining the data or providing the operation or service. Thinking about program organization in terms of "responsibilities" becomes increasingly helpful as the number of classes in a program and their interconnections grow.

Feature Visibility

C++, like Java, controls the visibility of class features with a set of keywords (in order of increasing visibility): private, protected, and public. Although the C++ syntax is a little different than Java, the meanings of the keywords are the same in both languages, as summarized by the following Venn diagram.

C++ Class Specifications

C++ classes differ in two important ways from Java classes. First is the obvious difference in how they use the public and private (and later the protected ) keywords. The features in a Java class are individually declared as public or private. Alternatively, in a C++ program, regions within the classes are labeled as public or private. Second, Java always includes method bodies inside the class. C++ programs can define short member functions inside of a class (and doing so makes them inline functions, without the need to use the inline keyword), but programmers should only prototype larger functions in the class and write the bodies in a separate compilation unit (i.e., another .cpp file). For example:

class Time
{
	private:
		int	hours;
		int	minutes;
		int	seconds;

	public:
		Time();
		Time(int h, int m, int s);
		Time(int s);

		Time	add(Time t2);
		Time*	add(Time* t2);

		void	print();
		void	read();
};

Class And Object Summary

Although the above class is a simple example, there are several important observations we can make:

• Notice that a C++ class, like a C++ struct, is terminated with a semicolon. The only real difference between a struct and a class is the default visibility: structs have public visibility, and classes have private visibility. Nevertheless, C++ programmers generally only use structs to represent packaged data and reserve classes for situations that are truly object-oriented (i.e., when an entity should have both attributes and operations packaged together).
• The public and private sections can appear in any order (I'll explain in the next section why I typically put my private section first and my public section second). Furthermore, a class may have any number of public and private sections in any order. Any features following the private keyword label will have private visibility until another label changes the visibility; similarly, any features following the public keyword label will have public visibility until another label changes the visibility.
• In this example, only function prototypes are included in the class. Programmers frequently specify a single class in a header (i.e., .h) file named after the contained class and write the complete functions (including their bodies) in a separate .cpp file, also named for the class. Organizing classes this way makes them easier to reuse. This organization is the same as introduced with structs in chapters 5 and 6.
• Like a struct, the name of a class becomes a type specifier, meaning it is a new, programmer-created data type. The class name may appear wherever a program requires the name of a data type, specifically in a variable definition statement:

  Time start;
  Time* end = new Time;

  In this context, we can also call start and end objects (which implies that an object is just a variable created from a class or structure). When we create a new object as illustrated above, we are said to have instantiated the class, so an instance is a synonym for an object.
• We can use a ZIP file to help understand the behavior of objects and the relationship between an object and its member variables. A ZIP file is a container that holds other files. But it's also a single file we can move, copy, and store like any computer file. Similarly, an object is a single, named data item (i.e., a variable) that we can move, copy, and store like any data item. However, an object is also a container that holds other data called member data or member variables. The assignment operation is essential:

  Time temp = start;
  

  copies start, byte-by-byte, to the new object temp. This example over-simplifies object assignment, but clarification and detail must wait for later chapters.
• Notice that three of the function prototypes (add, print, and read) are "normal" function headers with a return value type, function name, and argument list, but the first three prototypes do not have a return value type. The first three functions are constructors. Programs call constructor functions automatically when instantiating new objects (e.g., start above) to "construct" or initialize the object. When a constructor function has an empty parameter list, the C++ syntax still requires the parentheses in the prototype (as seen in the class specification above) and the definition. But unlike Java, when calling a constructor (e.g., the instantiation of start above), the parentheses are optional (in the past, they were not allowed). Parentheses are required when a constructor call passes arguments to the function. Constructor functions have another distinguishing characteristic: the function's name is the same as the class name. (Remember that C++ is a case-sensitive language, so Time is not the same as time). The example above suggests that constructors, like other functions, can be overloaded. We'll study constructors in greater detail in a later subsection.
• Finally, the dot operator is used in C++, just as in Java, to access member variables and functions inside an object. Additionally, it is possible to have a pointer to an object; in this case, the arrow operator selects variables and functions in the object. Ignoring visibility issues (i.e., private features) for a moment and assuming appropriately defined functions, the features of an object may be accessed as illustrated:

  Time start; Time end; start.hours = 60; cout << start.minutes << out; end.read(); Time total = start.add(end); total.print();	Time* start = new Time; Time* end = new Time; start->hours = 60; cout << start->minutes << out; end->read(); Time* total = start->add(end); total->print();
  (a)	(b)

¹ You may see some variation in terminology between different authors. Historically, authors called the variables declared inside a class either a member or a static variable (covered in detail later in the chapter). Alternatively, some authors call all variables declared inside a class member variables and further categorize them as either instance variables or class variables (also detailed later). I learned and used the first terminology as a professional software engineer. Furthermore, static or class variables are uncommon. Consequently, I use the first terminology throughout the text but explicitly state when I'm discussing static or class variables. The variations also apply to functions, although less commonly.

Fowler, M. (2004). UML distilled: A brief guide to the standard object modeling language. Boston: Addison-Wesley.

Rumbaugh, J., Blaha, M., Premerlani, W., Eddy, F., & Lorensen, W. (1991). Object-Oriented Modeling and Design. Englewood Cliffs, NJ: Prentice Hall.

Wirfs-Brock, R.; Wilkerson, B. (1989). "Object-oriented design: a responsibility-driven approach." Conference Proceedings on Object-Oriented Programming Systems, Languages and Applications. OOPSLA 1989 Proceedings, October, 1-6.