Algemene programmastructuur in c. Variabelen en arrays

Aanvankelijk was de C-taal bedoeld als vervanging voor de Assembleertaal voor schrijven besturingssystemen. Omdat C een taal op hoog niveau is die niet afhankelijk is van een bepaalde architectuur, was de tekst van het besturingssysteem gemakkelijk overdraagbaar van het ene platform naar het andere. Het eerste besturingssysteem dat vrijwel volledig in C was geschreven, was Unix-systeem. Momenteel zijn bijna alle gebruikte besturingssystemen geschreven in C. Bovendien zijn er programmeertools die besturingssysteem ontwikkelaars biedt applicatieprogramma's(de zogenaamde API - Application Program Interface) zijn sets systeem functies in C-taal.

De reikwijdte van de C-taal was echter niet beperkt tot de ontwikkeling van besturingssystemen. De C-taal is erg handig gebleken in tekst- en beeldverwerkingsprogramma's, in wetenschappelijke en technische berekeningen. Op C gebaseerde objectgeoriënteerde talen zijn ideaal voor programmeren in vensteromgevingen.

IN deze sectie Alleen de basisconcepten van de C-taal (en gedeeltelijk C++) worden gegeven. Dit is geen vervanging voor lezen. compleet leerboek in C of C++, bijvoorbeeld boeken en .

We zullen een C++-compiler gebruiken in plaats van C. Feit is dat de C-taal bijna volledig is opgenomen in C++, d.w.z. een normaal programma geschreven in C is een geldig C++ programma. Het woord ‘normaal’ betekent dat het geen mislukte constructies bevat die er nog van over zijn eerdere versies Si en momenteel niet in gebruik. De C++-compiler verdient de voorkeur boven de C-compiler omdat het heeft een strengere foutcontrole. Bovendien zijn sommige C++-constructies die geen verband houden met objectgeoriënteerd programmeren erg handig en in feite een verbetering ten opzichte van de C-taal. Dit zijn in de eerste plaats commentaren // , de mogelijkheid om lokale variabelen op elk punt in het programma te beschrijven, en niet alleen aan het begin van het blok, en ook om constanten in te stellen zonder de operator #define van de preprocessor te gebruiken. We zullen deze functies van C++ gebruiken terwijl we in wezen binnen de C-taal blijven.

Structuur van een C-programma

Elk is genoeg groot programma in C (programmeurs gebruiken de term project) bestaat uit bestanden. De bestanden worden onafhankelijk vertaald door de C-compiler en vervolgens gecombineerd door het taakbouwerprogramma, wat resulteert in een bestand met een programma dat klaar is om te worden uitgevoerd. Bestanden die C-programmateksten bevatten, worden aangeroepen origineel.

In de C-taal zijn er twee soorten bronbestanden:

• header- of h-bestanden;
• implementatiebestanden of C-bestanden.

Headerbestandsnamen hebben de extensie ".h". Namen van implementatiebestanden hebben de extensie ".c" voor de C-taal en ".cpp", ".cxx" of ".cc" voor de C++-taal.

Helaas zijn programmeurs, in tegenstelling tot de C-taal, er niet in geslaagd het eens te worden over een enkele naamextensie voor bestanden die C++-programma's bevatten. We gebruiken de extensie ".h" voor headerbestanden en de extensie ".cpp" voor implementatiebestanden.

Header-bestanden bevatten alleen beschrijvingen. Allereerst zijn dit functieprototypes. Functie-prototype beschrijft de functienaam, het retourtype, het aantal en de typen argumenten. De functietekst zelf staat niet in het h-bestand. Ook beschrijven h-bestanden de namen en typen van externe variabelen, constanten, nieuwe typen, structuren, enz. Over het algemeen bevatten h-bestanden alleen interfaces, d.w.z. informatie die nodig is om programma's te gebruiken die al door andere programmeurs zijn geschreven (of eerder door dezelfde programmeur). Headerbestanden geven alleen informatie over andere programma's. Bij het vertalen van headerbestanden worden in de regel geen objecten gemaakt. In een headerbestand is dat bijvoorbeeld niet mogelijk definiëren globale variabele. Beschrijvingsregel

het definiëren van een geheel getal variabele x is een fout. In plaats daarvan moet een beschrijving worden gebruikt

wat betekent dat de variabele x ergens in het implementatiebestand is gedefinieerd (wat onbekend is). Alleen het woord extern (extern). rapporteert informatie over een externe variabele, maar definieert die variabele niet.

Implementatie bestanden, of C-bestanden, bevatten functieteksten en definities van globale variabelen. Simpel gezegd bevatten C-bestanden de programma's zelf, terwijl h-bestanden alleen informatie over de programma's bevatten.

Weergave van broncodes in de vorm van headerbestanden en implementatiebestanden is noodzakelijk voor het creëren van grote projecten met een modulaire structuur. Headerbestanden worden gebruikt om informatie tussen modules over te dragen. De implementatiebestanden zijn individuele modules, die onafhankelijk van elkaar worden ontwikkeld en vertaald en gecombineerd om een ​​uitvoerbaar programma te creëren.

Implementatiebestanden kunnen beschrijvingen bevatten die zijn opgenomen in headerbestanden. De headerbestanden zelf kunnen ook andere headerbestanden gebruiken. Het headerbestand wordt opgenomen met behulp van de preprocessorrichtlijn #include. Beschrijvingen bijvoorbeeld standaard kenmerken I/O wordt ingeschakeld via de lijn

#erbij betrekken

(stdio - van de woorden standaardinvoer / uitvoer). De h-bestandsnaam is geschreven punthaken, als deze h-

Fig.1 Programmastructuur in C-taal.

Interne programmastructuur

Uitvoerbaar programma in C bestaat uit 4 delen: commandogebied, statisch datagebied, dynamisch datagebied, 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 hoofdfunctie 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

Laat ons nadenken 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. Functionele 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. Constanten zijn er in verschillende soorten. De typen verschillen in het principe van plaatsing in het computergeheugen en voor een persoon in het type opname. Er zijn 7 trefwoorden in C die worden gebruikt om aan te geven Verschillende types gegevens: int, lang, kort, niet-ondertekend, 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 benodigd: 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 is belangrijk 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 in 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 – overgang naar nieuwe lijn

\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

\" - citaten

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 \ heet 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 uitgegeven 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" -

Het programma geschreven in C# bestaat uit de volgende blokken:

• declaratie van een naamruimte (een soort container);
• klassedeclaratie (de belangrijkste essentie van het programma);
• klassemethoden (subroutines), tenminste een methode Voornaamst;
• operatoren en uitdrukkingen;
• opmerkingen.

Een voorbeeld van een eenvoudig programma

Laten we eens kijken naar een eenvoudig programma geschreven in C#. Dit wordt een consoleapplicatie die de string “Hello World” afdrukt (een soort klassieker voor het eerste programma in de praktijk van een programmeur). De code voor een dergelijk programma wordt hieronder gegeven, laten we ernaar kijken:

//De naamruimte System verbinden met System; //Declaratie van de naamruimte naamruimte ProgramStructure ( //Declaratie van de klasse klasse Program ( //Hoofdmethode van het programma static void Main(string args) ( //Voer de regel uit Console.WriteLine("Hello World!"); / /Hulpoperator Console.ReadKey ();

De eerste regel van dit programma is een commentaar. Opmerkingen hebben op geen enkele manier invloed op de werking van het programma; ze zijn nodig voor de persoon die de programmacode gaat onderhouden (verfijnen, fouten corrigeren, enz.).

Tweede regel van het programma ( gebruik maken van systeem;) is een operator die de standaardnaamruimte bevat Systeem. In wezen krijgen we toegang tot een reeks klassen die beschikbaar zijn in de “container” Systeem. Als gezien, gegeven lijn bestaat uit twee woorden, het eerste (trefwoord gebruik makend van) betekent dat we de naamruimte en de tweede willen opnemen Systeem— de naam van de vereiste naamruimte.

Aan het einde van de tweede regel staat een “;”-symbool, dat het einde van de verklaring aangeeft. Elke programma-instructie moet eindigen met een dergelijk symbool.

De vierde regel van het programma is opnieuw commentaar, net als de regels 7, 10, 13, 15. Commentaar in C# begint met de tekens “//” (twee schuine strepen naar voren, twee schuine strepen) en is slechts geldig tot het einde van de lijn.

C# heeft ook meerregelige commentaren, soms is het handiger om ze te gebruiken, we zullen ze later tegenkomen.

In de vijfde regel ( naamruimte ProgramStructure) zijn eigen naamruimte declareert, heet deze “ProgramStructure”. Een naamruimte is een soort container en is beperkt gekrulde beugels(opening - regel 6 en sluiting - regel 19), naar aanleiding van de naam. Alles tussen de regels 6 en 19 behoort dus tot de naamruimte Programmastructuur.

Regel 8 declareert een klasse genaamd “Programma”, dit is de belangrijkste en enige klasse van ons programma. Zoals u kunt zien, wordt het trefwoord gebruikt om een ​​klasse te declareren klas gevolgd door de klassenaam. Het programma heeft mogelijk niet één, maar meerdere klassen. Normaal gesproken bestaat een klasse uit een reeks methoden die het zogenaamde gedrag van de klasse definiëren (functionaliteit, zo u wilt). Klassengrenzen, evenals naamruimten, worden aangegeven met accolades (regels 9 en 18). In ons geval heeft de klasse slechts één methode, dit is de methode Voornaamst.

Regel 11 declareert alleen de methode Voornaamst. Deze methode is de belangrijkste in ons programma, het zogenaamde toegangspunt tot het programma. Dit betekent dat wanneer het programma start, de methode eerst wordt uitgevoerd Voornaamst. Elke methode heeft ook grenzen, die ook worden aangegeven door accolades (regels 12 en 17).

Methode Voornaamst ons programma bevat slechts twee uitspraken. Deze uitspraken verschijnen op de regels 14 en 16. De eerste drukt het bericht “Hallo wereld!” af. En de tweede is een hulpfunctie, deze dwingt het programma te wachten tot er een toets op het toetsenbord wordt ingedrukt, en zorgt ervoor dat de uitvoering pas op dat moment kan worden voltooid (zonder deze operator zou het programma de regel hebben afgedrukt en snel zijn gesloten , zodat we niet eens de tijd hadden om te lezen wat het opleverde).

Probeer nu dit programma te bouwen en uit te voeren Visuele studio. Om dit te doen heb je nodig:

• start Visual Studio;
• creëren nieuw project console applicatie;
• kopieer regels 13-16 uit het bovenstaande voorbeeld;
• plaats deze regels in de methode Voornaamst project gemaakt in Visual Studio;
• druk op de F5-toets.

Ik heb gedetailleerd gesproken over het maken van een consoletoepassingsproject in Visual Studion, ik raad je aan het te lezen.

STRUCTUUR VAN EEN EENVOUDIG PROGRAMMA

Nu we het hebben gebracht specifiek 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 enz. en de functienaam.

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

1.6 Programmastructuur Een C++ programma bestaat doorgaans uit groot nummer 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 laatste 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 bloksegmenten 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 bloksegmenten 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, zelfs zonder 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