151 pointers to objects and object arrays 394 acctptr

15.1. POINTERS TO OBJECTS AND OBJECT ARRAYS
394
acct_ptr = new Account( "Moe" , 400, 1300.00);
Note that we include the arguments expected by the Account class constructor. This statement allocates
memory for one Account object and executes the constructor’s code to initialize the newly created ob-
ject. Figure 15.1 illustrates a pointer to an account object. As with any dynamically allocated entity, a
'J' 'o' 'e' '\n'
0 1 2 3
name
acct_ptr
400
id
balance
1300.00
Figure 15.1: A pointer to an Account object
programmer must be careful to use the delete operator to deallocate any objects created via new .
C
++
supports vectors and arrays of objects, but they present special challenges. First, consider a simple
situation. The Point class defines no constructor, so the following code is valid:
vector<Point> pts(100); // Okay
The compiler happily generates code that at run time will allocate enough space for 100 Point objects.
No special initializations are needed since Point has no constructor. What if a class defines a constructor
that accepts arguments and does not supply also a constructor that requires no arguments? Consider the
Account class. The following statement is illegal:
vector<Account> accts(100); // Illegal, the Account class has
// no default constructor
When creating the space for the accts elements, C
++
expects a default constructor properly to properly
initialize all of the vector’s elements. The only constructor in the Account class requires arguments, and
so the compiler refuses to accept such a declaration. The compiler cannot ensure that the vector’s elements
are properly initialized before the programmer begins using the vector.
One solution uses an vector of pointers, as in
vector<Account
*
> accts(100); // A vector of account pointers
Note that this does not create any Account objects. The programmer subsequently must iterate through
the vector and use new to create individually each account element. An example of this would be
vector<Account
*
> accts(100); // A vector of account pointers
for ( int i = 0; i < 100; i++) {
// Get information from the user
cin >> name >> id >> amount;
©2014 Richard L. Halterman Draft date: January 26, 2014

15.1. POINTERS TO OBJECTS AND OBJECT ARRAYS
395
// Create the new account object
accts[i] = new Account(name, id, amount);
}
The dot operator syntax to access a field of a object through a pointer is a bit awkward:
Point
*
p = new Point;
(
*
p).x = 253.7;
(
*
p).y = -00.5;
The parentheses are required since the dot ( . ) has higher precedence than the pointer dereferencing operator
(
*
). Without the parentheses, the statement would be evaluated as if the parentheses were placed as shown
here
*
(p.x) = 253.7; // Error
The variable p is not a Point object, but a pointer to a Point object, so it must be dereferenced with
the
*
operator before applying the . operator. C
++
provides a simpler syntax to access fields of an object
through a pointer. The structure pointer operator eliminates the need for the parentheses:
Point
*
p = new Point;
p->x = 253.7;
p->y = -00.5;
The pair of symbols -> constitute one operator (no space in between is allowed), and the operator is meant
to look like an arrow pointing right. There is no associated left pointing arrow in C
++
.