Тип масив

В C++ структурата от данни масив е реализирана малко ограничено. Разглежда се като крайна редица от елементи от един и същ тип с пряк достъп до всеки елемент, осъществяващ чрез индекс с цели стойности, започващи от 0 и нарастващи с 1 до указана горна граница.

Задаване на масив

Типът масив се определя чрез задаване на типа и броя на елементите на редицата, определяща масив. Нека T е име или дефиниция на произволен тип, различен от псевдоним, void и функционален. За типа T и константния израз от интегрален или изброен тип с положителна стойност size, T[size] е тип масив от size елемента от тип T. Елементите се индексират от 0 до size–1. T се нарича базов тип за типа масив, а size – горна граница.
Примери:
int[5] е масив от 5 елемента от тип int, индексирани от 0 до 4;
double[10] е масив от 10 елемента от тип double, индексирани от 0 до 9;
bool[4] е масив от 4 елемента от тип bool, индексирани от 0 до 3.

Множество от стойности

Множеството от стойности на типа T[size] се състои от всички редици от по size елемента, които са произволни константи от тип T. Достъпът до елементите на редиците е пряк и се осъществява с помощта на индекс, като достъпът до първия елемент се осъществява с индекс със стойност 0, до последния – с индекс със стойност size-1, а до всеки от останалите елементи – с индекс със стойност с 1 по-голяма от тази на индекса на предишния елемент.
Примери:
1. Множеството от стойности на типа int[5] се състои от всички редици от по 5 цели числа. Достъпът до елементите на редиците се осъществява с индекс със стойности 0, 1, 2, 3 и 4.

int[5]




0 1 2 3 4

2. Множеството от стойности на типа double[10] се състои от всички редици от по 10 реални числа. Достъпът до елементите на редиците се осъществява с индекс със стойности 0, 1, 2, 3 и т.н. 9.

double[10]




0 1 9
Елементите от множеството от стойности на даден тип масив са константите на този тип масив.
Примери:
1. Следните редици {1,2,3,4,5}, {-3, 0, 1, 2, 0}, {12, -14, 8, 23, 1000} са константи от тип int[5].

2. Редиците {1.5, -2.3, 3.4, 4.9, 5.0, -11.6, -123, 13.7, -32.12, 0.98}, {-13, 0.5, 11.9, 21.98, 0.03, 1e2, -134.9, 0.09, 12.3, 15.6} са константи от тип double[10].

Променлива величина, множеството от допустимите стойности на която съвпада с множеството от стойности на даден тип масив, се нарича променлива от дадения тип масив. Понякога ще я наричаме само масив.
Фиг. 1 определя дефиницията на променлива от тип масив. Тук общоприетият запис е нарушен. Променливата се записва между името на типа и размерността.


<дефиниция_на_променлива_от _тип_масив> ::=
T <променлива>[size]; |
T <променлива>[size] = {<редица_от_константни_изра и>};
където
Т e име или дефиниция на произволен тип, различен от псевдоним, void, функционален;
<променлива> ::= <идентификатор>
size е константен израз от интегрален или изброен тип със положителна стойност;
<редица_от_константни_израз и> ::= <константен_израз>|
<константен_израз>, <редица_от_константни_израз и>
като константните изрази са от тип T или от тип, съвместим с него.


Фиг. 1.

Примери:
int a[5];
double c[10];
bool b[3];
enum {FALSE, TRUE} x[20];
double p[4] = {1.25, 2.5, 9.25, 4.12};

Вторият случай от дефиницията от Фиг. 1 се нарича дефиниция на масив с инициализация. При нея е възможно size да се пропусне. Тогава за стойност на size се подразбира броят на константните изрази, изброени при инициализацията. Ако size е указано и изброените константни изрази в инициализацията са по-малко от size, останалите се инициализират с 0.

Примери:
Дефиницията
int q[5] = {1, 2, 3};
е еквивалентна на
int q[] = {1, 2, 3, 0, 0};
Дефиницията
double r[] = {0, 1, 2, 3};
e еквивалентна на
double r[4] = {0, 1, 2, 3};
Забележка: Не са възможни конструкции от вида:
int q[5];
q = {0, 1, 2, 3, 4};
а също
int q[];
и
double r[4] = {0.5, 1.2, 2.4, 1.2, 3.4};
Фрагментите
<променлива>[size] и
<променлива>[size] = {<редица_от_константни_изра и>}
от дефиницията от Фиг. 1. могат да се повтарят. За разделител се използва знакът запетая.
Пример: Дефиницията
double m1[20], m2[35], proben[30];
е еквивалентна на дефинициите
double m1[20];
double m2[35];
double proben[30];

Инициализацията е един начин за свързване на променлива от тип масив с конкретна константа от множеството от стойности на този тип масив. Друг начин предоставят т.нар. индексирани променливи. С всяка променлива от тип масив е свързан набор от индексирани променливи. Фиг. 2. илюстрира техния синтаксис.


<индексирана_променлива> ::=
<променлива_от_тип_масив>[<индекс>]
където
<индекс> e израз от интегрален или изброен тип.
Всяка индексирана променлива е от базовия тип.


Фиг. 2.

Примери:
1. С променливата a от примера по-горе са свързани индексираните променливи a[0], a[1], a[2], a[3] и a[4], които са от тип int.
2. С променливата b са свързани индексираните променливи b[0], b[1],…, b[9], които са от тип double.
3. С променливата x са свързани индексираните променливи x[0], x[1],…, x[19], които са от тип enum {FALSE, TRUE}.

Дефиницията на променлива от тип масив не само свързва променливата с множеството от стойности на указания тип, но и отделя определено количество памет (обикновено 4B), в която записва адреса в паметта на първата индексирана променлива на масива. Останалите индексирани променливи се разполагат последователно след първата. За всяка индексирана променлива се отделя по толкова памет, колкото базовият тип изисква.
Пример:
ОП
а a[0] a[1] … a[4] b b[0] b[1] … b[9] …
адрес - - - адрес - - -
на a[0] на b[0]
4B 4B 4B … 4B 4B 8B 8B … 8B

За краткост, вместо “адрес на а[0]” ще записваме стрелка от а към a[0]. Съдържанието на отделената за индексираните променливи памет е неопределено освен ако не е зададена дефиниция с инициализация. Тогава в клетките се записват инициализиращите стойности.
Пример: Разпределението на паметта за променливите p и q, дефинирани в примерите по-горе, е следното:

ОП
p p[0] p[1] p[2] p[3]
1.25 2.5 9.25 4.12

q q[0] q[1] q[2] q[3] q[4]
1 2 3 0 0

Операции и вградени функции

Не са възможни операции над масиви като цяло, но всички операции и вградени функции, които базовият тип допуска, са възможни за индексираните променливи, свързани с масива.
Пример: Недопустими са:
int a[5], b[5];
cin >> a >> b;
a = b;
а също a == b или a != b.
Операторът
cout << a;
извежда адреса на a[0].

Задачи върху тип масив

Задача 48. Да се напише програма, която въвежда последователно n числа, след което ги извежда в обратен ред.

Програма Zad48.cpp решава задачата.
Program Zad48.cpp
#include <iostream.h>
int main()
{double x[100];
cout << "n= ";
int n;
cin >> n;
if (!cin)
{cout << "Error, Bad input! \n";
return 1;
}
if (n < 0 || n > 100)
{cout << "Incorrect input! \n";
return 1;
}
for (int i = 0; i <= n-1; i++)
{cout << "x[" << i << "]= ";
cin >> x[i];
if (!cin)
{cout << "Error, Bad Input! \n";
return 1;
}
}
for (i = n-1; i >= 0; i--)
cout << x[i] << "\n";
return 0;
}

Изпълнение на програма Zad48.cpp

Дефиницията double x[100]; води до отделяне на 800B ОП, които се именуват последователно с x[0], x[1], …, x[99] и са с неопределено съдържание. Освен това се отделят 4B ОП за променливата x, в които записва адресът на индексираната променлива x[0]. Следващият програмен фрагмент въвежда стойност на n (броя на елементите на масива, които ще бъдат използвани). Операторът
for (int i = 0; i <= n-1; i++)
{cout << "x[" << i << "]= ";
cin >> x[i];
if (!cin)
{cout << "Error, Bad Input! \n";
return 1;
}
}
въвежда стойности на целите променливи x[0], x[1], …, x[n-1]. Всяка въведена стойност е предшествана от подсещане. Операторът
for (i = n-1; i >= 0; i--)
cout << x[i] << "\n";
извежда в обратен ред компонентите на масива x.

Забележка: Фрагментите:
… и …
cout << "n= "; int n = 10;
int n; int x[10];
cin >> n;
int x[n];
…
са недопустими, тъй като n не е константен израз. Фрагментът
…
const int n = 10;
double x[n];
е допустим.