ஒரு செயல்பாட்டிலிருந்து முழு எண் தரவு வகை. மாறிகள். போஸ்ட்ஃபிக்ஸ் வகை பதவி

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

C/C++ இல் உள்ள தரவு வகைகள் பிரிக்கப்பட்டுள்ளன அடிப்படைமற்றும் வழித்தோன்றல்கள்.
முக்கிய வகைகளில் பின்வருவன அடங்கும்:

1. வெற்றிடமானது(வெற்று வகை),
2. முழு எண்ணாக(முழு வகை),
3. மிதவை(உண்மையான மிதக்கும் புள்ளி எண்கள்),
4. இரட்டை(இரட்டை துல்லியமான மிதக்கும் புள்ளி உண்மையான எண்கள்),
5. கரி(எழுத்து வகை),
6. பூல்- தருக்க.

கூட்டு வகைகள்

பிற வகையான தரவுப் பயன்பாட்டை உருவாக்க அடிப்படைவகைகள் + என்று அழைக்கப்படும் குறிப்பான்கள். குறிப்பான்களைப் பயன்படுத்தி நிலையான வகைகளிலிருந்து உருவாக்கப்பட்ட தரவு வகைகள் அழைக்கப்படுகின்றன கூட்டு தரவு வகைகள். C++ நான்கு தரவு வகை குறிப்பான்களை வரையறுக்கிறது:

1. குறுகிய - குறுகிய;
2. நீண்ட - நீண்ட;
3. கையொப்பமிட்ட-கையொப்பமிட்ட;
4. கையொப்பமிடாத

பெறப்பட்ட வகைகள்:

• வரிசைகள்,
• செயல்பாடுகள்,
• வகுப்புகள்,
• அறிகுறிகள்,
• இணைப்புகள்,
• கட்டமைப்புகள்,
• சங்கங்கள்.

எழுத்து வகை

தரவு வகை கரிகணினி நினைவகத்தில் எப்போதும் 1 பைட் இருக்கும். 256 விசைப்பலகை எழுத்துகளில் ஏதேனும் ஒன்றைச் சேமிப்பதற்குத் தேவையான அளவு நினைவகத்தின் அளவு பொதுவாக ஒரு எழுத்து வகை மதிப்புக்கு ஒதுக்கப்படும் என்பதே இதற்குக் காரணம்.
எழுத்து வகை இருக்கலாம் ஒரு அடையாளத்துடன்அல்லது கையொப்பமிடாத.
கையொப்பமிடப்பட்ட அளவுகளில் கையொப்பமிட்ட கரி-128 முதல் 127 வரையிலான வரம்பில் நீங்கள் மதிப்புகளைச் சேமிக்கலாம். அதன்படி, மாறிகளின் மதிப்புகள் கையொப்பமிடாத கரி 0 முதல் 255 வரை இருக்கலாம்.

தரவு வகை	மதிப்புகளின் வரம்பு	அளவு
கரி	-128...+127	1 பைட்
கையொப்பமிடாத கரி	0...255	1 பைட்
கையொப்பமிட்ட கரி	-128...127	1 பைட்

எழுத்துத் தரவுகளுடன் பணிபுரியும் போது, ​​ஒரு வெளிப்பாடு இருந்தால் என்பதை நீங்கள் நினைவில் கொள்ள வேண்டும் ஒற்றை பாத்திரம், அது இணைக்கப்பட வேண்டும் ஒற்றை மேற்கோள்கள். எழுத்துகளின் வரிசை, அதாவது, ஒரு சரம், வெளிப்பாடுகளில் பயன்படுத்தப்படும் போது இரட்டை மேற்கோள்களில். உதாரணமாக: 'F', '3', "Ivan", "235"

முழு எண் வகை

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

முழு எண் மதிப்பு வரம்புகள்

தரவு வகை	மதிப்புகளின் வரம்பு	அளவு(பைட்டுகள்)
முழு எண்ணாக கையொப்பமிடப்பட்டது நீண்ட எண்ணாக கையொப்பமிடப்பட்டது	-2147483648 ... 2147483647	4
கையொப்பமிடப்படாத முழு எண்ணாக கையொப்பமிடப்படாத நீண்ட எண்ணாக	0 ... 4294967295	4
குறுகிய முழு எண்ணாக சிறிய எண்ணாக கையொப்பமிடப்பட்டது	-32768 ... 32767	2
கையொப்பமிடப்படாத குறுகிய எண்ணாக	0... 65535	2
நீண்ட நீண்ட எண்ணாக	\(-(2^{63}-1)...(2^{63}-1)\)	8
கையொப்பமிடாத நீண்ட நீண்ட எண்ணாக	\(0...(2^{64}-1)\)	8

உண்மையான வகை

கணினி நினைவகத்தில் உள்ள உண்மையான எண்ணின் உள் பிரதிநிதித்துவம் ஒரு முழு எண்ணின் பிரதிநிதித்துவத்திலிருந்து வேறுபட்டது. ஒரு மிதக்கும் புள்ளி எண் குறிப்பிடப்படுகிறது அதிவேக வடிவத்தில். $$\pm mE\pm p$$ எங்கே மீ- மாண்டிசா (தசம புள்ளியுடன் முழு எண் அல்லது பின்ன எண்), ஆர்- வரிசை (முழு எண்). ஒரு எண்ணை அதிவேக வடிவில் வழக்கமான நிலையான-புள்ளி குறியீடாக மாற்ற, நீங்கள் மான்டிசாவை பத்தால் வரிசையின் சக்திக்கு பெருக்க வேண்டும் எடுத்துக்காட்டாக: \(-6.42E+2=-6.42*10^(2)\ )

உண்மையான வகைகளின் மதிப்பு வரம்புகள்

தரவு வகை	மதிப்புகளின் வரம்பு	அளவு (பைட்டுகள்)
மிதவை	3.4E-38 ... 3.4E+38	4
இரட்டை	1.7E-308... 1.7E+308	8
நீண்ட இரட்டை	3.4E-4932 ... 3.4E+4932	10

மாண்டிசாவின் நீளம் எண்ணின் துல்லியத்தையும் அதன் வரம்பின் வரிசையின் நீளத்தையும் தீர்மானிக்கிறது.
ஃப்ளோட் தரவு 4 பைட்டுகளை எடுக்கும், அதில் 1 பைனரி பிட் குறிக்கு ஒதுக்கப்படுகிறது, 8 பிட்கள் எக்ஸ்போனெண்டிற்கு மற்றும் 23 மாண்டிசாவிற்கு. மன்டிசாவின் மிக முக்கியமான இலக்கமானது எப்போதும் 1 ஆக இருப்பதால், அது சேமிக்கப்படுவதில்லை.
இரட்டை வகையின் தரவு 8 பைட்டுகளை ஆக்கிரமித்துள்ளது, அவை முறையே வரிசைக்கு -11 பிட்கள் மற்றும் மாண்டிசாவிற்கு -52 பிட்கள் உள்ளன.
இரட்டை வகை பெயருக்கு முன் நீண்ட வகை குறிப்பான் மதிப்புக்கு 10 பைட்டுகள் ஒதுக்கப்பட்டதைக் குறிக்கிறது.

பூலியன் வகை

வகை மாறி பூல்இரண்டு மதிப்புகளை மட்டுமே எடுக்க முடியும் உண்மை(உண்மை) அல்லது பொய்(பொய்). பூஜ்ஜியம் அல்லாத எந்த மதிப்பும் சரி என விளக்கப்படுகிறது, மேலும் முழு எண் வகைக்கு மாற்றப்படும் போது அது 1 ஆக மாறும். தவறான மதிப்பு நினைவகத்தில் 0 ஆக குறிப்பிடப்படுகிறது.

வெற்றிடத்தை தட்டச்சு செய்யவும்

இந்த வகையின் மதிப்பு தொகுப்பு காலியாக உள்ளது.
வெற்றிட வகை இதற்குப் பயன்படுத்தப்படுகிறது:

• மதிப்பைத் தராத செயல்பாடுகளின் வரையறைகள்;
• செயல்பாட்டு வாதங்களின் வெற்று பட்டியலைக் குறிப்பிட;
• சுட்டிகளுக்கான அடிப்படை வகையாக;
• வகை மாற்றும் செயல்பாட்டில்.

மாறிகளை அறிவித்தல்

மாறிஒரு குறிப்பிட்ட வகையின் மதிப்பை சேமிக்கும் நினைவகத்தின் பெயரிடப்பட்ட பகுதி.
மாறி உள்ளது பெயர்(அடையாளங்காட்டி) மற்றும் பொருள்.
பெயர்மதிப்பு சேமிக்கப்பட்டுள்ள நினைவக பகுதியை அணுக உதவுகிறது.
பெயர்(அடையாளங்காட்டி) என்பது ஒரு மாறியின் பெயர், ஒரு செயல்பாட்டின் பெயர் அல்லது ஒரு நிரலில் ஒரு முக்கிய சொல்லைக் குறிப்பிடும் எழுத்துக்கள், எண்கள் மற்றும் அடிக்கோடுகளின் தொகுப்பாகும். C/C++ மொழி வழக்கு உணர்திறன் கொண்டது (அதாவது தொகை மற்றும் தொகை இரண்டு வெவ்வேறு மாறிகளாகக் கருதப்படும்).
எங்கே, வகை- ஒரு மாறியின் மதிப்பை (நிரல் பொருளாக), (int – integer, float, double – real, char – symbolic, bool – logical) சேமிப்பதற்காக ஒதுக்கப்பட்ட நினைவகத்தின் அளவை (பைட்டுகளின் எண்ணிக்கை) வரையறுக்கும் முக்கிய சொல்;
பெயர் – தனித்துவமான அடையாளங்காட்டிகணினி நினைவகத்தில் நிரல் பொருளின் குறியீட்டு முகவரியைக் குறிப்பிடும் ஒரு மாறி;
துவக்குபவர்- மாறியின் ஆரம்ப மதிப்பு, இது விளக்கத்தில் இல்லாமல் இருக்கலாம்.
எடுத்துக்காட்டாக: ஒரே வகையின் மாறிகளை "" என்று பிரிப்பதன் மூலம் குழுவாக்கலாம். மாறிகளின் விளக்கம் பல்வேறு வகையானஆல் பிரிக்கப்பட்டது "; "
அவை அறிவிக்கப்படும் இடத்தைப் பொறுத்து, C/C++ மொழியில் உள்ள மாறிகளை மூன்று வகுப்புகளாகப் பிரிக்கலாம்:

1. உள்ளூர் - ஒரு செயல்பாட்டிற்குள் அறிவிக்கப்பட்டது மற்றும் அதில் மட்டுமே கிடைக்கும்;
2. உலகளாவிய - அனைத்து செயல்பாடுகளுக்கும் முன் விவரிக்கப்பட்டது மற்றும் நிரலில் எங்கிருந்தும் அணுகலாம்;
3. செயல்பாடுகளின் முறையான அளவுருக்கள் செயல்பாட்டு அளவுருக்களின் பட்டியலில் விவரிக்கப்பட்டுள்ளன.

உதாரணமாக:

முழு எண் வகை (int)

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

16-பிட் செயலிக்கு, இந்த வகை மதிப்புகளுக்கு 2 பைட்டுகள் ஒதுக்கப்படுகின்றன,

32-பிட் - 4 பைட்டுகளுக்கு.

குறிப்பான் குறுகியப்ராசஸர் பிட் ஆழத்தைப் பொருட்படுத்தாமல், எண்ணுக்கு 2 பைட்டுகள் ஒதுக்கப்பட வேண்டும் என்று வகைப் பெயருக்கு முன் கம்பைலர் குறிப்பிடுகிறது.

குறிப்பான் நீளமானதுமுழு எண் மதிப்பு 4 பைட்டுகளை ஆக்கிரமிக்கும் என்று அர்த்தம்.

எனவே 16-பிட் கணினியில் int மற்றும் short int க்கு சமமானவை

மற்றும் 32-பிட் - int மற்றும் நீண்ட எண்ணில்.

உள் பிரதிநிதித்துவம்முழு எண் வகையின் மதிப்புகள் - பைனரி குறியீட்டில் ஒரு முழு எண். குறிப்பானைப் பயன்படுத்தும் போது கையெழுத்திட்டார்எண்ணின் மிக முக்கியமான பிட் கையொப்பமிடப்பட்ட ஒன்றாக விளக்கப்படுகிறது (0 என்பது நேர்மறை எண், 1 என்பது எதிர்மறை எண்). குறிப்பான் கையொப்பமிடாதஎண்ணின் குறியீட்டின் ஒரு பகுதியாக மிகவும் குறிப்பிடத்தக்க பிட் கருதப்படுவதால், நேர்மறை எண்களை மட்டுமே குறிப்பிட அனுமதிக்கிறது. எனவே, முழு எண் மதிப்புகளின் வரம்பு குறிப்பான்களைப் பொறுத்தது. IBM PC-இணக்கமான கணினிகளுக்கான பல்வேறு குறிப்பான்களுடன் கூடிய முழு எண் வகை மதிப்புகளின் மதிப்புகளின் வரம்புகள் "எளிய தரவு வகைகளின் மதிப்பு வரம்புகள்" அட்டவணையில் கொடுக்கப்பட்டுள்ளன.

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

ஒரு நிரலில் காணப்படும் மாறிலிகள் அவற்றின் வகைக்கு ஏற்ப ஒரு வகை அல்லது மற்றொரு வகை ஒதுக்கப்படும். சில காரணங்களால் இது புரோகிராமருக்குப் பொருந்தவில்லை என்றால், L, l (நீளம்) மற்றும் U, u (கையொப்பமிடப்படாதது) பின்னொட்டுகளைப் பயன்படுத்தி தேவையான வகையை நீங்கள் வெளிப்படையாகக் குறிப்பிடலாம். எடுத்துக்காட்டாக, மாறிலி 32L வகை நீளமானது மற்றும் 4 பைட்டுகளை ஆக்கிரமிக்கும். நீங்கள் L மற்றும் U பின்னொட்டுகளை ஒரே நேரத்தில் பயன்படுத்தலாம், எடுத்துக்காட்டாக, 0x22UL அல்லது 05Lu.

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

எழுத்து வகை (கரி)

ஒரு எழுத்து வகையின் மதிப்பு, கொடுக்கப்பட்ட கணினிக்கான எழுத்துத் தொகுப்பிலிருந்து எந்த எழுத்தையும் இடமளிக்கப் போதுமான பல பைட்டுகள் ஒதுக்கப்பட்டுள்ளது, இது வகையின் பெயரைத் தீர்மானிக்கிறது. பொதுவாக இது 1 பைட் ஆகும். மற்ற முழு எண் வகைகளைப் போலவே சார் வகையும் கையொப்பமிடப்படலாம் அல்லது கையொப்பமிடப்படாமல் இருக்கலாம். கையொப்பமிடப்பட்ட மதிப்புகள் -128 முதல் 127 வரையிலான வரம்பில் மதிப்புகளைச் சேமிக்கலாம். கையொப்பமிடப்படாத குறிப்பீட்டைப் பயன்படுத்தி, மதிப்புகள் 0 முதல் 255 வரை இருக்கலாம். 256-எழுத்துகள் கொண்ட ASCII எழுத்துத் தொகுப்பில் எந்த எழுத்தையும் சேமிக்க இது போதுமானது. கரி வகையின் மதிப்புகள் முழு எண்களை சேமிக்கவும் பயன்படுத்தப்படுகின்றன.

விரிவாக்கப்பட்ட எழுத்து வகை (wchar_t)

வகை wchar_tகுறியாக்கம் செய்ய 1 பைட் போதுமானதாக இல்லாத எழுத்துகளின் தொகுப்புடன் வேலை செய்ய வடிவமைக்கப்பட்டுள்ளது. உதாரணமாக, யூனிகோட். இந்த வகையின் அளவு செயல்படுத்தல் சார்ந்தது; ஒரு விதியாக, இது வகைக்கு ஒத்திருக்கிறது குறுகிய. Wchar_t வகையின் சர மாறிலிகள் L முன்னொட்டுடன் எழுதப்படுகின்றன, எடுத்துக்காட்டாக, L“கேட்ஸ்”.

பூலியன் வகை (பூல்)

பூலியன் மதிப்புகள் மதிப்புகளை மட்டுமே எடுக்க முடியும் உண்மைமற்றும் பொய், ஒதுக்கப்பட்ட சொற்கள். தவறான மதிப்பைக் குறிக்கும் உள் வடிவம் 0 (பூஜ்ஜியம்) ஆகும். வேறு எந்த மதிப்பும் உண்மை என விளக்கப்படுகிறது. முழு எண் வகைக்கு மாற்றும் போது உண்மைமதிப்பு 1 உள்ளது.

மிதக்கும் புள்ளி வகைகள் (மிதவை, இரட்டை மற்றும் நீண்ட இரட்டை)

C++ தரநிலையானது உண்மையான மதிப்புகளை சேமிப்பதற்கான மூன்று தரவு வகைகளை வரையறுக்கிறது: மிதவை, இரட்டை மற்றும் நீண்ட இரட்டை.

முழு எண் தரவு வகைகளை விட மிதக்கும் புள்ளி தரவு வகைகள் நினைவகத்தில் வித்தியாசமாக சேமிக்கப்படுகின்றன. உண்மையான எண்ணின் உள் பிரதிநிதித்துவம் இரண்டு பகுதிகளைக் கொண்டுள்ளது - மாண்டிசாமற்றும் உத்தரவு.

IBM PC-இணக்கமான கணினிகளில், வகையின் மதிப்புகள் மிதவை 4 பைட்டுகளை ஆக்கிரமித்து, அதில் ஒரு பைனரி இலக்கம் ஒதுக்கப்பட்டுள்ளது மாண்டிசாவின் அடையாளத்தின் கீழ், 8 இலக்கங்கள் ஆணைப்படிமற்றும் 23 மன்டிசாவின் கீழ். மன்டிசா என்பது 1.0 ஐ விட பெரிய எண் ஆனால் 2.0 க்கு குறைவானது.மாண்டிசாவின் முன்னணி இலக்கம் எப்போதும் 1 ஆக இருப்பதால், அது சேமிக்கப்படாது.

வகையின் அளவுகளுக்கு இரட்டை, 8 பைட்டுகளை ஆக்கிரமித்து, 11 மற்றும் 52 பிட்கள் முறையே ஆர்டர் மற்றும் மன்டிசாவுக்கு ஒதுக்கப்படுகின்றன. மாண்டிசாவின் நீளம் எண்ணின் துல்லியத்தை தீர்மானிக்கிறது, மேலும் அடுக்கு நீளம் அதன் வரம்பை தீர்மானிக்கிறது.உள்ளீட்டின் முடிவில் உள்ள அட்டவணையில் இருந்து நீங்கள் பார்க்க முடியும், மிதவை மற்றும் நீண்ட எண்ணுக்கு ஒதுக்கப்பட்ட அதே எண்ணிக்கையிலான பைட்டுகள், அவற்றின் அனுமதிக்கப்பட்ட மதிப்புகளின் வரம்புகள் பெரிதும் வேறுபடுகின்றன. உள் பிரதிநிதித்துவ வடிவம் காரணமாக.

குறிப்பான் நீளமானதுவகை பெயருக்கு முன் இரட்டைஅதன் மதிப்புக்கு 10 பைட்டுகள் ஒதுக்கப்பட்டுள்ளன என்பதைக் குறிக்கிறது.

மிதக்கும் புள்ளி மாறிலிகள் முன்னிருப்பாக இரட்டை வகையாகும். F, f (float) மற்றும் L, l (நீளம்) பின்னொட்டுகளைப் பயன்படுத்தி மாறிலியின் வகையை நீங்கள் வெளிப்படையாகக் குறிப்பிடலாம்.

எடுத்துக்காட்டாக, மாறிலி 2E+6L நீண்ட இரட்டிப்பாகவும், மாறிலி 1.82f மிதவை வகையாகவும் இருக்கும்.

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

உதாரணமாக, க்கான இயக்க முறைமை MS-DOS sizeof (int) 2ஐக் கொடுக்கும், ஆனால் Windows 98 அல்லது OS/2 க்கு 4 ஆக இருக்கும்.

ANSI தரமானது அடிப்படை வகைகளுக்கான மதிப்பு வரம்புகளைக் குறிப்பிடவில்லை; அவற்றின் அளவுகளுக்கு இடையிலான உறவுகள் மட்டுமே வரையறுக்கப்படுகின்றன, எடுத்துக்காட்டாக:

அளவு(மிதவை) ≤ slzeof(இரட்டை) ≤ அளவு(நீண்ட இரட்டை)
sizeof(char) ≤ slzeof(short) ≤ sizeof(int) ≤ sizeof(long)

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

வகை வெற்றிடம்

பட்டியலிடப்பட்டவற்றைத் தவிர, மொழியின் முக்கிய வகைகளில் வெற்றிட வகை அடங்கும், ஆனால் இந்த வகையின் மதிப்புகளின் தொகுப்பு காலியாக உள்ளது. மதிப்பை வழங்காத செயல்பாடுகளை வரையறுக்கவும், செயல்பாட்டு வாதங்களின் வெற்று பட்டியலைக் குறிப்பிடவும், சுட்டிகளுக்கான அடிப்படை வகையாகவும், வகை வார்ப்பு செயல்பாடுகளிலும் இது பயன்படுத்தப்படுகிறது.

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

வகை	மதிப்புகளின் வரம்பு	அளவு (பைட்)
பூல்	உண்மை மற்றும் பொய்
கையொப்பமிட்ட கரி	-128 … 127
கையொப்பமிடாத கரி	0 … 255
சிறிய எண்ணாக கையொப்பமிடப்பட்டது	-32 768 … 32 767
கையொப்பமிடப்படாத குறுகிய எண்ணாக	0 … 65 535
நீண்ட எண்ணாக கையொப்பமிடப்பட்டது	-2 147 483 648 … 2 147 483 647
கையொப்பமிடப்படாத நீண்ட எண்ணாக	0 … 4 294 967 295
மிதவை	3.4e-38 … 3.4e+38
இரட்டை	1.7e-308 … 1.7C+308
நீண்ட இரட்டை	3.4e-4932 … 3.4e+4932

நிரல் அமைப்பு

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

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

• செயல்பாடு மதிப்பை வழங்கவில்லை என்றால், வெற்றிட வகை குறிப்பிடப்படுகிறது:
• செயல்பாட்டின் உடல் ஒரு தொகுதி மற்றும் எனவே சுருள் பிரேஸ்களில் இணைக்கப்பட்டுள்ளது;
• செயல்பாடுகளை உள்ளமைக்க முடியாது;
• ஒவ்வொரு அறிக்கையும் அரைப்புள்ளியுடன் முடிவடைகிறது (கூட்டு அறிக்கை தவிர).

முக்கிய, fl மற்றும் f2 செயல்பாடுகளைக் கொண்ட நிரல் கட்டமைப்பின் எடுத்துக்காட்டு:

நிரல் பலவற்றைக் கொண்டிருக்கலாம் தொகுதிகள்(மூல கோப்புகள்).

C++ இல் I/O பற்றிய குறிப்புகள்

C++ மொழியில் உள்ளமைக்கப்பட்ட உள்ளீடு/வெளியீட்டு வசதிகள் இல்லை - இது நிலையான நூலகங்களில் உள்ள செயல்பாடுகள், வகைகள் மற்றும் பொருள்களைப் பயன்படுத்தி மேற்கொள்ளப்படுகிறது.

இரண்டு முறைகள் பயன்படுத்தப்படுகின்றன: C மொழி மற்றும் C++ பொருள்களிலிருந்து பெறப்பட்ட செயல்பாடுகள்.

அடிப்படை C பாணி I/O செயல்பாடுகள்:

int scanf (const char* வடிவம், ...) // உள்ளீடு
int printf(const char* வடிவம், ...) // வெளியீடு

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

C-style I/O செயல்பாடுகளைப் பயன்படுத்தும் ஒரு எடுத்துக்காட்டு நிரல்:

#சேர்க்கிறது
முழு எண்ணாக முக்கிய() (
int i;
printf("ஒரு முழு எண்ணை உள்ளிடவும்\n");
scanf("%d", &i);
printf("%d எண்ணை உள்ளிட்டுள்ளீர்கள், நன்றி!", i);
திரும்ப 0;
}

இந்த நிரலின் முதல் வரியானது ஒரு முன்செயலி உத்தரவு ஆகும், இது நிரலில் பயன்படுத்தப்படும் உள்ளீடு/வெளியீடு செயல்பாடுகளின் விளக்கத்தைக் கொண்ட நிரல் உரையில் ஒரு தலைப்புக் கோப்பைச் செருகுகிறது. இந்த வழக்கில்கோண அடைப்புக்குறிகள் ஒரு மொழி உறுப்பு). அனைத்து முன்செயலி வழிமுறைகளும் # அடையாளத்துடன் தொடங்கும்.

மூன்றாவது வரி i என்ற பெயரிடப்பட்ட முழு எண் வகை மாறியின் விளக்கமாகும்.

வரி 4 இல் உள்ள printf செயல்பாடு "ஒரு முழு எண்ணை உள்ளிடவும்" வரியில் அச்சிடுகிறது மற்றும் செல்கிறது புதிய கோடுதப்பிக்கும் வரிசையின் படி \n. ஸ்கேன்ஃப் செயல்பாடு விசைப்பலகையிலிருந்து உள்ளிடப்பட்ட முழு எண்ணை i (அடையாளம் & முகவரியைப் பெறுவதற்கான செயல்பாட்டைக் குறிக்கிறது) இல் சேமிக்கிறது, மேலும் பின்வரும் அறிக்கை அதில் குறிப்பிடப்பட்டுள்ள சரத்தை இந்த எண்ணின் மதிப்புடன் மாற்றும்.

C++ வகுப்பு நூலகத்தைப் பயன்படுத்தி நிரல்:

#சேர்க்கிறது
முழு எண்ணாக முக்கிய() (
int i;
கூட்<< "Введите целое число\n"; சின் >> நான்;
கூட்<< "Вы ввели число " << i << ", спасибо!";
திரும்ப 0;
}

தலைப்புக் கோப்பில் உள்ளீடு/வெளியீட்டை நிர்வகிப்பதற்கான வகுப்புகளின் தொகுப்பின் விளக்கம் உள்ளது. இது நிலையான ஸ்ட்ரீம் பொருள்களை வரையறுக்கிறது சின்விசைப்பலகை உள்ளீடு மற்றும் கூட்காட்சிக்காக, அத்துடன் ஒரு ஸ்ட்ரீமில் வைப்பதன் செயல்பாடு< < и чтения из потока >>.

உள்ளீடு/வெளியீட்டை ஒழுங்கமைக்கும் இரண்டு முறைகளையும் நீங்கள் பயன்படுத்தலாம், ஆனால் அவற்றை ஒரு நிரலில் கலக்க பரிந்துரைக்கப்படவில்லை.

நிரலாக்கத்தில், தரவு வகை என்பது இரண்டு தொகுப்புகளின் தொகுப்பாகும்: மதிப்புகளின் தொகுப்பு மற்றும் அவற்றிற்குப் பயன்படுத்தக்கூடிய செயல்பாடுகளின் தொகுப்பு. எடுத்துக்காட்டாக, கூட்டல் (+), பெருக்கல் (*), முழு எண் வகுத்தல் (/), எஞ்சிய (%) மற்றும் கழித்தல் (-) ஆகியவற்றின் செயல்பாடுகள் இயற்கை எண்களின் வரையறுக்கப்பட்ட தொகுப்பைக் கொண்ட எதிர்மறையான முழு எண் தரவு வகைக்கு பயன்படுத்தப்படலாம்.

ஒரு நிரலாக்க மொழி பொதுவாக பழமையான தரவு வகைகளின் தொகுப்பைக் கொண்டுள்ளது - அடிப்படை உள்ளமைக்கப்பட்ட அலகு என நிரலாக்க மொழியால் வழங்கப்படும். C++ இல், மொழியை உருவாக்கியவர் அத்தகைய வகைகளை அடிப்படை வகைகள் என்று அழைக்கிறார். C++ இல் உள்ள அடிப்படை வகைகள்:

• பூலியன்(பூல்);
• பாத்திரம் (எ.கா. கரி);
• முழு எண்ணாக (எ.கா. முழு எண்ணாக);
• மிதக்கும் புள்ளி (எ.கா. மிதவை);
• கணக்கீடுகள் (புரோகிராமரால் வரையறுக்கப்பட்டது);
• வெற்றிடம் .

பட்டியலிடப்பட்டவற்றின் மேல், பின்வரும் வகைகள் கட்டப்பட்டுள்ளன:

• ஆர்ப்பாட்டம் (எ.கா. int*);
• வரிசைகள் (எ.கா. சார்);
• குறிப்பு (எ.கா. இரட்டை&);
• மற்ற கட்டமைப்புகள்.

ஒரு நேரடியான (உதாரணமாக, 1, 2.4F, 25e-4, 'a', முதலியன) கருத்துக்கு செல்லலாம்: ஒரு நிலையான மதிப்பைக் குறிக்கும் ஒரு நிரலின் மூலக் குறியீட்டில் உள்ளீடு என்பது ஒரு எழுத்து. வேறு வார்த்தைகளில் கூறுவதானால், ஒரு எழுத்து என்பது நிரல் குறியீட்டில் ஏதேனும் ஒரு பொருளின் (மதிப்பு) பிரதிநிதித்துவம் ஆகும். C++ ஆனது முழு எண், மிதக்கும் புள்ளி, எழுத்து, பூலியன் மற்றும் சரம் மதிப்புகளை எழுதும் திறனைக் கொண்டுள்ளது.

ஒரு முழு எண் வகை எழுத்துமுறையை இவ்வாறு எழுதலாம்:

• 10 வது எண் அமைப்பு. உதாரணமாக, 1205;
• 0 + எண் வடிவத்தில் 8வது எண் அமைப்பு. உதாரணமாக, 0142;
• 0x + எண் வடிவத்தில் 16வது எண் அமைப்பு. உதாரணமாக, 0x2F.

24, 030, 0x18 - இவை அனைத்தும் வெவ்வேறு எண் அமைப்புகளில் ஒரே எண்ணின் பதிவுகள்.
மிதக்கும் புள்ளி எண்களை எழுத, புள்ளி குறியீட்டைப் பயன்படுத்தவும்: 0.1, .5, 4. - இதில்
அதிவேக குறியீடு - 25e-100. அத்தகைய பதிவில் இடைவெளிகள் இருக்கக்கூடாது.

எழுத்துக்களில் எழுதப்பட்ட மதிப்புகளை நாம் இணைக்கக்கூடிய பெயர் மாறி என்று அழைக்கப்படுகிறது. ஒரு மாறி என்பது பெயரிடப்பட்ட அல்லது முகவரியிடக்கூடிய நினைவகப் பகுதியாகும், அதன் முகவரியைத் தரவை அணுக பயன்படுத்தலாம். நிரல் செயல்பாட்டின் போது இந்த தரவு ஒரு குறிப்பிட்ட வழியில் எழுதப்பட்டு, மீண்டும் எழுதப்பட்டு நினைவகத்தில் அழிக்கப்படுகிறது. எந்த நேரத்திலும் தரவை அணுகவும், தேவைப்பட்டால், அதை மாற்றவும் ஒரு மாறி உங்களை அனுமதிக்கிறது. ஒரு மாறி பெயரிலிருந்து பெறக்கூடிய தரவு மாறியின் மதிப்பு எனப்படும்.
ஒரு நிரலில் ஒரு மாறியைப் பயன்படுத்த, அது அறிவிக்கப்பட வேண்டும், தேவைப்பட்டால், அதை வரையறுக்கலாம் (= துவக்கப்பட்டது). நிரல் உரையில் ஒரு மாறியின் அறிவிப்பு அவசியமாக 2 பகுதிகளைக் கொண்டுள்ளது: அடிப்படை வகை மற்றும் அறிவிப்பாளர். குறிப்பான் மற்றும் துவக்கி ஆகியவை விருப்பப் பகுதிகள்:

Const int உதாரணம் = 3; // இங்கே const என்பது ஒரு குறிப்பான் // int என்பது அடிப்படை வகை // உதாரணம் மாறியின் பெயர் // = 3 - துவக்கி.

மாறி பெயர் என்பது லத்தீன் எழுத்துக்கள் (சிறிய மற்றும் பெரிய எழுத்து), எண்கள் மற்றும்/அல்லது அடிக்கோடினைக் கொண்ட எழுத்துகளின் வரிசையாகும், ஆனால் முதல் எழுத்து எண்ணாக இருக்க முடியாது. மாறி பெயர் தேர்ந்தெடுக்கப்பட வேண்டும், அதனால் அது எதைச் சேமிக்கிறது என்பதை யூகிக்க எளிதானது, எடுத்துக்காட்டாக, "மாத கட்டணம்". குறிப்புகள் மற்றும் நடைமுறையில், மாறிகளை பதிவு செய்வதற்கான விதிகளுக்கு கேமல்கேஸ் குறியீட்டைப் பயன்படுத்துவோம். மாறி பெயர் மொழியில் ஒதுக்கப்பட்ட சொற்களுடன் ஒத்துப்போக முடியாது; அத்தகைய சொற்களின் எடுத்துக்காட்டுகள்: if, while, function, goto, switch, etc.

மாறி பெயருடன் கூடுதலாக, அறிவிப்பாளர் கூடுதல் எழுத்துக்களைக் கொண்டிருக்கலாம்:

• * - சுட்டிக்காட்டி; பெயருக்கு முன்;
• * const - நிலையான சுட்டிக்காட்டி; பெயருக்கு முன்;
• & - இணைப்பு; பெயருக்கு முன்;
• - வரிசை; பெயருக்குப் பிறகு;
• () - செயல்பாடு; பெயருக்குப் பிறகு.

ஒரு மாறிக்கான மதிப்பை அதன் அறிவிப்புக்குப் பிறகு உடனடியாக வரையறுக்க ஒரு துவக்கி உங்களை அனுமதிக்கிறது. துவக்கி ஒரு சமத்துவ எழுத்தில் (=) தொடங்கி பின்னர் மாறியின் மதிப்பை அமைக்க தொடர்கிறது. பொதுவாக, C++ இல் உள்ள சம அடையாளம் ஒரு அசைன்மென்ட் செயல்பாட்டைக் குறிக்கிறது; அதன் உதவியுடன் நீங்கள் ஒரு மாறியின் மதிப்பை அமைக்கலாம் மற்றும் மாற்றலாம். வெவ்வேறு வகைகளுக்கு இது வேறுபட்டிருக்கலாம்.

குறிப்பிட்ட வகையைத் தவிர வேறு கூடுதல் பண்புக்கூறுகளைக் குறிப்பிடுகிறது. எடுத்துக்காட்டில் கொடுக்கப்பட்டுள்ள கான்ஸ்ட் ஸ்பெசிஃபையர், மாறியின் மதிப்பில் அடுத்தடுத்த மாற்றங்களைத் தடுக்க உங்களை அனுமதிக்கிறது. இத்தகைய மாறாத மாறிகள் மாறிலி அல்லது மாறிலி என்று அழைக்கப்படுகின்றன.

துவக்கம் இல்லாமல் மாறிலியை அறிவிப்பது தர்க்கரீதியான காரணங்களுக்காக வேலை செய்யாது:

கான்ஸ்ட் இன்ட் EMPTY_CONST; // பிழை, நிலையான மாறி துவக்கப்படவில்லை const int EXAMPLE = 2; // மாறிலி மதிப்பு 2 EXAMPLE = 3; // பிழை, ஒரு நிலையான மாறிக்கு மதிப்பை ஒதுக்க முயற்சிக்கவும்

மாறிலிகளுக்குப் பெயரிடும் போது, ​​அடிக்கோடிடப்பட்ட எழுத்துடன் சொற்களைப் பிரித்து, பெரிய எழுத்துக்களை மட்டுமே பயன்படுத்துவது வழக்கம்.

C++ இல் உள்ள அடிப்படை தரவு வகைகள்

ஒவ்வொரு வகையையும் ஆராயும்போது, ​​தரவு வகையின் வரையறையைப் பற்றி வாசகர் மறந்துவிடக் கூடாது.

1. முழு எண் வகை (char, short (int), int, long (int), long long)

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

• 2 8N = 2 8 * 1 = 256, N என்பது மதிப்பைச் சேமிக்க பைட்டுகளில் உள்ள நினைவகத்தின் அளவு.

இந்த வழக்கில், கிடைக்கக்கூடிய முழு எண்களின் வரம்புகள் பின்வருமாறு:

• - கையொப்பமிடாத கரிக்கு
• [-128..127] - கையொப்பமிட்ட கரிக்கு

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

கையொப்பமிடப்படாத நீண்ட மதிப்புகள்; // ஒரு முழு எண் (நீண்ட) கையொப்பமிடப்படாத வகையைக் குறிப்பிடுகிறது.

பட்டியலிடப்பட்ட வகைகள் சேமிப்பிற்கு தேவையான நினைவகத்தின் அளவு மட்டுமே வேறுபடுகின்றன. C++ மொழி இயந்திரம் சார்ந்தது என்பதால், மொழி தரநிலை பின்வரும் நிபந்தனைக்கு மட்டுமே உத்தரவாதம் அளிக்கிறது:

• 1 = கரி அளவு ≤ குறுகிய அளவு ≤ int அளவு ≤ நீண்ட அளவு.

பொதுவாக வகைகளின் அளவுகள் பின்வருமாறு: char - 1, short - 2, int - 4, long -8, long long - 8 bytes.

முழு எண் வகையின் மதிப்புகளுடன் நீங்கள் எண்கணித செயல்பாடுகளைச் செய்யலாம்: +, -, *, /, %; ஒப்பீட்டு செயல்பாடுகள்: ==, !=,<=, <, >, >=; பிட் செயல்பாடுகள்: &, |, xor,<<, >>.
கூட்டல், பெருக்கல், கழித்தல் மற்றும் ஒப்பீடு போன்ற பெரும்பாலான செயல்பாடுகள் எளிதில் புரிந்துகொள்ளக்கூடியவை. சில நேரங்களில், எண்கணித செயல்பாடுகளைச் செய்த பிறகு, முடிவு மதிப்புகளின் வரம்பிற்கு வெளியே இருக்கலாம்; இந்த வழக்கில் நிரல் பிழையை உருவாக்கும்.
முழு எண் பிரிவு (/) என்பது ஒரு முழு எண்ணின் முழு எண் பகுதியை மற்றொன்றால் வகுக்கப்படுவதைக் கண்டறியும். உதாரணத்திற்கு:

• 6 / 4 = 1;
• 2 / 5 = 0;
• 8 / 2 = 4.

சதவீத குறியீடு (%) என்பது இரண்டு முழு எண்களின் பிரிவின் எஞ்சிய பகுதியை நிர்ணயிக்கும் செயல்பாட்டைக் குறிக்கிறது:

• 6 % 4 = 2;
• 10 % 3 = 1.

செயல்பாடுகளைப் புரிந்துகொள்வது மிகவும் கடினம்: & (AND), | (OR), xor (பிரத்தியேக OR),<< (побитовый сдвиг влево), >> (பிட்வைஸ் ரைட் ஷிப்ட்).

பிட் செயல்பாடுகள் AND, OR மற்றும் XOR ஆகியவை ஒவ்வொரு பிட் தகவலுக்கும் தொடர்புடைய தருக்க செயல்பாட்டைப் பயன்படுத்துகின்றன:

• 1 10 = 01 2
• 3 10 = 11 2
• 1 10 & 3 10 = 01 2 & 11 2 = 01 2
• 1 10 | 3 10 = 01 2 | 11 2 = 11 2
• 1 10 xor 3 10 = 01 2 xor 11 2 = 10 2

பட செயலாக்கத்தில், 3 சேனல்கள் வண்ணத்திற்காகப் பயன்படுத்தப்படுகின்றன: சிவப்பு, நீலம் மற்றும் பச்சை - மேலும் வெளிப்படைத்தன்மை, இவை ஒரு முழு எண்ணாக மாறி சேமிக்கப்படுகின்றன, ஏனெனில் ஒவ்வொரு சேனலுக்கும் 0 முதல் 255 வரையிலான மதிப்புகள் உள்ளன. ஹெக்ஸாடெசிமல் எண் அமைப்பில், ஒரு குறிப்பிட்ட மதிப்பு பின்வருமாறு எழுதப்பட்டுள்ளது: 0x180013FF; பின்னர் மதிப்பு 18 16 சிவப்பு சேனலுக்கு ஒத்திருக்கிறது, 00 16 - நீலம், 13 16 - பச்சை, FF - ஆல்பா சேனல் (வெளிப்படைத்தன்மை). அத்தகைய முழு எண்ணிலிருந்து ஒரு குறிப்பிட்ட சேனலைத் தேர்ந்தெடுக்க, சேனல் என்று அழைக்கப்படுவது பயன்படுத்தப்படுகிறது. முகமூடி, இதில் நமக்கு விருப்பமான நிலைகள் F 16 அல்லது 1 2 ஆகும். அதாவது, நீல சேனலின் மதிப்பை முன்னிலைப்படுத்த, நீங்கள் ஒரு முகமூடியைப் பயன்படுத்த வேண்டும், அதாவது. பிட்வைஸ் மற்றும்:

Int blue_channel = 0x180013FF & 0x00FF0000;

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

ஒரு பிட் ஷிஃப்ட், செயல்பாட்டின் வலது பக்கத்தில் குறிப்பிடப்பட்டுள்ள பல பைனரி இலக்கங்களால் எண்ணை இடது அல்லது வலது பக்கம் மாற்றுகிறது. எடுத்துக்காட்டாக, கரி வகைக்கான எண் 39 பைனரியில் பின்வருமாறு எழுதப்பட்டுள்ளது: 00100111. பிறகு:

சார் பைனரி உதாரணம் = 39; // 00100111 எழுத்து முடிவு = பைனரி உதாரணம்<< 2; // сдвигаем 2 бита влево, результат: 10011100

மாறி கையொப்பமிடப்படாத வகையாக இருந்தால், இதன் விளைவாக எண் 156 ஆக இருக்கும், கையொப்பமிடப்பட்ட ஒன்றிற்கு அது -100 க்கு சமம். கையொப்பமிடப்பட்ட முழு எண் வகைகளுக்கு, பிட் பிரதிநிதித்துவத்தின் மிக முக்கியமான பிட்டில் உள்ள அலகு எண் எதிர்மறையாக இருப்பதற்கான அறிகுறியாகும். இந்த வழக்கில், அனைத்தையும் கொண்ட பைனரி வடிவத்தில் ஒரு மதிப்பு -1 ஐ ஒத்துள்ளது; 1 என்பது மிகவும் குறிப்பிடத்தக்க இலக்கத்தில் மட்டுமே இருந்தால், மீதமுள்ள எண்கள் பூஜ்ஜியங்களாக இருந்தால், அத்தகைய எண் ஒரு குறிப்பிட்ட வகைக்கான குறைந்தபட்ச மதிப்பைக் கொண்டுள்ளது: கரிக்கு அது -128 ஆகும்.

2. மிதக்கும் புள்ளி வகை (மிதவை, இரட்டை (மிதவை))

மிதக்கும் புள்ளி மதிப்புகளின் தொகுப்பு உண்மையான எண்களின் துணைக்குழு ஆகும், ஆனால் ஒவ்வொரு உண்மையான எண்ணையும் பைனரியில் குறிப்பிட முடியாது, இது சில நேரங்களில் முட்டாள் பிழைகளுக்கு வழிவகுக்கிறது:

மிதவை மதிப்பு = 0.2; மதிப்பு == 0.2; // பிழை, இங்கே மதிப்பு 0.2 க்கு சமமாக இருக்காது.

மிதக்கும்-புள்ளி மாறிகளுடன் பணிபுரியும் போது, ​​புரோகிராமர் சமத்துவம் அல்லது சமத்துவமின்மை சோதனையைப் பயன்படுத்தக்கூடாது; அதற்கு பதிலாக, ஒரு குறிப்பிட்ட இடைவெளியில் விழுவதற்கான சோதனை பொதுவாகப் பயன்படுத்தப்படுகிறது:

மதிப்பு - 0.2< 1e-6; // ok, подбирать интервал тоже нужно осторожно

ஒப்பீட்டு செயல்பாடுகளுக்கு கூடுதலாக, மிதக்கும் புள்ளி வகை 4 எண்கணித செயல்பாடுகளை ஆதரிக்கிறது, அவை உண்மையான எண்களுடன் கணித செயல்பாடுகளுடன் முழுமையாக ஒத்துப்போகின்றன.

3. பூலியன் (தர்க்கரீதியான) வகை (பூல்)

இரண்டு மதிப்புகளை மட்டுமே கொண்டுள்ளது: உண்மை (உண்மை) மற்றும் தவறு (தவறு). இந்த வகை மாறிகளுடன் வேலை செய்ய, தருக்க செயல்பாடுகள் பயன்படுத்தப்படுகின்றன: ! (இல்லை), == (சமத்துவம்), != (சமத்துவமின்மை), && (தருக்க மற்றும்), || (தர்க்கரீதியான OR). ஒவ்வொரு செயல்பாட்டின் முடிவும் தொடர்புடைய உண்மை அட்டவணையில் காணலாம். உதாரணத்திற்கு:

X Y XOR0 0 0 0 1 1 1 0 1 1 1 0

4. எழுத்து வகை (char, wchar_t)

சார் வகை என்பது ஒரு முழு எண் வகை மட்டுமல்ல (பொதுவாக இந்த வகை பைட் என அழைக்கப்படுகிறது), ஆனால் ஒரு எழுத்து வகை, அட்டவணையில் இருந்து எழுத்து எண்ணை ASCII எழுத்தாக சேமிக்கிறது. எடுத்துக்காட்டாக, 0x41 குறியீடு 'A' மற்றும் 0x71 - 't' எழுத்துக்கு ஒத்திருக்கிறது.

சில நேரங்களில் ASCII அட்டவணையில் சரி செய்யப்படாத எழுத்துக்களைப் பயன்படுத்துவது அவசியமாகிறது, எனவே சேமிப்பிற்கு 1 பைட்டுக்கு மேல் தேவைப்படுகிறது. அவர்களுக்கென்று ஒரு பரந்த தன்மை உள்ளது (wchar_t).

5.1 அணிவரிசைகள்

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

Int myArray; // முழு எண் வகையின் 5 கூறுகளின் வரிசை

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

Int முரண்பாடுகள் = (1, 3, 7, 9, 11); // வரிசை 5 மதிப்புகளுடன் துவக்கப்பட்டது

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

முரண்பாடுகள்; // அணிவரிசையின் முதல் உறுப்புக்கான அணுகல். மதிப்பு 1 முரண்பாடுகளை வழங்குகிறது; // மூன்றாவது உறுப்புக்கான அணுகல். 7 முரண்பாடுகள் = 13 மதிப்பை வழங்குகிறது; // வரிசை முரண்பாடுகளின் 5வது உறுப்புக்கு புதிய மதிப்பை ஒதுக்கவும்; // அணுகல் பிழை

5.3 சரங்கள்

ஒரு சரத்தை எழுத, புரோகிராமர்கள் ஒரு சரம் என்பது எழுத்துக்களின் தொடர் தொடர் (வரிசை) என்ற கருத்தைப் பயன்படுத்துகின்றனர். ஒரு வரியின் முடிவைக் கண்டறிய, சிறப்பு வரியின் இறுதி எழுத்தைப் பயன்படுத்தவும்: '\0'. இந்த சிறப்பு எழுத்துக்கள், பின்சாய்வு மற்றும் அடையாளம் காணும் தன்மை கொண்டவை, கட்டுப்பாடு அல்லது தப்பிக்கும் எழுத்துகள் எனப்படும். எடுத்துக்காட்டாக, '\n' - புதிய வரியின் தொடக்கம், '\t' - அட்டவணையும் உள்ளன. ஒரு சரத்தில் பின்சாய்வு எழுத, எஸ்கேப் பயன்படுத்தப்படுகிறது - '\' குறிக்கு முன்பாக மற்றொரு சாய்வு வைக்கப்படுகிறது. மேற்கோள் குறிகளை எழுதவும் எஸ்கேப்பிங் பயன்படுத்தப்படுகிறது.

ஒரு சரம் மாறியை உருவாக்குவோம்:

Char textExample = ('T', 'e', ​​'s', 't', '\0'); // “சோதனை” என்ற சரம் எழுதப்பட்டுள்ளது

சரம் துவக்கத்திற்கான எளிமையான குறியீடு உள்ளது:

Char textExample = "சோதனை"; // கடைசி எழுத்து எழுதப்படவில்லை, ஆனால் அளவு இன்னும் 5

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

சரம் ஹலோ = "ஹலோ,"; சரத்தின் பெயர் = "அதிகபட்சம்!"; சரம் hello_name = hello + name; // "ஹலோ, மேக்ஸ்!" என்ற சரத்தைப் பெறுங்கள்

6. இணைப்பு

Int a = 2; // மாறி "a" புள்ளிகள் மதிப்பு 2 int &b = a; // மாறி “b” என்பது “a” b = 4 போன்ற அதே இடத்தைக் குறிக்கிறது; // b இன் மதிப்பை மாற்றுவதன் மூலம், புரோகிராமர் a இன் மதிப்பை மாற்றுகிறார். இப்போது a = 4 int &c = 4; // பிழை, நீங்கள் இதைச் செய்ய முடியாது, ஏனெனில் குறிப்புக்கு மதிப்பை ஒதுக்க முடியாது

7. குறியீட்டு

இந்த தரவு வகையைப் புரிந்து கொள்ள, இந்த வகையின் பல மதிப்புகள் தரவு தொடங்கும் நினைவக கலங்களின் முகவரிகள் என்பதை நீங்கள் நினைவில் கொள்ள வேண்டும். சுட்டி கூட்டல் (+), கழித்தல் (-) மற்றும் dereference (*) செயல்பாடுகளையும் ஆதரிக்கிறது.

முகவரிகள் 0x0 என்றால் சுட்டிக்காட்டி காலியாக உள்ளது, அதாவது. எந்த தரவையும் சுட்டிக்காட்டவில்லை. இந்த முகவரிக்கு அதன் சொந்த எழுத்து உள்ளது - NULL:

Int *nullPtr = NULL; // பூஜ்ய சுட்டி

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

ஒரு சுட்டியில் சேமிக்கப்பட்ட முகவரியில் தொடங்கும் தரவை மீட்டெடுப்பதற்கான செயல்பாடு dereferencing (*) என்று அழைக்கப்படுகிறது. நிரல் தேவையான நினைவக செல்களைப் படிக்கிறது மற்றும் நினைவகத்தில் சேமிக்கப்பட்ட மதிப்பை வழங்குகிறது.

Int valueInMemory = 2; // முழு எண் வகையின் மாறியை அமைக்கவும் *somePtr = // மாறியின் முகவரியை நகலெடுக்கவும், இங்கே & - சிலPtr மாறியின் முகவரியை வழங்குகிறது; // நினைவக கலத்தின் முகவரி, எடுத்துக்காட்டாக, 0x2F *somePtr; // மதிப்பு 4 கலங்களில் சேமிக்கப்படுகிறது: 0x2F, 0x30, 0x31 மற்றும் 0x32

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

மற்ற வகை மாறிகளின் மதிப்புகளைப் போலவே, சுட்டிக்காட்டி நினைவகத்தில் சேமிக்கப்படுகிறது, மேலும் 4 பைட்டுகளை ஆக்கிரமித்துள்ளது, எனவே நீங்கள் ஒரு சுட்டிக்காட்டிக்கு ஒரு சுட்டிக்காட்டி உருவாக்கலாம்.

8. இடமாற்றங்கள்

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

எனம் நிறம் (சிவப்பு, நீலம், பச்சை);

இயல்பாக, RED = 0, BLUE = 1, GREEN = 2. எனவே, மதிப்புகளை ஒன்றுடன் ஒன்று ஒப்பிடலாம், அதாவது. சிவப்பு< BLUE < GREEN. Программист при объявлении перечисления может самостоятельно задать значения каждой из констант:

Enum அணுகல் (படிக்க = 1, எழுத = 2, EXEC = 4);

இரண்டு சக்திகளின் மதிப்புகளைக் கொண்ட கணக்கீடுகளைப் பயன்படுத்துவது பெரும்பாலும் வசதியானது பைனரி பிரதிநிதித்துவத்தில், 2 இன் சக்தியான எண் 1 மற்றும் பூஜ்ஜியங்களைக் கொண்டிருக்கும். உதாரணத்திற்கு:

8 10 = 00001000 2

இந்த எண்களை ஒன்றாகச் சேர்ப்பதன் விளைவாக, எந்த எண்கள் சேர்க்கப்பட்டன என்பதை எப்போதும் தெளிவாகக் குறிக்கிறது:

37 10 = 00100101 2 = 00000001 2 + 00000100 2 + 00100000 2 = 1 10 + 4 10 + 32 10

வெற்றிடமானது

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

Void பொருள்; // பிழை, void void வகை பொருள்கள் எதுவும் இல்லை // பிழை, void void *ptr பற்றிய குறிப்புகள் இல்லை; // சரி, தெரியாத வகைக்கு ஒரு சுட்டியை சேமிக்கவும்

ஒரு செயல்பாடு எந்த மதிப்பையும் தராது என்பதைக் குறிக்க பெரும்பாலும் வெற்றிடத்தைப் பயன்படுத்துவோம். நினைவகத்தின் ஒருமைப்பாடு மற்றும் சரியான வகை வார்ப்புக்கு புரோகிராமர் முழுப் பொறுப்பையும் ஏற்கும்போது வெற்றிட வகை சுட்டிக்காட்டி பயன்படுத்தப்படுகிறது.

நடிகர்கள்

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

முழு எண் = 2; float floating = முழு எண்; // மிதக்கும் = 2.0

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

வெளிப்படையான வகை மாற்றத்திற்கான வாய்ப்பு உள்ளது; இதற்காக, மாறியின் இடதுபுறம் அல்லது அசல் வகையின் எந்த மதிப்பையும் அடைப்புக்குறிக்குள் எழுதவும்:

முழு எண்ணாக மதிப்பு = (int) 2.5;

யூனரி மற்றும் பைனரி செயல்பாடுகள்

நாங்கள் முன்பு செய்த செயல்பாடுகள் பைனரி என்று அழைக்கப்படுகின்றன: செயல்பாட்டுக் குறியீட்டின் இடது மற்றும் வலதுபுறத்தில் மதிப்புகள் அல்லது மாறிகள் உள்ளன, எடுத்துக்காட்டாக, 2 + 3. பைனரி செயல்பாடுகளுக்கு கூடுதலாக, நிரலாக்க மொழிகள் மாறிகளுக்குப் பொருந்தக்கூடிய யூனரி செயல்பாடுகளையும் பயன்படுத்துகின்றன. . அவை ஒரு மாறியின் இடது அல்லது வலதுபுறமாக அமைந்திருக்கலாம்; இது போன்ற பல செயல்பாடுகள் இதற்கு முன்பு சந்தித்துள்ளன - dereferencing செயல்பாடு (*) மற்றும் ஒரு மாறியின் முகவரியை எடுத்துக்கொள்வது (&) அசாதாரணமானது. ஆபரேட்டர்கள் “++” மற்றும் “—” ஒரு முழு எண் மாறியின் மதிப்பை முறையே 1 ஆல் அதிகரிக்கவும் குறைக்கவும் செய்கின்றன, மேலும் மாறியின் இடது அல்லது வலதுபுறமாக எழுதலாம்.

ஒரு வெளிப்பாட்டின் இடது மற்றும் வலது பக்கங்களில் ஒரே மாறி இருக்கும் போது, ​​C++ ஆனது பைனரி செயல்பாடுகளுக்கு சுருக்கெழுத்து குறியீட்டைப் பயன்படுத்துகிறது, அதாவது. சில செயல்பாடு ஒரு மாறியின் மதிப்பில் செய்யப்படுகிறது மற்றும் செயல்பாட்டின் முடிவு அதே மாறியில் சேமிக்கப்படுகிறது:

A += 2; // a = a + 2 போன்றது; b /= 5; // அதே b = b / 5; c &= 3; // அதே c = c & 3;

குறிச்சொற்கள்: சி மாறிகள். char, int, unsigned, long, long long, float, double, long double, long float, lexical scoping. மாறிகளின் அறிவிப்பு. காணக்கூடிய பகுதி. மாறிகளின் துவக்கம். மாறி பெயர்கள். அதிவேக வடிவம்.

மாறிகள்

மதிப்புகளை சேமிக்க மாறிகள் பயன்படுத்தப்படுகின்றன (sic!). ஒரு மாறி ஒரு வகை மற்றும் பெயரால் வகைப்படுத்தப்படுகிறது. பெயருடன் ஆரம்பிக்கலாம். C இல், ஒரு மாறியானது அடிக்கோடிலோ அல்லது ஒரு எழுத்திலோ தொடங்கலாம், ஆனால் எண்ணுடன் அல்ல. மாறியில் ஆங்கில எழுத்துகள், எண்கள் மற்றும் அடிக்கோடுகள் இருக்கலாம். மாறியானது முக்கிய வார்த்தைகளுடன் பொருந்தாமல் இருக்க வேண்டும் (இவை கட்டுப்பாட்டு கட்டமைப்பாக, வகைகளை வரையறுப்பதற்காகப் பயன்படுத்தப்படும் சிறப்பு சொற்கள்.)

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

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

எடுத்துக்காட்டாக, சரியான அடையாளங்காட்டிகள்
a, _, _1_, Sarkasm, a_long_variable, aLongVariable, var19, defaultX, char_type
விசுவாசமற்ற
1a, $value, a-long-value, short

சி ஒரு வழக்கு உணர்திறன் மொழி. a மற்றும் A, அல்லது end மற்றும் END, அல்லது perfectDark மற்றும் PerfectDarK என பெயரிடப்பட்ட மாறிகள் வெவ்வேறு மாறிகள்.

மாறக்கூடிய வகைகள்

மாறி வகை தீர்மானிக்கிறது

• 1) பைட்டுகளில் மாறியின் அளவு (மதிப்பைச் சேமிக்க கணினி எத்தனை பைட் நினைவகத்தை ஒதுக்கும்)
• 2) நினைவகத்தில் ஒரு மாறியின் பிரதிநிதித்துவம் (ஒதுக்கப்பட்ட நினைவகப் பகுதியில் உள்ள பிட்கள் பைனரி வடிவத்தில் எவ்வாறு அமைந்திருக்கும்).

C இல் பல முக்கிய வகைகள் உள்ளன. அவற்றை இரண்டு குழுக்களாகப் பிரிப்போம் - முழு எண்கள் மற்றும் மிதக்கும் புள்ளி எண்கள்.

முழு

• கரி- அளவு 1 பைட். எப்போதும்! இதை நினைவில் கொள்ள வேண்டும்.
• குறுகிய- அளவு 2 பைட்டுகள்
• முழு எண்ணாக- அளவு 4 பைட்டுகள்
• நீளமானது- அளவு 4 பைட்டுகள்
• நீண்ட நீண்ட- அளவு 8 பைட்டுகள்.

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

கரி<= short <= int <= long <= long long

மேலே உள்ள மதிப்புகள் 32-பிட் கணினியில் உள்ள VC2012 கம்பைலருக்கு குறிப்பிட்டவை. உங்கள் நிரல் ஒரு மாறியின் அளவைப் பொறுத்து இருந்தால், அதன் அளவைக் கண்டறிய நேரம் ஒதுக்குங்கள்.

இப்போது ஒவ்வொரு வகையின் மாறியும் சேமிக்கக்கூடிய அதிகபட்ச மற்றும் குறைந்தபட்ச எண்ணைத் தீர்மானிப்போம். எண்கள் நேர்மறை அல்லது எதிர்மறையாக இருக்கலாம். குறியைச் சேமிக்க எதிர்மறை எண்கள் ஒரு பிட்டைப் பயன்படுத்துகின்றன. சில நேரங்களில் ஒரு அடையாளம் அவசியம் (உதாரணமாக, நாங்கள் ஒரு வங்கி கணக்கு, வெப்பநிலை, ஒருங்கிணைப்பு, முதலியன சேமிக்கிறோம்), சில நேரங்களில் அது தேவையில்லை (எடை, வரிசை அளவு, நபரின் வயது, முதலியன). இதைச் செய்ய, C கையொப்பமிடப்பட்ட மற்றும் கையொப்பமிடப்படாத வகை மாற்றியைப் பயன்படுத்துகிறது. கையொப்பமிடாத char - எண்ணுக்கான அனைத்து 8 பிட்களும், மொத்தமாக 00000000 முதல் 11111111 வரையிலான எண்களின் தொகுப்பை பைனரி வடிவத்தில் வைத்திருக்கிறோம், அதாவது 0 முதல் 255 வரை கையொப்பமிடப்பட்ட கரி -128 முதல் 128 வரை. C இல், மாறிகள் இயல்புநிலையாக கையொப்பமிடப்படும். எனவே, எழுதும் கரி மற்றும் கையொப்பமிடப்பட்ட சார் ஆகியவை சமமானவை.

தாவல். c இல் முழு எண் வகைகளின் அளவு.

வகை	அளவு, பைட்டுகள்	குறைந்தபட்ச மதிப்பு	அதிகபட்ச மதிப்பு
கையொப்பமிடாத கரி	1	0	255
கையொப்பமிட்ட கரி (கரி)	1	-128	127
கையொப்பமிடப்படாத குறுகிய	2	0	65535
சுருக்கமாக கையெழுத்திட்டார் (குறுகிய)	2	-32768	32767
கையொப்பமிடப்படாத முழு எண்ணாக (கையொப்பமிடாத)	4	0	4294967296
கையொப்பமிடப்பட்டது (int)	4	-2147483648	2147483647
கையொப்பமிடாத நீண்ட	4	0	4294967296
நீண்ட கையெழுத்து (நீண்ட)	4	-2147483648	2147483647
கையொப்பமிடாத நீண்ட நீண்ட	8	0	18446744073709551615
நீண்ட கையெழுத்து (நீண்ட நீளம்)	8	-9223372036854775808	9223372036854775807

அளவு

C இல் ஒரு ஆபரேட்டர் உள்ளது, இது ஒரு மாறியின் அளவை பைட்டுகளில் பெற அனுமதிக்கிறது. அளவு மாறி, அல்லது அளவு (மாறி) அல்லது அளவு (வகை). இது ஒரு ஆபரேட்டராகும், ஏனெனில் செயல்பாட்டிற்கு பயன்பாடு செயல்படுத்தும் போது வகை அளவு தகவலைப் பெற வழி இல்லை. மாறிகளின் அளவை சரிபார்க்க ஒரு சிறிய நிரலை எழுதுவோம்.

#சேர்க்கிறது #சேர்க்கிறது int main() (char c; short s; int i; long l; long long L; //Call sizeof as a “function” printf("sizeof(char) = %d\n", sizeof(c)); printf ("sizeof(short) = %d\n", sizeof(s)); printf("sizeof(int) = %d\n", sizeof(i)); printf("sizeof(long) = %d \ n", sizeof(l)); printf("sizeof(நீண்ட நீளம்) = %d\n", sizeof(L)); //ஆபரேட்டராக அழைக்கவும் printf("sizeof(char) = %d\n", sizeof c); printf("sizeof(short) = %d\n", sizeof s); printf("sizeof(int) = %d\n", sizeof i); printf("sizeof(long) = %d \ n", sizeof l); printf("sizeof(நீண்ட நீளம்) = %d\n", sizeof L); _getch(); )

(மாறிகள் ஏதேனும் சரியான பெயரைக் கொண்டிருக்கலாம் என்பது தெளிவாகிறது என்று நினைக்கிறேன்). இந்த திட்டத்தை எளிமையாக எழுதியிருக்கலாம்

#சேர்க்கிறது #சேர்க்கிறது int main() ( printf("sizeof(char) = %d\n", sizeof(char)); printf("sizeof(short) = %d\n", sizeof(short)); printf("sizeof("sizeof( int) = %d\n", sizeof(int)); printf("sizeof(long) = %d\n", sizeof(long)); printf("sizeof(long long) = %d\n", sizeof(நீண்ட நீளம்)); //நீங்கள் sizeof ஐ ஒரு வகை பெயருக்கு ஆபரேட்டராக அழைக்க முடியாது //sizeof int - தொகுத்தல் பிழை _getch(); )

C இல், ஒரே வகைக்கு பல பெயர்கள் இருக்கலாம்
குறுகிய === குறுகிய எண்ணாக
நீண்ட === நீண்ட எண்ணாக
நீண்ட நீண்ட === நீண்ட நீண்ட எண்ணாக
unsigned int === கையொப்பமிடாதது

மிதக்கும் புள்ளி வகைகள்

• மிதவை- 4 பைட்டுகள்,
• நீண்ட மிதவை- 8 பைட்டுகள்
• இரட்டை- 8 பைட்டுகள்
• நீண்ட இரட்டை- 8 பைட்டுகள்.

மிதவை வகைகளின் நிலையான அளவின் படி VC2012 க்கான மதிப்புகள் இங்கே உள்ளன<= long float <= double <= long double все числа с плавающей точкой - со знаком.

மாறி வழிதல்

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

#சேர்க்கிறது #சேர்க்கிறது void main() (கையொப்பமிடப்படாத a = 4294967295; int b = 2147483647; //கையொப்பமிடப்படாத வகை overflow printf("%u\n", a); a += 1; printf("%u", a); //Overflow கையொப்பமிடப்பட்ட வகை printf("%d\n", b); b += 1; printf("%d", b); getch(); )

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

போஸ்ட்ஃபிக்ஸ் வகை பதவி

எண்களுடன் பணிபுரியும் போது, ​​எண்ணின் முடிவில் உள்ள எழுத்துக்களைப் பயன்படுத்தி அதன் வகையை வெளிப்படையாகக் குறிப்பிடலாம், எடுத்துக்காட்டாக

• 11 - முழு எண்
• 10u - கையொப்பமிடப்படாதது
• 22லி அல்லது 22லி - நீளம்
• 3890ll அல்லது 3890LL - நீண்ட நீளம் (lL அல்லது Ll)
• 80.0f அல்லது 80.f அல்லது 80.0F - மிதவை (பதிவில் ஒரு தசம புள்ளி இருக்க வேண்டும்)
• 3.0 - இரட்டை எண்

அறிவியல் குறியீடானது முன்னிருப்பாக இரட்டிப்பைக் குறிக்கிறது. #சேர்க்கிறது #சேர்க்கிறது int main() ( printf("sizeof(int) = %d\n", sizeof(10)); printf("sizeof(unigned) = %d\n", sizeof(10u)); printf("sizeof("sizeof( நீளம்) = %d\n", sizeof(10l)); printf("sizeof(நீண்ட நீளம்) = %d\n", sizeof(10ll)); printf("sizeof(float) = %d\n", sizeof(10.f)); printf("sizeof(double) = %d\n", sizeof(10.)); printf("sizeof(double) = %d\n", sizeof(10e2)); getch ();)

இருப்பினும், பின்வரும் குறியீடு பிழைகளை உருவாக்காது, ஏனெனில் மறைமுக வகை மாற்றம் உள்ளது

Int a = 10u; இரட்டை g = 3.f;

ஹெக்ஸாடெசிமல் மற்றும் ஆக்டல் வடிவம்

எண்களுடன் பணிபுரியும் போது, ​​நீங்கள் ஹெக்ஸாடெசிமல் மற்றும் ஆக்டல் வடிவங்களைப் பயன்படுத்தலாம். ஹெக்ஸாடெசிமல் எண் அமைப்பில் உள்ள எண்கள் 0x உடன் தொடங்குகின்றன, எண்ம எண் அமைப்பில் அவை பூஜ்ஜியத்தில் தொடங்குகின்றன. அதன்படி, ஒரு எண் பூஜ்ஜியத்திலிருந்து தொடங்கினால், அது 7 ஐ விட அதிகமான இலக்கங்களைக் கொண்டிருக்கக்கூடாது:

#சேர்க்கிறது #சேர்க்கிறது void main() (int x = 0xFF; int y = 077; printf("hex x = %x\n", x); printf("dec x = %d\n", x); printf("oct x = %o\n", x); printf("oct y = %o\n", y); printf("dec y = %d\n", y); printf("hex y = %x", y); கெட்ச் (); )

எண்களுக்கான அறிவியல் குறியீடு

ஒரு எண்ணைக் குறிக்கும் அதிவேக வடிவம் என்பது M e ± p வடிவத்தில் உள்ள எண்ணின் பிரதிநிதித்துவமாகும். எம்- எண்ணின் மாண்டிசா, ப- பத்து சக்தி. இந்த வழக்கில், தசம புள்ளிக்கு முன் மன்டிசா ஒரு பூஜ்ஜியமற்ற அடையாளத்தைக் கொண்டிருக்க வேண்டும்.
உதாரணமாக 1.25 === 1.25e0, 123.5 === 1.235e2, 0.0002341 === 2.341e-4, முதலியன.
3.2435e7 பிரதிநிதித்துவங்கள் 3.2435e+7க்கு சமம்
மற்றொரு பிரதிநிதித்துவம் உள்ளது ("பொறியியல்"), இதில் பட்டம் மூன்றின் பெருக்கமாக இருக்க வேண்டும். எடுத்துக்காட்டாக 1.25 === 1.25e0, 123.5 === 123.5e0, 0.0002341 === 234.1e-6, 0.25873256 === 258.73256e-3, முதலியன.

மாறிகளை அறிவித்தல்

C இல், மாறிகள் எப்போதும் ஒரு தொகுதியின் தொடக்கத்தில் அறிவிக்கப்படும் (ஒரு தொகுதி என்பது சுருள் பிரேஸ்களால் பிரிக்கப்பட்ட குறியீட்டின் ஒரு பகுதி)

<возвращаемый тип> <имя функции> (<тип> <аргумент>[, <тип> <аргумент>]) (மாறிகளின் அறிவிப்பு, மற்ற அனைத்தும்)

ஒரு மாறியை அறிவிக்கும் போது, ​​அதன் வகை மற்றும் பெயர் எழுதப்படும்.

Int a; இரட்டை அளவுரு;

பெயர்களை கமாவால் பிரிப்பதன் மூலம் ஒரே வகையின் பல மாறிகளை நீங்கள் அறிவிக்கலாம்

நீண்ட நீண்ட arg1, arg2, arg3;

உதாரணத்திற்கு

#சேர்க்கிறது #சேர்க்கிறது int main() ( int a = 10; int b; while (a>0)( int z = a*a; b += z; ) )

மாறிகள் இங்கே அறிவிக்கப்படுகின்றன அமற்றும் பிஒரு செயல்பாட்டின் உள்ளே முக்கிய, மற்றும் மாறி zவளைய உடலின் உள்ளே. பின்வரும் குறியீடு தொகுத்தல் பிழையை ஏற்படுத்தும்

Int main() (int i; i = 10; int j;)

ஏனென்றால், அசைன்மென்ட் ஆபரேட்டருக்குப் பிறகு மாறி அறிவிப்பு வருகிறது. மாறிகளை அறிவிக்கும் போது, ​​அவற்றை உடனடியாக துவக்கலாம்.
int i = 0;
இருப்பினும், ஒரு மாறியை அறிவிக்கும் போது துவக்குவது ஒரு தனி அறிக்கையாக கருதப்படாது, எனவே பின்வரும் குறியீடு வேலை செய்யும்

Int main() ( int i = 10; int j; )

மாறியின் ஆரம்ப மதிப்பு

பல நிரலாக்க மொழிகளைப் போல, C இல் உள்ள மாறிகள் இயல்புநிலையாக பூஜ்ஜியத்திற்கு துவக்கப்படவில்லை என்பதை நினைவில் கொள்வது மிகவும் முக்கியம். ஒரு மாறியை அறிவித்த பிறகு, அது “குப்பையை” சேமிக்கிறது - இது மாறிக்கு ஒதுக்கப்பட்ட நினைவகப் பகுதியில் இருக்கும் சீரற்ற மதிப்பு. இது முதலில், நிரலின் மேம்படுத்தல் காரணமாகும்: துவக்கம் தேவையில்லை என்றால், பூஜ்ஜியங்களை எழுதி வளங்களை வீணாக்க வேண்டிய அவசியமில்லை (குறிப்பு: உலகளாவிய மாறிகள் பூஜ்ஜியங்களுடன் துவக்கப்படுகின்றன, ஏன், இந்த கட்டுரையைப் படியுங்கள்) .

#சேர்க்கிறது #சேர்க்கிறது int main() (int i; printf("%d", i); getch(); )

நீங்கள் VC இல் இந்த நிரலை இயக்கினால், செயல்படுத்தும் போது ஒரு எச்சரிக்கை தோன்றும்
ரன்-டைம் சரிபார்ப்பு தோல்வி #3 - "i" மாறி துவக்கப்படாமல் பயன்படுத்தப்படுகிறது.
நீங்கள் "தொடரவும்" என்பதைக் கிளிக் செய்தால், நிரல் "குப்பை" வெளியிடும். மற்ற பல கம்பைலர்களில் நிரல் செயல்படுத்தப்படும் போது எந்த எச்சரிக்கையும் இருக்காது.

மாறக்கூடிய நோக்கம்

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

#சேர்க்கிறது #சேர்க்கிறது முழு எண்ணாக உலகளாவிய = 100; void foo() ( printf("foo: %d\n", global); ) void bar(int global) ( printf("bar: %d\n", global); ) int main() ( foo() ; பார் (333); கெட்ச் (); )

காட்டப்படும்
foo: 100
பார்: 333
இங்கே ஒரு உலகளாவிய மாறி உள்ளது உலகளாவியஅனைத்து செயல்பாடுகளுக்கும் தெரியும். ஆனால் செயல்பாடு வாதம் உலகளாவிய மாறியை மேலெழுதுகிறது, எனவே வாதம் 333 ஐ கடக்கும்போது, ​​உள்ளூர் மதிப்பு 333 அச்சிடப்படுகிறது.
இதோ இன்னொரு உதாரணம்

#சேர்க்கிறது #சேர்க்கிறது முழு எண்ணாக உலகளாவிய = 100; int main() ( int global = 555; printf("%d\n", global); getch(); )

நிரல் 555 ஐ வெளியிடும். முந்தைய வழக்கைப் போலவே, உள்ளூர் மாறி "மிகவும் முக்கியமானது". ஒரு குறிப்பிட்ட ஸ்கோப்பில் அறிவிக்கப்பட்ட ஒரு மாறி அதற்கு வெளியே தெரியவில்லை, எடுத்துக்காட்டாக

#சேர்க்கிறது #சேர்க்கிறது முழு எண்ணாக உலகளாவிய = 100; int main() (int x = 10; (int y = 30; printf("%d", x); ) printf("%d", y); )

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

#சேர்க்கிறது #சேர்க்கிறது முழு எண்ணாக உலகளாவிய = 100; int main() (int x = 10; (int x = 20; (int x = 30; printf("%d\n", x); ) printf("%d\n", x); ) printf( "%d\n", x); getch(); )

நிரல் அச்சிடப்படும்
30
20
10
உலகளாவிய மாறிகள் தவிர்க்கப்பட வேண்டும். இதை நீங்கள் அடிக்கடி கேட்கலாம். ஏன் என்பதைக் கண்டுபிடிக்க முயற்சிப்போம். உங்கள் எளிய திட்டங்களில், உலகளாவிய மாறிகள் மிகவும் சாதாரணமாக இருக்கும். ஆனால் உங்களிடம் ஒரு பயன்பாடு இருப்பதாக கற்பனை செய்து பாருங்கள்

• 1) பல நபர்களால் உருவாக்கப்பட்டது மற்றும் நூறாயிரக்கணக்கான கோடுகளைக் கொண்டது
• 2) பல இழைகளில் வேலை செய்கிறது

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

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

இந்த பிரிவு C++ இல் உள்ள முக்கிய தரவு வகைகளைப் பற்றி விவாதிக்கும்; இந்த தரவு வகைகள் உள்ளமைக்கப்பட்டவை என்றும் அழைக்கப்படுகின்றன. C++ நிரலாக்க மொழி ஒரு விரிவாக்கக்கூடிய நிரலாக்க மொழியாகும். நீட்டிக்கக்கூடிய சொல் என்பது உள்ளமைக்கப்பட்ட தரவு வகைகளுக்கு கூடுதலாக, நீங்கள் உங்கள் சொந்த தரவு வகைகளை உருவாக்கலாம். அதனால்தான் C++ இல் அதிக எண்ணிக்கையிலான தரவு வகைகள் உள்ளன. முக்கியவற்றை மட்டும் படிப்போம்.

அட்டவணை 1 - C++ தரவு வகைகள்

வகை	பைட்	ஏற்றுக்கொள்ளப்பட்ட மதிப்புகளின் வரம்பு
முழு எண் (பூலியன்) தரவு வகை
பூல்	1	0 / 255
முழு எண் (எழுத்து) தரவு வகை
கரி	1	0 / 255
முழு எண் தரவு வகைகள்
குறுகிய முழு எண்ணாக	2	-32 768 / 32 767
கையொப்பமிடப்படாத குறுகிய எண்ணாக	2	0 / 65 535
முழு எண்ணாக	4
கையொப்பமிடப்படாத முழு எண்ணாக	4	0 / 4 294 967 295
நீண்ட எண்ணாக	4	-2 147 483 648 / 2 147 483 647
கையொப்பமிடப்படாத நீண்ட எண்ணாக	4	0 / 4 294 967 295
மிதக்கும் புள்ளி தரவு வகைகள்
மிதவை	4	-2 147 483 648.0 / 2 147 483 647.0
நீண்ட மிதவை	8
இரட்டை	8	-9 223 372 036 854 775 808 .0 / 9 223 372 036 854 775 807.0

C++ இல் உள்ள முக்கிய தரவு வகைகளை அட்டவணை 1 காட்டுகிறது. முழு அட்டவணையும் மூன்று நெடுவரிசைகளாக பிரிக்கப்பட்டுள்ளது. முதல் நெடுவரிசை ஒரு ஒதுக்கப்பட்ட வார்த்தையைக் குறிக்கிறது, இது ஒவ்வொன்றும் அதன் சொந்த தரவு வகையை தீர்மானிக்கும். இரண்டாவது நெடுவரிசை, தொடர்புடைய தரவு வகையுடன் மாறிக்கு ஒதுக்கப்பட்ட பைட்டுகளின் எண்ணிக்கையைக் குறிக்கிறது. மூன்றாவது நெடுவரிசை ஏற்றுக்கொள்ளக்கூடிய மதிப்புகளின் வரம்பைக் காட்டுகிறது. அட்டவணையில் அனைத்து தரவு வகைகளும் சிறியது முதல் பெரியது வரை வரிசைப்படுத்தப்பட்டுள்ளன என்பதை நினைவில் கொள்ளவும்.

bool தரவு வகை

அட்டவணையில் முதலில் இருப்பது பூல் தரவு வகை — ஒரு முழு எண் தரவு வகை, ஏனெனில் செல்லுபடியாகும் மதிப்புகளின் வரம்பு 0 முதல் 255 வரை முழு எண்களாகும். ஆனால் நீங்கள் ஏற்கனவே கவனித்தபடி, அடைப்புக்குறிக்குள் தருக்க தரவு வகை என்று கூறுகிறது, இதுவும் உண்மைதான். ஏனெனில் பூல்பூலியன் வெளிப்பாடுகளின் முடிவுகளைச் சேமிக்க பிரத்தியேகமாகப் பயன்படுத்தப்படுகிறது. பூலியன் வெளிப்பாடு இரண்டு முடிவுகளில் ஒன்றைக் கொண்டிருக்கலாம்: உண்மை அல்லது தவறு. உண்மை - தருக்க வெளிப்பாடு உண்மையாக இருந்தால், தவறானது - தருக்க வெளிப்பாடு தவறாக இருந்தால்.

ஆனால் பூல் தரவு வகையின் செல்லுபடியாகும் மதிப்புகளின் வரம்பு 0 முதல் 255 வரை இருப்பதால், நிரலாக்க மொழியில் வரையறுக்கப்பட்ட உண்மை மற்றும் தவறான தர்க்க மாறிலிகளுடன் இந்த வரம்பை எப்படியாவது பொருத்துவது அவசியம். எனவே, மாறிலி உண்மை என்பது 1 முதல் 255 வரை உள்ள அனைத்து எண்களுக்கும் சமமானதாகும், அதே சமயம் நிலையான தவறானது ஒரே ஒரு முழு எண்ணுக்குச் சமமானது - 0. பூல் தரவு வகையைப் பயன்படுத்தி ஒரு நிரலைக் கவனியுங்கள்.

// data_type.cpp: கன்சோல் பயன்பாட்டிற்கான நுழைவுப் புள்ளியை வரையறுக்கிறது. # "stdafx.h" #உள்ளடங்கும் பெயர்வெளி std ஐப் பயன்படுத்துதல்; int main(int argc, char* argv) ( bool boolean = 25; // பூலியன் என பெயரிடப்பட்ட பூல் வகையின் மாறி // if cout operator இன் நிலை<< "true = " << boolean << endl; // выполнится в случае истинности условия else cout << "false = " << boolean << endl; // выполнится в случае, если условие ложно system("pause"); return 0; }

IN வரி 9வகை மாறி அறிவிக்கப்பட்டதுபூல் , இது 25 க்கு துவக்கப்பட்டது. கோட்பாட்டளவில், பிறகுவரிகள் 9, பூலியன் மாறியில் எண் 25 ஐக் கொண்டிருக்க வேண்டும், ஆனால் உண்மையில் இந்த மாறி எண் 1 ஐக் கொண்டுள்ளது. நான் சொன்னது போல், எண் 0 ஒரு தவறான மதிப்பு, எண் 1 ஒரு உண்மையான மதிப்பு. புள்ளி ஒரு மாறி போன்றபூல் இரண்டு மதிப்புகளைக் கொண்டிருக்கலாம் - 0 (தவறு) அல்லது 1 (உண்மை). அதேசமயம் தரவு வகையின் கீழ்பூல் ஒரு முழு பைட் ஒதுக்கப்பட்டுள்ளது, அதாவது வகையின் மாறிபூல் 0 முதல் 255 வரையிலான எண்களைக் கொண்டிருக்கலாம். தவறான மற்றும் உண்மையான மதிப்புகளைத் தீர்மானிக்க, இரண்டு மதிப்புகள் 0 மற்றும் 1 மட்டுமே தேவை. கேள்வி எழுகிறது: "மற்ற 253 மதிப்புகள் எதற்காக?"

இந்த சூழ்நிலையின் அடிப்படையில், 2 முதல் 255 வரையிலான எண்களை எண் 1 க்கு சமமாக பயன்படுத்த ஒப்புக்கொண்டோம், அதாவது உண்மை. பூலியன் மாறி 25 என்ற எண்ணைக் கொண்டுள்ளது மற்றும் 1. இல் இல்லை வரிகள் 10-13அறிவிக்கப்பட்டது, இது கட்டுப்பாட்டை ஆபரேட்டருக்கு மாற்றுகிறது வரி 11, நிபந்தனை உண்மையாக இருந்தால், மற்றும் ஆபரேட்டர் வரி 13, நிபந்தனை தவறானதாக இருந்தால். நிரலின் முடிவு படம் 1 இல் காட்டப்பட்டுள்ளது.

உண்மை = 1 தொடர, எந்த விசையையும் அழுத்தவும். . .

படம் 1 - பூல் தரவு வகை

தரவு வகை சார்

சார் தரவு வகை என்பது ஒரு முழு எண் தரவு வகையாகும், இது எழுத்துக்களைக் குறிக்கப் பயன்படுகிறது. அதாவது, ஒவ்வொரு எழுத்தும் வரம்பிலிருந்து ஒரு குறிப்பிட்ட எண்ணுக்கு ஒத்திருக்கும். C++ இல் உள்ள எழுத்துக்களின் வரைகலைப் பிரதிநிதித்துவம் char மூலம் சாத்தியம் என்பதால், char தரவு வகையானது எழுத்துத் தரவு வகை என்றும் அழைக்கப்படுகிறது. C++ இல் உள்ள எழுத்துக்களைப் பிரதிநிதித்துவப்படுத்த, சார் தரவு வகைக்கு ஒரு பைட் ஒதுக்கப்படுகிறது, ஒரு பைட்டில் 8 பிட்கள் உள்ளன, பின்னர் இரண்டை 8 இன் சக்திக்கு உயர்த்தி 256 மதிப்பைப் பெறுகிறோம் - குறியாக்கம் செய்யக்கூடிய எழுத்துக்களின் எண்ணிக்கை. எனவே, சார் தரவு வகையைப் பயன்படுத்தி, நீங்கள் 256 எழுத்துகளில் ஏதேனும் ஒன்றைக் காட்டலாம். அனைத்து குறியிடப்பட்ட எழுத்துகளும் இல் குறிப்பிடப்படுகின்றன.

ASCII (தகவல் பரிமாற்றத்திற்கான ஆங்கில தரநிலைக் குறியீட்டிலிருந்து) - தகவல் பரிமாற்றத்திற்கான அமெரிக்க நிலையான குறியீடு.

சார் தரவு வகையைப் பயன்படுத்தி ஒரு நிரலைக் கவனியுங்கள்.

// symbols.cpp: கன்சோல் பயன்பாட்டிற்கான நுழைவுப் புள்ளியை வரையறுக்கிறது. # "stdafx.h" #உள்ளடங்கும் பெயர்வெளி std ஐப் பயன்படுத்துதல்; int main(int argc, char* argv) ( சார் சின்னம் = "a"; // சார் வகையின் மாறியை அறிவித்து, "a" cout என்ற குறியீட்டைக் கொண்டு துவக்குதல்<< "symbol = " << symbol << endl; // печать символа, содержащегося в переменной symbol char string = "сайт"; // объявление символьного массива (строки) cout << "string = " << string << endl; // печать строки system("pause"); return 0; }

எனவே, உள்ளே வரி 9என்ற ஒரு மாறிசின்னம் , இது குறியீட்டு மதிப்பு ஒதுக்கப்படுகிறது"a" ( ASCII குறியீடு) IN வரி 10கவுட் ஆபரேட்டர் மாறியில் உள்ள எழுத்தை அச்சிடுகிறதுசின்னம் IN வரி 11பெயருடன் ஒரு சரம் வரிசையை அறிவித்தார்லேசான கயிறு , மற்றும் வரிசையின் அளவு மறைமுகமாக குறிப்பிடப்பட்டுள்ளது. ஒரு சரம் ஒரு சரம் வரிசையில் சேமிக்கப்படுகிறது"இணையதளம்" . நாம் சின்னத்தை ஒரு மாறியில் சேமித்த போது என்பதை நினைவில் கொள்ளவும்கரி , பின்னர் சம அடையாளத்திற்குப் பிறகு நாம் குறியீட்டை எழுதிய ஒற்றை மேற்கோள்களை வைக்கிறோம். ஒரு குறிப்பிட்ட சரத்துடன் ஒரு சரம் வரிசையை துவக்கும் போது, ​​ஒரு குறிப்பிட்ட சரம் எழுதப்பட்ட சம அடையாளத்திற்குப் பிறகு இரட்டை மேற்கோள்கள் வைக்கப்படுகின்றன. வழக்கமான எழுத்தைப் போலவே, சரங்களும் ஆபரேட்டரைப் பயன்படுத்தி வெளியீடு ஆகும்கூட், வரி 12. நிரலின் முடிவு படம் 2 இல் காட்டப்பட்டுள்ளது.

சின்னம் = ஒரு சரம் = தளம் தொடர, எந்த விசையையும் அழுத்தவும். . .

படம் 2 - சார் தரவு வகை

முழு எண் தரவு வகைகள்

எண்களைக் குறிக்க முழு எண் தரவு வகைகள் பயன்படுத்தப்படுகின்றன. அட்டவணை 1 இல் அவற்றில் ஆறு உள்ளன: குறுகிய எண்ணாக, கையொப்பமிடப்படாத குறுகிய எண்ணாக, முழு எண்ணாக, கையொப்பமிடப்படாத முழு எண்ணாக, நீண்ட எண்ணாக, கையொப்பமிடப்படாத நீண்ட எண்ணாக உள்ளது. . அவை அனைத்தும் அவற்றின் சொந்த நினைவக அளவு மற்றும் ஏற்றுக்கொள்ளப்பட்ட மதிப்புகளின் வரம்பைக் கொண்டுள்ளன. கம்பைலரைப் பொறுத்து, நினைவகத்தின் அளவு மற்றும் ஏற்றுக்கொள்ளப்பட்ட மதிப்புகளின் வரம்பு மாறுபடலாம். அட்டவணை 1 இல், MVS2010 கம்பைலருக்கு ஏற்றுக்கொள்ளப்பட்ட மதிப்புகள் மற்றும் ஆக்கிரமிக்கப்பட்ட நினைவகத்தின் அளவுகளின் அனைத்து வரம்புகளும் எடுக்கப்படுகின்றன. மேலும், அட்டவணை 1 இல் உள்ள அனைத்து தரவு வகைகளும் ஆக்கிரமிக்கப்பட்ட நினைவகத்தின் அளவு மற்றும் ஏற்றுக்கொள்ளப்பட்ட மதிப்புகளின் வரம்பை அதிகரிக்கும் வரிசையில் அமைக்கப்பட்டுள்ளன. ஏற்றுக்கொள்ளப்பட்ட மதிப்புகளின் வரம்பு, ஒரு வழி அல்லது வேறு, ஆக்கிரமிக்கப்பட்ட நினைவகத்தின் அளவைப் பொறுத்தது. அதன்படி, ஆக்கிரமிக்கப்பட்ட நினைவகத்தின் அளவு பெரியது, ஏற்றுக்கொள்ளப்பட்ட மதிப்புகளின் வரம்பு பெரியதாக இருக்கும். மேலும், தரவு வகை கையொப்பமிடப்படாத முன்னொட்டுடன் அறிவிக்கப்பட்டால் ஏற்றுக்கொள்ளப்பட்ட மதிப்புகளின் வரம்பு மாறுகிறது. கையொப்பமிடப்படாத முன்னொட்டு என்பது தரவு வகை கையொப்பமிடப்பட்ட மதிப்புகளைச் சேமிக்க முடியாது என்பதாகும், பின்னர் நேர்மறை மதிப்புகளின் வரம்பு இரட்டிப்பாகிறது, எடுத்துக்காட்டாக, குறுகிய எண்ணும் கையொப்பமிடப்படாத குறுகிய எண்ணும் தரவு வகைகள்.

முழு எண் தரவு வகை முன்னொட்டுகள்:

குறுகிய — முன்னொட்டு அது ஆக்கிரமித்துள்ள நினைவகத்தின் அளவைக் குறைப்பதன் மூலம் அது பயன்படுத்தப்படும் தரவு வகையைக் குறைக்கிறது;

நீளமானது — முன்னொட்டு அது ஆக்கிரமித்துள்ள நினைவகத்தின் அளவை அதிகரிப்பதன் மூலம் பயன்படுத்தப்படும் தரவு வகையை விரிவுபடுத்துகிறது;

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

எனவே, அடிப்படையில், முழு எண்களைக் குறிக்க ஒரு முழு எண் வகை உள்ளது: int தரவு வகை. குறுகிய, நீண்ட, கையொப்பமிடப்படாத முன்னொட்டுகளுக்கு நன்றி, ஒரு குறிப்பிட்ட வகையான எண்ணற்ற தரவு வகைகள் தோன்றும், ஆக்கிரமிக்கப்பட்ட நினைவகத்தின் அளவு மற்றும் (அல்லது) ஏற்றுக்கொள்ளப்பட்ட மதிப்புகளின் வரம்பில் வேறுபடுகின்றன.

மிதக்கும் புள்ளி தரவு வகைகள்

C++ இல் இரண்டு வகையான மிதக்கும் புள்ளி தரவுகள் உள்ளன: மிதவை மற்றும் இரட்டை. மிதக்கும் புள்ளி தரவு வகைகள் மிதக்கும் புள்ளி எண்களை சேமிக்க வடிவமைக்கப்பட்டுள்ளன. மிதவை மற்றும் இரட்டை தரவு வகைகள் நேர்மறை மற்றும் எதிர்மறை மிதக்கும் புள்ளி எண்களை சேமிக்க முடியும். மிதவை தரவு வகை இரட்டை தரவு வகையின் பாதி நினைவக தடம் உள்ளது, அதாவது ஏற்றுக்கொள்ளப்பட்ட மதிப்புகளின் வரம்பும் சிறியது. மிதவை தரவு வகை நீண்ட முன்னொட்டுடன் அறிவிக்கப்பட்டால், ஏற்றுக்கொள்ளப்பட்ட மதிப்புகளின் வரம்பு இரட்டை தரவு வகையின் ஏற்றுக்கொள்ளப்பட்ட மதிப்புகளின் வரம்பிற்கு சமமாக இருக்கும். அடிப்படையில், பணப் பரிவர்த்தனைகள் போன்ற உயர் கணக்கீட்டுத் துல்லியத்துடன் சிக்கல்களைத் தீர்க்க மிதக்கும் புள்ளி தரவு வகைகள் தேவைப்படுகின்றன.

எனவே, C++ இல் உள்ள முக்கிய தரவு வகைகளைப் பற்றிய முக்கிய புள்ளிகளைப் பார்த்தோம். ஏற்றுக்கொள்ளப்பட்ட மதிப்புகளின் இந்த வரம்புகள் மற்றும் ஆக்கிரமிக்கப்பட்ட நினைவகத்தின் அளவுகள் எங்கிருந்து வருகின்றன என்பதைக் காண்பிப்பது மட்டுமே எஞ்சியுள்ளது. இதற்காக மேலே விவாதிக்கப்பட்ட அனைத்து வகையான தரவுகளின் முக்கிய பண்புகளையும் கணக்கிடும் ஒரு நிரலை உருவாக்குவோம்.

// data_types.cpp: கன்சோல் பயன்பாட்டிற்கான நுழைவுப் புள்ளியை வரையறுக்கிறது. # "stdafx.h" #உள்ளடங்கும் // I/O கையாளுதல் நூலகம் # அடங்கும் // கணித செயல்பாடுகளின் தலைப்பு கோப்பு # அடங்கும் பெயர்வெளி std ஐப் பயன்படுத்துதல்; int main(int argc, char* argv) ( cout<< " data type " << "byte" << " " << " max value "<< endl // நெடுவரிசை தலைப்புகள் <<"bool = " << sizeof(bool) << " " << fixed << setprecision(2) /*вычисляем максимальное значение для типа данных bool*/ << (pow(2,sizeof(bool) * 8.0) - 1) << endl << "char = " << sizeof(char) << " " << fixed << setprecision(2) /*вычисляем максимальное значение для типа данных char*/ << (pow(2,sizeof(char) * 8.0) - 1) << endl << "short int = " << sizeof(short int) << " " << fixed << setprecision(2) /*вычисляем максимальное значение для типа данных short int*/ << (pow(2,sizeof(short int) * 8.0 - 1) - 1) << endl << "unsigned short int = " << sizeof(unsigned short int) << " " << fixed << setprecision(2) /*вычисляем максимальное значение для типа данных unsigned short int*/ << (pow(2,sizeof(unsigned short int) * 8.0) - 1) << endl << "int = " << sizeof(int) << " " << fixed << setprecision(2) /*вычисляем максимальное значение для типа данных int*/ << (pow(2,sizeof(int) * 8.0 - 1) - 1) << endl << "unsigned int = " << sizeof(unsigned int) << " " << fixed << setprecision(2) /*вычисляем максимальное значение для типа данных unsigned int*/ << (pow(2,sizeof(unsigned int) * 8.0) - 1) << endl << "long int = " << sizeof(long int) << " " << fixed << setprecision(2) /*вычисляем максимальное значение для типа данных long int*/ << (pow(2,sizeof(long int) * 8.0 - 1) - 1) << endl << "unsigned long int = " << sizeof(unsigned long int) << " " << fixed << setprecision(2) /*вычисляем максимальное значение для типа данных undigned long int*/ << (pow(2,sizeof(unsigned long int) * 8.0) - 1) << endl << "float = " << sizeof(float) << " " << fixed << setprecision(2) /*вычисляем максимальное значение для типа данных float*/ << (pow(2,sizeof(float) * 8.0 - 1) - 1) << endl << "double = " << sizeof(double) << " " << fixed << setprecision(2) /*вычисляем максимальное значение для типа данных double*/ << (pow(2,sizeof(double) * 8.0 - 1) - 1) << endl; system("pause"); return 0; }

உங்கள் கணினியில் உள்ள தரவு வகைகளின் சிறப்பியல்புகளைக் காணும் வகையில் இந்த நிரல் இடுகையிடப்பட்டுள்ளது. நிரல் உங்களுக்கு இன்னும் அறிமுகமில்லாத கட்டுப்பாட்டு அறிக்கைகளைப் பயன்படுத்துவதால், குறியீட்டைப் புரிந்து கொள்ள வேண்டிய அவசியமில்லை. நிரல் குறியீட்டுடன் மேலோட்டமான அறிமுகத்திற்கு, கீழே சில புள்ளிகளை விளக்குகிறேன். ஆபரேட்டர்அளவு() தரவு வகை அல்லது மாறிக்கு ஒதுக்கப்பட்ட பைட்டுகளின் எண்ணிக்கையைக் கணக்கிடுகிறது. செயல்பாடுபவ்(x,y) அர்த்தத்தை உயர்த்துகிறது y இன் சக்திக்கு x , இந்தச் செயல்பாடு ஹெடர் கோப்பில் இருந்து கிடைக்கும் . நிலையான மற்றும் செட்பிரிசிஷன்() கையாளுபவர்கள் தலைப்பு கோப்பிலிருந்து கிடைக்கும் . முதலாவது நிலையானது , நிலையான வடிவத்தில் மதிப்புகளை வெளியீட்டு ஸ்ட்ரீமுக்கு அனுப்புகிறது. கையாளுபவர் setprecision(n) displays n தசம இடங்கள். ஒரு குறிப்பிட்ட தரவு வகையின் அதிகபட்ச மதிப்பு பின்வரும் சூத்திரத்தைப் பயன்படுத்தி கணக்கிடப்படுகிறது:

Max_val_type = 2^(b * 8 - 1) - 1; // எதிர்மறை மற்றும் நேர்மறை எண்களைக் கொண்ட தரவு வகைகளுக்கு // இங்கு b என்பது இந்த தரவு வகையுடன் கூடிய மாறிக்கு நினைவகத்தில் ஒதுக்கப்பட்ட பைட்டுகளின் எண்ணிக்கை // 8 ஆல் பெருக்கவும், ஒரு பைட்டில் 8 பிட்கள் இருப்பதால் // அடைப்புக்குறிக்குள் 1 ஐக் கழிக்கவும், வரம்பு எண்கள் நேர்மறை மற்றும் எதிர்மறை மதிப்புகளுக்கு இரண்டாகப் பிரிக்கப்பட வேண்டும் என்பதால் // இறுதியில் 1 ஐக் கழிக்கவும், எண்களின் வரம்பு பூஜ்ஜியத்திலிருந்து தொடங்குவதால் // தரவு வகைகள் கையொப்பமிடப்படாத max_val_type = 2^(b * 8) - 1; // நேர்மறை எண்களைக் கொண்ட தரவு வகைகளுக்கு மட்டுமே // சூத்திரத்திற்கான விளக்கங்கள் ஒரே மாதிரியானவை, அலகு மட்டும் அடைப்புக்குறியிலிருந்து கழிக்கப்படவில்லை

நிரல் எவ்வாறு செயல்படுகிறது என்பதற்கான உதாரணத்தை படம் 3 இல் காணலாம். முதல் நெடுவரிசை C++ இல் உள்ள முக்கிய தரவு வகைகளைக் காட்டுகிறது, இரண்டாவது நெடுவரிசை ஒவ்வொரு தரவு வகைக்கும் ஒதுக்கப்பட்ட நினைவகத்தின் அளவைக் காட்டுகிறது, மேலும் மூன்றாவது நெடுவரிசை தொடர்புடைய அதிகபட்ச மதிப்பைக் காட்டுகிறது. தரவு வகை கொண்டிருக்கும். குறைந்தபட்ச மதிப்பு அதிகபட்ச மதிப்பைப் போலவே காணப்படுகிறது. கையொப்பமிடப்படாத முன்னொட்டு கொண்ட தரவு வகைகளுக்கு, குறைந்தபட்ச மதிப்பு 0 ஆகும்.

தரவு வகை பைட் அதிகபட்ச மதிப்பு பூல் = 1 255.00 கரி = 1 255.00 குறுகிய எண்ணாக = 2 32767.00 கையொப்பமிடப்படாத குறுகிய எண்ணாக = 2 65535.00 எண்ணாக = 4 2147483647.00 கையொப்பமிடப்படாத முழு எண்ணாக = 4. 4 42t5 490 42t5 நீண்ட 647. 00 கையொப்பமிடாத நீண்ட எண்ணாக = 4 4294967295.00 மிதவை = 4 2147483647.00 இரட்டை = 8 9223372036854775808.00 தொடர, ஏதேனும் ஒரு விசையை அழுத்தவும். . .

படம் 3 - C++ தரவு வகைகள்

எடுத்துக்காட்டாக, short int வகையின் மாறிக்கு மதிப்பு 33000 ஒதுக்கப்பட்டால், பிட் கட்டம் நிரம்பி வழியும், ஏனெனில் வகை short int இன் ஒரு மாறியின் அதிகபட்ச மதிப்பு 32767 ஆகும். அதாவது, வேறு சில மதிப்பு மாறியில் சேமிக்கப்படும். குறுகிய எண்ணின் வகை, பெரும்பாலும் அது எதிர்மறையாக இருக்கும். நாங்கள் int தரவு வகையைத் தொட்டதால், நீங்கள் int முக்கிய சொல்லைத் தவிர்த்துவிட்டு, எடுத்துக்காட்டாக, சுருக்கமாக எழுதலாம் என்பது குறிப்பிடத்தக்கது. தொகுப்பாளர் அத்தகைய உள்ளீட்டை குறுகிய எண்ணாக விளக்குவார். நீண்ட மற்றும் கையொப்பமிடப்படாத முன்னொட்டுகளுக்கும் இது பொருந்தும். உதாரணத்திற்கு:

// தரவு வகைக்கான சுருக்கெழுத்து int short a1; // குறுகிய முழு எண்ணாக நீளம் a1; // நீண்ட எண்ணாக கையொப்பமிடப்படாத a1; // கையொப்பமிடப்படாத முழு எண்ணாக கையொப்பமிடப்படாத குறுகிய a1; // கையொப்பமிடப்படாத குறுகிய எண்ணைப் போன்றது