C++: ஒரு பரிமாண அணி

ஒரு பரிமாண அணி 

இது ஒரு எளிய வடிவிலான அணி ஆகும். ஒரு பரிமாண அணியில் மதிப்புகள் ஒரே வரிசை அல்லது ஒரே நெடுவரிசையில் சேமிக்கப்படும். 

அணியை அறிவித்தலுக்கான தொடரியல்: 

<data types> <array-name> [<array - size>]; 

Data- type அணியின் தரவுவகையை குறிக்கும், அதாவது அணியிலுள்ள ஒவ்வொரு உறுப்பின் தரவு வகையாகும். 

Array-name அணியின் பெயரை குறிக்கும், அணியை அணுக இந்த பெயரே உதவும். 

Array-size அணியின் அளவை குறிப்பதற்கு பயன்படுகிறது. அணியின் அளவு எப்பொழுதும் [ ] என்ற அடைப்புக் குறிகளுக்குள் கொடுக்கப்படல் வேண்டும்.

எடுத்துக்காட்டு: 

int num [10]; 

மேலே அறிவிக்கப்பட்டுள்ள "num” என்ற அணியானது 10 முழு எண் மதிப்புகளை சேமிக்கும் அணியாகும். (முழு எண் தரவு வகையைச் சார்ந்த 10 பல்வேறு மதிப்புகளை நினைவகத்தில் சேமிக்கலாம்). 

கீழே உள்ள படத்தில் உள்ளதுபோல, இந்த அறிவிப்புக்கு "num" என்ற பொதுப் பெயரில் நிரல்பெயர்ப்பி 10 நினைவக இடங்களை (பெட்டிகள்) ஒதுக்கும். 

ஒவ்வொரு உறுப்புக்கும் நினைவக பெட்டி) தனித்தன்மையுடைய சுட்டு எண் 0 - விலிருந்து தொடங்கும், இந்த எண் "கீழொட்டு" என்றழைக்கப்படும். கீழொட்டு எப்பொழுதும் 0 என்ற எண்ணிலிருந்து தொடங்கும். மேலும் இது, குறியில்லா முழு எண்ணாக இருக்க வேண்டும்.

அணியின் ஒவ்வொரு உறுப்பும் அதன் பொது பெயருடன் கூடிய சதுர அடைப்புக் குறிகளுக்குள் கொடுக்கப்பட்டிருக்கும். கீழொட்டு மதிப்பை கொண்டு குறிக்கப்படும். எடுத்துக்காட்டாக num [3] என்பது num என்ற அணியின் நான்காவது உறுப்பைச் சுட்டும். 

பல்வேறு தரவின வகையுடன் மேலும் பல அணிகளின் அறிவிப்புகள்: char emp_name[ 25]; // emp-name Tom 31600f| 25 உறுப்புகளை கொண்ட குறியுரு அணியாகும். 

float salary[20];// salary 6T60 3160001 20 தசமபுள்ளி உறுப்புகளை கொண்ட அணியாகும். 

int a [5] , b[10], c[15]; // int தரவின் வகையில் அமைந்த ஒன்றுக்கு மேற்பட்ட அணிகளின் அறிவிப்பு ஆகும். 

ஒரு பரிமாண அணியின் நினைவக ஒதுக்கீடு

ஒரு அணியின் நினைவக ஒதுக்கீடானது அதன் அளவு மற்றும் அதன் தரவுவகைக்கு நேரடியாக தொடர்புடையது.

கீழே கொடுக்கப்பட்டுள்ள படம் ஐந்து உறுப்புகளைக் கொண்ட அணியின் நினைவக ஒதுக்கீட்டை காட்டுகின்றது.

மேலே கொடுக்கப்பட்டுள்ள படத்தில், num என்ற அணியானது 5 உறுப்புகளைக் கொண்ட முழு எண் அணி என்பது காட்டப்பட்டுள்ளது. Dev - C++ நிரல் பெயர்ப்பியானது, ஒவ்வொரு int தரவுவகை மாறிக்கும் 4 பைட்டுகள் (bytes) நினைவகத்தை ஒதுக்கீடு செய்யும். 5 உறுப்புகளை கொண்ட இவ்வணிக்கு, ஒவ்வொரு உறுப்புக்கும் 4 பைட்டுகள் விதம் மொத்தமாக 20 பைட்டுகள் ஒதுக்கப்படும்.

அணியின் நினைவக ஒதுக்கீட்டை கணக்கிட பயன்படும் வாய்ப்பாடு 

அணியின் தரவினத்துக்கு ஒதுக்கப்படும் பைட்டுகளின் எண்ணிக்கை × உறுப்புகளின் எண்ணிக்கை. 

தொடக்க மதிப்பிருத்தல்

ஒரு அணியை அறிவிக்கும் பொழுதே அதற்கு உரிய தொடக்க மதிப்பை இருத்தலாம். அவ்வாறு அணிக்கு உரிய தொடக்க மதிப்பை இருத்தவில்லையெனில் அதன் உறுப்புகள் தேவையற்ற மதிப்புகளைக் (garbage values) கொண்டிருக்கும். 

அணிக்கு தொடக்க மதிப்பு இருத்தலுக்கான தொடரியல் : 

<data type> <array name> [size] = {value 1, value-2..... value - n}; 

எடுத்துக்காட்டு 

int age [5] = { 19,21,16,1,50};

மேற்கண்ட எடுத்துக்காட்டில் ‘age' என்ற அணியின் அளவானது 5 ஆகும். இதில் முதல் உறுப்பு age[0]ல் 19 என்ற எண் சேமிக்கப்பட்டிருக்கும், உறுப்பு age[1]ல் 21 என்ற எண் சேமிக்கப்பட்டிருக்கும், இது போல மற்ற உறுப்புகளிலும் கொடுக்கப்பட்டுள்ள எண்கள் சேமிக்கப்பட்டிருக்கும். (பார்க்க படம் 12.1)

ஒரு அணியை அறிவிக்கும்ப போதே உறுப்புகளுக்கு தொடக்க மதிப்பு இருத்த வேண்டுமெனில், தொடக்க மதிப்புகள் கொக்கி வடிவ { } அடைப்புக்குறிக்குள் கொடுக்கப்படல் வேண்டும். 

அணியை அறிவிக்கும் போதே தொடக்க மதிப்பு இருத்தப்படுமாயின் அணியின் அளவை கொடுப்பது அவசியமில்லை.

எடுத்துக்காட்டு 

int age[ ] = {19, 21,16,1,50};

மேலே குறிப்பிட்டுள்ள எடுத்துக்காட்டில் தொடக்க மதிப்புடன் அணியை அறிவிக்கும்போது அணியின் அளவானது நேரடியாக கொடுக்கப்படவில்லை. ஆனால் நிரல்பெயர்ப்பி தானாகவே அணியில் இருத்தப்பட்ட மதிப்புகளின் எண்ணிக்கையைக் கொண்டு அணியின் அளவை கணக்கிடும். அணியின் அளவு 5 என எடுத்துக்கொள்ளப்படும் அணிக்கு

தொடக்க மதிப்பிருத்தலுக்கான வேறு சில எடுத்துக்காட்டுகள்: 

float x[5] = {5.6,5.7,5.8,5.9,6.1}; 

char vowel [6] = {'a', 'e', 'i' ,'o' ,'u', '\0'};

நிரலை இயக்கும்போது அணிக்குறிய மதிப்புகளை உள்ளீடு செய்தல்:

நிரலின் இயக்க நேரத்தில் அணிக்கு ஒரு மதிப்பை மட்டுமே உள்ளீடு செய்ய முடியும். ஒன்றிற்க்கு மேற்பட்ட மதிப்புகளை உள்ளீடு செய்ய வேண்டுமெனில் ஏதேனும் ஒரு மடக்கைப் பயன்படுத்தலாம். for மடக்கானது அணியின் உறுப்புகளுக்கு மதிப்பைப் பெற சிறந்த மடக்கு வகையாகும்.

// நிரல் இயக்க நேரத்தில் மதிப்புகளை உள்ளீடாக பெறுதல்

#include <iostream>

using namespace std;

int main()

{

      int num[5];

      for(int i=0; i<5; i++)

      {

           cout<< "\n Enter value " << i+1 << "= ";

           cin>>num[i];

      }

}

மேலே கொடுக்கப்பட்டுள்ள நிரலில் int num [5); என்பது 5 உறுப்புகளைக் கொண்ட ஒரு முழு எண் அணியாகும்.

இந்த for மடக்கு 5 முறை இயங்குமாறு வடிவமைக்கப்பட்டுள்ளது. ஒவ்வொரு முறையும் மடக்கு இயங்கும் போதே "Enter value” என்ற அறிக்கையை cout கூற்று வெளியிடும். மேலும் cin மூலம் உள்ளீடு மதிப்பு பெறப்பட்டு num [i] என்ற அணியில் சேமிக்கப்படும். 

பின்வரும் அட்டவணையானது மேற்கண்ட நிரல் குறிமுறை செயல்படும் விதத்தை காட்டுகிறது.

குறிப்பு : for மடக்கில் கட்டுப்பாட்டு மாறியை அறிவிக்கும்போது அதன் தொடக்க மதிப்பு 0 (பூஜ்ஜியம்) என்று இருத்தப்பட்டுள்ளது.

அணியின் உறுப்புகளின் மதிப்பை படிப்பதற்கோ அல்லது உறுப்புகளில் மதிப்பை சேமிப்பதற்கோ மடக்கினை அறிவிக்கும் போது மடக்கின் கட்டுப்பாட்டு மாறியின் தொடக்க மதிப்பானது 0 பூஜ்ஜியம்) என அறிவிக்க வேண்டும். ஏனெனில் பெரும்பாலான சமயங்களில் கட்டுப்பாட்டு மாறியின் மதிப்பு அணியின் கீழொட்டை குறிக்க பயன்படுத்தப்படும். 

அணியின் உறுப்புகளை அணுகுதல்

அணியின் உறுப்புகளை நிரலில் நாம் எங்கு வேண்டுமானாலும் சாதாரண மாறிகளைப் போல பயன்படுத்தலாம். அணியின் உறுப்புகளை அணுக அணியின் பெயருடன் சதுர அடைப்புக் குறிகளுக்குள் கீழொட்டின் மதிப்பை கொடுக்க வேண்டும்.

எடுத்துக்காட்டு 

cout << num [3]; 

இதில் num [3] என்ற கீழொட்டானது அணியின் 4வது உறுப்பை குறிக்கும். num[3] என்ற உறுப்பின் மதிப்பை cout கூற்று வெளியிடும்.

அடைப்பு குறிக்குள் கொடுக்கப்படும் கீழொட்டு ஒரு மாறியாகவோ, ஒரு மாறிலியாகவோ அல்லது ஒரு கோவையாகவோ இருக்கலாம். கோவையாக இருந்தால் அதன் விடையானது ஒரு முழு எண் மதிப்பாகத்தான் இருக்க வேண்டும்.

//அணியின் உறுப்புகளை அணுகுதல்

#include <iostream>

using namespace std;

int main()

{

      int num[5] = {10, 20, 30, 40, 50};

      int t=2;

      cout<<num[2] <<endl; // S1

      cout<<num[3+1] <<endl; // S2

      cout<<num[t=t+1]; // S3

}

output:

30

50

40

மேலே கொடுக்கப்பட்டுள்ள நிரலில், முதல் cout கூற்று num என்ற அணியின் 3வது உறுப்பின் மதிப்பை வெளியிடும் (கீழொட்டு சுட்டு 2) இரண்டாவது cout கூற்று அணியின் 5 வது உறுப்பின் மதிப்பை வெளியிடும் (கீழொட்டு மதிப்பு 3+1=4) மூன்றாவது cout கூற்று, 4-வது உறுப்பின் மதிப்பை வெளியிடும் (C++ மொழியானது சதுர அடைப்பு குறிக்குள் கொடுக்கப்பட்டுள்ள கோவையை t=2+1=3 என்று கணக்கிடும்.)

C++ மொழியில் 10 மதிப்புகளை உள்ளீடாக பெற்று அதில் ஒற்றை எண்களின் எண்ணிக்கை (odd numbers) மற்றும் இரட்டை எண்களின் எண்ணிக்கையை ( Even numbers) காண்பதற்கான நிரல்.

#include <iostream>

using namespace std;

int main()

{

      int age[4];//declaration of array

      cout<< "Enter the age of four persons:" <<endl;

      for(int i = 0; i < 4; i++)//loop to write array elements

      cin>> age[i];

      cout<<"The ages of four persons are:";

      for(int j = 0; j< 4; j++)

           cout<< age[j]<<endl;

}

வெளியீடு:

Enter Number 1= 78 

Enter Number 2= 51 

Enter Number 3= 32

Enter Number 4= 66

Enter Number 5= 41 

Enter Number 6= 68

Enter Number 7= 27 

Enter Number 8= 65 

Enter Number 9= 28 

Enter Number 10= 94

There are 6 Even Numbers

There are 4 Odd Numbers

(HOT மேலே கொடுக்கப்பட்டுள்ள நிரலை if கூற்றிற்கு பதிலாக நிபந்தனைச் செயற்குறியைப் பயன்படுத்தி எழுதவும்) 

ஒரு பரிமாண அணியில் தேடல்

கொடுக்கப்பட்ட எண்களின் தொகுப்பில் இருந்து ஒரு குறிப்பிட்ட மதிப்பை தேடும் செயல்முறை தேடல் என்றழைக்கப்படும். நேரியல் தேடல் (linear search) அல்லது தொடர் தேடல் ஆனது (Sequential search) தேடப்படும் மதிப்பை பட்டியலில் உள்ள உறுப்புகளின் மதிப்புடன் ஒப்பிட்டு அந்த மதிப்பை கண்டுபிடிக்கும்வரை அணியிலுள்ள அனைத்து உறுப்புகளுக்கும் பயணித்து ஒப்பிடும்.

நேரியல் தேடலுக்கான நிரல் 

#include <iostream> 

using namespace std; 

int main()

{

  int num[10], val, id=-1; 

  for (int i=0; i<10; i++)

  {

  cout<< "\n Enter value" <<i+1 <<"="'; 

  cin>>num[i];

  }

  cout<< "\n Enter a value to be searched: '';

  cin>>val; 

for (int i=0; i<size; i++)

{

  if (arr[i] == value) 

   { id=i;

     break;

   }

}

  if(id==-1) 

  cout<< "\n Given value is not found in the array.."; 

  else 

  cout<< "\n The value is found at the position" << id+1; 

  return 0;

}

மேலே கொடுக்கப்பட்டுள்ள நிரல் தேடப்படும் மதிப்பை பட்டியலில் உள்ள உறுப்புகளின் மதிப்புடன் ஒப்பிட்டு அந்த மதிப்பை கண்டுபிடிக்கும்வரை அணியிலுள்ள அனைத்து உறுப்புகளுக்கும் பயணித்து ஒப்பிடும். 

சரங்கள்

குறியுருக்களின் வரிசையை சரம் என்கின்றோம், இதில் குறியுரு என்பது ஒரு எழுத்து எண் அல்லது குறியீடாக இருக்கலாம் ஒவ்வொரு குறியுருவும் நினைவகத்தில் ஒரு பைட் அளவு இடம் எடுத்துக்கொள்ளும். ஒவ்வொரு சரமும் அதன் முடிவை குறிக்கும் வெற்றுக் குறியுருவைக் (null character-'\0', ASCII கோடு 0) கொண்டு முற்று பெற்றிருக்க வேண்டும். C++ மொழியில் சரத்திற்கென தனி தரவு வகை கிடையாது. அதற்கு பதிலாக ஒரு சரத்தை ஒரு பரிமாண குறியுரு அணியாக அறிவிக்கலாம். குறியுரு அணியை அறிவிக்கும் போது, அது வெற்றிடக் குறியுருவை இறுதியில் கொண்டிருக்க வேண்டும். எனவே குறியுரு அணியின் அளவானது சரத்தின் நீளத்தை விட ஒரு குறியுரு அதிகமாக இருக்குமாறு அமைக்க வேண்டும். 

குறியுறு அணி (சரம்) உருவாக்குதல்

ஒரு அணியை உருவாக்கும் முன் அதனுடைய அளவை (நீளம்) அறிந்திருத்தல் வேண்டும். ஏனெனில் நினைவகமானது அணியின் அளவிற்கு தகுந்தவாறு ஒதுக்கப்படும். அணியானது உருவாக்கப்பட்ட பின்பு அதன் நீளத்தை இயக்க நேரத்தில் மாற்றமுடியாது. (பார்க்க படம் 12.2).

குறியுரு அணியை தெரிவிப்பதற்கான தொடரியல்: 

char array- name [size];

மேலே கொடுக்கப்பட்டுள்ள தொடரியலில் அணியின் அளவு (Size) எப்பொழுதும் குறியில்லாத முழு எண் மதிப்பாக தான் இருக்க வேண்டும்.

எடுத்துக்காட்டு 

char country ( 6);

மேற்கண்ட எடுத்துக்காட்டில் குறியுருக்களின் வரிசையை சேமிப்பதற்கு நினைவகத்தில் 6 பைட்டுகள் ஒதுக்கப்படும். சரத்தின் நீளம் 5 குறியுருக்களுக்கு மேல் இருக்க முடியாது. மேலும் வெற்று குறியுருக்காக ஒரு இடம் சரத்தின் இறுதியில் ஒதுக்கப்படும்.

//குறியுரு அணியை விளக்கும் நிரல்

#include <iostream> 

using namespace std; 

int main()

{

char country[6];

      cout<< "Enter the name of the country: ''; 

      cin>>country; 

      cout<<" The name of the country is "<<country;

}

வெளியீடு: 

Enter country the name: INDIA

The country name is INDIA

தொடக்க மதிப்பிருத்தல்

குறியுறு அணியை அறிவிக்கும் போதே அதற்கு தொடக்கமதிப்பு இருத்தலாம். அதன் தொடரியல் கீழே கொடுக்கப்பட்டுள்ளது.

char arrayName[size] ={ list of characters separated by comma };

எடுத்துக்காட்டு 

char country[6]="INDIA”;

மேலே கொடுக்கப்பட்டுள்ள எடுத்துக்காட்டில் " INDIA" என்ற சரமானது 5 எழுத்துக்களை கொண்டுள்ளளது. இது country என்ற அணியில் தொடக்க மதிப்பாக இருத்தப்படுகிறது. உரையானது இரட்டை மேற்கோள் குறிகளுக்குள் கொடுக்கப்பட வேண்டும்.

மேற்கண்ட எடுத்துக்காட்டில் ஒவ்வொரு குறியுருவும் நினைவகத்தில் ஒரு பைட் எடுத்துக்கொள்ளும். சரத்தின் இறுதியில், நிரல்பெயர்ப்பி தானாகவே ஒரு வெற்று குறியுருவை அதன் இறுதியில் இணைத்துக்கொள்ளும்.

C++ மொழியில் குறியுரு அணிக்கு தொடக்க மதிப்பை இருத்துவதற்கான பல வழிகள் கீழே கொடுக்கப்பட்டுள்ளது. 

char country[6]={‘I’, ‘N’, ‘D’, ‘I’, ‘A’, ‘\0’};

char country[]=“INDIA”;

char country[]={‘I’, ‘N’, ‘D’, ‘I’, ‘A’, ‘\0’};

அணியின் அளவு வெளிப்படையாக அறிவிக்கப்படவில்லையெனில் நிரல்பெயர்ப்பி தாமாகவே அதன் அளவை அணியின் உறுப்புகளின் எண்ணிக்கைக்கு ஏற்ப நிர்ணயிக்கும்.

சரத்திற்கு தொடக்க மதிப்பிருத்தும் போது அனைத்து உறுப்புகளுக்கும் தொடக்க மதிப்பு இருத்தப்படவில்லையெனில், மதிப்பிருத்தப்படாத மீதமுள்ள நினைவக இடங்களுக்கு வெற்று மதிப்பானது (NULL) இருத்தப்படும். 

எடுத்துக்காட்டு 

char str[5]={'5','+','A'};

str[0]; ---> 5

str[1]; ---> +

str[2]; ---> A

str[3]; ---> NULL

str[4]; ---> NULL

குறிப்பு

சரங்களின் உறுப்புகளுக்கு தொடக்க மதிப்பிருத்தும்போது, அதன் அளவிற்கு அதிகமாக மதிப்புகளை இருத்தக்கூடாது.

எடுத்துக்காட்டு 

char str[2]=]'5','+','A','B'); // தவறானது

மேலே கொடுக்கப்பட்டுள்ள எடுத்துக்காட்டில், நிரல்பெயர்ப்பி “Initialize string for array of chars is too long” என்ற பிழை அறிக்கையை வெளியிடும்.

கொடுக்கப்படும் சொல்லானது palindrome சொல்லா என சோதிக்க C++ நிரல் எழுதுதல்.

#include<iostream>

using namespace std;

int main( )

{

      int i, j, len, flag =1;

      char a [20];

      cout<<"Enter a string:";

      cin>>a;

      for(len=0;a[len]!='\0';++len)

for(!=0,j=len-1;i<len/2;++i,--j)

      {

      if(a[j]!=a[i])

           flag=0;

      }

      if(flag==1)

           cout<<"\n The String is palindrome";

      else

           cout<<"\n The String is not palindrome";

      return 0;

}

வெளியீடு:

Enter a string : madam

The String is palindrome