Slingor och andra kontroller. Strukturerad programmering

Filialoperatör

Filialoperatören (villkorlig gren) låter dig utföra vissa programinstruktioner beroende på logiska förhållanden. I Visual Basic kan filialoperatören användas i två varianter: inline och block.

onlineutbyte av studentdokument ">

Exempel 1

Till exempel, Om a> b Då max = a Annat max = b.

Om du behöver köra flera satser separeras de med kolon.

Exempel 2

Till exempel, om a> 0 Då är b = a + 1: c = a \ 2.

Blocksyntaxen är kraftfullare, mer strukturerad och mer läsbar.

Blocksyntax:

Tillstånd är ett booleskt uttryck som kan anta ett värde Sann(Sann), Falsk(falskt) eller Null vilket motsvarar Falsk... När en blockgreningsats exekveras kontrolleras villkoret och, om sant, satsen som följer Sedan... Om villkoret inte är sant, kontrolleras det skick2 följande ElseIf... När ett sant värde hittas exekveras operator_of_true2, vilket följer Sedan, varefter programmet går längre än EndIf(dvs efterföljande ElseIf, om några, inte är markerade). Om de verkliga förutsättningarna för ElseIf hittades inte, operatorn under_of_condition exekveras.

Figur 3. Ett exempel på blocksyntax. Author24 - onlineutbyte av studentuppsatser

Urvalsoperatör

Ärendevalsoperatör exekverar vissa operatorer beroende på uppsättningen värden för det testade uttrycket eller variabeln. Välj satssyntax:

Figur 4. Syntaxen för select-satsen. Author24 - onlineutbyte av studentuppsatser

Värde är en variabel eller ett uttryck som testas mot ett eller flera villkor. Värdelistan anges med kommatecken, värdeintervallet anges med hjälp av ett serviceord Till(till exempel 5 till 9).

Exempel 3

Med numret på månaden på året, visa ett meddelande om vilken tid på året den angivna månaden tillhör.

Strukturerad operatörer - det är konstruktioner byggda enligt vissa regler från andra operatörer. Strukturerade operatörer inkluderar:

Sammansatt operatör

Villkorlig operatör

Urval Operatörer

Slingoperatörer

Med uttalande

1. Sammansatt operatör

Sammansatt operatör är en grupp av valfritt antal operatorer, separerade från varandra med semikolon, och avgränsade av operatorparenteserna börjar och slutar.

Sammansatt operatorformat:

Börja<Оператор1>; ... ; <ОператорN>;

Oavsett antalet operatörer som ingår i den, uppfattas den sammansatta operatören som en helhet. Den vanligaste sammansatta operatorn är i villkors- och loop-satser.

Sammansatta operatorer kan kapslas inuti varandra, utan begränsningar på kapsdjupet för sammansatta operatorer.

2. Villkorlig operatör

Villkorlig operatör upprätthåller eller inte följer vissa uttalanden, beroende på efterlevnaden av vissa villkor.

Villkorligt operatörsformat:

Om sedan<Оператор1> ;

Tillståndet är ett booleskt uttryck. Operatören fungerar enligt följande: om villkoret är sant (har värdet True), så exekveras operator1, annars exekveras operator2. Båda operatorerna kan vara sammansatta.

Ett villkorligt uttalande kan skrivas i förkortad form när ordet else och statement2 efter det saknas.

För att organisera grenar i tre riktningar eller fler kan du använda flera villkorssatser, kapslade i varandra. Dessutom motsvarar varje annan den då omedelbart föregående den. På grund av möjliga fel bör du undvika djupt kapslande villkorliga uttalanden inom varandra.

3. Val av operatör

Operatör av val är en generalisering av den villkorliga operatorn och låter dig välja från ett godtyckligt antal tillgängliga alternativ. Detta påstående består av ett uttryck som kallas väljare, en lista med alternativ och en valfri annan gren, som har samma betydelse som i ett villkorligt uttalande.

Välj operatörsformat:

fall<Выражение-селектор>av

<Список1> : <Оператор1>;

<СписокN> : <ОператорN>

Väljaruttryck måste vara av ordinär typ. Varje variant är en lista med konstanter, separerade med ett kolon från motsvarande operator. Listan med urvalskonstanter består av ett godtyckligt antal värden och intervall, separerade med kommatecken. Områdesgränserna skrivs i två konstanter åtskilda av ".."-avgränsaren. Typen av konstanter måste matcha typen av väljaruttrycket.

Urvalssatsen utförs enligt följande:

1. Värdet på väljaruttrycket utvärderas.

2. Alternativen skannas sekventiellt efter sammanfallande av väljarvärdet med konstanter och värden från intervallen i motsvarande lista.

3. Om denna sökning lyckas för nästa variant, exekveras operatören för denna variant. Därefter avslutas exekveringen av urvalssatsen.

4. Om alla kontroller misslyckades, exekveras operatören efter ordet annat (om någon).

Exempel. Urvalsoperatör

caseNumberDag av

1..5: strDay: = "Arbetsdag";

6..7: strDay: = "Ledig dag"

else strDay: = "";

Beroende på värdet på heltalsvariabeln NumberDay som innehåller veckodagens nummer, tilldelas strängvariabeln strDay motsvarande värde.

Kapitel 6. KONTROLLSTRUKTURER Tilldelning Operatör Enkla och sammansatta operatörer Villkorlig operatör Flervalsoperatör Förkonditionerad slingoperatör Efterkonditionerad slingoperatör Parameteriserad loopoperator och ovillkorliga hoppprocedurer

2 kap. 6. KONTROLLSTRUKTURER Tilldelningsoperator En operator är en programmeringsspråkskonstruktion som används för att ställa in en åtgärd eller en sekvens av åtgärder i ett program på data. Uppsättningen programoperatörer implementerar algoritmen som är inneboende i den. Varje operatör innebär en åtgärd. Processen att "skjuta in" ett värde i en variabel kallas tilldelning (den första tilldelningen kallas initialisering). Tilldelningen utförs med en speciell konstruktion - tilldelningsoperatorn: variabelidentifierare: =: = uttryck Var W, H: Heltal; Börja W: = 23; H: = 17; W: = W * H; Slutet.

3 kap. 6. KONTROLLSTRUKTURER Enkla och sammansatta satser Två på varandra följande satser måste separeras med semikolon (vilket betyder slutet av en sats): a: = 11; b: = a * a; Skriv (a, b); Ett sammansatt påstående är en sekvens av påståenden som behandlas som ett enda påstående. Den är formaterad med de reserverade orden start och end (operatorparenteser). En operatör i ett program är ett enda odelbart uttalande som utför en åtgärd. En enkel operatör innehåller inga andra operatörer (uppdragsoperatör, proceduranrop, ...). börja a: = 11; b: = a * a; Skriv (a, b) avsluta;

5 börjar sedan X: = X + 5; Y: = 1 ände annars Y: = -1; Den villkorliga operatorn används för att programmera grenar, dvs. situationer då det under vissa förhållanden blir nödvändigt att utföra "title =" (! LANG: 4 Kap. 6. KONTROLLSTRUKTURER Villkorssats om K> 5 börjar då X: = X + 5; Y: = 1 slut annars Y: = - 1; Den villkorliga operatören används för att programmera grenar, det vill säga situationer då det blir nödvändigt, under vissa förutsättningar, att utföra" class="link_thumb"> 4 !} 4 kap. 6. KONTROLLSTRUKTURER Villkorligt uttalande om K> 5 börjar då X: = X + 5; Y: = 1 ände annars Y: = -1; Den villkorliga operatorn används för att programmera grenar, dvs. situationer då det under vissa förutsättningar blir nödvändigt att utföra olika åtgärder. Den villkorliga operatorn har strukturen: om booleskt uttryck så operatorn else operator Endast en operator kan skrivas i varje gren. 5 börjar sedan X: = X + 5; Y: = 1 ände annars Y: = -1; Den villkorliga operatorn används för att programmera grenar, dvs. situationer när det under vissa förhållanden blir nödvändigt att utföra "> 5 börjar sedan X: = X + 5; Y: = 1 slut annars Y: = -1; Den villkorliga operatorn används för att programmera förgreningar, d.v.s. situationer när det är nödvändigt när vissa villkor för att utföra olika åtgärder Den villkorliga operatorn har strukturen: om logiskt uttryck så operatorn else operatorn I varje gren kan endast en operator skrivas. "> 5 börjar sedan X: = X + 5; Y: = 1 ände annars Y: = -1; Den villkorliga operatorn används för att programmera grenar, dvs. situationer då det under vissa förhållanden blir nödvändigt att utföra "title =" (! LANG: 4 Kap. 6. KONTROLLSTRUKTURER Villkorssats om K> 5 börjar då X: = X + 5; Y: = 1 slut annars Y: = - 1; Den villkorliga operatören används för att programmera grenar, det vill säga situationer då det blir nödvändigt, under vissa förutsättningar, att utföra"> title="4 kap. 6. KONTROLLSTRUKTURER Villkorligt uttalande om K> 5 börjar då X: = X + 5; Y: = 1 ände annars Y: = -1; Den villkorliga operatorn används för att programmera grenar, dvs. situationer då det under vissa förutsättningar blir nödvändigt att utföra"> !}

6 kap. 6. KONTROLLSTRUKTURER Flervalsoperator Valoperatorn används för att implementera flera alternativa alternativ för åtgärder, som var och en motsvarar sina egna värden för någon parameter. kasusuttryck av konstant / range else-satser: slutsats; Värdet och måste också vara av en av ordningstyperna (förutom LongInt). Beroende på värdet väljs operatorn, som föregås av en urvalskonstant lika med det beräknade värdet (alternativet är operatorerna efter det andra). Konstanta värden måste vara unika i varje uppsättning, dvs. de kan endast förekomma i en variant.

7 kap. 6. KONTROLLSTRUKTURER fall I av (I: Ord) 1: X: = X +1; 2,3: X: = X+2; 4..9: börja Skriv (X); X: = X + 3 (mb ";") slut (mb ";") annars X: = X * X; Writeln (X) (mb ";") slut;

8 kap. 6. KONTROLLSTRUKTURER "While" loop-operator (med förutsättning) medan villkorligt uttryck do-operator (loop body) efter do-funktionsordet kommer att exekveras cykliskt så länge som det logiska villkoret är uppfyllt, dvs. medan värdet är True. För att en loop ska ha en chans att någonsin avslutas måste innehållet i dess kropp påverka loopens tillstånd. Villkoret måste bestå av giltiga uttryck och värden som definieras före den första exekveringen av loopkroppen. VarF, N: LongInt; (beräkning 10 Begin F:= 1; N:= 1; while N !}

9 kap. 6. KONTROLLSTRUKTURER "Before" loopoperator (med postcondition) Utsagorna mellan orden upprepas och tills bildar slingans kropp. Om det är sant, slutar slingan. Slinga "Medan" - "medan villkoret är sant, kör kroppens uttalanden." Slinga "Före" - "kör slingans kropp tills villkoret blir sant"; upprepa tills False; upprepa t-operatorn tills villkorligt uttryck;

10 kap. 6. KONTROLLSTRUKTURER En loopoperator med en parameter (loop över en räknare) är en variabel av ordningstyp, värdena och måste vara av samma typ. Värdet ändras i stigande (när man använder det reserverade ordet till) eller fallande (nedåt) ordning från värde till värde med ett konstant steg lika med intervallet mellan de två närmaste värdena i typen som det tillhör (för heltalstyper, detta är 1, för teckentyper, från ett tecken till ett annat när du ökar koden med 1, etc.). For loopar kan kapslas om ingen av de kapslade looparna använder eller modifierar variabler - parametrar för de yttre looparna. Används för att organisera "strikta" cykler som måste göras ett visst antal gånger. för slingparametern: = uttryck 1 till uttryck 2 gör downto-satsen

12 kap. 6. KONTROLLSTRUKTURER Ovillkorlig filialoperatör En etikett kan förekomma var som helst i programmet mellan operatörer och separeras från den andra operatören med ett kolon ":". Omfattningen av ovillkorliga hoppoperatörer är strikt lokaliserad. Övergångar av goto-operatören mellan procedurer, såväl som mellan huvudblocket och en procedur, är förbjudna. Den ovillkorliga hoppoperatören överför exekveringskontrollen till den programplats som anges med hjälp av etiketten (det är "överflödigt" ur teorin om strukturerad programmering). goto label Etikett osignerat heltal; etikettidentifierare, syntaxdiagram och: LabelL1, L2; Börja ... gå till L1; ... L1: gå till L2; ... L2: Sluta.

13 kap. 6. KONTROLLSTRUKTURER Ovillkorliga hoppprocedurer Icke-strukturella kontrollöverföringsprocedurer vid arbete med cykliska strukturer: Break - implementerar en utgång från en slinga av vilken typ som helst; Fortsätt - flyttar till nästa iteration av loopen och ignorerar de påståenden som återstår till slutet av loopkroppen. Exit- och stoppprocedurer är speciellt utformade för att avsluta programblock (procedurer, funktioner, huvudprogramblock). Halt () avslutar programmet genom att returnera den angivna utgångskoden till operativsystemet. Exit avslutar subrutinen villkorslöst. Om proceduren används i huvudblocket, utförs den på samma sätt som Halt.

Loop-satser Loop-satser används för att organisera repetitiva beräkningar. För att organisera en loop behövs en variabel som kallas loopparameter eller en loopkontrollvariabel. Varje cykel består av: initiala inställningar eller block av initialisering av cykelparametern; loopens kropp, det vill säga de satser som exekveras flera gånger; cykelparametermodifieringsblock; kontrollerar utgångsvillkoret från slingan, som kan placeras antingen före slingans kropp, då talar de om en slinga med en förutsättning eller efter kroppen ...

Dela ditt arbete på sociala medier

Om detta verk inte passade dig längst ner på sidan finns en lista över liknande verk. Du kan också använda sökknappen

Ämne 2 Kontrolloperatörer

2.1 Grundläggande konstruktioner av strukturerad programmering

V programmeringsteoridet har bevisats att ett program för att lösa ett problem av vilken komplexitet som helst kan bestå av endast tre strukturer, kallade sekvensering, förgrening och looping. De kallas grundläggande designstrukturerad programmering.

Följande är en konstruktion som är en sekventiell exekvering av två eller flera operatorer (enkel eller sammansatt).

Förgrening specificerar utförandet av antingen den ena eller andra operatören, beroende på uppfyllelsen av ett villkor.

Cykel anger flera exekveringar av uttalandet.

En egenskap hos de grundläggande strukturerna är att någon av dem bara har en ingång och en utgång, så strukturerna kan kapslas in i varandra på ett godtyckligt sätt.

Figur 2.1 - Grundläggande konstruktioner av strukturerad programmering

Syftet med att använda grundläggande konstruktioner är att få ett program med en enkel struktur. Ett sådant program är lätt att läsa, felsöka och vid behov göra ändringar i det.

Varje uttryck som slutar med semikolon behandlas som ett uttalande vars exekvering består av att utvärdera uttrycket.

2.2 Relationella och logiska operationer

Relationsverksamhet(<, <=, >,> =, ==,! =) jämför den första operand med den andra. Operander kan vara av aritmetisk typ eller pekare. Resultatet av operationen är värdet sant eller falskt ... Jämställdhet och ojämlikhet har lägre företräde än andra jämförelser. Till exempel: x> = 0, y! = 10, z == 0.

UPPMÄRKSAMHET! Notera skillnaden mellan likhetstestet (== ), vars resultat är sant eller falskt , och tilldelningsoperationen (= ), vilket resulterar i värdet som tilldelas den vänstra operanden.

Logiska operationer(&&, ||, ^). Operander logiska operationer OCH (&&), ELLER (|| ), EXKLUSIVT ELLER (^ ) måste vara av en typ som kan konverteras till en typ bool, med operanderna i en operation kan vara av olika slag. Resultatet av operationen är sant eller falskt.

Resultatet av operationen boolesk AND är sant endast om båda operanderna är giltiga Sann ... Resultatet av operationen logiskt ELLER är sant om minst en av operanderna har ett värde Sann ... Resultatet av operationenlogiskt EXKLUSIVT ELLERär sant om en av operanderna är det sant och det andra är falskt. Logisk negation ( !) resulterar i värdet false om operanden är sann, och sant om operanden är falsk. Operand kan vara av aritmetisk typ. I detta fall,implicit konvertering att skriva bool ... Logiska operationer utförs från vänster till höger. Om värdet på den första operanden är tillräckligt för att bestämma resultatet av operationen, den andra operanden utvärderas inte.

Tabell över resultat av operationer OCH, ELLER, EXKLUSIVT ELLER, INTE

(A och B är operander)

		A && B	A || B	A ^ B

Exempel på uttryck med logiska operationer:

x> 0 && y<=10

(a< -1 && b >0) || c! = 100

Villkorlig drift(? :). Detta är den enda i C++ ternär operation (har tre operander), dess format är:

operand_1? operand_2: operand_3

Operander beräknas från vänster till höger. Resultatet av att utvärdera den första operanden måste vara av en typ som kan konverteras till en typ bool ... Om resultatet är Sann , då blir resultatet av exekveringen av hela den villkorliga operationen värdet av den andra operanden, annars värdet på den tredje operanden. Deras typer kan vara olika.

Exempel: anta att något heltalsvärde krävs för att öka med 1 om dess värde inte överstiger n , annars tog det värdet 1. Detta kan skrivas med en enda kodrad:

i = (i< n) ? i + 1: 1;

2.3 Filialoperatörer. Villkorligt om uttalande

Villkorligt om uttalandeanvänds för att förgrena beräkningsprocessen i två riktningar. Algoritmdiagram operatören visas i figur 2.1. Operatörsformat:

if (uttryck) statement_1; [annat uttalande_2;]

Först utvärderas ett uttryck, som kan vara av en aritmetisk typ eller en pekartyp. Om det inte är lika med noll, dvs. lika Sann , sedan körs den första satsen, annars den andra. Därefter överförs kontrollen till operatören efter den villkorade. En av grenarna kan saknas.

Om mer än en sats behöver exekveras på en gren, måste de vara inneslutna i ett block. Ett block kan innehålla vilka satser som helst, inklusive beskrivningar och andra villkorliga satser.

Exempel:

Om en< 0) b = 1;

Om en< b && (a >d || a == 0)) B++; annan (b * = a; a = 0;)

Om en< b) Om en< c ) M = a; annan M = c; annan Om (b< c ) M = b; annan m = c;

Exempel 1 gren saknas annan ... En sådan konstruktion kallas "operatörshopp" eftersom uppdrag exekveras eller hoppas över beroende på om villkoret är uppfyllt.

Om du behöver kontrollera flera förhållanden kombineras de av skyltarlogiska operationer... Till exempel uttrycket i exempel 2 kommer att vara sant om villkoret a< b и одно из условий в скобках. Если опустить внутренние скобки, будет выполнено сначала логическое И, а потом – ИЛИ.

Operatör i exempel 3 beräknar det minsta värdet av tre variabler.

Efter operatorsyntax om det bör inte finnas mer än en operatör i dess filialer. Om det finns fler av dem måste de kombineras till ett block med hjälp av lockiga hängslen eller med kommaoperationer (,).

Exempel. Ett skott avlossas mot målet som visas i Figur 3.2. Bestäm antalet poäng.

Figur 3.2 - Mål

#omfatta

int main ()

flyta x, y;

int kol;

Printf ("\ n Ange koordinaterna för skottet ");

Scanf ("% f", & x);

Scanf ("% f", & y);

Om (x * x + y * y< 1)

Kol = 2;

Annan

Om (x * x + y * y< 4)

kol = 1;

annan

kol = 0;

printf ("\ n Poäng:% d", kol);

2.4 Filialoperatörer. Flervalsoperatör växla

Byt uttalandeär avsedd för att förgrena beräkningsprocessen i flera riktningar. Operatörsformat:

switch (uttryck)

Case constant_expression_1: operatorer 1;

Case constant_expression_2: påståenden 2;

...

Case constant_expression_n: påståenden n;

Utlåtandets körning börjar medutvärdera ett uttryck(det måste vara heltal ), och sedan överförs kontrollen fall -label - till operatorer markerade med ett konstant uttryck, vars värde sammanfaller med det beräknade, varefter alla andra grenar exekveras sekventiellt, om utgången från ingen switch är explicit specificerad.

Alla konstanta uttryck måste ha olika betydelser, men vara desammaheltalstyp... Flera etiketter kan följa i rad. Om det inte finns någon matchning exekveras satserna efter ordet standard (och i dess frånvaro överförs kontrollen till nästa switch-sats).

Om i någon av fall -etiketter saknar operatör ha sönder , sedan operatörerna i nästa fall -etikett och så vidare tills operatören hittas någonstans ha sönder.

Exempel (programmet implementerar den enklaste kalkylatorn för 4 åtgärder):

#omfatta

int main ()

int a, b, res;

char op;

printf ("\ n Ange 1:a operanden: ");

scanf ("% d", & a);

printf ("\ n Ange operationstecknet: ");

scanf ("% c", & op);

printf ("\ n Ange den andra operanden: ");

scanf ("% d", & b);

bool f = sant;

Switch (op)

Fall "+": res = a + b; ha sönder;

Fall "-": res = a - b; ha sönder;

Fall "*": res = a * b; ha sönder;

Fall "/": res = a / b; ha sönder;

standard: printf ("\ n Okänd operation"); f = falskt;

om (f)

printf ("\ n Resultat:% d", res);

Gå ur strömbrytaren görs vanligtvis med operatörer bryta eller återvända.

2.5 Slingangivelser

Slingoperatörer används för att organisera repetitiva beräkningar.

För att organisera loopen kallas en variabel loop parameter eller loopkontrollvariabel... Varje cykel består av:

• initiala inställningar eller initieringsblock för loopparameter;
• slingkroppar , det vill säga de uttalanden som körs flera gånger;
• cykelparametermodifieringsblock;
• kontrollera utgångsläget från en slinga som kan placeras antingen innan slingkroppar (då pratar de om cykeln med en förutsättning), eller efter slingans kropp (en loop med ett eftervillkor).

Figur 3.3 - Två typer av cykler

Ett pass av slingan kallas iteration ... Heltalsloopparametrar som ändras med ett heltal på varje iterationer kallas cykelräknare.

Du kan inte överföra kontroll från utsidan till insidan av slingan. Utgången från slingan är möjlig både när utgångsvillkoret är uppfyllt och av operatörer bryta, återvända eller villkorslöst hopp gå till.

2.6 Slinga med förutsättning (medan)

Slinga med förutsättning implementerar algoritmschemat

while (uttrycks)operator;

Till exempel:

Uttrycket definierar upprepningsvillkoret slingkroppar representeras av en enkel eller sammansatt operator. Om uttrycket inte är 0 (true) exekveras loopsatsen och sedan utvärderas uttrycket igen. Om uttrycket vid den första kontrollen är 0 (falskt), kommer loopen inte att exekveras ens en gång. Uttryckstypen måste vara aritmetisk eller konverterbar.

funktionsvärden y = x 2+1 i det angivna intervallet):

#omfatta

int main ()

flyta Xn, Xk, Dx;

flyta X = Xn; // initiala inställningar för cykeln

Medan (X<= Xk) //проверка условия выхода

Printf ("\ n% 5,2f% 5,2f", X, X * X + 1); // kropp

X+ = Dx; //modifiering

2.7 Slinga med postcondition (gör medan)

Slinga med postcondition implementerar algoritmschemat , ges nedan, och ser ut så här:

gör uttalande medan uttryck;

En enkel ellersammansatt operatörsom komponerar slingans kropp, och sedan utvärderas uttrycket. Om det inte är lika med 0 (sant) exekveras slingans kropp igen, och så vidare, tills uttrycket blir lika med noll (falskt) eller någotöverföringsoperatör... Uttryckstypen måste vara aritmetisk eller konverterbar.

Exempel (programmet kontrollerar inmatningen):

#omfatta

int main ()

röding svar;

printf ("\ n Köp en elefant!");

scanf ("% c", & svar);

while (svar! = "y");

2,8 för slinga

För slinga implementerar algoritmschemat nedan och har formen:

för (initieringsblock; tillståndskontrollblock; modifieringsblock)

Slingkropp;

Exempel:

Initialiseringsblockanvänds för att deklarera och initiera de värden som används i slingan. I den här delen kan du skriva flera operatorer, separerade med kommatecken.

Tillståndskontrollblockdefinierar villkoret för slingexekveringen: om det inte är lika med 0 (true), exekveras slingan.

Modifieringsblockutförs efter varje iterationer och tjänar vanligtvis till att ändra parametrarna för cykeln. I delen av ändringar kan du skriva flera operatorer separerade med kommatecken.

Enkel eller sammansatt operatör representeraröglekropp ... Vilken del av operatören som helst för kan utelämnas (men lämna semikolon på plats!). I vilken del som helst kan du använda kommaoperationen (sekventiell beräkning), till exempel:

för (int i = 1, s = 0; i<= 100; i++)

S+ = i; // summan av siffror från 1 till 100

Exempel (programmet skriver ut tabellenfunktionsvärden y = x 2 +1 i det angivna intervallet):

#omfatta

int main ()

flyta Xn, Xk, Dx;

printf ("Ange intervall och steg för att ändra argumentet:");

scanf ("% f% f% f", & Xn, & Xk, & Dx);

För (flytande X = Xn; X<= Xk; X += Dx)

Printf ("\ n% 5,2f% 5,2f", X, X * X + 1);

2.9 Kapslade slingor

Var och en av slingoperatorerna kan kapslas i valfri ordning. Slingornas häckningsdjup är inte begränsat. Det bestäms endast av algoritmen för problemet som löses.

Nedan är ett exempel på kapslade slingor för

Detta programutdrag fungerar enligt följande. För ett värde för den yttre slingparametern i (till exempel i = 1 ) parametern för den inre slingan j varierar i intervallet från lägsta till maxvärde (från 1 till M ). Först då parametern i ökar med ett. Således kommer slingans kropp att exekveras N * M gånger.

Andra varianter av kapslade slingor fungerar på liknande sätt: parametern för den yttre slingan ändras långsamt och den inre ändras snabbt. Det rekommenderas att behärska dem själv. För att göra detta, infoga hela slingans kropp istället för blocket för den inre slingalgoritmen.

2.10 Operatörer för kontrollöverföring

I C++ det finns fem operatorer som ändrar den naturliga beräkningsordningen:

• loop exit-satsen och bryta brytare;
• hoppoperatör till nästa loop iteration fortsätt;
• funktion return-sats lämna tillbaka;
• operatör villkorslöst hopp gå till;
• kastoperatör kasta.

Bryt uttalande används för omedelbar uppsägning loop uttalande eller switch ... Utförande överförs till nästa påstående efter det avslutade.

Låt oss överväga dess användning med ett exempel.öppen iterativ loop för ... Till exempel att beräkna summan av siffror från 1 till 100.

int i = 1, summa = 0;

för (;;)

Om (i> 100) bryta;

summa + = i;

i ++;

Gå till nästa iterationsoperator loop fortsätt hoppar över alla återstående påståenden till slutet slingkroppar , och överför kontroll för att modifiera parametrarna för cykeln (i fallet med en cykel för ) och början på nästa iterationer.

Låt oss överväga dess användning genom exemplet att beräkna summan 1 / x om x varierar i intervallet [-5, 5].

#omfatta

int main ()

float X, Sum = 0;

för (X = -5; X<= 5; X++)

Om (X == 0)

Fortsätta;

Summa = Summa + 1 / X;

Printf ("\ n Summa =% f", Summa);

Funktionsreturoperatör lämna tillbaka avslutar funktionen och överför kontrollen till den punkt där den anropades. Vi kommer att täcka det tillsammans med funktionerna i det relaterade ämnet.

Ovillkorlig hoppoperatör goto har formatet:

goto etikett;

Kroppen av samma funktion måste innehålla exakt en konstruktion av formen:

etikett: operatör;

Gå till uttalande överför kontrollen till den markerade operatören. Märka Är en vanlig identifierare,omfattningvilket är den funktion i kroppen som den förekommer.

Användande ovillkorlig hoppoperatörmotiverat i två fall:

• tvångsavsluta ner programtexten från flerakapslade slingoreller omkopplare;
• övergång från flera platser i en funktion till en (till exempel om du alltid behöver utföra någon åtgärd innan du avslutar en funktion).

I andra fall finns det mer lämpliga sätt att spela in vilken algoritm som helst.

En exceptionell situation(eller bara ett undantag ) genereras antingen av programmeraren som använder operatören kasta eller själva körtiden. Detta händer när ett fel uppstår under programkörning, såsom division med noll eller svämma över. Mekanism undantagshanteringimplementeras i C++ , låter dig svara på sådana fel och därmed undvika onormal avslutning av programmet. Det kommer att behandlas i ett annat ämne.

Andra liknande verk som kan intressera dig. Wshm>
2784.		Tillstånd och urvalsoperatörer	16 KB
	Om tillståndsoperatör. Därför kan du redan nu skriva följande uppdragssatser: Koren: = Sqrtxy; Modul: = bsxy. För att implementera sådana villkorliga hopp i Pascal-språket används If- och Else-satserna, liksom den ovillkorliga hoppoperatorn Goto. Tänk på If-påståendet.
2750.		Skriv och skriv uttalanden	12,34 KB
	Skriv eng. WriteLn-operatorn utför samma åtgärd, men eftersom den också har slutet Ln-raden eng. Allmän vy: Skriv lista med uttryck WriteLn lista med uttryck Write- och WriteLn-procedurerna används inte bara för att visa resultatet, utan också för att visa olika meddelanden eller förfrågningar.
6706.		Structured Query Language - SQL: Historik, standarder, grundläggande språkoperatörer	12,1 kB
	Det strukturerade frågespråket SQL är baserat på relationskalkylen med variabla tupler. SQL-språket är utformat för att utföra operationer på tabeller, skapa, radera, ändra struktur och på data i tabeller, urval, ändring, tillägg och radering, samt vissa relaterade operationer. SQL är ett icke-procedurspråk och innehåller inga satser för att styra organisationen av inmatnings-/utgångsrutiner etc.

Den enklaste strukturen är följande. Det kan representeras så här:

Modulerna "a" och "b" kan innehålla antingen en operatör eller valfritt antal strukturer som följer efter varandra, inkl. och diskuteras nedan.

Gaffelstrukturen (om - då - annars) tjänar till att välja ett av två möjliga sätt att exekvera algoritmen. Det är baserat på verifiering. Gaffeln ser ut så här:

OM-DÅ-ANNE-strukturer kan nästlas i varandra, till exempel på detta sätt.

Antalet kapslade strukturer begränsas av datorns kapacitet och programvaran som är installerad på den. Detta belopp anges vanligtvis i språkbeskrivningen. För att säkerställa läsbarheten kan de kapslade strukturerna ersättas med rektanglar, och blockschemat för varje rektangel kan visas i detalj på ett separat blad. I allmänhet är alla blockscheman eller program bättre läsbara om de är helt placerade på en sida.

Strukturen som visas i det sista blockschemat låter dig välja en av tre vägar. På liknande sätt, med hjälp av kapslade strukturer, kan du organisera valet av en av valfritt antal sökvägar. Eftersom behovet av detta dyker upp ganska ofta har en speciell struktur införts - ett val, som ser ut så här

Här betecknar symbolen "P" fortfarande villkoret, baserat på uppfyllelsen av vilken en av de möjliga vägarna som väljs.

När man utvecklar algoritmer är det ofta extremt viktigt att upprepa en operation eller grupp av operationer. För att visa sådana fragment av algoritmen tillhandahålls speciella strukturer - cykler. Οʜᴎ Det finns tre typer: bye-loop, by-loop och by-count loop. Cykelns arbete skildras av följande flödesschema.

Innan den första exekveringen av blocket av satser, som vanligtvis kallas loopens kropp, kontrolleras villkoret "P" och, om det är sant, exekveras slingans kropp, och kontrollen återgår till början av slingan. slinga. Sedan kontrolleras tillståndet igen, och så vidare tills loopvillkoret blir falskt. I detta fall avslutas exekveringen av cykeln. Det utförs så länge som villkoret är uppfyllt.

Cycle-do är organiserat annorlunda.

Verifieringen av slingtillståndets sanning utförs efter exekveringen av slingkroppen, och utgången från den utförs när villkoret är sant. Τᴀᴋᴎᴍ ᴏϬᴩᴀᴈᴏᴍ, slingans kropp exekveras alltid en gång, till skillnad från cykla hejdå, som inte exekveras ens en gång om loopvillkoret inte är uppfyllt.

Den tredje typen av cykel är en motcykel. Det används i fall där det är extremt viktigt att upprepa slingans kropp ett visst antal gånger. Dess struktur kan avbildas av följande blockschema.

Det visar att denna cykel är ett specialfall cykla hejdå, men eftersom detta fall ofta påträffas, i programmeringsspråk, i synnerhet i VBA, introduceras en speciell operatör för att beskriva en slinga med en räknare.
Upplagt på ref.rf
Av denna anledning har vi tilldelat en speciell struktur för denna cykel.

Som ett exempel, överväg ett blockschema för att hitta det maximala elementet i en tabell med N tal.

Här är Max det maximala antalet, i är numret på talet i tabellen med nummer X, N är storleken på tabellen. Blockdiagrammet innehåller följande strukturella konstruktioner: follow, loop-bye, som exekveras tills numret på det markerade numret är mindre än eller lika med tabellens storlek, och en gaffel, där en väg väljs som innehåller tilldelning av det aktuella numret från tabellen till variabeln Max, i så fall om denna variabel är mindre än det aktuella numret.

De huvudsakliga styrande strukturerna är begrepp och typer. Klassificering och funktioner i kategorin "Huvudkontrollstrukturer" 2017, 2018.