|
|
Every compilation that uses a List must contain the line:
#include <List.h>
near the beginning of the file.
This defines templates that are used to declare
and implement Lists.
As mentioned above, each List contains only one type of object.
If you want to have Lists of integers
and Lists of Strings in your program, you
must declare automatic, static, and external variables
of types List<int>
and List<String>.
Henceforth in this tutorial, we will use
the letter T to represent the type of the object on a List, which is
int
for List<int> and
String
for List<String>.
Lists of pointers are like Lists of objects in that a pointer is a kind of
object.
Declarations for Lists that hold pointers can be of the form:
List<T*>
.
However, there is a special template for creating Lists of pointers that is
a little more convenient to use and generates a lot less code.
For example, to
create a List of pointers to floats,
you can declare variables of type
List_of_p<float>
.
The set of operations on
Lists and List_of_p's are identical.
Any type can be on a List<T>
, including
your own structs and classes.
But the type, T, must have the == operator (T::operator==(const
T&);
) defined in order for List operations to work.
For example, if you want a List of pointers to functions (that map integers to integers, say) and a List of structs, each containing a String and an int, you might write:
typedef int (ifunc)(int);
class Myclass {
int count;
String word;
public:
Myclass();
Myclass(const Myclass&);
~Myclass();
int operator==(const Myclass&);
Myclass& operator=(const Myclass&);
};
to create the types List_of_p<ifunc>
and
List<Myclass>
.
The initial value of a List declaration is an empty List, unless an explicit initialization is given. Initializers can be either Lists or List elements. For example,
1: List<int> w; 2: List<int> x(2); 3: List<String> y("abcd", "efg"); 4: List<String> z = y;
are all legal List declarations.
In line 1, w
is initialized to an empty List of integers.
In line 2, x
is initialized to a List of integers with one element, 2
.
In line 3, y
is initialized to a two-element
List of Strings (which were themselves initialized from arrays of characters).
You can supply up to four elements in a List initializer.
In line 4,
z
is initialized to a copy of y
.
Storage management of List elements is handled by the List functions themselves, but if you build a List of pointers, it is up to you to be sure that the pointed-to objects are valid when the pointers are dereferenced.