Arrays
Arrays are a kind of
composite type because they allow you to clump a lot of
variables together, one right after the other, under a single identifier name.
If you say:
int a[10];
You create storage for 10 int
variables stacked on top of each other, but without unique identifier names for
each variable. Instead, they are all lumped under the name
a.
To access one of these array
elements, you use the same square-bracket syntax that you use to define an
array:
a[5] = 47;
However, you must remember that even
though the size of a is 10, you select array elements starting at
zero (this is sometimes called
zero indexing), so you can
select only the array elements 0-9, like this:
//: C03:Arrays.cpp
#include <iostream>
using namespace std;
int main() {
int a[10];
for(int i = 0; i < 10; i++) {
a[i] = i * 10;
cout << "a[" << i << "] = " << a[i] << endl;
}
} ///:~
Array access is extremely fast. However,
if you index past the end of the array, there is no safety net –
you’ll step on other variables. The other drawback is that you must define
the size of the array at compile time; if you want to change the size at runtime
you can’t do it with the syntax above (C does have a way to create an
array dynamically, but it’s significantly messier). The C++ vector,
introduced in the previous chapter, provides an array-like object that
automatically resizes itself, so it is usually a much better solution if your
array size cannot be known at compile time.
You can make an array of any type, even
of structs:
//: C03:StructArray.cpp
// An array of struct
typedef struct {
int i, j, k;
} ThreeDpoint;
int main() {
ThreeDpoint p[10];
for(int i = 0; i < 10; i++) {
p[i].i = i + 1;
p[i].j = i + 2;
p[i].k = i + 3;
}
} ///:~
Notice how the struct identifier
i is independent of the for loop’s
i.
To see that each element of an array is
contiguous with the next, you can print out the addresses like
this:
//: C03:ArrayAddresses.cpp
#include <iostream>
using namespace std;
int main() {
int a[10];
cout << "sizeof(int) = "<< sizeof(int) << endl;
for(int i = 0; i < 10; i++)
cout << "&a[" << i << "] = "
<< (long)&a[i] << endl;
} ///:~
When you run this program, you’ll
see that each element is one int size away from the previous one. That
is, they are stacked one on top of the other.
