|
|
The next group of operators allows access to arbitrary elements of Lists.
The semantics of the subscript operator ([]) are
the same as ordinary array subscripting except that you can't apply the address
operator (&) to a subscript.
The following
are examples of the use of these operations:
List<int> ix;
for(int i = 0;i < 5;i++) {
ix.put(i);
}
cout << ix; // prints ( 0 1 2 3 4 )
cout << (int) ix[3]; // prints 3
ix[2] = -1;
cout << ix; // prints ( 0 1 -1 3 4 )
int i = ix[4]; // i is 4
int *ip = &ix[1]; // compile-time error
cout << (int) ix[5]; // run-time error
L[n] is the n+1th
of List L.
(Remember that the first element of L is
L[0].)
The object returned
will be converted automatically to a T anywhere that a T is expected,
for example,
T t = L[i];.
In statements such as
cout << L[i];, however, the user must cast
it to a T, for example, cout << (T) L[i] ;.
If the expression L[n] is the left operand of an assignment,
then L is modified in the expected way.
L[i] = t replaces the i+1th
element of List L with T t.
It implements one type of element replacement for Lists (when L[n]
is used as the left operand of =).
The arguments to these functions should always stay within the bounds of the
List (in the range 0 through L.length() - 1). A
statement such as T t = L[i] where
i is out of bounds is considered a program bug,
and the result may be unexpected.
It is the application's responsibility to make
sure that i is within the boundaries. (See "Error
handling" below.) A statement such as L[i]=t where
i is out of bounds has no effect on
L.
A programmer should generally not use arbitrary access operations, for example,
operator[](), to iterate over a List.
Since Lists
are linked, the implementation must
generally step through the List to find a given
element; thus, iterating this way is quadratic
in the size of the List.
The iterator
class (to be introduced in the next section) should be used instead.