സി ++ അറേകൾ


സമാന വസ്തുക്കളുടെ ഒരു ശേഖരമാണ് അറേ

നമുക്ക് ഒരു സംഖ്യയിൽ ഏതെങ്കിലും തരത്തിലുള്ള ശേഖരം (സംഖ്യകൾ, പ്രതീകങ്ങൾ, സ്ട്രിംഗുകൾ മുതലായവ) ഉണ്ടായിരിക്കാമെന്നതിനാൽ, ഒരു സംഖ്യയിൽ നമുക്ക് സംഖ്യകൾ, പ്രതീകങ്ങൾ, സ്ട്രിംഗുകൾ, ഉപയോക്തൃ നിർവചിക്കപ്പെട്ട തരങ്ങൾ മുതലായവ ഉണ്ടായിരിക്കാം, അതിനാൽ ഒരു സാധാരണ രീതിയിൽ നമുക്ക് അറേ എന്ന് വിളിക്കാം സമാന വസ്തുക്കളുടെ ശേഖരം.

അറേകളുടെ വലുപ്പം ഉറപ്പിച്ചിരിക്കുന്നു

ഒരു അറേ പ്രഖ്യാപിച്ചതിന് ശേഷം, ഞങ്ങൾക്ക് അറേയുടെ വലുപ്പം മാറ്റാൻ കഴിയില്ല. അതിനർത്ഥം ഞങ്ങൾക്ക് വലുപ്പം കുറയ്‌ക്കാനോ ഒരു അറേയുടെ വലുപ്പം കൂട്ടാനോ കഴിയില്ല.

ഒരു അറേയിലെ ഘടകങ്ങൾ മെമ്മറിയിൽ തുടർച്ചയായി അനുവദിക്കും

ഞങ്ങൾ ഒരു അറേ സൃഷ്ടിക്കുമ്പോൾ, ഒരു അറേയുടെ ഓരോ ഘടകങ്ങളും തുടർച്ചയായ മെമ്മറി സ്ഥാനങ്ങളിൽ അനുവദിക്കും.

തുടർച്ചയായ മെമ്മറി സ്ഥാനങ്ങൾ അർത്ഥമാക്കുന്നത് ഒരു അറേയുടെ ആദ്യ ഘടകത്തിന് തൊട്ടുപിന്നാലെ രണ്ടാമത്തെ ഘടകം മെമ്മറിയിൽ ഉണ്ടാകും എന്നാണ്. രണ്ടാമത്തെ ഘടകത്തിന് തൊട്ടുപിന്നാലെ, മൂന്നാമത്തെ ഘടകം ഉണ്ടാകും, അങ്ങനെ.

എല്ലാ ഘടകങ്ങളും മെമ്മറി ലൊക്കേഷനുകളിൽ പിന്നിലേക്ക് പിന്നിലേക്ക് അനുവദിക്കും.

ഒരു അറേയുടെ ആദ്യ ഘടകത്തിന് ഏറ്റവും കുറഞ്ഞ വിലാസവും അവസാന ഘടകത്തിന് ഏറ്റവും ഉയർന്ന വിലാസവും ഉണ്ടായിരിക്കും.

ഒരു അറേയിലെ ഘടകങ്ങൾ ഒരു സൂചിക ആക്സസ് ചെയ്യുന്നു

ഒരു അറേയിലെ ഘടകങ്ങൾ ഒരു സൂചിക ആക്സസ് ചെയ്യുന്നു. ആദ്യ ഘടകത്തിന് സൂചിക 0 ഉം രണ്ടാമത്തെ ഘടകത്തിന് സൂചിക 1 ഉം മൂന്നാമത്തേത് സൂചിക 2 ഉം മറ്റും ഉണ്ടാകും. അവസാന ഘടകത്തിന് സൂചിക (n-1) ഉണ്ടാകും, ഇവിടെ n എന്നത് ഒരു അറേയിലെ ഘടകങ്ങളുടെ എണ്ണം.

  • അറേ സമാന വസ്തുക്കളുടെ ശേഖരമാണോ?
  • അറേകളുടെ വലുപ്പം ഉറപ്പിച്ചിട്ടുണ്ടോ?
  • ഒരു അറേയിലെ ഘടകങ്ങൾ മെമ്മറിയിൽ തുടർച്ചയായി അനുവദിക്കുമോ?
  • ഒരു അറേയിലെ ഘടകങ്ങൾ ഒരു സൂചിക ആക്‌സസ്സുചെയ്യുന്നുണ്ടോ?

മുകളിലുള്ള എല്ലാ ചോദ്യങ്ങൾ‌ക്കും നിങ്ങൾ‌ അതെ എന്ന് പറഞ്ഞാൽ‌ ഒരു അറേയുടെ നിർ‌വ്വചനം ആയിരിക്കും

ഒരു സൂചിക ആക്‌സസ്സുചെയ്യുന്ന തുടർച്ചയായി സംഭരിച്ച സമാന വസ്‌തുക്കളുടെ ഒരു നിശ്ചിത ശേഖരമാണ് അറേ

അറേ പ്രഖ്യാപനം

അറേകളുടെ പ്രഖ്യാപനം ഇനിപ്പറയുന്ന വാക്യഘടന ഉപയോഗിക്കുന്നു:

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];

നിങ്ങൾ ഒരു അറേ പ്രഖ്യാപിക്കുമ്പോൾ മെമ്മറിയുടെ വിഹിതം സ്റ്റാക്ക് മെമ്മറിയിൽ സംഭവിക്കുന്നു. അറേയ്ക്കുള്ള മെമ്മറി ലേ layout ട്ട് തുടർച്ചയാണ്. അറേയുടെ ഐഡന്റിഫയർ (അതിന്റെ “പേര്”) മെമ്മറിയിലെ അറേയുടെ ആരംഭ വിലാസമാണ്. അറേ ഇരട്ട myDoubleArray [5] ന്റെ മെമ്മറി ലേ layout ട്ട് ഇനിപ്പറയുന്ന ചിത്രത്തിലൂടെ പ്രദർശിപ്പിക്കാൻ കഴിയും

അറേയുടെ ഓരോ “സെല്ലിനും” ഇരട്ടി വലുപ്പമുണ്ട്. അറേയുടെ സംഖ്യ 0 ൽ ആരംഭിച്ച് മൂലകങ്ങളുടെ എണ്ണത്തിൽ അവസാനിക്കുന്നു - 1.
പ്രഖ്യാപിത അറേ ഉപയോഗിക്കുന്നതിന് നിങ്ങൾ അത് സമാരംഭിക്കണം.

അറേ സമാരംഭിക്കൽ

ഒരു അറേ സമാരംഭിക്കുന്നതിന് നിരവധി മാർഗങ്ങളുണ്ട്:

    1. ചതുര ബ്രാക്കറ്റുകളിൽ ഒരു പ്രസ്താവന ഉപയോഗിക്കുന്നതിലൂടെ:

int anotherIntArray[3] = { 1, 2, 5, 7 };
    1. ഈ രീതിയിൽ നിങ്ങൾ ഒരു അറേ സമാരംഭിക്കുകയാണെങ്കിൽ, ഡിക്ലറേഷനിൽ നിങ്ങൾക്ക് അറേയുടെ വലുപ്പം ഒഴിവാക്കാനാകും:

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

ഘടകങ്ങളുടെ എണ്ണം അനുസരിച്ച് അറേയുടെ വലുപ്പം യാന്ത്രികമായി സജ്ജമാക്കും. ഈ ശ്രേണി വലുപ്പം 4 ആയിരിക്കും.

അറേയുടെ ഘടകങ്ങൾ ആക്‌സസ്സുചെയ്യുന്നു

അറേയിലെ ഘടകങ്ങൾ നേരിട്ട് ആക്സസ് ചെയ്യുന്നു. ഘടകങ്ങൾ ആക്സസ് ചെയ്യുന്നതിന് അറേയുടെ സൂചികകൾ ഉപയോഗിച്ച് ഇത് ചെയ്യാൻ കഴിയും.

നിങ്ങൾ അറേയ്‌ക്കൊപ്പം പ്രവർത്തിക്കേണ്ടിവരുമ്പോൾ, നിങ്ങൾ അറേയുടെ ഘടകങ്ങൾ ആക്‌സസ് ചെയ്യേണ്ടതുണ്ട്. അറേയുടെ പേരിനൊപ്പം ബ്രാക്കറ്റുകളിലെ ഘടകത്തിന്റെ സൂചിക ഉപയോഗിച്ച് ഇത് ചെയ്യാൻ കഴിയും. അറേയിലെ മൂലകത്തിന്റെ സ്ഥാനമാണ് സൂചിക. മറ്റൊരു വിധത്തിൽ പറഞ്ഞാൽ, അറേയുടെ ആരംഭവുമായി ബന്ധപ്പെട്ട മൂലകത്തിന്റെ ഓഫ്സെറ്റാണ് സൂചിക. അറേയിലെ മൂലകങ്ങളുടെ സംഖ്യ 0 ൽ ആരംഭിക്കുന്നു, അതിനാൽ ഒരു അറേയുടെ ആദ്യ ഘടകത്തിന് സൂചിക 0 ഉണ്ട്. ഇരട്ട തരം 5 ഘടകങ്ങളുടെ ഒരു അറേയുടെ മെമ്മറി ലേ layout ട്ടിന്റെയും സൂചികകളുടെയും ഉദാഹരണം ഇതാ:

ഒരു അറേയിലെ ഘടകങ്ങൾ ഒരു ലൂപ്പിൽ ആക്സസ് ചെയ്യുന്നതിനുള്ള ഒരു ഉദാഹരണമാണിത്:

//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 ഉപയോഗിച്ച് ഘടകത്തിലേക്ക് പ്രവേശിക്കുന്നു. Output ട്ട്‌പുട്ട് നോക്കുക:

സൂചിക 0 ഉള്ള ഘടകം 1 ആണ്
സൂചിക 1 ഉള്ള ഘടകം 2 ആണ്
സൂചിക 2 ഉള്ള ഘടകം 5 ആണ്
സൂചിക 3 ഉള്ള ഘടകം 7 ആണ്

ഒരു സൂചികയ്ക്കായി നിങ്ങൾക്ക് ഒരു നെഗറ്റീവ് നമ്പർ ഉപയോഗിക്കാൻ കഴിയില്ല. കൂടാതെ, അറേയുടെ വലുപ്പത്തേക്കാൾ കൂടുതലുള്ള സൂചിക നിങ്ങൾക്ക് ഉപയോഗിക്കാൻ കഴിയില്ല - 1. നിങ്ങൾ അത് ചെയ്യാൻ ശ്രമിച്ചാൽ നിങ്ങളുടെ അറേയ്ക്ക് സമീപമുള്ള മെമ്മറിയുടെ ഒരു ഭാഗം ആക്സസ് ചെയ്യും. ഇതിന് നിങ്ങളുടെ പ്രോഗ്രാമിനായി തികച്ചും മാരകമായ ഫലങ്ങൾ നൽകാൻ കഴിയും.

ഒരു പ്രവർത്തനത്തിലേക്ക് അറേ കടന്നുപോകുന്നു

നിങ്ങളുടെ ശ്രേണി ഒരു ഫംഗ്ഷനിലേക്ക് കൈമാറാൻ കഴിയും. ഒരു ഫംഗ്ഷനിലേക്ക് ഒരു അറേ കൈമാറാൻ നിങ്ങൾ അത് പാരാമീറ്റർ ലിസ്റ്റിലേക്ക് ചേർക്കേണ്ടതുണ്ട്. ഒരു ശ്രേണിയെ ആർഗ്യുമെൻറായി എടുക്കുന്ന ഫംഗ്ഷന്റെ ലളിതമായ ഉദാഹരണമാണിത്:

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

പാരാമീറ്ററുകൾ ഉപയോഗിച്ച് ഈ ഫംഗ്ഷനെ വിളിക്കാൻ നിങ്ങളുടെ അറേ ഒരു ലളിതമായ പാരാമീറ്ററായി നൽകുക:
passArray(anotherIntArray, 4);

ഒരു ഫംഗ്ഷനിൽ നിന്ന് അറേയിലേക്ക് മടങ്ങുക

ഒരു ഫംഗ്ഷനിൽ നിന്ന് ഒരു അറേ മടക്കിനൽകാനുള്ള സാധ്യതയുണ്ട്. പോയിന്ററുകൾ ഉപയോഗിച്ചാണ് ഇത് ചെയ്യുന്നത് പ്രവർത്തനത്തിൽ നിന്ന് അറേയിലേക്ക് പോയിന്റർ മടങ്ങുക.

മൾട്ടി-ഡൈമെൻഷണൽ അറേ

മൾട്ടി-ഡൈമെൻഷണൽ അറേ സൃഷ്ടിക്കാൻ സി ++ നിങ്ങളെ അനുവദിക്കുന്നു. അറേകളുള്ള ഘടകങ്ങളുള്ള ഒരു അറേയാണ് മൾട്ടി-ഡൈമെൻഷണൽ അറേ. മൾട്ടി-ഡൈമെൻഷണൽ അറേയുടെ ലളിതമായ ഉദാഹരണം ഒരു മാട്രിക്സിനെ പ്രതിനിധീകരിക്കുന്ന 2 ഡൈമൻഷണൽ അറേയാണ്. ഈ അറേ ഘടകങ്ങളിൽ 1 ഡൈമൻഷണൽ അറേ ഉണ്ട്. മൾട്ടി-ഡൈമെൻഷണൽ അറേയുടെ പ്രഖ്യാപനത്തിനായി നിങ്ങൾ ഇനിപ്പറയുന്ന വാക്യഘടന ഉപയോഗിക്കേണ്ടതുണ്ട്:

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

ഇത് N ഡൈമൻഷണൽ അറേയുടെ പ്രഖ്യാപനമാണ്. അടിസ്ഥാനപരമായി നിങ്ങളുടെ പ്രോഗ്രാമുകളിൽ 2 അല്ലെങ്കിൽ 3 ഡൈമൻഷണൽ അറേകൾ ഉപയോഗിക്കും.

2 ഡി അറേകൾ

2 ഡി അറേകൾ മാട്രിക്സിനെ പ്രതിനിധീകരിക്കുന്നു. അറേയിലെ ഏത് ഘടകത്തിനും, ചതുര ബ്രാക്കറ്റുകളിലെ ആദ്യ സൂചിക വരികളുടെ എണ്ണവും രണ്ടാമത്തെ സൂചിക ആ മൂലകത്തിന്റെ നിരകളുടെ എണ്ണവുമാണ്. ഇനിപ്പറയുന്ന രീതിയിൽ നിങ്ങൾക്ക് ഒരു 2 ഡി അറേ പ്രഖ്യാപിക്കാൻ കഴിയും:

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

ഈ പ്രഖ്യാപനം അർത്ഥമാക്കുന്നത് നിങ്ങൾ 3 വരികളും 2 നിരകളും ഉള്ള ഒരു അറേ പ്രഖ്യാപിക്കുന്നു എന്നാണ്. നിങ്ങൾക്ക് ഈ ശ്രേണി ഇനിപ്പറയുന്ന രീതിയിൽ സങ്കൽപ്പിക്കാൻ കഴിയും:

ഇത് ഒരു 2 ഡി അറേ ആണെങ്കിലും, മുകളിലുള്ള ഈ അറേയുടെ മെമ്മറി ലേ layout ട്ട് തുടർച്ചയായിരിക്കും:

2 ഡൈമൻഷണൽ അറേ ആക്സസ് ചെയ്യുന്നതിനുള്ള ഒരു ഉദാഹരണം ഇതാ:

//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;

2 ഡി അറേ പ്രദർശിപ്പിക്കുന്നതിനുള്ള: ട്ട്‌പുട്ട്:

0 1
1 2
2 3

3D അറേ

3 സൂചികകളുള്ള ഒരു അറേയാണ് 3D അറേ:

//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;

എല്ലാ അറേകളിലേയും പോലെ 3 ഡി അറേകൾക്കുള്ള മെമ്മറി ലേ layout ട്ട് തുടർച്ചയാണ്.

നിങ്ങൾക്ക് ഈ ശ്രേണി ഇനിപ്പറയുന്ന രീതിയിൽ അച്ചടിക്കാൻ കഴിയും:

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 അറേയ്ക്കുള്ള output ട്ട്‌പുട്ട് ഇതാണ്:

പേജ് #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 അറേ 2 ഡി അറേകളുടെ ഒരു നിരയാണ്.