10.5.1. Building Aggregation

Pointers are notoriously error-prone. Nevertheless, their power and flexibility make them an indispensable part of programming. We can alleviate some anticipated problems by embedding pointers in classes and accessing them with member functions. Once the functions are debugged and validated, pointers are no longer a "monster in the closet." Indeed, smart pointers, a topic covered in CS 2420, are an abstract data type created with classes that further automate C++'s "raw" pointers and insulate programmers from some of their most troublesome behaviors. We can take a similar approach by using pointers to implement aggregation.

(a)	(b)

A Basic Aggregation Example

C++ does not automatically initialize local and class-scope variables¹. Nevertheless, memory always contains some bit-pattern - a sequence of 1's and 0's. If a program doesn't explicitly initialize the value saved in a variable, the pattern is essentially random (often colloquially called "garbage") and invalid. Consider what happens when a program attempts to use the arrow operator with an uninitialized pointer: object->member;. The program cannot locate member (neither data nor a function) if object is invalid, which causes a catastrophic failure (i.e., the program "crashes").

Even if the program initializes object to nullptr, the arrow operator still can't find member, causing a runtime error. However, if we carefully initialize a pointer to nullptr, the program can test for this condition and avoid misusing an invalid pointer. Writing safe, secure, and correct code requires rigorously initializing and testing the values saved in pointer variables. We extend the Person class introduced in the previous section to demonstrate simple aggregation and three ways of initializing its pointer variable. The next section builds on the example, showing how to use aggregation.

class Person { private: string* name = nullptr; // (a) int weight = 0; double height = 0; public: Person() {} // (b) Person(string n, int w, double h) : name(new string(n)), weight(w), height(h) {} // (c) Person(int w, double h) : name(nullptr), weight(w), height(h) {} // (d) void setName(string* n) // (e) { if (name != nullptr) delete name; name = n; } };

Constructor Initialization Options

Although the previous example demonstrated three constructors, only one created an aggregation relationship. That example created a new part object from its constituent or "raw" ingredients (i.e., data), passed in as the constructor's parameters. Alternatively, the constructor's parameter may be the address of an existing object created elsewhere in the program. Classes may have both constructors but typically only need one. Which constructor programmers choose to implement depends on the problem the program solves.

class Engine								// the part class
{
	private:
		double	size;
		int	cylinders;

	public:
		Engine(double s, int c) : size(s), cylinders(c) {}	// (a)
};

class Car								// the whole class
{
	private:
		Engine*	motor;						// (b)
		string	model;

	public:
		Car(string m, double s, int c)				// (c)
			: motor(new Engine(s, c)), model(m) {}

		Car(string m, Engine* e)				// (d)
			: motor(e), model(m) {}
};

Setter Options

It may not always be practical to build an aggregation relationship (i.e., initialize a pointer member) when constructing a whole object. At other times, programmers may need to change an existing part by updating a pointer. The solution in both cases is an accessor or setter function. But there is one subtle difference between a constructor and a setter. A constructor creates a new object, so initially, the pointer member cannot point to an existing part. Alternatively, a setter function may establish the whole's first part or replace an existing one. Unlike a constructor, a setter must detect which situation applies and behave accordingly.

class Car
{
    private:
        Engine*	motor;
        string	model;

    public:
        Car(string s) : model(s), motor(nullptr) {}

        void set_motor(double s, int c);
        void set_motor(Engine* e);
};
 
 

void Car::set_motor(double s, int c)
{
   delete motor;
   motor = new Engine(s, c);
}

void Car::set_motor(Engine* e)
{
    delete motor;
    motor = e;
}

Who "Owns" The Part?

Pointers are a small, fixed-size data type whose size is independent of the data (object) to which they point, and it's entirely possible to have multiple pointers pointing to the same data or object. Programmers can use multiple pointers to organize data in numerous ways without incurring the expense of duplicating that data. In this way, two or more whole objects can share a part. What the sharing means depends on the problem that the program solves. For the following example, imagine the Car illustrated in Figure 1 is a sponsored racing car. Racing cars are notoriously hard on engines, so it's not unreasonable to further imagine that the racing team has several spare engines. Finally, imagine that the team tracks the spare engines with a database class named Warehouse. Now, it should be easier to see how a Car can share its Engine with another program object.

(a)	(b)

When two or more whole classes share a part, programmers must establish a protocol specifying which whole is responsible for managing the parts. Typically, we designate one class to create new part objects and destroy them when they are no longer needed. Alternatively, any whole can create a part and share it as needed. Finally, while we can devise an arbitrarily complex algorithm to determine which whole will destroy a part, I highly recommend assigning that responsibility to a single class.

Aggregation and Inheritance Examples

We expect the number and variety of class relationships to grow as the size and complexity of programs increase. Programs build objects and the relationships that bind them together by creating constructor-call chains. The chains execute when the program instantiates an object from one class. The following examples demonstrate how we form the constructor chains. Aside from the class names, the two examples are similar, differing only in the aggregation's location relative to the inheritance relationship. We'll see how to use the chains in the next section.

class Address { private: string city; string state; public: Address(string c, string s) : city(c), state(s) {} };
class Person { private: string name; Address* addr; // aggregation public: Person(string n, string c, string s) : addr(new Address(c, s)), name(n) {} };	class Student : public Person { private: double gpa; public: Student(string n, double g, string c, string s) : Person(n, c, s), gpa(g) {} };

class Pet { private: string name; string vaccinations; public: Pet(string pn, string v) : name(pn), vaccinations(v) {} };
class Person { private: string name; public: Person(string n) : name(n) {} };	class Owner : public Person { private: Pet* my_pet; // aggregation int account; public: Owner(string n, int a, string pn, string v) : Person(n), my_pet(new Pet(pn, v), account(a) {} };

1. Some compilers do automatically initialize local and member variables to their zero-equivalent values, which for pointers is nullptr. However, the ANSI C++ standard does not require initializing these variables, and you should not rely on that behavior. Any program dependence on non-standard behaviors reduces its portability.