Structuur van een consoleprogramma in c. Structuur van een eenvoudig programma

Fig.1 Programmastructuur in C-taal.

Interne programmastructuur

Een uitvoerbaar C-programma bestaat uit 4 delen: het opdrachtgebied, het statische gegevensgebied, het dynamische gegevensgebied en het stapelgebied. zie Afb.2.

1. Het commandogebied bevat machineopdrachten; instructies die de microprocessor moet uitvoeren.

2. Statisch gegevensgebied voor het opslaan van variabelen waarmee het programma werkt;

3. Dynamisch gegevensgebied voor het opslaan van aanvullende gegevens die verschijnen tijdens de werking van het programma (bijvoorbeeld tijdelijke variabelen).

4. De stapel wordt gebruikt om tijdelijk gegevens op te slaan en adressen van functies terug te sturen.

functie lichaam/*functietekst*/

printf(" Hallo wereld!");

1e lijn – richtlijn die het headerbestand bevat standaard I/O. Er zijn weinig operators in C, maar er is een bibliotheek met functies. Om ze te gebruiken moet je ze verbinden, wat de richtlijn doet: de eerste regel van het programma. Het #-symbool geeft aan dat de tekenreeks moet worden verwerkt door de C-taalpreprocessor.

2e lijn - Naam belangrijkste functie voornaamst(), retourneert deze functie geen parameters (ik zal hier later over praten). Een C-programma heeft altijd een functie voornaamst(). De uitvoering van het programma begint ermee.

3e lijn – het begin van de functiebody. () definieer de body van de functie (in Pascal zijn dit begin en einde)

4e lijn – een commentaar, het is niet samengesteld, maar legt alleen uit wat er wordt gedaan.

5e regel – bibliotheekfunctie – afdruk op het scherm, de uitdrukking tussen haakjes op deze regel is een functieparameter en wordt altijd tussen aanhalingstekens geplaatst.

; - dit is een teken van de C-operator, het maakt deel uit van de operator en niet van een operatorscheidingsteken, zoals in Pascal.

Tips om een ​​programma leesbaar te maken:

1) Kies betekenisvolle namen

2) Gebruik opmerkingen

3) Gebruik lege regels om het ene deel van een functie van het andere te scheiden

4) Plaats elke uitspraak op een andere regel.

BASISELEMENTEN VAN DE C-TAAL

Laten we eens overwegen vereiste elementen, met behulp waarvan een C-programma moet worden ontworpen:

1. Opmerkingen – gebruikt om het programma te documenteren. Elk programma moet commentaar bevatten: welk algoritme wordt gebruikt, wat het programma doet...

Ø 1 manier: /* Tekst */ - overal in het programma.

Zodra de compiler /**/ tegenkomt, slaat hij deze over. De compiler negeert /* */ omdat deze geen andere taal dan C kan interpreteren. Dat wil zeggen, als u een regel wilt uitsluiten van de compilatie, plaats deze dan in /**/.

Ø Methode 2: als de opmerking groot is, gebruik dan dit type

/* Regel 1 - voor commentaar van elke lengte

lijn 3*/

Ø 3 manier: // - tekst tot het einde van de regel.

2. Identificatie is een naam die aan een object (variabele) wordt toegewezen. Kleine letters en hoofdletters, cijfers en onderstrepingstekens. Kleine letters en hoofdletters zijn verschillend. (Ze verschillen niet in BASIC). Als u een variabele naam, Name of NAME, aanroept, dan zijn dit verschillende variabelen.

Identificatiegegevens beginnen met een letter of een onderstrepingsteken. Bijvoorbeeld _naam. Maar het wordt niet aanbevolen om met _ te beginnen, omdat dit teken wordt gebruikt voor globale namen in de C-taal.

IN moderne programmering vaak gebruikt om identificatiegegevens te maken is de Hongaarse notatie, waarbij bepaalde tekens worden gebruikt om de identificatiecode te karakteriseren, bijvoorbeeld:

b – bytes; ch – teken van één byte;

w – woord; f – vlag;

l – lang woord; fn – functie;

u – niet ondertekend; p – wijzer;

с – teller; d – verschil van twee pre-x

cz – tekenreeks; enz.

3. Functie woorden - dit zijn woorden waarmee bepaalde semantische betekenissen in de taal rigide geassocieerd zijn en die niet voor andere doeleinden kunnen worden gebruikt. Dit zijn de namen van operators, bibliotheekfuncties, preprocessoropdrachten, enzovoort. Deze woorden kunnen niet worden gebruikt om namen te maken voor uw functies, variabelen...

GEGEVENS IN SI-PROGRAMMA

Elk programma werkt met gegevens. Ze zijn in het programma aanwezig in de vorm van variabelen en constanten.

Gegevens die tijdens de uitvoering van het programma kunnen worden gewijzigd of waaraan een waarde kan worden toegewezen, worden aangeroepen variabelen.

Gegevens die op specifieke waarden zijn ingesteld en hun waarden behouden gedurende de hele werking van het programma, worden constanten genoemd.

Constanten

Constanten zijn vaste waarden. De waarde verandert, eenmaal ingesteld, niet meer. Er zijn constanten verschillende soorten. De typen verschillen in het principe van plaatsing in het computergeheugen, en voor een persoon in het type opname. Er worden in C zeven trefwoorden gebruikt om verschillende gegevenstypen aan te duiden: int, long, short, unsigned, char, float, double.

Soorten constanten :

A) Gehele getallen en lange gehele getallen . Ze zijn geschreven in decimale, octale en hexadecimale getalsystemen. Ze kunnen ondertekend of niet-ondertekend zijn.

Decimaal systeem: gehele constanten bezetten 16 bits geheugen, en neem een ​​reeks waarden: -32768 tot +32767 (2 15) . Als de constante geen teken heeft, wordt het bereik verdubbeld: 0 tot 65535(vanwege het feit dat voor het nummer het 15e cijfer – ondertekend – wordt gebruikt). Het achtervoegsel wordt gebruikt om een ​​niet-ondertekend nummer aan te duiden u (niet ondertekend), bijvoorbeeld 123u.

Als het getal groter is dan 40.000, zal de compiler het automatisch omzetten naar een negatief getal, zodat het achtervoegsel u vereist:40000u. In het 123u-voorbeeld maakt het de compiler niet uit of er een achtervoegsel is of niet, aangezien dit nummer in het bereik 32767 ligt.

Lang geheel getal neemt 32 bits , waardebereik

±2147483648 (lang – lang getekend). Als je het achtervoegsel l, dan zullen, ondanks het aantal, 32 bits bezet zijn. Bijvoorbeeld: -5326 l

0 – 4294967295 lang niet ondertekend- (niet ondertekend lang). Het bereik wordt vergroot met de 31e bit. Achtervoegsels gebruikt ul bijv. 32659ul.

Octaal systeem :

Als een getal begint met het cijfer 0, wordt het geïnterpreteerd als een octaal getal

16 bits 0 ¸ 077777

0100000 ¸ 0177777u

32 bits 0200000 ¸ 01777777777l

020000000000 ¸ 037777777777ul

Hexadecimaal systeem :

Als een getal begint met het teken 0x, wordt het geïnterpreteerd als hexadecimaal

16 bits 0x0000 ¸ 0x7FFF

0x8000 ¸ 0xEFFFu

32 bits 0x10000 ¸ 0x7FFFFFFFl

0x80000000 ¸ 0xFFFFFFFFul

B) Echte constanten. Dit zijn drijvende-kommagetallen. Het doet ertoe fractioneel deel. Standaard zijn alle reële constanten van het type met dubbele precisie dubbele . Neemt geheugen in beslag 8 bytes (zelfs als 0,0). Bereik van waarden ±1*10 ±307 , kan ook in wetenschappelijke vorm worden geschreven, bijvoorbeeld: 0,5e+15 of

1,2e-3=1,2*10-8 =0,0012.

U kunt het formaat forceren om enkele precisie te hebben vlot . Het nummer zal duren 4 bytes , wordt het achtervoegsel gebruikt F(5,7 v). Dienovereenkomstig wordt het bereik kleiner ±1*10 ±37

En ook uitgebreide nauwkeurigheid – lang dubbel – 10 bytes . (3,14L)

Het + teken kan worden weggelaten. Het is toegestaan ​​om de komma of het exponentiële deel weg te laten, maar niet beide (.2; 4e16). Je kunt het gedeeltelijke of hele deel achterwege laten, maar niet tegelijkertijd (100.; .8e-5)

c) Symbolische constanten. Dit is een reeks tekens die in een computer worden gebruikt.

Verdeeld in 2 groepen: bedrukt en onbedrukt(controlecodes). Een tekenconstante bevat slechts 1 teken, dat tussen apostrofs moet worden geplaatst en in beslag wordt genomen 1 byte geheugen.

Elk symbool heeft zijn dubbele representatie ASCII-tabel. In het programma worden symbolische constanten ingevoerd enkele aanhalingstekens Tijdens het compileren wordt de numerieke waarde van het symbool uit ASCII in het programma vervangen. Eén teken neemt 1 byte in beslag.

Teken "A" "a" " " "\n"

De code is 65 97 32 10

Hoe hele soort gegevens "A"=0101 8 , 01000001 2 , 41 16 , 65 10 . Het is niet nodig om codes te onthouden.

Besturingscodes beginnen met een \-teken en staan ​​ook tussen apostrofs. De meest voorkomende controlecodes zijn:

\n – ga naar nieuwe regel

\t – tab (verplaatst de cursor met een vaste waarde)

\b – stap terug (één positie terugschuiven)

\r – Carriage Return (terug naar het begin van de regel)

\f – formulierinvoer (papier invoeren op 1 pagina)

\’ - apostrof

\” - aanhalingstekens

De laatste drie karakters kunnen fungeren als symbolische constanten en kunnen ook worden gebruikt in printf-functies() , dus het gebruik ervan als symbolen kan tot een fout leiden. Als we bijvoorbeeld de tekenreeks 'Het teken \ wordt een schuine streep' willen uitvoeren, moet de operator er als volgt uitzien:

printf("Het teken \\ heet een schuine streep");

A) Tekenreeksconstanten - een reeks van 1 of meer tekens bevatten, omsloten door " ". Er wordt 1 byte besteed voor elk teken + 1 byte voor het zogenaamde nulteken - een teken van het einde van de regel. Het nulteken is niet het getal nul, het betekent dat het aantal tekens in de regel (N) 1 byte meer moet zijn (N+1) om het einde van de regel aan te geven (de compiler voegt dit automatisch toe). Bijvoorbeeld: “tekstregel” neemt (13+1) bytes in beslag;

"Wereld" -

Elk programma geschreven in de C-taal bestaat uit een of meer “functies”, de belangrijkste modules waaruit het is samengesteld.

Een voorbeeld van de structuur van een eenvoudig C-programma:

1. Preprocessor-richtlijnen

Onderdeel van de compiler is een programma genaamd preprocessor. De preprocessor werkt voordat het programma vanuit de taal wordt vertaald hoog niveau op machinetaal, waarbij de voorlopige transformatie wordt uitgevoerd. Elke preprocessorrichtlijn begint met een #-teken (cijfer) en beslaat de hele regel. Richtlijnen die niet op de ene regel passen, kunnen op de volgende regel worden voortgezet. Het regelvoortzettingsteken is het backslash-teken (\) in de regel die moet worden voortgezet.

De meest gebruikte richtlijn is het opnemen van een bestand in een programma

# erbij betrekken < naam>

Waar naam– de naam van het bestand dat in de programmatekst is opgenomen.

Deze richtlijn heet vervangingsrichtlijn . Het instrueert de compiler om het bestand op zijn plaats te plaatsen naam. naam kop genoemd. Het bevat verklaringen van gegevens en functies die in het programma worden gebruikt. Neem bijvoorbeeld de richtlijn op in het programma

# erbij betrekken < wiskunde. H>

kunt u standaard wiskundige functies in het programma gebruiken, zoals sin x, cos x, ln x, enz. Hieronder wordt een lijst met standaard wiskundige functies gegeven.

Richtlijn

# erbij betrekken < stdio. H>

maakt het mogelijk om standaard invoer-/uitvoerfuncties in het programma te gebruiken.

Een andere veelgebruikte richtlijn is de definitierichtlijn

#define S1 S2

Waar S1, S2– tekenreeksen.

De preprocessor vindt een reeks tekens in de programmatekst S1 en vervangt deze door de string S2 . Neem bijvoorbeeld de richtlijn in het programma op

# definiëren P afdrukkenf

Hiermee kunt u een letter op het toetsenbord typen P in plaats van het woord afdrukkenf.

Deze vervanging wordt niet uitgevoerd binnen tekststrings (letterlijke waarden), karakterconstanten en commentaar, d.w.z. actie van de richtlijn # definiëren is niet van toepassing op teksten die worden gescheiden door aanhalingstekens, apostrofs en teksten die in commentaar staan.

1. Hoofdfunctie

Elk C-programma moet een functiedeclaratie bevatten voornaamst(), wat de hoofdfunctie wordt genoemd . Normaal gesproken heeft deze functie geen parameters en retourneert deze geen enkele waarde. Om dit feit aan te duiden wordt het woord gebruikt leegte. De regel met de naam van de hoofdfunctie ziet er dus meestal als volgt uit:

leegte hoofd(leegte)

leegte hoofd()

1. Variabelen en arrays

Een array is een groep variabelen van hetzelfde type met een gemeenschappelijke naam. De naam van een variabele of array is een identificatie: een reeks bestaande uit tekens:

a – z, A - Z, 0 – 9,_(onderstrepen),

Bovendien mag het eerste teken geen getal zijn. Kleine letters en hoofdletters Het Latijnse alfabet wordt gezien als verschillende karakters. Functiewoorden in de C-taal kunnen niet worden gebruikt als variabele of arraynaam. De belangrijkste functiewoorden van de C-taal worden gegeven in de bijlage.

De array-elementen onderscheiden zich door hun nummers (indices). De index kan alleen niet-negatieve gehele waarden accepteren. De index wordt geschreven na de arraynaam in vierkante haakjes. Er kunnen meerdere indexen zijn. In dit geval wordt elke index tussen zijn eigen vierkante haken geschreven.

Variabelen en arrays van verschillende typen kunnen in de C-taal worden gebruikt. Elk type gegevens neemt een bepaald aantal bytes geheugen in beslag en kan waarden uit een bepaald bereik aannemen. Het volume van dit geheugen en dienovereenkomstig het bereik van geaccepteerde waarden in verschillende implementaties van de C-taal kan variëren. Het aantal bytes geheugen dat wordt ingenomen door een variabele van een bepaald type voor een specifieke implementatie van de C-taal kan worden bepaald met behulp van de bewerking groottevan(type). U kunt bijvoorbeeld als volgt de hoeveelheid geheugen bepalen die is toegewezen aan een variabele van het type geheel getal:

Deze richtlijnen bespreken drie hoofdtypen variabelen en arrays en bieden typische waarden voor de hoeveelheid bezet geheugen en het bereik van waarden (tabel 1):

Tabel 1

Laten we de typevariabele eens nader bekijken verkoold. Zoals uit de tabel blijkt. 1, typ variabele verkoold neemt één byte geheugen in beslag. Eén byte geheugen kan een geheel getal zonder teken uit het bereik bevatten, of een geheel getal met teken uit het bereik [–128, 127]. Dit nummer is de code voor een van de 256 tekens. Het teken dat overeenkomt met een bepaalde code wordt bepaald door de gebruikte codetabel. Dus de waarde van een variabele zoals verkoold kan worden behandeld als een geheel getal of als een teken waarvan de code gelijk is aan dat getal.

Waaruit bestaat het programma?

Om te beginnen is het de moeite waard om te begrijpen dat een programma niet kan worden gelezen en geschreven als een boek: van kaft tot kaft, van boven naar beneden, regel voor regel. Elk programma bestaat uit afzonderlijke blokken. Het begin van een codeblok in C/C++ wordt aangegeven door een accolade links ( , het einde ervan door een accolade rechts ) .

Er zijn blokken verschillende soorten en welke wanneer zal worden uitgevoerd, hangt af van externe omstandigheden. In het voorbeeld minimaal programma je ziet 2 blokken. In dit voorbeeld worden de blokken aangeroepen het definiëren van een functie. Een functie is slechts een blok code met voornaam, die iemand vervolgens van buitenaf kan gebruiken.

IN in dit geval we hebben 2 functies genaamd setup en loop. Hun aanwezigheid is verplicht in elk C++-programma voor Arduino. Ze mogen niets doen, zoals in ons geval, maar ze moeten wel geschreven worden. Anders krijgt u een foutmelding tijdens de compilatiefase.

Klassieker van het genre: knipperende LED

Laten we nu ons programma aanvullen, zodat er in ieder geval iets gebeurt. Op Arduino is een LED aangesloten op pin 13. Het kan worden gecontroleerd, en dat is wat we zullen doen.

Compileer en download het programma. Je zult zien dat de LED op het bord elke seconde knippert. Laten we uitzoeken waarom deze code elke seconde tot knipperen leidt.

Elke expressie is een opdracht aan de processor om iets te doen. Expressies binnen één blok worden na elkaar uitgevoerd, in strikte volgorde, zonder pauzes of wisselingen. Dat wil zeggen, als we het over één specifiek codeblok hebben, kan dit van boven naar beneden worden gelezen om te begrijpen wat er wordt gedaan.

Laten we nu begrijpen in welke volgorde de blokken zelf worden uitgevoerd, d.w.z. setup- en lusfuncties. Maak je nog geen zorgen over wat specifieke uitdrukkingen betekenen, maar let gewoon op de volgorde.

Zodra de Arduino wordt aangezet, knippert of de RESET-knop wordt ingedrukt, “iets” roept een functie aan opstelling. Dat wil zeggen, het dwingt de expressies erin uit te voeren.

Zodra de installatie is voltooid, roept "iets" onmiddellijk de lusfunctie op.

Zodra de lus is voltooid, roept "iets" de lusfunctie onmiddellijk opnieuw aan, enzovoort tot in het oneindige.

Als we de uitdrukkingen nummeren in volgorde van hoe ze worden uitgevoerd, krijgen we:

Laten we u er nogmaals aan herinneren dat u niet moet proberen het hele programma waar te nemen door van boven naar beneden te lezen. Alleen de inhoud van de blokken wordt van boven naar beneden gelezen. Over het algemeen kunnen we de volgorde van de setup- en lusdeclaraties wijzigen.

Het resultaat zal niets veranderen: na compilatie krijgt u een absoluut gelijkwaardig binair bestand.

Wat expressies doen

Laten we nu proberen te begrijpen waarom het geschreven programma er uiteindelijk voor zorgt dat de LED gaat knipperen.

Zoals je weet kunnen Arduino-pinnen zowel als uitgang als als ingang werken. Als we iets willen besturen, dat wil zeggen een signaal willen afgeven, moeten we de bedieningspin naar de uitgangsstatus schakelen. In ons voorbeeld sturen we de LED op de 13e pin aan, dus van de 13e pin moet voor gebruik een uitgang worden gemaakt.

Dit wordt gedaan door een expressie in de setup-functie:

PinModus(13, UITGANG) ;

Uitdrukkingen kunnen verschillend zijn: rekenkunde, declaraties, definities, conditionals, etc. In dit geval implementeren we in de expressie functie oproep. Herinneren? Wij hebben hun de setup- en loop-functies, die worden aangeroepen door iets dat we "iets" noemden. Dus nu Wij we noemen functies die al ergens zijn geschreven.

Specifiek in onze opstelling noemen we een functie genaamd pinMode. Het stelt de pincode in die is gespecificeerd door het nummer ingestelde modus: in- of uitgang. We geven aan over welke pin en over welke modus we het hebben tussen haakjes, gescheiden door komma's, direct na de functienaam. In ons geval willen we dat de 13e pin als uitvoer fungeert. OUTPUT betekent output, INPUT betekent input.

Kwalificerende waarden zoals 13 en OUTPUT worden aangeroepen functie argumenten. Het is helemaal niet nodig dat alle functies 2 argumenten moeten hebben. Hoeveel argumenten een functie heeft, hangt af van de essentie van de functie en hoe de auteur deze heeft geschreven. Er kunnen functies zijn met één argument, drie, twintig; functies kunnen helemaal geen argumenten hebben. Om ze vervolgens te bellen haakje opent en sluit onmiddellijk:

GeenInterrupts() ;

Het is je misschien opgevallen dat onze setup- en lusfuncties ook geen argumenten gebruiken. En het mysterieuze ‘iets’ roept ze op dezelfde manier op, met lege haakjes, op het juiste moment.

Laten we terugkeren naar onze code. Dus omdat we van plan zijn de LED voor altijd te laten knipperen, moet de controlepin één keer een uitgang krijgen en dan willen we er niets meer van onthouden. Dit is waar de setup-functie ideologisch voor bedoeld is: het bord naar behoefte instellen en er vervolgens mee aan de slag.

Laten we verder gaan met de lusfunctie:

Zoals gezegd wordt deze direct na het instellen aangeroepen. En het wordt keer op keer gebeld zodra het eindigt. De lusfunctie wordt de hoofdlus van het programma genoemd en is ideologisch ontworpen om nuttig werk uit te voeren. In ons geval nuttig werk- knipperende LED.

Laten we de uitdrukkingen in volgorde doornemen. De eerste expressie is dus een aanroep van de ingebouwde functie digitalWrite. Het is ontworpen om een ​​logische nul (LAAG, 0 volt) of een logische nul (HOOG, 5 volt) toe te passen op een bepaalde pin. Er worden twee argumenten doorgegeven aan de digitalWrite-functie: pinnummer en Booleaanse waarde. Het resultaat is dat het eerste wat we doen de LED op de 13e pin aansteekt en er 5 volt op zet.

Zodra dit is gebeurd, gaat de processor onmiddellijk verder met de volgende uitdrukking. Voor ons is dit een oproep aan de vertragingsfunctie. De vertragingsfunctie is wederom een ​​ingebouwde functie die de processor een bepaalde tijd laat slapen. Er is slechts één argument nodig: de tijd in milliseconden om te slapen. In ons geval is dit 100 ms.

Terwijl we slapen, blijft alles zoals het is, d.w.z. de LED blijft branden. Zodra de 100 ms is verstreken, wordt de processor wakker en gaat onmiddellijk verder met de volgende expressie. In ons voorbeeld is dit opnieuw een aanroep van de bekende ingebouwde digitalWrite-functie. Het is waar dat we deze keer de waarde LAAG als tweede argument doorgeven. Dat wil zeggen, we stellen een logische nul in op de 13e pin, dat wil zeggen dat we 0 volt leveren, dat wil zeggen dat we de LED uitschakelen.

Nadat de LED is gedoofd, gaan we verder met de volgende uitdrukking. Opnieuw is dit een oproep aan de vertragingsfunctie. Deze keer vallen we 900 ms in slaap.

Zodra de slaap voorbij is, wordt de lusfunctie afgesloten. Bij voltooiing roept “iets” onmiddellijk opnieuw en alles gebeurt opnieuw: de LED brandt, licht op, gaat uit, wacht, enz.

Als je vertaalt wat er in het Russisch is geschreven, krijg je het volgende algoritme:

Het verlichten van de LED

Slaap 100 milliseconden

De LED uitschakelen

We slapen 900 milliseconden

Laten we naar punt 1 gaan

Zo kregen we een Arduino met een baken dat elke 100 + 900 ms = 1000 ms = 1 seconde knippert.

Wat kan er veranderd worden

Laten we alleen de kennis gebruiken die we hebben opgedaan om verschillende variaties op het programma te maken om het principe beter te begrijpen.

U kunt een externe LED of ander apparaat dat moet "knipperen" op een andere pin aansluiten. Bijvoorbeeld op de 5e. Hoe moet het programma in dit geval veranderen? We moeten het nummer vervangen door het 5e, waar we ook toegang hadden tot de 13e pin:

Compileren, downloaden, testen.

Wat moet er gedaan worden om de LED 2 keer per seconde te laten knipperen? Verkort de slaaptijd zodat het totaal 500 ms is:

Hoe kan ik ervoor zorgen dat de LED twee keer flikkert telkens wanneer deze knippert? Je moet hem twee keer aansteken met een korte pauze tussen het inschakelen:

Hoe kan ik ervoor zorgen dat het apparaat 2 LED's heeft die elke seconde afwisselend knipperen? Je moet communiceren met twee pinnen en in een lus werken met de een of de ander:

Hoe zorg ik ervoor dat het apparaat 2 LED's heeft die schakelen als een spoorwegverkeerslicht: eerst de ene en dan de andere? U hoeft alleen de brandende LED niet meteen uit te schakelen, maar te wachten op het moment van schakelen:

Voel je vrij om zelf andere ideeën te bekijken. Zoals je kunt zien, is het eenvoudig!

Over lege ruimte en mooie code

In C++ bestaan ​​er geen spaties, regeleinden en tabtekens van groot belang voor de compiler. Waar er een spatie is, kan er een regelbreuk zijn en omgekeerd. In feite zijn 10 spaties op rij, 2 regeleinden en 5 extra spaties het equivalent van één spatie.

Lege ruimte is het gereedschap van een programmeur, waarmee je een programma begrijpelijk en visueel kunt maken, of onherkenbaar kunt vervormen. Onthoud bijvoorbeeld het programma voor het knipperen van een LED:

We kunnen het als volgt veranderen:

Het enige wat we deden was een beetje met de lege ruimte werken. Nu kun je duidelijk het verschil zien tussen harmonieuze code en onleesbare code.

Om de onuitgesproken wet van programmaontwerp te volgen, die op forums wordt gerespecteerd, door andere mensen wordt gelezen en gemakkelijk door u kan worden waargenomen, volgt u een paar eenvoudige regels:

1. Vergroot altijd de inspringing tussen ( en ) bij het starten van een nieuw blok. Meestal worden er 2 of 4 spaties gebruikt. Kies een van de waarden en houd je daar de hele tijd aan.

Slecht:

Prima:

2. Net als in natuurlijke taal: plaats een spatie na komma's en niet ervoor.

Slecht:

Digitaal schrijven(5,HOOG) ;

Prima:

digitalWrite(5, HOOG) ;

3. digitalWrite(5,HOOG) ; Digitaal schrijven(5, HOOG) ; Plaats het blokstartsymbool ( aan

Slecht:

Prima:

4. void setup() ( pinMode(5, OUTPUT); ) void setup() ( pinMode(5, OUTPUT); ) void setup() ( pinMode(5, OUTPUT); )

Prima:

void setup() ( pinMode(5, UITVOER); ) void setup() ( pinMode(5, OUTPUT); )

Nog beter:

void loop() ( digitalWrite(5, HOOG) ; vertraging(100 ) ; digitalWrite(5 , LAAG) ; vertraging(900 ) ; digitalWrite(6 , HOOG) ; vertraging(100 ) ; digitalWrite(6 , LAAG) ; vertraging( 900 ); Over puntkomma's Je vraagt ​​je misschien af: waarom staat er een puntkomma aan het einde van elke uitdrukking? Dit zijn de regels van C++. Dergelijke regels worden genoemd

taal syntaxis

Zoals eerder vermeld zijn regeleinden voor hem een ​​lege zin, dus concentreert hij zich op dit leesteken. Hierdoor kunt u meerdere uitdrukkingen op één regel schrijven:

void loop() ( digitalWrite(5 , HOOG) ; vertraging(100 ) ; digitalWrite(5 , LAAG) ; vertraging(900 ) ; )

Het programma is correct en gelijkwaardig aan wat we al hebben gezien. Dit soort schrijven is echter een slechte vorm. De code is veel moeilijker te lezen. Dus tenzij je een 100% goede reden hebt om meerdere uitdrukkingen op dezelfde regel te schrijven, doe het dan niet.

Over opmerkingen Een van de regels van goed programmeren is: “schrijf code zo dat deze zo duidelijk is dat deze geen uitleg nodig heeft.” Dit is mogelijk, maar niet altijd. Om enkele niet voor de hand liggende punten in de code aan de lezers uit te leggen: uw collega's of uzelf over een maand, zijn er zogenaamde opmerkingen. Dit zijn de ontwerpen binnen

Zoals u kunt zien, kunt u tussen de symbolen /* en */ zoveel commentaarregels schrijven als u wilt. En na de reeks / / wordt alles wat volgt tot het einde van de regel als commentaar beschouwd.

We hopen dus dat de meest fundamentele principes van het schrijven van programma's duidelijk zijn geworden. Met de opgedane kennis kun je de stroomtoevoer naar de Arduino-pinnen programmatisch regelen volgens bepaalde timingpatronen. Dit is niet zo veel, maar toch genoeg voor de eerste experimenten.

Het C++-programma zelf is een tekstbestand met constructies en operatoren van deze taal in de volgorde aangegeven door de programmeur. In de zeer eenvoudig geval dit tekstbestand kan de volgende informatie bevatten:

Lijst 1.1. Een voorbeeld van een eenvoudig programma.

/* Voorbeeld van een eenvoudig programma */
#erbij betrekken
int hoofd()
{
printf(“Hallo wereld!”);
retour 0;
}

en heeft meestal een cpp-extensie, bijvoorbeeld "ex1.cpp".

De volgende stap is het compileren broncode. Compilatie verwijst naar het proces waarbij inhoud wordt gegenereerd tekstbestand omgezet in uitvoerbare machinecode die door de computerprocessor kan worden begrepen. De compiler maakt echter geen programma dat gereed is voor uitvoering, maar alleen objectcode (een bestand met de extensie *.obj). Deze code is een tussenstap bij het maken klaar programma. Het feit is dat het gemaakte programma functies kan bevatten van standaardbibliotheken van de C++-taal, waarvan de implementaties worden beschreven in de bibliotheekobjectbestanden. Het volgende programma gebruikt bijvoorbeeld de functie printf(). standaard bibliotheek"stdio.h". Dit betekent dat het objectbestand ex1.obj alleen instructies zal bevatten voor het aanroepen van deze functie, maar de code van de functie zelf zal er niet zijn.

Op naar de finale uitvoerbaar programma alle noodzakelijke implementaties van functies bevat, wordt een objectcode-linker gebruikt. Een linker is een programma dat wordt gecombineerd tot één programma uitvoerbaar bestand objectcodes gemaakt programma, objectcodes van implementaties van bibliotheekfuncties en standaardcode opstarten voor een bepaald besturingssysteem. Als gevolg hiervan bestaan ​​zowel het objectbestand als het uitvoerbare bestand uit machinecode-instructies. Het objectbestand bevat echter alleen het resultaat van de machinetaalvertaling van de tekst van het programma dat door de programmeur is gemaakt, en het uitvoerbare bestand bevat ook de machinecode voor de gebruikte standaardbibliotheekroutines en voor de opstartcode.

Laten we het voorbeeldprogramma in Listing 1.1 eens nader bekijken. De eerste regel specificeert opmerkingen, d.w.z. opmerkingen om u te helpen het programma beter te begrijpen. Ze zijn alleen-lezen en worden door de compiler genegeerd. De tweede regel bevat de #include-richtlijn, die de C++-taalpreprocessor instrueert om tijdens het compileren de inhoud van het bestand ‘stdio.h’ in plaats van deze regel in te voegen. De derde regel definieert een functie genaamd main die een geheel getal retourneert ( int-type) en accepteert geen argumenten (type void). De functie main() is een vereiste functie voor alle C++-programma's, en zonder deze functie verschijnt er een foutmelding in de compilatiefase die de afwezigheid van deze functie aangeeft. Deze functie is verplicht omdat dit het toegangspunt tot het programma is. In dit geval is het startpunt de functie waarmee het programma begint en eindigt. Wanneer u bijvoorbeeld een exe-bestand uitvoert, wordt de functie main() geactiveerd, worden alle daarin opgenomen instructies uitgevoerd en wordt het programma beëindigd. De logica van het hele programma zit dus in deze functie. In het bovenstaande voorbeeld wordt, wanneer de functie main() wordt aangeroepen, de functie printf() aangeroepen, die het bericht "Hallo wereld!" op het beeldscherm weergeeft, en vervolgens wordt de return-instructie uitgevoerd, die een nulwaarde retourneert. Dit nummer wordt vanzelf geretourneerd functie hoofd() besturingssysteem en betekent een succesvolle afronding van het programma. Beugel() dienen om het begin en einde van het functielichaam te bepalen, d.w.z. ze bevatten alle mogelijke operatoren die de werking van deze functie beschrijven. Opgemerkt moet worden dat er na elke operator in de C++-taal een ‘;’-symbool staat. Het gegeven voorbeeld laat dus zien algemene structuur programma's in C++-taal.

STRUCTUUR VAN EEN EENVOUDIG PROGRAMMA

Nu, nadat we het hebben gebracht concreet voorbeeld, ben je klaar om er meerdere te ontmoeten algemene regels over programma's geschreven in C-taal. Een programma bestaat uit een of meer functies, en een daarvan moet worden aangeroepen voornaamst(). Een functiebeschrijving bestaat uit een header en een body. De header bestaat op zijn beurt uit preprocessor-richtlijnen zoals #erbij betrekken etc. en de functienaam.

RIJST. 2.4. Functiestructuur in C-taal: header en body.

1.6 Programmastructuur Een C++ programma bestaat doorgaans uit groot aantal bronbestanden, die elk beschrijvingen bevatten van typen, functies, variabelen en constanten. Zodat de naam op verschillende manieren gebruikt kan worden bronbestanden om naar hetzelfde object te verwijzen, moet dit

Structuur Superprogramma's Home Suite Laten we eens kijken naar het hoofdvenster van het Super Home Suite-programma (demoversie 3.5.2) (Fig. 2.1). Rijst. 2.1. Het hoofdvenster van het Super Home Suite-programma bevindt zich bovenaan systeemmenu, dat secties met opdrachten bevat voor het besturen van het programma, gegevens bewerken,

Programmastructuur Het programmavenster van PromOffice Euroremont (Fig. 3.1) bestaat uit verschillende delen. Bovenaan bevindt zich een horizontaal paneel met het hoofdmenu, daaronder bevindt zich een werkbalk. De rest van het venstergebied wordt ingenomen door panelen voor het werken met gegevens. IN nieuwste versie programma's aan de rechterkant

1. Structuur van een assemblerprogramma Een assemblerprogramma is een verzameling geheugenblokken die geheugensegmenten worden genoemd. Een programma kan uit één of meer van dergelijke segmentblokken bestaan. Elk segment bevat een reeks taalzinnen,

47. Structuur van een assemblerprogramma Een assemblerprogramma is een verzameling geheugenblokken die geheugensegmenten worden genoemd. Een programma kan uit één of meer van dergelijke segmentblokken bestaan. Elk segment bevat een reeks aanbiedingen

De structuur van een eenvoudig C#-programma De C#-taal vereist dat alle programmalogica binnen de definitie van een bepaald type valt (denk aan hoofdstuk 1 dat de term type wordt gebruikt om naar elk element van een set te verwijzen (klasse, interface, struct, opsomming , afgevaardigde)). IN

PROGRAMMASTRUCTUUR Bronprogramma Het bronprogramma is een verzameling van de volgende elementen: preprocessorrichtlijnen, compilerinstructies, declaraties en definities. Preprocessorrichtlijnen specificeren wat de preprocessor moet doen om te transformeren

De structuur en het proces van het laden van een COM-programma Wat is een COM-programma, hoe wordt het in het geheugen geladen en gestart? De structuur van een COM-programma is uiterst eenvoudig: het bevat alleen code en programmagegevens, zonder zelfs maar een header. COM-programmagrootte is beperkt

Structuur en laadproces van een EXE-programma In tegenstelling tot COM-programma's kunnen EXE-programma's uit meerdere segmenten bestaan ​​(code, data, stack). Ze kunnen meer dan 64 KB in beslag nemen. Het EXE-bestand heeft een header die wordt gebruikt bij het laden ervan. De kop bestaat uit

VOORBEELD VAN EEN EENVOUDIG PROGRAMMA IN C-TAAL Laten we eens kijken een eenvoudig programma in C-taal. Het moet meteen gezegd worden dat we zo'n voorbeeld alleen nodig hebben om enkele van de belangrijkste kenmerken te identificeren van elk programma dat in de C-taal is geschreven. Vervolgens geven we uitleg voor elke regel, maar daarvoor