ഗണിത പ്രവർത്തനങ്ങൾ. ലോജിക്കൽ പ്രവർത്തനങ്ങൾ

7.2 ഏകീകൃത പ്രവർത്തനങ്ങൾ

ഏകീകൃത ഓപ്പറേറ്റർമാരുമായുള്ള എക്സ്പ്രഷനുകൾ വലത്തേക്ക് ഗ്രൂപ്പുചെയ്‌തിരിക്കുന്നു:

unary_expression: unary_operation എക്സ്പ്രഷൻ എക്സ്പ്രഷൻ ++ എക്സ്പ്രഷൻ - സൈസ് ഓഫ് എക്സ്പ്രഷൻ സൈസ്ഓഫ് (type_name) (type_name) എക്സ്പ്രഷൻ simple_type_name (പ്രകടനങ്ങളുടെ ലിസ്റ്റ്) new type_name initializer ഓപ്റ്റ് പുതിയത് (type_name) ഡിലീറ്റ് എക്സ്പ്രഷൻ ഡിലീറ്റ് ചെയ്യുക [expression ] എക്സ്പ്രഷൻ unary_operation: ഒന്ന് * amp; – ! ~ ++ –

unary * ഓപ്പറേറ്റർ അർത്ഥമാക്കുന്നത് പരോക്ഷമാണ്: എക്സ്പ്രഷൻ ഒരു പോയിൻ്റർ ആയിരിക്കണം, ഫലം എക്സ്പ്രഷൻ ചൂണ്ടിക്കാണിക്കുന്ന ഒബ്ജക്റ്റിനെ സൂചിപ്പിക്കുന്ന ഒരു മൂല്യമായിരിക്കും. എക്സ്പ്രഷൻ "പോയിൻ്റർ ടു..." എന്ന തരത്തിലാണെങ്കിൽ, ഫലത്തിൻ്റെ തരം "..." ആണ്.

യുണറി ഓപ്പറേഷൻ്റെ ഫലം amp; ഓപ്പറാൻറ് പരാമർശിക്കുന്ന ഒബ്ജക്റ്റിലേക്കുള്ള ഒരു പോയിൻ്ററാണ്. ഓപ്പറാൻറ് മൂല്യമായിരിക്കണം. എക്സ്പ്രഷൻ "..." എന്ന തരത്തിലാണെങ്കിൽ, ഫല തരം "പോയിൻ്റർ ടു..." ആണ്.

സാധാരണ ഗണിത പരിവർത്തനങ്ങൾ നടത്തിയതിന് ശേഷമുള്ള അതിൻ്റെ ഓപ്പറണ്ടിൻ്റെ മൂല്യമാണ് unary operator + ൻ്റെ ഫലം. ഓപ്പറാൻറ് ഗണിത തരത്തിലുള്ളതായിരിക്കണം.

ഒരു ഏകീകൃത പ്രവർത്തനത്തിൻ്റെ ഫലം അതിൻ്റെ പ്രവർത്തനത്തിൻ്റെ നെഗറ്റീവ് മൂല്യമാണ്. ഓപ്പറണ്ടിൽ ഉണ്ടായിരിക്കണം മുഴുവൻ തരം. സാധാരണ ഗണിത പരിവർത്തനങ്ങൾ നടത്തുന്നു. സൈൻ ചെയ്യാത്ത മൂല്യത്തിൻ്റെ നെഗറ്റീവ് മൂല്യം അതിൻ്റെ മൂല്യം 2n-ൽ നിന്ന് കുറച്ചാണ് കണക്കാക്കുന്നത്, ഇവിടെ n എന്നത് ഇൻ്റിലെ ബിറ്റുകളുടെ എണ്ണമാണ്.

ഒരു ലോജിക്കൽ നിഷേധ പ്രവർത്തനത്തിൻ്റെ ഫലം! ഓപ്പറാൻറ് മൂല്യം 0 ആണെങ്കിൽ 1 ആണ്, കൂടാതെ 0 അല്ലെങ്കിൽ 0 ആണ്. ഫലം int തരം. ഏതെങ്കിലും ഗണിത തരം അല്ലെങ്കിൽ പോയിൻ്ററുകൾക്ക് ബാധകമാണ്.

~ ഓപ്പറേഷൻ ഒന്നിന് ഓപ്പറാൻറ് മൂല്യത്തിൻ്റെ പൂരകം നൽകുന്നു. സാധാരണ ഗണിത പരിവർത്തനങ്ങൾ നടത്തുന്നു. ഓപ്പറാൻറ് ഒരു പൂർണ്ണസംഖ്യയായിരിക്കണം.

C++ പുസ്തകത്തിൽ നിന്ന് ഹിൽ മുറെ എഴുതിയത്

6.2.1 ബൈനറി, യൂണറി ഓപ്പറേഷനുകൾ ഒരു ബൈനറി ഓപ്പറേഷനെ ഒരു അംഗ ഫംഗ്ഷൻ അല്ലെങ്കിൽ രണ്ട് പാരാമീറ്ററുകൾ എടുക്കുന്ന ഒരു ഫ്രണ്ട് ഫംഗ്ഷൻ എന്ന് നിർവചിക്കാം. അതിനാൽ, ഏതൊരു ബൈനറി പ്രവർത്തനത്തിനും, @ aa@bb എന്നത് ഒന്നുകിൽ aa.operator@(bb) അല്ലെങ്കിൽ

വികസന പ്രക്രിയ മെച്യൂരിറ്റി മോഡൽ എന്ന പുസ്തകത്തിൽ നിന്ന് സോഫ്റ്റ്വെയർ പോൾക്ക് മാർക്ക്

7.2 Unary ഓപ്പറേറ്റർമാരുമൊത്തുള്ള എക്സ്പ്രഷനുകൾ വലത് വശത്ത് തരംതിരിച്ചിരിക്കുന്നു: unary_expression: unary_operation എക്സ്പ്രഷൻ എക്സ്പ്രഷൻ ++ എക്സ്പ്രഷൻ - സൈസ് ഓഫ് എക്സ്പ്രഷൻ സൈസ്ഓഫ് (type_name) (type_name) എക്സ്പ്രഷൻ simple_type_name (പദപ്രയോഗങ്ങളുടെ പട്ടിക) പുതിയ ടൈപ്പ്_നെയിം ഇനീഷ്യലൈസർ ഓപ്റ്റ് പുതിയത് (

ഡാറ്റാബേസുകൾ: പ്രഭാഷണ കുറിപ്പുകൾ എന്ന പുസ്തകത്തിൽ നിന്ന് രചയിതാവ് രചയിതാവ് അജ്ഞാതൻ

പ്രവർത്തനങ്ങൾ മാനസികമോ ശാരീരികമോ ആയ നിർവ്വഹണത്തിന് ഒരു നിർദ്ദിഷ്ട ഉദ്ദേശ്യമുള്ള ഏതെങ്കിലും ഘട്ടമോ പ്രവർത്തനമോ ആണ് ഓപ്പറേഷൻ. പ്രോജക്റ്റ് ലക്ഷ്യങ്ങൾ നിറവേറ്റുന്നതിനായി മാനേജ്മെൻ്റിൻ്റെയും സാങ്കേതിക ഉദ്യോഗസ്ഥരുടെയും എല്ലാ പ്രവർത്തനങ്ങളും പ്രവർത്തനങ്ങളിൽ ഉൾപ്പെടുന്നു

പുസ്തകത്തിൽ നിന്ന് സഹായ ഗൈഡ് C++ ൽ രചയിതാവ് Stroustrap Bjarne

പ്രഭാഷണ നമ്പർ 4. റിലേഷണൽ ബീജഗണിതം. ഏകീകൃത പ്രവർത്തനങ്ങൾ റിലേഷണൽ ബീജഗണിതം, നിങ്ങൾ ഊഹിച്ചേക്കാവുന്നതുപോലെ, എല്ലാ പ്രവർത്തനങ്ങളും നടത്തുന്ന ഒരു പ്രത്യേക തരം ബീജഗണിതമാണ് ബന്ധപ്പെട്ട മോഡലുകൾഡാറ്റ, അതായത് ഓവർ ബന്ധങ്ങൾ. പട്ടികയിൽ, ഒരു ബന്ധത്തിൽ ഉൾപ്പെടുന്നു

C# 2005 പ്രോഗ്രാമിംഗ് ലാംഗ്വേജ് എന്ന പുസ്തകത്തിൽ നിന്നും .NET 2.0 പ്ലാറ്റ്‌ഫോമിൽ നിന്നും. Troelsen ആൻഡ്രൂ എഴുതിയത്

2. ഭാഷയിലെ ഏകീകൃത പ്രവർത്തനങ്ങൾ ഘടനാപരമായ ചോദ്യങ്ങൾഈ വിഭാഗത്തിൽ ഘടനാപരമായ അന്വേഷണ ഭാഷ ഉപയോഗിച്ച് എങ്ങനെ നടപ്പിലാക്കാം എന്ന് നോക്കാം ഓപ്പറേറ്ററെ തിരഞ്ഞെടുക്കുകതിരഞ്ഞെടുക്കൽ, പ്രൊജക്ഷൻ, പുനർനാമകരണം എന്നിവയുടെ അനിയന്ത്രിതമായ പ്രവർത്തനങ്ങൾ ഞങ്ങൾക്ക് ഇതിനകം പരിചിതമാണ്.

AS/400 അടിസ്ഥാനങ്ങൾ എന്ന പുസ്തകത്തിൽ നിന്ന് സോൾട്ടിസ് ഫ്രാങ്ക്

R.5.3 Unary operators ഉള്ള എക്സ്പ്രഷനുകൾ വലത്തു നിന്ന് ഇടത്തോട്ട് എക്സിക്യൂട്ട് ചെയ്യുന്നു unary-expression: postfix-expression ++ unary express -- unary express unary-operation cast-expression sizeof unary-operation sizeof

Windows 2000/XP-നുള്ള Windows Script Host എന്ന പുസ്തകത്തിൽ നിന്ന് രചയിതാവ് പോപോവ് ആൻഡ്രി വ്ലാഡിമിറോവിച്ച്

R.13.4.1 Unary operators ഒരു പ്രിഫിക്‌സ് unary ഓപ്പറേറ്ററെ ഒരു നോൺ-സ്റ്റാറ്റിക് അംഗം ഫംഗ്‌ഷൻ (§R.9.3), പാരാമീറ്ററുകൾ ഇല്ലാതെ അല്ലെങ്കിൽ ഒരു പാരാമീറ്ററുള്ള ഒരു നോൺ-മെമ്പർ ഫംഗ്‌ഷൻ വഴി വ്യക്തമാക്കാൻ കഴിയും. അതിനാൽ, ഏതെങ്കിലും പ്രിഫിക്‌സ് യൂണറി ഓപ്പറേഷനും @x എന്ന പദപ്രയോഗത്തിന് കഴിയും

ആപ്ലിക്കേഷൻ വികസനം എന്ന പുസ്തകത്തിൽ നിന്ന് ലിനക്സ് പരിസ്ഥിതി. രണ്ടാം പതിപ്പ് രചയിതാവ് ജോൺസൺ മൈക്കിൾ കെ.

+=, -= ഓപ്പറേറ്റർമാർ മുമ്പത്തെ C++ അനുഭവം ഉപയോഗിച്ച് നിങ്ങൾ C# പഠിക്കുകയാണെങ്കിൽ, ഒരു അസൈൻമെൻ്റ് ഓപ്പറേറ്റർ (+=, -=, മുതലായവ) ഉൾപ്പെടുന്ന ഓപ്പറേറ്റർ ചുരുക്കങ്ങൾ ഓവർലോഡ് ചെയ്യാൻ കഴിയില്ലെന്ന് നിങ്ങൾ ശ്രദ്ധിച്ചേക്കാം. വിഷമിക്കേണ്ട, C#-ൽ അസൈൻമെൻ്റ് ഓപ്പറേറ്റർ കുറുക്കുവഴികൾ

സി പ്രോഗ്രാമിംഗ് ലാംഗ്വേജ് എന്ന പുസ്തകത്തിൽ നിന്ന് പെഴ്സണൽ കമ്പ്യൂട്ടർ രചയിതാവ് ബോച്ച്കോവ് എസ്.ഒ.

MI ഓപ്‌കോഡ് പട്ടിക 4.14 MI ഓപ്‌കോഡ് ബിറ്റുകളുടെ അസൈൻമെൻ്റ് കാണിക്കുന്നു. കമാൻഡിൻ്റെ കമ്പ്യൂട്ടേഷണൽ അല്ലെങ്കിൽ നോൺ-കമ്പ്യൂട്ടേഷണൽ ഫോർമാറ്റ് ബിറ്റ് 3 വ്യക്തമാക്കുന്നു. രണ്ടാമത്തെ സാഹചര്യത്തിൽ, ഓപ്‌കോഡിൻ്റെ 5-15 ബിറ്റുകളിൽ നിർവ്വഹിക്കേണ്ട പ്രവർത്തനം എൻകോഡ് ചെയ്‌തിരിക്കുന്നു. കമ്പ്യൂട്ടിംഗ് നിർവ്വഹിക്കുന്ന പ്രവർത്തനം

ദി സി ലാംഗ്വേജ് - തുടക്കക്കാർക്കുള്ള ഒരു ഗൈഡ് എന്ന പുസ്തകത്തിൽ നിന്ന് പ്രാത സ്റ്റീവൻ എഴുതിയത്

യൂണറി ഓപ്പറേറ്റർമാർ ഒരു ഓപ്പറണ്ടിന് ബാധകമാകുന്ന ഓപ്പറേറ്റർമാരാണ് യുണറി ഓപ്പറേറ്റർമാർ (പട്ടിക A1.3) പട്ടിക A1.3. Unary operators ഓപ്പറേറ്റർ വിവരണം - വിപരീത ചിഹ്നം! കൂട്ടിച്ചേർക്കൽ. ഒരു ബൂളിയൻ വേരിയബിളിൻ്റെ മൂല്യം മാറ്റാൻ ഉപയോഗിക്കുന്നു

തുടക്കക്കാർക്കുള്ള C++ പുസ്തകത്തിൽ നിന്ന് ലിപ്മാൻ സ്റ്റാൻലി എഴുതിയത്

16.1 Tty ഓപ്പറേഷൻസ് Tty ഉപകരണങ്ങൾ ധാരാളം ഡാറ്റ പ്രോസസ്സിംഗ് ഓപ്ഷനുകൾ നൽകുന്നു; അവ ഏറ്റവും സങ്കീർണ്ണമായ കേർണൽ ഉപകരണങ്ങളിൽ ഒന്നാണ്. ഇൻപുട്ട്, ഔട്ട്പുട്ട് ഡാറ്റ, ഡാറ്റാ ഫ്ലോ എന്നിവ പ്രോസസ്സ് ചെയ്യുന്നതിനുള്ള ഓപ്ഷനുകൾ നിങ്ങൾക്ക് ക്രമീകരിക്കാൻ കഴിയും. പരിമിതമായ നിയന്ത്രണവും സാധ്യമാണ്

PascalABC.NET ഭാഷയുടെ വിവരണം എന്ന പുസ്തകത്തിൽ നിന്ന് രചയിതാവ് റൂബോർഡ് ടീം

യുണറി ഓപ്പറേറ്റർമാർ യുണറി മൈനസ് (-) യുണറി മൈനസ് ഓപ്പറേറ്റർ അതിൻ്റെ ഓപ്പറണ്ടിൻ്റെ ഗണിത നിഷേധം നടത്തുന്നു. ഓപ്പറാൻറ് ഒരു പൂർണ്ണസംഖ്യയോ ഫ്ലോട്ടിംഗ് മൂല്യമോ ആയിരിക്കണം. ഡിഫോൾട്ട് ഓപ്പറാൻറ് പരിവർത്തനങ്ങൾ നടത്തുന്നു. പരിവർത്തനം ചെയ്ത തരത്തിന് തുല്യമാണ് ഫല തരം

രചയിതാവിൻ്റെ പുസ്തകത്തിൽ നിന്ന്

പ്രവർത്തനങ്ങൾ സി ഭാഷ ബിറ്റ്വൈസ് ലോജിക്കൽ ഓപ്പറേഷനുകളും ഷിഫ്റ്റ് ഓപ്പറേഷനുകളും നൽകുന്നു. അടുത്തതായി, ഞങ്ങൾ മൂല്യങ്ങൾ ബൈനറിയിൽ എഴുതും, അതിനാൽ പ്രവർത്തനങ്ങൾ എങ്ങനെ നടത്തുന്നുവെന്ന് നിങ്ങൾക്ക് കാണാൻ കഴിയും. IN യഥാർത്ഥ പ്രോഗ്രാമുകൾപൂർണ്ണസംഖ്യ വേരിയബിളുകൾ അല്ലെങ്കിൽ സ്ഥിരാങ്കങ്ങൾ എഴുതിയിരിക്കുന്നു

രചയിതാവിൻ്റെ പുസ്തകത്തിൽ നിന്ന്

ഓപ്പറേഷനുകൾ ഇപ്പോൾ enum മൂല്യങ്ങൾ ഉപയോഗിച്ച് നിങ്ങൾക്ക് ചെയ്യാൻ കഴിയുന്നതും ചെയ്യാൻ കഴിയാത്തതും നോക്കാം. enum ടൈപ്പുചെയ്യാൻ നിങ്ങൾക്ക് ഒരു സ്ഥിരാങ്കം നൽകാം വേരിയബിൾ അത്ഒരേ തരത്തിലുള്ള enum feline pet;പെറ്റ് = കടുവ;നിങ്ങൾക്ക് മറ്റ് അസൈൻമെൻ്റ് പ്രവർത്തനങ്ങൾ ഉപയോഗിക്കാൻ കഴിയില്ല: pet += cat; /* അസാധുവായ */ തിരിച്ചറിയാൻ താരതമ്യം ചെയ്യാം

രചയിതാവിൻ്റെ പുസ്തകത്തിൽ നിന്ന്

4.3 താരതമ്യവും ലോജിക്കൽ പ്രവർത്തനങ്ങളും ഓപ്പറേഷൻ ചിഹ്നത്തിൻ്റെ അർത്ഥം ഉപയോഗിക്കുക! ലോജിക്കൽ അല്ല!expr exprexpr-നേക്കാൾ കുറവ് = expr-നേക്കാൾ കുറവ് അല്ലെങ്കിൽ തുല്യം = exprexpr-നേക്കാൾ വലുത് = expr-നേക്കാൾ വലുതോ തുല്യമോ = expr = expr == exr-നേക്കാൾ വലുതോ തുല്യമോ == expr ==expr != expr-ന് തുല്യമല്ല!=expr ലോജിക്കൽ

രചയിതാവിൻ്റെ പുസ്തകത്തിൽ നിന്ന്

ഒരു ക്ലാസ് വേരിയബിളിന് വ്യക്തമാക്കിയിട്ടുണ്ടോ എന്ന് പരിശോധിക്കാൻ The is ഓപ്പറേഷൻ ഉപയോഗിക്കുന്നു ചലനാത്മക തരം. ഒരു ക്ലാസ് തരത്തിൽ നിന്ന് മറ്റൊരു ക്ലാസ് തരത്തിലേക്ക് ഒരു വേരിയബിളിനെ സുരക്ഷിതമായി പരിവർത്തനം ചെയ്യാൻ ആസ് ഓപ്പറേറ്റർ നിങ്ങളെ അനുവദിക്കുന്നു (വ്യക്തമായ ക്ലാസ് കാസ്റ്റിൽ നിന്ന് വ്യത്യസ്തമായി).

പ്രവർത്തനങ്ങളിൽ നിന്നും പ്രവർത്തനങ്ങളിൽ നിന്നും, ഒരു മൂല്യം ലഭിക്കുന്നതിന് ഉപയോഗിക്കുന്ന എക്സ്പ്രഷൻ ഓപ്പറേറ്ററുകൾ നിർമ്മിക്കപ്പെടുന്നു. അടിസ്ഥാന പ്രവർത്തനങ്ങൾ നോക്കാം, ഞങ്ങൾ ഇനിപ്പറയുന്ന ക്ലാസുകളായി വിഭജിക്കും: unary, ഒരു ഓപ്പറണ്ടിൽ പ്രയോഗിക്കുന്നു; ബൈനറി, രണ്ട് ഓപ്പറണ്ടുകളിൽ പ്രയോഗിക്കുന്നു; ടെർനറി ഓപ്പറേറ്റർ (ഒറ്റ), മൂന്ന് ഓപ്പറണ്ടുകളിൽ പ്രയോഗിക്കുന്നു. ചില പ്രവർത്തനങ്ങൾ ലിസ്റ്റുചെയ്യുകയും പിന്നീട് കൂടുതൽ വിശദമായി ചർച്ച ചെയ്യുകയും ചെയ്യും.

ഏകീകൃത പ്രവർത്തനങ്ങൾ:

«-» ഗണിത ഓപ്പറണ്ടുകളിൽ (പൂർണ്ണസംഖ്യകൾ, യഥാർത്ഥ വേരിയബിളുകൾ അല്ലെങ്കിൽ സ്ഥിരാങ്കങ്ങൾ) "unary മൈനസ്" പ്രയോഗിക്കുന്നു, പ്രവർത്തനത്തിൻ്റെ ഫലം വിപരീത ചിഹ്നമുള്ള ഓപ്പറണ്ടിൻ്റെ മൂല്യമാണ്;

«+» - "unary plus" പ്രവർത്തനം ഒന്നും ചെയ്യുന്നില്ല, "unary minus" പ്രവർത്തനവുമായി സമമിതിക്കായി അവതരിപ്പിച്ചു;

«*» - "വിലാസത്തിലേക്കുള്ള ആക്സസ്", പ്രവർത്തനം പോയിൻ്ററുകളിലേക്ക് പ്രയോഗിക്കുന്നു, പ്രവർത്തനത്തിൻ്റെ ഫലം പോയിൻ്റർ പോയിൻ്റ് ചെയ്യുന്ന ഒബ്ജക്റ്റിൻ്റെ (ഓപ്പറാൻഡിൻ്റെ) മൂല്യമാണ്;

«&» - "ഒരു വിലാസം ലഭിക്കുന്നു", പ്രവർത്തനത്തിൻ്റെ ഫലം വസ്തുവിൻ്റെ വിലാസമാണ് (വേരിയബിൾ);

«~» - "ബിറ്റ്‌വൈസ് നെഗേഷൻ" ഓപ്പറേഷൻ ഇൻ്റിജർ ഓപ്പറണ്ടുകൾക്ക് മാത്രമേ ബാധകമാകൂ, ഓപ്പറേഷൻ്റെ ഫലം യഥാർത്ഥ ഓപ്പറണ്ടിൻ്റെ ബിറ്റുകൾ വിപരീതമാക്കപ്പെടുന്ന ഒരു പൂർണ്ണ മൂല്യമാണ്;

«!» - "ലോജിക്കൽ നിഷേധം" ("ലോജിക്കൽ NOT"), ഓപ്പറാൻറ് ശരിയാണെങ്കിൽ (പൂജ്യം അല്ല) മൂല്യം 0-ലും ഓപ്പറാൻറ് പൂജ്യമാണെങ്കിൽ മൂല്യം 1-ലും (വിഷ്വൽ C++ ഫലത്തിൻ്റെ തരം ബൂൾ ആണ്), അത് ആയിരിക്കണം അടിസ്ഥാന ANSI സ്റ്റാൻഡേർഡിൽ C കാണുന്നില്ല വ്യക്തമായി 2 മൂല്യങ്ങൾ എടുക്കുന്ന ഒരു ലോജിക്കൽ തരം: "ശരി", "തെറ്റ്", പകരം ബൂളിയൻ തരംചട്ടം പോലെ, ഒരു പൂർണ്ണസംഖ്യ തരം ഉപയോഗിച്ചു, മൂല്യം 0 "തെറ്റ്" ആയി വ്യാഖ്യാനിക്കപ്പെട്ടു, 0 ഒഴികെയുള്ള ഏതൊരു മൂല്യവും "ശരി" ആയിരുന്നു;

(<тип>) - "തരം പരിവർത്തന പ്രവർത്തനം" നേരത്തെ ചർച്ച ചെയ്തു;

"വലിപ്പം"- സൈസിംഗ് ഓപ്പറേഷൻ രൂപകൽപ്പന ചെയ്തിരിക്കുന്നത് ഒരു ഒബ്‌ജക്റ്റിൻ്റെ വലുപ്പം അല്ലെങ്കിൽ ബൈറ്റുകളിൽ തരം കണക്കാക്കുന്നതിനാണ്, കൂടാതെ രണ്ട് രൂപങ്ങളുണ്ട്:

ആവിഷ്കാരത്തിൻ്റെ വലിപ്പംഅഥവാ വലിപ്പം (എക്സ്പ്രഷൻ)

വലിപ്പം(തരം)

ഇൻക്രിമെൻ്റ് (1 കൊണ്ട് വർദ്ധിപ്പിക്കുക), -- - ഡിക്രിമെൻ്റ് (1 കൊണ്ട് കുറയുക), രണ്ട് രൂപത്തിലുള്ള നൊട്ടേഷൻ ഉണ്ട് - പ്രിഫിക്സ്, ഓപ്പറണ്ടിന് മുമ്പ് ഓപ്പറേഷൻ എഴുതുമ്പോൾ, പോസ്റ്റ്ഫിക്സ്. ഓപ്പറേറ്റർമാർ സ്വന്തമായി ഉപയോഗിക്കുകയാണെങ്കിൽ (ഓരോ ഓപ്പറേറ്റർക്കും ഒരു ഓപ്പറേറ്റർ മാത്രമേ ഉള്ളൂ), അപ്പോൾ രണ്ട് ഫോമുകൾ തമ്മിൽ വ്യത്യാസമില്ല. മറ്റ് ഓപ്പറേറ്റർമാരുമായി ഒരു എക്‌സ്‌പ്രഷനിൽ ഒരു ഓപ്പറേഷൻ ഉപയോഗിക്കുകയാണെങ്കിൽ, പ്രിഫിക്‌സ് ഫോമിൽ ആദ്യം ഓപ്പറാൻറ് മാറ്റുകയും അതിൻ്റെ പുതിയ മൂല്യം എക്‌സ്‌പ്രഷനിലേക്ക് മാറ്റി സ്ഥാപിക്കുകയും പോസ്റ്റ്ഫിക്‌സ് ഫോമിൽ പഴയ മൂല്യം എക്‌സ്‌പ്രഷനിലേക്കും പിന്നീട് മൂല്യത്തിലേക്കും മാറ്റിസ്ഥാപിക്കുന്നു. പ്രവർത്തനരീതി മാറ്റി. ഉദാഹരണത്തിന്,

int i=10, j;

j=++i; // പ്രിഫിക്സ് ഫോംപ്രവർത്തനങ്ങൾ

ഈ ശകലം നടപ്പിലാക്കിയതിൻ്റെ ഫലമായി, ഐഒപ്പം ജെ 11 ന് തുല്യമായിരിക്കും (വേരിയബിൾ j ന് i യുടെ പുതിയ മൂല്യം നൽകിയിരിക്കുന്നു, 1 കൊണ്ട് വർദ്ധിപ്പിക്കുന്നു), നമ്മൾ ++ പ്രവർത്തനത്തിൻ്റെ രൂപം മാറ്റുകയാണെങ്കിൽ:

int i=10, j;

j=i++; // ഓപ്പറേഷൻ്റെ പോസ്റ്റ്ഫിക്സ് ഫോം

തുടർന്ന്, നടപ്പിലാക്കിയ ശേഷം ഐ 11 ന് തുല്യമായിരിക്കും, ഒപ്പം ജെ 10-ന് തുല്യമായിരിക്കും, വേരിയബിൾ ജെപഴയ മൂല്യം വേരിയബിളിന് നൽകിയിരിക്കുന്നു ഐ, തുടർന്ന് അത് 1 കൊണ്ട് വർദ്ധിപ്പിക്കുന്നു. പ്രവർത്തനങ്ങൾ മിക്കപ്പോഴും പൂർണ്ണസംഖ്യാ ഓപ്പറണ്ടുകളിൽ പ്രയോഗിക്കുന്നു, എന്നാൽ അവ യഥാർത്ഥ ഓപ്പറണ്ടുകളിലും പോയിൻ്ററുകളിലും പോലും പ്രയോഗിക്കാവുന്നതാണ്.

ബൈനറി പ്രവർത്തനങ്ങളെ ഇനിപ്പറയുന്ന ക്ലാസുകളായി തിരിക്കാം:

കണക്ക്:

«+» - ബൈനറി പ്ലസ്;

«-» - ബൈനറി മൈനസ്;

«*» - ഗുണനം;

«/» - ഡിവിഷൻ;

% - ഡിവിഷൻ്റെ ശേഷിക്കുന്ന ഭാഗം നേടുന്നു.

ആദ്യത്തെ നാല് പ്രവർത്തനങ്ങൾ ഗണിത ഓപ്പറണ്ടുകൾക്ക് ബാധകമാണ്: പൂർണ്ണസംഖ്യ അല്ലെങ്കിൽ യഥാർത്ഥ, പ്രവർത്തനങ്ങൾ «+» ഒപ്പം «-» പരിമിതമായ രീതിയിൽപോയിൻ്ററുകളിൽ പ്രയോഗിക്കാൻ കഴിയും. ഓപ്പറേഷൻ - «%» പൂർണ്ണസംഖ്യ ഓപ്പറണ്ടുകൾക്ക് മാത്രം ബാധകമാണ്.

ബ്രെയിൻ ടീസർ:

«&&» - ലോജിക്കൽ AND;

«||» - ലോജിക്കൽ അല്ലെങ്കിൽ;

«^» - ലോജിക്കൽ എക്സ്ക്ലൂസീവ് അല്ലെങ്കിൽ.

ലോജിക്കൽ പ്രവർത്തനങ്ങളുടെ ഓപ്പറണ്ടുകൾ ഗണിത തരം അല്ലെങ്കിൽ പോയിൻ്ററുകൾ ആകാം, കൂടാതെ ഓരോ പ്രവർത്തനത്തിലെയും ഓപ്പറണ്ടുകൾ വിവിധ തരം. തരം പരിവർത്തനങ്ങളൊന്നും നടത്തുന്നില്ല, ഓരോ ഓപ്പറണ്ടും പൂജ്യത്തിന് തുല്യമായതിൻ്റെ അടിസ്ഥാനത്തിൽ വിലയിരുത്തപ്പെടുന്നു (ഓപ്പറാൻറ്, പൂജ്യത്തിന് തുല്യം, "തെറ്റ്" ആയി കണക്കാക്കപ്പെടുന്നു, പൂജ്യത്തിന് തുല്യമല്ല - "സത്യം"). വിഷ്വൽ സി++ ൽ ഫല തരം intഅഥവാ ബൂൾഓപ്പറണ്ടുകളുടെ തരങ്ങളെ ആശ്രയിച്ച്.

ബിറ്റ്വൈസ്:

«&» - ബിറ്റ്വൈസ് ആൻഡ്;

«|» - ബിറ്റ്വൈസ് അല്ലെങ്കിൽ;

«^» - ബിറ്റ്വൈസ് എക്സ്ക്ലൂസീവ് അല്ലെങ്കിൽ;

«>>» - ബിറ്റ്വൈസ് വലത്തേക്ക് മാറ്റുക;

«<<» - ബിറ്റ്വൈസ് ഇടത്തേക്ക് മാറ്റുക.

ഈ പ്രവർത്തനങ്ങൾ പൂർണ്ണസംഖ്യാ ഓപ്പറണ്ടുകൾക്ക് മാത്രം ബാധകമാണ് കൂടാതെ അവയുടെ ബൈനറി പ്രാതിനിധ്യങ്ങളിൽ പ്രവർത്തിക്കുന്നു. പ്രവർത്തനങ്ങൾ നടത്തുമ്പോൾ «&», «|», «^» ഓപ്പറാൻഡുകൾ ബിറ്റ്വൈസായി മാപ്പ് ചെയ്തിരിക്കുന്നു (ആദ്യ ഓപ്പറണ്ടിൻ്റെ ആദ്യ ബിറ്റ് രണ്ടാമത്തേതിൻ്റെ ആദ്യ ബിറ്റിലേക്ക്, ആദ്യത്തെ ഓപ്പറണ്ടിൻ്റെ രണ്ടാമത്തെ ബിറ്റ് രണ്ടാമത്തേതിൻ്റെ രണ്ടാമത്തെ ബിറ്റിലേക്ക് മുതലായവ).

ഷിഫ്റ്റ് പ്രവർത്തനങ്ങൾ ആദ്യ ഓപ്പറണ്ടിൻ്റെ ബൈനറി പ്രാതിനിധ്യത്തെ രണ്ടാമത്തെ ഓപ്പറാൻറ് വ്യക്തമാക്കിയ ബൈനറി അക്കങ്ങളുടെ എണ്ണം കൊണ്ട് ഇടത്തോട്ടോ വലത്തോട്ടോ മാറ്റുന്നു. ഇടത്തേക്ക് മാറുമ്പോൾ «<<» ഒഴിഞ്ഞ അക്കങ്ങൾ പൂജ്യത്തിലേക്ക് പുനഃസജ്ജീകരിച്ചിരിക്കുന്നു. വലത്തേക്ക് മാറുമ്പോൾ «>>» ആദ്യത്തെ ഓപ്പറാൻറ് ഒപ്പിട്ടിട്ടില്ലെങ്കിൽ ഫ്രീഡ് ബിറ്റുകൾ പൂജ്യങ്ങളാലും അല്ലെങ്കിൽ ഒരു സൈൻ ചെയ്ത ബിറ്റിലും നിറയും.

ബന്ധങ്ങൾ (താരതമ്യങ്ങൾ):

“==” - തുല്യം (അസൈൻമെൻ്റ് ഓപ്പറേറ്ററുമായി തെറ്റിദ്ധരിക്കേണ്ടതില്ല);

“!=” - തുല്യമല്ല;

">" - കൂടുതൽ;

«<» - меньше;

“>=” - അതിലും വലുതോ തുല്യമോ;

«<=» - меньше или равно.

റിലേഷണൽ ഓപ്പറേറ്റർമാർ ആദ്യ പ്രവർത്തനത്തെ രണ്ടാമത്തേതുമായി താരതമ്യം ചെയ്യുന്നു. ഓപ്പറണ്ടുകൾ ഗണിത തരം അല്ലെങ്കിൽ പോയിൻ്ററുകൾ ആകാം. പ്രവർത്തനത്തിൻ്റെ ഫലം "ശരി" (ഏതെങ്കിലും മൂല്യം 0 ന് തുല്യമല്ല, സാധാരണയായി 1) അല്ലെങ്കിൽ "തെറ്റ്" (0) ആണ്. വിഷ്വൽ സി++ ൽ ഫല തരം ബൂൾ.

അസൈൻമെൻ്റുകൾ:

"=" ഒരു ലളിതമായ അസൈൻമെൻ്റ് ആണ്.

ആദ്യത്തെ ഓപ്പറണ്ട് ഒരു എൽ-മൂല്യം ആയിരിക്കണം; പ്രവർത്തനത്തിൻ്റെ ഫലം സംഭരിക്കപ്പെടുന്ന മെമ്മറി ഏരിയ. രണ്ടാമത്തേത് - എക്സ്പ്രഷൻ വഴി. ആദ്യം, ഓപ്പറേഷൻ്റെ വലതുവശത്തുള്ള പദപ്രയോഗം കണക്കാക്കുന്നു, തുടർന്ന് അതിൻ്റെ ഫലം ഇടതുവശത്ത് സൂചിപ്പിച്ചിരിക്കുന്ന മെമ്മറി ഏരിയയിലേക്ക് എഴുതുന്നു. വിളിക്കപ്പെടുന്ന , എൽ-മൂല്യം(ഇടത്-സാധുവായ മൂല്യം, അസൈൻമെൻ്റ് പ്രവർത്തനത്തിൻ്റെ ഇടതുവശത്ത് ഉപയോഗിക്കാം), ഇത് ഒരു മൂല്യം സംഭരിക്കാൻ കഴിയുന്ന ഒരു നിശ്ചിത മെമ്മറി ഏരിയയെ അഭിസംബോധന ചെയ്യുന്ന ഏതൊരു പദപ്രയോഗത്തിൻ്റെയും പദവിയാണ്.

op= (ഇവിടെ op ഒരു ബൈനറി പ്രവർത്തനത്തിൻ്റെ പ്രതീകമാണ്) ഒരു സംയോജിത അസൈൻമെൻ്റ് ആണ്, ഒരു അസൈൻമെൻ്റ് ഓപ്പറേഷനുള്ള ഒരു ബൈനറി പ്രവർത്തനത്തിൻ്റെ സംയോജനമാണ്, ഉദാഹരണത്തിന്, "+=" എന്നത് സങ്കലനത്തോടുകൂടിയ ഒരു അസൈൻമെൻ്റാണ്, സാമ്യമനുസരിച്ച് പ്രവർത്തനങ്ങളുണ്ട്: "* =", "/=", "-= ", "%=", "&=", "|=", "^=", മുതലായവ. സംയോജിത പ്രവർത്തനങ്ങൾ ഇനിപ്പറയുന്ന നിയമം അനുസരിച്ച് പ്രവർത്തിക്കുന്നു:

i+=10; അതുപോലെ i=i+10;

മറ്റ് ബൈനറി പ്രവർത്തനങ്ങൾ, നമുക്ക് അവയെ പട്ടികപ്പെടുത്താം:

() - ഫംഗ്ഷൻ കോൾ;

- ഒരു അറേ ഘടകത്തിലേക്കുള്ള പ്രവേശനം;

"." ("ഡോട്ട്") - ഒരു ഘടന തരത്തിൻ്റെ വേരിയബിളിൻ്റെ ഒരു ഫീൽഡിലേക്കുള്ള പ്രവേശനം;

“->” - ഒരു പോയിൻ്റർ വഴി ഒരു ഘടനാ തരത്തിൻ്റെ വേരിയബിളിൻ്റെ ഒരു ഫീൽഡിലേക്കുള്ള ആക്സസ്;

"," ("കോമ") - തുടർച്ചയായ കണക്കുകൂട്ടൽ, എക്സ്പ്രഷനുകൾക്കിടയിൽ സ്ഥാപിക്കാം, എക്സ്പ്രഷനുകൾ തുടർച്ചയായി കണക്കാക്കുന്നു, പ്രവർത്തനത്തിൻ്റെ ഫലം രണ്ടാമത്തെ ഓപ്പറണ്ടിൻ്റെ (എക്സ്പ്രഷൻ) ഫലമാണ്.

ത്രിതല പ്രവർത്തനം:

“?:” എന്നത് ഒരു സോപാധിക പ്രവർത്തനമാണ്.

ഫോർമാറ്റ്:<операнд1> ? <операнд2> : <операнд3>

ആദ്യത്തെ ഓപ്പറാൻ്റിന് ലോജിക്കൽ ഒന്ന് മാറ്റിസ്ഥാപിക്കുന്ന ഒരു തരം ഉണ്ട് - ഗണിത അല്ലെങ്കിൽ പോയിൻ്റർ; ആദ്യത്തെ ഓപ്പറണ്ടിന് "ശരി" എന്ന മൂല്യമുണ്ടെങ്കിൽ, പ്രവർത്തനത്തിൻ്റെ ഫലം രണ്ടാമത്തെ ഓപ്പറണ്ടിൻ്റെ മൂല്യമാണ്, കൂടാതെ "തെറ്റ്" ആണെങ്കിൽ ഫലം പ്രവർത്തനത്തിൻ്റെ മൂല്യം മൂന്നാം ഓപ്പറണ്ടിൻ്റെ മൂല്യമാണ്. ഉദാഹരണം,

y= x>=0 ? x: -x;

വേരിയബിൾ x-ൻ്റെ മോഡുലസ് മൂല്യം y എന്ന വേരിയബിളിന് നൽകിയിരിക്കുന്നു.

ലോജിക്കൽ പ്രവർത്തനങ്ങൾക്കായി സി ഇനിപ്പറയുന്ന നൊട്ടേഷൻ ഉപയോഗിക്കുന്നു:

|| ലോജിക്കൽ "അല്ലെങ്കിൽ" (ലോജിക്കൽ കൂട്ടിച്ചേർക്കൽ)

&& ലോജിക്കൽ "ഒപ്പം" (ലോജിക്കൽ ഗുണനം)

ലോജിക്കൽ "അല്ല" (ലോജിക്കൽ നിഷേധം)

ലോജിക്കൽ സ്ഥിരാങ്കങ്ങളായ "ശരി", "തെറ്റ്" എന്നിവ ശരിയും തെറ്റും കൊണ്ട് സൂചിപ്പിക്കുന്നു (ഇവ ഭാഷാ കീവേഡുകളാണ്). ലോജിക്കൽ എക്സ്പ്രഷനുകളുടെ ഉദാഹരണങ്ങൾ:

bool a, b, c, d;

a = b || സി; // ലോജിക്കൽ "അല്ലെങ്കിൽ"

d = b && c; // ലോജിക്കൽ "ഒപ്പം"

a = !b; // ലോജിക്കൽ "അല്ല"

a = (x == y); // വലതുവശത്ത് താരതമ്യം

a = false; // നുണ

b = true; //ശരി

c = (x > 0 && y != 1); // സി എപ്പോൾ ശരിയാണ്

// രണ്ട് താരതമ്യങ്ങളും ശരിയാണ്

ലോജിക്കൽ നിഷേധത്തിന് ഏറ്റവും ഉയർന്ന മുൻഗണനയുണ്ട്, തുടർന്ന് ലോജിക്കൽ ഗുണനത്തിന്, ലോജിക്കൽ സങ്കലനത്തിന് ഏറ്റവും കുറഞ്ഞ മുൻഗണനയുണ്ട്.

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

പ്രവർത്തനത്തിൽ ഉൾപ്പെട്ടിരിക്കുന്ന ഓപ്പറണ്ടുകളുടെ എണ്ണത്തെ അടിസ്ഥാനമാക്കി, പ്രവർത്തനങ്ങൾ ഏകീകൃത, ബൈനറി, ത്രിതീയ എന്നിങ്ങനെ തിരിച്ചിരിക്കുന്നു.

സി ഭാഷയ്ക്ക് ഇനിപ്പറയുന്ന ഏകീകൃത പ്രവർത്തനങ്ങൾ ഉണ്ട്:

ഗണിത നിഷേധം (നിഷേധവും കൂട്ടിച്ചേർക്കലും);

~ ബിറ്റ്വൈസ് ലോജിക്കൽ നിഷേധം (പൂരകം);

ലോജിക്കൽ നിഷേധം;

* ഡീ-അഡ്രസ്സിംഗ് (പരോക്ഷ വിലാസം);

&വിലാസം കണക്കുകൂട്ടൽ;

യൂണറി പ്ലസ്;

വർദ്ധനവ് (വർദ്ധന);

കുറയ്ക്കുക (കുറവ്);

വലിപ്പം.

യൂണറി പ്രവർത്തനങ്ങൾ വലത്തുനിന്ന് ഇടത്തോട്ട് നടത്തുന്നു.

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

ഒരു പ്രിഫിക്സ് ഫോം

A++ പോസ്റ്റ്ഫിക്സ് ഫോം

#ഉൾപ്പെടുന്നു

(// എക്സ്പ്രഷനുകളിലെ വ്യത്യാസങ്ങൾ കാണിക്കുന്നു

printf("a = %d b = %d \n",a,b);

printf("a = %d b = %d \n",a++,++b);

ഫലമായി

unary പോലെയല്ല ബൈനറി പ്രവർത്തനങ്ങൾ, പട്ടികയിൽ നൽകിയിരിക്കുന്ന പട്ടിക ഇടത്തുനിന്ന് വലത്തോട്ട് നടത്തുന്നു.

മേശ

പ്രവർത്തന ചിഹ്നം	ഓപ്പറേഷൻ	ഓപ്പറേഷൻ ഗ്രൂപ്പ്
	ഗുണനം	ഗുണിതം

	ഡിവിഷൻ്റെ ബാക്കി
	കൂട്ടിച്ചേർക്കൽ	കൂട്ടിച്ചേർക്കൽ
	കുറയ്ക്കൽ	കൂട്ടിച്ചേർക്കൽ
	ഷിഫ്റ്റ് വിട്ടു	ഷിഫ്റ്റ് പ്രവർത്തനങ്ങൾ
	വലത്തേക്ക് മാറുക	ഷിഫ്റ്റ് പ്രവർത്തനങ്ങൾ
		ബന്ധ പ്രവർത്തനങ്ങൾ
	കുറവോ തുല്യമോ
	കൂടുതലോ തുല്യമോ

	തുല്യമല്ല
	ബിറ്റ്വൈസ് AND	ബിറ്റ്വൈസ് പ്രവർത്തനങ്ങൾ
	ബിറ്റ്വൈസ് അല്ലെങ്കിൽ
	ബിറ്റ്വൈസ് എക്സ്ക്ലൂസീവ് അല്ലെങ്കിൽ
	ലോജിക്കൽ AND	ലോജിക്കൽ പ്രവർത്തനങ്ങൾ
	ലോജിക്കൽ OR	ലോജിക്കൽ പ്രവർത്തനങ്ങൾ
	തുടർച്ചയായ കണക്കുകൂട്ടൽ	തുടർച്ചയായ കണക്കുകൂട്ടൽ
	അസൈൻമെൻ്റ്	അസൈൻമെൻ്റ് ഓപ്പറേറ്റർമാർ
	അസൈൻമെൻ്റിനൊപ്പം ഗുണനം
	അസൈൻമെൻ്റോടുകൂടിയ ഡിവിഷൻ
	അസൈൻമെൻ്റിനൊപ്പം ഡിവിഷൻ്റെ ബാക്കി
	അസൈൻമെൻ്റിനൊപ്പം കുറയ്ക്കൽ
	അസൈൻമെൻ്റിനൊപ്പം കൂട്ടിച്ചേർക്കൽ
	അസൈൻമെൻ്റിനൊപ്പം ഇടത് ഷിഫ്റ്റ്
	അസൈൻമെൻ്റ് അനുസരിച്ച് വലത് ഷിഫ്റ്റ്
	ബിറ്റ്‌വൈസ് ആൻഡ് അസൈൻമെൻ്റിനൊപ്പം
	ബിറ്റ്‌വൈസ് അല്ലെങ്കിൽ അസൈൻമെൻ്റിനൊപ്പം
	ബിറ്റ്‌വൈസ് എക്‌സ്‌ക്ലൂസീവ് അല്ലെങ്കിൽ അസൈൻമെൻ്റിനൊപ്പം

അസൈൻമെൻ്റ് ഓപ്പറേഷൻ്റെ ഇടത് ഓപ്പറണ്ട് ഒരു മെമ്മറി ലൊക്കേഷനെ സൂചിപ്പിക്കുന്ന ഒരു എക്സ്പ്രഷൻ ആയിരിക്കണം (എന്നാൽ കോൺസ്റ്റ് കീവേഡ് ഉപയോഗിച്ച് പ്രഖ്യാപിച്ച ഒരു വസ്തുവല്ല); അത്തരം പദപ്രയോഗങ്ങളെ ഇടത്-അനുവദനീയമെന്ന് വിളിക്കുന്നു, അവയിൽ ഉൾപ്പെടുന്നവ:

പൂർണ്ണസംഖ്യയുടെയും ഫ്ലോട്ടിംഗ് തരങ്ങളുടെയും ഡാറ്റ ഐഡൻ്റിഫയറുകൾ, പോയിൻ്റർ തരങ്ങൾ, ഘടന, യൂണിയൻ;

അറേ അല്ലെങ്കിൽ ഫംഗ്‌ഷൻ തരത്തിൻ്റെ എക്‌സ്‌പ്രഷനുകൾ ഒഴികെയുള്ള സൂചിക എക്‌സ്‌പ്രഷനുകൾ;

എലമെൻ്റ് സെലക്ഷൻ എക്സ്പ്രഷനുകൾ (->) കൂടാതെ (.) തിരഞ്ഞെടുത്ത ഘടകം ഇടത്-സാധുതയുള്ളതാണെങ്കിൽ;

ഏകീകൃത അഡ്രസ് ഓപ്പറേറ്റർ എക്സ്പ്രഷനുകൾ (*), ഒരു അറേയെയോ ഫംഗ്ഷനെയോ സൂചിപ്പിക്കുന്ന എക്സ്പ്രഷനുകൾ ഒഴികെ;

തത്ഫലമായുണ്ടാകുന്ന തരം യഥാർത്ഥ തരത്തിൻ്റെ വലുപ്പത്തിൽ കവിയുന്നില്ലെങ്കിൽ ഒരു തരം കാസ്റ്റ് എക്സ്പ്രഷൻ.

പദപ്രയോഗങ്ങൾ എഴുതുമ്പോൾ, (*), (&), (!), (+) ചിഹ്നങ്ങൾക്ക് ഒരു ഏകീകൃത അല്ലെങ്കിൽ ബൈനറി പ്രവർത്തനത്തെ സൂചിപ്പിക്കാൻ കഴിയുമെന്ന് ഓർമ്മിക്കുക.

തരം പരിവർത്തനം

പ്രവർത്തനങ്ങൾ നടത്തുമ്പോൾ, ഇനിപ്പറയുന്ന സന്ദർഭങ്ങളിൽ വ്യക്തമായ തരത്തിലുള്ള പരിവർത്തനങ്ങൾ സംഭവിക്കുന്നു:

പ്രവർത്തനങ്ങൾ നടത്തുമ്പോൾ, സാധാരണ ഗണിത പരിവർത്തനങ്ങൾ (മുകളിൽ ചർച്ച ചെയ്തവ) നടപ്പിലാക്കുന്നു;

അസൈൻമെൻ്റ് പ്രവർത്തനങ്ങൾ നടത്തുമ്പോൾ, ഒരു തരത്തിൻ്റെ മൂല്യം മറ്റൊരു തരത്തിൻ്റെ വേരിയബിളിന് നൽകിയിട്ടുണ്ടെങ്കിൽ;

ഒരു ഫംഗ്ഷനിലേക്ക് ആർഗ്യുമെൻ്റുകൾ കൈമാറുമ്പോൾ.

കൂടാതെ, ഒരു തരത്തിൽ നിന്ന് മറ്റൊന്നിലേക്ക് ഒരു മൂല്യം വ്യക്തമായി കാസ്റ്റ് ചെയ്യാൻ C നിങ്ങളെ അനുവദിക്കുന്നു.

അസൈൻമെൻ്റ് പ്രവർത്തനങ്ങളിൽ, അസൈൻ ചെയ്യുന്ന മൂല്യത്തിൻ്റെ തരം ആ മൂല്യം സ്വീകരിക്കുന്ന വേരിയബിളിൻ്റെ തരത്തിലേക്ക് പരിവർത്തനം ചെയ്യപ്പെടുന്നു. പൂർണ്ണസംഖ്യ, ഫ്ലോട്ടിംഗ് പോയിൻ്റ് തരങ്ങളുടെ പരിവർത്തനം അനുവദനീയമാണ്, അത്തരം പരിവർത്തനം വിവരങ്ങൾ നഷ്‌ടപ്പെടുന്നതിന് ഇടയാക്കിയാലും.

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

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

ഒപ്പിടാത്ത പൂർണ്ണസംഖ്യ തരങ്ങൾ പരിവർത്തനം ചെയ്യുന്നു. ഏറ്റവും പ്രധാനപ്പെട്ട ബിറ്റുകൾ വെട്ടിച്ചുരുക്കുന്നതിലൂടെ ഒരു ഒപ്പിടാത്ത പൂർണ്ണസംഖ്യയെ ചെറിയ ഒപ്പിടാത്ത അല്ലെങ്കിൽ ഒപ്പിട്ട പൂർണ്ണസംഖ്യയായി പരിവർത്തനം ചെയ്യുന്നു. ഇടതുവശത്ത് പൂജ്യങ്ങൾ പാഡ് ചെയ്യുന്നതിലൂടെ ഒപ്പിടാത്ത പൂർണ്ണസംഖ്യയെ ദൈർഘ്യമേറിയ ഒപ്പിടാത്ത അല്ലെങ്കിൽ ഒപ്പിട്ട പൂർണ്ണസംഖ്യയായി പരിവർത്തനം ചെയ്യുന്നു.

ഒപ്പിടാത്ത ഒരു പൂർണ്ണസംഖ്യ അതേ വലിപ്പത്തിലുള്ള ഒരു അടയാളപ്പെടുത്തിയ പൂർണ്ണസംഖ്യയിലേക്ക് പരിവർത്തനം ചെയ്യുമ്പോൾ, ബിറ്റ് പ്രാതിനിധ്യം മാറില്ല. അതിനാൽ, സൈൻ ബിറ്റ് സജ്ജമാക്കിയാൽ അത് പ്രതിനിധീകരിക്കുന്ന മൂല്യം മാറുന്നു (1 ന് തുല്യമാണ്), അതായത്. യഥാർത്ഥ ഒപ്പിടാത്ത പൂർണ്ണസംഖ്യ ഒരേ നീളമുള്ള പരമാവധി പോസിറ്റീവ് സൈൻ ചെയ്ത പൂർണ്ണസംഖ്യയേക്കാൾ വലുതായിരിക്കുമ്പോൾ.

ഒപ്പിടാത്ത പൂർണ്ണസംഖ്യയെ സൈൻ ചെയ്ത ദൈർഘ്യമുള്ള മൂല്യത്തിലേക്ക് പരിവർത്തനം ചെയ്തുകൊണ്ട് ഒരു ഫ്ലോട്ട് തരത്തിലേക്ക് പരിവർത്തനം ചെയ്യുന്നു, തുടർന്ന് ഒപ്പിട്ട ദൈർഘ്യമേറിയ മൂല്യത്തെ ഫ്ലോട്ട് തരത്തിലേക്ക് പരിവർത്തനം ചെയ്യുന്നു. സൈൻ ചെയ്യാത്ത നീളത്തിൽ നിന്ന് ഫ്ലോട്ട്, ഇരട്ട അല്ലെങ്കിൽ നീണ്ട ഇരട്ടപരിവർത്തനം ചെയ്യപ്പെടുന്ന മൂല്യം ദൈർഘ്യമേറിയ തരത്തിന് പ്രതിനിധീകരിക്കാവുന്ന പരമാവധി പോസിറ്റീവ് മൂല്യത്തേക്കാൾ കൂടുതലാണെങ്കിൽ, വിവരങ്ങൾ നഷ്‌ടപ്പെട്ട് നിർമ്മിക്കപ്പെടുന്നു.

ഫ്ലോട്ടിംഗ് തരം പരിവർത്തനങ്ങൾ. ടൈപ്പ് ഫ്ലോട്ടിൻ്റെ മൂല്യങ്ങൾ മൂല്യം മാറ്റാതെ തന്നെ ഇരട്ട ടൈപ്പിലേക്ക് പരിവർത്തനം ചെയ്യുന്നു. ഇരട്ട, ദൈർഘ്യമേറിയ ഇരട്ട മൂല്യങ്ങൾ കൃത്യത നഷ്ടപ്പെടുന്നതോടെ ഫ്ലോട്ടിലേക്ക് പരിവർത്തനം ചെയ്യപ്പെടുന്നു. ഒരു ഫ്ലോട്ടിന് മൂല്യം വളരെ വലുതാണെങ്കിൽ, അണ്ടർഫ്ലോ സംഭവിക്കുകയും റൺടൈമിൽ റിപ്പോർട്ട് ചെയ്യുകയും ചെയ്യുന്നു.

ഒരു ഫ്ലോട്ടിംഗ് പോയിൻ്റ് മൂല്യം പൂർണ്ണസംഖ്യകളിലേക്ക് പരിവർത്തനം ചെയ്യുമ്പോൾ, അത് ആദ്യം ഒരു ദീർഘമായി പരിവർത്തനം ചെയ്യപ്പെടുന്നു (ഫ്ലോട്ടിംഗ് പോയിൻ്റ് മൂല്യത്തിൻ്റെ ഫ്രാക്ഷണൽ ഭാഗം ഉപേക്ഷിക്കപ്പെടും), തുടർന്ന് ദൈർഘ്യമേറിയ മൂല്യം ആവശ്യമുള്ള പൂർണ്ണസംഖ്യ തരത്തിലേക്ക് പരിവർത്തനം ചെയ്യുന്നു. മൂല്യം വളരെ വലുതാണെങ്കിൽ, പരിവർത്തനത്തിൻ്റെ ഫലം നിർവചിച്ചിട്ടില്ല.

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

പോയിൻ്റർ തരം പരിവർത്തനം. ഒരു തരം മൂല്യത്തിലേക്കുള്ള ഒരു പോയിൻ്റർ മറ്റൊരു തരത്തിൻ്റെ മൂല്യത്തിലേക്ക് ഒരു പോയിൻ്ററിലേക്ക് പരിവർത്തനം ചെയ്യാവുന്നതാണ്. എന്നിരുന്നാലും, തരങ്ങൾ തമ്മിലുള്ള വിന്യാസത്തിലും വലുപ്പ ആവശ്യകതകളിലും ഉള്ള വ്യത്യാസങ്ങൾ കാരണം ഫലം അനിശ്ചിതത്വത്തിലായിരിക്കാം.

ചൂണ്ടിക്കാണിക്കുക ശൂന്യമായ ടൈപ്പ്ഏത് തരത്തിലുമുള്ള ഒരു പോയിൻ്ററിലേക്ക് പരിവർത്തനം ചെയ്യാൻ കഴിയും, കൂടാതെ ഏത് തരത്തിലുമുള്ള ഒരു പോയിൻ്ററിനെ നിയന്ത്രണങ്ങളില്ലാതെ ശൂന്യമായി ടൈപ്പുചെയ്യുന്നതിന് ഒരു പോയിൻ്ററായി പരിവർത്തനം ചെയ്യാൻ കഴിയും. പോയിൻ്റർ മൂല്യം ഒരു പൂർണ്ണസംഖ്യയായി പരിവർത്തനം ചെയ്യാവുന്നതാണ്. പരിവർത്തന രീതി പോയിൻ്ററിൻ്റെ വലുപ്പത്തെയും പൂർണ്ണസംഖ്യ തരത്തിൻ്റെ വലുപ്പത്തെയും ആശ്രയിച്ചിരിക്കുന്നു:

പോയിൻ്ററിൻ്റെ വലുപ്പം പൂർണ്ണസംഖ്യയുടെ വലുപ്പത്തേക്കാൾ കുറവോ തുല്യമോ ആണെങ്കിൽ, പോയിൻ്റർ ഒപ്പിടാത്ത പൂർണ്ണസംഖ്യ പോലെ പരിവർത്തനം ചെയ്യപ്പെടും;

പോയിൻ്റർ പൂർണ്ണസംഖ്യ തരത്തിൻ്റെ വലുപ്പത്തേക്കാൾ വലുതാണെങ്കിൽ, പോയിൻ്റർ ആദ്യം പൂർണ്ണസംഖ്യ തരത്തിൻ്റെ അതേ വലുപ്പമുള്ള പോയിൻ്ററിലേക്ക് പരിവർത്തനം ചെയ്യുന്നു, തുടർന്ന് പൂർണ്ണസംഖ്യ തരത്തിലേക്ക് പരിവർത്തനം ചെയ്യുന്നു.

ഇനിപ്പറയുന്ന നിയമങ്ങൾ ഉപയോഗിച്ച് ഒരു പൂർണ്ണസംഖ്യ തരം ഒരു വിലാസ തരത്തിലേക്ക് പരിവർത്തനം ചെയ്യാൻ കഴിയും:

പൂർണ്ണസംഖ്യ തരം പോയിൻ്ററിൻ്റെ അതേ വലുപ്പമാണെങ്കിൽ, പൂർണ്ണസംഖ്യ മൂല്യത്തെ ഒരു പോയിൻ്ററായി കണക്കാക്കുന്നു (ഒരു ഒപ്പിടാത്ത പൂർണ്ണസംഖ്യ);

ഒരു പൂർണ്ണസംഖ്യ തരത്തിൻ്റെ വലുപ്പം ഒരു പോയിൻ്ററിൻ്റെ വലുപ്പത്തിൽ നിന്ന് വ്യത്യസ്തമാണെങ്കിൽ, പൂർണ്ണസംഖ്യ തരം ആദ്യം പോയിൻ്ററിൻ്റെ വലുപ്പത്തിലേക്ക് പരിവർത്തനം ചെയ്യുന്നു (മുകളിൽ വിവരിച്ച പരിവർത്തന രീതികൾ ഉപയോഗിച്ച്), തുടർന്ന് ഫലമായുണ്ടാകുന്ന മൂല്യം ഒരു പോയിൻ്ററായി കണക്കാക്കുന്നു.

ഒരു ഫംഗ്‌ഷൻ വിളിക്കുമ്പോൾ പരിവർത്തനങ്ങൾ. ഒരു ഫംഗ്‌ഷൻ വിളിക്കുമ്പോൾ ആർഗ്യുമെൻ്റുകളിൽ നടത്തുന്ന പരിവർത്തനങ്ങൾ ഒരു ഫംഗ്‌ഷൻ പ്രോട്ടോടൈപ്പ് (ഒരു ഫോർവേഡ് ഡിക്ലറേഷൻ) ആർഗ്യുമെൻ്റ് ടൈപ്പ് ഡിക്ലറേഷനുകളുടെ ലിസ്‌റ്റിനൊപ്പം വ്യക്തമാക്കിയിട്ടുണ്ടോ എന്നതിനെ ആശ്രയിച്ചിരിക്കുന്നു.

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

ഈ പരിവർത്തനങ്ങൾ ഓരോ ആർഗ്യുമെൻ്റിനും സ്വതന്ത്രമായി നടപ്പിലാക്കുന്നു. ടൈപ്പ് ഫ്ലോട്ടിൻ്റെ മൂല്യങ്ങൾ ഇരട്ടിയായി പരിവർത്തനം ചെയ്യപ്പെടുന്നു, ടൈപ്പ് ചാർ, ഷോർട്ട് എന്നിവയുടെ മൂല്യങ്ങൾ int ആയി പരിവർത്തനം ചെയ്യപ്പെടുന്നു, ടൈപ്പ് ചെയ്യാത്ത ചാർ, ഒപ്പിടാത്ത ഷോർട്ട് എന്നിവയുടെ മൂല്യങ്ങൾ സൈൻ ചെയ്യാത്ത സംഖ്യയിലേക്ക് പരിവർത്തനം ചെയ്യപ്പെടുന്നു. പോയിൻ്റർ വേരിയബിളുകളിലും അവ്യക്തമായ പരിവർത്തനങ്ങൾ നടത്താം. ഫംഗ്‌ഷൻ പ്രോട്ടോടൈപ്പുകൾ വ്യക്തമാക്കുന്നതിലൂടെ, നിങ്ങൾക്ക് ഈ അവ്യക്തമായ പരിവർത്തനങ്ങൾ അസാധുവാക്കാനും ടൈപ്പ് ചെക്കിംഗ് നടത്താൻ കംപൈലറിനെ അനുവദിക്കാനും കഴിയും.

തരങ്ങൾ കാസ്റ്റുചെയ്യുമ്പോൾ പരിവർത്തനങ്ങൾ. ഫോർമാറ്റ് ഉള്ള ഒരു തരം കാസ്റ്റ് ഓപ്പറേഷൻ ഉപയോഗിച്ച് വ്യക്തമായ തരം പരിവർത്തനം സാധ്യമാക്കാം:

(തരം-പേര്) ഓപ്പറാൻറ്.

ഇനിപ്പറയുന്ന നൊട്ടേഷനിൽ, ടൈപ്പ്-നെയിം ഏത് തരം ഓപ്പറാൻറ് പരിവർത്തനം ചെയ്യണമെന്ന് വ്യക്തമാക്കുന്നു.

int i=2; നീണ്ട l=2; ഇരട്ട ഡി; ഫ്ലോട്ട് എഫ്; d=(ഇരട്ട) i * (ഇരട്ട) l; f=(ഫ്ലോട്ട്)d; ഈ ഉദാഹരണത്തിൽ, i,l,d മൂല്യങ്ങൾ പരാൻതീസിസിൽ സൂചിപ്പിച്ചിരിക്കുന്ന തരങ്ങളിലേക്ക് വ്യക്തമായി പരിവർത്തനം ചെയ്യും.

ഏകമാനവും മൾട്ടിഡൈമൻഷണൽ അറേകളും.

പ്രോഗ്രാമുകൾക്ക് പലപ്പോഴും ഒരേ തരത്തിലുള്ള ഡാറ്റയുടെ വലിയ അളവുകൾ പ്രോസസ്സ് ചെയ്യേണ്ടതുണ്ട്. ഇതിനായി സാധാരണ വേരിയബിളുകൾ ഉപയോഗിക്കുന്നത് വളരെ അസൗകര്യമാണ്: വ്യത്യസ്ത പേരുകളുള്ള 1000 വേരിയബിളുകളും ഒരു ലൂപ്പിൽ പ്രോസസ്സ് ചെയ്യാൻ കഴിയാത്ത അതേ തരവും സങ്കൽപ്പിക്കുക. അറേകൾ ഉപയോഗിച്ച് ഈ പ്രശ്നം പരിഹരിക്കാൻ കഴിയും.

അറേ- ഒരേ തരത്തിലുള്ള വേരിയബിളുകളുടെ (ഘടകങ്ങൾ) ഒരു പൊതു നാമവും. ആക്സസ്സ് അറേ ഘടകങ്ങൾമൂലക നമ്പർ സൂചിപ്പിക്കുന്നതിലൂടെ നടപ്പിലാക്കുന്നു - സൂചിക.

സി ഭാഷയിൽ, അറേ മൂലകങ്ങളുടെ എണ്ണം പൂജ്യത്തിൽ നിന്നാണ് ആരംഭിക്കുന്നത്!

അറേ ഡിക്ലറേഷനുകളുടെ ഉദാഹരണങ്ങൾ:

int a; // പൂർണ്ണസംഖ്യ അറേ a, വലിപ്പം – 10 ഘടകങ്ങൾ

ഇരട്ട വെക്റ്റ്; // അറേ യഥാർത്ഥ സംഖ്യകൾ vect, ഇതിന് 20 ഘടകങ്ങളുണ്ട്

ചാർ str; // 1024 ഘടകങ്ങളുള്ള പ്രതീക ശ്രേണി

ഒരു അറേ പ്രഖ്യാപിക്കുമ്പോൾ, നിങ്ങൾക്ക് ആവശ്യമുള്ള മൂല്യങ്ങൾ അതിൻ്റെ ഘടകങ്ങളിലേക്ക് ഉടൻ നൽകാം (അതായത്, അറേ സമാരംഭിക്കുക):

int x = (10, 20, 30, 40, 50);

char str = "ഹലോ!"; // ഓട്ടോമാറ്റിക്

int a = (1, 2, 3); // വലിപ്പം നിർണ്ണയിക്കുക

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

printf("%d\n",x);

സ്കാൻഫ്("%d", &x);

C++ ൽ മൂന്ന് ബിറ്റ്‌വൈസ് ലോജിക്കൽ ഓപ്പറേഷനുകളുണ്ട്:

ബിറ്റ്വൈസ് AND, ചിഹ്നം: &
ബിറ്റ്‌വൈസ് എക്‌സ്‌ക്ലൂസീവ് അല്ലെങ്കിൽ, നൊട്ടേഷൻ: ^
ബിറ്റ്വൈസ് ഇൻക്ലൂസീവ് അല്ലെങ്കിൽ, പദവി: |

C++ ലും ഉണ്ട്: OR - || ; ഒപ്പം - && . പലർക്കും ഒരു ചോദ്യം ഉണ്ട്, “പ്രവർത്തനങ്ങൾ തമ്മിലുള്ള വ്യത്യാസം എന്താണ്: & && ; | ഒപ്പം || ? ബിറ്റ്വൈസ് ലോജിക്കൽ പ്രവർത്തനങ്ങളുടെ പ്രവർത്തന തത്വം നിങ്ങൾ മനസ്സിലാക്കിയാൽ ഈ ചോദ്യത്തിനുള്ള ഉത്തരം ലഭിക്കും. എനിക്ക് ഉടനെ ഒരു കാര്യം പറയാം: ലോജിക്കൽ പ്രവർത്തനങ്ങൾ && ഒപ്പം || ലോജിക്കൽ അവസ്ഥകൾ നിർമ്മിക്കാൻ മാത്രമാണ് ഉപയോഗിക്കുന്നത്. ബൈനറി ഗണിതത്തിൽ ബിറ്റ്വൈസ് ലോജിക്കൽ ഓപ്പറേഷനുകൾ ഉപയോഗിക്കുന്നു. ഈ പ്രവർത്തനങ്ങൾ മെമ്മറി സെല്ലുകളുടെ ബിറ്റുകൾ ഉപയോഗിച്ച് പ്രവർത്തിക്കുന്നു, ഓപ്പറണ്ടുകളും ഫലവും മറ്റൊരു രൂപത്തിൽ വ്യക്തമാക്കാം, ഉദാഹരണത്തിന്, ദശാംശത്തിൽ. അടുത്തതായി, ഓരോ പ്രവർത്തനങ്ങളും ഞങ്ങൾ വിശദമായി പരിഗണിക്കും.

ബിറ്റ്വൈസ് ലോജിക്കൽ ആൻഡ് ഓപ്പറേഷൻ.
പദവികൾ: X, Y - ഓപ്പറണ്ടുകൾ; എഫ് - നിർവ്വഹണ ഫലം ലോജിക്കൽ പ്രവർത്തനം

പട്ടിക 1-ബിറ്റ്‌വൈസും സത്യ പട്ടികയും

എക്സ്	വൈ	എഫ്
0	0	0
0	1	0
1	0	0
1	1	1

ഒരു ബിറ്റെങ്കിലും 0 ആണെങ്കിൽ ഫലം പൂജ്യമാകുമെന്ന് സത്യ പട്ടികയിൽ നിന്ന് നമുക്ക് കാണാൻ കഴിയും. രണ്ട് ബിറ്റുകളും 1 ആണെങ്കിൽ, ഫലം 1 ആണ്.
അക്കങ്ങളുള്ള ഉദാഹരണം:
കണക്കുകൂട്ടലുകൾ ലളിതമാക്കാൻ, നമുക്ക് നാല്-ബിറ്റ് (4-ബിറ്റ് ബൈനറി കോഡ്) പോസിറ്റീവ് പ്രവർത്തനങ്ങൾ. ആദ്യം ഞങ്ങൾ അക്കങ്ങളെ ബൈനറി കോഡിലേക്ക് പരിവർത്തനം ചെയ്യുന്നു, തുടർന്ന് ഞങ്ങൾ പ്രവർത്തനം നടത്തുന്നു.

1111 = 15 1000 = 8
& 1001 = 9 & 1010 = 10
1001 = 9 1000 = 8
ഫലം 9. ഫലം 8 ആണ്.

ബിറ്റ്വൈസ് എക്സ്ക്ലൂസീവ്അഥവാ .

പട്ടിക 2-ബിറ്റ്‌വൈസ് എക്‌സ്‌ക്ലൂസീവ് അല്ലെങ്കിൽ സത്യ പട്ടിക

എക്സ്	വൈ	എഫ്
0	0	0
0	1	1
1	0	1
1	1	0

രണ്ട് ബിറ്റുകളും തുല്യമാണെങ്കിൽ ഫലം പൂജ്യമാകുമെന്ന് സത്യ പട്ടിക കാണിക്കുന്നു, മറ്റെല്ലാ സാഹചര്യങ്ങളിലും ഫലം 1 ആയിരിക്കും.
അക്കങ്ങളുള്ള ഉദാഹരണം:

1111 = 15 1000 = 8
^ 1001 = 9 ^ 1010 = 10
0110 = 6 0010 = 2
ഫലം 6. ഫലം 2 ആണ്.

ബിറ്റ്വൈസ് ഉൾപ്പെടെഅഥവാ .

പട്ടിക 3 — ബിറ്റ്വൈസ് ഉൾപ്പെടുന്ന സത്യ പട്ടിക അല്ലെങ്കിൽ

എക്സ്	വൈ	എഫ്
0	0	0
0	1	1
1	0	1
1	1	1

രണ്ട് ബിറ്റുകളും 0 ആണെങ്കിൽ ഫലം പൂജ്യമാകുമെന്ന് സത്യ പട്ടിക കാണിക്കുന്നു, മറ്റെല്ലാ സാഹചര്യങ്ങളിലും ഫലം 1 ആയിരിക്കും.
അക്കങ്ങളുള്ള ഉദാഹരണം:

1111 = 15 1000 = 8
| 1001 = 9 | 1010 = 10
1111 = 15 1010 = 10
ഫലം 15. ഫലം 10 ആണ്.

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

// log.cpp: കൺസോൾ ആപ്ലിക്കേഷൻ്റെ എൻട്രി പോയിൻ്റ് നിർവചിക്കുന്നു. #ഉൾപ്പെടുത്തുക "stdafx.h" #ഉൾപ്പെടുത്തുക << "\n 15 & 9 = " << (15 & 9) << endl; cout << "\n 15 ^ 9 = " << (15 ^ 9) << endl; cout << "\n 15 | 9 = " << (15 | 9) << endl; system("pause"); return 0; }

// കോഡ് കോഡ്:: ബ്ലോക്കുകൾ

// ദേവ്-സി++ കോഡ്

// log.cpp: കൺസോൾ ആപ്ലിക്കേഷൻ്റെ എൻട്രി പോയിൻ്റ് നിർവചിക്കുന്നു. #ഉൾപ്പെടുന്നു നെയിംസ്പേസ് എസ്ടിഡി ഉപയോഗിക്കുന്നു; int main(int argc, char* argv) ( cout<< "\n 15 & 9 = " << (15 & 9) << endl; cout << "\n 15 ^ 9 = " << (15 ^ 9) << endl; cout << "\n 15 | 9 = " << (15 | 9) << endl; return 0; }

ലോജിക്കൽ അവസ്ഥകളിൽ ബിറ്റ്‌വൈസ് ലോജിക്കൽ ഓപ്പറേഷനുകൾ ഉപയോഗിക്കുമ്പോൾ, ലോജിക്കൽ ഓപ്പറേഷനുകൾ ഉപയോഗിക്കുമ്പോൾ ലഭിക്കുന്ന ഫലം തന്നെയാണ് && || . ഇത് മനസ്സിലാക്കാവുന്നതേയുള്ളൂ, കാരണം അവരുടെ യുക്തി ഒന്നുതന്നെയാണ് !!

C++ ൽ, ഒരു തെറ്റായ അവസ്ഥ പൂജ്യം മൂല്യവുമായി പൊരുത്തപ്പെടുന്നു, കൂടാതെ ഒരു യഥാർത്ഥ അവസ്ഥ പൂജ്യത്തേക്കാൾ കൂടുതലുള്ള ഏതെങ്കിലും പൂർണ്ണസംഖ്യയുമായി പൊരുത്തപ്പെടുന്നു. അതിനാൽ ശരിയും തെറ്റും സ്ഥിരാങ്കങ്ങൾ പൂർണ്ണസംഖ്യകളായി വ്യാഖ്യാനിക്കപ്പെടുന്നു, തുടർന്ന് ബിറ്റ്വൈസ് ലോജിക്കൽ പ്രവർത്തനങ്ങൾ ബിറ്റ്വൈസ് അവസ്ഥയുടെ ഫലമായി രൂപം കൊള്ളുന്നു. എന്നാൽ ബിറ്റ്വൈസ് ലോജിക്കൽ പ്രവർത്തനങ്ങളുടെ നേരിട്ടുള്ള ഉദ്ദേശം ബൈനറി ഗണിതമാണ്. പ്രോഗ്രാമിൻ്റെ ഫലം (ചിത്രം 1 കാണുക).

15 & 9 = 9 15 ^ 9 = 6 15 | 9 = 15 തുടരാൻ, ഏതെങ്കിലും കീ അമർത്തുക. . .

ചിത്രം 1 - C++ ബിറ്റ്വൈസ് ലോജിക്കൽ പ്രവർത്തനങ്ങൾ