Site ng sasakyan - Sa likod ng gulong

Priyoridad sa pagpapatakbo— ang pagkakasunud-sunod ng pagpapatupad ng mga operasyon sa isang expression, sa kondisyon na ang expression ay hindi tahasang nagpapahiwatig ng pagkakasunud-sunod ng mga operasyon (gamit ang mga panaklong).

Kung ang mga operasyon ay may parehong priyoridad, pagkatapos ay ang pagkakasunud-sunod ng pagpapatupad ng mga naturang operasyon ay tinutukoy ayon sa pag-aari ng pagkakaugnay.

Pagkakaisa— direksyon ng pagsasagawa ng mga operasyon kung ang mga operasyon ay may parehong priyoridad.

Ipinapakita sa talahanayan 1 ang mga pangunahing operasyon sa C++, ang kanilang priority sa pagpapatupad at pagkakaugnay.

Hindi laging posible na matandaan ang priyoridad ng mga operasyon, samakatuwid, kung hindi ka sigurado tungkol sa pagkakasunud-sunod ng mga operasyon sa isang expression, malinaw na ipahiwatig ang pagkakasunud-sunod ng mga operasyon, iyon ay, ilagay ang mga panaklong. Tingnan natin ang isang piraso ng code kung saan ang priyoridad ng mga operasyon ay may mahalagang papel.

// maling expression int value = 5; cout<< value += 3; //(ОШИБКА) передаем в поток вывода значение переменной value + 3

Hindi mauunawaan ng compiler ang expression sa linya 3, dahil ang left shift operation ay may mas mataas na priyoridad kaysa sa sum assignment operation. Bilang isang resulta, ang isang programa na may ganoong expression ay hindi maaaring tumakbo. Ang punto ay naiintindihan ng compiler ang expression na ito hindi tulad ng ginagawa natin, ngunit sa isang ganap na naiibang paraan. Paano mangangatuwiran ang compiler: "Mayroong dalawang operasyon sa expression, at ang unang operasyon<< имеет больший приоритет, чем вторая += , ibig sabihin, ililipat ko muna ang value ng value variable sa output stream, at pagkatapos ay magdagdag ng 3 sa?????? Walang dapat idagdag ng 3, dahil ang value variable ay ipinapasa sa output stream." Ito ay kung saan ang error ay namamalagi, at upang maiwasan ito kailangan mo lamang maglagay ng mga panaklong.

// tamang expression int value = 5; cout<< (value += 3); // передаем в поток вывода значение переменной value + 3

Sa kasong ito, ang expression sa panaklong ay unang isasagawa, at pagkatapos ay ang halaga ng variable na halaga ay ipapasa sa output stream.

Ang pagkakasunud-sunod ng mga operasyon kapag kinakalkula ang halaga ng isang expression ay tinutukoy ng pag-aayos ng mga palatandaan ng operasyon, panaklong At priyoridad ng mga operasyon . Ang mga operasyong may pinakamataas na priyoridad ay unang ginagawa. Kung ang isang expression ay naglalaman ng ilang mga operasyon ng parehong priyoridad sa parehong antas, pagkatapos ay pinoproseso ang mga ito alinsunod sa pagkakasunud-sunod ng pagpapatupad - mula kanan hanggang kaliwa o mula kaliwa hanggang kanan. Kung kailangan mong baguhin ang pagkakasunud-sunod ng mga operasyon sa isang expression, dapat kang gumamit ng mga panaklong, halimbawa (x + y) * z .

Ang prioridad pagpapatakbo ng kuwit mas mababa kaysa sa lahat ng iba pang mga operasyon.

Inililista ng sumusunod na talahanayan ang mga pagpapatakbo ng wikang C++ sa pababang pagkakasunud-sunod ng priyoridad. Ang mga operasyong may iba't ibang priyoridad ay pinaghihiwalay ng isang linya.

Talahanayan ng Priyoridad ng Operasyon

Uri ng casting

Wika ng programming C++, bilang isang naka-type na wika, gayunpaman ay nagbibigay-daan sa iyo na pangasiwaan ang mga expression na tumatakbo sa iba't ibang uri ng data nang malaya. Sa kasong ito, ang mga operand ng expression ay inihagis sa ilang karaniwang uri.

Tanging ang mga conversion na nagko-convert ng mga operand na may mas maliit na hanay ng mga halaga sa mga operand na may mas malaking hanay ng mga halaga ang awtomatikong ginagawa, dahil ito ay nangyayari nang walang anumang pagkawala ng impormasyon. Halimbawa, kung sa expression ival + fval variable ival uri int , at ang variable fval– uri lumutang , tapos kapag nag-execute mga operasyon(+ ) variable na halaga ival ay ipapalabas upang mag-type lumutang .

Ang mga expression na maaaring mawalan ng impormasyon, gaya ng kapag nagtatalaga ng mahahabang integer sa mas maikli o totoong integer, ay maaaring magtaas ng Mga Babala, ngunit wasto ang mga ito (tingnan ang operator ng pagtatalaga).

Para sa anumang expression, maaari mong tahasang tukuyin ang isang conversion ng uri nito gamit ang unary operator na tinatawag nagdadala (sa pamamagitan ng pagbabagong-anyo) uri . Ang operasyon ay maaaring isulat sa dalawang format:

(uri) pagpapahayag

uri(expression)

Operand mga operasyonuri ng mga cast ay ang pagpapahayag na iko-convert. Ang prioridad uri ng cast operations katulad ng iba pang unary operations. Halimbawa: (mahabadoble) 5; (int) f ; (doble) a/2 .

Kung ang expression na pinag-uusapan ay may medyo kumplikadong anyo, ipinapayong ilagay ito sa mga panaklong upang matiyak na ang uri ng resulta ng buong expression ay mababago, at hindi lamang bahagi nito. Halimbawa,

(int) x + b * c

(int) (x + b * c )

Sa unang kaso, ang pagbabago ay nauugnay sa variable x , sa pangalawa – sa buong expression x+b*c.

Pagbati, mahal na mga mambabasa ng blog site! Huling beses naming tiningnan ang isyu ng sa built-in na wika 1C:Enterprise 8. Ngayon ay pag-uusapan natin ang tungkol sa tungkol sa mga priyoridad ng mga pagpapatakbo ng arithmetic ng mga primitive na uri ng data, at isaalang-alang din ang ilang magkakasunod na operasyon ng aritmetika. Tingnan natin!

Mula sa kurikulum ng paaralan, pamilyar ka sa katotohanang iyon pinakamataas na priyoridad sa mga operasyong aritmetika ay ang mga panaklong "()".
Kung ang isang expression ay nasa panaklong, ito ay isasagawa muna. Ang mga susunod na priyoridad ay ang unary operations na "+" at "-", ang unary operation ay nangangahulugan na ang operasyon at isang value ay tinukoy, halimbawa "-5". Ang mga operasyon ng multiplikasyon at paghahati ay isinasagawa sa pangatlo, at ang pagdaragdag at pagbabawas ay isinasagawa sa huli. Tingnan natin kung paano ito gumagana:

99+15/5*8

Sa kasong ito, ang unang 15 ay hahatiin ng 5, ang resultang numero ay i-multiply sa 6, at ang ikatlong operasyon: 99 ay idadagdag sa resultang numero. Susunod, ang sumusunod na simpleng expression ay 10+5/2+1. Malinaw na ang operasyon ng paghahati ay isasagawa muna, pagkatapos ay isasagawa ang operasyon ng karagdagan. Kung gagamit ka ng panaklong:

(90+30)/(7+5)

Sa kasong ito, sa simula ay magdaragdag kami ng 90 at 30 at hatiin ang lahat sa pamamagitan ng 7+5 at sa kasong ito ang expression ay magiging katumbas ng 10. Isaalang-alang natin ang iba pang mga operasyon na posible sa 1C: Enterprise 8 program code nagtrabaho ka sa PHP, kung saan posible ang naturang operator i++; o ako—;. Ito ay isang pagtaas o pagbaba ng isang yunit. Imposible ang pagpapatupad ng naturang mga operator sa 1C, ngunit posible ang operator i++1; At j—1;. Tingnan natin ang mga ito nang mas detalyado. Ito ay isang ganap na normal na operator. Buksan natin ang isang module ng anumang direktoryo sa Configurator:

Configuration -> Directories -> Nomenclature, i-right-click upang tawagan ang item Buksan ang object module.

Para maiwasan ang mga error, magdeklara tayo ng variable sa program code na ito:

A=0; b=a++1;

Kung titingnan mo ang mga error sa syntax, wala na. Kahit na ang expression ay inilagay sa iba't ibang mga linya:

A=0; b=a+ +1;

Sa pangkalahatan, ang mga line break ay walang epekto sa pagpapatupad ng mga pahayag. Paano gagana ang naturang operator? Ang 1C language compiler ay unang magsasagawa ng unary plus operation, ibig sabihin, ang +1 ay magbibigay ng 1 at pagkatapos ay sa a magdadagdag ng isa. Ito ay kapareho ng pagdaragdag ng isang sa isa. Sa parehong paraan maaari kang sumulat:

A=0; b=a+-1;

Una, isinasagawa ang unary minus operation, ang resulta ay -1, pagkatapos ay idinagdag ang minus at plus at ang resulta ay -1. Alinsunod dito, ito ay kapareho ng i-1. Kailangan mong malaman ang tungkol sa mga partikular na operasyon at maunawaan kung paano isasagawa ang mga ito. Makakatulong ito sa iyo na wastong unahin ang mga pagpapatakbo ng aritmetika alinsunod sa pagkakasunud-sunod na pinag-uusapan natin.

Kaya, nalaman namin na ang system ay mahinahon na nagpoproseso ng isang operasyon kung saan ang dalawang aritmetika na operasyon ay nangyayari sa isang hilera, halimbawa ++, +-, -+, ngunit ano ang mangyayari kung sumulat tayo ng ilang mga aritmetika na operasyon sa isang hilera? Maaari itong suriin. Upang gawin ito, buksan ang 1C:Enterprise mula sa Configurator sa debugging mode, pindutin ang "F5". Maglagay tayo ng breakpoint, ang "F9" key, sa dulo ng ating expression at maglagay ng simpleng expression sa table. Sa Configurator, buksan ang menu item Debug -> Tableau.

Isulat natin ang expression na 3+++5 sa scoreboard; tandaan na ang output na nakukuha natin ay isang error sa expression. Ang plataporma ay hindi makakagawa ng ganoong pagbabago. Gumagana ang expression na 3++5, ngunit may tatlong plus ang system ay hindi na naiintindihan kung ano ang eksaktong gusto nila mula dito. Ngunit kung maglalagay ka ng mga panaklong 1++(+2) , ang lahat ng ito ay gagawin nang tama. Tulad ng nakikita natin, upang maayos na maisaayos ang gawain ng mga operasyon ng aritmetika, kinakailangan na magkaroon ng isang mahusay na pag-unawa sa mga priyoridad ng kanilang pagpapatupad. Sa susunod na artikulo ay titingnan natin.

Lecture 4 Department of Applied Mathematics M-703, tel. 362-79-62 Ph.D., propesor Glagolev Viktor Borisovich, silid. Zh-405b, tel. 362-73-28 http://glagvik.narod2.ru/index.htm Arithmetic operations Priyoridad ng arithmetic operations Mathematical functions Arrays Logical operations Priyoridad ng operations

Operations and Functions Ang VB ay may malaking hanay ng mga built-in na function. Maaaring hatiin ang mga ito sa ilang kategorya: Mga pinansiyal at matematikal na function Mga matematikal na function Mga string processing function Uri ng conversion function Iba pang mga function

Makakakita ka ng mga detalyadong paglalarawan ng mga function sa sistema ng tulong ng VB. Susunod, titingnan lamang natin ang VB mathematical function. Ang talahanayan sa susunod na slide ay nagbibigay ng kumpletong listahan ng mga operasyon na maaaring ilapat sa numerical data.

Mga operasyon sa aritmetika

Mga operasyon ng relasyon

Pangunahing operator Kung maraming operator ang ginagamit sa isang expression, ang mga pagpapatakbong may pinakamataas na priyoridad ay unang gagawin. Kung ang priyoridad ng mga operasyon ay pareho, pagkatapos ay isinasagawa ang mga ito mula kaliwa hanggang kanan. a + b/c + d (a + b)/(c + d) Mga Halimbawa Expression Code

Mga function ng matematika

Ang mga anggulo ay ipinahayag sa radians. Dapat i-import ng iyong proyekto ang System.Math namespace sa pamamagitan ng pagdaragdag ng linyang Imports System.Math sa simula ng source code (bago ideklara ang unang module o klase). Kung hindi, bago ang pangalan ng bawat function, kakailanganing idagdag ang pangalan ng klase, halimbawa: Math.Sin(x)

Pag-import ng System.Math namespace sa isang proyekto

Ang mga function ng Int at Fix ay nagbabalik ng halaga na katumbas ng integer na bahagi ng isang numero na ang uri ay tumutugma sa uri ng argumento. Syntax: Int(number) at Fix(number) Ang kinakailangang numero ng argumento ay anumang wastong numeric expression.

Ang pagkakaiba sa pagitan ng mga function ng Int at Fix ay para sa isang negatibong halaga ng argumento, ibinabalik ng Int function ang pinakamalapit na negatibong integer na mas mababa sa o katumbas ng tinukoy, habang ang Fix ay nagbabalik ng pinakamalapit na negatibong integer na mas malaki sa o katumbas ng tinukoy. Halimbawa, ang Int function ay nagko-convert -8.4 sa -9, at ang Fix function ay nagko-convert -8.4 sa -8.

Ang Rnd function ay nagbabalik ng Single na naglalaman ng random na numero na mas mababa sa 1 at mas malaki kaysa o katumbas ng 0. Bago ang unang tawag sa Rnd function, dapat mong gamitin ang Randomize() na pahayag nang walang argumento para masimulan ang random number generator.

Halimbawa. Larong “Hulaan ang Numero” Kondisyon ng laro: Hulaan ng computer ang ilang random na integer k mula sa hanay na 0 – 100. Dapat mong hulaan ang nahulaan na numero, na gumawa ng kaunting pagsubok hangga't maaari. Pagkatapos ng bawat pagsubok, sasabihin sa iyo ng computer kung ang nakatagong numero ay mas malaki o mas mababa kaysa sa iminungkahing numero.

Talaan ng mga impormasyon

Algorithm block diagram Pagbuo ng random na numero k mula 0 hanggang 100 Input k1 a

Interface

Mga halaga ng ari-arian

Code ng programa

Mga Array Ang array ay isang pangkat ng mga variable na naglalaman ng mga elemento ng data ng parehong uri at may parehong pangalan. Ang isang hiwalay na memory cell ay inilalaan para sa bawat elemento ng array. Ang lahat ng mga elemento ng array ay may parehong uri. Posible ang mga sanggunian sa mga indibidwal na elemento ng array. Ang bawat indibidwal na elemento ng array ay nakikilala sa pamamagitan ng pangalan ng array at mga halaga ng index.

Halimbawa, ang mga reference na a(7) o a1(2, 9) ay nangangahulugan na: a ay ang pangalan ng isang one-dimensional array (vector) na may isang index, ang array element ay may index value na katumbas ng 7. a1 ay ang pangalan ng isang two-dimensional array (matrix). Ito ay napatunayan sa pamamagitan ng paggamit ng dalawang index upang matukoy ang isang elemento ng array.

Ang unang index ng isang two-dimensional array ay binibigyang-kahulugan bilang ang bilang ng row kung saan matatagpuan ang array element, at ang pangalawang index bilang ang numero ng column. Ang index ay maaaring isang expression ng isang uri ng integer na may hindi negatibong halaga. Ang lower bound ng isang index ay palaging 0. Ang upper bound ng bawat array index ay tinukoy kapag ito ay idineklara.

Array name Index (position number) ng array element km Halimbawa ng array na may pangalan na km ng uri ng Integer ng kilometro counter readings sa speedometer ng sasakyan sa simula ng bawat buwan sa buong taon:

Tulad ng mga simpleng variable, idineklara ang mga array gamit ang Dim, Static, Private, o Public statement. Mga halimbawa ng mga deklarasyon ng array: Dim x() Bilang Single Dim y(,) Bilang Single

Ang isang one-dimensional array na pinangalanang x at isang two-dimensional array na pinangalanang y ay idineklara. Ito ay ipinahiwatig ng mga bracket sa deklarasyon pagkatapos ng pangalan ng bawat array. Kapag nagdedeklara ng two-dimensional array, dapat mayroong kuwit sa pagitan ng mga bracket. Ang deklarasyon ng mga upper bounds sa mga index sa mga halimbawang ito ay ipinagpaliban hanggang sa ibang pagkakataon (tinatawag na dynamic ang mga ganitong array). Ang isang one-dimensional na array ay tinatawag na vector. Ang isang two-dimensional array ay tinatawag na matrix.

Upang ideklara ang itaas na hangganan ng index at ilagay ang mga arrays sa memorya, dapat mong ilagay ang pagtuturo: Redim x(10), y(4,5) Ang mga halaga ng upper bounds ng bawat array index ay tinukoy dito.

Ang index ng array x ay maaaring mula 0 hanggang 10. Ang array x ay may 11 elemento. Ang unang index ng y array ay maaaring mula 0 hanggang 4. Ang pangalawang index ng y array ay maaaring mula 0 hanggang 5. Ang y array ay may 30 elemento (ang produkto ng bilang ng mga row at bilang ng mga column).

Kapag nagdedeklara ng isang array, maaari mo itong simulan: Dim z() Bilang Single = (1.3, -2.7, _ 14.6, -5) Ang halimbawang ito ay nagdedeklara ng isang one-dimensional array z, na mayroong 4 na elemento, ang mga halaga kung saan ay tinukoy ng listahan ng pagsisimula. Ang array na idineklara na walang upper bounds sa mga indeks nito (dynamic array) ay maaaring muling ideklara nang paulit-ulit gamit ang ReDim statement.

Kabilang sa mga tagubilin sa loob ng pamamaraan maaari kang sumulat: ReDim y(5, 10) Pagkatapos ang array na ito ay maaaring muling ideklara: ReDim y(5, 20)

Ang ReDim statement ay maaari lamang baguhin ang itaas na mga hangganan ng mga indeks. Ang laki ng array (bilang ng mga index) ay maaaring itakda nang isang beses. Hindi ito mababago. Maaaring gamitin ang ReDim statement upang baguhin ang isang dynamic na array nang maraming beses kung kinakailangan. Gayunpaman, sa bawat oras na ito ay ginagamit, ang data na nilalaman sa array ay nawala.

Ang pahayag ng ReDim Preserve ay maaaring pataasin ang laki ng isang array habang pinapanatili ang mga nilalaman nito. Ipinapakita ng sumusunod na halimbawa kung paano mo mapapalaki ang laki ng array ng a4 ng 10 elemento nang hindi sinisira ang kasalukuyang mga halaga ng mga elemento ng array. Hayaang ideklara ang isang array: Dim a4 () Bilang Integer Pagkatapos ang laki ng array na ito ay nakatakda sa programa: ReDim a4 (n)

Kung, kapag nagdedeklara ng isang array, ang mga itaas na hangganan ng mga indeks ay tinukoy, kung gayon ang naturang array ay tinatawag na fixed. Halimbawa Dim s(10) Bilang Single Dim b(4, 5) Bilang Integer Ang pagtuturo ng ReDim ay hindi naaangkop sa mga nakapirming array.

Posibleng italaga ang mga nilalaman ng isang array sa isa pa sa parehong paraan tulad ng ginagawa para sa mga simpleng variable. Ngunit ang mga array na ito ay dapat na may parehong laki at parehong bilang ng mga elemento.

Kung mayroong isang dynamic na array sa kaliwang bahagi ng assignment operator, kung gayon ang bilang ng mga elemento ay hindi kailangang tumugma. Ang bilang ng mga elemento ng array sa kaliwang bahagi ng assignment operator ay magbabago kung kinakailangan.

Halimbawa. Dim a() As Integer = (1, 2, 3, 4), _ b(), i As Integer b = a Para sa i = 0 Hanggang 3 MsgBox(b(i)) Susunod Sunud-sunod sa screen sa MsgBox function Ang window ay magiging output: 1, 2, 3, 4.

Halimbawa 1 Kalkulahin ang arithmetic mean ng k na ibinigay na mga numero.

Naaangkop na data Paunang data: k – variable ng uri ng integer, bilang ng mga tinukoy na halaga; a() – array ng uri Single, mga halaga ng mga tinukoy na halaga. Mga resulta: s – variable ng uri Single, ang halaga ng arithmetic mean.

Intermediate: Sum – Isang variable na uri, ang halaga ng kabuuan ng unang k elemento ng array a; i ay isang integer type variable, ang index value ng array element a.

Flowchart ng algorithm (1) (2) 1

(3) (4) (5) (6) (7) (8) 1 2 No

Tingnan natin ang block diagram na ito sa mga tuntunin ng mga pangunahing istruktura na pumapasok dito. Ang mga bloke 1 – 2 ay bumubuo ng isang sequential na istraktura (sumusunod), na tatawagin nating Structure 1. Ang mga bloke 3 – 8 ay kabilang sa cycle. Tatawagin natin itong istrukturang Structure 2. Ang mga block 9 at 10 ay muling isang sequential structure, na tatawagin nating Structure 3.

Ang Structure 1, Structure 2 at Structure 3, na isinasaalang-alang nang magkasama, ay isa ring follow-up na istraktura. Sa isang flowchart ng anumang structured na algorithm, palaging malinaw na makikita ng isa ang mga pinagbabatayan na istruktura kung saan binuo ang algorithm.

Interface ng proyekto Ang field ng teksto ay inilaan para sa pagpapakita ng mga resulta ng pagkalkula. Ang pag-click sa pindutan ay magsisimula ng mga kalkulasyon.

Interface ng proyekto

Code ng Proyekto Kapag gumawa ka ng proyekto, awtomatikong bubuo ang system ng sumusunod na template ng code na nauugnay sa Form1, na isang deklarasyon ng klase ng Form1. Ang lahat ng code na nauugnay sa form ay dapat na nasa loob ng template na ito.

Dapat magsimulang tumakbo ang proyekto sa pamamagitan ng pag-click sa BtnStart button. Samakatuwid, ang code ng proyekto ay dapat na kasama ang BtnStart_Click subroutine, ang pagpapatupad nito ay na-trigger ng Click event na nangyayari sa BtnStart button (sa pamamagitan ng pag-click sa button na ito).

Ang susunod na hakbang sa paggawa ng project code ay dapat na isama sa project code ang BtnStart_Click subroutine template, na nilikha ng system kung i-double click mo ang BtnStart button, halimbawa.

Nasa ibaba ang code na makukuha pagkatapos gawin ang BtnStart_Click subroutine template.

Pagkatapos ilunsad ang proyekto para sa pagpapatupad, ang program code ay magsisimulang isagawa lamang pagkatapos ng pag-click sa BtnStart button. Sa kasong ito, ang kaganapan ng Pag-click ay nangyayari para sa button na ito, na humahantong sa pagpapatupad ng pamamaraan ng kaganapan ng BtnStart_Click. Mga resulta ng solusyon

Ang mga linya 1 hanggang 5 ng katawan ng pamamaraang ito ay nagdedeklara ng data. Ang linya 6 ay nag-clear sa field ng teksto. Ang Clear method ay ginagamit para dito. Kung hindi ito nagawa, pagkatapos ay kapag ang proyekto ay inilunsad nang maraming beses, ang impormasyong ipinapakita sa field ng teksto sa susunod na paglulunsad ay idaragdag sa impormasyong ipinapakita dito sa mga nakaraang paglulunsad.

Ang Linya 7 ay nagbibigay ng input para sa halaga ng variable k. Inirerekomenda na palaging subaybayan ang kawastuhan ng pagpasok ng data. Ito ay para sa layuning ito na sa linya 8 ang halaga ng variable k ay ipinapakita sa field ng teksto. Inilalaan ng Linya 9 ang array a sa memorya.

Sa mga linya 10 hanggang 12, ang mga halaga ng mga elemento ng array a ay ipinasok. Ang halaga ng elemento a(0) ay hindi ipinasok. Hindi namin papansinin ang pagkakaroon ng elementong ito. Hindi ito gagamitin kahit saan. Sa mga linya 13 hanggang 16, ang mga halaga ng ipinasok na mga elemento ng array a ay ipinapakita para sa kontrol sa field ng teksto.

Kinakalkula ng mga linya 17 hanggang 20 ang halaga ng variable s. Sa wakas, ang linya 21 ay nagbibigay ng output ng variable s sa isang text field.

Pansinin na ang programa ay hindi kasama ang pagtuturo i = 1 at ang pagtuturo i = i + 1, kahit na ang mga tagubiling ito ay lumilitaw sa block diagram. Wala ring check para sa kondisyon i<= k. Выполнение всех этих действий обеспечивает инструкция цикла For … Next.

Pakitandaan na hindi rin naglalaman ang program ng instruction sum = 0. Ang variable sum ay nakatanggap ng value na 0 bilang resulta ng deklarasyon nito. Maaari mong alisin ang Dim i As Integer na pagtuturo. Ang For...Next loop statement ay isang block. Ang variable na i sa loob ng bloke ay awtomatikong makakatanggap ng uri ng Integer (batay sa uri ng paunang at panghuling halaga ng parameter), ngunit kikilos lamang sa loob ng bloke.

Ang Logical Operations VB.NET ay tumutukoy sa mga lohikal na operasyon: At (lohikal na pagpaparami), O (lohikal na karagdagan), Hindi (lohikal na negation), at Xor (lohikal na eksklusibong karagdagan). Ang Not operator ay may sumusunod na syntax: Not Operand

Ang isang operand na may uri na Boolean ay isang kaugnayan, variable, o function ng Boolean type, o ang resulta ng isang Boolean operation. Ang resulta ng isang lohikal na negation ay may kabaligtaran na kahulugan ng operand nito, tulad ng ipinapakita ng talahanayan sa ibaba.

Hindi Operand ang Operand

Ang And operation ay may dalawang operand: Operand 1 At Operand 2 Ang resulta ng And operation ay tinutukoy ng table:

Ang And operator ay nagsusuri sa True lamang kapag ang parehong operand ay nagsusuri sa True. Halimbawa Hindi pagkakapantay-pantay a ? x? b ay dapat isulat: a<= x And x <= b Неправильно написать: a <= x <= b

Ang Or operation ay mayroon ding dalawang operand: Operand 1 O Operand 2 Ang resulta ng Or operation ay ibinibigay sa talahanayan:

Ang operator na Or ay nagsusuri sa True kung ang hindi bababa sa isang operand (at maging ang parehong magkasama) ay nagsusuri sa True. Halimbawa: Ang kundisyong "x ay hindi kabilang sa segment" ay dapat isulat: x< a Or x >b o Hindi(a<= x And x <= b)

Xor (Boolean Exceptional Addition) Ang resulta ng Xor operation ay ibinigay sa talahanayan: Ang Xor operation ay nagsusuri sa True kung ang isa sa mga operand (ngunit hindi pareho) ay nagsusuri sa True.

Tinutukoy din ng VB.NET ang mga lohikal na operasyon: AndAlso at OrElse. Ang AndAlso operation ay halos kapareho sa And operation. Nagsasagawa rin ito ng lohikal na pagpaparami sa dalawang Boolean operand.

Ang pangunahing pagkakaiba sa pagitan ng AndAlso at And ay ang AndAlso ay nagbibigay-daan sa shorthand, bahagyang pagsusuri ng mga operand nito. Kung ang unang operand sa AndAlso ay nagsusuri sa False, ang pangalawang operand ay hindi sinusuri at ang AndAlso na operasyon ay nagbabalik ng False.

Gayundin, ang operasyon ng OrElse ay halos kapareho sa operasyon ng Or. Ginagawa nito ang pinaikling lohikal na pagdaragdag ng dalawang lohikal na operand. Kung True ang unang operand sa expression ng OrElse, hindi susuriin ang pangalawang operand at ibabalik ang True para sa operasyon ng OrElse.

• ang prioridad mga operasyon,
• para sa mga operasyon ng parehong priyoridad pamamaraan ng aplikasyon- mula kaliwa pakanan o mula kanan pakaliwa;
• pag-convert ng mga uri ng operand at pagpili ng mga pagpapatupad para sa mga overloaded na operator;
• ang uri at halaga ng resulta ng pagsasagawa ng isang operasyon sa mga ibinigay na halaga ng mga operand ng isang tiyak na uri.

Priyoridad at pagkakasunud-sunod ng mga operasyon

Karamihan sa mga operasyon sa wikang C#, ang kanilang priyoridad at pagkakasunud-sunod, ay minana mula sa wikang C++. Gayunpaman, mayroon ding mga pagkakaiba: halimbawa, walang operasyong " , " na nagpapahintulot sa iyo na suriin ang isang listahan ng mga expression; nagdagdag ng checked at unchecked operations na naaangkop sa mga expression.

Gaya ng karaniwang ginagawa, nagtatanghal kami talahanayan ng priyoridad mga operasyon, sa bawat linya kung saan kinokolekta ang mga operasyon ng parehong priyoridad, at ang mga linya ay sumusunod sa priority order, mula sa pinakamataas hanggang sa pinakamababa.

Overloading na mga operasyon at pamamaraan

Sa ilalim overloading ang operasyon ang pagkakaroon ng ilang mga pagpapatupad ng parehong operasyon ay nauunawaan. Halimbawa, naiiba ang pagganap ng operasyong "+" depende sa kung ang mga operand nito ay mga integer, mahahabang integer, fixed-point o floating-point integer, o text string.

Kailangan mong maunawaan na ang mga operasyon ay isang espesyal na kaso ng pagtatala ng mga pamamaraan ng klase. Ang mga pamamaraan ng klase, tulad ng mga operasyon, ay maaaring ma-overload. Ang pamamaraan ng klase ay tinatawag overloaded, kung mayroong maraming pagpapatupad ng paraang ito. Ang mga overloaded na pamamaraan ay may parehong pangalan, ngunit dapat magkaiba sa kanilang pirma. Ang lagda ng pamamaraan ay isang listahan ng mga uri ng mga pormal na argumento ng pamamaraan. Kaya ang dalawang mga pamamaraan ng klase na may parehong pangalan, ngunit magkakaiba, halimbawa, sa bilang ng mga parameter, ay may ibang lagda at natutugunan ang mga kinakailangan para sa mga overload na pamamaraan.

Karamihan sa mga operator ng C# ay overloaded - ang parehong operator ay maaaring ilapat sa mga operand ng iba't ibang uri. Samakatuwid, bago magsagawa ng isang operasyon, ang isang pagpapatupad ay hinahanap na angkop para sa mga ibinigay na uri ng operand. Tandaan na ang mga operasyon ay karaniwang ginagawa sa mga operand ng parehong uri. Kung ang mga operand ay may iba't ibang uri, pagkatapos ay una implicit na uri ng conversion isa sa mga operand. Ang parehong mga operand ay maaaring magkapareho ang uri, ngunit ang uri ng conversion ay maaaring mangyari pa rin dahil walang katumbas na overloaded na operator para sa mga ibinigay na uri. Ang sitwasyong ito ay madalas na lumitaw sa pagsasanay, dahil, halimbawa, ang pagpapatakbo ng karagdagan ay hindi tinukoy para sa mas mababang mga subtype ng uri ng aritmetika. Kung walang angkop na pagpapatupad ng operasyon para sa mga ibinigay na uri ng operand at hindi posible ang implicit na pag-cast ng mga uri ng operand, kung gayon, bilang panuntunan, ang error na ito ay nakita sa yugto ng compilation.

Mga Uri ng Conversion

Ang bawat bagay (variable), bawat operand kapag sinusuri ang isang expression, ang expression mismo ay nailalarawan sa pamamagitan ng isang pares na tumutukoy sa halaga ng expression at ang uri nito. Sa proseso ng mga kalkulasyon, madalas na kailangan para sa uri ng conversion - ang pangangailangan na mag-convert ng isang pares sa mag-asawa . Ang orihinal na pares ay tinatawag na pinagmulan ng pagbabago, ang panghuling pares ay tinatawag na target ng pagbabago.

Ang pangangailangan para sa gayong mga pagbabago ay lumitaw, tulad ng nabanggit na, sa panahon ng pagsusuri ng isang expression kapag nagko-convert ng mga operand sa isang uri na naaayon sa uri ng operasyon. Kinakailangan ang conversion ng uri sa mga operator ng pagtatalaga kapag ang uri ng expression sa kanang bahagi ng operator ay na-cast sa uri na tinukoy ng kaliwang bahagi ng operator na ito. Nagaganap din ang mga semantika ng pagtatalaga kapag tumatawag sa mga pamamaraan sa proseso ng pagpapalit ng mga pormal na argumento ng pamamaraan ng aktwal na mga parameter. At dito kailangan ang uri ng conversion.

Maaaring hatiin ang mga uri ng conversion sa ligtas at mapanganib. Ang ligtas na conversion ay isang conversion kung saan ginagarantiyahan na:

Ang pagbabagong kung saan hindi bababa sa isa sa mga kundisyong ito ay hindi natutugunan ay tinatawag na mapanganib. Ang isang sapat na kundisyon para sa pagkakaroon ng ligtas na conversion ay, halimbawa, ang kundisyon na ang uri ay isang subtype ng uri . Sa katunayan, sa kasong ito, ang anumang source value ay isa ring valid na target na value. Kaya, ang conversion mula sa type int hanggang sa type double ay ligtas. Ang reverse conversion ay natural na mapanganib.

Awtomatikong ginagawa ang ilang uri ng mga conversion. Ang mga conversion na ito ay tinatawag na mga implicit na conversion, at karaniwan ang mga ito kapag sinusuri ang mga expression. Malinaw, ang mga ligtas na conversion lang ang maaaring implicit. Ang anumang mapanganib na pagbabagong-anyo ay dapat na tahasang tinukoy ng programmer mismo, na siyang buong responsibilidad sa pagsasagawa ng mapanganib na pagbabagong-anyo.

Mayroong iba't ibang mga paraan upang magsagawa ng mga tahasang conversion - ang pagpapatakbo ng pag-cast (pag-cast sa uri), mga pamamaraan ng espesyal na klase ng Convert, mga espesyal na pamamaraan na ToString, Parse. Ang lahat ng mga pamamaraang ito ay tatalakayin sa panayam na ito.

Ipaliwanag natin kung paano ginagawa ang mga implicit na conversion kapag sinusuri ang isang expression. Ipagpalagay na kapag kinakalkula ang ilang expression ay kinakailangan na magsagawa ng karagdagan, kung saan ang uri ay doble at ang uri ay int. Kabilang sa maraming mga pagpapatupad ng karagdagan ay ang mga operasyon na nagsasagawa ng pagdaragdag sa mga int operand at pagdaragdag sa mga dobleng operand, kaya ang pagpili ng alinman sa mga pagpapatupad ng karagdagan na ito ay mangangailangan ng isang uri ng conversion ng isa sa mga operand. Dahil ligtas ang conversion mula int hanggang double, ngunit mapanganib ang kabilang paraan, pinipili ang ligtas na conversion, na awtomatikong ginagawa, ang pangalawang operand ay tahasang na-convert sa type double, ang pagdaragdag ng mga operand ng ganitong uri ay isinasagawa, at ang resulta ng karagdagan ay magiging double type.

Pag-aayos ng proyekto ng software ng ConsoleExpressions

Gaya ng dati, ang lahat ng mga halimbawa ng code na lumalabas sa teksto ay bahagi ng proyekto ng software. Ilalarawan ko ang istruktura ng console project na ginamit sa lecture na ito, na tinatawag na ConsoleExpressions. Bilang karagdagan sa ginawang default na klase ng Programa, dalawang klase na pinangalanang TestingExpressions at Scales ang idinagdag sa proyekto. Ang bawat isa sa mga pamamaraan sa klase ng TestingExpressions ay kumakatawan sa isang pagsubok na nagbibigay-daan sa iyong pag-aralan ang mga tampok ng mga operasyong ginagamit upang bumuo ng mga expression, kaya ang klase na ito ay isang koleksyon ng mga pagsubok. Ang klase ng Scale ay nagbibigay-kaalaman, na nagpapakita kung paano gamitin ang mga timbangan na tatalakayin sa panayam na ito. Upang matawagan ang mga pamamaraan ng mga klase na ito, ang mga object ng mga klase na ito ay idineklara at nilikha sa Pangunahing pamamaraan ng klase ng Programa. Ang mga bagay na ito ay ginamit bilang target ng pagtawag sa mga naaangkop na pamamaraan. Ang pangkalahatang pamamaraan ng Pangunahing pamamaraan at mga pamamaraan ng klase ng pagtawag ay ang mga sumusunod:

static void Main(string args) ( string answer = "Yes"; do ( try ( TestingExpressions test = new TestingExpressions(); test.Casting(); //Tumawag sa ibang paraan... ) catch (Exception e) ( Console. WriteLine( "Imposibleng magpatuloy sa pagtatrabaho ng normal!"); (sagot == " Oo" || sagot == "oo" || sagot == "oo" )

Sa tuwing ang isang halimbawa ng code ay kailangang ibigay sa teksto ng lektura, alinman sa buong teksto ng pamamaraang tinatawag, halimbawa, ang Casting method, o isang hiwalay na fragment ng pamamaraan ay ibibigay.