In het programma Tekenreeksen, of tekenreeksconstanten, worden weergegeven door een reeks tekenafbeeldingen tussen aanhalingstekens (geen apostrofs), zoals 'alle tekens'. Tussen de karakters van de string kunnen zich ontsnappingsreeksen bevinden die overeenkomen met de codes van niet-representatieve (speciale) karakterconstanten.
Voorbeelden:
“1234567890”
“\tsamenstelling van het presidium”
“begin van regel \t en einde van regel.”
Als beëindiging karakter Het symbool met code 0 is geselecteerd (niet verwarren met het symbool "0"). Dus de definitie
char HelloStr = "Hallo wereld";
eigenlijk geïnterpreteerd als
char HelloStr = ("H", "e", "l", "l", "o", " ", ", "w", "o", "r", "l", "d" , " \0");
Dit gebeurt wanneer een array wordt geïnitialiseerd met een string. In alle andere gevallen wordt de aangetroffen tekenreeks geïnterpreteerd als een naamloze array met de juiste lengte die nog niet is gemaakt. Dat wil zeggen: de uitdrukking
printf("Hallo wereld\n");
wordt feitelijk geïnterpreteerd als
char str1 = "Hallo wereld\n";
Wanneer een string in het geheugen wordt geplaatst, voegt de vertaler automatisch het teken ‘\0’ toe aan het einde ervan, d.w.z. nulbyte.
Het aantal elementen in zo'n array is 1 meer dan in het beeld van de corresponderende stringconstante, omdat er is een null-byte ‘\0’ toegevoegd aan het einde van de regel.
Strings hebben nog een ander kenmerk: de vertaler wijst elke string een aparte plaats in het computergeheugen toe, zelfs in gevallen waarin meerdere strings volledig samenvallen (de SI-taalstandaard suggereert dat deze regel in specifieke implementaties mogelijk niet wordt gevolgd).
Wijs een waarde toe aan een tekenarray(dat wil zeggen een string) kan niet worden gedaan met behulp van een reguliere toewijzingsoperator. U kunt een tekenreeks in een array plaatsen via initialisatie (bij het definiëren van een tekenarray) of via invoerfuncties. In functie scannenf() of afdrukkenf() Voor tekenreeksen specificatie gebruikt transformatie % S.
Voorbeeld:
/*druk een tekenreeks af*/
#erbij betrekken
( char B=”Sesam openen!”;
printf(“%s”,B); ) /*einde programma*/
Resultaat programma-uitvoering: Sesam, open!
In het programma de lengte van de array IN– 17 elementen, d.w.z. de lengte van de string die in de array moet worden geplaatst (16 tekens), plus de null-byte aan het einde van de string. Er worden 17 bytes toegewezen bij het initialiseren van de array in het bovenstaande voorbeeld. Het initialiseren van een karakterarray met een stringconstante is een verkorte versie van array-initialisatie en werd omwille van de eenvoud in de taal geïntroduceerd. U kunt de normale initialisatie gebruiken door de beginwaarden van de array-elementen in te plaatsen beugel en niet te vergeten aan het einde van de lijst met initiële waarden te plaatsen speciaal karakter regel die eindigt op '\0'. De volgende initialisatie van array B was dus toegestaan in het programma:
char B = ('C','e','z','a','m',',',' ','o','t','k','p','o' ,'de',','i','!','\0');
Hoe tekenreeksen invoeren of op het scherm weergeven?
De regel kan worden uitgevoerd door een functie die u al kent printf() met invoerspecificatie "%S", of speciale functie int put (char *string) wat een string oplevert snaar op het scherm en retourneert een waarde die niet nul is, indien succesvol.
Waarom hebben we de specificatie nodig " %S"? Dit wordt gedaan zodat u strings met willekeurige tekens kunt afdrukken. Vergelijk:
Voorbeeld:
char str = "Ik wilde %d uitvoeren...";
printf("%s", str); /* Juiste optie */
printf("\n"); /* Scheidingsteken nieuwe regel */
printf(str); /* Onjuiste optie */
In de eerste In dit geval drukt de functie precies af wat er van wordt verlangd. Maar binnen seconde geval printf(), nadat ik elkaar in de rij had ontmoet str De specificatie "%d" (nu is deze regel immers de eerste, wat betekent dat hij het uitvoerformaat specificeert) zal concluderen dat deze moet worden gevolgd door een getal. En aangezien het niet volgt, in plaats van " %D"Er wordt wat afval afgedrukt - het nummer dat momenteel op de stapel staat.
De gevolgen kunnen ernstiger zijn als de regel de reeks bevat "%S", het zal het als een string behandelen en het afdrukken totdat het een nulteken tegenkomt. En waar ze hem zal ontmoeten, hoeveel tijd ze zal hebben om te typen en of het zal crashen omdat ze geen toegang heeft tot haar geheugen - niemand weet het.
De regeleindeconventie moet in acht worden genomen bij het maken van regels van individuele karakters. Beschouw als voorbeeld het volgende
/*een regel lezen vanaf de terminal*/
int getline(char S, / *tekenreeks ingevoerd*/
int lim) /*de maximale lengte*/
( int c, i; /* c – invoerteken */
voor (i=0; ik s[ik] = '\0'; String-invoer/-uitvoer. Basisstringfuncties
Een van de meest populaire I/O-bewerkingen is de tekenreeks-I/O-bewerking. String I/O-functies zijn opgenomen in de SI-bibliotheek voor het uitwisselen van gegevens via standaard invoer-/uitvoerstromen krijgt()
En zet(),
die handig zijn om te gebruiken bij het maken van dialoogsystemen. Voor invoerreeks er is een functie met een prototype char *krijgt (char *string), die een regel van het toetsenbord leest en in een buffer plaatst snaar, een pointer waarnaar het terugkeert. Als er een fout optreedt, wordt EOF geretourneerd. De functie heeft er maar één betoog – wijzer S <
stdio.
H>.
krijgt() functie voltooit zijn werk bij het invoeren van een teken ‘\
N’
, dat automatisch wordt overgedragen van het toetsenbord naar de computer wanneer een toets wordt ingedrukt Hier moet u letten op de volgende functie van het invoeren van gegevens via het toetsenbord. Functie krijgt()
begint pas met het verwerken van informatie van het toetsenbord nadat u op een toets hebt gedrukt <
Binnenkomen>.
Het “wacht” dus totdat het wordt gebeld noodzakelijke informatie en de toets wordt ingedrukt<Binnenkomen>. Pas daarna begint de gegevensinvoer in het programma. Voorbeeld:
#erbij betrekken int hoofd (nietig) ( printf("Voer een tekenreeks in:"); printf("De stringinvoer was: %s\n", string); Functie zet()
(lijnuitgang op het scherm) retourneert, indien succesvol, het laatst afgedrukte teken, wat altijd een teken is ‘\
N"
Als er een fout optreedt, wordt deze geretourneerd door de EOF-functie. Het prototype van deze functie ziet er als volgt uit: De functie heeft er maar één betoog – wijzer S int zet(char*s); /*tekenreeksuitvoerfunctie*/ <
stdio.
H>.
naar een reeks karakters. Het functieprototype wordt beschreven in het bestand Laten we de eenvoudigste geven
voorbeeld #erbij betrekken gebruik van deze functies. char strl = ”voer de achternaam van de werknemer in:”; ‘\0’
Bedenk dat elke tekenreeks in de SI-taal moet eindigen met een nulteken . Naar het laatste element van de array strl Het null-teken wordt automatisch geschreven tijdens de vertaling wanneer de array wordt geïnitialiseerd. Voor functie zet() De aanwezigheid van een null-teken aan het einde van de string is vereist.‘\0’
Anders, d.w.z. als er geen teken in de tekenarray staatzet
()
, kan het programma abnormaal eindigen, omdat functie . Naar het laatste element van de array
.
op zoek naar een nulteken doorzoekt het byte voor byte alle beschikbare geheugens, beginnend, in ons voorbeeld, vanaf het adres Dit moet onthouden worden als het programma een string genereert om deze op het beeldscherm weer te geven.
:
#erbij betrekken int hoofd (nietig) ( Voorbeeld char string = "Dit is een voorbeeld van een uitvoerreeks\n";
Omdat er in C geen vooraf gedefinieerd type voor een string bestaat, zijn er geen bewerkingen die voor velen zo bekend zijn, zoals het vergelijken en aaneenschakelen van strings, die in veel talen zijn geïmplementeerd als optel- en vergelijkingsoperatoren. Hier is het toevoegen van arrays niet toegestaan, en bij het vergelijken worden niet de strings zelf vergeleken, maar alleen aanwijzingen op hen, wat voor ons natuurlijk niet interessant is. Voor stringmanipulatie is er een reeks functies gedeclareerd in het bestand De belangrijkste functies: int strcmp (char *string1, char *string2) voert uit twee strings vergelijken.
Retouren een negatief getal als de eerste rij kleiner is dan de tweede, 0 als de rijen gelijk zijn, en een positief getal als de eerste rij groter is dan de tweede. Meer gedetailleerd retourneert de functie het verschil tussen de codes van de eerste ongelijke tekens die worden aangetroffen (als de tekenreeksen ongelijk in lengte zijn, wordt een teken dat niet nul is, vergeleken met nul). Dit moet onthouden worden als het programma een string genereert om deze op het beeldscherm weer te geven.
:
#erbij betrekken #erbij betrekken int hoofd (nietig) ( char *buf1 = "aaa", *buf2 = "bbb", *buf3 = "ccc"; ptr = strcmp(buf2, buf1); als (ptr > 0) printf("buffer 2 is groter dan buffer 1 \n"); printf("buffer 2 is kleiner dan buffer 1 \n"); ptr = strcmp(buf2, buf3); printf("buffer 2 is groter dan buffer 3\n"); printf("buffer 2 is kleiner dan buffer 3\n"); Het volgende verschijnt op het scherm: buffer 2 is groter dan buffer 1 buffer 2 is kleiner dan buffer 3 char *strcpy (char *dest, char *bron) voert uit kopiëren lijnen bron in plaats van de lijn bestem. Zorg er opnieuw voor dat de hele lijn in de daarvoor bestemde ruimte past. De functie retourneert een verwijzing naar de doelreeks. Voorbeeld:
#erbij betrekken #erbij betrekken int hoofd (nietig) ( char *str1 = "a b c d e f g h i"; strcpy(tekenreeks, str1); printf("%s \n", tekenreeks); Op het scherm verschijnt: a b c d e f g h I char *strcat (char *string1, char *string2) voert uit twee regels aaneenschakelen. De tweede regel wordt toegevoegd aan het einde van de eerste. De functie controleert niet (en kan technisch gezien niet controleren) de aanwezigheid van de vereiste hoeveelheid geheugen aan het einde van de eerste regel - u moet hiervoor zorgen. De functie retourneert een verwijzing naar de eerste rij. Voorbeeld:
#erbij betrekken #erbij betrekken int hoofd(nietig) ( char-bestemming; char *blank = " ", *c = "C++", *turbo = "Turbo"; strcpy(bestemming, turbo); //Kopieer de string "turbo" op zijn plaats bestemming strcat(bestemming, blanco); // Lijmen bestemming... strcat(bestemming, c); // eerst met leeg, dan met C printf("%s\n", bestemming); Het scherm verschijnt: Turbo C++ int strlen (char *string) retourneert lijn lengtesnaar
(het nul-teken niet meegerekend). char *strdup (char *string) creëert dubbele lijnsnaar
en geeft er een verwijzing naar terug. Houd er rekening mee dat, in tegenstelling tot andere functies, opstaan maakt zelf een string aan en vergeet daarom niet deze te bevrijden als u deze niet langer nodig heeft. char *strncpy (char *dest, char *source, int count) char *strncat (char *string1, char *string2, int-aantal) op dezelfde manier strcpy En strcat, maar alleen de eerste worden gekopieerd graaf karakters. De functies voegen geen afsluitende null toe aan de string; dat moet je zelf doen. char *strchr (char *string, int c) char *strstr (char *string, char *substring) op zoek naar eerste voorkomen naar lijn snaar respectievelijk symbool C en subreeksen subtekenreeks. Beide functies retourneren het adres van de eerste keer dat het voorkomt of NUL, als er geen wordt gevonden. Dit moet onthouden worden als het programma een string genereert om deze op het beeldscherm weer te geven.
:
int hoofd (nietig) ( char *ptr, c = "r"; //Maak een lijn strcpy(string, "Dit is een string"); ptr = strchr(tekenreeks, c); printf("Het karakter %c staat op positie: %d\n", c, ptr-string); printf("Het karakter is niet gevonden\n"); Laboratoriumwerk nr. 1 Inleiding tot de programmeertaal C++ Doel van het werk: 1. Studie van de Visual C++ shell-interface; 2. Het compileren en creëren van uitvoerbare bestanden. 3. Studie van de basisgegevenstypes van de C++-taal; Basistypen gegevens; Variabelen en constanten; 4. Onderzoek van exploitanten: Rekenkundig; Logisch; Vergelijkingen; Bitsgewijs; Invoer en uitvoer. 5. Vaardigheden verwerven om te werken met Microsoft Visual C++ 5.0-software. Gebruikte apparatuur: Persoonlijke computer compatibel met IBM-pc. Gebruikt software:
besturingssysteem Ramen; Geïntegreerde programmeeromgeving Microsoft Visual C++ 5.0 (ISP Microsoft Visual C++ 5.0). Werkopdracht 1.1. Download ISP Microsoft Visual C++ 5.0. 1.2. Leer Microsoft Visual C++ 5.0 ISP-opdrachten. 1.3. Leer de belangrijkste gegevenstypen van Microsoft Visual C++ 5.0 COI. 1.4. Vul voorbeeld 1, voorbeeld 2, voorbeeld 3 en de opdracht van de docent in. 1.5. Leg een protocol vast voor het werken met de geïntegreerde omgeving. Werkorder 2.1. Start Microsoft Visual C++ 5.0. 2.2. Maak een *.cpp-bestand in de werkmap. 2.3. Vul voorbeeld 1, voorbeeld 2, voorbeeld 3 en de opdracht van de docent in. 2.4. Maak een algoritmediagram en schrijf een programma (volgens instructies van de docent). Leg een protocol vast voor het werken met de geïntegreerde omgeving. 2.5. Voltooi Microsoft Visual C++ 5.0 en voer het programma uit. 3.1. Naam laboratoriumwerk. 3.2. Doel van het werk. 3.3. Het theoretische gedeelte. 3.4. Algoritmen van uitgevoerde programma's. 3.5. Tekst van uitgevoerde programma's. 3.6. Conclusie. Korte beschrijving werk 4.1. Start en werk in Microsoft Visual C++ 5.0. Om Microsoft Visual C++ 5.0 ISP te starten, moet u het menu Start - Microsoft Visual C++ 5.0 - Microsoft Visual C++ 5.0 starten. Om in C++ te gaan werken, moet je eerst een eenvoudige consoleapplicatie maken, hiervoor moet je deze uitvoeren volgende stappen: Ø Start Visual C++ (Start®Programma's® Microsoft Visual C++ 5.0.® Microsoft Visual C++ 5.0 .
); ØSelecteer "Nieuw" in het menu "Bestand". Zorg ervoor dat het tabblad “Projecten” is geselecteerd in het dialoogvenster “Nieuw”. Selecteer "Win32 Console Application" in de lijst met projecttypen; Ø Selecteer de map voor het project ‘Locatie’ (C:\studenten\’groep*) en de projectnaam ‘Projectnaam’, bijvoorbeeld “Eerste” en klik op “OK”. Er worden "Eerste lessen" aangemaakt; Ø Selecteer daarna opnieuw "Nieuw", maar dan via het tabblad "Bestanden" en selecteer "C++ Bronbestand". Stel in de lijst ‘Bestandsnaam’ een naam in, bijvoorbeeld ‘Eerste’. Klik vervolgens op ‘OK’ en het bestand ‘Eerste.cpp’ wordt aangemaakt. Algemene structuur van het programma. Onze taak is om na te denken algemene structuur programma geschreven in C/C++, dat wil zeggen het geheel bron in één bestand: Ø Preprocessor-richtlijngebied (opnemen, definiëren..); Ø Beschrijving aangepaste typen gegevens; Ø Onvolledige functiedeclaraties; Ø Beschrijving van globale variabelen; Ø Functiedeclaratie 1; Ø Functiedeclaratie 2; Ø Declaratie van de functie main(). Dit schema heeft dat niet strikte volgorde net als bij Pascal wordt het echter als traditioneel beschouwd. Een programma bestaat uit een of meer procedures, traditioneel functies genoemd. Eén functie die in elk programma vereist is, zou main moeten heten. Het dient als toegangspunt tot het programma en roept vervolgens andere functies op. Minimaal programma ziet er zo uit: Leegte belangrijkste (leegte) Het bestaat uit een hoofdfunctie die geen parameters accepteert of retourneert (void). Ook de functie body, tussen accolades, bevat geen bruikbare uitspraken. Variabelen kunnen zowel binnen de functiebody als buiten de body worden gedeclareerd. In het eerste geval zijn ze alleen toegankelijk vanuit de hoofdtekst van een bepaalde functie (lokale aangiften), en in het tweede geval - vanuit elke functie (globale aangiften). De uitvoering van het programma begint met de hoofdtekst van de hoofdfunctie, waaruit een reeks waarden kan worden overgenomen opdrachtregel. De hoofdtekst bevat aanroepen naar andere functies, zoals standaard bibliotheken, Dus gebruiker gedefinieerd in de programmatekst. De uitvoering van het programma eindigt standaard wanneer het hoofdprogramma wordt afgesloten, maar kan op elk moment worden onderbroken als er een probleem optreedt. kritische fout, of zoals van toepassing. Om dit te doen gebruiken ze meestal de functie exit() uit de stdlib-bibliotheek. Een tekenreeks naar het scherm afdrukken Laten we eerst een programma schrijven dat een string op het scherm afdrukt. Het programma moet een functie bevatten met de naam main(). Ze wordt gecrediteerd met de rol van het starten van het programma. Deze functie is niet vooraf gedefinieerd door de compiler, kan niet worden overbelast en het type is afhankelijk van de implementatie. belangrijkste functie kan als volgt worden gedefinieerd: Voorbeeld 1: // Eerste programma in C++ #erbij betrekken Leeg hoofd() uit<< “Thise is my first program\n” << endl;
Om een programma uit te kunnen voeren, moet u het eerst opslaan. Ga naar het menu Bestand en klik daar op Bewaar alles. Vervolgens moet je het bouwen (compileren); hiervoor moet je de volgende stappen uitvoeren: ØLaten we naar het menu gaan ( Build®Build *.exe) of sneltoets (F7), zal het programma beginnen met bouwen. Als de compiler geen foutmelding genereert, die u kunt bekijken in het venster dat hieronder verschijnt, kunt u het programma veilig uitvoeren; Ø Nu hoef je alleen nog maar het programma uit te voeren, ga hiervoor naar het menu ( Build®Execute *.exe.) of sneltoets (Ctrl+F5); ØUw programma wordt uitgevoerd. Lijn #erbij betrekken vertelt de compiler om de standaard invoer- en uitvoerstroommogelijkheden in het bestand iostream.h in te schakelen. Zonder deze beschrijvingen de uitdrukking uit << "Dit is mijn eerste programma" zou geen zin hebben. De belangrijkste standaardbibliotheken staan vermeld in Tabel 1. Tabel 1. Core C/C++ standaardbibliotheken Operatie<< ("поместить в") пишет свой первый аргумент во второй (в данном случае, строку "Dit is mijn eerste programma" naar de standaarduitvoer van cout). Een string is een reeks tekens tussen dubbele aanhalingstekens. In een string geeft een backslash-teken \ gevolgd door een ander teken een enkel speciaal teken aan; in dit geval is \n een teken voor een nieuwe regel. Dus , de uitvoertekens bestaan uit " Dit is mijn eerste programma" en line feed, die een functie definiëren genaamd voornaamst. Elk programma moet een functie bevatten genaamd voornaamst, en het programma begint met de uitvoering van deze functie. Toetsenbordinvoer Het volgende (nogal uitgebreide) programma vraagt u om het aantal inches in te voeren. Zodra u dit doet, wordt het overeenkomstige aantal centimeters afgedrukt. Voorbeeld 2: #erbij betrekken Leeg hoofd() int inch = 0; // inch-inch uit<< "inches";
cin >> inch; uit<< inch;
uit<< " in = ";
uit<< inch*2.54;
uit<< " cm\n";
Eerste regel van de functie voornaamst() beschrijft een hele variabele inch. De waarde ervan wordt gelezen met behulp van de >> ("take from") bewerking op standaardinvoer cin. In dit voorbeeld is er één instructie voor elke uitvoeropdracht; het is te lang. Opnameoperatie<< можно применять к ее собственному результату, так что последние четыре команды вывода можно было записать одним оператором: Opmerkingen Het is vaak handig om tekst in een programma in te voegen die alleen bedoeld is als commentaar voor de persoon die het programma leest en die door de compiler in het programma wordt genegeerd. In C++ kan dit op twee manieren worden gedaan. De /*-tekens beginnen een commentaar dat eindigt met de */-tekens. Deze hele reeks tekens is gelijk aan een spatieteken (bijvoorbeeld het spatieteken). Dit is vooral handig voor commentaar met meerdere regels en het verwijderen van delen van een programma tijdens het bewerken, maar houd er rekening mee dat /* */ commentaar niet kan worden genest. De //-tekens beginnen met een commentaar dat eindigt aan het einde van de regel waarop ze verschijnen. Nogmaals, de hele reeks karakters is gelijk aan een gat. Deze methode is het nuttigst voor korte opmerkingen. De //-tekens kunnen worden gebruikt om commentaar te geven op /*- of */-tekens, en de /*-tekens kunnen worden gebruikt om commentaar te geven op //. 4.6. Gegevenstypen in C++ Voordat u een programma schrijft, moet u de gegevenstypen instellen. Er zijn verschillende veelgebruikte gegevenstypen in C++ (niet allemaal): Ø Numerieke gehele getallen met teken
(int, kort, char); Ø Numerieke ondertekende breuken
(zwevend, dubbel, lang (in C), lang dubbel (in C); Ø Niet-ondertekend numeriek
- alle bovenstaande typen met de toevoeging Niet-ondertekend; Ø Char
kan ook gebruikt worden als karaktertype
. Hieronder vindt u de standaardtypen en -groottes van de bijbehorende cellen. Een variabele in C/C++ wordt als volgt gedeclareerd: Int iMijnVariabele; In de bovenstaande verklaring wordt iMyVariable gedeclareerd als een geheel getalvariabele. En hier is de declaratie van een typevariabele verkoold
: Char cMijnChar; Gegevenstypen zoals int
, vlot
, verkoold
En lang
, zijn een integraal onderdeel van C/C++ en u hoeft geen code te schrijven om de compiler te vertellen wat deze woorden betekenen. Met C/C++ kunt u ook uw eigen, speciale gegevenstypen declareren. Voorbeeld 3 presenteert een programma dat de grootte van gegevenstypen in bytes afdrukt. Voorbeeld 3: #erbij betrekken Leegte belangrijkste (leegte) uit<< " (unsigned)int = " << sizeof(int) << endl;
uit<< " (unsigned)short = " << sizeof(short) << endl;
uit<< " (unsigned)char = " << sizeof(char) << endl;
uit<< " (unsigned)float = " << sizeof(float) << endl;
uit<< " (unsigned)double = " << sizeof(double) << endl;
uit<< " (unsigned)long = " << sizeof(long) << endl;
uit<< " (unsigned)long double = " << sizeof(long double) << endl;
Om de grootte van een cel van het overeenkomstige type te achterhalen, schrijft u gewoon in het programma groottevan(type). Het is een feit dat voor verschillende besturingssystemen de grootte van een cel van hetzelfde type kan verschillen (het int-type in 16-bits en 32-bits besturingssystemen is bijvoorbeeld respectievelijk 1 byte en 2 bytes). Exploitant groottevan berekent de grootte van zijn operand in bytes. De operand moet een expressie zijn die niet wordt geëvalueerd, of een typenaam tussen haakjes. Aan de exploitant groottevan kan niet worden toegepast op een functie, bitveld, ongedefinieerde klasse, leegtetype of array met niet-gespecificeerde indexgrenzen. Een byte wordt op geen enkele manier gedefinieerd door de taal anders dan het resultaat van een bewerking groottevan, precies groottevan(char) is 1. Een variabele is de naam van een geheugenlocatie die moet worden gebruikt om de waarde die wordt gewijzigd op te slaan. Om ervoor te zorgen dat het geheugen beschikbaar is voor gebruik door het programma, moet het eraan worden toegewezen. Er zijn statische en dynamische geheugentoewijzingen. Statische geheugentoewijzing vindt plaats tijdens het compileren en de blokgrootte kan niet worden gewijzigd tijdens de uitvoering van het programma. Dynamisch geheugen wordt tijdens runtime toegewezen en de grootte ervan kan afhangen van de huidige status van het programma. Het geheugengebied dat aan het programma is toegewezen, wordt gebruikt om gegevens op te slaan. Als de gegevens tijdens het gebruik kunnen veranderen, praten ze over het gebruik van variabelen, als dat niet mogelijk is, gebruik dan constanten. Om toegang te krijgen tot een variabele of constante, moet u een naam of adres gebruiken. Een variabele is een benoemd geheugengebied waarvan de waarde kan veranderen tijdens de uitvoering van het programma. Alle variabelen moeten worden gedeclareerd voor gebruik, zodat de compiler statisch geheugen kan toewijzen, dus de exacte grootte ervan moet bekend zijn. Om een variabele te declareren, moet u het volgende specificeren: naam, adres, maat(gedefinieerd per type), betekenis. Als de declaratie zich binnen een paar accolades bevindt (bijvoorbeeld in de hoofdtekst van een functie), worden de gedeclareerde variabelen als lokaal beschouwd en wordt geheugen toegewezen in het programmastapelgebied, en is de initiële waarde niet gedefinieerd. Als een variabele buiten de functielichamen wordt gedeclareerd, wordt deze als globaal beschouwd en in het gegevenssegment geplaatst en is de initiële waarde nul. Het declareren van een variabele en het toekennen van een initiële waarde wordt genoemd initialisatie. Als een functie een argument heeft, moet je variabelen declareren die hun waarden aannemen; deze variabelen worden aangeroepen formele parameters. In C++ zijn er twee classificaties die de toegang en wijziging regelen: const En vluchtig. Een constante is een benoemd geheugengebied waarvan de waarde niet kan veranderen tijdens de uitvoering van het programma. Constanten krijgen bij het declareren altijd een waarde toegewezen en kunnen later niet meer worden gewijzigd. Typ variabelen const kunnen niet worden gewijzigd, maar ze kunnen wel worden geïnitialiseerd. Kwalificatie vluchtig vertelt de compiler dat de waarde van een variabele impliciet kan worden gewijzigd. Bijvoorbeeld, wordt het adres van de globale variabele doorgegeven aan de timer van het besturingssysteem en gebruikt om in realtime te tellen. In dit geval wordt de inhoud van de variabele gewijzigd zonder expliciet een toewijzingsinstructie uit te voeren. De taal C/C++ biedt dit controlekarakterconstanten, die worden weergegeven in Tabel 2. Tabel 2. Controletekenconstanten De bekendste servicetekens: line feed (code 13), Carriage Return (code 10), Tab (code 9). Om ze in het programma op te geven in de vorm van karakterconstanten, wordt een combinatie van twee zichtbare karakters gebruikt, namelijk respectievelijk “\n”, “\r”, “\t”. Om het schuine streep-teken weer te geven, gebruikt u de constructie “\\” Er zijn vier opslagspecificaties in C: extern, statisch, registreren, automatisch. Deze specificaties vertellen de compiler hoe de gedeclareerde variabele moet worden opgeslagen. Het algemene uiterlijk van een aangifte die deze specificaties gebruikt, is: Gerelateerde informatie. IO Uitgangsfuncties: %d is een geheel getal met teken %u - geheel getal zonder teken %f is een reëel getal %s-teken Invoerfuncties: 24 Gegevenstypen in C-taal. lange int-teller; Rekenkundige constanten. of in hexadecimaal: \een belsignaal \\ backslash \b terug naar stap (onder in het boorgat) \f paginafeed \n nieuwe regel \r vervoer terug \? vraagteken \"enkel aanhalingsteken \" dubbel aanhalingsteken \ooo octale code \xhh hexadecimale code Houd er rekening mee dat een tekenconstante en een string die één enkel teken bevat, niet hetzelfde zijn: "x" is niet hetzelfde als "x". De invoer "x" geeft een geheel getal aan dat gelijk is aan de code van de letter x uit de standaardtekenset, en de invoer "x" is een tekenarray die één teken (de letter x) en "\0" bevat. Variabelen en hun beschrijvingen. In C moet elke variabele worden gedeclareerd voordat deze wordt gebruikt; Normaal gesproken worden alle variabelen aan het begin van de functie gedeclareerd, vóór de eerste instructie die moet worden uitgevoerd. De declaratie beschrijft de eigenschappen van de variabelen. Het bestaat uit een typenaam en een lijst met variabelen, bijvoorbeeld: int fahr, celsius; int lager, hoger, stap; In de declaratie kan een variabele als volgt worden geïnitialiseerd: char esc = "\\" ; Aan elke variabele in een declaratie kan een const-kwalificatie worden gegeven om aan te geven dat de waarde ervan niet verder zal veranderen. const dubbele e = 2,71828182845905; const char msg = "waarschuwing: "; Wanneer toegepast op een array, geeft de const-kwalificatie aan dat geen van de elementen ervan zal veranderen. De const-hint kan ook worden toegepast op een array-argument om aan te geven dat de functie de array niet wijzigt: int strlen(const char); De reactie op een poging om een variabele te wijzigen die is gemarkeerd met de kwalificatie const, hangt af van de implementatie van de compiler. Unaire operaties in C. De operator voor verhogen ++ telt 1 op bij de operand, en de operator voor verlagen -- trekt er 1 af. Het ongebruikelijke aan de operatoren ++ en -- is dat ze beide als voorvoegsel kunnen worden gebruikt (door voor een variabele te plaatsen: + +n) en als postfix (door na de variabele te plaatsen: n++) operatoren. In beide gevallen wordt de waarde van n met 1 verhoogd, maar de uitdrukking ++n verhoogt n voordat de waarde ervan wordt gebruikt, en n++ daarna. Bitsgewijze bewerkingen in C. C heeft zes operators voor het manipuleren van bits. Ze kunnen alleen worden toegepast op operanden met gehele getallen, dat wil zeggen operanden van het type char, short, int en long, ondertekend en niet-ondertekend. & - bitsgewijze AND. | - bitsgewijze OF. ^ - bitsgewijze exclusieve OR.<< - сдвиг влево. >> - schuif naar rechts. ~ - bitsgewijze negatie (unair). De operator & (bitsgewijze AND) wordt vaak gebruikt om een groep bits op nul te zetten. Bijvoorbeeld, n = n & 0177 reset alle bits in n behalve de laagste zeven. Exploitant | (bitwise OR) wordt gebruikt om bits in te stellen; dus x = x! SET_ON stelt eenheden in die bits van x in die overeenkomen met eenheden in SET_ON. De bitsgewijze operatoren & en | moet worden onderscheiden van de logische operatoren && en ||, die naar waarheid evalueren wanneer ze van links naar rechts worden geëvalueerd. Als x bijvoorbeeld 1 is en y 2, dan levert x & y een nul op, en x && y een één. De operator ^ (bitwise exclusive OR) stelt elke bit in op 1 als de corresponderende bits van de operanden verschillende waarden hebben, en op 0 als ze hetzelfde zijn. Exploitanten<< и >> verschuif de linker operand naar links of rechts met het aantal bitposities gespecificeerd door de rechter operand, dat niet-negatief mag zijn. Ja, x<< 2 сдвигает значение х влево на 2 позиции, заполняя освобождающиеся биты нулями, что эквивалентно умножению х на 4. Сдвиг вправо беззнаковой величины всегда сопровождается заполнением освобождающихся разрядов нулями. Сдвиг вправо знаковой величины на одних машинах происходит с распространением знака ("арифметический сдвиг"), на других - с заполнением освобождающихся разрядов нулями ("логический сдвиг"). De unaire operator ~ “inverteert” een geheel getal bitsgewijze, dat wil zeggen, het verandert elke bit in een nulbit en omgekeerd. Met x = x & ~077 worden bijvoorbeeld de laatste 6 cijfers in x gereset. Voorwaardelijke uitspraken in C. Voorwaardelijke if-instructie Syntaxis: a) verkorte vorm als (<выр>) <оператор1>; b) volledige vorm als (<выр>) <оператор1>; anders<оператор2>; Uitdrukking<выр>kan rekenkundig, logisch of relationeel zijn. Als de waarde<выр>niet gelijk is aan nul, dan wordt deze uitgevoerd<оператор1>. In volledige vorm als<выр>is dan gelijk aan nul<оператор2>. Voorwaardelijke drievoudige werking (? :) Syntaxis: <выр1> ? <выр2> : <выр3>; De waarde wordt eerst berekend<выр1>. Als deze niet nul (waar) is, wordt de waarde berekend<выр2>. Betekenis<выр3>niet berekend. Als de waarde<выр1>gelijk is aan nul (onwaar), dan wordt de waarde berekend<выр3>. Berekening van de waarde<выр2>wordt niet geproduceerd. Teken = x<0 ? -1: 1; 35. Wisseloperator. Schakelaars Syntaxis: schakelaar(<выр>) geval<константа_1> : <операторы_1>; geval<константа_2> : <операторы_2>; geval<константа_L> : <операторы_L>; standaard:<операторы>; Bij het invoeren van een wissel wordt de waarde berekend<выр>. Als het overeenkomt met een van de constanten, worden de instructies die zijn opgegeven in de overeenkomstige casusvertakking uitgevoerd. Bijvoorbeeld als<выр>==<константа_L>, dan zijn ze vervuld<операторы_L>. Als de waarde<выр>komt niet overeen met een van de constanten, dan worden de operators die na de standaardinstelling zijn opgegeven, uitgevoerd. Als er onder de operators van de uitvoerende vertakking geen transitieoperator is (break, goto, return, exit()), dan worden de operators van de volgende vertakking uitgevoerd. Als er een break-operator wordt aangetroffen onder de operators van de uitvoerende tak, wordt na de overstap de controle overgedragen aan de operator. Als er een goto-instructie wordt aangetroffen, wordt de controle overgedragen naar het opgegeven label. De standaardvertakking kan zich overal in de groep switchvertakkingen bevinden. schakelaar (operand) ( geval VERMENIGVULDIG: x *= y; pauze; geval DELEN: x /= y; pauze; geval TOEVOEGEN: x += y; pauze; geval AFTREKKEN: x -= y; pauze; geval INCREMENT2: x++; geval INCREMENT1: x++; pauze; case MOD: printf("Niet gedaan\n"); pauze; standaard: printf("Bug!\n"); Als operand == VERMENIGVULDIG, dan wordt x *= y uitgevoerd; en de switchverwerking (en programma-uitvoering) zal eindigen. Als operand == INCREMENT2, dan wordt x++ uitgevoerd; x++; en de schakelverwerking wordt voltooid. Als de operand EXPONENT, ROOT of MOD is, dan printf("Not done\n"); pauze; 36. Lusoperatoren in C. Parametrisch voor lus Syntaxis: voor ([<выр1>]; [<выр2>]; [<выр3>]) <оператор>; <оператор>wordt herhaald tot<выр2>accepteert de waarde 0 (“false”) niet. VOOR de EERSTE iteratie van de lus wordt de waarde berekend<выр1>. Meestal wordt dit gebruikt om een lusteller te initialiseren. Vervolgens wordt de waarde berekend<выр2>. NA ELKE iteratie wordt de waarde berekend<выр3>. Dit wordt meestal gebruikt om de lusteller te verhogen. Vervolgens wordt de waarde berekend<выр2>. <выр1>En<выр3>kan uit verschillende uitdrukkingen bestaan, gescheiden door komma's. Alle luskopparameters zijn optioneel, maar beide ';'-scheidingstekens moeten aanwezig zijn. Dat wil zeggen, de formulieren zijn acceptabel Voor(<выр1>;;) <оператор>; Voor(;<выр2>;) <оператор>; Voor(;;<выр3>) <оператор>; Voor(<выр1>;;<выр3>) <оператор>; Indien vermist<выр2>, dan wordt de waarde ervan beschouwd als gelijk aan 1 (“waar”). Lus met voorwaarde while Syntaxis: terwijl (<выр>) <оператор>; <оператор> <выр> <выр>wordt VOOR elke iteratie berekend. Lus met do ... while postcondition Syntaxis: Doen<оператор>terwijl (<выр>); <оператор>opnieuw uitgevoerd tot de waarde<выр>blijft niet-nul. Betekenis<выр>wordt NA elke iteratie berekend. Ontwerp van functies. 39. Structuur van een C-programma. Rassen van variabelen. void main() /* hoofdprogramma */ intx,y,z; /* declaratie van variabelen van het type geheel getal */ x=5; y=6; /* toewijzingsoperatoren */ printf("som=%d\n",z); /* standaardfunctie voor uitvoer vanuit de bibliotheek. */ Variabelen zijn nodig wanneer het nodig is om informatie in het geheugen van de computer op te slaan, bijvoorbeeld tussenresultaten van berekeningen, enz. Bijna geen enkel programma kan zonder hen. Een variabele is een RAM-gebied met een toegewezen naam waarmee dit gebied toegankelijk is. De naam mag maximaal 247 tekens lang zijn en moet altijd beginnen met een letter van het Latijnse alfabet of een onderstrepingsteken, gevolgd door andere letters, cijfers en onderstrepingstekens. Karaktergeval is belangrijk. Variabelen kunnen verschillende gegevens opslaan, en hun type hangt hiervan af. Er zijn nogal wat verschillende soorten variabelen in C++, ze zijn onderverdeeld in geheel getal, fractioneel, logisch en karakter. Er is ook een apart type voor strings, maar dat is een aparte discussie. Typen gehele getallen omvatten typen zoals int, short (short int) en long. Variabelen van het type int nemen 32 bits geheugen in beslag. Korte variabelen zijn twee keer zo ‘korter’ dan de naam doet vermoeden. Ze nemen 16 bits geheugen in beslag. Variabelen van het type long zijn respectievelijk twee keer zo lang en nemen 64 bits geheugen in beslag. Naast de vermelde typen gehele getallen zijn er varianten zonder teken. Zoals je misschien hebt gemerkt, kunnen integer-variabelen zowel positieve als negatieve waarden aannemen. Niet-ondertekende integer-variabelen kunnen alleen positieve waarden of nulwaarden aannemen. Om een variabele niet-ondertekend te maken, moet u het type vooraf laten gaan door het trefwoord unsigned, gescheiden door een spatie. Fractionele typen omvatten respectievelijk float en dubbele, enkele en dubbele precisie fractionele getallen. Variabelen van het eerste type bezetten 32 bits in het geheugen, het tweede type - 64. Er is slechts één logisch type, en dat heet bool. Zoals de naam al doet vermoeden, is dit type ontworpen om de logische waarden "true" (true) of "false" (false) op te slaan. Het karaktertype is ook het enige. Het wordt char genoemd en kan één teken, preciezer gezegd, het nummer ervan, opslaan in ASCII-codering, in dit opzicht ligt dit type dicht bij integer-typen. Het bereik van waarden van het char-type is gehele getallen van -128 tot 127 (van 0 tot 255 voor niet-ondertekende char), dat wil zeggen alle tekens van het Latijnse en nationale alfabet, cijfers, leestekens en speciale tekens zoals regeleinde enz. Houd er rekening mee dat afzonderlijke tekens in C++ tussen apostrofs staan. Strings als afzonderlijk type verschenen alleen in C++, in gewoon C, strings waren letterlijk arrays van karakters, en het werken ermee leek in veel opzichten op het werken met arrays. Adres rekenkunde. kan anders zijn: resultaat van type int* Aanwijzers en functies. Pointers en dynamische geheugentoewijzing werden kort geïntroduceerd in paragraaf 2.2. Een pointer is een object dat het adres van een ander object bevat en indirecte toegang mogelijk maakt manipuleer dit object. Meestal worden er pointers gebruikt om mee te werken dynamisch gemaakte objecten om gerelateerde datastructuren te bouwen, zoals als gekoppelde lijsten en hiërarchische bomen, en om groot door te geven objecten – arrays en klasseobjecten – als parameters. Elke aanwijzer is gekoppeld aan een bepaald gegevenstype en hun interne gegevens representatie is onafhankelijk van het interne type: en de grootte van het geheugen dat door het object wordt ingenomen type aanwijzer, en hun waardenbereik is hetzelfde5. Het verschil is hoe de compiler neemt het geadresseerde object waar. Verwijzingen naar verschillende typen kunnen hebben dezelfde waarde, maar het geheugengebied waar de overeenkomstige typen zich bevinden, kan anders zijn: geheugen 1000-1003 (in een 32-bits systeem); geheugen 1000-1007 (in een 32-bits systeem). Wanneer we de adresoperator (&) toepassen op een object van het type int, krijgen we resultaat van type int* Naarmate uw programma's groter en complexer worden, moet u ze opsplitsen in kleine, gemakkelijk te beheren stukjes die functies worden genoemd. Elke functie in uw programma moet een specifieke taak uitvoeren. Als u bijvoorbeeld een betalingsprogramma schrijft, kunt u één functie maken die het aantal uren bepaalt dat een werknemer werkt, een tweede functie die de uitbetaling van overuren bepaalt, een derde functie die afdrukt, enz. Als het programma een specifieke taak moet uitvoeren taak, roept het de juiste function aan en voorziet deze functie van de informatie die deze nodig heeft tijdens de verwerking. Formaat invoer/uitvoer. Met twee functies: printf voor uitvoer en scanf voor invoer (volgende sectie) kunt u numerieke waarden converteren naar symbolische representatie en terug. Ze maken het ook mogelijk dat formatstrings worden gegenereerd en geïnterpreteerd. Functie printf(controle, arg1, arg2, ...) converteert de argumenten naar tekstvorm volgens de formaten gespecificeerd in de controleregel en drukt af resultaat naar standaarduitvoer. De controlstring bevat twee soorten objecten: gewone tekens, die eenvoudigweg worden gekopieerd naar de uitvoerstroom worden verzonden, en conversiespecificaties, die er elk voor zorgen dat het volgende argument wordt geconverteerd en afgedrukt. ment printf. Elke conversiespecificatie begint met een "%"-teken en eindigt met een conversieteken (de letter die definieert het definiëren van het type transformatie). Tussen het "%" en het conversiesymbool kan het volgende staan: Een minteken dat ervoor zorgt dat het geconverteerde argument wordt uitgelijnd op de linkerrand van het veld. Een reeks cijfers die de minimale veldbreedte specificeert. Het omgezette getal wordt afgedrukt in een veld van minimaal deze breedte, en indien nodig in een breder veld. Als het geconverteerde argument minder tekens bevat dan de opgegeven veldbreedte, wordt het links opgevuld (of rechts als links uitgelijnd is opgegeven) met opvultekens tot die breedte. Het opvulteken is doorgaans een spatie, en als de veldbreedte wordt gespecificeerd met een voorloopnul, dan zal dat teken een nul zijn (de voorloopnul betekent in dit geval niet de octale breedte van het veld). Het punt dat de breedte van het veld scheidt van de volgende rij getallen. Cijferreeks (precisie); specificeert het maximale aantal tekens in een string dat moet worden afgedrukt, of het aantal cijfers dat rechts van de komma moet worden afgedrukt voor float- of double-variabelen. Lengtemodificator l, die aangeeft dat het overeenkomstige gegevenselement van het type long is in plaats van int. De scanf-functie die invoer uitvoert, is analoog aan printf en stelt u in staat veel dingen in de tegenovergestelde richting te doen. uit dezelfde transformaties. De functie scanf(control, arg1, arg2, ...) leest tekens uit standaardinvoer, interpreteert ze volgens het formaat dat is opgegeven in het control-argument, en plaatst de resultaten in de overige argumenten. De controlelijn wordt hieronder beschreven; de andere argumenten, die elk een pointer moeten zijn, geven aan waar de op de juiste wijze geconverteerde invoer moet worden geplaatst. De controlstring bevat doorgaans conversiespecificaties die worden gebruikt voor directe interpretatie retratie van invoersequenties. De controlelijn kan het volgende bevatten: Spaties, tabs of nieuwe regels (“spaties”) die worden genegeerd; Reguliere tekens (niet %), waarvan wordt aangenomen dat ze overeenkomen met de volgende niet-witruimtetekens in de invoerstroom; Een conversiespecificatie bestaande uit een %-teken, een optioneel toewijzingsonderdrukkingsteken *, een optioneel getal dat de maximale veldbreedte specificeert, en een conversieteken. 48.Lijn is een reeks tekens die als één element wordt behandeld. De tekenreeks kan letters, cijfers en verschillende speciale tekens bevatten. In SI worden letterlijke tekenreeksen of constante tekenreeksen tussen dubbele aanhalingstekens geplaatst. Een string in SI is een array van karakters die eindigt met een nulteken ('\0'). Een string is toegankelijk via een pointer die verwijst naar het eerste karakter van de string. De waarde van een string is het adres van zijn eerste karakter. In SI is het dus correct om te zeggen dat een string een pointer is, feitelijk een pointer naar het eerste karakter van een string. Een string kan in een declaratie worden toegewezen aan een array van karakters of aan een variabele van het type teken*. Structuren. In moderne programmeertalen is er een speciaal gegevenstype dat dit kan zijn kan verschillende elementen van eenvoudigere (en verschillende!) typen bevatten. Een structuur is een gegevenstype dat meerdere velden (elementen) kan bevatten verschillende typen (inclusief andere structuren). Een van de toepassingen van structuren is het organiseren van verschillende databases, lijsten, enz. Omdat een structuur een nieuw gegevenstype is, moet deze eerst aan het begin worden gedeclareerd tekentitel; // naam, tekenreeks int jaar; // jaar van publicatie, geheel getal int-pagina's; // aantal pagina's, geheel getal Om naar de hele structuur te verwijzen, wordt de naam ervan gebruikt, en om naar een individu te verwijzen De naam van dit veld wordt gescheiden door een punt. Structuurelementen worden opeenvolgend geïntroduceerd volgens alleen. Je kunt ze in willekeurige volgorde invullen. U kunt op dezelfde manier met een structuurveld werken als en met een variabele van het juiste type: numerieke variabelen kunnen deelnemen aan de rekenkunde In logische expressies kunt u alle standaardbewerkingen op tekenreeksen uitvoeren. strcpy(b.auteur, "A.S. Poesjkin"); Structuren dienen om een grote hoeveelheid informatie te verwerken, dus meestal Het programma maakt gebruik van arrays van structuren. Ze worden op dezelfde manier aangekondigd als gewoonlijk, maar eerst In wezen (hierboven) moet u de structuur zelf declareren als een nieuw gegevenstype. Om toegang te krijgen tot een structuurveld wordt ook een punt gebruikt, maar nu moet je dit in een vierkant aangeven tussen haakjes staat bijvoorbeeld ook het nummer van de gewenste structuur voor (i = 0; ik< 20; i ++) // цикл по всем структурам в массива zet(A[i].titel); // toon de titel van het boek Structuren kunnen, net als alle andere typen, parameters zijn van functies en procedures. Werken met bestanden. Bestanden kunnen tekstbestanden zijn (waarin u alleen letters, cijfers, haakjes en enz.) en binair (waarin alle tekens uit de tabel kunnen worden opgeslagen). Tekstbestanden (hetzelfde als voor lineaire arrays) fouten door ontbrekende of onvoldoende gegevens in het bestand. Binaire bestanden Het is handig om met een binair bestand te werken wanneer de gegevens zijn geschreven (of worden gelezen) een ander programma en ze hoeven niet handmatig te worden bekeken. Het belangrijkste voordeel van deze methode is de lees- en schrijfsnelheid, aangezien de hele array in één keer als één blok wordt gelezen (of geschreven). Beschrijvingen van functies voor het werken met bestanden bevinden zich in de stdio.h-bibliotheek Eerst moet u een verwijzing maken naar een variabele van het type FILE (FILE* bestand;). Het bestand wordt geopend door de fopen-functie aan te roepen (file = fopen(file_name, "w");) De eerste parameter van deze functie is de bestandsnaam, de tweede geeft aan in welke modus het bestand geopend moet worden. "w" - open voor schrijven, "r" - open voor lezen, "a" - bestand toevoegen (dit zijn de meest gebruikte modi, hoewel er andere zijn). Het schrijven en lezen van gegevens uit een bestand wordt uitgevoerd door de volgende functies: fputc, fputs, fgetc, fgets, fprintf, fscanf (voor een beschrijving van deze functies, zie stdio.h). Het sluiten van een bestand gebeurt door de functie fclose (fclose(file);) aan te roepen. IO De C-taal zelf biedt geen invoer-/uitvoermogelijkheden. Al deze mechanismen op hoog niveau moeten worden geleverd door expliciet opvraagbare functies. Uitgangsfuncties: Int putchar(int c). Zet één teken in stdout Int fputs(int c,FILE *f). Voert één teken uit naar bestand f Int puts(char *s). Zet de string s tot aan het afsluitende teken met code 0 in de standaarduitvoer. Drukt een nieuwe regel af aan het einde Int fputs(char *s,FILE *f). Voert de tekenreeks s tot aan het laatste teken met de code uit in bestand f. Int printf(). Drukt tekst in het opgegeven formaat af naar standaarduitvoer. De formaatbeschrijving begint met het %-symbool %d is een geheel getal met teken %u - geheel getal zonder teken %f is een reëel getal %s-teken Invoerfuncties: Int getchar(void).leest één teken uit stdin Int fgetc(FILE *f).Leest één teken uit bestand f Char *fgets(char *s,int size,FILE *f). Leest uit bestand f een regel met tekens van maximale grootte, inclusief het teken voor het einde van de regel, en plaatst deze op adres s Int scanf() Leest gegevens uit standaardinvoer volgens het opgegeven formaat 24 Gegevenstypen in C-taal. C heeft soorten gehele getallen van verschillende groottes, ondertekend en niet-ondertekend, drijvende komma, tekens, enums en structs. Bovendien biedt de C-taal een unietype, waarmee u heterogene gegevens op één geheugenlocatie kunt opslaan die elkaar tijdens de levensduur niet overlappen (hierdoor kunt u geheugen besparen), of toegang krijgen tot de inhoud van een geheugengebied als gegevens van verschillende types (waarmee u de interpretatie van het gegevenstype kunt wijzigen zonder de gegevens zelf te wijzigen). Er zijn verschillende basistypen in C: char - enkele byte, kan één teken uit de geldige tekenset bevatten; int is een geheel getal, dat gewoonlijk de natuurlijke weergave van gehele getallen door de machine vertegenwoordigt; float - drijvende-kommagetal met enkele precisie; dubbel - drijvende-kommagetal met dubbele precisie. Er zijn ook verschillende kwalificaties die kunnen worden gebruikt in combinatie met de opgegeven basistypen. De korte en lange kwalificaties zijn bijvoorbeeld van toepassing op gehele getallen: lange int-teller; In dergelijke verklaringen kan het woord int worden weggelaten, wat meestal wordt gedaan. De ondertekende of niet-ondertekende kwalificaties kunnen worden toegepast op het char-type en elk integraal type. Niet-ondertekende waarden zijn altijd positief of nul en gehoorzamen aan de wetten van de modulo 2n-rekenkunde, waarbij n het aantal bits in de typerepresentatie is. Dus als een char-waarde 8 bits heeft, heeft niet-ondertekende char waarden in het bereik van 0 tot 255, en ondertekende char - van -128 tot 127 (in een binaire machine). cijfer extra code). Of waarden van het type simpelweg char ondertekend of niet-ondertekend zijn, is afhankelijk van de implementatie, maar in beide gevallen zijn de afdrukbare tekencodes positief. Het lange dubbele type is bedoeld voor uiterst nauwkeurige drijvende-kommaberekeningen. Net als bij gehele getallen zijn de afmetingen van objecten met drijvende komma afhankelijk van de implementatie; float, dubbel en lang dubbel blik Het kan één maat lijken, maar het kunnen ook twee of drie verschillende maten zijn. Rekenkundige constanten. Een geheel getalconstante, zoals 1234, is van het type int. Een lange constante eindigt met de letter l of L, bijvoorbeeld 123456789L; Een geheel getal dat te groot is om als een int te worden weergegeven, wordt als een long weergegeven. Constanten zonder teken eindigen op de letter u of U, en de uitgang ul of UL geeft aan dat het type van de constante lang zonder teken is. Drijvende-kommaconstanten hebben een decimaalteken (123,4), of een exponentieel deel (1e-2), of beide. Als ze geen einde hebben, worden ze beschouwd als dubbel. De uitgang f of F geeft het float-type aan, en de 1 of L geeft het lange dubbele type aan. Naast decimaal kan een geheel getal een octale of hexadecimale weergave hebben. Als een constante begint bij nul, wordt deze weergegeven in octale vorm; deze begint bij 0x of 0X en wordt vervolgens weergegeven in hexadecimaal. Het decimale gehele getal 31 kan bijvoorbeeld worden geschreven als 037 of als 0X1F. Octale en hexadecimale constanten kunnen worden afgesloten met L (om aan te geven dat het type lang is) en U (om aan te geven dat de constante geen teken heeft). De constante 0XFUL heeft bijvoorbeeld de waarde 15 en het type is lang zonder teken. Teken- en tekenreeksconstanten. Een tekenconstante is een geheel getal geschreven als een teken omgeven door enkele aanhalingstekens, zoals 'x'. De waarde van een tekenconstante is de numerieke code van een teken uit de tekenset op een bepaalde machine. De ASCII-tekenconstante "0" heeft bijvoorbeeld de waarde 48, wat niets te maken heeft met de numerieke waarde 0. Wanneer we "0" schrijven in plaats van een waarde (bijvoorbeeld 48), maken we het programma, afhankelijk van de coderingsmethode, onafhankelijk van de privébetekenis van de code, en is het ook gemakkelijker te lezen. Tekenconstanten kunnen net als elk ander geheel getal bij getalsbewerkingen worden gebruikt, hoewel ze vaker worden gebruikt om met andere tekens te vergelijken. Sommige tekens in teken- en tekenreeksconstanten worden geschreven met behulp van escape-reeksen, zoals \n (nieuwe regel); Dergelijke reeksen worden weergegeven door twee symbolen, maar vertegenwoordigen één. Bovendien kan een willekeurige octale code worden gespecificeerd als "\ooo", waarbij ooo één, twee of drie octale cijfers is (0...7) of "\xhh", waarbij hh één, twee of meer hexadecimale cijfers is ( 0 ...9, a...f, A...F). Dus we konden schrijven #define VTAB "013" /* verticaal tabblad in ASCII */ #define BELL "\007" /* oproep naar ASCII */ of in hexadecimaal: #define VTAB "\xb" /* verticaal tabblad in ASCII */ #define BELL "\x7" /* aanroep naar ASCII */ De volledige set ontsnappingssequenties is als volgt: \een belsignaal \\ backslash \b terug naar stap (onder in het boorgat) \f paginafeed \n nieuwe regel \r vervoer terug \t horizontaal tabblad \v verticaal tabblad \? vraagteken \"enkel aanhalingsteken \" dubbel aanhalingsteken \ooo octale code \xhh hexadecimale code De tekenconstante "\0" is een teken met een nulwaarde, het zogenaamde nulteken. In plaats van alleen 0 wordt vaak de notatie "\0" gebruikt om de symbolische aard van de uitdrukking te benadrukken, hoewel de notatie in beide gevallen nul aangeeft. Een tekenreeksconstante, of letterlijke tekenreeks, bestaat uit nul of meer tekens tussen dubbele aanhalingstekens, zoals 'Ik ben een tekenreeksconstante' of '' (de lege tekenreeks). Aanhalingstekens zijn niet opgenomen in de tekenreeks, maar dienen alleen als scheidingstekens. Net als karakterconstanten kunnen escape-reeksen in strings worden opgenomen; \" vertegenwoordigt bijvoorbeeld een dubbel aanhalingsteken. Tekenreeksconstanten kunnen tijdens het compileren worden samengevoegd ("aan elkaar gelijmd"); het schrijven van twee tekenreeksen "Hallo", "wereld!" is bijvoorbeeld gelijk aan het schrijven van één tekenreeks zoals "Hallo". , wereld!". Met deze eigenschap kunt u lange lijnen in delen opdelen en deze delen op afzonderlijke lijnen plaatsen. In feite is een stringconstante een array van karakters. De interne representatie van een string vereist een null-teken "\0", dus de string heeft één byte meer geheugen nodig dan het aantal tekens tussen de dubbele aanhalingstekens. Dit betekent dat er geen limiet is aan de lengte van de string die u opgeeft, maar dat u de hele string moet scannen om de lengte ervan te bepalen. In C worden de tekens tussen apostrofs geplaatst. Dus als we een waarde aan een variabele toekennen geroosterd type verkoold, we moeten schrijven geroosterd = "T"; /* RECHTS */, geroosterd = T; /* FOUT */ Als de apostrofs worden weggelaten, "denkt" de compiler dat we een variabele gebruiken met de naam T, die ze vergaten te beschrijven. De C-taalstandaard heeft de regel aangenomen dat de waarden van een variabele of constante van het type zijn verkoold er kunnen slechts enkele tekens zijn. Dienovereenkomstig is de onderstaande reeks instructies ongeldig omdat deze probeert toe te wijzen aan een variabele rund een waarde bestaande uit twee tekens: ehar runderen; rund = "os"; /*FOUT */ Als u naar de ASCII-codetabel kijkt, ziet u dat sommige "tekens" daarin niet worden afgedrukt. Wanneer u bijvoorbeeld tekennummer 7 in een programma gebruikt, maakt de computerterminal een pieptoon. Maar hoe gebruik je een teken dat niet op het toetsenbord kan worden getypt? Er zijn twee manieren om dit te doen in de C-taal. IN eerste methode de ASCII-code zelf wordt gebruikt. U hoeft alleen het tekennummer op te geven samen met de voorafgaande backslash. We hebben dit al gedaan in ons gouden equivalentprogramma. Dit is de lijn piep = "07"; Er zijn hier twee belangrijke punten die u duidelijk moet begrijpen. De eerste is dat de reeks tekens op dezelfde manier tussen apostrofs wordt ingesloten als bij een gewoon teken. De tweede is dat het tekennummer in octaal moet worden geschreven. Bij het schrijven van een reeks tekens kunnen we per ongeluk nullen in de eerste posities weglaten; in dit geval zouden we de code "signaal" kunnen gebruiken "7"
of zelfs "7"
. Maar in geen geval mag u de laatste nullen in uw invoer weglaten! Karaktervolgorde "20"
kan in de vorm worden geschreven "20"
, maar niet "2"
. Bij het gebruik van ASCII-code is het belangrijk om het verschil tussen cijfers en cijfersymbolen te noteren. Het symbool bijvoorbeeld "4"
komt overeen met een ASCII-code van 52. Dit is het teken "4"
niet het nummer 4. RIJST. 3. 4. Vormen voor het schrijven van constanten van gehele typen In tweede methode Om "lastige" karakters weer te geven, worden speciale reeksen symbolen gebruikt. Dit worden ontsnappingssequenties genoemd en zien er als volgt uit: n nieuwe regel t tabblad b stap terug r vervoer terug f het formulier verzenden backslash() "apostrof (") "aanhalingstekens ("") Bij het toewijzen aan een tekenvariabele moeten deze reeksen ook tussen apostrofs worden geplaatst. We kunnen bijvoorbeeld de verklaring schrijven nerf = "n"; en druk vervolgens de variabele af nerf; hierdoor gaat u één regel vooruit op het afdrukapparaat of het beeldscherm. De eerste vijf besturingsreeksen zijn algemene tekens die zijn ontworpen om de werking van het afdrukapparaat te besturen: het teken "nieuwe regel" veroorzaakt een nieuwe regel; het "tab"-teken verplaatst de cursor of printkop over een bepaald vast aantal posities 5 of 8; het "stap terug"-symbool gaat één positie terug; Het Carriage Return-teken keert terug naar het begin van de regel; Het “form feed”-symbool zorgt ervoor dat het papier één pagina wordt ingevoerd. In de laatste drie ontsnappingssequenties de personages , "
, "
kunnen worden beschouwd als symbolische constanten [omdat ze daartoe dienen definities tekenconstanten en worden rechtstreeks in de instructie gebruikt printf(), het gebruik ervan als symbolen zou tot een fout leiden]. Als u een string wilt afdrukken. Onthoud: "het personage wordt een backslash genoemd." de operator ziet er als volgt uit: printf(" Onthoud: " het teken wordt een backslash genoemd. " n"); Hier heeft u mogelijk twee vragen. Ten eerste: waarom hebben we de ontsnappingsreeksen niet tussen apostrofs gezet? Ten tweede: wanneer moet je ASCII-code gebruiken en wanneer gebruik je de escape-reeksen die we zojuist hebben besproken? (We hopen dat dit de vragen zijn die u heeft, OMDAT dit de vragen zijn die we gaan beantwoorden.)Bereik Grootte (BT)
teken -128..127;
niet-ondertekend teken 0..255;
int-32 768.. 32 767;
niet-ondertekend int 0..65535;
lang -2 147 483 648..2 147 483 647;
ongetekend lang 0..4 294 967 295;
vlotter 3.4e-38..3.4e+38;
dubbel 1.7e-308..1.7e+308;
lang dubbel 3.4e-4932..3.4e+4932.
