C ++ զանգվածներ


Array- ը նմանատիպ օբյեկտների հավաքածու է

Մենք կարող ենք ունենալ ամբողջ թվերի, նիշերի, տողերի, օգտագործողի կողմից սահմանված ցանկացած տիպի զանգված և այլն: Քանի որ զանգվածում կարող ենք ունենալ ցանկացած տեսակի հավաքածուներ (ամբողջ թվեր, նիշեր, տողեր և այլն), ուստի ընդհանուր ձևով զանգվածը կարող ենք անվանել ` նմանատիպ առարկաների հավաքածու:

Raանգվածները ֆիքսված են չափերով

Զանգված հայտարարելուց հետո մենք չենք կարող փոխել զանգվածի չափը: Դա նշանակում է, որ մենք չենք կարող նվազեցնել զանգվածի չափը և ոչ էլ մեծացնել զանգվածի չափը:

Rayանգվածի տարրերը բաշխվում են հիշողությանը զուգահեռ

Երբ մենք զանգված ստեղծենք, ապա զանգվածի յուրաքանչյուր տարր կհատկացվի հարակից հիշողության վայրերում:

Հարակից հիշողության տեղերը նշանակում են, որ զանգվածի առաջին տարրից անմիջապես հետո, երկրորդ տարրը հիշողության մեջ կլինի: Եվ հենց երկրորդ տարրից հետո, երրորդ տարրը ներկա կլինի և այլն:

Բոլոր տարրերը հատկացված կլինեն հիշողության վայրերում ՝ հետ-հետ:

Rayանգվածի առաջին տարրը կունենա ամենացածր հասցեն, իսկ վերջին տարրը `ամենաբարձր հասցեն:

Rayուցանիշի միջոցով հասանելի են դառնում զանգվածի տարրերը

Rayուցանիշի միջոցով հասանելի են դառնում զանգվածի տարրերը: Առաջին տարրը կունենա 0 ինդեքս, երկրորդ տարրը կունենա ցուցիչ 1, երրորդը կունենա ինդեքս 2 և այլն: Վերջին տարրը կունենա ինդեքս (n-1), որտեղ n - զանգվածի տարրերի քանակը:

  • Arանգվածը նմանատիպ առարկաների հավաքվա՞ծ է:
  • Raանգվածները ֆիքսվա՞ծ են չափերով:
  • Rayանգվածի տարրերը բաշխվում են հիշողությանը զուգահեռ:
  • Rayուցանիշով հասանելի՞ են զանգվածի տարրերին:

Եթե ​​ասում եք ԱՅՈ վերը նշված բոլոր հարցերի համար, ապա զանգվածի սահմանումը կլինի

Rayանգվածը նմանատիպ օբյեկտների ֆիքսված հավաքածու է, որոնք պահվում են միմյանց հետ, որոնց մատչում են ինդեքսը

Զանգվածի հայտարարագիր

Raանգվածների հայտարարագրում օգտագործվում է հետևյալ շարահյուսությունը.

elements_type name_of_array [ number_of elements]

Ահա զանգվածի հայտարարագրման մի քանի օրինակներ.
//declare an array of 100 elements of the type int
int myIntArray[100];
//declare an array of 5 elements of the type double
double myDoubleArray[5];

Երբ զանգված եք հայտարարում, հիշողության բաշխումը տեղի է ունենում Stack Memory- ում: Rayանգվածի հիշողության դասավորությունը հարակից է: Rayանգվածի նույնացուցիչը (նրա «անվանումը») զանգվածի սկզբնական հասցեն է հիշողության մեջ: Rayանգվածի կրկնակի myDoubleArray- ի հիշողության դասավորությունը [5] կարելի է ցույց տալ հետևյալ նկարով

Rayանգվածի յուրաքանչյուր «բջիջ» ունի կրկնակի չափ: Պետք է հիշել, որ զանգվածի համարակալումը սկսվում է 0-ից և ավարտվում տարրերի քանակով `1:
Հայտարարված զանգվածն օգտագործելու համար դուք պետք է նախնական նշեք այն:

Rayանգվածի սկզբնավորում

Rayանգվածը սկզբնավորելու մի քանի եղանակներ կան.

    1. Քառակուսի փակագծերի հետ մեկ հայտարարություն օգտագործելով.

int anotherIntArray[3] = { 1, 2, 5, 7 };
    1. Եթե ​​այս եղանակով զանգված ընտրեք, հայտարարագրում կկարողանաք դուրս թողնել զանգվածի չափը.

int anotherIntArray[] = { 1, 2, 5, 7 };

Rayանգվածի չափը ինքնաբերաբար կսահմանվի ՝ ըստ տարրերի քանակի: Այս զանգվածը կլինի 4 չափի:

Rayանգվածի տարրերին մուտք գործելը

Ուղիղ մուտք դեպի զանգվածի տարրեր: Դա կարելի է անել, օգտագործելով զանգվածի ինդեքսները `տարրեր մուտք գործելու համար:

Երբ դուք պետք է աշխատեք զանգվածի հետ, անհրաժեշտ է մուտք գործել զանգվածի տարրեր: Դա կարելի է անել ՝ օգտագործելով զանգվածի անունով փակագծերում գտնվող տարրի ցուցիչը: Ինդեքսը զանգվածի տարրի դիրքն է: Այլ կերպ ասած, ինդեքսը զանգվածի մեկնարկի հետ կապված տարրի փոխհատուցումն է: Rayանգվածի տարրերի համարակալումը սկսվում է 0-ից, ուստի զանգվածի առաջին տարրն ունի ինդեքս 0. Ահա և հիշողության դասավորության օրինակ, և 5 տիպի կրկնակի XNUMX տարրերի զանգվածի ցուցիչներ.

Սա օղակի մեջ զանգվածի տարրեր մուտք գործելու օրինակ է.

//display all values of an array in a loop
for (int i = 0; i < 4; ++i)
cout << "Element with index " << i <<" is "<< anotherIntArray[i] << endl;

Այս օղակը մուտք է գործում տարր ՝ օգտագործելով i ինդեքսը: Նայեք արդյունքին.

0 ցուցանիշով տարրը 1 է
1 ցուցանիշով տարրը 2 է
2 ցուցանիշով տարրը 5 է
3 ցուցանիշով տարրը 7 է

Դուք չեք կարող օգտագործել բացասական թիվ ինդեքսի համար: Բացի այդ, դուք չեք կարող օգտագործել ցուցիչը, որը զանգվածի չափից ավելին է. 1. Եթե փորձեք դա անել, ապա մուտք կունենաք հիշողության մի մաս, որը գտնվում է ձեր զանգվածի մոտ: Այն կարող է բացարձակապես ճակատագրական արդյունքներ տալ ձեր ծրագրի համար:

Rayանգվածը ֆունկցիային անցնելը

Ձեր զանգվածը կարող եք փոխանցել գործառույթի: Aանգվածը գործառույթին փոխանցելու համար պարզապես անհրաժեշտ է այն ավելացնել պարամետրերի ցուցակում: Սա ֆունկցիայի պարզ օրինակ է, որը զանգվածը բերում է որպես փաստարկ.

void passArray(int arr[], int size)
{
	for(int i = 0; i != size; ++i)
		cout << "Array[" << i << "] = " << arr[i] << endl;
}

Այս գործառույթը պարամետրերով զանգահարելու համար պարզապես փոխանցեք ձեր զանգվածը որպես պարզ պարամետր.
passArray(anotherIntArray, 4);

Returnանգվածը վերադարձնել գործառույթից

Գործառույթից զանգվածը վերադարձնելու հնարավորություն կա: Բայց դա արվում է ցուցիչների միջոցով և քննարկվում է այստեղ Վերադարձեք ցուցիչը գործառույթից զանգված.

Բազմաչափ զանգված

C ++ - ը թույլ է տալիս ստեղծել բազմաչափ զանգված: Բազմաչափ զանգվածը զանգված է, որի տարրերը նույնպես զանգված են: Բազմաչափ զանգվածի պարզ օրինակ է երկչափ զանգվածը, որը ներկայացնում է մատրիցա: Այս զանգվածում տարրերը 2 ծավալային զանգված են: Բազմաչափ զանգվածի հայտարարագրման համար հարկավոր է օգտագործել հետևյալ շարահյուսությունը.

elements_type name_of_array [ number_of elements1] [ number_of elements2]… 
[ number_of elementsN]

Սա N ծավալային զանգվածի հռչակագիր է: Հիմնականում ձեր ծրագրերում կօգտագործեք 2 կամ 3 ծավալային զանգվածներ:

2D զանգվածներ

2D զանգվածները ներկայացնում են մատրիցան: Rayանգվածի ցանկացած տարրի համար քառակուսի փակագծերում առաջին ցուցիչը տողերի թիվն է, իսկ երկրորդ ցուցանիշը `այդ տարրի սյունակների քանակը: Դուք կարող եք հայտարարագրել 2D զանգված հետեւյալ եղանակով.

//2d array of ints
int array2D[3][2];

Այս հայտարարությունը նշանակում է, որ դուք հայտարարում եք զանգված 3 տողերով և 2 սյունակներով: Դուք կարող եք պատկերացնել այս զանգվածը հետևյալ կերպ.

Նույնիսկ եթե դա 2D զանգված է, բայց այս վերը նշված զանգվածի հիշողության դասավորությունը հարակից կլինի.

Ահա երկչափ զանգվածին մուտք գործելու մի օրինակ.

//initialize 2D array:
for (int i = 0; i < 3; ++i)
	for (int j = 0; j < 2; ++j)
		array2D[i][j] = i + j;
//display 2d array
for (int i = 0; i < 3; ++i){
	for (int j = 0; j < 2; ++j)
		cout << array2D[i][j] << "  " ;
	cout << endl;

2D զանգվածը ցուցադրելու ելքը.

0 1
1 2
2 3

3D զանգված

3D զանգվածը 3 ինդեքսներով զանգված է.

//3d array of ints
int array3D[3][5][4];

Պատկերացնելու, թե ինչ է 3D զանգվածը, կան մի քանի եղանակներ: Մենք կցանկանայինք ձեզ խորհուրդ տալ 3D զանգվածը պատկերել որպես սեղանների գիրք `յուրաքանչյուր էջում նույն քանակի տողերով և սյունակներով: Այս դեպքում առաջին ինդեքսը էջի թիվն է, երկրորդ ինդեքսը `էջի տողի քանակը, իսկ երրորդը` էջի սյունակի քանակը.

3D զանգվածի նախնականացում.

	
for (int i = 0; i < 3; ++i)
	for (int j = 0; j < 5; ++j)
		for (int k = 0; k < 4; ++k)
			array3D[i][j][k] = i + j - k;

3d զանգվածների հիշողության դասավորությունը, ինչպես բոլոր զանգվածների համար, հարակից է:

Այս զանգվածը կարող եք տպել հետևյալ ձևով.

for (int i = 0; i < 3; ++i){
	cout << "Page #" << i << endl;
	for (int j = 0; j < 5; ++j)
	{
		for (int k = 0; k < 4; ++k)
			cout << array3D[i][j][k] << " ";
		cout << endl;
	}
}

3D զանգվածի արտադրանքը հետևյալն է.

Էջ #0
0 -1 -2 -3
1 0 -1 -2
2 1 0 -1
3 2 1 0
4 3 2 1
Էջ #1
1 0 -1 -2
2 1 0 -1
3 2 1 0
4 3 2 1
5 4 3 2
Էջ #2
2 1 0 -1
3 2 1 0
4 3 2 1
5 4 3 2
6 5 4 3

Ինչպես տեսնում եք, 3D զանգվածը 2D զանգվածների զանգված է: