ВИДІЛЕННЯ Й Звільнення ПАМ'ЯТІ
ПЛАН
ОБ'ЯВА МАСИВУ
ІНІЦІАЛІЗАЦІЯ МАСИВУ
3.багатомірні МАСИВИ
ВИДІЛЕННЯ ТА ЗВІЛЬНЕННЯ ПАМ'ЯТІ
Функції - malloc,calloc,free
ОПЕРАТОРИ - NEW,DELETE
МАСИВИ В ЯКОСТІ ПАРАМЕТРІВ ФУНКЦІЙ
ОГОЛОШЕННЯ МАСИВУ
У повсякденнім житті постійно доводиться зустрічатися з однотипними об'єктами. Як і багато інші мови високого рівня, C++ надає програмістові можливість роботи з наборами однотипних даних – масивами. Окрема одиниця таких даних, що входять у масив, називається елементом масиву. У якості елементів масиву можуть виступати дані будь-якого типу (один тип даних для кожного масиву), а також вказівники на однотипні дані. Масиви бувають одномірними й багатомірними.
Оскільки всі елементи масиву мають один тип, вони також мають однаковий розмір. Використанню масиву в програмі передує його оголошення, що резервує під масив певну кількість пам'яті. При цьому вказується тип елементів масиву, ім'я масиву і його розмір. Розмір повідомляє компілятора, яка кількість елементів буде розміщена в масиві. Синтаксис оголошення масиву має вигляд:
тип ідентифікатор [ кількість_елементів ] ;
Наприклад, оголошення
int Array [ 20 ] ;
зарезервує в пам'яті місце для розміщення двадцяти цілих елементів.
 |
Елементи масиву в пам'яті розташовуються безпосередньо один за одним. На малюнку показане розташування одномірного масиву двобайтних елементів (типу short) у пам'яті.
|
|
|
Звернення до елементів масиву може здійснюватися одним із двох способів:
Ø по номеру елемента в масиві ( через його індекс);
Ø по вказівнику.
При звертанні через індекс за іменем масиву у квадратних дужках вказується номер елемента, до якого потрібно виконати доступ. Слід пам'ятати, що в C++ елементи масиву нумеруються, починаючи з 0. Перший елемент масиву має індекс 0, другий – індекс 1 і т.д. Таким чином, запис типу:
х = Array [13 ] ;
y = Array [19 ] ;
виконує присвоєння змінної х значення 14-го елемента, а змінної y – значення 20-го елемента масиву.
Доступ до елементів масиву через вказівник полягає в наступному. Ім'я масиву, що оголошується, асоціюється компілятором з адресою його найпершого елемента (з індексом 0). Таким чином, можна привласнити вказівнику адресу нульового елемента, використовуючи ім'я масиву:
char Array [ ] = { 'W’, 'О', ’R', 'L’, 'D' } ; // оголошення й ініціалізація масиву символів Array
char* parray = Array ; // parray указує на Array [ 0 ]
Розіменуванням вказівника parray, можна одержати доступ до вмісту Array [ 0 ]:
char Letter = *parray ; // оголошення й ініціалізація символьної змінної
cout << Letter << ‘\n’ ; // виводить на екран W
Оскільки в C++ вказівники та масиви тісно взаємопов’язані, збільшуючи або зменшуючи значення вказівника на масив, програміст отримує можливість доступу до всіх елементів масиву шляхом відповідної модифікації вказівника:
|
|
|
parray += 3 ; // збільшує адресу на 3 байта
cout << *parray << ‘\n’ ; // виводить на екран L
parray ++ ; // збільшує адресу на 1 байт
cout << *parray << ‘\n’ ; // виводить на екран D
Таким чином, після проведених арифметичних операцій вказівник parray буде посилатися на елемент масиву з індексом 4. До цього ж елемента можна звернутися іншим способом:
Letter = *( Array + 4 ) ; // еквівалент Letter = Array [ 4 ] ;
Присвоєння значень одного масиву значенням іншого масиву виду Array [ ] = Another [ ] або Array = Another неприпустимо, тому що компілятор не може самостійно скопіювати всі значення одного масиву в значення іншого. Для цього програмістові необхідно вживати певні дії ( при доступі до елементів по індексу найчастіше використовується циклічне присвоєння). Оголошення виду
char ( * parray) [ 10 ] ;
визначає вказівник parray на масив з 10 символів (char). Якщо ж вилучити дужки, компілятор зрозуміє запис як оголошення масиву з 10 вказівників на тип char. Розглянемо приклад використання масиву.
|
|
|
Short Num [5] ; // оголошення масиву цілих, що містить 5 елементів
for ( int i = 0 ; i<5 ; i++) Num [ i ] = i ; // заповнення всіх елементів масиву в циклі
for ( int i = 2 ; i<5 ; i++) cout << Num [ i ] <<’\n’ ; // вивід значення з 3-го по 5-й
ІНІЦІАЛІЗАЦІЯ МАСИВІВ
Ініціалізацію масивів, що містять елементи базових типів, можна робити при їхньому оголошенні. При цьому безпосередньо після оголошення необхідно за знаком рівності ( = ) перелічити значення елементів у фігурних дужках через кому (, ). Наприклад, вираз:
int Temp [ 12 ] = { 2, 4, 7, 11, 12, 12, 13, 12, 10, 8, 5, 1 } ;
проініціалізує масив температур Temp відповідними значеннями. Так, елемент Теmр[0] одержить значення 2, елемент Temp[1] – значення 4 і т.д. до елемента Temp[11] із присвоєнням йому значення 1.
Якщо в списку ініціалізації значень зазначено менше, чим оголошене в розмірі масиву, останні елементи будуть проініціалізовані 0. У цьому випадку іноді після останнього значення в ініціалізуючим вираженні для наочності ставлять кому:
int Temp (12) = {2, 4, 7, } ;
Таким чином, елементи Temp[0], Теmр[1] і Temp[2] будуть проініціалізовані, у той час елементи, що як залишилися, ініціалізації не одержать.
При оголошенні одномірного масиву з одночасною його ініціалізацією дозволяється опускати значення розміру, що звичайно вказується у квадратних дужках. При цьому компілятор самостійно підрахує кількість елементів у списку ініціалізації й виділить під них необхідну область пам'яті:
|
|
|
// виділення в пам'яті місця для зберігання шести об'єктів типу int
int Even [ ] = { 0, 2, 4, 6, 8, 10 } ;
Якщо далі в програмі буде потрібно визначити, скільки елементів є в масиві, можна скористатися наступним виразм:
int Size = sizeof ( Even ) / sizeof ( Even [ 0 ] ) ;
Тут вираз sizeof(Even) визначає загальний розмір, займаний масивом Even у пам'яті (у байтах), а вираз sizeof(Even[0]) повертає розмір (теж у байтах) одного елемента масиву.
.
БАГАТОМІРНІ МАСИВИ
Багатомірний масив розмірності N можна представити як одномірний масив з масивів розмірності (N-1). Таким чином, наприклад тривимірний масив – це масив, кожний елемент якого представляє двовимірну матрицю.
Приклади оголошення багатомірних масивів:
char Mat2D [6] [9] ; // двовимірний масив 6´9 елементів
unsigned long Arr3D [4] [2] [8] ; // тривимірний масив 4´2´8 елементів
Вираз A[i][j], що представляє двовимірний масив, переводиться компілятором в еквівалентний вираз:
*( *( A + i ) + j )
 |
Елементи двовимірного масиву A[i][j] розташовуються в оперативній пам'яті так, як показано на малюнку – спочатку елементи нульового рядка ( i = 0 ), потім першої ( i = 1 ), другий ( i = 2 ) і т.д.
Багатомірні масиви ініціалізуються в порядку найшвидшої зміни самого правого індексу (задом наперед): спочатку відбувається присвоєння початкових значень усім елементам останнього індексу, потім попереднього і т.д. до самого початку:
int Mass [2] [2] [3] = { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12 } ;
У цьому випадку елементи масиву будуть приймати наступні значення:
Mass [0] [0] [0] = 1 ; Mass [0] [0] [1] = 2 ; Mass [0] [0] [2] = 3 ;
Mass [0] [1] [0] = 4 ; Mass [0] [1] [1] = 5 ; Mass [0] [1] [2] = 6 ;
Mass [1] [0] [0] = 7 ; Mass [1] [0] [1] = 8 ; Mass [1] [0] [2] = 9 ;
Mass [1] [1] [0] = 10 ; Mass [1] [1] [1] = 11 ; Mass [1] [1] [2] = 12 ;
Щоб не заплутатися, для наочності можна групувати дані за допомогою проміжних фігурних дужок:
int Mass [2] [2] [3] = { { { 1, 2, 3 }, { 4, 5, 6 } }, { { 7, 8, 9 }, { 10,11, 12 } } } ;
Для багатомірних масивів при ініціалізації дозволяється опускати тільки величину першої розмірності:
int Mat [ ] [3] = { { 9, 8, 7 }, { 6, 5, 4 }, { 3, 2, 1 } } ;
Доступ до елементів багатомірного масиву через вказівники здійснюється набагато складніше. Оскільки, наприклад, двовимірний масив Mat[i][j] може бути представлений як одномірний ( Mat[i] ), кожний елемент якого також є одномірним масивом ( Mat[j] ), вказівник на двовимірний масив pmat, посилаючись на елемент масиву Mat[i][j], по суті, указує на масив Mat[j] у масиві Mat[i]. Таким чином, для доступу до вмісту пам’яті, на яку вказує вказівник pmat прийдеться розіменовувати двічі.
char Arr [3] [2] = { ‘W', '0', 'R', 'L', 'D',’ ! ’ } ;
char* parr = (char*) Arr ;
parr += 3 ;
char Letter = *parr ;
cout << Letter ;
У наведеному прикладі оголошується масив символів розмірністю 3´2 і вказівник parr на нього (фактично - вказівник на Arr[0][0]). У рядку
char* parr = (char*) Arr ;
ідентифікатор Arr уже є вказівником на елемент із індексом 0, однак, оскільки масив двовимірний, потрібно його повторне розіменування.
Збільшення parr на 3 приводить до того, що він указує на елемент масиву, значення якого – символ 'L' (елемент Агr[1][1]). Далі здійснюється вивід значення елемента масиву, на яке вказує parr.
Розглянемо приклад, у якім на екран виводиться двовимірний масив розміром n´m у вигляді таблиці. Звертання до елементів масиву здійснюється за допомогою індексів – номера рядка i і номера стовпця j.
const n=3, m=4 ; // розмір масиву
// оголошення й ініціалізація двовимірного масиву
int Mat [n] [m] = { {1,2,3,4}, {5,6,7,8}, {9,10,11,12} } ;
for ( int i = 0 ; i<n ; i++) // для всіх номерів рядків i від 0 до n
{
cout<<" i = "<< i <<' \t '; // вивідна екран номер рядка
for ( int j = 0 ; j < m ; j++) // для всіх номерів стовпців j від 0 до m
cout<< Mat [ i ] [ j ]<<' \t ';// вивідна екран елемент масиву з i рядка й j стовпця
cout<<' \n '; // переклад каретки на початок наступного рядка
}
На екран буде виведено:
i=0 1 2 3 4
i=1 5 6 7 8
i=2 9 10 11 12
Розглянемо приклад, у якім демонструється, що ідентифікатор Mat+j є вказівником на j рядок і що двовимірний масив є масивом одномірних масивів.
for ( int i=0 ; i<n ; i++) cout <<"i="<< i <<' \t '<< Mat + i <<' \n ' ;
На екран буде виведено, наприклад:
i=0 0x0012FF48
i=1 0x0012FF58
i=2 0x0012FF68
Наведений фрагмент коду виводить на екран значення вказівників на рядки. Різниця між адресами становить 4*4 байта =16 байт.
Розіменування вказівників на рядки дозволяє одержати вказівники на елементи двовимірного масиву, що показане в наступному прикладі:
// Mass.cpp : Defines the entry point for the console application.
//
#include "stdafx.h"
#include <iostream>
using namespace std;
int _tmain(int argc, _TCHAR* argv[])
{
const int n=3, m=4 ; // розмір масиву
// оголошення й ініціалізація двовимірного масиву
int Mat [n] [m] = { {1,2,3,4}, {5,6,7,8}, {9,10,11,12} } ;
cout<<&Mat[0][0]<<"\n";
for ( int i=0 ; i<n ; i++)
{
cout<<hex;
cout << "\n i = "<< i << '\n' ; // вивід на екран номер рядка
for ( int j=0 ; j<m ; j++) // для всіх номерів стовпців j від 0 до m
// вивід на екран значення вказівника на елемент масиву з i рядка й j стовпця
cout << " j= "<<j<<"=="<< *( Mat + i ) + j <<"\n";
cout << '\n' ;
}
system("pause");
return 0;
}
На екран буде виведено, наприклад:
i=0 0x0012FF48 0x0012FF4C 0x0012FF50 0x0012FF54
i=1 0x0012FF58 0x0012FF5C 0x0012FF60 0x0012FF64
i=2 0x0012FF68 0x0012FF6C 0x0012FF70 0x0012FF74
Розіменування вказівників на елементи двовимірного масиву дозволяє одержати значення самих елементів, що показане в наступному прикладі:
for ( int i=0 ; i<n ; i++) // для всіх номерів рядків i від 0 до n
{
cout<<" i= "<< i << ' \t '; // вивід на екран номер рядка
for ( int j=0 ; j<m ; j++) // для всіх номерів стовпців j від 0 до m
// вивід на екран елемент масиву з i рядка й j стовпця
cout<< *(*( Mat + i ) + j ) << ' \t ' ;
cout << ' \n ' ;
}
Оскільки елементи двовимірного масиву розташовуються в пам'яті в тому ж порядку, що й виводяться на екран, скористаємося цією обставиною в наступному прикладі для рішення тієї ж задачі:
#include "stdafx.h"
#include <iostream>
using namespace std;
int _tmain(int argc, _TCHAR* argv[])
{
const int n=3, m=4 ; // розмір масиву
// оголошення й ініціалізація двовимірного масиву
int Mat [n] [m] = { {1,2,3,4}, {5,6,7,8}, {9,10,11,12} } ;
int *parr=&Mat[0][0];
for ( int i=0 ; i<n*m ; i++)
{
cout<<*parr++<<'\t';
if((i+1)%m==0)
cout<<'\n';
}
system("pause");
return 0;
}
ДИНАМІЧНЕ РОзміщення МАСИВІВ
У програмі кожна змінна може розміщатися в одному із трьох місць: в області даних програми, у стеці або у вільній пам'яті ( так звана купа).
Кожної змінної в програмі пам'ять може приділятися або статично, тобто в момент завантаження програми, або динамічно – у процесі виконання програми. Дотепер обумовлені масиви оголошувалися статично, і, отже, зберігали значення всіх своїх елементів у стековій пам'яті або області даних програми. Якщо кількість елементів масиву невелике, таке розміщення виправдане. Однак досить часто виникають випадки, коли в стековій пам'яті, що містить локальні змінні й допоміжну інформацію (наприклад, точеки повернення із вкладених функцій), недостатньо місця для розміщення всіх елементів великого масиву. Ситуація ще погіршується, якщо масивів великого розміру повинне бути багато. Тут на допомогу приходить можливість використання для зберігання даних динамічної пам'яті.
ВИДІЛЕННЯ Й Звільнення ПАМ'ЯТІ
Щоб надалі можна було розмістити в пам'яті деякий динамічний об'єкт, для нього необхідно попередньо виділити в пам'яті відповідне місце. По закінченню роботи з об'єктом виділену для його зберігання пам'ять потрібно звільнити.
Виділення динамічної пам'яті під об'єкт здійснюється за допомогою наступних функцій malloc і calloc і оператора new. Звільнення виділених ресурсів пам'яті проводиться функцією free і оператором delete.
Функція malloc
Функція malloc підключається в одному із заголовних файлів stdlib.h або alloc.h і має синтаксис:
void *malloc ( size_t size ) ;
Дана функція покликано виділити в пам'яті блок розміром size байт із кучі.
У випадку успішного резервування блоку пам'яті функція malloc повертає вказівник на тільки що виділений блок.
При невдалому результаті операції з пам'яттю функція повертає NULL – зарезервований ідентифікатор зі значенням '\0' (абсолютне значення 0х00). При цьому вміст блоку залишається незмінним. Якщо в якості аргументу функції зазначене значення 0, функція повертає NULL.
Як видно із синтаксису, дана функція повертає вказівник типу void, однак, оскільки на практиці найчастіше доводиться виділяти пам'ять для об'єктів конкретного типу, доводиться приводити тип отриманого порожнього вказівника до необхідного типу. Наприклад, виділення пам'яті під три об'єкти типу int і визначення вказівника на початок виділеного блоку можна зробити в такий спосіб:
int pint = (int*) malloc ( 3*sizeof ( int ) ) ;
Функція calloc
На відміну від malloc, функція calloc крім виділення області пам'яті під масив об'єктів ще робить ініціалізацію елементів масиву нульовими значеннями. Функція має наступний синтаксис:
void *calloc ( size_t num, size_t size ) ;
Аргумент num указує, скільки елементів буде зберігатися в масиві, а параметр size повідомляє розмір кожного елемента в байтах. Наведений тут тип size_t (оголошений у заголовному файлі stddef.h) є синонімом типу unsigned char, що вертається оператором sizeof.
Функція free
Функція звільнення пам'яті free у якості єдиного аргументу приймає вказівник на блок пам’яті
void free ( void *block ) ;
Дана функція підключається в заголовному файлі stdlib.h або alloc.h. Тип об'єктів блоку, що видаляється, може бути довільним, на що вказує ключове слово void.
Розглянемо приклад виділення динамічної пам'яті для десяти об'єктів типу int, заповнення виділеної області числами від нуля до дев'яти й звільнення ресурсу пам'яті.
#include <iostream.h>
#include <stdlib.h>
#include <windows.h>
int main ( void )
{
int* preg ; // оголошення вказівника на область пам'яті
// виділення області пам'яті
if ( ( preg = ( int* ) malloc ( 10*sizeof ( int ) ) )==NULL )
{
char S [80] ; // перетворення рядка
cout<< “\n Heдостаточно пам'яті \n”;
return 1 ; // завер.прогр, якщо не вистачає пам'яті для виділення
}
for ( int i=0 ; i<10 ; i++ ) *( preg + i ) = i ; // заповнення виділеного блоку пам'яті
for ( i=0 ; i<10 ; i++ ) cout << *( preg + i ) << ' \n ' ; // вивід заповненого блоку
free ( preg ) ; // звільнення блоку пам'яті
}
Приклад динамічного виділення пам'яті під двовимірний масив Array[n][m] змінних типу int виглядає в такий спосіб:
Array = ( int* ) malloc ( n*m*sizeof ( int ) ) ;
Оператори new і delete
На відміну від функцій роботи з динамічною пам'яттю malloc, calloc і free, запозичених в C++ зі стандарту ANSIІ для сумісності, нові оператори динамічного розподілу пам'яті new і delete мають додаткові можливості, перераховані нижче.
Ø Функції malloc і calloc повертають порожній вказівник, який надалі потрібно приводити до заданого типу. Оператор new повертає вказівник на тип, для якого виділялася пам'ять, і додаткових перетворень уже не потрібно.
Ø Операція new припускає можливість використання разом з бібліотечною функцією set_new_handler, що дозволяє користувачеві визначити свою власну процедуру обробки помилки при виділенні пам'яті.
Ø Оператори new і delete можуть бути перевантажені для того, щоб вони, наприклад, могли приймати додаткові параметри або виконували специфічні дії з урахуванням конкретної ситуації роботи з пам'яттю.
Оператори new і delete мають дві форми:
Ø керування динамічним розміщенням у пам'яті одиничного об'єкта;
Ø динамічне розміщення масиву об'єктів.
Синтаксис операторів new і delete при роботі з одиничними об'єктами наступний:
тип_об'єкта *ім'я = new тип_об'єкта ;
delete ім'я ;
При керуванні життєвим циклом масиву об'єктів синтаксис операторів new і delete має вигляд:
тип_об'єкта *ім'я = new тип_об'єкта [кількість] ;
delete [] ім'я ;
Тут параметр кількість в операторові new[] характеризує кількість об'єктів типу тип_об'єкта, для яких проводиться виділення області пам'яті. У випадку успішного резервування пам'яті змінна вказівник ім'я посилається на початок виділеної області. При видаленні масиву його розмір указувати не потрібно.
Форма оператора delete повинна обов'язково відповідати формі оператора new для даного об'єкта: якщо виділення пам'яті проводилося для одиничного об'єкта (new), звільнення пам'яті також повинне здійснюватися для одиничного об'єкта (delete). У випадку застосування оператора new[] ( для масиву об'єктів), в остаточному підсумку вивільнення пам'яті повинне бути зроблене з використанням оператора delete[].
Пояснимо все вищесказане на прикладі.
#include <iostream.h>
#include < windows.h>
void main ()
{
const n = 100 ; // розмір масиву - константа типу int
int* pint ; // оголошення вказівника на змінну типу int
pint = new int [n] ; // виділення пам'яті для масиву з n об'єктів типу int
for ( int i=0 ; i<n ; i++) *( pint + i ) = n – i ; // ініціалізація масиву
for ( i=0 ; i<n ; i++) cout << *( pint + i ) << '\t' ; // вивідмасиву на екран
delete [ ] ptr ; // видалення масиву з пам'яті
const m =100000 ; // розмір масиву
long double* plong ; // оголошення вказівника типу long double
if ( plong = new long double [m] ) // якщо пам'ять виділена
{
Cout<<" \n Готове ! \n " ; // перетворення рядка
delete [ ] plong ; // видалення масиву з пам'яті
}
else // якщо пам'ять не виділена
{
Cout<<" \n Невдача... \n ") ;
}
}
У головній функції програми випливає оголошення цілочисельного вказівника ptr, якому відразу оператором new привласнюється адреса виділеного блоку динамічної пам'яті для n значень типу int. Далі область пам'яті заповнюється в циклі числами від n до 1, а в наступному циклі здійснюється вивідїї вмісту, після чого виділений блок динамічної пам'яті звільняється (оператор delete[]).
Наступний крок – спроба виділення пам'яті для великого масиву типу long double. Якщо результат операції new[] не нульовий, вказівнику plong буде привласнене значення адреси зарезервованої пам'яті з виводом напису "Готове!" і наступним вивільненням області. У випадку невдалого виділення виводиться повідомлення "Невдача…".
МАСИВИ ЯК ПАРАМЕТРИ ФУНКЦІЙ
У тіло функції в якості аргументів можна передавати значення, що зберігаються в масивах. При виклику функції, параметр типу масиву перетворюється компілятором у вказівник на тип масиву. Наприклад, якщо аргумент масив має тип unsigned long, при виклику він буде перетворений в unsigned long*. Таким чином, зміна у функції значення будь-якого елемента масиву, що є аргументом, обов'язково вплине й на оригінал. Масиви відрізняються від інших типів тим, що їх не можна передавати за значенням - усередину тіла функції попадає тільки адреса масиву.
Синтаксис виклику функції при цьому може бути наступним:
FunctionName ( ArrayName ) ;
Тоді прототип функції включає вказівник, як параметр типу переданого масиву й наступних за ним прямокутних дужок. Наприклад:
FunctionName ( char [ ] ) ;
Інший варіант синтаксису передачі масиву у функцію – коли прототип функції містить символ операції узяття адреси після вказівка типу аргументу:
char FunctionName ( char& ) ;
При цьому синтаксис виклику функції приймає наступний вид:
FunctionName (*ArrayName ) ;
Нижче приводиться приклад, що ілюструє обидва варіанта передачі масиву як параметра функції.
#include <iostream.h>
void Out1 ( int [ ], short ) ; // прототип першої функції
void Out2 ( int&, short ) ; // прототип другої функції
void main ()
{
int Array [ ] = {10, 8, 6, 4, 2, 0 } ; // оголошення й ініціалізація масиву
short n ; // розмір масиву
n = sizeof ( Array ) / sizeof ( Array [0] ) ;
Out1 ( Array, n ) ; // виклик першої функції
Out2 ( *Array, n ) ; // виклик другої функції
}
void Out1 ( int arr [ ], short n ) // реалізація першої функції
{
for ( int i = 0 ; i < n ; i++) cout << arr [ i ] << ‘ \t ‘ ;
cout << ' \n ' ;
}
void Out2 ( int& arr, short n ) // реалізація другої функції
{
for ( int i = 0 ; i < n ; i++) cout << *( & ( arr ) + i ) << ‘ \t ‘ ;
cout << ' \n ' ;
}
У розглянутому прикладі оголошується масив Array[], що містить шість цілих значень, і здійснюється його передача у функції Out1 і Out2. Обидві функції виконують те саме дію – виводять уміст масиву аргументу на друк. Функція Out1 одержує в якості параметра вказівник на масив, а функція Out2 – посилання на масив. Крім того, оголошується, ініціалізується й передається в якості параметра змінна n, яка зберігає кількість елементів масиву.
Використання в якості параметра функції багатомірного масиву утруднене, тому на практиці найчастіше здійснюється передача масиву вказівників, що значно спрощує синтаксис.
Дата добавления: 2022-06-11; просмотров: 29; Мы поможем в написании вашей работы! |
Мы поможем в написании ваших работ!