Файл: Особенности и примеры использования массивов при разработке программ (Одномерные массивы).pdf

4. Примеры использования массивов

Так как массив является структурным типом, то основные операции с ним необходимо проводить с помощью оператора цикла. Покажем это на ряде примеров. В примере на рис. 11.1 с помощью оператора цикла осуществляется присвоение начальных нулевых значений элементам массива n[5], содержащего пять целых чисел. Печать массива осуществляется в табулированном формате. Первый оператор вывода печатает на экране заголовки столбцов, а второй выводит эле- 90 менты массива и их значения. Функция setw() указывает ширину поля, в котором будет выведено следующее значение.
#include
#include
#include
#include
main( )
{ clrscr(); // очистка экрана
int n[5];
for(int i=0;i<5;i++)n[i]=0; // обнуление элементов массива
cout<<"элемент"«setw(13)<<"значение\n"; // вывод заголовков
for(i=0;i<5;i++)
cout<<setw(7)<<i<<setw(13)<<n[i]<<"\n"; // вывод элементов
cout<<"\nНажмите любую клавишу…";
getch();
return 0;
}__________________________________________________________

Результаты работы программы:
элемент значение
0 0
1 0
2 0
3 0
4 0
Рис. 11.1
В примере на рис. 11.2 реализуются операция копирования массивов (mes, mcopy) и вывод их элементов на экран дисплея. При копировании элементам массива mcopy последовательно (в цикле) присваиваются значения элементов массива mes. При этом для доступа к элементам массива используются индексы. Вывод элементов массива также осуществляется в цикле.
#include
#include
#include
#include
main()
{
clrscr(); int i;
int mes[12]={31,28,31,30,31,30,31,31,30,31,30,31}; // инициализация массива
int mcopy[12];
for(i=0;i<12;i++) mcopy[i]=mes[i]; // копирование массива
cout<<"Исходный массив "<<setw(29)<<" Скопированный массив"; //вывод
//заголовков
for(i=0;i<<"\nmes="<<mes[i]<<"\t\t\tmcopy="<mcopy[i]; // вывод
// массивов
Cout<<"\nНажмите любую клавишу…";
getch();
return 0; }_________________________________________________________
Результаты работы программы:
Исходный массив Скопированный массив
mes=31 mcopy=31
mes=28 mcopy=28

… …
mes=31 mcopy=31

Рис.11.2

На рис. 11.3 приведен пример вычисления одномерного массива y[10] по заданному массиву x[10], элементы, которых связаны следующим соотношением: y[i] = (x[i]+a)/sqrt((x[i]2+1 ));.
#include
#include
#include
main()
{
float a=0;
float y[10], x[10];
int i=0;
clrscr(); // очистка экрана
cout<<"\nВведите a : ";
cin>>a; //ввод переменной а
for( i=0; i<10;i++)
{
cout<<"\nВведите x["<<i<<"] : ";
cin>>x[i]; //ввод массива x[i]
y[i]= (x[i] + a) / sqrt((x[i]*x[i])+1);
cout<<"\t\t\t y["<<i<<"] ="<< y[i] ; //вывод массива y[i]
}
cout<<"Нажмите любую клавишу…";
getch();
}
Рис. 11.3
В данной программе ввод переменной а и элементов массива x[i] организован в режиме диалога.
В примере на рис. 11.4 аналогичная задача решается для двумерных массивов. В этой программе ввод и вывод массивов осуществляется с помощью вложенных циклов.
#include
#include
#include
main()
{
float a=0;
float y[3][2], x[3][2];
int i=0, j=0;
clrscr();
cout<<"\nВведите a : ";
cin>> a; // ввод переменной а
for( i=0; i<3; i++)
{
for( j=0; j<2; j++)
{
cout<<"\nВведите x["<<i<<","<<j<<"]:" ;
cin>> x[i][j]; // ввод элементов массива x[i][j]
y[i][j]=(x[i][j] + a)/sqrt((x[i][j] * x[i][j])+1);
cout<<"\t\t\t y["<<i<<","<<j<<"]="<<y[i][j]; // вывод элементов
массива
}
cout<<"\n"; //вывод пустой строки
cout<<"\n\n";
cout<<"\nНажмите любую клавишу ...";
getch();
return 0;
}
Рис. 11.4.
На рис. 11.5 приведен пример программы, в которой вычисляется количество положительных, отрицательных и нулевых элементов одномерного массива.
Количество положительных элементов суммируется в переменной p, отрицательных - в переменной n, а нулевых - в переменной zero.
#include
#include
#include
main()
{
float a[10];
int i=0, n=0, p=0, zero=0; // обнуление переменных
clrscr();
cout<<"\nОпределить количество положительных и отрицательных
элементов массива a[10]\n";
for( i=0; i<10;i++)
{
cout«"\nВведите a["<<i+1<<"] : ";
cin>>a[i];
for( i=0; i<10; i++)
{
if( a[i] > 0) p += 1; // определение количества положительных .элементов
if( a[i] < 0) n += 1; // определение количества отрицательных элементов
if( a[i] == 0) zero += 1; // определение количества нулевых элементов
}
cout<<"\n\n";
cout<<"\nЧисло положительных элементов ="<<p;
cout<<"\nЧисло отрицательных элементов ="<<n;
cout<<"\nЧисло нулевых элементов ="<<zero;
cout<<"\n\n";
cout<<"\nНажмите любую клавишу…";
getch();
}
Рис. 11.5.

Для задания размера массива часто удобно использовать константы. В примере на рис. 11.6 число строк двумерного массива задается константой row, а число столбцов - константой col. Использование констант для задания размера массивов делает программу более наглядной и масштабируемой, так как при любом изменении размеров массива в программе достаточно будет изменить только значения констант. Этот прием наиболее эффективен в больших программах. В данной 94 программе решается задача вычисления количества положительных, отрицательных и нулевых элементов двумерного массива размерностью 2 на 3.
#include
#include
#include
#define row 2 // строки
#define col 3 // столбцы
main()
{
float b[row][col]; // объявление массива
int i=0, j=0,n=0, p=0, zero=0;
clrscr();
cout<<"\nОпределить количество положительных и отрицательных элементов";
cout<<"\n массива b["<<row<<","<<col<<"]\n";
for( i=0; i<row; i++){
for( j=0; j<col; j++){
cout<<"\n Введите b["«i+1«","«j+1<<"]=";
cin>> b[i][j]; // ввод элементов двумерного массива
}
cout<<"\n\n";
}
for(i=0; i<row; i++) {
for(j=0; j<col; j++) {
if(b[i][j] > 0) p += 1;
if(b[i][j] < 0) n += 1;
if(b[i][j] == 0) zero += 1;
}
}
cout<<"\nЧисло положительных элементов = "<<p;
cout<<"\nЧисло отрицательных элементов = "<<n;
cout<<"\nЧисло нулевых элементов = "<<zero;
cout<<"\nНажмите любую клавишу…";
getch();
return 0;
}

Рис. 11.6.

5. Массивы и функции

При передаче массива в функцию в качестве параметра в заголовке функции необходимо указывать тип и имя массива с последующими пустыми квадратными скобками, а также тип и имя переменной, определяющей размерность массива. В 95 прототипе функции имена массива и переменной могут быть опущены. На рис. 11.7 приведена программа вычисления минимальной компоненты вектора с использованием функции vec( ), в которой заголовок функции имеет вид vec(int x[ ], int k), а аргументы int x[ ] и int k соответствуют имени массива и его размерности. В прототипе функции vec(int, int) эти имена опущены.
#include
#include
#include
#include
#define n 5
vec(int [ ], int); // прототип функции вычисления min компоненты вектора
main()
{
int y[n], i, min;
clrscr();
for(i=0;i<n;i++){
cout<<"\nВведите y["<<i<<"]=";
cin>>y[i]; // ввод элементов вектора
}
min=vec(y, n); // вызывающая функция
cout<<"\nМинимальная компонента = "<<min;
cout<<"\nНажмите любую клавишу…";
getch();
return 0;
}
vec(int x[ ], int k) // заголовок функции
{
int min1=x[0];
int i;
for(i=1; i < k;i++)
if(x[i]<min1) min1=x[i];
return min1;
}
Рис. 11.7.
Для передачи многомерных массивов в функцию необходимо учитывать ряд особенностей, которые связаны с тем, что при описании функции необходимо указывать размерность второго индекса и всех последующих индексов массива. Размерность первого индекса многомерного массива также не указывается, но 96 значения размерностей всех последующих индексов необходимы. Это обусловлено тем, что в памяти компьютера элементы массивов хранятся последовательно, независимо от количества индексов (размерности массива), а знание величин индексов дает возможность компилятору сообщить функции о том, как расположены элементы в массиве. Пример программы, в которой функция mas принимает двумерный массив как параметр, приведен на рис. 11.8.
//Вычисление минимальной компоненты двумерного массива
#include
#include
#include
#include
#define n 2 // число строк
#define m 3 // число столбцов
mas(int [ ][m], int, int); // прототип функции
main( )
{
int y[n][m], i, j, min ;
clrscr(); // очистка экрана
for(i=0;I<n;i++)
for(j=0;j<m;j++)
{
cout<<"\nВведите y["<<i<<"]["<<j<<"]=";
cin>>y[i][j]; // ввод массива
}
min=mas(y, n, m); // обращение к функции и получение результата
cout<<"\n\nМинимальная компонента = "<<min;
cout<<"\nНажмите любую клавишу…";
getch( );
return 0;
}
mas(int x[ ][m], int k, int d) //заголовок функции
{
int min1=x[0][0]; int i, j;
for( i=0; i < k; i++)
for(j=0;j<d;j++){
if( x[i][j]<min1) min1=x[i][j];
}
return min1;
}
Рис. 11.8.
В этой программе значения индексов массива задаются с помощью констант n и m, а в заголовке функция описывается следующим образом:
mas(int x[][m], int k, int d),
где m - значение второго индекса массива, а k и d - фиктивные параметры, численные значения которым присваиваются после вызова функции с помощью оператора вида mas(y, n, m);.
В прототипе функции также необходимо указывать размерность второго индекса, в соответствии с выражением mas(int [][m], int, int).

6. Массивы и указатели

Массивы и указатели в языке С++ тесно связаны и могут использоваться почти эквивалентно. Так, имя массива является константным указателем на первый элемент массива, а указатели можно использовать для выполнения любой операции, включая индексирование массива. Пусть сделано следующее объявление: int b[5] = {1,2,3,4,5}, *p;, которое означает, что объявлены массив целых чисел b[5] и указатель на целое р. Поскольку имя массива является указателем на первый элемент массива, можно задать указателю р адрес первого элемента массива с помощью оператора p = b; . Это эквивалентно присвоению адреса первого элемента массива другим способом: р = &b[0];. Теперь можно сослаться на элемент массива b[3] с помощью выражения *(р+3). В этой записи скобки необходимы, потому что приоритет * выше, чем +. На рис. 11.9 показан пример программы, которая с помощью указателей заносит данные в одномерный массив а[5]. Определяет сумму и количество положительных элементов. Выводит на экран полученный массив и адреса его элементов, а также результаты расчетов.
#include
#include
void main()
{ clrscr();
int a[5], sum = 0, *p;
int kol = 0, i;
p = &a[0]; // инициализация указателя адресом первого элемента
cout << " Ввод данных в массив a[ ]\n";
for ( i = 0; I <5; i++){
cout << " a [ " << i << " ] = ";
cin >> *(p+i); // разыменовывание смещенного указателя
}
// расчет суммы и количества положительных элементов
for ( i = 0; i < 5; i ++)
if ( *(p+ i) > 0 ) {
sum += *( p+i );
kol ++;
}
// вывод исходных данных и результатов
cout << "\n\n\n Элемент массива Адрес элемента массива \n";
for ( i = 0; i < 5; i++ ){
cout << *( p+ i) << "\t\t " << (p+i) << "\n"; // вывод результатов
}
cout << "\nсумма = " << sum << "^количество = " << kol; cout<<"\n\n";
cout<<"\nНажмите любую клавишу…";
getch();
}_____________________________________________________________
Результаты работы программы:
Ввод данных в массив a[ ] :
a[0]=1
a[1]=2
a[2]=5
a[3]=5
a[4]=4

Элементы массива Адрес элемента массива
1 Oxffec
2 Oxffee
3 Oxfff0
4 Oxfff2
5 Oxfff4

сумма = 17
количество=5
Рис. 11.9.
На рис.11.10 приведен пример программы, в которой с помощью указателей формируется двумерный массив а[2][2], а из минимальных элементов его столбцов формируется массив b[2]. Значения полученных массивов выводятся на дисплей.
#include
#define I 2
#define J 2
#include
void main()
{
clrscr();
int a[I][J], b[J], min, *p
; int i,j;
p = &a[0][0]; // инициализация указателя адресом первой ячейки
cout << "Введите данные в массив a["<< I <<"]["<<J<<"]:\n";
for ( i = 0; i < I; i++ )
for ( j = 0; j < J; j++ ){
cout << "a[" << i << "][" << j << "]=";
cin >> *(p + i*I + j); // ввод массива
}
// расчет массива b[2]
for ( j = 0; j < J; j++ ) { // цикл по столбцам
min = *(p + j); // присваивание min значения первого элемента столбца
for (i = 1; i < I; i+) // цикл по строкам, начиная со второго элемента
if ( ( *(p + i*I + j)) < min) min = *(p + i*I + j);
*(b + j) = min;
}
cout << "nВывод исходного массива a[,]:";
for (i = 0; i < I;i++){
cout << "\n";
for ( j = 0; j < J;j++){
cout <<"\t"<< *(p + i*I + j);
}
}
cout << "\n\nВывод полученного массива b[]:\n";
for ( j = 0; j < J; j++ ){
cout <<"\t"<< *( b + j);
}
cout<<"\n\n";
cout<<"\nНажмите любую клавишу…";
getch();
}_____________________________________________________________
Результаты работы программы:
Введите данные в массив a[2][2]:
a[0][0]=1
a[0][1]=4
a[1][0]=5
a[1][1]=3
Вывод исходного массива a[2][2]:
1 4
5 3
Вывод полученного массива b[]: