- Built-in types
provided by C/C++ allow the programmer to define
variables to store very simple values
- Most computer applications (even numerical programs)
will use an array of different kinds of values.
- Although the programmer can define multiple variables to
store the various values, managing
the different values stored in a large number of variables
can be more complicated that it ought to be....
- Every modern programming languages allow the programmer to define
structured variables
that enable the programmer to all the different kinds of value
in one place
- Some modern programming languages
(e.g., Java)
will even allow the programmer to define
functions
that will ONLY operate on
the prescribed type of variables
(object oriented programming languages)
- A few programming languages (e.g., C++, Algol68) go all the way and allow the programmer to define operators that will ONLY operate on the prescribed type of variables
- An array is probably the most simplest kind of structured
variables...
- An array consists of N variables of the same type
- Syntax to define an one-dimensional
array variable:
TYPE array_var_name[SIZE]; // Uninitialized
TYPE array_var_name[SIZE] = {value1, value2, ...}; // Initialized
TYPE array_var_name[] = {value1, value2, ...}; // Initialized array. // Array size is determined by // the # of items in initialization
- Example:
int A[10]; // A is an array of 10 integers // All elements are uninitialized int B[10] = {11, 12, 13, 14, 15 }; // B is an array of 10 integers // First 5 elements are initialized int C[] = {21, 22, 23, 24, 25, 26, 27, 28, 29, 30}; // C is an array of 10 integers // All 10 elements are initialized
- NOTE:
- Array indices in C/C++
ALWAYS
start at
0
So the indices of an array of size N are:
- 0, 1, 2, 3, ......, N-1
- A
common way
to run down every element of an array in C/C++ is:
int i; for (i = 0; i < N ; i = i + 1) { A[i]... }
- Array indices in C/C++
ALWAYS
start at
0
- Example Program:
(Demo above code)
- Prog file: click here
Multi-dimensional arrays (matrices)
- Multidimensional arrays can be described as arrays of arrays.
For example, a two dimensional array can be imagined as a Two dimensional table of a certain data type:
jimmy is an two dimensional array of 3x5 values of type int.
The way to define this array is:
int jimmy [3][5];
- Each individual element in the array can be referenced
using a multi-dimensional bracket index notation
- Remember that array indices in C/C++ always start with 0 (ZERO)
- For example, to reference the
second element vertically
and fourth horizontally is:
-
jimmy[1][3]:
- Three dimensional arrays are defined in a similar manner;
- Example:
int A[10][5][20];
- The main thing that you have to be aware of is that:
- Array variables can take up a
very large amount
of computer memory
- E.g.:
- double A[100] uses 8 x 100 = 800 bytes
- double A[100][100] uses 8 x 100 x 100 = 80,000 bytes (about 80 KBytes)
- double A[100][100][100] uses 8 x 100 x 100 x 100 = 8,000,000 bytes (about 8 MBytes)
- Array variables can take up a
very large amount
of computer memory
- Sometimes,
due to memory restrictions ,
your program with a very large array will compile,
but
will not run
- Or it runs, but progress is slow
- Programs with large arrays
may run slower
because of a computer technique
known as
virtual memory
- The virtual memory
technique:
- The program (including variables)
is
stored on the DISK
The amount of memory of a disk is several magnitudes larger than main memory
(We have terra-bytes of disk space, but only giga-bytes of main memory)
- The computer
stores
only the portion of the program
(including variables)
that is needed NOW
in memory
- When some segment of the program is no longer needed , the segment in memory is written back to disk and the currently needed segment is brought into the memory
- The program (including variables)
is
stored on the DISK
- The virtual memory
technique will allow the computer to
run programs that are LARGER
than the available main memory
- However , due to the additional overhead (writing program segments to disk and bringing in new program segments), the program execution speed will be greatly reduced
- The computer memory uses
linear addresses
- A multi-dimensional array
needs to be
linearized
to be stored in memory
- There are 2 ways to
linearized
an array:
- row major:
store elements of the last index in consecutive
memory
A[0][0] A[0][1] A[0][2] A[0][3] A[0][4] A[1][0] A[1][1] A[1][2] A[1][3] A[1][4] A[2][0] A[2][1] A[2][2] A[2][3] A[2][4] stored as:
A[0][0] A[0][1] A[0][2] A[0][3] A[0][4] A[1][0] A[1][1] ... A[2][3] A[2][4]
- column major:
store elements of the first index in consecutive
memory
A[0][0] A[0][1] A[0][2] A[0][3] A[0][4] A[1][0] A[1][1] A[1][2] A[1][3] A[1][4] A[2][0] A[2][1] A[2][2] A[2][3] A[2][4] stored as:
A[0][0] A[1][0] A[2][0] A[0][1] A[1][1] A[2][1] A[0][2] ... A[1][4] A[2][4]
- row major:
store elements of the last index in consecutive
memory
- Arrays in
C, C++ and Java
are stored
in row major manner
- Arrays in
Fortran
are stored
in column major manner
- This detail will be
very important
when you
use a function
that are
written in different programming language !!!
- Example:
- The popular
LA Pack
library is written in
Fortran
- If you are writing a program in
C/C++ and
wants to
use a function from the
LA Pack
library,
you
cannot pass array variables
from the
C/C++ and
to the
LA Pack function
You must convert the representation from row major to column major first !!!
- The popular
LA Pack
library is written in
Fortran
- The entire array
can be
passed by reference
This is possible because arrays (in C/C++) are stored in row major manner.
- Hence, if we know:
- The
location of the FIRST element
of the array
- The dimensions of the array
Then we can find the location of any element of that array.
- The
location of the FIRST element
of the array
- Schematically:
int A[10][10]; | | +----------+ A: | | <--- A = address of first element +----------+ | | +----------+ | | +----------+ | | +----------+ A[i][j] | | <--- address = A + (i*10 + j) +----------+ | | +----------+ | | +----------+ | | +----------+ | |
- Example:
#define MAX 5 int A[MAX]; void Change(int A[]) { int i; for (i = 0; i < MAX; i = i + 1) { A[i] = A[i] + 1000; } } int main () { Change(A); }
- Example Program:
(Demo above code)
- Prog file: click here
NOTE:
The effect of pass-by-reference is clearly seen by the change of the values in the array elements
- Multidimensional arrays
are nothing more than an
mapping exercise
- done for your convenience.
- You can do the
mapping
yourself
and get the
same results
with a one-dimensional array
by manipulating its indices:
- Example:
int jimmy[3][5]; jimmy[i][j] = 1234;
Is equivalent to: int jimmy[3*5]; jimmy[i*5+j] = 1234;
- The
do-it-yourself mapping
of
multi-dimensional array
is not recommended because
of
type checks
performed by C/C++ compiler
- The C/C++ compiler performs
type checks
on function parameters
and will
prevent
you to pass
a Two-dimensional array
as a
a One-dimensional array
- Example:
- The formal parameter type
of Print is a
Two-dimensional array
- The actual parameter type
to Print is a
One-dimensional array
- Result:
Error: Formal argument A of type int* in call to Print(int*) is being passed int(*)[5].
#define WIDTH 5 #define HEIGHT 3 int jimmy [HEIGHT][WIDTH]; void Print(int A[]) { int i,j; for (i = 0; i < HEIGHT; i = i + 1) { for (j = 0; j < WIDTH; j = j + 1) cout << A[i*WIDTH + j] << "\t"; cout << "\n"; } } int main () { Print( jimmy ); }
- The formal parameter type
of Print is a
Two-dimensional array
- Example Program:
(Demo above code)
- Prog file: click here
- You can pass a
Two-dimensional array
to Print by using
type conversion (casting)
- Question:
What is the type of the variable A if A is a one-dimensional array: -
int A[10];
To answer this question, we look at how the array is stored
- A one-dimensional array
is stored in memory as follows:
int A[10]; | | +---------+ | | +---------+ A: | A[0] | (4 bytes) +---------+ | A[1] | (4 bytes) +---------+ | A[2] | (4 bytes) +---------+ | ... | +---------+ | |
Observation:
The value A is an address of an integer variable I.e.: the type is (int *)
- The following
casting expression
converts the variable
int jimmy[3][5]
to the type
int A[]:
(int *) jimmy
- Here is how to pass
a two-dimensional array
to Print that uses
a
one-dimensional array:
- Example Program:
(Demo above code)
- Prog file: click here
#define WIDTH 5 #define HEIGHT 3 int jimmy [HEIGHT][WIDTH]; void Print(int A[]) { int i,j; for (i = 0; i < HEIGHT; i = i + 1) { for (j = 0; j < WIDTH; j = j + 1) cout << A[i*WIDTH + j] << "\t"; cout << "\n"; } } int main () { Print( (int *) jimmy ); }
- Example Program:
(Demo above code)
- Array in C++
CAN
be passed
by VALUE...
using a
programming trick :-)
This is done by defining the array inside a struct construct
- Example:
#define MAX 5 struct Array { int x[MAX]; } A; void Change(struct Array A) { int i; for (i = 0; i < MAX; i = i + 1) { A.x[i] = A.x[i] + 1; } } int main () { Change(A); }
- Example Program:
(Demo above code)
- Prog file: click here
NOTE:
The effect of pass-by-value is clearly seen by NO changes made to the values in the array elements NOTE: the struct construct will be covered in detail later....
- The C/C++ compiler
does NOT have
information on the
dimensions of a multi-dimensional array
- Therefore, we must provide
all but one dimensions
to a function
The reason for all but one dimensions is clear by using an example:
int A[3][4]; | | +---------+ A: | A[0][0] | <---- Base +---------+ | A[0][1] | +---------+ | A[0][2] | +---------+ | A[0][3] | +---------+ | A[1][0] | <---- Base + 1*4 +---------+ | A[1][1] | +---------+ | A[1][2] | +---------+ | A[1][3] | +---------+ | A[2][0] | <---- Base + 2*4 +---------+ | |
- In order for the C/C++ compiler
to
compute the offset to find the element
A[i][j],
the C/C++ compiler
must know the
size of the second dimension
(The C/C++ compiler does NOT need to know the size of the first dimension)
- Therefore,
you must specify the second dimension
of a
Two-dimensional array
function parameter
- Example:
int main(int argc, char *argv[]) { void Print(float [][4]); // How to declare function // with 2-dim ARRAY parameter // NOTE: parameter and the // first dimension is NOT // required // You MAY write: // void Print(float X[3][4]); float A[3][4]; int i, j, k; k = 1; for (i = 0; i < 3; i = i + 1) for (j = 0; j < 4; j = j + 1) { A[i][j] = k; k = k + 1; } Print(A); // Passing an ARRAY parameter } void Print(float H[][4]) // How to define function // with array parameter { int i, j, k; for (i = 0; i < 3; i = i + 1) { for (j = 0; j < 4; j = j + 1) cout << H[i][j] << "\t"; cout << "\n"; } }
- Example Program:
(Demo above code)
- Prog file: click here