പൂർണ്ണസംഖ്യ തരം (int)

തരം വലിപ്പം intസ്റ്റാൻഡേർഡ് നിർവചിച്ചിട്ടില്ല, കമ്പ്യൂട്ടറിനെയും കമ്പൈലറെയും ആശ്രയിച്ചിരിക്കുന്നു.

ഒരു 16-ബിറ്റ് പ്രോസസറിനായി, ഈ തരത്തിലുള്ള മൂല്യങ്ങൾക്കായി 2 ബൈറ്റുകൾ അനുവദിച്ചിരിക്കുന്നു,

32-ബിറ്റ് - 4 ബൈറ്റുകൾക്ക്.

സ്പെസിഫയർ ചെറുത്പ്രോസസർ ബിറ്റ് ഡെപ്‌ത് പരിഗണിക്കാതെ തന്നെ സംഖ്യയ്‌ക്കായി 2 ബൈറ്റുകൾ അനുവദിക്കണമെന്ന് ടൈപ്പ് നാമം കംപൈലറിന് സൂചിപ്പിക്കുന്നതിന് മുമ്പ്.

സ്പെസിഫയർ നീളമുള്ളപൂർണ്ണസംഖ്യ മൂല്യം 4 ബൈറ്റുകൾ ഉൾക്കൊള്ളും എന്നാണ്.

അതിനാൽ ഒരു 16-ബിറ്റ് കമ്പ്യൂട്ടറിൽ int, short int എന്നിവയ്ക്ക് തുല്യമാണ്

കൂടാതെ 32-ബിറ്റിലും - int, long int.

ആന്തരിക പ്രാതിനിധ്യംപൂർണ്ണസംഖ്യ തരം മൂല്യങ്ങൾ - ബൈനറി കോഡിലെ ഒരു പൂർണ്ണസംഖ്യ. സ്പെസിഫയർ ഉപയോഗിക്കുമ്പോൾ ഒപ്പിട്ടുസംഖ്യയുടെ ഏറ്റവും പ്രധാനപ്പെട്ട ബിറ്റ് ഒപ്പിട്ട ഒന്നായി വ്യാഖ്യാനിക്കപ്പെടുന്നു (0 ഒരു പോസിറ്റീവ് സംഖ്യയാണ്, 1 ഒരു നെഗറ്റീവ് സംഖ്യയാണ്). സ്പെസിഫയർ ഒപ്പിടാത്തത്പോസിറ്റീവ് സംഖ്യകളെ മാത്രം പ്രതിനിധീകരിക്കാൻ അനുവദിക്കുന്നു, കാരണം ഏറ്റവും പ്രധാനപ്പെട്ട ബിറ്റ് നമ്പറിന്റെ കോഡിന്റെ ഭാഗമായി കണക്കാക്കുന്നു. അങ്ങനെ, int മൂല്യങ്ങളുടെ ശ്രേണി സ്പെസിഫയറുകളെ ആശ്രയിച്ചിരിക്കുന്നു. ഐബിഎം പിസി-അനുയോജ്യമായ കമ്പ്യൂട്ടറുകൾക്കായുള്ള വിവിധ സ്പെസിഫയറുകളുള്ള പൂർണ്ണസംഖ്യ തരം മൂല്യങ്ങളുടെ മൂല്യങ്ങളുടെ ശ്രേണികൾ "ലളിതമായ ഡാറ്റ തരങ്ങളുടെ മൂല്യ ശ്രേണികൾ" പട്ടികയിൽ നൽകിയിരിക്കുന്നു.

സ്ഥിരസ്ഥിതിയായി, എല്ലാ പൂർണ്ണസംഖ്യ തരങ്ങളും ഒപ്പിട്ടതായി കണക്കാക്കുന്നു, അതായത് ഒപ്പിട്ട സ്പെസിഫയർ ഒഴിവാക്കാം.

ഒരു പ്രോഗ്രാമിൽ കാണുന്ന കോൺസ്റ്റന്റുകൾ അവയുടെ തരത്തിന് അനുസൃതമായി ഒരു തരം അല്ലെങ്കിൽ മറ്റൊന്ന് നൽകിയിരിക്കുന്നു. ചില കാരണങ്ങളാൽ ഇത് പ്രോഗ്രാമർക്ക് അനുയോജ്യമല്ലെങ്കിൽ, നിങ്ങൾക്ക് L, l (നീളം), U, u (ഒപ്പ് ചെയ്യാത്തത്) എന്നീ പ്രത്യയങ്ങൾ ഉപയോഗിച്ച് ആവശ്യമായ തരം വ്യക്തമായി സൂചിപ്പിക്കാൻ കഴിയും. ഉദാഹരണത്തിന്, സ്ഥിരമായ 32L നീളമുള്ളതും 4 ബൈറ്റുകളുള്ളതും ആയിരിക്കും. നിങ്ങൾക്ക് ഒരേ സമയം L, U സഫിക്സുകൾ ഉപയോഗിക്കാം, ഉദാഹരണത്തിന്, 0x22UL അല്ലെങ്കിൽ 05Lu.

കുറിപ്പ്. short int, long int, signed int, unsigned int എന്നീ തരങ്ങളെ യഥാക്രമം short, long, signed, unsigned എന്നിങ്ങനെ ചുരുക്കാം.

പ്രതീക തരം (char)

ഒരു പ്രതീക തരത്തിന്റെ മൂല്യം, തന്നിരിക്കുന്ന കമ്പ്യൂട്ടറിനായുള്ള പ്രതീക സെറ്റിൽ നിന്ന് ഏത് പ്രതീകത്തെയും ഉൾക്കൊള്ളാൻ പര്യാപ്തമായ നിരവധി ബൈറ്റുകൾ അനുവദിച്ചിരിക്കുന്നു, അതാണ് തരത്തിന്റെ പേര് നിർണ്ണയിക്കുന്നത്. സാധാരണയായി ഇത് 1 ബൈറ്റ് ആണ്. മറ്റ് പൂർണ്ണസംഖ്യ തരങ്ങളെപ്പോലെ, ചാർ തരവും ഒപ്പിടുകയോ ഒപ്പിടാതിരിക്കുകയോ ചെയ്യാം. ഒപ്പിട്ട മൂല്യങ്ങൾക്ക് -128 മുതൽ 127 വരെയുള്ള ശ്രേണിയിൽ മൂല്യങ്ങൾ സംഭരിക്കാൻ കഴിയും. ഒപ്പിടാത്ത സ്‌പെസിഫയർ ഉപയോഗിച്ച്, മൂല്യങ്ങൾ 0 മുതൽ 255 വരെയാകാം. 256 പ്രതീകങ്ങളുള്ള ASCII പ്രതീക സെറ്റിൽ ഏത് പ്രതീകവും സംഭരിക്കുന്നതിന് ഇത് മതിയാകും. പൂർണ്ണസംഖ്യകൾ സംഭരിക്കാൻ ടൈപ്പ് ചാറിന്റെ മൂല്യങ്ങളും ഉപയോഗിക്കുന്നു.

വിപുലീകരിച്ച പ്രതീക തരം (wchar_t)

ടൈപ്പ് ചെയ്യുക wchar_tഎൻകോഡ് ചെയ്യാൻ 1 ബൈറ്റ് മതിയാകാത്ത ഒരു കൂട്ടം പ്രതീകങ്ങൾക്കൊപ്പം പ്രവർത്തിക്കാൻ രൂപകൽപ്പന ചെയ്‌തിരിക്കുന്നു. ഉദാഹരണത്തിന്, യൂണികോഡ്. ഈ തരത്തിന്റെ വലിപ്പം നടപ്പിലാക്കുന്നതിനെ ആശ്രയിച്ചിരിക്കുന്നു; ചട്ടം പോലെ, ഇത് തരവുമായി പൊരുത്തപ്പെടുന്നു ചെറുത്. wchar_t ടൈപ്പിന്റെ സ്ട്രിംഗ് കോൺസ്റ്റന്റ്സ് L പ്രിഫിക്‌സ് ഉപയോഗിച്ചാണ് എഴുതിയിരിക്കുന്നത്, ഉദാഹരണത്തിന്, L“ഗേറ്റ്സ്”.

ബൂളിയൻ തരം (ബൂൾ)

ബൂളിയൻ മൂല്യങ്ങൾക്ക് മൂല്യങ്ങൾ മാത്രമേ എടുക്കാൻ കഴിയൂ സത്യംഒപ്പം തെറ്റായ, സംവരണം ചെയ്ത വാക്കുകളാണ്. തെറ്റായ മൂല്യത്തെ പ്രതിനിധീകരിക്കുന്നതിന്റെ ആന്തരിക രൂപം 0 (പൂജ്യം) ആണ്. മറ്റേതെങ്കിലും മൂല്യം ശരിയാണെന്ന് വ്യാഖ്യാനിക്കുന്നു. ഒരു പൂർണ്ണസംഖ്യ തരത്തിലേക്ക് പരിവർത്തനം ചെയ്യുമ്പോൾ സത്യംമൂല്യം 1 ഉണ്ട്.

ഫ്ലോട്ടിംഗ് പോയിന്റ് തരങ്ങൾ (ഫ്ലോട്ട്, ഡബിൾ, ലോംഗ് ഡബിൾ)

C++ സ്റ്റാൻഡേർഡ് യഥാർത്ഥ മൂല്യങ്ങൾ സംഭരിക്കുന്നതിന് മൂന്ന് ഡാറ്റ തരങ്ങളെ നിർവചിക്കുന്നു: ഫ്ലോട്ട്, ഡബിൾ, ലോംഗ് ഡബിൾ.

ഫ്ലോട്ടിംഗ്-പോയിന്റ് ഡാറ്റ തരങ്ങൾ പൂർണ്ണസംഖ്യ ഡാറ്റ തരങ്ങളേക്കാൾ വ്യത്യസ്തമായി മെമ്മറിയിൽ സംഭരിക്കുന്നു. ഒരു യഥാർത്ഥ സംഖ്യയുടെ ആന്തരിക പ്രാതിനിധ്യം രണ്ട് ഭാഗങ്ങൾ ഉൾക്കൊള്ളുന്നു - മാന്റിസ്സഒപ്പം ഓർഡർ.

ഐബിഎം പിസി-അനുയോജ്യമായ കമ്പ്യൂട്ടറുകളിൽ, തരം മൂല്യങ്ങൾ ഫ്ലോട്ട് 4 ബൈറ്റുകൾ ഉൾക്കൊള്ളുന്നു, അതിൽ ഒരു ബൈനറി അക്കം അനുവദിച്ചിരിക്കുന്നു മാന്റിസയുടെ അടയാളത്തിന് കീഴിൽ, 8 അക്കങ്ങൾ ക്രമത്തിൽകൂടാതെ 23 മാന്റിസയുടെ കീഴിൽ. മാന്റിസ 1.0-നേക്കാൾ വലുതും എന്നാൽ 2.0-നേക്കാൾ കുറവുമാണ്.മാന്റിസയുടെ മുൻനിര അക്കം എപ്പോഴും 1 ആയതിനാൽ, അത് സംഭരിക്കപ്പെടുന്നില്ല.

തരത്തിന്റെ അളവുകൾക്കായി ഇരട്ട, 8 ബൈറ്റുകൾ ഉൾക്കൊള്ളുന്നു, യഥാക്രമം ഓർഡറിനും മാന്റിസയ്ക്കും വേണ്ടി 11, 52 ബിറ്റുകൾ അനുവദിച്ചിരിക്കുന്നു. മാന്റിസയുടെ നീളം സംഖ്യയുടെ കൃത്യത നിർണ്ണയിക്കുന്നു, ഘാതകത്തിന്റെ ദൈർഘ്യം അതിന്റെ പരിധി നിശ്ചയിക്കുന്നു.എൻട്രിയുടെ അവസാനത്തെ പട്ടികയിൽ നിന്ന് നിങ്ങൾക്ക് കാണാനാകുന്നതുപോലെ, ഫ്ലോട്ട്, ലോംഗ് ഇൻറ്റ് മൂല്യങ്ങൾക്കായി അനുവദിച്ചിരിക്കുന്ന അതേ എണ്ണം ബൈറ്റുകൾ, അവയുടെ അനുവദനീയമായ മൂല്യങ്ങളുടെ ശ്രേണികൾ വളരെ വ്യത്യാസപ്പെട്ടിരിക്കുന്നു. ആന്തരിക പ്രാതിനിധ്യ രൂപം കാരണം.

സ്പെസിഫയർ നീളമുള്ളതരം പേരിന് മുമ്പ് ഇരട്ടിഅതിന്റെ മൂല്യത്തിനായി 10 ബൈറ്റുകൾ അനുവദിച്ചിട്ടുണ്ടെന്ന് സൂചിപ്പിക്കുന്നു.

ഫ്ലോട്ടിംഗ്-പോയിന്റ് സ്ഥിരാങ്കങ്ങൾ സ്ഥിരസ്ഥിതിയായി ഇരട്ട തരം ആണ്. F, f (float), L, l (നീളം) എന്നീ പ്രത്യയങ്ങൾ ഉപയോഗിച്ച് നിങ്ങൾക്ക് ഒരു സ്ഥിരാങ്കത്തിന്റെ തരം വ്യക്തമായി വ്യക്തമാക്കാൻ കഴിയും.

ഉദാഹരണത്തിന്, സ്ഥിരമായ 2E+6L ടൈപ്പ് ലോംഗ് ഡബിൾ ആയിരിക്കും, സ്ഥിരമായ 1.82f തരം ഫ്ലോട്ട് ആയിരിക്കും.

വ്യത്യസ്ത പ്ലാറ്റ്‌ഫോമുകൾക്കായി സാർവത്രികമായ പ്രോഗ്രാമുകൾ എഴുതുമ്പോൾ, തരത്തിന്റെ വലുപ്പത്തെക്കുറിച്ച് നിങ്ങൾക്ക് അനുമാനങ്ങൾ നടത്താൻ കഴിയില്ല. int.ഇത് ലഭിക്കുന്നതിന്, നിങ്ങൾ പ്രവർത്തനത്തിന്റെ വലുപ്പം ഉപയോഗിക്കണം, അതിന്റെ ഫലം ബൈറ്റുകളിലെ തരത്തിന്റെ വലുപ്പമാണ്.

ഉദാഹരണത്തിന്, MS-DOS-ന് ഓപ്പറേറ്റിംഗ് സിസ്റ്റത്തിന്റെ sizeof (int) 2 ആയിരിക്കും, എന്നാൽ Windows 98 അല്ലെങ്കിൽ OS/2 ന് ഫലം 4 ആയിരിക്കും.

ANSI സ്റ്റാൻഡേർഡ് അടിസ്ഥാന തരങ്ങൾക്കുള്ള മൂല്യ ശ്രേണികൾ വ്യക്തമാക്കുന്നില്ല; അവയുടെ വലുപ്പങ്ങൾ തമ്മിലുള്ള ബന്ധങ്ങൾ മാത്രമേ നിർവചിച്ചിട്ടുള്ളൂ, ഉദാഹരണത്തിന്:

sizeof(float) ≤ slzeof(ഇരട്ട) ≤ sizeof(നീണ്ട ഇരട്ടി)
sizeof(char) ≤ slzeof(ഹ്രസ്വ) ≤ 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 ശൈലി I/O ഫംഗ്‌ഷനുകൾ:

int scanf (const char* ഫോർമാറ്റ്, ...) // ഇൻപുട്ട്
int printf(const char* ഫോർമാറ്റ്, ...) // ഔട്ട്‌പുട്ട്

ഫോർമാറ്റ് സ്ട്രിംഗിന് അനുസൃതമായി അനിയന്ത്രിതമായ മൂല്യങ്ങളുടെ ഫോർമാറ്റ് ചെയ്ത ഇൻപുട്ടും ഔട്ട്പുട്ടും അവർ നിർവഹിക്കുന്നു. ഫോർമാറ്റ് സ്‌ട്രിംഗിൽ ഔട്ട്‌പുട്ടിലെ സ്ട്രീമിലേക്ക് (സ്‌ക്രീനിൽ) പകർത്തിയതോ ഇൻപുട്ടിലെ സ്ട്രീമിൽ നിന്ന് (കീബോർഡിൽ നിന്ന്) അഭ്യർത്ഥിച്ചതോ ആയ പ്രതീകങ്ങളും ഇൻപുട്ടിലെ നിർദ്ദിഷ്ട മൂല്യങ്ങൾ ഉപയോഗിച്ച് മാറ്റിസ്ഥാപിക്കുന്ന % ചിഹ്നത്തിൽ ആരംഭിക്കുന്ന പരിവർത്തന സവിശേഷതകളും അടങ്ങിയിരിക്കുന്നു. ഔട്ട്പുട്ടും.

സി-സ്റ്റൈൽ I/O ഫംഗ്‌ഷനുകൾ ഉപയോഗിക്കുന്ന ഒരു ഉദാഹരണം പ്രോഗ്രാം:

#ഉൾപ്പെടുന്നു
int main() (
int i;
printf("ഒരു പൂർണ്ണസംഖ്യ നൽകുക\n");
scanf("%d", &i);
printf("നിങ്ങൾ %d എന്ന നമ്പർ നൽകി, നന്ദി!", i);
തിരികെ 0;
}

ഈ പ്രോഗ്രാമിന്റെ ആദ്യ വരി ഒരു പ്രീപ്രൊസസ്സർ ഡയറക്റ്റീവ് ആണ്, അത് പ്രോഗ്രാമിൽ ഉപയോഗിക്കുന്ന ഇൻപുട്ട്/ഔട്ട്പുട്ട് ഫംഗ്ഷനുകളുടെ വിവരണം അടങ്ങിയ പ്രോഗ്രാം ടെക്സ്റ്റിലേക്ക് ഒരു ഹെഡർ ഫയൽ ചേർക്കുന്നു (ഈ സാഹചര്യത്തിൽ, ആംഗിൾ ബ്രാക്കറ്റുകൾ ഒരു ഭാഷാ ഘടകമാണ്). എല്ലാ പ്രീപ്രൊസസ്സർ നിർദ്ദേശങ്ങളും # ചിഹ്നത്തിൽ ആരംഭിക്കുന്നു.

മൂന്നാമത്തെ വരി i എന്ന് പേരുള്ള ഒരു പൂർണ്ണസംഖ്യ തരം വേരിയബിളിന്റെ വിവരണമാണ്.

നാലാമത്തെ വരിയിലെ printf ഫംഗ്‌ഷൻ "Enter an integer" പ്രോംപ്റ്റ് പ്രിന്റ് ചെയ്യുകയും \n രക്ഷപ്പെടൽ ക്രമം അനുസരിച്ച് ഒരു പുതിയ ലൈനിലേക്ക് ബ്രേക്ക് ചെയ്യുകയും ചെയ്യുന്നു. സ്കാൻഫ് ഫംഗ്‌ഷൻ കീബോർഡിൽ നിന്ന് നൽകിയ പൂർണ്ണസംഖ്യയെ വേരിയബിളിലേക്ക് സംഭരിക്കുന്നു i (ചിഹ്നം & വിലാസം നേടുന്നതിന്റെ പ്രവർത്തനത്തെ സൂചിപ്പിക്കുന്നു), ഇനിപ്പറയുന്ന പ്രസ്താവന അതിൽ വ്യക്തമാക്കിയ സ്ട്രിംഗ് പ്രദർശിപ്പിക്കുന്നു, ഈ സംഖ്യയുടെ മൂല്യം ഉപയോഗിച്ച് കൺവേർഷൻ സ്പെസിഫിക്കേഷൻ മാറ്റിസ്ഥാപിക്കുന്നു.

C++ ക്ലാസ് ലൈബ്രറി ഉപയോഗിക്കുന്ന പ്രോഗ്രാം:

#ഉൾപ്പെടുന്നു
int main() (
int i;
കട്ട്<< "Введите целое число\n"; സിൻ >> ഞാൻ;
കട്ട്<< "Вы ввели число " << i << ", спасибо!";
തിരികെ 0;
}

ഇൻപുട്ട്/ഔട്ട്പുട്ട് കൈകാര്യം ചെയ്യുന്നതിനുള്ള ഒരു കൂട്ടം ക്ലാസുകളുടെ വിവരണം ഹെഡർ ഫയലിൽ അടങ്ങിയിരിക്കുന്നു. ഇത് സ്റ്റാൻഡേർഡ് സ്ട്രീം ഒബ്ജക്റ്റുകളെ നിർവചിക്കുന്നു സിൻകീബോർഡ് ഇൻപുട്ടിനും കട്ട്പ്രദർശനത്തിനായി, അതുപോലെ ഒരു സ്ട്രീമിൽ സ്ഥാപിക്കുന്നതിനുള്ള പ്രവർത്തനവും< < и чтения из потока >>.

ഇൻപുട്ട്/ഔട്ട്പുട്ട് സംഘടിപ്പിക്കുന്നതിനുള്ള രണ്ട് രീതികളും നിങ്ങൾക്ക് ഉപയോഗിക്കാം, എന്നാൽ അവ ഒരു പ്രോഗ്രാമിൽ മിക്സ് ചെയ്യാൻ ശുപാർശ ചെയ്യുന്നില്ല.

പ്രോഗ്രാമിംഗിൽ, ഒരു ഡാറ്റ തരം രണ്ട് സെറ്റുകളുടെ ഒരു ശേഖരമാണ്: മൂല്യങ്ങളുടെ ഒരു കൂട്ടവും അവയിൽ പ്രയോഗിക്കാൻ കഴിയുന്ന പ്രവർത്തനങ്ങളുടെ ഒരു കൂട്ടവും. ഉദാഹരണത്തിന്, സങ്കലനം (+), ഗുണനം (*), പൂർണ്ണസംഖ്യ വിഭജനം (/), ശേഷിപ്പ് (%), വ്യവകലനം (-) എന്നിവയുടെ പ്രവർത്തനങ്ങൾ പരിമിതമായ സ്വാഭാവിക സംഖ്യകൾ അടങ്ങുന്ന ഒരു നോൺ-നെഗറ്റീവ് ഇന്റിജർ ഡാറ്റാ തരത്തിലേക്ക് പ്രയോഗിക്കാവുന്നതാണ്.

ഒരു പ്രോഗ്രാമിംഗ് ഭാഷയ്ക്ക് സാധാരണയായി ഒരു കൂട്ടം പ്രാകൃത ഡാറ്റാ തരങ്ങളുണ്ട് - അടിസ്ഥാന ബിൽറ്റ്-ഇൻ യൂണിറ്റായി പ്രോഗ്രാമിംഗ് ഭാഷ നൽകുന്ന തരങ്ങൾ. C++ ൽ, ഭാഷയുടെ സ്രഷ്ടാവ് അത്തരം തരങ്ങളെ അടിസ്ഥാന തരങ്ങൾ എന്ന് വിളിക്കുന്നു. C++ ലെ അടിസ്ഥാന തരങ്ങൾ ഇവയാണ്:

• ബൂളിയൻ (ബൂൾ);
• സ്വഭാവം (ഉദാ: ചാർ);
• int (ഉദാ int);
• ഫ്ലോട്ടിംഗ് പോയിന്റ് (ഉദാ. ഫ്ലോട്ട്);
• കണക്കുകൾ (പ്രോഗ്രാമർ നിർവചിച്ചിരിക്കുന്നത്);
• ശൂന്യം .

ലിസ്റ്റുചെയ്തവയുടെ മുകളിൽ, ഇനിപ്പറയുന്ന തരങ്ങൾ നിർമ്മിച്ചിരിക്കുന്നു:

• ഡെമോൺസ്ട്രേറ്റീവ് (ഉദാ int*);
• അറേകൾ (ഉദാ ചാർ);
• റഫറൻസ് (ഉദാ. ഇരട്ട&);
• മറ്റ് ഘടനകൾ.

നമുക്ക് ഒരു ലിറ്ററൽ എന്ന ആശയത്തിലേക്ക് പോകാം (ഉദാഹരണത്തിന്, 1, 2.4F, 25e-4, 'a' മുതലായവ): ഒരു നിശ്ചിത മൂല്യത്തെ പ്രതിനിധീകരിക്കുന്ന ഒരു പ്രോഗ്രാമിന്റെ സോഴ്സ് കോഡിലെ ഒരു എൻട്രിയാണ് ലിറ്ററൽ. മറ്റൊരു വിധത്തിൽ പറഞ്ഞാൽ, പ്രോഗ്രാം കോഡിലെ ഏതെങ്കിലും തരത്തിലുള്ള ഒരു വസ്തുവിന്റെ (മൂല്യം) പ്രതിനിധാനം മാത്രമാണ് അക്ഷരം. C++ ന് പൂർണ്ണസംഖ്യ, ഫ്ലോട്ടിംഗ് പോയിന്റ്, പ്രതീകം, ബൂളിയൻ, സ്ട്രിംഗ് മൂല്യങ്ങൾ എന്നിവ എഴുതാനുള്ള കഴിവുണ്ട്.

ഒരു പൂർണ്ണസംഖ്യ തരം ലിറ്ററൽ ഇങ്ങനെ എഴുതാം:

• പത്താം നമ്പർ സിസ്റ്റം. ഉദാഹരണത്തിന്, 1205;
• 0 + നമ്പർ ഫോർമാറ്റിലുള്ള എട്ടാമത്തെ നമ്പർ സിസ്റ്റം. ഉദാഹരണത്തിന്, 0142;
• 0x + നമ്പർ ഫോർമാറ്റിലുള്ള 16-ാമത്തെ നമ്പർ സിസ്റ്റം. ഉദാഹരണത്തിന്, 0x2F.

24, 030, 0x18 - ഇവയെല്ലാം വ്യത്യസ്‌ത നമ്പർ സിസ്റ്റങ്ങളിലെ ഒരേ സംഖ്യയുടെ രേഖകളാണ്.
ഫ്ലോട്ടിംഗ് പോയിന്റ് നമ്പറുകൾ എഴുതാൻ, ഡോട്ട് നൊട്ടേഷൻ ഉപയോഗിക്കുക: 0.1, .5, 4. - ഒന്നുകിൽ
എക്‌സ്‌പോണൻഷ്യൽ നൊട്ടേഷൻ - 25e-100. അത്തരമൊരു രേഖയിൽ ഇടങ്ങൾ ഉണ്ടാകരുത്.

അക്ഷരങ്ങളിൽ എഴുതിയ മൂല്യങ്ങളെ നമുക്ക് ബന്ധപ്പെടുത്താൻ കഴിയുന്ന പേരിനെ വേരിയബിൾ എന്ന് വിളിക്കുന്നു. ഒരു വേരിയബിൾ എന്നത് പേരിട്ടിരിക്കുന്നതോ അല്ലെങ്കിൽ വിലാസം നൽകാവുന്നതോ ആയ മെമ്മറി ഏരിയയാണ്, അതിന്റെ വിലാസം ഡാറ്റ ആക്‌സസ് ചെയ്യാൻ ഉപയോഗിക്കാം. പ്രോഗ്രാം എക്സിക്യൂഷൻ സമയത്ത് ഈ ഡാറ്റ ഒരു പ്രത്യേക രീതിയിൽ മെമ്മറിയിൽ എഴുതുകയും വീണ്ടും എഴുതുകയും മായ്‌ക്കുകയും ചെയ്യുന്നു. എപ്പോൾ വേണമെങ്കിലും ഡാറ്റ ആക്സസ് ചെയ്യാനും ആവശ്യമെങ്കിൽ അത് മാറ്റാനും ഒരു വേരിയബിൾ നിങ്ങളെ അനുവദിക്കുന്നു. ഒരു വേരിയബിൾ നാമത്തിൽ നിന്ന് വീണ്ടെടുക്കാൻ കഴിയുന്ന ഡാറ്റയെ വേരിയബിളിന്റെ മൂല്യം എന്ന് വിളിക്കുന്നു.
ഒരു പ്രോഗ്രാമിൽ ഒരു വേരിയബിൾ ഉപയോഗിക്കുന്നതിന്, അത് ഡിക്ലെയർ ചെയ്യണം, ആവശ്യമെങ്കിൽ അത് നിർവചിക്കാം (= ഇനീഷ്യലൈസ്). പ്രോഗ്രാം ടെക്സ്റ്റിലെ ഒരു വേരിയബിളിന്റെ ഡിക്ലറേഷനിൽ 2 ഭാഗങ്ങൾ അടങ്ങിയിരിക്കണം: അടിസ്ഥാന തരവും ഡിക്ലറേറ്ററും. സ്പെസിഫയറും ഇനീഷ്യലൈസറും ഓപ്ഷണൽ ഭാഗങ്ങളാണ്:

കോൺസ്റ്റ് ഇൻറ്റ് ഉദാഹരണം = 3; // ഇവിടെ const ഒരു സ്പെസിഫയർ ആണ് // int അടിസ്ഥാന തരം ആണ് // ഉദാഹരണം വേരിയബിളിന്റെ പേര് // = 3 - ഇനീഷ്യലൈസർ.

വേരിയബിൾ നാമം എന്നത് ലാറ്റിൻ അക്ഷരമാലയിലെ അക്ഷരങ്ങൾ (ചെറിയക്ഷരവും വലിയക്ഷരവും), അക്കങ്ങളും കൂടാതെ/അല്ലെങ്കിൽ ഒരു അടിവരയും അടങ്ങുന്ന പ്രതീകങ്ങളുടെ ഒരു ശ്രേണിയാണ്, എന്നാൽ ആദ്യ പ്രതീകം ഒരു സംഖ്യയാകരുത്. വേരിയബിൾ നാമം തിരഞ്ഞെടുക്കണം, അതുവഴി അത് സംഭരിക്കുന്നതെന്താണെന്ന് ഊഹിക്കാൻ എപ്പോഴും എളുപ്പമാണ്, ഉദാഹരണത്തിന്, "മാസം പേയ്മെന്റ്". കുറിപ്പുകളിലും പ്രായോഗികമായും, വേരിയബിളുകൾ റെക്കോർഡുചെയ്യുന്നതിനുള്ള നിയമങ്ങൾക്കായി ഞങ്ങൾ CamelCase നൊട്ടേഷൻ ഉപയോഗിക്കും. വേരിയബിൾ നാമം ഭാഷയിൽ സംവരണം ചെയ്തിരിക്കുന്ന പദങ്ങളുമായി പൊരുത്തപ്പെടുന്നില്ല; അത്തരം വാക്കുകളുടെ ഉദാഹരണങ്ങൾ ഇവയാണ്: if, while, function, goto, switch, മുതലായവ.

വേരിയബിൾ പേരിന് പുറമേ, ഡിക്ലറേറ്ററിൽ അധിക പ്രതീകങ്ങൾ അടങ്ങിയിരിക്കാം:

• * - പോയിന്റർ; പേരിന് മുമ്പ്;
• * കോൺസ്റ്റ് - സ്ഥിരമായ പോയിന്റർ; പേരിന് മുമ്പ്;
• & - ലിങ്ക്; പേരിന് മുമ്പ്;
• - അറേ; പേരിനു ശേഷം;
• () - ഫംഗ്ഷൻ; പേരിനു ശേഷം.

ഒരു വേരിയബിളിന്റെ പ്രഖ്യാപനത്തിന് തൊട്ടുപിന്നാലെ അതിന്റെ മൂല്യം നിർവചിക്കാൻ ഒരു ഇനീഷ്യലൈസർ നിങ്ങളെ അനുവദിക്കുന്നു. ഇനീഷ്യലൈസർ ഒരു സമത്വ ലിറ്ററൽ (=) ഉപയോഗിച്ച് ആരംഭിക്കുന്നു, തുടർന്ന് വേരിയബിളിന്റെ മൂല്യം സജ്ജമാക്കാൻ തുടരുന്നു. പൊതുവായി പറഞ്ഞാൽ, C++ ലെ തുല്യ ചിഹ്നം ഒരു അസൈൻമെന്റ് പ്രവർത്തനത്തെ സൂചിപ്പിക്കുന്നു; അതിന്റെ സഹായത്തോടെ നിങ്ങൾക്ക് ഒരു വേരിയബിളിന്റെ മൂല്യം സജ്ജമാക്കാനും മാറ്റാനും കഴിയും. വ്യത്യസ്ത തരങ്ങൾക്ക് ഇത് വ്യത്യസ്തമായിരിക്കാം.

സ്പെസിഫയർ തരം ഒഴികെയുള്ള അധിക ആട്രിബ്യൂട്ടുകൾ വ്യക്തമാക്കുന്നു. ഉദാഹരണത്തിൽ നൽകിയിരിക്കുന്ന കോൺസ്റ്റ് സ്പെസിഫയർ, വേരിയബിളിന്റെ മൂല്യത്തിൽ തുടർന്നുള്ള മാറ്റങ്ങൾ നിരോധിക്കാൻ നിങ്ങളെ അനുവദിക്കുന്നു. അത്തരം മാറ്റമില്ലാത്ത വേരിയബിളുകളെ സ്ഥിരം അല്ലെങ്കിൽ സ്ഥിരാങ്കം എന്ന് വിളിക്കുന്നു.

സമാരംഭിക്കാതെ സ്ഥിരാങ്കം പ്രഖ്യാപിക്കുന്നത് യുക്തിസഹമായ കാരണങ്ങളാൽ പ്രവർത്തിക്കില്ല:

Const int EMPTY_CONST; // പിശക്, സ്ഥിരമായ വേരിയബിൾ ആരംഭിച്ചിട്ടില്ല const int EXAMPLE = 2; 2 മൂല്യമുള്ള സ്ഥിരാങ്കം ഉദാഹരണം = 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. ബൂളിയൻ (ലോജിക്കൽ) തരം (ബൂൾ)

രണ്ട് മൂല്യങ്ങൾ മാത്രം ഉൾക്കൊള്ളുന്നു: ശരി (സത്യം), തെറ്റ് (തെറ്റ്). ഈ തരത്തിലുള്ള വേരിയബിളുകളിൽ പ്രവർത്തിക്കാൻ, ലോജിക്കൽ പ്രവർത്തനങ്ങൾ ഉപയോഗിക്കുന്നു: ! (അല്ല), == (സമത്വം), != (അസമത്വം), && (ലോജിക്കൽ AND), || (ലോജിക്കൽ അല്ലെങ്കിൽ). ഓരോ പ്രവർത്തനത്തിന്റെയും ഫലം അനുബന്ധ സത്യ പട്ടികയിൽ കാണാം. ഉദാഹരണത്തിന്:

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 odds = (1, 3, 7, 9, 11); // അറേ 5 മൂല്യങ്ങൾ ഉപയോഗിച്ച് ആരംഭിച്ചിരിക്കുന്നു

ഒരു അറേയിൽ (അറേ എലമെന്റ്) ഒരു നിർദ്ദിഷ്‌ട മൂല്യം ആക്‌സസ് ചെയ്യുന്നതിന്, എലമെന്റ് നമ്പർ സൂചിപ്പിക്കുന്ന ഇൻഡെക്‌സ് ആക്‌സസ് ഓപ്പറേഷൻ () ഉപയോഗിക്കുക (സംഖ്യകൾ 0 മുതൽ ആരംഭിക്കുന്നു). ഉദാഹരണത്തിന്:

അസന്തുലിതാവസ്ഥ; // അറേയുടെ ആദ്യ ഘടകത്തിലേക്കുള്ള പ്രവേശനം. മൂല്യം 1 ഓഡ്സ് നൽകുന്നു; // മൂന്നാമത്തെ ഘടകത്തിലേക്കുള്ള പ്രവേശനം. മൂല്യം 7 ഓഡ്സ് = 13 നൽകുന്നു; // അറേ ഓഡ്‌സിന്റെ അഞ്ചാമത്തെ ഘടകത്തിന് ഒരു പുതിയ മൂല്യം നൽകുക; // ആക്സസ് പിശക്

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. സൂചിക

ഈ ഡാറ്റ തരം മനസിലാക്കാൻ, ഈ തരത്തിലുള്ള പല മൂല്യങ്ങളും ഡാറ്റ ആരംഭിക്കുന്ന മെമ്മറി സെല്ലുകളുടെ വിലാസങ്ങളാണെന്ന് നിങ്ങൾ ഓർമ്മിക്കേണ്ടതുണ്ട്. പോയിന്റർ കൂട്ടിച്ചേർക്കൽ (+), കുറയ്ക്കൽ (-), ഡീററൻസ് (*) പ്രവർത്തനങ്ങളെ പിന്തുണയ്ക്കുന്നു.

വിലാസങ്ങൾ 0x0 അർത്ഥമാക്കുന്നത് പോയിന്റർ ശൂന്യമാണ്, അതായത്. ഒരു ഡാറ്റയിലേക്കും ചൂണ്ടിക്കാണിക്കുന്നില്ല. ഈ വിലാസത്തിന് അതിന്റേതായ അക്ഷരരൂപമുണ്ട് - NULL:

Int *nullPtr = NULL; // നൾ പോയിന്റർ

ഒരു പൂർണ്ണസംഖ്യയോ മറ്റൊരു വിലാസമോ ഉപയോഗിച്ച് ഒരു വിലാസം ചേർക്കുന്നതും കുറയ്ക്കുന്നതും അനുവദിക്കുന്നു
പ്രോഗ്രാമിന് ലഭ്യമായ മെമ്മറിക്ക് ചുറ്റും നീങ്ങുക.

ഒരു പോയിന്ററിൽ സംഭരിച്ചിരിക്കുന്ന വിലാസത്തിൽ ആരംഭിക്കുന്ന ഡാറ്റ വീണ്ടെടുക്കുന്നതിനുള്ള പ്രവർത്തനത്തെ dereferencing (*) എന്ന് വിളിക്കുന്നു. പ്രോഗ്രാം ആവശ്യമായ മെമ്മറി സെല്ലുകളുടെ എണ്ണം വായിക്കുകയും മെമ്മറിയിൽ സംഭരിച്ചിരിക്കുന്ന മൂല്യം തിരികെ നൽകുകയും ചെയ്യുന്നു.

Int valueInMemory = 2; // intger ടൈപ്പിന്റെ ഒരു വേരിയബിൾ സജ്ജമാക്കുക *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

ശൂന്യം

വാക്യഘടനാപരമായി, ശൂന്യ തരം അടിസ്ഥാന തരങ്ങളിൽ പെടുന്നു, എന്നാൽ ഇത് കൂടുതൽ സങ്കീർണ്ണമായ തരങ്ങളുടെ ഭാഗമായി മാത്രമേ ഉപയോഗിക്കാൻ കഴിയൂ, കാരണം തരം ശൂന്യമായ ഒബ്‌ജക്‌റ്റുകളൊന്നുമില്ല. സാധാരണഗതിയിൽ, ഒരു ഫംഗ്‌ഷന് റിട്ടേൺ മൂല്യമില്ലെന്ന് സൂചിപ്പിക്കാൻ അല്ലെങ്കിൽ നിർവചിക്കാത്ത തരത്തിലുള്ള ഒബ്‌ജക്റ്റുകളിലേക്കുള്ള പോയിന്ററിന്റെ അടിസ്ഥാന തരമായി ഈ തരം ഉപയോഗിക്കുന്നു:

ശൂന്യമായ വസ്തു; // പിശക്, ശൂന്യമായ ശൂന്യത എന്ന തരത്തിലുള്ള ഒബ്‌ജക്‌റ്റുകളൊന്നുമില്ല // പിശക്, അസാധുവായ ശൂന്യതയെക്കുറിച്ച് പരാമർശങ്ങളൊന്നുമില്ല *pt; // ശരി, ഒരു അജ്ഞാത തരത്തിലേക്ക് ഒരു പോയിന്റർ സംഭരിക്കുക

ഒരു ഫംഗ്‌ഷൻ ഒരു മൂല്യവും നൽകുന്നില്ലെന്ന് സൂചിപ്പിക്കാൻ ഞങ്ങൾ പലപ്പോഴും ശൂന്യത ഉപയോഗിക്കും. മെമ്മറിയുടെ സമഗ്രതയുടെയും ശരിയായ തരം കാസ്റ്റിംഗിന്റെയും പൂർണ ഉത്തരവാദിത്തം പ്രോഗ്രാമർ ഏറ്റെടുക്കുമ്പോൾ ഒരു ശൂന്യമായ ടൈപ്പ് പോയിന്റർ ഉപയോഗിക്കുന്നു.

കാസ്റ്റ്

ഒരു തരത്തിലുള്ള വേരിയബിളിന്റെ മൂല്യം മറ്റൊന്നിലേക്ക് കാസ്റ്റ് ചെയ്യേണ്ടത് പലപ്പോഴും ആവശ്യമാണ്. ഒറിജിനൽ തരത്തിന്റെ മൂല്യങ്ങളുടെ കൂട്ടം ഒരു വലിയ തരത്തിന്റെ ഒരു ഉപഗണം ആണെങ്കിൽ (ഉദാഹരണത്തിന്, int എന്നത് ദൈർഘ്യത്തിന്റെ ഒരു ഉപഗണവും നീളമുള്ളത് ഇരട്ടയുമാണ്), കംപൈലറിന് പരോക്ഷമായി ( പരോക്ഷമായി) മൂല്യത്തിന്റെ തരം മാറ്റുക.

പൂർണ്ണസംഖ്യ = 2; ഫ്ലോട്ട് ഫ്ലോട്ടിംഗ് = പൂർണ്ണസംഖ്യ; // ഫ്ലോട്ടിംഗ് = 2.0

ഒരു റിവേഴ്‌സ് ടൈപ്പ് കാസ്റ്റ്, വിവരങ്ങൾ നഷ്‌ടപ്പെടുന്നതിനാൽ, ഫ്ലോട്ടിംഗ് പോയിന്റ് നമ്പറിന്റെ പൂർണ്ണസംഖ്യ മാത്രമേ നിലനിൽക്കൂ, ഫ്രാക്ഷണൽ ഭാഗം നഷ്‌ടമാകും.

വ്യക്തമായ തരം പരിവർത്തനത്തിന് സാധ്യതയുണ്ട്; ഇതിനായി, വേരിയബിളിന്റെ ഇടതുവശത്ത് അല്ലെങ്കിൽ യഥാർത്ഥ തരത്തിന്റെ ഏതെങ്കിലും മൂല്യം, പരാൻതീസിസിൽ ഏത് തരം കാസ്റ്റ് നിർവഹിക്കും എന്ന് എഴുതുക:

Int മൂല്യം = (int) 2.5;

ഏകീകൃത, ബൈനറി പ്രവർത്തനങ്ങൾ

ഞങ്ങൾ നേരത്തെ നടത്തിയ പ്രവർത്തനങ്ങളെ ബൈനറി എന്ന് വിളിക്കുന്നു: ഓപ്പറേഷൻ ചിഹ്നത്തിന്റെ ഇടത്തും വലത്തും മൂല്യങ്ങളോ വേരിയബിളുകളോ ഉണ്ട്, ഉദാഹരണത്തിന്, 2 + 3. ബൈനറി പ്രവർത്തനങ്ങൾക്ക് പുറമേ, പ്രോഗ്രാമിംഗ് ഭാഷകൾ വേരിയബിളുകൾക്ക് ബാധകമായ ഏകീകൃത പ്രവർത്തനങ്ങളും ഉപയോഗിക്കുന്നു. . അവ ഒരു വേരിയബിളിന്റെ ഇടത്തോട്ടോ വലത്തോട്ടോ സ്ഥിതിചെയ്യാം; അത്തരത്തിലുള്ള നിരവധി പ്രവർത്തനങ്ങൾ മുമ്പ് നേരിട്ടിട്ടുണ്ട് - ഡിറഫറൻസിംഗ് ഓപ്പറേഷൻ (*) കൂടാതെ ഒരു വേരിയബിളിന്റെ വിലാസം (&) എടുക്കുന്നത് അസാധാരണമാണ്. “++”, “—” എന്നീ ഓപ്പറേറ്റർമാർ ഒരു പൂർണ്ണസംഖ്യ വേരിയബിളിന്റെ മൂല്യം യഥാക്രമം 1 കൊണ്ട് കൂട്ടുകയും കുറയ്ക്കുകയും ചെയ്യുന്നു, കൂടാതെ വേരിയബിളിന്റെ ഇടത്തോട്ടോ വലത്തോട്ടോ എഴുതാം.

ഒരു എക്സ്പ്രഷന്റെ ഇടത്തും വലത്തും ഒരേ വേരിയബിൾ അടങ്ങിയിരിക്കുമ്പോൾ, ബൈനറി പ്രവർത്തനങ്ങൾക്കായി C++ ഒരു ഷോർട്ട്ഹാൻഡ് നൊട്ടേഷനും ഉപയോഗിക്കുന്നു, അതായത്. ചില പ്രവർത്തനം ഒരു വേരിയബിളിന്റെ മൂല്യത്തിൽ നടത്തുകയും പ്രവർത്തനത്തിന്റെ ഫലം അതേ വേരിയബിളിൽ സൂക്ഷിക്കുകയും ചെയ്യുന്നു:

എ += 2; // a = a + 2 പോലെ തന്നെ; b /= 5; // b = b / 5 പോലെ തന്നെ; സി &= 3; // c = c & 3 പോലെ തന്നെ;

അവസാനം അപ്ഡേറ്റ് ചെയ്തത്: 09/17/2017

ഓരോ വേരിയബിളിനും ഒരു പ്രത്യേക തരം ഉണ്ട്. ഒരു വേരിയബിളിന് എന്ത് മൂല്യങ്ങൾ ഉണ്ടായിരിക്കാമെന്നും അതിൽ എന്ത് പ്രവർത്തനങ്ങൾ നടത്താമെന്നും മെമ്മറിയിൽ എത്ര ബൈറ്റുകൾ ഉൾക്കൊള്ളുമെന്നും ഈ തരം നിർണ്ണയിക്കുന്നു. ഇനിപ്പറയുന്ന അടിസ്ഥാന ഡാറ്റ തരങ്ങൾ C++ ഭാഷയിൽ നിർവചിച്ചിരിക്കുന്നു:

bool : ബൂളിയൻ തരം. രണ്ട് മൂല്യങ്ങളിൽ ഒന്ന് എടുക്കാം: ശരിയും തെറ്റും. ഈ തരത്തിലുള്ള മെമ്മറി കാൽപ്പാടുകൾ കൃത്യമായി നിർവചിച്ചിട്ടില്ല.

char : ഒരൊറ്റ ASCII പ്രതീകത്തെ പ്രതിനിധീകരിക്കുന്നു. മെമ്മറിയിൽ 1 ബൈറ്റ് (8 ബിറ്റുകൾ) ഉൾക്കൊള്ളുന്നു. -128 മുതൽ 127 വരെ അല്ലെങ്കിൽ 0 മുതൽ 255 വരെയുള്ള ഏത് മൂല്യവും സംഭരിക്കാൻ കഴിയും

ഒപ്പിട്ട പ്രതീകം : ഒരൊറ്റ പ്രതീകത്തെ പ്രതിനിധീകരിക്കുന്നു. മെമ്മറിയിൽ 1 ബൈറ്റ് (8 ബിറ്റുകൾ) ഉൾക്കൊള്ളുന്നു. -128 മുതൽ 127 വരെയുള്ള ഏത് മൂല്യവും സംഭരിക്കാൻ കഴിയും

ഒപ്പിടാത്ത പ്രതീകം : ഒരൊറ്റ പ്രതീകത്തെ പ്രതിനിധീകരിക്കുന്നു. മെമ്മറിയിൽ 1 ബൈറ്റ് (8 ബിറ്റുകൾ) ഉൾക്കൊള്ളുന്നു. 0 മുതൽ 255 വരെയുള്ള ഏത് മൂല്യവും സംഭരിക്കാൻ കഴിയും

wchar_t : വിശാലമായ പ്രതീകത്തെ പ്രതിനിധീകരിക്കുന്നു. വിൻഡോസിൽ 2 ബൈറ്റുകൾ (16 ബിറ്റുകൾ) മെമ്മറി എടുക്കുന്നു, ലിനക്സിൽ 4 ബൈറ്റുകൾ (32 ബിറ്റുകൾ) എടുക്കുന്നു. 0 മുതൽ 65,535 (2 ബൈറ്റുകൾക്ക്), അല്ലെങ്കിൽ 0 മുതൽ 4,294,967,295 (4 ബൈറ്റുകൾക്ക്) വരെയുള്ള ശ്രേണിയിൽ നിന്ന് ഏത് മൂല്യവും സംഭരിക്കാൻ കഴിയും

char16_t : ഒരൊറ്റ യൂണികോഡ് പ്രതീകത്തെ പ്രതിനിധീകരിക്കുന്നു. മെമ്മറിയിൽ 2 ബൈറ്റുകൾ (16 ബിറ്റുകൾ) ഉൾക്കൊള്ളുന്നു. 0 മുതൽ 65,535 വരെയുള്ള ഏത് മൂല്യവും സംഭരിക്കാൻ കഴിയും

char32_t : ഒരൊറ്റ യൂണികോഡ് പ്രതീകത്തെ പ്രതിനിധീകരിക്കുന്നു. മെമ്മറിയിൽ 4 ബൈറ്റുകൾ (32 ബിറ്റുകൾ) ഉൾക്കൊള്ളുന്നു. 0 മുതൽ 4,294,967,295 വരെയുള്ള ഏത് മൂല്യവും സംഭരിക്കാൻ കഴിയും

short : -32768 മുതൽ 32767 വരെയുള്ള ശ്രേണിയിലെ ഒരു പൂർണ്ണസംഖ്യയെ പ്രതിനിധീകരിക്കുന്നു. മെമ്മറിയുടെ 2 ബൈറ്റുകൾ (16 ബിറ്റുകൾ) ഉൾക്കൊള്ളുന്നു.

ഈ തരത്തിന് short int, signed short int, signed short എന്നീ പര്യായങ്ങളും ഉണ്ട്.

ഒപ്പിടാത്ത ഹ്രസ്വം: 0 മുതൽ 65535 വരെയുള്ള ശ്രേണിയിലെ ഒരു പൂർണ്ണസംഖ്യയെ പ്രതിനിധീകരിക്കുന്നു. മെമ്മറിയുടെ 2 ബൈറ്റുകൾ (16 ബിറ്റുകൾ) ഉൾക്കൊള്ളുന്നു.

ഈ തരത്തിന് സൈൻ ചെയ്യാത്ത ഷോർട്ട് ഇന്റ് എന്ന പര്യായപദവുമുണ്ട്.

int: ഒരു പൂർണ്ണസംഖ്യയെ പ്രതിനിധീകരിക്കുന്നു. പ്രോസസർ ആർക്കിടെക്ചറിനെ ആശ്രയിച്ച്, ഇതിന് 2 ബൈറ്റുകൾ (16 ബിറ്റുകൾ) അല്ലെങ്കിൽ 4 ബൈറ്റുകൾ (32 ബിറ്റുകൾ) ഉൾക്കൊള്ളാൻ കഴിയും. പരിധി മൂല്യങ്ങളുടെ പരിധി -32768 മുതൽ 32767 വരെ (2 ബൈറ്റുകളോടെ) അല്ലെങ്കിൽ −2,147,483,648 മുതൽ 2,147,483,647 (4 ബൈറ്റുകൾക്കൊപ്പം) വരെ വ്യത്യാസപ്പെടാം. എന്നാൽ ഏത് സാഹചര്യത്തിലും, വലുപ്പം ചെറിയ തരത്തിന്റെ വലുപ്പത്തേക്കാൾ വലുതോ തുല്യമോ ആയിരിക്കണം കൂടാതെ നീളമുള്ള തരത്തിന്റെ വലുപ്പത്തേക്കാൾ കുറവോ തുല്യമോ ആയിരിക്കണം

ഈ തരത്തിന് സൈൻ ഇൻ, സൈൻഡ് എന്നീ പര്യായങ്ങളുണ്ട്.

ഒപ്പിടാത്ത സംഖ്യ : ഒരു പോസിറ്റീവ് പൂർണ്ണസംഖ്യയെ പ്രതിനിധീകരിക്കുന്നു. പ്രോസസർ ആർക്കിടെക്ചറിനെ ആശ്രയിച്ച്, ഇതിന് 2 ബൈറ്റുകൾ (16 ബിറ്റുകൾ) അല്ലെങ്കിൽ 4 ബൈറ്റുകൾ (32 ബിറ്റുകൾ) ഉണ്ടായിരിക്കാം, ഇക്കാരണത്താൽ, പരിധി മൂല്യങ്ങളുടെ പരിധി വ്യത്യാസപ്പെടാം: 0 മുതൽ 65535 വരെ (2 ബൈറ്റുകൾക്ക്), അല്ലെങ്കിൽ 0 മുതൽ 4,294,967,295 വരെ (4 ബൈറ്റുകൾക്ക്).

ഈ തരത്തിന്റെ പര്യായമായി unsigned എന്നത് ഉപയോഗിക്കാം

നീളം : −2,147,483,648 മുതൽ 2,147,483,647 വരെയുള്ള ശ്രേണിയിലെ ഒരു പൂർണ്ണസംഖ്യയെ പ്രതിനിധീകരിക്കുന്നു. മെമ്മറിയുടെ 4 ബൈറ്റുകൾ (32 ബിറ്റുകൾ) ഉൾക്കൊള്ളുന്നു.

ഈ തരത്തിന് ലോംഗ് ഇൻറ്റ്, സൈൻഡ് ലോംഗ് ഇൻറ്റ്, സൈൻഡ് ലോംഗ് എന്നീ പര്യായങ്ങളും ഉണ്ട്

ഒപ്പിടാത്ത നീളം: 0 മുതൽ 4,294,967,295 വരെയുള്ള ശ്രേണിയിലെ ഒരു പൂർണ്ണസംഖ്യയെ പ്രതിനിധീകരിക്കുന്നു. 4 ബൈറ്റുകൾ (32 ബിറ്റുകൾ) മെമ്മറി ഉൾക്കൊള്ളുന്നു.

സൈൻ ചെയ്യാത്ത ദൈർഘ്യമേറിയ int എന്ന പര്യായപദമുണ്ട്.

ദൈർഘ്യമേറിയത്: −9,223,372,036,854,775,808 മുതൽ +9,223,372,036,854,775,807 വരെയുള്ള ശ്രേണിയിലെ ഒരു പൂർണ്ണസംഖ്യയെ പ്രതിനിധീകരിക്കുന്നു. സാധാരണയായി 8 ബൈറ്റുകൾ (64 ബിറ്റുകൾ) മെമ്മറി ഉൾക്കൊള്ളുന്നു.

ലോംഗ് ലോംഗ് ഇന്റ്, സൈഡ് ലോങ് ലോംഗ് ഇൻറ്റ്, സൈഡ് ലോങ് ലോംഗ് എന്നിങ്ങനെയുള്ള പര്യായപദങ്ങളുണ്ട്.

ഒപ്പിടാത്ത നീളം : 0 മുതൽ 18,446,744,073,709,551,615 വരെയുള്ള ശ്രേണിയിലെ ഒരു പൂർണ്ണസംഖ്യയെ പ്രതിനിധീകരിക്കുന്നു. സാധാരണ 8 ബൈറ്റുകൾ (64 ബിറ്റുകൾ) മെമ്മറി ഉൾക്കൊള്ളുന്നു.

സൈൻ ചെയ്യാത്ത നീളമുള്ള സംഖ്യാ പര്യായമുണ്ട്.

float : +/- 3.4E-38 മുതൽ 3.4E+38 വരെയുള്ള ശ്രേണിയിലെ ഏക-കൃത്യതയുള്ള ഫ്ലോട്ടിംഗ് പോയിന്റ് യഥാർത്ഥ സംഖ്യയെ പ്രതിനിധീകരിക്കുന്നു. മെമ്മറിയിൽ 4 ബൈറ്റുകൾ (32 ബിറ്റുകൾ) ഉൾക്കൊള്ളുന്നു

ഇരട്ട : +/- 1.7E-308 മുതൽ 1.7E+308 വരെയുള്ള ശ്രേണിയിലുള്ള ഇരട്ട പ്രിസിഷൻ ഫ്ലോട്ടിംഗ് പോയിന്റ് യഥാർത്ഥ സംഖ്യയെ പ്രതിനിധീകരിക്കുന്നു. മെമ്മറിയിൽ 8 ബൈറ്റുകൾ (64 ബിറ്റുകൾ) ഉൾക്കൊള്ളുന്നു

നീളമുള്ള ഇരട്ട : കുറഞ്ഞത് 8 ബൈറ്റുകളുടെ (64 ബിറ്റുകൾ) ഇരട്ട-പ്രിസിഷൻ ഫ്ലോട്ടിംഗ് പോയിന്റ് യഥാർത്ഥ സംഖ്യയെ പ്രതിനിധീകരിക്കുന്നു. അധിനിവേശ മെമ്മറിയുടെ വലുപ്പത്തെ ആശ്രയിച്ച്, സാധുവായ മൂല്യങ്ങളുടെ ശ്രേണി വ്യത്യാസപ്പെടാം.

void : മൂല്യമില്ലാതെ ടൈപ്പ് ചെയ്യുക

അങ്ങനെ, ശൂന്യത ഒഴികെയുള്ള എല്ലാ ഡാറ്റാ തരങ്ങളെയും മൂന്ന് ഗ്രൂപ്പുകളായി തിരിക്കാം: പ്രതീകം (char, wchar_t, char16_t, char32_t), പൂർണ്ണസംഖ്യ (ഹ്രസ്വ, സംഖ്യ, നീളം, നീളം, നീളം), ഫ്ലോട്ടിംഗ് പോയിന്റ് നമ്പർ തരങ്ങൾ (ഫ്ലോട്ട്, ഡബിൾ, ലോംഗ് ഡബിൾ).

പ്രതീക തരങ്ങൾ

ആപ്ലിക്കേഷനിലെ പ്രതീകങ്ങളെ പ്രതിനിധീകരിക്കാൻ ഉപയോഗിക്കുന്ന തരങ്ങൾ char, wchar_t, char16_t, char32_t എന്നിവയാണ്.

നമുക്ക് നിരവധി വേരിയബിളുകൾ നിർവചിക്കാം:

ചാർ സി="ഡി"; wchar_t d="c";

ഒരു ചാർ വേരിയബിൾ ഒറ്റ ഉദ്ധരണികളിലെ ഒരു പ്രതീകം അതിന്റെ മൂല്യമായി എടുക്കുന്നു: char c = "d" . പട്ടികയിൽ മുകളിൽ വ്യക്തമാക്കിയ ശ്രേണിയിൽ നിന്ന് നിങ്ങൾക്ക് ഒരു നമ്പർ നൽകാനും കഴിയും: char c = 120 . ഈ സാഹചര്യത്തിൽ, ASCII പ്രതീക പട്ടികയിൽ കോഡ് 120 ഉള്ള പ്രതീകമായിരിക്കും c വേരിയബിളിന്റെ മൂല്യം.

കൺസോളിലേക്ക് wchar_t പ്രതീകങ്ങൾ ഔട്ട്‌പുട്ട് ചെയ്യുന്നതിന്, നിങ്ങൾ ഉപയോഗിക്കേണ്ടത് std::cout അല്ല, std::wcout സ്ട്രീം:

#ഉൾപ്പെടുന്നു int main() (char a = "H"; wchar_t b = "e"; std::wcout<< a << b << "\n"; return 0; }

ഈ സാഹചര്യത്തിൽ, std::wcout സ്ട്രീമിന് char, wchar_t എന്നിവയിൽ പ്രവർത്തിക്കാൻ കഴിയും. wchar_t വേരിയബിളിനായുള്ള std::cout സ്ട്രീം ഒരു പ്രതീകത്തിന് പകരം അതിന്റെ സംഖ്യാ കോഡ് ഔട്ട്പുട്ട് ചെയ്യും.

C++11 സ്റ്റാൻഡേർഡ് char16_t, char32_t തരങ്ങൾ ചേർത്തു, അവ യൂണികോഡ് ഉപയോഗിക്കുന്നതിന് വേണ്ടിയുള്ളതാണ്. എന്നിരുന്നാലും, ഈ തരങ്ങളുമായി പ്രവർത്തിക്കുന്നതിനുള്ള ത്രെഡുകൾ OS തലത്തിൽ ഇതുവരെ നടപ്പിലാക്കിയിട്ടില്ല. അതിനാൽ, ഈ തരത്തിലുള്ള വേരിയബിളുകളുടെ മൂല്യങ്ങൾ കൺസോളിലേക്ക് പ്രദർശിപ്പിക്കണമെങ്കിൽ, നിങ്ങൾ വേരിയബിളുകളെ char അല്ലെങ്കിൽ wchar_t തരങ്ങളിലേക്ക് പരിവർത്തനം ചെയ്യേണ്ടതുണ്ട്:

#ഉൾപ്പെടുന്നു int main() (char a = "H"; wchar_t b = "e"; char16_t c = "l"; char32_t d = "o"; std::cout<< a << (char)b << (char)c << (char)d << "\n"; return 0; }

ഈ സാഹചര്യത്തിൽ, ഔട്ട്പുട്ട് ചെയ്യുമ്പോൾ, വേരിയബിളുകൾക്ക് മുമ്പായി ചാർ തരത്തിലേക്ക് ഒരു കാസ്റ്റ് ഓപ്പറേഷൻ നൽകുന്നു - (char) , അതിനാൽ b, c, d എന്നീ വേരിയബിളുകളുടെ മൂല്യങ്ങൾ ചാർ തരത്തിലേക്ക് പരിവർത്തനം ചെയ്യപ്പെടുകയും ഔട്ട്പുട്ട് ചെയ്യാൻ കഴിയും std::cout സ്ട്രീം ഉപയോഗിക്കുന്ന കൺസോൾ.

പൂർണ്ണസംഖ്യ തരങ്ങൾ

പൂർണ്ണസംഖ്യ തരങ്ങളെ ഇനിപ്പറയുന്ന തരങ്ങളാൽ പ്രതിനിധീകരിക്കുന്നു: ഹ്രസ്വ, ഒപ്പിടാത്ത ഷോർട്ട്, ഇൻറ്റ്, സൈൻ ചെയ്യാത്ത സംഖ്യ, നീളം, ഒപ്പിടാത്ത നീളം, നീണ്ട നീളം, ഒപ്പിടാത്ത നീളം:

ഷോർട്ട് എ = -10; ഒപ്പിടാത്ത ഷോർട്ട് b= 10; int c = -30; ഒപ്പിടാത്ത int d = 60; നീണ്ട ഇ = -170; ഒപ്പിടാത്ത നീണ്ട f = 45; നീണ്ട നീണ്ട g = 89;

ഫ്ലോട്ടിംഗ് പോയിന്റ് നമ്പറുകളുടെ തരങ്ങൾ

ഫ്ലോട്ടിംഗ് പോയിന്റ്, ഫ്രാക്ഷണൽ നമ്പർ തരങ്ങളെ ഫ്ലോട്ട്, ഡബിൾ, ലോംഗ് ഡബിൾ എന്നിവ പ്രതിനിധീകരിക്കുന്നു:

ഫ്ലോട്ട് a = -10.45; ഇരട്ട ബി = 0.00105; നീളമുള്ള ഇരട്ട സി = 30.890045;

ഡാറ്റ തരം വലുപ്പങ്ങൾ

മുകളിലെ ലിസ്റ്റ് ഓരോ തരത്തിനും അത് മെമ്മറിയിൽ ഉൾക്കൊള്ളുന്ന വലുപ്പം കാണിക്കുന്നു. എന്നിരുന്നാലും, കമ്പ്യൂട്ടറിന്റെ ഹാർഡ്‌വെയർ കഴിവുകളെ അടിസ്ഥാനമാക്കി, കംപൈലർ ഡെവലപ്പർമാർക്ക് തരങ്ങൾക്കുള്ള വലുപ്പ പരിധികൾ സ്വതന്ത്രമായി തിരഞ്ഞെടുക്കാൻ കഴിയുമെന്നത് ശ്രദ്ധിക്കേണ്ടതാണ്. സ്റ്റാൻഡേർഡ് ഏറ്റവും കുറഞ്ഞ മൂല്യങ്ങൾ മാത്രം സജ്ജമാക്കുന്നു. ഉദാഹരണത്തിന്, int, short തരങ്ങൾക്ക് ഏറ്റവും കുറഞ്ഞ മൂല്യം 16 ബിറ്റുകൾ ആണ്, നീളമുള്ള തരത്തിന് - 32 ബിറ്റുകൾ, നീളമുള്ള ഇരട്ട തരത്തിന്. ഈ സാഹചര്യത്തിൽ, നീളമുള്ള തരത്തിന്റെ വലുപ്പം int തരത്തിന്റെ വലുപ്പത്തേക്കാൾ കുറവായിരിക്കരുത്, കൂടാതെ int തരത്തിന്റെ വലുപ്പം ഹ്രസ്വ തരത്തിന്റെ വലുപ്പത്തേക്കാൾ കുറവായിരിക്കരുത്, കൂടാതെ നീളമുള്ള ഇരട്ട തരത്തിന്റെ വലുപ്പം ഇരട്ടിയേക്കാൾ വലുതായിരിക്കും. ഉദാഹരണത്തിന്, വിൻഡോസിനായുള്ള g++ കംപൈലർ ലോംഗ് ഡബിൾസിനായി 12 ബൈറ്റുകൾ ഉപയോഗിക്കുന്നു, കൂടാതെ വിഷ്വൽ സ്റ്റുഡിയോയിൽ നിർമ്മിച്ച കംപൈലർ വിൻഡോസിന് കീഴിൽ പ്രവർത്തിക്കുന്നതും ദൈർഘ്യമേറിയ ഇരട്ടകൾക്ക് 8 ബൈറ്റുകൾ ഉപയോഗിക്കുന്നു. അതായത്, ഒരേ പ്ലാറ്റ്‌ഫോമിൽ പോലും, വ്യത്യസ്ത കംപൈലറുകൾക്ക് ചില ഡാറ്റാ തരങ്ങളുടെ വലുപ്പത്തിൽ വ്യത്യസ്ത സമീപനങ്ങളുണ്ടാകാം. എന്നാൽ പൊതുവായി, ഡാറ്റ തരങ്ങൾ വിവരിക്കുമ്പോൾ മുകളിൽ സൂചിപ്പിച്ച വലുപ്പങ്ങൾ ഉപയോഗിക്കുന്നു.

എന്നിരുന്നാലും, ഒരു പ്രത്യേക തരം വലിപ്പം കൃത്യമായി അറിയേണ്ട സാഹചര്യങ്ങളുണ്ട്. ഇതിനായി, C++ ന് sizeof() ഓപ്പറേറ്റർ ഉണ്ട്, അത് വേരിയബിൾ ഉൾക്കൊള്ളുന്ന ബൈറ്റുകളിൽ മെമ്മറിയുടെ വലുപ്പം നൽകുന്നു:

#ഉൾപ്പെടുന്നു int main() (നീണ്ട ഇരട്ട നമ്പർ = 2; std::cout<< "sizeof(number) =" << sizeof(number); return 0; }

g++ ൽ കംപൈൽ ചെയ്യുമ്പോൾ കൺസോൾ ഔട്ട്പുട്ട്:

വലിപ്പം(സംഖ്യ) = 12

അതേ സമയം, വേരിയബിളുകൾ നിർവചിക്കുമ്പോൾ, ഒരു വേരിയബിളിന്റെ മൂല്യം അതിന്റെ തരത്തിനായുള്ള പരിധിക്കപ്പുറം പോകരുതെന്ന് മനസ്സിലാക്കേണ്ടത് പ്രധാനമാണ്. ഉദാഹരണത്തിന്:

ഒപ്പിടാത്ത ഹ്രസ്വ നമ്പർ = -65535;

G++ കംപൈലർ, ഈ വരി ഉപയോഗിച്ച് ഒരു പ്രോഗ്രാം കംപൈൽ ചെയ്യുമ്പോൾ, മൂല്യം -65535 സൈൻ ചെയ്യാത്ത ഷോർട്ട് ടൈപ്പിനുള്ള സാധുവായ മൂല്യങ്ങളുടെ പരിധിയിലല്ലെന്നും അത് വെട്ടിച്ചുരുക്കുമെന്നും പ്രസ്താവിക്കുന്ന ഒരു പിശക് സൃഷ്ടിക്കും.

വിഷ്വൽ സ്റ്റുഡിയോയിൽ, കംപൈലേഷൻ പിശകുകളില്ലാതെ തുടരാം, പക്ഷേ നമ്പർ വേരിയബിളിന് മൂല്യം 2 ലഭിക്കും - -65535 എന്ന നമ്പർ സൈൻ ചെയ്യാത്ത ഹ്രസ്വ തരത്തിലേക്ക് പരിവർത്തനം ചെയ്തതിന്റെ ഫലം. അതായത്, വീണ്ടും, ഫലം പ്രതീക്ഷിച്ചതുപോലെ ആയിരിക്കില്ല. ഒരു പ്രത്യേക തരം അനുസരിച്ച് വ്യാഖ്യാനിക്കപ്പെടുന്ന മെമ്മറിയിലുള്ള ബിറ്റുകളുടെ ഒരു ശേഖരം മാത്രമാണ് വേരിയബിളിന്റെ മൂല്യം. വ്യത്യസ്ത തരങ്ങൾക്ക്, ഒരേ കൂട്ടം ബിറ്റുകൾ വ്യത്യസ്തമായി വ്യാഖ്യാനിക്കാം. അതിനാൽ, ഒരു വേരിയബിളിന് ഒരു മൂല്യം നൽകുമ്പോൾ തന്നിരിക്കുന്ന തരത്തിനായുള്ള മൂല്യ ശ്രേണികൾ പരിഗണിക്കേണ്ടത് പ്രധാനമാണ്.

യാന്ത്രിക സ്പെസിഫയർ

പദപ്രയോഗത്തിന്റെ തരം നിർണ്ണയിക്കാൻ ചിലപ്പോൾ ബുദ്ധിമുട്ടായിരിക്കും. ഏറ്റവും പുതിയ മാനദണ്ഡങ്ങൾ അനുസരിച്ച്, ഒബ്‌ജക്റ്റിന്റെ തരം അനുമാനിക്കാൻ നിങ്ങൾക്ക് കമ്പൈലറെ അനുവദിക്കാം. കൂടാതെ ഓട്ടോ സ്‌പെസിഫയർ ഇതിനായി ഉപയോഗിക്കുന്നു. മാത്രമല്ല, ഞങ്ങൾ ഓട്ടോ സ്‌പെസിഫയർ ഉപയോഗിച്ച് ഒരു വേരിയബിൾ നിർവചിക്കുകയാണെങ്കിൽ, ഈ വേരിയബിൾ കുറച്ച് മൂല്യം ഉപയോഗിച്ച് ആരംഭിക്കണം:

ഓട്ടോ നമ്പർ = 5;

അസൈൻ ചെയ്‌ത മൂല്യത്തെ അടിസ്ഥാനമാക്കി, കംപൈലർ വേരിയബിളിന്റെ തരം അനുമാനിക്കും. യാന്ത്രിക സ്പെസിഫയർ ഉള്ള അൺഇനീഷ്യലൈസ്ഡ് വേരിയബിളുകൾ അനുവദനീയമല്ല.

C ലെ ഡാറ്റ തരങ്ങൾ, മൂല്യങ്ങൾക്ക് സമാനമായ സ്വഭാവസവിശേഷതകളുള്ള ഡാറ്റയുടെ ഒരു വിഭാഗമാണ്. മെമ്മറിയിലെ ഡാറ്റയുടെ ആന്തരിക പ്രാതിനിധ്യം തരം നിർവചിക്കുന്നു. ഏറ്റവും അടിസ്ഥാന ഡാറ്റാ തരങ്ങൾ: ലോജിക്കൽ, പൂർണ്ണസംഖ്യ, ഫ്ലോട്ടിംഗ് പോയിന്റ് നമ്പറുകൾ, സ്ട്രിംഗുകൾ, പോയിന്ററുകൾ.

ഡൈനാമിക് ടൈപ്പിംഗ് ഉപയോഗിച്ച്, ഒരു വേരിയബിൾ ആരംഭിക്കുന്ന സമയത്ത് ഒരു തരവുമായി ബന്ധപ്പെട്ടിരിക്കുന്നു. കോഡിന്റെ വിവിധ ഭാഗങ്ങളിലുള്ള ഒരു വേരിയബിളിന് വ്യത്യസ്ത തരങ്ങളുണ്ടാകാമെന്ന് ഇത് മാറുന്നു. ജാവ സ്ക്രിപ്റ്റ്, പൈത്തൺ, റൂബി, പിഎച്ച്പി എന്നിവ ഡൈനാമിക് ടൈപ്പിംഗ് പിന്തുണയ്ക്കുന്നു.

ഡൈനാമിക് ടൈപ്പിംഗിന്റെ വിപരീതമാണ് സ്റ്റാറ്റിക് ടൈപ്പിംഗ്. പ്രഖ്യാപിക്കുമ്പോൾ, ഒരു വേരിയബിളിന് പിന്നീട് മാറാത്ത ഒരു തരം ലഭിക്കും. സി, സി++ എന്നീ ഭാഷകൾ അങ്ങനെയാണ്. സങ്കീർണ്ണമായ കോഡ് എഴുതുന്നതിന് ഈ രീതി ഏറ്റവും സൗകര്യപ്രദമാണ്, കൂടാതെ കംപൈലേഷൻ ഘട്ടത്തിൽ നിരവധി പിശകുകൾ ഇല്ലാതാക്കുന്നു.

ഭാഷകളെ അനൗപചാരികമായി ശക്തമായി ടൈപ്പ് ചെയ്തതും ദുർബലമായി ടൈപ്പ് ചെയ്തതുമായി തിരിച്ചിരിക്കുന്നു. ശക്തമായ ടൈപ്പിംഗ് അർത്ഥമാക്കുന്നത്, പ്രതീക്ഷിച്ചതും യഥാർത്ഥവുമായ തരങ്ങൾ പൊരുത്തപ്പെടുന്നില്ലെങ്കിൽ കംപൈലർ ഒരു പിശക് വരുത്തും എന്നാണ്.

x = 1 + "2"; //പിശക് - നിങ്ങൾക്ക് ഒരു സംഖ്യയിലേക്ക് ഒരു ചിഹ്നം ചേർക്കാൻ കഴിയില്ല

ദുർബലമായ ടൈപ്പിംഗിന്റെ ഒരു ഉദാഹരണം.

തരം സുരക്ഷാ സംവിധാനമാണ് ടൈപ്പ് സ്ഥിരത പരിശോധന നടത്തുന്നത്. ടൈപ്പിംഗ് പിശക് സംഭവിക്കുന്നു, ഉദാഹരണത്തിന്, ഒരു ഫംഗ്‌ഷനായി ഒരു നമ്പർ ഉപയോഗിക്കാൻ ശ്രമിക്കുമ്പോൾ. ടൈപ്പ് ചെയ്യാത്ത ഭാഷകളുണ്ട്. ടൈപ്പ് ചെയ്തവയിൽ നിന്ന് വ്യത്യസ്തമായി, ഓരോ ഒബ്ജക്റ്റിലും ഏത് പ്രവർത്തനവും നടത്താൻ അവ നിങ്ങളെ അനുവദിക്കുന്നു.

മെമ്മറി ക്ലാസുകൾ

വേരിയബിളുകൾക്ക്, അവയുടെ തരം പരിഗണിക്കാതെ, അതിന്റേതായ വ്യാപ്തിയും ആയുസ്സും ഉണ്ട്.

മെമ്മറി ക്ലാസുകൾ:

• ഓട്ടോ;
• സ്റ്റാറ്റിക്;
• ബാഹ്യമായ;
• രജിസ്റ്റർ ചെയ്യുക.

സി ഭാഷയിലെ എല്ലാ വേരിയബിളുകളും സ്ഥിരസ്ഥിതിയായി പ്രാദേശികമാണ്. ഒരു ഫംഗ്ഷനിലോ ബ്ലോക്കിലോ മാത്രമേ അവ ഉപയോഗിക്കാൻ കഴിയൂ. പ്രവർത്തനം പൂർത്തിയാകുമ്പോൾ, അവയുടെ മൂല്യം നശിപ്പിക്കപ്പെടും.

ഒരു സ്റ്റാറ്റിക് വേരിയബിളും പ്രാദേശികമാണ്, എന്നാൽ അതിന്റെ ബ്ലോക്കിന് പുറത്ത് മറ്റൊരു മൂല്യം ഉണ്ടായിരിക്കാം, കൂടാതെ ഫംഗ്‌ഷൻ കോളുകൾക്കിടയിൽ മൂല്യം നിലനിർത്തും.

ബാഹ്യ വേരിയബിൾ ആഗോളമാണ്. ഇത് കോഡിന്റെ ഏത് ഭാഗത്തും മറ്റൊരു ഫയലിലും ലഭ്യമാണ്.

C-യിലെ ഡാറ്റാ തരം സ്പെസിഫയറുകൾ ഇനിപ്പറയുന്ന സന്ദർഭങ്ങളിൽ വ്യക്തമാക്കിയേക്കില്ല:

1. ബ്ലോക്കിനുള്ളിലെ എല്ലാ വേരിയബിളുകളും വേരിയബിളുകളല്ല; അതിനാൽ, ഈ പ്രത്യേക മെമ്മറി ക്ലാസ് ഉപയോഗിക്കാനാണ് ഉദ്ദേശിക്കുന്നതെങ്കിൽ, യാന്ത്രിക സ്പെസിഫയർ വ്യക്തമാക്കിയിട്ടില്ല.
2. ഒരു ബ്ലോക്കിനോ ഫംഗ്‌ഷനോ പുറത്ത് പ്രഖ്യാപിച്ചിരിക്കുന്ന എല്ലാ ഫംഗ്‌ഷനുകളും ഡിഫോൾട്ടായി ആഗോളമാണ്, അതിനാൽ എക്‌സ്‌റ്റേൺ സ്‌പെസിഫയർ ആവശ്യമില്ല.

ലളിതമായ തരങ്ങൾ സൂചിപ്പിക്കാൻ, int, char, float അല്ലെങ്കിൽ ഇരട്ട സ്പെസിഫയറുകൾ ഉപയോഗിക്കുക. ഒപ്പിടാത്തതും ഒപ്പിട്ടതും ഹ്രസ്വവും നീളമുള്ളതും നീളമുള്ളതുമായ മോഡിഫയറുകൾ വേരിയബിളുകൾക്ക് പകരം വയ്ക്കാം.

സ്ഥിരസ്ഥിതിയായി, എല്ലാ സംഖ്യകളും ഒപ്പിട്ടിരിക്കുന്നു; അതിനാൽ, അവ പോസിറ്റീവ് സംഖ്യകളുടെ പരിധിയിൽ മാത്രമേ ഉണ്ടാകൂ. സൈൻ ചെയ്‌തിരിക്കുന്ന ചാറിന്റെ ഒരു വേരിയബിൾ നിർവചിക്കുന്നതിന്, ഒപ്പിട്ട ചാർ എഴുതുക. ദൈർഘ്യമേറിയതും നീളമുള്ളതും ഹ്രസ്വവും സ്റ്റോറേജിനായി എത്ര മെമ്മറി സ്പേസ് അനുവദിച്ചിട്ടുണ്ടെന്ന് സൂചിപ്പിക്കുന്നു. ഏറ്റവും വലുത് നീളമുള്ളതാണ്, ചെറുത് ചെറുതാണ്.

സിയിലെ ഏറ്റവും ചെറിയ ഡാറ്റാ തരമാണ് ചാർ. സ്റ്റോർ മൂല്യങ്ങൾക്കായി 1 ബൈറ്റ് മെമ്മറി മാത്രമേ അനുവദിച്ചിട്ടുള്ളൂ. തരം പ്രതീകത്തിന്റെ ഒരു വേരിയബിളിന് സാധാരണയായി പ്രതീകങ്ങൾ നൽകിയിരിക്കുന്നു, കുറച്ച് തവണ - അക്കങ്ങൾ. പ്രതീക മൂല്യങ്ങൾ ഉദ്ധരണി ചിഹ്നങ്ങളിൽ ഉൾപ്പെടുത്തിയിട്ടുണ്ട്.

int ടൈപ്പ് പൂർണ്ണസംഖ്യകൾ സംഭരിക്കുന്നു, അതിന്റെ വലുപ്പം നിർവചിച്ചിട്ടില്ല - കമ്പ്യൂട്ടർ ആർക്കിടെക്ചറിനെ ആശ്രയിച്ച് ഇതിന് 4 ബൈറ്റുകൾ മെമ്മറി എടുക്കും.

ഒപ്പിടാത്ത വേരിയബിളിന്റെ വ്യക്തമായ പരിവർത്തനം ഇനിപ്പറയുന്ന രീതിയിൽ വ്യക്തമാക്കിയിരിക്കുന്നു:

പരോക്ഷമായ ഒന്ന് ഇതുപോലെ കാണപ്പെടുന്നു:

ഫ്ലോട്ടുചെയ്ത് ഒരു ഡോട്ട് ഉപയോഗിച്ച് നമ്പറുകൾ ഇരട്ടി നിർവചിക്കുക. ഫ്ലോട്ട് നമ്പറുകൾ -2.3 അല്ലെങ്കിൽ 3.34 ആയി പ്രതിനിധീകരിക്കുന്നു. കൂടുതൽ കൃത്യതയ്ക്കായി ഇരട്ട ഉപയോഗിക്കുന്നു - പൂർണ്ണസംഖ്യയ്ക്കും ഫ്രാക്ഷണൽ സെപ്പറേറ്ററിനും ശേഷം കൂടുതൽ അക്കങ്ങൾ സൂചിപ്പിച്ചിരിക്കുന്നു. ഈ തരം ഫ്ലോട്ടിനേക്കാൾ കൂടുതൽ മെമ്മറി സ്പേസ് എടുക്കുന്നു.

ശൂന്യമായ ഒരു മൂല്യമുണ്ട്. ഒന്നും തിരികെ നൽകാത്ത പ്രവർത്തനങ്ങളെ ഇത് നിർവചിക്കുന്നു. ഈ സ്പെസിഫയർ മെത്തേഡ് ആർഗ്യുമെന്റുകളിൽ ഒരു ശൂന്യമായ മൂല്യം വ്യക്തമാക്കുന്നു. ഏത് തരത്തിലുള്ള ഡാറ്റയും സ്വീകരിക്കാൻ കഴിയുന്ന പോയിന്ററുകളും അസാധുവായി നിർവചിച്ചിരിക്കുന്നു.

ബൂളിയൻ തരം ബൂൾ

അവസ്ഥ പരിശോധനകളിലും ലൂപ്പുകളിലും ഉപയോഗിക്കുന്നു. രണ്ട് അർത്ഥങ്ങൾ മാത്രമേയുള്ളൂ:

• സത്യം;
• കള്ളം.

ബൂളിയൻ മൂല്യങ്ങൾ ഒരു ഇൻറ്റ് മൂല്യത്തിലേക്ക് പരിവർത്തനം ചെയ്യാൻ കഴിയും. ശരി ഒന്നിന് തുല്യമാണ്, തെറ്റ് പൂജ്യത്തിന് തുല്യമാണ്. ടൈപ്പ് കൺവേർഷൻ bool, int എന്നിവയ്ക്കിടയിൽ മാത്രമേ സാധ്യമാകൂ, അല്ലാത്തപക്ഷം കംപൈലർ ഒരു പിശക് വരുത്തും.

എങ്കിൽ (x) ( //പിശക്: "'int' എന്ന തരത്തെ പരോക്ഷമായി 'bool ആയി പരിവർത്തനം ചെയ്യാൻ കഴിയില്ല""

എങ്കിൽ (x != 0) // C# വഴി

സ്ട്രിംഗുകളും അറേകളും

സിയിലെ സങ്കീർണ്ണമായ ഡാറ്റാ തരങ്ങളാണ് അറേകൾ. Javascript അല്ലെങ്കിൽ Ruby ചെയ്യുന്നതുപോലെ PL സ്ട്രിംഗുകൾ ഉപയോഗിച്ച് പ്രവർത്തിക്കുന്നില്ല. സിയിൽ, എല്ലാ സ്ട്രിംഗുകളും ഒരു പ്രതീക മൂല്യമുള്ള മൂലകങ്ങളുടെ നിരകളാണ്. വരികൾ ഒരു നൾ ബൈറ്റിൽ അവസാനിക്കുന്നു "

ഈ പാഠത്തിൽ ഞങ്ങൾ പൂർണ്ണസംഖ്യ ഡാറ്റ തരങ്ങൾ, അവയുടെ മൂല്യ ശ്രേണികൾ, വിഭജനം, ഓവർഫ്ലോ എന്നിവ പരിശോധിക്കും: അവ എന്താണെന്നും ഉദാഹരണങ്ങളും.

പൂർണ്ണസംഖ്യ ഡാറ്റ തരങ്ങൾ

പൂർണ്ണസംഖ്യ ഡാറ്റ തരംവേരിയബിളുകളിൽ പൂർണ്ണസംഖ്യകൾ മാത്രം ഉൾക്കൊള്ളാൻ കഴിയുന്ന ഒരു തരം (ഫ്രാക്ഷണൽ ഭാഗം ഇല്ലാതെ, ഉദാഹരണത്തിന്: -2, -1, 0, 1, 2). C++ ൽ ഉപയോഗത്തിന് അഞ്ച് അടിസ്ഥാന പൂർണ്ണസംഖ്യകൾ ലഭ്യമാണ്:

കുറിപ്പ്: ചാർ തരം ഒരു പ്രത്യേക കേസാണ്, ഇത് ഒരു പൂർണ്ണസംഖ്യയും പ്രതീക ഡാറ്റാ തരവുമാണ്. ഇനിപ്പറയുന്ന പാഠങ്ങളിലൊന്നിൽ ഞങ്ങൾ ഇതിനെക്കുറിച്ച് കൂടുതൽ വിശദമായി സംസാരിക്കും.

മുകളിലുള്ള പൂർണ്ണസംഖ്യ തരങ്ങൾ തമ്മിലുള്ള പ്രധാന വ്യത്യാസം, അത് വലുതാണ്, ആ തരത്തിലുള്ള ഒരു വേരിയബിളിന് കൂടുതൽ മൂല്യങ്ങൾ സംഭരിക്കാൻ കഴിയും എന്നതാണ്.

പൂർണ്ണസംഖ്യ വേരിയബിളുകൾ നിർവചിക്കുന്നു

ഇത് ഇനിപ്പറയുന്ന രീതിയിൽ സംഭവിക്കുന്നു:

ചാർ സി; ഷോർട്ട് ഇൻറ്റ് SI; // സാധുവായ ഹ്രസ്വങ്ങൾ; //ഇഷ്ടപ്പെട്ട int i; നീണ്ട ഇൻറ്റ് ലി; // സാധുവായ നീണ്ട l; // വെയിലത്ത് നീളമുള്ള നീളം ഉള്ളത്; // സാധുവായ നീണ്ട നീണ്ട ll; // അഭികാമ്യം

പൂർണ്ണമായ പേരുകൾ short int , long int , long long int എന്നിവ ഉപയോഗിക്കാമെങ്കിലും, അവയുടെ ചുരുക്കിയ പതിപ്പുകൾ (int ഇല്ലാതെ) ഉപയോഗത്തിന് മുൻഗണന നൽകുന്നു. കൂടാതെ, തുടർച്ചയായി ints ചേർക്കുന്നത് കോഡ് വായിക്കുന്നത് പ്രയാസകരമാക്കുന്നു (ഒരു വേരിയബിളുമായി എളുപ്പത്തിൽ ആശയക്കുഴപ്പത്തിലാക്കുന്നു).

മൂല്യ ശ്രേണികളും പൂർണ്ണസംഖ്യ ഡാറ്റ തരങ്ങളുടെ അടയാളവും

മുമ്പത്തെ പാഠത്തിൽ നിന്ന് നിങ്ങൾക്കറിയാവുന്നതുപോലെ, n എണ്ണം ബിറ്റുകളുള്ള ഒരു വേരിയബിളിന് 2n സാധ്യമായ മൂല്യങ്ങൾ സംഭരിക്കാൻ കഴിയും. എന്നാൽ ഈ അർത്ഥങ്ങൾ എന്താണ്? പരിധിയിലുള്ളവ. പരിധി- ഒരു പ്രത്യേക തരം ഡാറ്റ സംഭരിക്കാൻ കഴിയുന്ന മൂല്യങ്ങളാണ് ഇവ. ഒരു പൂർണ്ണസംഖ്യ വേരിയബിളിന്റെ ശ്രേണി നിർണ്ണയിക്കുന്നത് രണ്ട് ഘടകങ്ങളാണ്: അതിന്റെ വലുപ്പവും (ബിറ്റുകളിൽ) അതിന്റെയും അടയാളം(അതായിരിക്കാം ഒപ്പിട്ടുഅഥവാ ഒപ്പിടാത്തത്).

ഒപ്പിട്ടു(ഒപ്പിട്ടത്) എന്നതിനർത്ഥം വേരിയബിളിൽ പോസിറ്റീവ്, നെഗറ്റീവ് സംഖ്യകൾ അടങ്ങിയിരിക്കാം എന്നാണ്. ഒരു വേരിയബിൾ ഒപ്പിട്ടതായി പ്രഖ്യാപിക്കാൻ, കീവേഡ് ഉപയോഗിക്കുക ഒപ്പിട്ടു:

ഒപ്പിട്ട ചാര് സി; ഒപ്പിട്ട ഷോർട്ട് എസ്; ഒപ്പിട്ടത് i; ഒപ്പിട്ട നീണ്ട l; ഒപ്പിട്ടു നീണ്ട നീണ്ട ll;

ഒപ്പിട്ട ചാര് സി; ഒപ്പിട്ട ഷോർട്ട് എസ്; ഒപ്പിട്ടത് ഐ ; നീണ്ട എൽ ഒപ്പിട്ടു; ഒപ്പിട്ടു നീണ്ട നീണ്ട ll;

സ്ഥിരസ്ഥിതിയായി, ഡാറ്റ തരത്തിന് മുമ്പായി ഒപ്പിട്ട കീവേഡ് എഴുതിയിരിക്കുന്നു.

ഒരു 1-ബൈറ്റ് ഒപ്പിട്ട പൂർണ്ണസംഖ്യ വേരിയബിളിന് -128 മുതൽ 127 വരെയുള്ള മൂല്യങ്ങളുടെ ശ്രേണിയുണ്ട്. -128 മുതൽ 127 വരെയുള്ള ഏത് മൂല്യവും (ഉൾപ്പെടെ) അതിൽ സുരക്ഷിതമായി സംഭരിക്കാൻ കഴിയും.

ചില സന്ദർഭങ്ങളിൽ, പ്രോഗ്രാമിൽ നെഗറ്റീവ് നമ്പറുകൾ ഉപയോഗിക്കില്ലെന്ന് മുൻകൂട്ടി അറിയാൻ കഴിയും. എന്തിന്റെയെങ്കിലും അളവോ വലുപ്പമോ സംഭരിക്കുന്നതിന് വേരിയബിളുകൾ ഉപയോഗിക്കുമ്പോൾ ഇത് വളരെ സാധാരണമാണ് (ഉദാഹരണത്തിന്, നിങ്ങളുടെ ഉയരമോ ഭാരമോ നെഗറ്റീവ് ആയിരിക്കരുത്). പൂർണ്ണസംഖ്യ തരം ഒപ്പിടാത്തത്(ഒപ്പ് ചെയ്യാത്തത്) പോസിറ്റീവ് നമ്പറുകൾ മാത്രമേ ഉൾക്കൊള്ളാൻ കഴിയൂ. ആയി ഒരു വേരിയബിൾ പ്രഖ്യാപിക്കാൻ ഒപ്പിടാത്തത്, കീവേഡ് ഉപയോഗിക്കുക ഒപ്പിടാത്തത്:

ഒപ്പിടാത്ത ചാർ സി; ഒപ്പിടാത്ത ഷോർട്ട് എസ്; ഒപ്പിടാത്ത int i; ഒപ്പിടാത്ത നീണ്ട l; ഒപ്പിടാത്ത നീളമുള്ള ll;

ഒപ്പിടാത്ത ചാര് സി; ഒപ്പിടാത്ത ഷോർട്ട് എസ്; ഒപ്പിടാത്ത int i; ഒപ്പിടാത്ത നീണ്ട എൽ; ഒപ്പിടാത്ത നീളമുള്ള ll;

ഒരു 1-ബൈറ്റ് ഒപ്പിടാത്ത പൂർണ്ണസംഖ്യ വേരിയബിളിന് 0 മുതൽ 255 വരെയുള്ള മൂല്യ ശ്രേണിയുണ്ട്.

ഒരു വേരിയബിളിനെ ഒപ്പിടാത്തതായി പ്രഖ്യാപിക്കുന്നത് അർത്ഥമാക്കുന്നത് അതിൽ നെഗറ്റീവ് സംഖ്യകൾ (പോസിറ്റീവ് മാത്രം) അടങ്ങിയിരിക്കരുത് എന്നാണ്.

ഒപ്പിട്ടതും ഒപ്പിടാത്തതും തമ്മിലുള്ള വ്യത്യാസം ഇപ്പോൾ നിങ്ങൾ മനസ്സിലാക്കുന്നു, വ്യത്യസ്ത ഡാറ്റാ തരങ്ങളുടെ മൂല്യ ശ്രേണികൾ നോക്കാം:

വലിപ്പം/തരം	മൂല്യങ്ങളുടെ ശ്രേണി
1 ബൈറ്റ് ഒപ്പിട്ടു	-128 മുതൽ 127 വരെ
1 ബൈറ്റ് ഒപ്പിട്ടിട്ടില്ല	0 മുതൽ 255 വരെ
2 ബൈറ്റുകൾ ഒപ്പിട്ടു	-32,768 മുതൽ 32,767 വരെ
2 ബൈറ്റുകൾ ഒപ്പിട്ടിട്ടില്ല	0 മുതൽ 65 535 വരെ
4 ബൈറ്റുകൾ ഒപ്പിട്ടു	-2 147 483 648 മുതൽ 2 147 483 647 വരെ
4 ബൈറ്റുകൾ ഒപ്പിട്ടിട്ടില്ല	0 മുതൽ 4 വരെ 294 967 295
8 ബൈറ്റുകൾ ഒപ്പിട്ടു	-9 223 372 036 854 775 808 മുതൽ 9 223 372 036 854 775 807
8 ബൈറ്റുകൾ ഒപ്പിട്ടിട്ടില്ല	0 മുതൽ 18 വരെ 446 744 073 709 551 615

ഗണിതശാസ്ത്രജ്ഞർക്ക്: ബിറ്റുകളുടെ n-ാമത്തെ സംഖ്യയുള്ള ഒരു സൈൻഡ് വേരിയബിളിന് -(2 n-1) മുതൽ 2 n-1 -1 വരെയുള്ള ശ്രേണിയുണ്ട്. n-ാമത്തെ എണ്ണം ബിറ്റുകളുള്ള ഒരു സൈൻ ചെയ്യാത്ത വേരിയബിളിന് 0 മുതൽ (2n)-1 വരെയുള്ള ശ്രേണിയുണ്ട്. ഗണിതശാസ്ത്രജ്ഞരല്ലാത്തവർക്ക്: ഒരു പട്ടിക ഉപയോഗിക്കുക :)

തുടക്കക്കാരായ പ്രോഗ്രാമർമാർ ചിലപ്പോൾ ഒപ്പിട്ടതും ഒപ്പിടാത്തതുമായ വേരിയബിളുകൾക്കിടയിൽ ആശയക്കുഴപ്പത്തിലാകും. എന്നാൽ അവരുടെ വ്യത്യാസങ്ങൾ ഓർക്കാൻ ഒരു എളുപ്പവഴിയുണ്ട്. നെഗറ്റീവ് സംഖ്യയും പോസിറ്റീവ് സംഖ്യയും തമ്മിലുള്ള വ്യത്യാസം എന്താണ്? ശരിയാണ്! മുൻവശത്ത് മൈനസ്. മൈനസ് ഇല്ലെങ്കിൽ, നമ്പർ പോസിറ്റീവ് ആണ്. അതിനാൽ, ഒരു അടയാളപ്പെടുത്തിയ പൂർണ്ണസംഖ്യ തരം അർത്ഥമാക്കുന്നത് ഒരു മൈനസ് ചിഹ്നം ഉണ്ടായിരിക്കാം എന്നാണ്, അതായത്. സംഖ്യകൾ പോസിറ്റീവ് അല്ലെങ്കിൽ നെഗറ്റീവ് ആകാം. ഒപ്പിടാത്ത പൂർണ്ണസംഖ്യ തരം അർത്ഥമാക്കുന്നത് മുന്നിലുള്ള മൈനസ് ചിഹ്നം പൂർണ്ണമായും ഇല്ല എന്നാണ്, അതായത്. സംഖ്യകൾ പോസിറ്റീവ് ആയിരിക്കാം.

എന്താണ് സ്ഥിരസ്ഥിതി: ഒപ്പിട്ടതോ ഒപ്പിടാത്തതോ?

സൈൻ ചെയ്യാതെയോ ഒപ്പിടാതെയോ ഒരു വേരിയബിൾ പ്രഖ്യാപിച്ചാൽ എന്ത് സംഭവിക്കും?

ചാർ ഒഴികെയുള്ള എല്ലാ പൂർണ്ണസംഖ്യ ഡാറ്റ തരങ്ങളും ഡിഫോൾട്ടായി ഒപ്പിട്ടിരിക്കുന്നു. ചാർ തരം ഒന്നുകിൽ ഒപ്പിട്ടതോ ഒപ്പിടാത്തതോ ആകാം (എന്നാൽ സാധാരണയായി ഒപ്പിട്ടതാണ്).

മിക്ക കേസുകളിലും, ചാർ തരം ഒഴികെ, ഒപ്പിട്ട കീവേഡ് എഴുതിയിട്ടില്ല (ഇത് ഇതിനകം സ്ഥിരസ്ഥിതിയായി ഉപയോഗിച്ചിട്ടുണ്ട്), (ഇവിടെ വ്യക്തമാക്കുന്നതാണ് നല്ലത്).

പ്രോഗ്രാമർമാർ, ചട്ടം പോലെ, ഒരു പ്രത്യേക ആവശ്യമില്ലെങ്കിൽ ഒപ്പിടാത്ത പൂർണ്ണസംഖ്യകൾ ഉപയോഗിക്കുന്നത് ഒഴിവാക്കുന്നു, കാരണം, സ്ഥിതിവിവരക്കണക്കുകൾ പ്രകാരം, ഒപ്പിട്ട വേരിയബിളുകളേക്കാൾ കൂടുതൽ പിശകുകൾ ഒപ്പിടാത്ത വേരിയബിളുകളിൽ സംഭവിക്കുന്നു.

നിയമം: ഒപ്പിട്ട പൂർണ്ണസംഖ്യ തരങ്ങൾ ഉപയോഗിക്കുക ഇതിനുപകരമായി ഒപ്പിടാത്തത്.

ഓവർഫ്ലോ

ചോദ്യം: "ഒരു നിശ്ചിത ഡാറ്റാ തരത്തിന്റെ മൂല്യങ്ങളുടെ പരിധിക്ക് പുറത്തുള്ള ഒരു മൂല്യം ഉപയോഗിക്കാൻ ഞങ്ങൾ ശ്രമിച്ചാൽ എന്ത് സംഭവിക്കും?" ഉത്തരം: ഓവർഫ്ലോ. ഓവർഫ്ലോ(ഇംഗ്ലീഷ്) "ഓവർഫ്ലോ") വേരിയബിളിന് അവ സംഭരിക്കുന്നതിന് ആവശ്യമായ മെമ്മറി അനുവദിക്കാത്തതിനാൽ ബിറ്റുകൾ നഷ്‌ടപ്പെടുമ്പോൾ സംഭവിക്കുന്നു.

ഓവർഫ്ലോ ഉദാഹരണങ്ങൾ

4 ബിറ്റുകൾ അടങ്ങുന്ന, ഒപ്പിടാത്ത വേരിയബിൾ പരിഗണിക്കുക. മുകളിലെ പട്ടികയിൽ ലിസ്റ്റുചെയ്തിരിക്കുന്ന ഏതെങ്കിലും ബൈനറി നമ്പറുകൾ ഈ വേരിയബിളിനുള്ളിൽ യോജിക്കും.

"എന്നാൽ 4 ബിറ്റുകളിൽ കൂടുതൽ എടുക്കുന്ന ഒരു മൂല്യം നൽകാൻ ശ്രമിച്ചാൽ എന്ത് സംഭവിക്കും?" ശരിയാണ്! ഓവർഫ്ലോ. ഞങ്ങളുടെ വേരിയബിൾ ഏറ്റവും കുറഞ്ഞ പ്രാധാന്യമുള്ള 4 (വലതുവശത്തുള്ള) ബിറ്റുകൾ മാത്രമേ സംഭരിക്കുന്നുള്ളൂ, ബാക്കിയുള്ളവയെല്ലാം നഷ്‌ടമാകും.

ഉദാഹരണത്തിന്, നമ്മുടെ 4-ബിറ്റ് വേരിയബിളിൽ നമ്പർ 21 ഇടാൻ ശ്രമിക്കുകയാണെങ്കിൽ:

ദശാംശ വ്യവസ്ഥ	ബൈനറി സിസ്റ്റം
21	10101

21 എന്ന സംഖ്യ 5 ബിറ്റുകൾ എടുക്കുന്നു (10101). വലതുവശത്തുള്ള 4 ബിറ്റുകൾ (0101) വേരിയബിളുമായി യോജിക്കും, ഇടതുവശത്തെ ബിറ്റ് (1) കേവലം നഷ്ടപ്പെടും. ആ. ഞങ്ങളുടെ വേരിയബിളിൽ 0101 അടങ്ങിയിരിക്കും, അത് 101 ന് തുല്യമാണ് (മുൻവശത്തെ പൂജ്യം കണക്കാക്കില്ല), ഇത് ഇതിനകം 21 അല്ല, 5 ആണ്.

കുറിപ്പ്: സംഖ്യകളെ ബൈനറിയിൽ നിന്ന് ദശാംശത്തിലേക്കും തിരിച്ചും പരിവർത്തനം ചെയ്യുന്നതിനെക്കുറിച്ചുള്ള ഒരു പ്രത്യേക പാഠം ഉണ്ടാകും, അവിടെ ഞങ്ങൾ എല്ലാം വിശദമായി പരിഗണിക്കുകയും ചർച്ച ചെയ്യുകയും ചെയ്യും.

ഇനി നമുക്ക് കോഡിലെ ഒരു ഉദാഹരണം നോക്കാം (ഹ്രസ്വ തരം 16 ബിറ്റുകൾ എടുക്കും):

#ഉൾപ്പെടുന്നു int main() ( ഒപ്പിടാത്ത ഷോർട്ട് x = 65535; // 16-ബിറ്റ് ഒപ്പിടാത്ത std ::cout വേരിയബിളിന് സംഭരിക്കാൻ കഴിയുന്ന ഏറ്റവും വലിയ മൂല്യം<< "x was: " << x << std::endl; x = x + 1; // 65536 - это число больше максимально допустимого числа из диапазона допустимых значений. Следовательно, произойдёт переполнение, так как переменнная x не может хранить 17 бит std::cout << "x is now: " << x << std::endl; return 0; }

#ഉൾപ്പെടുന്നു int main() ഒപ്പിടാത്ത ഷോർട്ട് x = 65535 ; // 16-ബിറ്റ് സൈൻ ചെയ്യാത്ത വേരിയബിളിന് സംഭരിക്കാൻ കഴിയുന്ന ഏറ്റവും വലിയ മൂല്യം std::cout<< "x was: " << x << std :: endl ; x = x + 1 ; // 65536 എന്നത് സാധുവായ മൂല്യങ്ങളുടെ ശ്രേണിയിൽ നിന്ന് അനുവദനീയമായ പരമാവധി സംഖ്യയേക്കാൾ വലിയ സംഖ്യയാണ്. അതിനാൽ, x എന്ന വേരിയബിളിന് 17 ബിറ്റുകൾ സംഭരിക്കാൻ കഴിയാത്തതിനാൽ ഒരു ഓവർഫ്ലോ സംഭവിക്കും std::cout<< "x is now: " << x << std :: endl ; തിരികെ 0;

x ആയിരുന്നു: 65535
x ഇപ്പോൾ: 0 ആണ്

എന്താണ് സംഭവിക്കുന്നത്? x വേരിയബിളിലേക്ക് തള്ളാൻ കഴിയാത്ത എന്തെങ്കിലും ഞങ്ങൾ ക്രാം ചെയ്യാൻ ശ്രമിച്ചതിനാൽ ഒരു ഓവർഫ്ലോ സംഭവിച്ചു.

കൂടുതൽ അറിയാൻ ആഗ്രഹിക്കുന്നവർക്ക്:ബൈനറിയിലെ 65535 എന്ന സംഖ്യയെ 1111 1111 1111 1111 ആയി പ്രതിനിധീകരിക്കുന്നു. എല്ലാ 16 ബിറ്റുകളും ഉപയോഗിക്കുന്നതിനാൽ 2-ബൈറ്റ് (16-ബിറ്റ്) സൈൻ ചെയ്യാത്ത പൂർണ്ണസംഖ്യ വേരിയബിളിന് സംഭരിക്കാൻ കഴിയുന്ന ഏറ്റവും വലിയ സംഖ്യയാണ് 65535. നമ്മൾ 1 ചേർക്കുമ്പോൾ, നമുക്ക് 65536 എന്ന നമ്പർ ലഭിക്കും. 65536 എന്ന സംഖ്യ ബൈനറിയിൽ 1 0000 0000 0000 0000 ആയി പ്രതിനിധീകരിക്കുന്നു, കൂടാതെ 17 ബിറ്റുകൾ എടുക്കുന്നു! അതിനാൽ, ഏറ്റവും പ്രധാനപ്പെട്ട ബിറ്റ് (അത് 1 ആണ്) നഷ്ടപ്പെട്ടു, വലതുവശത്തുള്ള എല്ലാ 16 ബിറ്റുകളും നിലനിർത്തുന്നു. 0000 0000 0000 0000 എന്ന കോമ്പിനേഷൻ ദശാംശ 0 യുമായി യോജിക്കുന്നു, ഇത് ഞങ്ങളുടെ ഫലമാണ്.

അതുപോലെ, സാധുതയുള്ള മൂല്യങ്ങളുടെ ഏറ്റവും കുറഞ്ഞ ശ്രേണിയേക്കാൾ കുറവുള്ള ഒരു സംഖ്യ ഉപയോഗിച്ച് നമുക്ക് ഓവർഫ്ലോ ലഭിക്കും:

#ഉൾപ്പെടുന്നു int main() ( ഒപ്പിടാത്ത ഷോർട്ട് x = 0; // 2-ബൈറ്റ് സൈൻ ചെയ്യാത്ത വേരിയബിളിന് std ::cout സംഭരിക്കാൻ കഴിയുന്ന ഏറ്റവും ചെറിയ മൂല്യം<< "x was: " << x << std::endl; x = x - 1; // переполнение! std::cout << "x is now: " << x << std::endl; return 0; }

#ഉൾപ്പെടുന്നു int main() ഒപ്പിടാത്ത ഷോർട്ട് x = 0 ; // 2-ബൈറ്റ് സൈൻ ചെയ്യാത്ത വേരിയബിളിന് സംഭരിക്കാൻ കഴിയുന്ന ഏറ്റവും ചെറിയ മൂല്യം std::cout<< "x was: " << x << std :: endl ; x = x - 1 ; // കവിഞ്ഞൊഴുകുന്നു! std::cout<< "x is now: " << x << std :: endl ; തിരികെ 0;

മുകളിലുള്ള പ്രോഗ്രാം പ്രവർത്തിപ്പിക്കുന്നതിന്റെ ഫലം:

x ആയിരുന്നു: 0
x ഇപ്പോൾ: 65535

ഓവർഫ്ലോ വിവരങ്ങൾ നഷ്ടപ്പെടുന്നതിലേക്ക് നയിക്കുന്നു, അത് ഒരിക്കലും നല്ല കാര്യമല്ല. ഒരു വേരിയബിളിന്റെ മൂല്യം ഉപയോഗിക്കുന്ന ഡാറ്റാ തരത്തിന്റെ അനുവദനീയമായ മൂല്യങ്ങളുടെ പരിധിക്ക് പുറത്തുള്ള ഒരു സംഖ്യയായിരിക്കാം എന്ന ചെറിയ സംശയമോ നിർദ്ദേശമോ പോലും ഉണ്ടെങ്കിൽ, ഒരു വലിയ ഡാറ്റ തരം ഉപയോഗിക്കുക!