Fallkonstanter i en switch-sats måste vara. Villkorliga uttalanden

Senaste uppdatering: 2016-07-30

Villkorliga konstruktioner är en av grundkomponenterna i många programmeringsspråk, som styr programmets arbete längs en av vägarna beroende på vissa förutsättningar.

Följande villkorliga konstruktioner används i C#: if..else och switch..case

om/annas konstruktion

If/else-konstruktionen kontrollerar sanningen i ett visst tillstånd och, beroende på resultatet av kontrollen, exekverar en viss kod:

int num1 = 8; int num2 = 6; if(num1 > num2) ( Console.WriteLine($"Numret (num1) är större än talet (num2)"); )

Nyckelordet if följs av ett villkor. Och om detta villkor är uppfyllt, fungerar koden som placeras längre fram i if-blocket efter de lockiga hängslen. De tidigare övervägda jämförelseoperationerna fungerar som villkor.

I det här fallet har vi det första talet större än det andra, så uttrycket num1 > num2 är sant och returnerar true , därför skickas kontrollen till raden Console.WriteLine("Numret (num1) är större än talet (num2 )");

Men vad händer om vi vill att något ska göras om villkoret inte är uppfyllt? I det här fallet kan vi lägga till ett annat block:

int num1 = 8; int num2 = 6; if(num1 > num2) ( Console.WriteLine($"Numret (num1) är större än siffran (num2)"); ) else ( Console.WriteLine($"Numret (num1) är mindre än talet (num2) )"); )

int num1 = 8; int num2 = 6; if(num1 > num2) ( Console.WriteLine($"Number (num1) är större än antalet (num2)"); ) else if (num1< num2) { Console.WriteLine($"Число {num1} меньше числа {num2}"); } else { Console.WriteLine("Число num1 равно числу num2"); }

Vi kan också koppla ihop flera villkor samtidigt med hjälp av logiska operatorer:

int num1 = 8; int num2 = 6; if(num1 > num2 && num1==8) ( Console.WriteLine($"Numret (num1) är större än talet (num2)"); )

I detta fall kommer if-blocket att exekveras om num1 > num2 är sant och num1==8 är sant .

switch design

Switch/case-konstruktionen liknar if/else-konstruktionen, eftersom den låter dig bearbeta flera villkor samtidigt:

Console.WriteLine("Tryck på Y eller N"); string selection = Console.ReadLine(); switch (selektion) ( case "Y": Console.WriteLine("Du tryckte på bokstaven Y"); break; case "N": Console.WriteLine("Du tryckte på bokstaven N"); break; standard: Console.WriteLine ("Du tryckte på en okänd bokstav"); break; )

Nyckelordet switch följs av jämförelseuttrycket inom parentes. Värdet på detta uttryck jämförs sekventiellt med värdena som placeras efter case statement. Och om en matchning hittas kommer ett specifikt fallblock att exekveras.

Varje fallblock måste avslutas med ett av hoppsatserna: break , goto case , return , eller throw . Vanligtvis används break-satsen. När det tillämpas kommer inga andra ärendeblock att exekveras.

Men om vi tvärtom vill, efter exekveringen av det aktuella caseblocket, exekveras ett annat caseblock, då kan vi använda goto case-satsen istället för break:

int nummer = 1; switch (nummer) ( fall 1: Console.WriteLine("fall 1"); gå till fall 5; // hoppa till fall 5 fall 3: Console.WriteLine("fall 3"); break; fall 5: Console.WriteLine( "fall 5"); break; default: Console.WriteLine("default"); break; )

Om vi ​​också vill hantera situationen när ingen matchning hittas, så kan vi lägga till ett standardblock, som i exemplet ovan.

Genom att använda return-satsen kan du lämna inte bara ärendeblocket utan också från anropsmetoden. Det vill säga, om det finns några operatorer och uttryck i Main-metoden efter switch..case-konstruktionen, där return-satsen används, kommer de inte att exekveras, och Main-metoden kommer att avslutas.

The throw-satsen används för att kasta fel och kommer att diskuteras i något av följande ämnen.

Ternär operation

Den ternära operationen har följande syntax: [första operand - villkor] ? [andra operand] : [tredje operand] . Det finns tre operander här. Beroende på villkoret returnerar den ternära operationen den andra eller tredje operanden: om villkoret är sant returneras den andra operanden; om villkoret är falskt, då det tredje. Till exempel:

intx=3; int y=2; Console.WriteLine("Tryck + eller -"); string selection = Console.ReadLine(); int z = urval=="+"? (x+y): (x-y); Console.WriteLine(z);

Här är resultatet av den ternära operationen variabeln z. Om vi ​​anger "+" ovan, kommer z att vara lika med den andra operanden - (x + y). Annars kommer z att vara lika med den tredje operanden.

Men C++ har också switch-multiple choice-operatören, som vi kommer att titta på i detalj om ett ögonblick.

// notation av omkopplaren för flervalssatsen (/*variabel eller uttryck*/) ( case /*konstant uttryck1/*: ( /*grupp av satser*/; break; ) case /*konstant uttryck2*/: ( / *gruppoperatorer*/; break; ) //. . standard: ( /*grupp av operatorer*/; ) )

I det inledande skedet analyseras ett uttryck eller en variabel. Därefter görs övergången till den gren av programmet för vilken värdet på variabeln eller uttrycket matchar det angivna konstanta uttrycket. Därefter exekveras en sats eller en grupp av satser tills antingen en avslutande, krullig parentes påträffas. Om värdet på en variabel eller ett uttryck inte matchar något av de konstanta uttrycken, överförs kontrollen till programgrenen som innehåller det reserverade ordet default . Därefter exekveras uttalandet eller gruppen av uttalanden för denna gren. Låt oss nu överväga en uppgift som använder switch-satsen.

Problemvillkor: skriv ett program som adderar, subtraherar, multiplicerar, dividerar två tal som skrivits in från tangentbordet. Utveckla ett användargränssnitt.

// switch.cpp: definierar startpunkten för konsolapplikationen. #inkludera "stdafx.h" #inkludera använder namnutrymme std; int main(int argc, char* argv) ( int count; // variabel att välja i switch double a,b; // variabler för att lagra operander cout<< "Vvedite pervoe chislo: "; cin >>a; cout<< "Vvedite vtoroe chislo: "; cin >>b; cout<< "Vibirite deistvie: 1-clojenie; 2-vichitanie; 3-ymnojenie; 4-delenie: "; cin >> räkna; switch (count) // start av switch-sats ( fall 1: // om count = 1 ( cout<< a << " + " << b << " = " << a + b << endl; // выполнить сложение break; } case 2: // если count = 2 { cout << a << " - " << b << " = " << a - b << endl; // выполнить вычитание break; } case 3: // если count = 3 { cout << a << " * " << b << " = " << a * b << endl; // выполнить умножение break; } case 4: // если count = 4 { cout << a << " / " << b << " = " << a / b << endl; // выполнить деление break; } default: // если count равно любому другому значению cout << "Nepravilni vvod" << endl; } system("pause"); return 0; }

PÅ 9:e raden vi har deklarerat räknevariabeln av heltalstyp. Det är värdet på denna variabel som programmet kommer att jämföra med värdet på det konstanta uttrycket. PÅ rad 10 två reella variabler deklareras för att lagra de inmatade talen. Varför på riktigt, ska jag förklara senare. Med 17 till 41 rader den villkorliga flervalsoperatörsomkopplaren skrivs. I det inledande skedet analyseras räknevariabeln. Analyserat så här:
om variabelantalet är lika med ett, då blocket av påståenden med 20:e till 23:e raderna;
om variabelantalet är lika med två, då blocket av påståenden med 25:e till 28:e raderna;
om variabelantalet är lika med tre, då blocket av påståenden med 30:e till 33:e raderna;
om variabelantalet är lika med fyra, då blocket av påståenden med 35:e till 38:e raderna;

Om värdet på räknevariabeln inte matchar något av de konstanta uttrycken, överförs kontrollen till programgrenen som innehåller det reserverade ordet default . Det vill säga följande rad kommer att exekveras

Cout<< "Nepravilni vvod" << endl;

Switch-satsen kan innehålla det reserverade ordet default eller inte. Om värdet på variabeln inte matchar något konstant uttryck och inte är standard, så skulle programkontroll i det här fallet helt enkelt hoppa till den första satsen efter switch. PÅ raderna 19, 24, 29, 34 konstanta uttryck skrivs, med vilka programmet jämför värdet på variabeln count .
PÅ raderna 22, 27, 32, 37, inspelad av . Frågan uppstår: "Varför behövs det?" Låt oss säga att användaren skrev in 2, det vill säga att räknevariabeln initierades med en tvåa. Den villkorliga flervalsoperatörsomkopplaren börjar fungera. Det vill säga en sökning efter en tvåa i konstanta uttryck utförs. Kollade först rad 19, det ser vi i rad 19 det konstanta uttrycket är lika med ett, och vi behöver en tvåa. Vi kollar vidare. Och sedan i ordning rad 24. Det ser vi i rad 24 konstant uttryck är lika med två, det är vad du behöver!!! Variabelantalet är lika med ett konstant uttryck, ett block av satser exekveras med 25 till 28 rader. Och här inne 27:e raden break-satsen skrivs, vilket gör att programmet hoppar till den första satsen efter switch-satsen. I detta fall överförs kontrollen linje 42. Och denna övergång behövs bara så att uppenbart onödiga åtgärder inte utförs. Om du tar bort break-satsen kommer programmet att fortsätta att jämföra variabelns värde med konstanta uttryck tills de alla slutar och sedan överföra kontrollen ändå linje 42. Resultatet av programmet visas nedan (se figur 1).

Figur 1 - Flervalsoperator i C++

Tillbaka till linje 10 , två variabler av typen dubbel deklareras där. Förmodligen uppstår frågan, "Varför en riktig typ och inte ett heltal?". Jag svarar: ”Eftersom en av åtgärderna som ett program kan utföra är division, och vid division har resultatet en riktig datatyp. När C++-kompilatorn delar tal, uppmärksammar deras datatyper. Om vi ​​helt enkelt delar tal på en miniräknare, till exempel 4/5=0.8 C++-kompilatorn ger oss resultatet med en sådan division på 0. Eftersom båda talen är heltal betyder det att resultatet också blir heltal, dvs. heltalsdelen av den vanliga divisionen, och i vårt fall är heltalsdelen med en sådan division 0, så en del av informationen går förlorad, eller, som man säger, skärs av (åtta tiondelar, i vårt fall, skärs av av). Och om utdelningen och divisorn är utbytta får vi på kalkylatorn: 5/4=1,25; C++-kompilatorn kommer att visa ett något annorlunda resultat, nämligen 5/4=1 (0,25 är avskuren). Ett sådant fenomen i C++ kallas implicit typgjutning. Den verkliga datatypen används för att representera tal mer exakt än heltalsdatatypen (det vill säga den visar bråkdelen).

I C++ finns det två riktiga:

1) dubbel är en realdatatyp med dubbel precision, vilket innebär att den tar upp dubbelt så mycket minne som flyttypen
2) flyta - enkel precision verklig datatyp

switch (uttryck) ( [deklaration] : [ case constant-expression1]: [ statement-list1] [ case constant-expression2]: [ statement-list2] : : [ default: [ statement-list ]] )

Uttrycket efter nyckelordet växla inom parentes kan vara vilket uttryck som helst som är tillåtet i C-språket, vars värde måste vara ett heltal. Observera att du kan använda en explicit cast till en heltalstyp, men du måste vara medveten om begränsningarna och rekommendationerna som diskuteras ovan.

Värdet av detta uttryck är nyckeln till att välja mellan flera alternativ. Brödtexten i en smitch-sats består av flera satser markerade med nyckelordet case följt av ett konstant uttryck. Det bör noteras att användningen av ett heltalskonstantuttryck är en betydande nackdel som är inneboende i den betraktade operatorn.

Eftersom ett konstant uttryck utvärderas vid översättningstidpunkten kan det inte innehålla variabler eller funktionsanrop. Vanligtvis används heltals- eller teckenkonstanter som ett konstantuttryck.

Alla konstanta uttryck i påståendet växla måste vara unik. Förutom påståenden som är markerade med nyckelordet case kan det finnas, men alltid ett, ett fragment markerat med nyckelordet standard.

Operatörslistan kan vara tom eller innehålla en eller flera operatorer. Och i operatören växla det finns inget behov av att omsluta sekvensen av uttalanden i hängslen.

Notera också att i operatören växla du kan använda dina egna lokala variabler vars deklarationer kommer före det första case-nyckelordet, men deklarationerna får inte använda initialisering.

System för utförande av utlåtanden växla Nästa:

• uttrycket inom parentes utvärderas;
• de beräknade värdena jämförs sekventiellt med de konstanta uttrycken efter case-nyckelorden;
• om ett av de konstanta uttrycken matchar uttryckets värde, överförs kontrollen till satsen markerad med motsvarande nyckelord för case;

- om inget av de konstanta uttrycken är lika med uttrycket, överförs kontrollen till operatorn markerad med nyckelordet standard, och i händelse av frånvaro överförs kontrollen till nästa efter växla operatör.

Notera en intressant egenskap med att använda switch-satsen: konstruktionen med ordet standard kanske inte är den sista i operatörsorganet växla. Nyckelord fall och standard i operatörens kropp växlaär betydelsefulla först vid den inledande kontrollen, när utgångspunkten för utförandet av utlåtandekroppen bestäms växla. Alla satser mellan startsatsen och slutet av texten exekveras oavsett nyckelord, såvida inte ett av satserna överför kontrollen från satsens brödtext. växla. Således måste programmeraren ta hand om att avsluta fall om det behövs. Den mest använda operatören för detta är ha sönder.

För att utföra samma åtgärder för olika värden av ett uttryck kan du markera samma påstående med flera nyckelord fall.

Exempel:

int i=2; switch (i) (fall 1: i += 2; fall 2: i *= 3; fall 0: i /= 2; fall 4: i -= 5; standard: ; )

Utlåtandeutförande växla börjar med ett påstående märkt fall 2. Variabeln alltså i får värdet lika med 6, sedan körs satsen markerad med nyckelordet fall 0, sedan fall 4, i sätts till 3 och sedan till -2. En sats markerad med standardnyckelordet ändrar inte värdet på variabeln.

Betrakta det föregående exemplet, som illustrerade användningen av kapslade if-satser, nu omskrivna med hjälp av satsen växla.

kol ZNAC; int x,y,z; switch (ZNAC) ( case "+": x = y + z; break; case "-": x = y - z; break; case "*": x = y * z; break; case "/": x = u / z; break; standard: ; )

Operatörsanvändning ha sönder låter dig avbryta sekvensen av körda satser i huvuddelen av switch-satsen vid det nödvändiga ögonblicket genom att överföra kontrollen till satsen efter växla.

Observera att kapslade satser kan användas i huvuddelen av switch-satsen växla, medan samma konstanta uttryck kan användas i case-nyckelord. fall 2: f-= 9; ha sönder ; fall 3: b-= c; ha sönder ; :)

: brytare (a) ( fall 1: b=c; brytning; fall 2: brytare (d) ( fall 0: f=s; brytning; fall 1: f=9; brytning; fall 2: f-=9; brytning ; ) fall 3: b-=c; break; : )

1.4.6. bryta uttalande
Break-satsen avslutar exekveringen av den innersta satsen som ansluter sig till den. byta, göra, för, medan. Efter att break-satsen har körts överförs kontrollen till satsen efter den avbrutna.

Villkorliga uttalanden

Villkorliga uttalanden låter dig kontrollera flöde programexekvering så att varje kodrad inte exekveras som den ska i programmet. Låt oss titta på alla villkorliga uttalanden i C#-språket:

om uttalande

För att organisera villkorlig förgrening ärvde C#-språket if...else-konstruktionen från C och C++. Dess syntax bör vara intuitiv för alla som har programmerat på procedurspråk:

om (villkor)
operatör(er)
annan
operatör(er)

Om mer än en sats behöver köras för vart och ett av villkoren, måste dessa satser kombineras till ett block med hjälp av klammerparenteser (...). (Detta gäller även andra C#-konstruktioner där satser kan grupperas i ett block, som for- och while-loopar.)

Det är värt att notera att, till skillnad från i C och C++, i C# kan if-satsen bara fungera med booleska uttryck, men inte med godtyckliga värden som -1 och 0.

If-satsen kan använda komplexa uttryck och kan innehålla else-satser för att möjliggöra mer komplexa kontroller. Syntaxen liknar den som används i liknande situationer i C (C++) och Java. Vid konstruktion av komplexa uttryck i C# används den förväntade uppsättningen logiska operatorer. Låt oss titta på följande exempel:

Använda System; använder System.Collections.Generic; använder System.Linq; använder System.Text; namespace ConsoleApplication1 ( klass Program ( static void Main(string args) ( string myStr; Console.WriteLine("Ange sträng: "); myStr = Console.ReadLine(); if (myStr.Length = 5) && (myStr.Length

Som du kan se är antalet andra ifs som lagts till i en singel om obegränsat. En sak att notera om: lockiga hängslen krävs inte om det bara finns ett påstående i den villkorliga grenen, som visas i det ursprungliga exemplet.

byta uttalande

Den andra select-satsen i C# är byta uttalande, som ger flerriktad förgrening av programmet. Därför tillåter detta uttalande dig att göra ett val mellan flera alternativa alternativ för ytterligare programexekvering. Medan flervägstestning kan göras med en serie kapslade if-satser, är det i många fall mer effektivt att använda en switch-sats. Denna operatör fungerar enligt följande. Värdet på uttrycket jämförs sekventiellt med urvalskonstanterna från den givna listan. Så snart en matchning hittas med ett av urvalsvillkoren exekveras sekvensen av satser som är associerade med detta villkor. Följande är den allmänna formen för switch-satsen:

switch(uttryck) ( case constant1: sekvens av break-satser; case constant2: sekvens av break-satser; case constant3: sekvens av break-satser; ... standard: sekvens av break-satser; )

Medan switch...case-satsen borde vara bekant för C- och C++-programmerare, är den något säkrare i C# än sin C++-motsvarighet. I synnerhet förbjuder den "genom"-förhållanden i nästan alla fall. Detta innebär att om en case-del anropas i början av ett block, så kan kodfragment efter efterföljande case-delar inte exekveras om inte en goto-sats uttryckligen används för att hoppa till dem. Kompilatorn upprätthåller denna begränsning genom att kräva att varje falldel följs av bryta uttalande, annars ger det ett fel.

Det är viktigt att notera att det givna uttrycket i switchsatsen måste vara av heltalstyp (char, byte, short eller int), uppräknat eller sträng. Och uttryck av andra typer, såsom flyttal, är inte tillåtna i switch-satsen. Ofta reduceras uttrycket som styr switch-satsen helt enkelt till en enda variabel. Dessutom måste urvalskonstanter vara av en typ som är kompatibel med typen av uttryck. I en switch-sats är två urvalskonstanter med samma värde inte tillåtna.

Switch-satsen är en mycket bekväm ersättning för flera användningsområden. Switch-satsen jämför värdet av en variabel med flera konstanter. Det grundläggande formatet för att använda flervalsväxelfallssatsen visas nedan. Värdet på variabeln som anges i switch-satsen jämförs med värdena som följer case-nyckelordet. När värdet i variabeln matchar värdet i raden med case-satsen, kommer datorn att fortsätta programmet från den punkten.

Switch (/*variabel*/) (case const1: /*Här är koden som ska exekveras om variabeln är lika med const1*/ break; case const2: /*denna kod kommer att exekveras om variabeln är lika med const2*/ break ; /*...*/ default: /*Kod som kommer att exekveras om ingen av konstanterna matchar värdet i variabelvariabeln*/ break; )

När det jämförda värdet i variabeln matchar det första värdet i case-satsen, kommer programmet att börja exekvera koden mellan den aktuella case-satsen och . Break-satsen används för att bryta programflödet i switch-satsen och överföra kontrollen till nästa sats efter switch-satsen. Om du inte använder break-satsen kommer programmet omedelbart efter att ett kodblock har körts att byta till körningen av nästa fall, även om det konstanta värdet inte är lika med värdet i variabeln . Därför, i en switch-sats, måste kodblock efter fall alltid föregås av en break-sats.

Det är också värt att uppmärksamma standardsökordet, det krävs inte, men samtidigt är det nödvändigt att hantera oväntade situationer. Till exempel, när värdet på en variabel inte matchar något av fallvärdena, kommer koden i standardgrenen att exekveras. Detta kan vara användbart om vi inte förväntar oss att något av kasusvärdena matchar värdet på variabeln i switch-satsen. I det här fallet kommer vi att se att koden i standardgrenen fungerade.

För att förstå och komma ihåg allt som sagts tidigare, låt oss gå vidare till ett enkelt program med switch-satsen. Även om det här exemplet kanske inte är det mest framgångsrika, visar det tydligt all funktionalitet i switch-satsen.

#omfatta int main() ( printf("Vad skulle du vilja se idag?\n"); printf("1. Arrow(Arrow)\n"); printf("2. Supernatural(Supernatural)\n"); printf ("3 . Walking Dead\n"); printf("4. Avsluta\n"); printf("Ditt val: "); int input; scanf("%d", &input); switch (ingång) ( case 1: /* notera kolon, inget semikolon här */ printf(""Hans död var bara början"\n"); break; fall 2: printf(""Skrämmande blev just sexigt"\n") ; break; fall 3: printf(""Kämpa mot de döda. Frukta de levande"\n"); break; fall 4: printf("Vi kommer inte att titta på någonting idag:(\n"); break; default: printf(" Ogiltigt input.\n"); ) getchar(); return 0; )

Så hur fungerar den här koden? Till att börja med gjorde vi en liten meny ( rad 5 - 10) för att på något sätt informera användaren om vad som behöver matas in i programmet. Som du redan förstått måste du ange ett nummer - 1, 2, 3 eller 4. Beroende på det inmatade numret kommer programmet att fungera annorlunda. I det här exemplet är det mycket tydligt att indatavärdet lagras i indatavariabeln, och efter det skickas värdet i denna variabel till switch-satsen, rad 13.PÅ rad 13 - 29 växelns flervalsoperatör deklareras. Hur fungerar det? Mycket enkelt, i ordning, jämför programmet indatavariabeln med värdena 1, 2, 3 och 4 . Om vi ​​till exempel skrev in siffran 3, så kommer programmet att exekvera koden som finns på rad 21-22, när du anger en enhet kommer programmet att skriva ut ett meddelande från rad 15. Jag tror du förstår poängen. Tja, om vi skrev in ett annat nummer än de givna, blockeras koden rad 27. Vi tittar på resultatet av programmet. Jag skrev in värdet - 3, idag ska jag titta på - Walking!

Vad skulle du vilja se idag? 1. Pil 2. Övernaturligt 3. Walking Dead 4. Avsluta Ditt val: 3 “Fight the dead. Frukta de levande»

Du kan lägga denna meny och användarinmatning i en loop, sedan kan du gå igenom valet så många gånger du vill. Jag hoppas att jag beskrev hela processen tillräckligt tydligt, ämnet är inte komplicerat, men för att konsolidera materialet, experimentera med den här koden. Lycka till!