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) |
C++ does not automatically initialize local and class-scope variables1. 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; } }; |
string
the part. Aggregation is a weak relationship that programmers can establish and change at any convenient time by changing the address saved in the pointer. If the whole class constructor doesn't build an aggregation relationship, the class must initialize the pointer to nullptr
.
nullptr
, which, until the ANSI C++14 standard, could only be done in the constructor as illustrated.delete
(i.e., deallocate) an existing part object before it installs a new one. Deleting a null pointer should be safe, but as recently as 2019, I witnessed a program fail when it did. So, I still test before deleting, but the test is probably no longer needed. If the whole already has a part, the setter destroys it before installing a new one.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) {} };
new Engine(s, c))
is a function call to the Engine constructor, so the number and type of arguments in the call must match the number and type of parameters in the constructor. The variable names in the constructor call must match the names in the constructor's parameter list.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);
} |
(b) | |
void Car::set_motor(Engine* e)
{
delete motor;
motor = e;
}
|
|
(a) | (c) |
nullptr
.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.
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) {}
};
|
Student valedictorian("Alice", 4.00, "Ogden", "Utah");The program provides the data to populate the three related objects as constructor arguments.
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) {} }; |
Owner client("McCartney", 123456, "Martha", "June 1, 1980");The figure highlights the syntax forming the relationships in yellow, while the Owner constructor calls the Person and Pet constructors.