Post on 29-Mar-2020
Array declaration
An array is a series of objects (called its elements) of the
same type placed in contiguous memory locations
Declaration syntax of an array with N dimensions:
type array_name [dim_1] [dim_2]…[dim_N];
Reserved memory area contains:
dim_1 x dim_2 x ... x dim_N elements.
The array has a symbolic name (array_name )
Each element is identified by indexes which denotes the
position of the element in the array.
The number of elements in an array is called its dimension.
Array declaration
Examples:
float vect1[5]; // declares an array with 5 elements of type float;
// it is allocated memory for 5 * sizeof (float) bytes
int dimensiuni[4][12]; // declares an array with 4*12 elements of
// type int; is allocated memory for
// 4*12*sizeof(int) bytes
double tab[2][3][4]; // declares an array with 2*3*4 elements of
// type double; is allocated memory for
// 2*3*4*sizeof(double) bytes
type name
dimensions
Array declaration
Array declaration with initialization
int vect2[10]={2, 7, -1, 0, 9, 15, -5, 22, 6, 11}; // declares an array with 10
// elements of type int with
// initial values;
int mat[2][3]={{3, 5, -3},{2, -1, 0}}; // declares an bidimensional array
// with 2*3 elements of type int with
// initial values;
float vect[5] = { 1.5, 3.2, 7.1}; // initializes the first three values, two
// remain uninitialized
float vect[5] = { 1.5, 3.2, 7.1, -2.5, 6, 10 };// error, the number of initialization
// values is greater than the number
// of array elements
float vect[ ]={ 1.5, 3.2, 7.1, -2.5, 6 }; // number of initialization values is 5,
// so the default size of the array will
// be 5
Array declaration
Using the array elements
float vect1[5]; // declares an array with 5 elements of type float
// without initialization
vect[0] = 1.5; // to the element of index 0 is assigned the value 1.5
vect[1] = -2.5; // to the element of index 1 is assigned the value -2.5
vect[5] = 3.2; // although no error is reported, the index is used
// incorrectly, the correct values are 0 ... 4, this may
// lead to uncontrolled effects on the development
// of the program
int mat[2][3]={{3, 5, -3},{2, -1, 0}}; // declares an bidimensional array
// with 2*3 elements of type int with
// initial values;
mat[1][2]= 23; // to element of indexes 1 and 2, is assigned
// the value 23
Array declaration
The name of the array (unaccompanied by index) is the
memory address that is assigned to the array.
The first element index is 0 (zero), then the maximum value of
the index is dimension -1.
After allocating the necessary memory or to compile or to
execution, are no longer checks for size, so not check that the
indexes used are correct values.
If indexes exceed the size of the array, there is a risk to
modify values in memory locations used for any purpose,
destroying data or program code.
Array declaration
Uninitialized elements of the arrays take values, like any
variable, as follows:
value zero if the array has a global declaration
residual value, if the declaration of the array is local to
a block of instructions.
When declaring an array, the size is specified by constant
integers (literal or named constants), such as:
#define dim1 15
const int dim2 = 99;
int vector1[20];
float vector2[dim1];
double vector3[dim2];
Literal constant
Named constant
One-dimensional array
The syntax for declaring a one-dimensional array:
type array_name [dimension];
The syntax for declaring a one-dimensional array with initialization of
elements:
type array_name [dimension] = { value_list };
To mention an element use the following syntax:
array_name[index]
One-dimensional array
float array[8];
int i = 5;
array[ 0 ] = 11.11; // index is expressed by a constant
array [ i ] = 12.12; // index is expressed by a variable
array[ i+2 ] = 13.13; // index is expressed by an expression
array [ ++i ] = 14.14; // index is expressed by an expression
One-dimensional array
Examples:
//declares an array with 5 elements of type int without initialization
int tab1[5];
// tab1 item values displayed
printf(“Element values: ");
for(i=0 ; i<5 ; i++)
printf("\ntab1[%d]=%d", i, tab1[i]);
// be read from the keyboard element values of tab1
printf("\n\nReading values for elements: ");
for(i=0 ; i<5 ; i++)
{ printf("\ntab1[%d]=", i);
scanf("%d", &tab1[i]);
}
One-dimensional array
// tab1 item values displayed
printf("\n\n Element values: ");
for(i=4 ; i>=0 ; i--)
printf("\ntab1[%d]=%d", i, tab1[i]);
//display elements divisible by 3
printf("\n\n Element values: - divizibile by 3");
for(i=0 ; i<5 ; i++)
if (!(tab1[i] % 3))
printf("\ntab1[%d]=%d", i, tab1[i]);
One-dimensional array
Specific language operators can be applied to elements of the array to
the extent that such items permits.
No operation can’t be made with array as a whole, but with elements of
their.
int tab1[5];
float tab2[10];
// …
tab1=tab2 ; // error, can not be made the assignment, tab1 and
// tab2 are memory addresses that are assigned to
// arrays and they can not be changed
tab1+tab2 ; // error, operator + is not defined to work with arrays
// (memory addresses)
tab1[0]+tab2[0]; // correct, tab1[0] and tab2[0] are data type int and
// float, so the addition can be made
One-dimensional array
Examples:
1. Write a program that:
• Declares an array with 12 elements of type int.
• Displays memory address that is assigned to the array and the number of
bytes occupied.
• Displays memory address that is assigned to each element and the number
of bytes occupied by them.
• Elements are read from the keyboard and then they are displayed.
• Displays the array elements in ascending order of indexes and than in
reverse order.
• Determines and display the maximum element of the array.
• Determines and display the arithmetic mean of the items.
• Displays the even elements and then the odd elements.
2. Write a program that:
• Reads from the keyboard elements of two arrays with 8 elements of type
double.
• Displays the elements of the two arrays.
• Calculates and displays elements of the 3rd array as the sum of the two
first ( every element is sum of the elements of the same index).
Strings (Character Sequences)
One-dimensional arrays with elements of type char are used for storing
strings (character sequences).
Declaring a string is as specific syntax of single dimensional arrays, the
type of items (char):
char string_name[dimension];
char name[6]; (1)
char name[6] = { ’S’, ’M’, ’I’, ’T’, ’H’, ’\0’}; (2) char name[6] =”SMITH”; (3)
Strings (Character Sequences)
// declaring a char array with 17 elements (a string) with initialization (the
last character in the series is the terminator. ‘\0’
char sir3[ ]=”character sequence”;
// size was not stated explicitly, but implicitly determined by the length of
initialization string
sir3[0]=’C’; // first character of the string receives value ‘C’
Strings (Character Sequences)
Strings can be treated like any one-dimensional array, making
processed item by item, so character by character.
In addition, there are defined in standard header files a set of functions
for processing strings.
char string [20] = “example”;
puts(string); // displays the string
printf(“%s”, string); // displays the string
for(int i=0 ; i<20; i++) // displays all elements
printf(“%c”, string[i]);
for(i=0 ; sir[i] != ‘\0’; i++) // displays all elements up to the terminator
printf(“%c”, string[i]);
Strings (Character Sequences)
If the string is empty, the first element of the picture is even the
terminator of the string, for example:
string[0]=’\0’;
The size specified when declare a string must be one unit higher than
the number of significant characters to allow saving terminator so.
The terminator of the string enables easy testing of the end of the
string.
Defined functions to work with strings do not refer to their size, but they
use the terminator of the string to indicate the end of strings.
Strings (Character Sequences)
header file string.h contains functions which work with strings.
strcpy(sir_destinatie, sir_sursa); - copy content of source string to destination
string
strcat(sir_destinatie, sir_sursa); - add content source string to destination
string (merges the two strings)
strlen(sir); - returns the number of elements of the
string (length string)
strcmp(sir1, sir2); - compares two strings, returning the value
0 if strings are equal, and different value of
0 if they are different (the value is given by
the difference between the first different
characters)
strupr(sir); - replace all lowercase characters with
appropriate capitalization
strlwr(sir); - replaces all uppercase characters with
lowercase letters corresponding
Strings (Character Sequences)
Examples:
1. Write a program that:
• Declares a string wits dimension 12.
• Read the string from the keyboard Elements are read from the keyboard.
• Displays memory address that is assigned to the string and the number of
bytes occupied.
• Displays memory address that is assigned to each element and the number
of bytes occupied by them.
• Displays the string using a function.
• Displays the string character by character.
• Prints on the screen only digit characters (‘0’, ‘1’, ...).
• Transform the string changing the lowercases with capitals.
1. Write a program that:
• Reads from the keyboard elements of two strings.
• Displays the elements of the two strings
• Determines a string by … and print it.
Multi-dimensional arrays
Declaration syntax of a multi-dimensional array :
type array_name [dim_1] [dim_2]…[dim_N];
Reserved memory area contains:
dim_1 x dim_2 x ... x dim_N elements.
A multidimensional array has more than one subscript
There is no limit to the number of dimensions a C++ array can
have
Multidimensional arrays are interpreted as arrays whose
elements are of type of the array.
Multi-dimensional arrays
Frequently there are used arrays with two dimensions
named matrix.
// declaration with initial values
int matrix[3][4] = { { 10, 20, 30, 40},
{ 50, 60, 70, 80},
{ 90, 100, 110, 120} };
Multi-dimensional arrays
matrix is an one-dimensional array with 3 elements; each
element is also an array with 4 integers.
The name of the matrix is the address where the array is
allocated and it is the same address with the address of the
first row of the matrix (matrix[0]) and the same with the
address of the first element (&matrix[0][0]).
The name of the array with one subscript is the name of a row
of matrix (matrix[0], matrix[1], matrix[2]).
One element of matrix can be used like any variable of the
same type.
Multi-dimensional arrays
/* working with multi-dimensional array*/
#include <stdio.h>
int main(void)
{
int matrix[3][4] = { { 10, 20, 30, 40},
{ 50, 60, 70, 80},
{ 90, 100, 110, 120}};
int row, col;
for (row =0; row < 3; row++)
for (col =0; col < 4; col++)
printf(“matrix[%d][%d]=%d\n”, row, col, matrix[row][col]);
return 0;
}
Multi-dimensional arrays
#include <stdio.h>
#include <conio.h>
int main()
{ int x; int y;
int array[8][8]; /* Declares an array */
for ( x = 0; x < 8; x++ )
for ( y = 0; y < 8; y++ )
array[x][y]=x * y; /* Set each element to a value */
printf( "Array Indexes:\n" );
for ( x = 0; x < 8;x++ )
{ for ( y = 0; y < 8; y++ )
printf( "[%d][%d]=%d", x, y, array[x][y] );
printf( "\n" );
}
getch();
}
Multi-dimensional arrays
Examples:
1. Write a program that:
• Declares an matrix with 4 rows and 4 columns (4x4=16 elements) of type
float.
• Displays memory address that is assigned to the array and the number of
occupied bytes.
• Displays memory address that is assigned to each row and the number of
bytes occupied by them.
• Displays memory address that is assigned to each element and the number
of bytes occupied by them.
• Reads from keyboard elements and then displays the matrix.
• Displays the elements of the second row.
• Displays the elements of the main diagonal of the matrix.
• Displays the elements of the secondary diagonal of the matrix.
1. Write a program that:
• Reads from the keyboard elements of two matrix with equal dimensions
with elements of type double.
• Displays the elements of the two arrays.
• Calculates and displays elements of the 3rd array as the sum of the two
first ( every element is sum of the elements of the same indexes.)