ഏറ്റവും കുറഞ്ഞ അളവിലുള്ള വിവരങ്ങൾ നഷ്ടപ്പെട്ട തരത്തിനാണ് ഏറ്റവും കൂടുതൽ മുൻഗണന നൽകുന്നത്. അപ്രതീക്ഷിതമായ വിവിധ സാഹചര്യങ്ങൾ ഉണ്ടാകാനിടയുള്ളതിനാൽ നിങ്ങൾ പരോക്ഷമായ തരത്തിലുള്ള പരിവർത്തനം അമിതമായി ഉപയോഗിക്കരുത്.

• വ്യക്തമായ പരിവർത്തനംപരോക്ഷമായതിൽ നിന്ന് വ്യത്യസ്തമായി, അത് പ്രോഗ്രാമർ നടപ്പിലാക്കുന്നു. ഈ പരിവർത്തനം ചെയ്യാൻ നിരവധി മാർഗങ്ങളുണ്ട്:

1. ശൈലികളിലേക്ക് പരിവർത്തനം ചെയ്യുന്നു സി: (ഫ്ലോട്ട്) a
2. ശൈലികളിലേക്ക് പരിവർത്തനം ചെയ്യുന്നു C++: ഫ്ലോട്ട് ()

ഇനിപ്പറയുന്ന പ്രവർത്തനങ്ങൾ ഉപയോഗിച്ച് ടൈപ്പ് കാസ്റ്റിംഗ് നടത്താനും കഴിയും:

സ്റ്റാറ്റിക്_കാസ്റ്റ്<>() const_cast<>() പുനർവ്യാഖ്യാനം_കാസ്റ്റ്<>() ഡൈനാമിക്_കാസ്റ്റ്<> ()

സ്റ്റാറ്റിക്_കാസ്- ബന്ധപ്പെട്ട ഡാറ്റ തരങ്ങൾ പരിവർത്തനം ചെയ്യുന്നു. ഈ ഓപ്പറേറ്റർ സാധാരണ നിയമങ്ങൾക്കനുസൃതമായി തരങ്ങൾ കാസ്റ്റുചെയ്യുന്നു, കംപൈലർ യാന്ത്രിക പരിവർത്തനം നടത്താത്തപ്പോൾ ഇത് ആവശ്യമായി വന്നേക്കാം. വാക്യഘടന ഇതുപോലെ കാണപ്പെടും:

static_cast എന്ന് ടൈപ്പ് ചെയ്യുക<Тип>(ഒരു വസ്തു);

സ്റ്റാറ്റിക്_കാസ്റ്റ് ഉപയോഗിച്ച്, നിങ്ങൾക്ക് ഒരു വേരിയബിളിൽ നിന്ന് സ്ഥിരത നീക്കംചെയ്യാൻ കഴിയില്ല, പക്ഷേ ഇനിപ്പറയുന്ന ഓപ്പറേറ്റർക്ക് അത് ചെയ്യാൻ കഴിയും. const_cast- ഒരു വസ്തുവിൽ നിന്ന് സ്ഥിരത നീക്കം ചെയ്യേണ്ടത് ആവശ്യമുള്ളപ്പോൾ മാത്രം ഉപയോഗിക്കുന്നു. വാക്യഘടന ഇതുപോലെ കാണപ്പെടും:

ടൈപ്പ് ചെയ്യുകconst_cast< ടൈപ്പ് ചെയ്യുക> (ഒരു വസ്തു);

പുനർവ്യാഖ്യാനം_കാസ്റ്റ്- വ്യത്യസ്ത തരങ്ങളെ പരിവർത്തനം ചെയ്യാൻ ഉപയോഗിക്കുന്നു, പൂർണ്ണസംഖ്യയെ പോയിൻ്ററിലേക്കും തിരിച്ചും. നിങ്ങൾ ഒരു പുതിയ വാക്ക് "സൂചിക" കാണുകയാണെങ്കിൽ - പരിഭ്രാന്തരാകരുത്! ഇതും ഒരു ഡാറ്റാ തരമാണ്, എന്നാൽ ഞങ്ങൾ ഇത് ഉടൻ പ്രവർത്തിക്കില്ല. ഇവിടെയുള്ള വാക്യഘടന മുമ്പ് ചർച്ച ചെയ്ത ഓപ്പറേറ്റർമാരുടേതിന് സമാനമാണ്:

ടൈപ്പ് ചെയ്യുകപുനർവ്യാഖ്യാനം ചെയ്യുക_കാസ്റ്റ്< ടൈപ്പ് ചെയ്യുക> (ഒരു വസ്തു);

ഡൈനാമിക്_കാസ്റ്റ്- ഡൈനാമിക് തരം പരിവർത്തനത്തിനായി ഉപയോഗിക്കുന്നു, പോയിൻ്റർ അല്ലെങ്കിൽ റഫറൻസ് കാസ്റ്റിംഗ് നടപ്പിലാക്കുന്നു. വാക്യഘടന:

ടൈപ്പ് ചെയ്യുകചലനാത്മകം _കാസ്റ്റ്< ടൈപ്പ് ചെയ്യുക> (ഒരു വസ്തു);

പ്രതീകങ്ങൾ നിയന്ത്രിക്കുക

ഈ "നിയന്ത്രണ പ്രതീകങ്ങളിൽ" ചിലത് നിങ്ങൾക്ക് ഇതിനകം പരിചിതമാണ് (ഉദാഹരണത്തിന്, കൂടെ \n). അവയെല്ലാം ഒരു ബാക്ക്‌സ്ലാഷിൽ ആരംഭിക്കുന്നു, കൂടാതെ ഇരട്ട ഉദ്ധരണികളാൽ ചുറ്റപ്പെട്ടവയുമാണ്.

സി ഭാഷയിലെ എല്ലാ ഡാറ്റയ്ക്കും അതിൻ്റേതായ തരമുണ്ട്. ചില തരം വേരിയബിളുകൾ മെമ്മറിയിൽ കുറച്ച് ഇടം പിടിക്കുന്നു, അത് തരം അനുസരിച്ച് വ്യത്യാസപ്പെടുന്നു. C യിൽ ചില തരം മെമ്മറിയുടെ അളവ് സംബന്ധിച്ച് വ്യക്തമായ അസൈൻമെൻ്റ് ഇല്ല. ഒരു നിർദ്ദിഷ്‌ട പ്ലാറ്റ്‌ഫോമിനായി ഒരു നിർദ്ദിഷ്‌ട കമ്പൈലർ നടപ്പിലാക്കുന്നതിന് ഇത് നൽകിയിരിക്കുന്നു. ഉദാഹരണത്തിന്, ഒരു വേരിയബിൾ പോലെ int ഒരു കംപൈലറിൽ ഇതിന് 16 ബിറ്റുകൾ മെമ്മറിയിൽ ഉൾക്കൊള്ളാൻ കഴിയും, മറ്റൊന്നിൽ - 32 ബിറ്റുകൾ, മൂന്നാമത്തേതിൽ - 8 ബിറ്റുകൾ. എല്ലാം നിർദ്ദിഷ്ട കംപൈലർ നിർണ്ണയിക്കുന്നു. ശരിയാണ്, എല്ലാവരും സാർവത്രികവൽക്കരണത്തിനായി പരിശ്രമിക്കുന്നു, അടിസ്ഥാനപരമായി മിക്ക കംപൈലറുകളിലും ഈ തരം int , ഉദാഹരണത്തിന്, 2 ബൈറ്റുകൾ എടുക്കുന്നു, കൂടാതെ തരം ചാർ - ഒന്ന്.

ഈയിടെയായി ഞാൻ അൽപ്പം മൂകനായിരുന്നു, ഒരു തരം എത്ര ബൈറ്റുകൾ എടുക്കുമെന്ന് എനിക്ക് ഓർമയില്ല ഇരട്ടി വി എവിആർ-ജിസിസി. സാധാരണഗതിയിൽ, കൺട്രോളറുകൾ പ്രോഗ്രാമിംഗ് ചെയ്യുമ്പോൾ, നിങ്ങൾ പൂർണ്ണസംഖ്യ തരങ്ങളുമായി പ്രവർത്തിക്കുന്നു int ഒപ്പം ചാർ , കൂടാതെ വിഭവ ഉപഭോഗം കാരണം നിങ്ങൾ പലപ്പോഴും ഫ്ലോട്ടിംഗ് പോയിൻ്റ് തരങ്ങൾ അവലംബിക്കാറില്ല.

അതിനാൽ, ഭാവിയിൽ, AVR-GCC കംപൈലറിനായുള്ള ഡാറ്റ തരങ്ങൾ ഉൾക്കൊള്ളുന്ന മെമ്മറിയുടെ വലുപ്പവും ഈ തരത്തിലുള്ള വേരിയബിളുകളിലെ മാറ്റങ്ങളുടെ ശ്രേണിയും സൂചിപ്പിക്കുന്ന ഒരു ഓർമ്മപ്പെടുത്തൽ ഞാൻ ഇവിടെ ഉപേക്ഷിക്കും.

AVR-GCC കംപൈലറിനായുള്ള സി ഭാഷയിലുള്ള ഡാറ്റ തരങ്ങൾ

കുറിപ്പ്

ടൈപ്പ് നടപ്പിലാക്കൽ ഇരട്ടി AVR-GCC നിലവാരത്തിൽ നിന്ന് വ്യതിചലിക്കുന്നു. സ്റ്റാൻഡേർഡ് അനുസരിച്ച് ഇരട്ടി 64 ബിറ്റുകൾ ഉൾക്കൊള്ളുന്നു. AVR-GCC-യിൽ, ഈ തരത്തിലുള്ള ഒരു വേരിയബിൾ 32 ബിറ്റുകൾ ഉൾക്കൊള്ളുന്നു, അതനുസരിച്ച്, ഇത് തരം ഉള്ള ഒരു വേരിയബിളിന് തുല്യമാണ്. ഫ്ലോട്ട്!

ഇതുകൂടാതെ, AVR-GCC ലൈബ്രറികൾ സ്റ്റാൻഡേർഡ് തരങ്ങളുടെ നിരവധി ഡെറിവേറ്റീവുകൾ അവതരിപ്പിക്കുന്നു. അവ ഫയലിൽ വിവരിച്ചിട്ടുണ്ട് stdint.h . വ്യക്തത മെച്ചപ്പെടുത്തുന്നതിനും പ്രോഗ്രാമുകളുടെ വാചകം കുറയ്ക്കുന്നതിനുമായി ഇത് ചെയ്തിരിക്കാം (അവരുടെ എഴുത്ത് വേഗത്തിലാക്കുക :)). അനുരൂപമായ പ്ലേറ്റ് ഇതാ:

AVR-GCC കംപൈലറിനായി C ഭാഷയിലെ സ്റ്റാൻഡേർഡ് തരങ്ങളിൽ നിന്ന് ഉരുത്തിരിഞ്ഞ തരങ്ങൾ

ശൂന്യമായ തരം

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

അവസാനം അപ്ഡേറ്റ് ചെയ്തത്: 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++ ൽ, ഭാഷയുടെ സ്രഷ്ടാവ് അത്തരം തരങ്ങളെ അടിസ്ഥാന തരങ്ങൾ എന്ന് വിളിക്കുന്നു. 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), || (ലോജിക്കൽ അല്ലെങ്കിൽ). ഓരോ പ്രവർത്തനത്തിൻ്റെയും ഫലം അനുബന്ധ സത്യ പട്ടികയിൽ കാണാം. ഉദാഹരണത്തിന്:

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 പോലെ തന്നെ;