Hallo en welkom. We beginnen een nieuwe sectie,
en we gaan het hebben over controle. Flow control flow
houdt zich in principe bezig met voorwaardelijke
statements, statements, if-statements en het nemen van beslissingen in je programma,
evenals herhalende code, wat lussen is.
Dit is dus een belangrijke sectie en dit zijn fundamentele programmeertechnieken die in
de meeste talen worden gebruikt. We gaan het hebben over hoe ze specifiek zijn voor c.
Maar om je een overzicht
te geven, voordat we beginnen te praten over syntaxis en uitwijken naar voorbeelden.
Ik wil je vertellen wat control flow betekent in termen van een programma.
Dus de instructies in je bronbestanden worden over het algemeen van boven naar beneden uitgevoerd in de
volgorde waarin ze verschijnen, dat wordt sequentieel genoemd.
Je hebt al deze uitspraken. We hebben geleerd over uitdrukkingen binnen
of buiten de uitspraken, maar je gaat van het begin tot het einde.
Dat is wat we tot nu toe hebben geleerd.
We hebben nog nooit gesprongen. We hebben nog nooit iets gedaan waarbij we dingen automatisch herhaalden,
van begin tot eind.
Controlestroominstructies zullen deze uitvoeringsstroom echter doorbreken door zaken toe te
voegen als besluitvorming, in wezen vragen stellen,
code herhalen, lussen en vertakkingen.
Hierdoor kan uw programma bepaalde
codeblokken voorwaardelijk uitvoeren.
Dus het zal niet alleen beginnen aan de bovenkant van de hoofdfunctie, ga naar de onderkant.
Je kunt nu heen en weer gaan.
Misschien vertakt u zich of springt u in
en uit codeblokken. Dus de code
in het programma wordt een beetje ingewikkelder.
Dus dingen waar we het over hebben in termen
van beslissingen over controlestromen. Dit is waar je in
wezen een vraag stelt en dan krijg je een antwoord, goed of fout antwoord.
Dingen die ondersteund worden in c zijn de if decision statement en dan
heb je if else en dan heb
je ook nog een switch statement en een go to statement.
Dit zijn allemaal uitspraken die besluiten nemen. Ga naar, ik heb het hier ingevuld
omdat het bestaat in c.
Je zult het waarschijnlijk niet willen gebruiken. Ik zal er kort over praten.
Het is eigenlijk gewoon iets dat de programmeur hard codeert op een label.
We hebben ook looping-instructies die worden ondersteund in c-taal.
Het trefwoord 4, het trefwoord while en het trefwoord do while.
Dat zijn de drie soorten lussen. Lussen herhalen de code.
En dan zijn vertakkingsverklaringen vergelijkbaar. Ze worden meestal
gebruikt in een lus of in een beslissing.
Dit zijn zaken als de doorlopende terugkeer.
Dus we gaan ons in deze sectie concentreren op specifieke colleges voor beslissing
versus looping en dan ook een beetje praten over breken.
Wederom een zeer belangrijke lezing.
Besluitvorming dus. Wat betekent dit echt in een programma?
Nogmaals, tot nu toe hebben we in feite variabelen gemaakt,
gedeclareerd en berekeningen uitgevoerd.
Maar we hebben nooit echt specifieke logische beslissingen genomen.
Dus een besluitvormingsconcept is dat het vereist dat de programmeur een
of meer voorwaarden specificeert die door het programma moeten worden
geëvalueerd of getest.
Wat er in wezen gebeurt, is dat je een vraag stelt in het programma, dat is de logica.
En als de voorwaarde of het antwoord op die vraag
waar is, dan ga je wat
code uitvoeren, wat statements. Als het antwoord op die
vraag onwaar is, kunt u andere uitspraken doen of helemaal niets doen.
Dus hier is ons kleine gegevensstroomdiagram dat je het concept van besluitvorming
in een programma laat zien. U heeft deze aandoening.
Afhankelijk van het antwoord op die voorwaarde, of het waar of niet
waar is, ga je code uitvoeren of niet uitvoeren.
Het hangt er van af. Het wordt een beetje ingewikkelder, maar dit
is de basisstructuur van hoe je beslissingen kunt nemen in je programma.
En wat dit betekent, zit in je broncode, je kunt wat code overslaan, afhankelijk van het antwoord
op een vraag, afhankelijk van of
het waar of niet waar is.
Dus de statements die ondersteund worden door c zijn de if statement.
Het if-statement heeft een speciaal sleutelwoord genaamd.
Als we hier in detail over gaan praten en
voorbeelden geven, maar deze verklaring gaat in wezen de vraag stellen.
Tussen haakjes staat een Booleaanse uitdrukking.
We weten wat Booleaanse uitdrukkingen zijn.
In principe kunnen ze een waar of
onwaar waarde retourneren, een instructie
die een waar of onwaar waarde retourneert, behalve in zijn
expressie, en het kan een of meer instructies in de hoofdtekst hebben, de if-instructie.
Je hebt ook een if else.
Dit is dus een if-statement dat kan worden gevolgd door een optionele else.
Als het waar is, doe dit dan. Als het onwaar is, doe dan iets anders.
En dan hebben we geneste if-statements.
Dit is wanneer je een if-statement in een ander if-statement hebt.
Het kan dus zijn dat u meerdere vragen stelt.
En nogmaals, dit wordt gedetailleerd met
specifieke voorbeelden en syntaxis. Ik probeer op dit moment alleen een overzicht te geven.
Wat betreft herhalende code, wat weer een ander controlestroommechanisme is, omdat
je niet langer sequentieel gaat.
Met herhalende code ga je dezelfde code een aantal keer uitvoeren.
Er kan zich dus een situatie voordoen waarin u een codeblok meerdere keren moet uitvoeren,
de instructies worden opeenvolgend uitgevoerd, de
eerste instructie in een functie wordt eerst uitgevoerd, gevolgd door de tweede enzovoort.
Het hangt er vanaf. Dit is een soort blok van de code van de lusbody.
Dus een lusinstructie stelt ons in staat om een instructie of een groep instructies
meerdere keren uit te voeren zonder dat elke instructie zo vaak
hoeft te worden herhaald.
Lusbesturingsinstructies veranderen de uitvoering van de normale volgorde.
Wanneer de uitvoering het bereik
verlaat, worden alle automatische objecten die in dat bereik zijn gemaakt, vernietigd.
Dit gaat dus over het bereik met betrekking
tot variabelen en in feite zeggen we dat wanneer je je in de
body van een lus bevindt en je
lokale variabelen hebt, je ze niet buiten de lus kunt benaderen.
Een lus wordt een oneindige lus als een voorwaarde nooit onwaar wordt.
En dat betekent dat je programma vastloopt, omdat je de code keer op
keer zult uitvoeren, en je zult nooit echt afsluiten.
Soms moet je dat ook echt doen.
Als je iets in de gaten houdt of ergens naar luistert.
En de manier om dat daadwerkelijk te implementeren en te zien, is dat je hoogstwaarschijnlijk een for-lus zou gebruiken,
maar je zou ook een while-lus kunnen gebruiken.
We zullen het hebben over oneindige lussen en waarom je ze misschien nodig hebt en wat dat betekent
in een latere lezing.
Dus de feitelijke gegevensstroom van een lus ziet er ongeveer zo uit.
Je vinkt een voorwaarde aan. En als de voorwaarde waar
is, voer je wat code uit en dan blijf je het steeds opnieuw en opnieuw
doen totdat de voorwaarde evalueert naar onwaar.
Zodra de voorwaarde onwaar is, verlaat u de lus.
De lussen die ondersteund worden in c zijn de while-lus, de for-lus en de do while-lus.
Speciale trefwoorden.
De while-lus herhaalt een instructie of een groep instructies
terwijl een bepaalde voorwaarde waar is. De voorwaarde staat dus helemaal bovenaan tussen de wilde haakjes.
Voorwaarde is test aan de bovenkant voordat het luslichaam uitvoert.
Ook al zijn er drie verschillende soorten loops die worden ondersteund, u kunt de
ene meer gebruiken dan de andere. Hoewel de for-lussen vrijwel hetzelfde zijn, hebben
ze alleen een andere syntaxis. En je kunt meer dingen anders doen.
De do while-lus is anders omdat je de
test eigenlijk onderaan hebt. Dus je bent er altijd zeker van dat je de lus minstens
één keer uitvoert, de body van de lus.
Maar nogmaals, we zullen het over deze dingen hebben. For loop, speciaal sleutelwoord, voert reeksinstructies
meerdere keren uit. Het heeft
gewoon een eenvoudigere syntaxis. U kunt de regelvariabele lus en de voorwaarden
allemaal in één instructie initialiseren.
En dan is de doe een while-lus, zoals ik al
zei, een beetje anders omdat het een post-test-lus is, een exit-controlelus, wat betekent
dat je altijd gegarandeerd minstens één keer in de body van de lus komt.
En we zullen het ook hebben over geneste lussen. Dit is weer gewoon een lus
in een lus, net zoals een geneste voor if-instructie een if-instructie in een
if-instructie is, hetzelfde geldt voor lussen, en we zullen zien hoe
dit soms nodig is en dingen kan compliceren, maar het
is essentieel voor programmeren.
Een mooi snel overzicht van de verschillende controlestroommechanismen, hoog
niveau en dan enkele van de sleutelwoorden die door c worden
ondersteund om dit daadwerkelijk te implementeren.
Laten we nu verder gaan en enkele voorbeelden geven en beginnen te praten over besluitvorming.
Dank u.