So far we have declared variables one at a time. We will often need many variables in a program, and "array"s are a technique for declaring many variables of the same type in one statement, and for being able to consider the whole collection as a single object for appropriate operations.
A "structure" is a means for combining several related items which may be of different types as a single object, while still being able to refer to the separate individual components if we wish to.
We are analysing the annual rainfall over a period of 90 years; we require 90 float variables to store the information.
We are studying a piece of English text; we require 10000 char variables to store the characters.
We are recording the numbers of students in each department of the university; we need (depending on how many departments there are) 100 int variables.
The above examples would be declared as
// 90 float variables float annual_rain[ 90 ]; // 10000 char variables char text[ 10000 ]; // 100 int variables int stud_nos[ 100 ];
The number of elements requested in the declaration must be fixed at compile time.
To get at a particular variable (element) in an array, we write the identifier of the array followed by the subscript in square brackets. In C++ if we declare
float annual_rain[ 90 ];
then the subscripts run from 0 (zero) to 89 inclusive; this gives us the required number (90) of variables.
To access the 23rd of these variables, we would put the subscript in square brackets after the array identifier, and use
... annual_rain[ 22 ] ...
The subscript can be any integer expression.
To store a value in this variable we may use
annual_rain[ 22 ] = ....;
or perhaps
cin >> annual_rain[ 22 ];
and to use the value stored there
if ( annual_rain[ 22 ] > minimum ) {
total = total + annual_rain[ 22 ];
}
The real use of arrays is when we refer to each element of the array not by a specific constant subscript, but access all elements in turn or choose a particular element dynamically. To access the variables in turn, for example to read 90 values from the data into the 90 locations, we would use
int year;
for( year = 0; year < 90; year++ ) {
// Variable "year" goes from 0 to 89
cin >> annual_rain[ year ];
} // for year
The 90 values would have to appear in the data stream in the correct order, separated by "white space", i.e. spaces, tabs or newlines.
Having read the 90 values in, we may wish to calculate the total and average rainfall over these 90 years. For this we would use
float total = 0;
for( year = 0; year < 90; year++ ) {
// Each array element is a "float"
total += annual_rain[ year ];
} // for year
cout << "Total " << total << "\n";
cout << "Average " << total / 90 << "\n";
In the above examples, the constant value 90 keeps appearing. We should really take this out as a constant, so that the actual value appears at only one point in the program. The program now becomes as follows.
// Global constant
const int duration = 90;
main() {
float annual_rain[ duration ];
int year;
for( year = 0; year < duration; year++ ) {
cin >> annual_rain[ year ];
} // for year
float total = 0;
for( year = 0; year < duration; year++ ) {
total += annual_rain[ year ];
} // for year
cout << "Total " << total << "\n";
cout << "Avege " << total / duration << "\n";
} // end main
We will not now have problems when the number of years duration of the rainfall analysis needs to be changed; all values of the duration will change in step together when we change the value of the global constant. If we had not done this, we might have forgotten to change some of the occurrences of "90" to another value.
Note that the value of the "const" denoting the number of elements in the array must be a genuine integer constant! When the compiler is digesting your program must know exactly how many array elements are required. The constant must not be one which is determined as the result of some calculation while the program is running.
Note also the typical C++ loop, starting at zero, and limited by "counter strictly less than number of elements". This gives us the range of values 0, ..., 89 if there are 90 elements. There is NO element with subscript 90.
To count the number of occurrences of the letter 'e' in a piece of text, we will write a program to read the characters of the text into an array of characters, and then search the array for occurrences of the letter 'e'. We will need an array of char elements. We will read characters from the input until we encounter a full stop.
// Set maximum number of characters
const int max = 100;
// Grab space for 100 characters
char sentence[ max ];
int i = 0;
// Read up to a full stop
while(
cin >> sentence[ i ],
sentence[ i ] != '.'
) {
if ( ++i >= max ) {
cerr << "Error sentence overflow\n";
exit( 1 );
}
} // while read character not full stop
const int no_of_chars_read = i;
We should declare the array long enough to hold all likely sentences, and check that the data does not overflow it. Another "safe" way to code the loop might be
for ( i = 0; i < 200; i++ ) {
cin >> sentence[i];
if ( sentence[i] == '.' ) {
break;
}
}
If we ran the program, and typed
The cat sat on the mat.
at the terminal, the code would set
| sentence[ 0 ] | to the value | 'T' |
| sentence[ 1 ] | to the value | 'h' |
| sentence[ 2 ] | to the value | 'e' |
Note that "cin >> character" ignores all white space (spaces, tabs and newlines), so that we would have set
| sentence[ 3 ] | to the value | 'c' |
| sentence[ 4 ] | to the value | 'a' |
| sentence[ 5 ] | to the value | 't' |
To search through the array once it has been read in looking for occurrences of the letter 'e', we use
int count = 0;
// Now go through the array counting
for( i = 0; sentence[ i ] != '.'; i++ ) {
if( sentence[ i ] == 'e' ) {
count++;
} // end if letter is e
} // end search sentence
cout << "Number of e's is "
<< count << "\n";
Or we could use
for ( i = 0; i < numberofchars; i++ ) {
to control the loop
We again control the loop by looking for the full stop '.'. It would be possible instead to count the total number of characters as they are read in, and use this count to control the upper limit of the loop.
Beware of looking for a pair of consecutive letters with, for example
if ( sentence[i] == 'h' && sentence[i+1] == 'e' ) ...
to look for the string "he". The "i+1" suffix means that you must terminate the loop one position earlier. If you terminate the loop by
for( i = 0; sentence[i+1] != '.'; i++ )
you will miss the terminator on an empty sentence.
We wish to read integers into an array (of int variables), sort them into ascending order by swapping, and then print them out. We will assume that the data is terminated by a zero value. First the declarations:
// the maximum number of ints const int max_n = 100; int array[ max_n ];
Then we read the data in:
int i = 0;
while(
cin >> array[ i ],
array[ i ] != 0
) {
if ( ++i >= max_n ) {
cerr << "Error array overflow\n";
exit( 1 );
}
} // while read up to zero
// note how many we read in
const int number = i;
Then we sort the numbers into ascending order by swapping:
int j;
for( i = 0; i < number; i++ ) {
for( j = 0; j < i; j++ ) {
if( array[ j ] > array[ i ] ) {
// swap if out of order
const int swap = array[ i ];
array[ i ] = array[ j ];
array[ j ] = swap;
} // if out of order
} // for j up to i-1
} // for i in the array
Then we might print the results:
for( i = 0; i < number; i++ ) {
cout << i << array[ i ] << "\n";
} // for i
To print the results ten entries per line
// npl = number per line
const int npl = 10;
for( i = 0; i < number; i++ ) {
cout << array[ i ];
if ( (i+1) % npl == 0 ) {
cout << "\n"; // newline
}
} // for i
cout << "\n";
The above program when put together becomes as follows.
#include <iostream.h>
// the maximum number of ints
const int max_n = 100;
// npl = number printed per line
const int npl = 10;
main() {
int array[ max_n ];
int i = 0;
while(
cin >> array[ i ],
array[ i ] != 0
) {
if ( ++i >= max_n ) {
cerr << "Error array overflow\n";
exit( 0 );
} // if check array overflow
} // while read up to zero
// note how many numbers we read in
const int number = i;
int j;
// Now order them
for( i = 0; i < number; i++ ) {
for( j = 0; j < i; j++ ) {
if( array[ j ] > array[ i ] ) {
// swap if out of order
const int swap = array[ i ];
array[ i ] = array[ j ];
array[ j ] = swap;
} // if out of order
} // for j up to i-1
} // for i in the array
// Now print them
for( i = 0; i < number; i++ ) {
cout << i << array[ i ];
if ( (i+1) % npl == 0 ) {
cout << "\n"; // newline
}
} // for i
cout << "\n";
} // end main program
Always be careful to distinguish between the operation
and
To find the maximum value in an array you may write
float values[100];
// Assume that the array is set up
// with values terminated by a zero.
int sub; // Subscript
float max = values[0];
// note that we start here at subscript 1
for ( sub = 1; values[ sub ] >= 0; sub++ ) {
if ( max < values[ sub ] ) {
max = values[ sub ];
}
} // for sub in array
cout << max << "\n";
We start by assuming that the first element is the largest, and compare each of the remaining elements (subscripts from 1 upwards) with it in turn.
We now have the largest value in the "float" variable "max". The type of the variable "max" will be the same as the type of the array elements.
To find the position (the "index") of the largest element, write
float values[100];
// Assume the array is set up
// as before.
int sub;
int maxpos = 0;
for ( sub = 1; values[ sub ] >= 0; sub++ ) {
if ( values[ maxpos ] < values[ sub ] ) {
maxpos = sub;
}
} // for sub in array
cout << "Position " << maxpos << "\n;"
cout << "Largest value " << values[ maxpos ] << "\n;"
We assume the position of the largest element is zero, and compare each other element with it in turn. We now have the position of the largest element in the "int" variable "maxpos". The type of the variable "maxpos" will always be int.
Note that there is always a unique maximum value for an element of an array; there may not be a unique position of the largest element if the are several equal largest values. The above code gives us the position of the first of the equal maxima; if we replaced the
if ( values[ maxpos ] < values[ sub ] ) {
by
if ( values[ maxpos ] <= values[ sub ] ) {
we would get the position of the last of the equal maxima.
To search for the occurrences of a particular word such as "the" in the text, we must search for occurrences of the 3 characters 't', 'h' and 'e' in adjacent positions in the array.
count = 0;
// now go through the array counting
for( i = 0; sentence[ i ] != '.'; i++ ) {
if ( i < 2 ) {
continue;
}
if(
sentence[ i-2 ] == 't' &&
sentence[ i-1 ] == 'h' &&
sentence[ i ] == 'e'
) {
count++;
} // end if word "the"
} // end search sentence
Note that in this case we start the subscript at 2 rather than zero.
We could move the subscript from zero upwards using
count = 0;
// now go through the array counting
if ( sentence[0] != '.' && sentence[1] != '.' ) {
for( i = 0; sentence[ i+2 ] != '.'; i++ ) {
if(
sentence[ i ] == 't' &&
sentence[ i+1 ] == 'h' &&
sentence[ i+2 ] == 'e'
) {
count++;
} // end if word "the"
} // end search sentence
} // end if not early dot
In either case, we must be careful not to run off either end of the array.
If we were actually looking for the word "the" for serious linguistic reasons, we would need to check that there were non-letters at both ends of the string "the" wherever we find it, using perhaps
if (
( i < 3 || sentence[ i-3 ] not a letter )
&&
sentence[ i+1 ] not a letter
) { ...
There is a standard library function is_alpha to check whether a character given as parameter represents a letter. In addition we would probably accept either a leading upper case 'T' or lower case 't'. using a construction such as
if (
sentence[ i-2 ] == 'T'
|| sentence[ i-2 ] == 't'
) { ...
Instead of looking for a specific word such as "the", we may wish to look for a general word (string). We would then store the word we are looking for in a second character array. To search our stored sentence for a word of length "l_word" stored in a character array "word" (assuming that the value in l_word has been set up to equal the length of the word stored in the character array word ) the second part of the program would have to be turned into a loop to compare characters in the word with characters in the array. The code might be:
count = 0;
int found;
// Now go through the sentence counting
for(
i = l_word-1; // Start at length of word
sentence[ i ] != '.'; // Stop at full stop
i++
) {
found = 1; // 1 means true
for ( j = 0; j < l_word; j++ ) {
if(
sentence[ i-l_word+j+1 ] != word[ j ]
) {
found = 0; // 0 means false
} // end if next letter found
} // end for all chars in word
if( found ) { // if ( found == 1 ) would do
count++;
} // end if found
} // end search sentence
The above example would be a little more easily readable if we declared
const int TRUE = 1; const int FALSE = 0;
and use the values TRUE or FALSE later in the program.
Any operation like this will be much more easily performed by using the string library functions, perhaps "strncmp" to compare strings in this case:
count = 0;
// Now go through the array counting
for( i = 0; sentence[ i ] != 0; i++ ) {
if(
strncmp(
word,
sentence + i,
l_word
) == 0
) {
count++;
} // end if found
} // end search sentence
For serious programming, always use library functions whenever they are available. Type
man string
for details.
All of the string library functions assume that the characters stored in the array are terminated by a null (zero) character. Such arrays could be printed by "cout", which will print characters from a character array until a zero element is encountered.
If you read a string, you should use
char sentence[100];
int subscript;
subscript = 0;
while (
cin >> s[subscript],
s[subscript] != '.'
) {
subscript++;
}
s[subscript] = 0;
to insert the terminating null.
If you wish the values of an array to be initialised, you can write ONLY IN GLOBAL
int primes[ ] = { 1, 2, 3, 5, 7, 11 };
with the initial values comma-separated, between curly braces. You need not put a value for the length of the array between the square brackets, since the compiler can count how many elements you have declared! This would set up an array of six elements starting at suffix zero with
primes[0] = 1 primes[1] = 2 etc
If you do put a value between the square brackets, as in
int primes[ 10 ] = { 1, 2, 3, 5, 7, 11 };
an array of 10 elements will be declared, with the remaining elements (4 in this case) not initialised. The number given between the square brackets must be greater than or equal to the number of initialising values given.
To initialise a character array, you could write of course
char word[ ] = { 'E', 'r', 'i', 'c', 0 };
An alternative notation has been devised because initialised strings are required so often. You can also write
char word[ ] = "John";
This actually initialises a 5-character array, with an additional zero element at the end; this is provided so that programs using the array can keep looping until they find the zero element. The form of a loop using this array of characters (an array with a terminating zero element) is now
int sub; // Our subscript
for( sub = 0; word[ sub ] != 0; sub++ ) {
....;
}
We could, of course, omit the "!= 0".
Notice that "word" is an ordinary array of character elements. If we execute
word[2] = 'a';
the word becomes "Joan".
To operate on the elements of an initialised array you will need to know how many elements it has. It is bad practice to have a separate constant giving the number of elements, declared separately from the initialised array declaration, since there is always a possibility that the length value might not agree with the actual length.
One possibility is to use the compile-time operator sizeof (deliver the size in bytes of an object) which was mentioned earlier, and write
const int arr_length = sizeof annual_rain / sizeof annual_rain[0];
and then
for ( sub = 0; sub < arr_length; sub++ ) { ...
Alternatively you can put a special marker element at the end of the array, and loop through the elements until you encounter that special value. For example
int primes[ ] = { 1, 2, 3, 5, 7, 11, 0 };
for( i = 0; primes[ i ] != 0; i++ ) {
....;
} // for i loop
Adding extra prime numbers into the declaration at a later stage will not affect the correct functioning of the loop, as long as the last element is always a zero.
This is exactly the way that strings are scanned by library functions; you may well see the lazy version written as
for( i = 0; sentence[ i ]; i++ ) {
....;
} // for i loop
where the " "!= 0 " " is omitted.
To initialise a globally declared array take NO time while the program is running. The appropriate locations have already been initialied to the correct values in your executable file.
To initalise an array declared inside a function requires
Large initialised arrays are usually seen only in global declarations.
Arrays and variables declared in global, and not otherwise initialised, are all initialised to zero.
For large arrays, you will not wish to
Use a construct such as
for( sub = 0; sub < MAX; sub++ ) {
if ( sub % 10 == 0 ) {
cout << "\n";
}
cout << array[ sub ];
}
cout << "\n";
Entries 0 to 9 will appear on one line, entries 10 to 19 on the next ...
To make the values appear in neat columns, you would need to format the output as in
cout << form( "%5d", array[sub] );
The above arrays are one-dimensional, and can store a single "row" or "column" or "vector" of values. Suppose we wish to store a table (two-dimensional) of values; these might be the rainfall for each of 12 months for each of 90 years, or the IQs of each of the 11 people in each of 22 football teams, or the marks for each of 20 exercises for each of 100 students, or the names (30 characters long) of each of 100 students. We now need two subscripts for each element, and would write
// 90 * 12 variables const int n_yrs = 90; const int n_mths = 12; float month_rain[ n_yrs ][ n_mths ];
int IQ[ 22 ][ 11 ];
int mark[ 100 ][ 20 ];
char names[ 100 ][ 30 ];
To read rainfall data in, we might use
int year, month; // for subscripts
// Read in all the 12 * 90 values
for( year = 0; year < n_yrs; year++ ) {
for( month = 0; month < n_mths; month++ ) {
cin >> month_rain[ year ][ month ];
} // Month loop
} // Year loop
The numbers in the data must be given in the correct order required by the program; if the loops are nested as above, we would require the twelve numbers for the first year, then the twelve numbers for the second year, ...
If the loops had been nested the other way round (just interchange the two "for" lines) the data would have had to consist of the 90 January figures, then the 90 February figures, ...
To calculate the annual totals for each of the 90 years we might write
// Calculate the year totals
float total;
for( year = 0; year < n_yrs; year++ ) {
total = 0;
for( month = 0; month < n_mths; month++ ) {
total += month_rain[ year ][ month ];
} // for month
annual_rain[ year ] = total;
cout << "year " << year + 1900
<< " rain " << total << "\n";
} // for year
We could have used "annual_rain[ year ]" instead of "total" for our addition above; it would be marginally slower on the computer, since it would have to look up the array subscript each time.
To print the average rainfall over the 90 years for each of the 12 months separately, we might write
// print monthly averages
for( month = 0; month < n_mths; month++ ) {
total = 0;
for( year = 0; year < n_yrs; year++ ) {
total += month_rain[ year ] [ month ];
} // for year
cout << month << total / n_yrs << "\n";
} // for month
To find the first student whose name starts with the letter 'S', we might use
int student = -1, i;
for ( i = 0; i < n_students; i++ ) {
if ( names[ i ][ 0 ] == 'S' ) {
student = i;
break;
}
}
leaving student set to -1 if no such student was found.
You could write (only in global) for example
int table[ ][ ] = {
{ 1, 2, 3, 4, 5 },
{ 5, 4, 3, 2, 1 },
{ 1, 3, 5, 3, 1 }
};
This would give us a 3 by 5 array of integers.
There is an alternative "flattened" form
int table[3][5] = {
1, 2, 3, 4, 5,
5, 4, 3, 2, 1,
1, 3, 5, 3, 1
};
In the flattened form we have to insert the bounds, since the compiler could not know whether we intended a 3 by 5 array or a 5 by 3 array.
The particular case of initialised two-dimensional character arrays which will be explained more fully later, but is introduced here since you may find it useful. We are concerned with initialising an array of words.
When looking at C++ programs, we may wish to search for all keywords. We would declare
char *keywords[] = {
"int",
"float",
"double",
"char"
""
};
This is effectively a 2-dimensional array of characters. Each row of this array is of a different length, the length of that keyword + one for the terminating zero which is always added to a string.
We could now have code to look for each keyword in turn, the element "keyword[i][j]" is the j-th character of the i-th keyword. We search along each keyword until we encounter the terminating zero.
This subject is dealt with more fully later under the subject of pointers.
You can, of course, declare and use 3-dimensional, 4-dimensional and higher dimensioned arrays by extending the above notation.
In three dimensions
float mass[10][10][10];
int x_co_ord, y_co_ord, z_co_ord;
for ( x_co_ord = 0; x_co_ord < 10; x_co_ord++ ) {
for ( y_co_ord = 0; y_co_ord < 10; y_co_ord++ ) {
for ( z_co_ord = 0; z_co_ord < 10; z_co_ord++ ) {
if ( mass[x_co_ord][y_co_ord][z_co_ord] >= min ) ...
} // z loop
} // y loop
} // x loop
Beware that it is very easy to eat up huge amounts of storage (the above example declares 1000 variables) with many-dimensioned arrays. The declaration
float mass[100][100][100][100];
would occupy 100,000,000 floats. For your programs you may assume a megabyte of space, say 250K integers or 100k floats.
We read text from standard input until end-of-file is encountered, printing each line as it is read in reflected from left to right. We use the function "getchar()" to read characters instead of "cin", since it reads spaces and newline characters. The "getchar()" function returns a negative value when it reaches end-of-file, so that the loop is controlled by a "while ... > 0" mechanism.
#include <iostream.h>
#include <stdio.h>
main() {
// Store each line as it is read
char line[100];
char ch;
int i = 0;
while ( ch = getchar(), ch > 0 ) {
if ( ch == '\n' ) {
// End of line, print in reverse
while( --i >= 0 ) {
cout << line[ i ];
}
cout << "\n";
i = 0;
} else {
// Ordinary character, store it
line[ i++ ] = ch;
} // end if else end of line
} // end while not end of file
} // end main
Observe that we have a single loop to read the characters, which takes a special action when it encounters a newline character.
Observe that if the compiled program is called "reflect", then typing
cat any_file | reflect | reflect
or
reflect < any_file | reflect
should show the original file.
Arrays can be passed as function parameters, subject to a few new ideas.
When the identifier of an array is used as a parameter, the identifier (which is a single value representing the location of the array in memory) is passed over; this reference to where the array is stored is passed "by value" in terms of our earlier jargon. This means that, inside the function, individual elements of the array can be modified. Thus in the program
// declaration
void functn( int a[] );
main() {
int eric[10];
int fred[1000];
functn( eric );
functn( fred );
} // end main
// definition
void functn( int a[] ) {
int temp = a[0];
a[0] = a[1];
a[1] = temp;
} // end functn
the call of "functn" in the main program will have the effect of swapping over the values in "eric[0]" and "eric[1]". It is the identifier of the array which is passed over, not the contents of the whole array. To do the latter would cause great inefficiency in terms of storage space and processor time if the arrays were large.
If you wish to ensure (for safety reasons) that the array elements cannot be accidentally overwritten, then the function declaration becomes something like
void functn( const int a[] ) { ....
The "const" keyword should ensure that any attempt to overwrite array elements from within the function is prevented (reported as a compile-time error) by the compiler. The "g++" compiler appears merely to report a warning, not an error.
If the function needs to know the size of the array, you must pass it as an integer parameter, as in
// declaration
void functn( int a[], int length );
main() {
int eric[10];
int fred[1000];
functn( eric, 10 );
functn( fred, 1000 );
} // end main
// definition
void functn( int a[], int length ) {
int temp;
for( temp = 0; temp < length; temp++ ) {
...
}
} // end functn
The purpose of structures is to group together a number of related items. The items do NOT need to be of the same type.
.N( We are analysing the properties of a proposed bridge design. For each component of the structure we need its
.N( We are working with geographical data. Each item of data consists of
.N( We are working with train timetables. For each entry in the timetable we need
.N( We are working with a number of countries. For each country we need
We will declare first the layout (components) required of a particular type of structure; the declaration of the structure objects themselves will come later elsewhere.
A bridge component structure type might need
struct element {
float strength;
float length, breadth, height;
int cost;
float weight;
char name[50];
int stock;
};
A general purpose structure for handling dates might be
struct date {
int day_no, week_no, month_no;
char name[4];
long int secs;
};
A structure for handling geographical data might be
struct city {
char name[50];
float latitude, longitude;
};
struct country {
char name[50];
city capital;
int population;
float area;
}
A structure for integer data values each of which is associated with an (x,y) co-ordinate (the x and y could represent geographical latitude and longitude or Ordnance survey co-ordinates) might be
// The structure type
struct data_item {
float x, y;
int value;
};
A structure for railway timetable entries might be
struct t_table {
int depart;
int arrive;
int Fri_only;
int buffet;
};
A structure for a country might be
struct country {
char name[20];
int popn;
float area;
};
A structure for a string might be
struct string {
char data[200];
int length;
}
where the integer field tells us how long the stored string is.
The separate components of a structure are called its fields.
The above declarations are of structure types, not of structure variables for storing data values. To actually declare objects of the above structures, we might write
data_item this, that, result[200];
Here we have declared two single structures called this and that and an array of 200 structures; the whole array is called result .
Do not confuse the structure type declaration (uses no space, gives an identifier to the type of structure) and the variable declarations (they occupy space in the program's memory when the program is running) . Typically the structure type declarations would go into a header file.
This is similar in some ways to the distinction between a function declaration and definition. The function declaration merely informs the compiler of the details of how function calls are to be handled, the definition includes the actual code to be executed.
In order to access individual fields of a structure we use the structure variable identifier, followed by a full stop, then the field identifier from the structure type declaration. Given
data_item this, that, result[200];
declared earlier, we may write
this.x = 10.5; // float
this.y = 20.7; // another float
this.value = 15; // an int
if ( this.x > 0 ) { ....
for ( i = 0; i < 200; i++ ) {
cin >> result[i].x >> result[i].y;
}
// "girder" is a "element" structure
element girder;
// "all_stock" is an array of 100 structures
element all_stock[ 100 ];
girder.name = "Box girder type 10A"; // array of char
girder.strength = 25.93; // float
girder.stock = 0; // int
if ( all_stock[ 10 ].stock < minimum ) {
all_stock[ 10 ].required = minimum;
}
for ( stock = 0; stock < 100; stock++ ) {
tot_requd += all_stock[ stock ].required;
} // for stock loop
The compiler will not be confused by the fact that "stock" is used both as a structure field identifier, and as an array identifier. The field identifier will always follow a full stop.
// "nott_london" is an array of "t_table"
// for the Nottm to London timetable
for( i = 0; i < NTTS; i++ ) {
if ( nott_london[ i ].depart < .... ) {
....;
// "result" is an array of "data_item"s
// add data values for all points within
// given "radius" circle
int sum = 0;
for ( i = 0; ...... ) {
if (
result[ i ].x * result[ i ].x
+ result[ i ].y * result[ i ].y
< radius * radius
) {
sum += result[ i ].value;
}
} // for i loop
To declare an array of countries use
country asia[50];
("country" is the structure type, "asia" is the object identifier) and to access fields
// the area of the first one asia[0].area // a float // the latitude of the capital of the next one asia[1].capital.latitude
To copy a whole structure use:
all_structs[0] = girder;
or if you require merely to copy certain fields use:
all_stock[0].strength = girder.strength; all_stock[0].length = girder.length; all_stock[0].breadth = girder.breadth; all_stock[0].height = girder.height;
To initialise structures we use a notation similar to that for initialising arrays, with the values between curly braces, as in
element girder = {
1234.56,
15.7, 32,6, 99,9,
7600,
50.05,
"Box girder"
};
For an array of structures, use either the nested braces as in
data_item value[] = {
{ 1.0, 2.0, 1323 },
{ 1.5, 1.0, 4523 },
{ 0.0, 2.9, 4373 },
};
or use the flattened form as in
data_item value[] = {
1.0, 2.0, 1323,
1.5, 1.0, 4523,
0.0, 2.9, 4373,
};
For geographical data use
country europe[] = {
"UK", { "London", 52, 0 }, 50000000, 2000000,
etc.
The length of (the number of elements in) an initialised array of structures can be calculated (a compile-time constant) by using the sizeof function to divide the total size of the array by the size of one element, as in
const int nvalues = sizeof value / sizeof value[0];
Do not forget always to divide by the size of a single element of the array. You may then use
for( sub = 0; sub < nvalues; sub++ ) {
to control various loops.
For a simplified BritRail timetable, use perhaps
struct t_table {
int depart, arrive ;
};
for the structure type, and
t_table nott_lond[] = {
{ 537, 727 },
{ 738, 909 },
{ 837, 1023 },
{ 1037, 1216 },
{ 1237, 1412 },
{ 1437, 1623 },
{ 1637, 1819 },
{ 2037, 2229 },
{ 2214, 512 }
};
for the initialised declaration. You will also need
const int num_trains = ( sizeof nott_lond / sizeof nott_lond[0] );
In this case the structure type "t_table" represents a single timetable entry, whereas the array of structures "t_table" represents a whole timetable.
Ordinary mortals do not need to know that structure notation can be used to break a single computer word down into small bit-fields for storing small data items.
struct line_type {
int i;
float f;
unsigned line : 5;
unsigned col : 6;
unsigned mode : 2;
unsigned t : 2;
};
The numbers after each field indicate the number of bits allocated. All fields must be of type unsigned.
Whenever you have related items, they should be grouped in a structure. If a program contains two arrays of the same length, it can usually be inferred that the corresponding elements are related.
You should replace
float x[100], y[100]; int value[100]; for ( i = 0; i < 100; i++ ) cout << x[i] << y[i];
by
struct data {
float x, y;
int value;
};
data point[100];
and use by
for ( i = 0; i < 100; i++ ) cout << point[i].x << point[i].y;
Program style checkers look for arrays of the same length, and recommend that they be turned into a structure.
Your program layout should now treat square brackets like any others; if the open and close fit on the same line, that's OK. If they don't, use the same rules as for curly braces (but of course no comment necessary after the close).
average +=
this_val[
( total * factor + base ) / per_unit + offset
];
Copyright Eric Foxley Tue Dec 10 10:09:20 GMT 1996
Notes converted from troff to HTML by an Eric Foxley shell script, email errors to me!