Karakter- og strengkonstanter. A2.5.2
I et program Strenge eller strengkonstanter er repræsenteret af en sekvens af tegnbilleder omgivet af anførselstegn (ikke apostrof), såsom "alle tegn". Blandt tegnene i strengen kan der være escape-sekvenser svarende til koderne for ikke-repræsenterbare (specielle) tegnkonstanter.
Eksempler:
“1234567890”
"præsidiets sammensætning"
"begyndelsen af linjen \t og slutningen af linjen."
Som opsigelseskarakter Symbolet med kode 0 er valgt (må ikke forveksle det med symbolet "0"). Så definitionen
char HelloStr = "Hej verden";
faktisk tolket som
char HelloStr = ("H", "e", "l", "l", "o", " ", ", "w", "o", "r", "l", "d" , " \0");
Dette sker, når et array initialiseres med en streng. I alle andre tilfælde fortolkes den stødte streng som en unavngiven matrix af den passende længde, der endnu ikke er blevet oprettet. Altså udtrykket
printf("Hej verden\n");
faktisk tolkes som
char str1 = "Hej verden\n";
Når du placerer en streng i hukommelsen, tilføjer oversætteren automatisk tegnet '\0' til sin ende, dvs. null byte.
Antallet af elementer i et sådant array er 1 mere end i billedet af den tilsvarende strengkonstant, fordi en null-byte '\0' blev tilføjet til slutningen af linjen.
Strings har en anden funktion: oversætteren tildeler hver streng en separat plads i computerens hukommelse, selv i tilfælde hvor flere strenge falder helt sammen (SI-sprogstandarden antyder, at denne regel muligvis ikke følges i specifikke implementeringer).
Tildel en værdi til et tegnarray(dvs. en streng) kan ikke udføres ved hjælp af en almindelig tildelingsoperator. Du kan placere en streng i et array enten ved hjælp af initialisering (når du definerer et tegnarray) eller ved at bruge inputfunktioner. I funktion scanf() eller printf() for tegnstrenge bruges specifikationen transformation % s.
Eksempel:
/*udskriv en tegnstreng*/
#omfatte
( char B = "Åben Sesam!";
printf(“%s”,B); ) /*programslut*/
Resultat programudførelse: Sesam, åben!
I programmet, længden af arrayet I– 17 elementer, dvs. længden af strengen, der skal placeres i arrayet (16 tegn), plus null-byten i slutningen af strengen. Det er 17 bytes, der tildeles ved initialisering af arrayet i eksemplet ovenfor. Initialisering af et tegnarray med en strengkonstant er en stenografisk version af matrixinitialisering og blev introduceret i sproget for nemheds skyld. Du kan bruge normal initialisering ved at placere startværdierne for array-elementerne i seler og ikke at glemme at placere i slutningen af listen over begyndelsesværdier speciel karakter linje, der slutter '\0'. Således blev følgende initialisering af array B tilladt i programmet:
char B = ('C','e','z','a','m',',',','o','t','k','p','o' ,'th','s','i','!','\0');
Hvordan indtaster man strenge eller viser dem på skærmen?
Linjen kan enten udsendes af en funktion, du allerede kender printf() med inputspecifikation "%s", eller speciel funktion int puts (char *streng), som udsender en streng snor til skærmen og returnerer en værdi, der ikke er nul, hvis det lykkes.
Hvorfor har vi brug for specifikationen " %s"? Dette gøres, så du kan udskrive strenge med alle tegn. Sammenlign:
Eksempel:
char str = "Jeg ønskede at udlæse %d...";
printf("%s", str); /* Korrekt indstilling */
printf("\n"); /* Newline afgrænsning */
printf(str); /* Forkert valgmulighed */
Først og fremmest I dette tilfælde vil funktionen udskrive præcis, hvad der kræves af den. Men i anden sag printf(), efter at have mødt i køen str"%d"-specifikationen (denne linje er trods alt den første, hvilket betyder, at den angiver outputformatet) vil konkludere, at den skal efterfølges af et tal. Og da det ikke følger, i stedet for " %d" noget affald vil blive udskrevet - nummeret i øjeblikket på stakken.
Konsekvenserne kan være mere alvorlige, hvis linjen indeholder sekvensen "%s", den vil behandle den som en streng og udskrive den, indtil den støder på et nul-tegn. Og hvor hun vil møde ham, hvor meget hun får tid til at skrive, og om det vil gå ned, fordi hun ikke har adgang til sin hukommelse – ingen ved.
Linjeafslutningskonventionen skal overholdes, når der dannes strenge fra individuelle tegn i programmer. Som et eksempel kan du overveje følgende
/*læser en linje fra terminalen*/
int getline(char s, / *indtastet streng*/
int lim) /*dens maksimale længde*/
(int c, i; /* c – inputtegn */
for (i=0; i s[i] = '\0'; Streng input/output. Grundlæggende strengfunktioner
En af de mest populære I/O-operationer er I/O-operationen for tegnstrengen. String I/O-funktioner er inkluderet i SI-biblioteket til udveksling af data via standard input/output-strømme får()
Og sætter(),
som er praktiske at bruge ved oprettelse af dialogsystemer. Til input linje der er en funktion med en prototype char *får (char *streng), som læser en linje fra tastaturet og lægger den i en buffer snor, en pegepind, som den vender tilbage til. Hvis der opstår en fejl, returneres EOF. Funktionen har kun én argument – pointer s <
stdio.
h>.
gets() funktion afslutter sit arbejde når du indtaster et tegn ‘\
n’
, som automatisk overføres fra tastaturet til computeren, når der trykkes på en tast Her skal du være opmærksom på følgende funktion ved at indtaste data fra tastaturet. Fungere får()
begynder først at behandle information fra tastaturet efter at have trykket på en tast <
Gå ind>.
Den "venter", indtil den bliver ringet op nødvendige oplysninger og der trykkes på tasten<Gå ind>. Først herefter begynder dataindtastningen i programmet. Eksempel:
#omfatte int main (void) ( printf("Indtast en streng:"); printf("Strenginputtet var: %s\n", string); Fungere sætter()
(linjeudgang til skærmen), hvis det lykkedes, returnerer det sidst udskrevne tegn, som altid er et tegn ‘\
n"
, hvis der opstår en fejl, returneres den fra EOF-funktionen. Prototypen af denne funktion ser sådan ud: int puts(char*s); /*string output funktion*/ Funktionen har kun én argument – pointer s til en række karakterer. Funktionsprototypen er beskrevet i filen <
stdio.
h>.
Lad os give det enkleste eksempel
brug af disse funktioner. #omfatte char strl = "indtast medarbejderens efternavn:"; Husk, at enhver streng af tegn i SI-sproget skal ende med et nul-tegn ‘\0’
. I sidste element array strl Null-tegnet skrives automatisk under oversættelsen, når arrayet initialiseres. Til funktion sætter () Tilstedeværelsen af et nul-tegn i slutningen af strengen er påkrævet. Ellers, dvs. når der ikke er noget tegn i tegnarrayet‘\0’
, kan programmet afslutte unormalt, fordi fungeresætter
()
på jagt efter et nul-tegn, vil det gå gennem al tilgængelig hukommelse byte for byte, startende, i vores eksempel, fra adressen strl
.
Dette skal huskes, hvis programmet genererer en streng for at vise den på skærmen. Eksempel
:
#omfatte int main (void) ( char string = "Dette er et eksempel på en udgangsstreng\n"; String manipulation funktioner
Da der ikke er nogen foruddefineret type for en streng i C, er der ingen operationer, der er så velkendte for mange, såsom at sammenligne og sammenkæde strenge, implementeret på mange sprog som additions- og sammenligningsoperatorer. Her er tilføjelse af arrays ikke tilladt, og ved sammenligning sammenlignes ikke strengene selv, men kun pointer på dem, hvilket selvfølgelig ikke er interessant for os. Til strengmanipulation er der erklæret et sæt funktioner i filen De vigtigste funktioner: int strcmp (char *string1, char *string2) udfører sammenligne to strenge.
Vender tilbage et negativt tal, hvis den første række er mindre end den anden, 0, hvis rækkerne er ens og et positivt tal, hvis den første række er større end den anden. Mere detaljeret returnerer funktionen forskellen mellem koderne for de første ulige tegn, der stødes på (hvis strengene er ulige i længden, vil et ikke-nul tegn blive sammenlignet med nul). Eksempel
:
#omfatte #omfatte int main (void) ( char *buf1 = "aaa", *buf2 = "bbb", *buf3 = "ccc"; ptr = strcmp(buf2, buf1); hvis (ptr > 0) printf("buffer 2 er større end buffer 1 \n"); printf("buffer 2 er mindre end buffer 1 \n"); ptr = strcmp(buf2, buf3); printf("buffer 2 er større end buffer 3\n"); printf("buffer 2 er mindre end buffer 3\n"); Følgende vises på skærmen: buffer 2 er større end buffer 1 buffer 2 er mindre end buffer 3 char *strcpy (char *dest, char *source) udfører kopiering linjer kilde i stedet for linjen dest. Igen skal du sørge for, at hele linjen passer ind i det rum, der er tilvejebragt. Funktionen returnerer en markør til destinationsstrengen. Eksempel:
#omfatte #omfatte int main (void) ( char *str1 = "a b c d e f g h i"; strcpy(streng, str1); printf("%s \n", streng); Skærmen viser: a b c d e f g h I char *strcat (char *string1, char *string2) udfører sammenkædning af to linjer. Den anden linje føjes til slutningen af den første. Funktionen kontrollerer ikke (og kan teknisk set ikke kontrollere) tilstedeværelsen af den nødvendige mængde hukommelse i slutningen af den første linje - det skal du sørge for. Funktionen returnerer en markør til den første række. Eksempel:
#omfatte #omfatte int main(void) ( char destination; char *blank = " ", *c = "C++", *turbo = "Turbo"; strcpy(destination, turbo); //Kopiér strengen "turbo" på plads bestemmelsessted strcat(destination, blank); // Limning bestemmelsessted... strcat(destination, c); // først med blank, så med c printf("%s\n", destination); Skærmen vises: Turbo C++ int strlen (char *streng) vender tilbage linjelængdesnor
(ikke medregnet null-tegnet). char *strdup (char *streng) skaber dublet linjesnor
og returnerer en markør til den. Bemærk venligst, at i modsætning til andre funktioner, strdup opretter en streng selv, og glem derfor ikke at frigøre den, når du ikke længere har brug for den. char *strncpy (char *dest, char *source, int count) char *strncat (char *string1, char *string2, int count) tilsvarende strcpy Og strcat, men kun de første kopieres tælle tegn. Funktionerne tilføjer ikke en afsluttende null til strengen – det skal du selv gøre. char *strchr (char *streng, int c) char *strstr (char *streng, char *understreng) leder efter første hændelse at line snor henholdsvis symbol c og understrenge understreng. Begge funktioner returnerer adressen på den første forekomst eller NUL, hvis en ikke findes. Eksempel
:
int main (void) ( char *ptr, c = "r"; //Opret en linje strcpy(streng, "Dette er en streng"); ptr = strchr(streng, c); printf("Tegnet %c er på position: %d\n", c, ptr-streng); printf("Tegnet var ikke fundet\n"); Input Output Output funktioner: %d er et signeret heltal %u - usigneret heltal %f er et reelt tal %s-tegn Input funktioner: 24 C sprog datatyper. lang int tæller; Aritmetiske konstanter. eller i hexadecimal: \ et klokkesignal \\ omvendt skråstreg \b tilbage til trin (ned) \f sidefeed \n ny linje \r vogn retur \? spørgsmålstegn \" enkelt citat \ooo oktal kode \xhh hexadecimal kode Vær omhyggelig med at huske, at en tegnkonstant og en streng, der indeholder et enkelt tegn, ikke er det samme: "x" er ikke det samme som "x". Indtastningen "x" angiver en heltalsværdi svarende til koden for bogstavet x fra standardtegnsættet, og indtastningen "x" er et tegnarray, der indeholder ét tegn (bogstavet x) og "\0". Variabler og deres beskrivelser. I C skal enhver variabel deklareres, før den bruges; Typisk er alle variable erklæret i begyndelsen af funktionen, før den første instruktion, der skal udføres. Deklarationen beskriver variablernes egenskaber. Den består af et typenavn og en liste over variabler, for eksempel: int fahr, celsius; int nedre, øvre, trin; I dens erklæring kan en variabel initialiseres på følgende måde: char esc = "\\" ; Enhver variabel i en erklæring kan gives en const-kvalifikation for at angive, at dens værdi ikke vil ændre sig yderligere. const double e = 2,71828182845905; const char msg = "advarsel: "; Når den anvendes på en matrix, angiver const-kvalifikationen, at ingen af dens elementer vil ændre sig. Const-hintet kan også anvendes på et array-argument for at angive, at funktionen ikke ændrer arrayet: int strlen(const char); Svaret på et forsøg på at ændre en variabel markeret med const-kvalifikationen afhænger af compilerimplementeringen. Unære operationer i C. Inkrementoperatoren ++ tilføjer 1 til sin operand, og dekrementoperatoren -- trækker 1 fra. Det usædvanlige ved ++ og -- operatorerne er, at de kan bruges både som præfiks (ved at placere foran en variabel: + +n) og som postfix (ved at placere efter variablen: n++) operatorer. I begge tilfælde øges værdien af n med 1, men udtrykket ++n øges n før dens værdi bruges, og n++ efter. Bitvise operationer i C. C har seks operatorer til at manipulere bits. De kan kun anvendes på heltalsoperander, dvs. på operander char typer, kort, int og lang, underskrevet og usigneret. & - bitvis OG. | - bitvis ELLER. ^ - bitvis eksklusiv ELLER.<< - сдвиг влево. >> - skift til højre. ~ - bitvis negation (unær). Operatoren & (bitvist OG) bruges ofte til at nulstille en gruppe bits. For eksempel, n = n & 0177 nulstiller alle bit i n undtagen de laveste syv. Operatør | (bitvis OR) bruges til at sætte bit; altså x = x! SET_ON sætter enheder i de bits af x, der svarer til enheder i SET_ON. De bitvise operatorer & og | skal skelnes fra logiske operatorer&& og ||, som, når de evalueres fra venstre mod højre, producerer en sandhedsværdi. For eksempel, hvis x er 1 og y er 2, så vil x & y give et nul, og x && y vil give et et. Operatoren ^ (bitwise exclusive OR) vil sætte hver bit til 1, hvis de tilsvarende bits af operanderne har forskellige betydninger, og 0, når de falder sammen. Operatører<< и >> skift til venstre eller højre dens venstre operand med antallet af bitpositioner angivet af højre operand, som skal være ikke-negativ. Ja, x<< 2 сдвигает значение х влево на 2 позиции, заполняя освобождающиеся биты нулями, что эквивалентно умножению х на 4. Сдвиг вправо беззнаковой величины всегда сопровождается заполнением освобождающихся разрядов нулями. Сдвиг вправо знаковой величины на одних машинах происходит с распространением знака ("арифметический сдвиг"), на других - с заполнением освобождающихся разрядов нулями ("логический сдвиг"). Den unære operator ~ "inverterer" et heltal bitvis, det vil sige, at den forvandler hver enkelt bit til en nulbit og omvendt. For eksempel nulstiller x = x & ~077 de sidste 6 cifre i x. Betingede erklæringer i C. Betinget hvis erklæring Syntaks: a) forkortet form hvis (<выр>) <оператор1>; b) fuld formular hvis (<выр>) <оператор1>; andet<оператор2>; Udtryk<выр>kan være aritmetiske, logiske eller relationelle. Hvis værdien<выр>er ikke lig med nul, så udføres den<оператор1>. I fuld form hvis<выр>er altså lig nul<оператор2>. Betinget tredobbelt operation (? :) Syntaks: <выр1> ? <выр2> : <выр3>; Værdien beregnes først<выр1>. Hvis den ikke er nul (sand), så beregnes værdien<выр2>. Betyder<выр3>ikke beregnet. Hvis værdien<выр1>er nul (falsk), så beregnes værdien<выр3>. Beregning af værdi<выр2>er ikke produceret. Tegn = x<0 ? -1: 1; 35. Skift operatør. Afbrydere Syntaks: kontakt(<выр>) sag<константа_1> : <операторы_1>; sag<константа_2> : <операторы_2>; sag<константа_L> : <операторы_L>; Standard:<операторы>; Ved indtastning af en switch beregnes værdien<выр>. Hvis det matcher en af konstanterne, udføres sætningerne specificeret i den tilsvarende kasusgren. For eksempel hvis<выр>==<константа_L>, så er de opfyldt<операторы_L>. Hvis værdien<выр>ikke matcher nogen af konstanterne, så udføres de operatorer, der er angivet efter standard. Hvis der blandt operatørerne af den udførende gren ikke er nogen overgangsoperator (break, goto, return, exit()), så udføres operatørerne af den næste gren. Hvis en pauseoperatør støder på blandt operatørerne af den udførende filial, overføres kontrollen til operatøren efter skiftet. Hvis en goto-sætning stødes på, overføres kontrollen til den angivne etiket. Standardgrenen kan være placeret hvor som helst i gruppen af skiftegrene. switch (operand) ( kasus MANGE: x *= y; pause; case DIVIDE: x /= y; pause; tilfælde ADD: x += y; pause; kasus SUBTRAKT: x -= y; pause; case INCREMENT2: x++; case INCREMENT1: x++; pause; case MOD: printf("Ikke udført\n"); pause; default: printf("Bug!\n"); Hvis operand == MULTIPERER, så vil x *= y blive udført; og switch-behandling (og programudførelse) afsluttes. Hvis operand == INCREMENT2, så vil x++ blive udført; x++; og skiftbehandlingen afsluttes. Hvis operand er EXPONENT, ROOT eller MOD, så printf("Ikke udført\n"); pause; 36. Sløjfeoperatører i C. Parametrisk for loop Syntaks: til ([<выр1>]; [<выр2>]; [<выр3>]) <оператор>; <оператор>gentages indtil<выр2>vil ikke acceptere værdien 0 ("false"). FØR FØRSTE iteration af løkken beregnes værdien<выр1>. Typisk bruges dette til at initialisere en loop-tæller. Derefter beregnes værdien<выр2>. EFTER HVER iteration beregnes værdien<выр3>. Dette bruges normalt til at øge sløjfetælleren. Derefter beregnes værdien<выр2>. <выр1>Og<выр3>kan bestå af flere udtryk adskilt af kommaer. Alle loop-header-parametre er valgfrie, men begge ';'-afgrænsninger skal være til stede. Det vil sige, at formerne er acceptable Til(<выр1>;;) <оператор>; Til(;<выр2>;) <оператор>; Til(;;<выр3>) <оператор>; Til(<выр1>;;<выр3>) <оператор>; Hvis der mangler<выр2>, så anses dens værdi for at være lig med 1 ("sand"). Løkke med forudsætning mens Syntaks: mens (<выр>) <оператор>; <оператор> <выр> <выр>beregnes FØR hver iteration. Løkke med do ... mens postcondition Syntaks: gør<оператор>mens (<выр>); <оператор>genudført indtil værdien<выр>forbliver ikke-nul. Betyder<выр>beregnes EFTER hver iteration. Design af funktioner. 39. Opbygning af et C-program. Variationer af variable. void main() /* hovedprogram */ int x,y,z; /* erklæring af variabler af heltalstype */ x=5; y=6; /* tildelingsoperatører */ printf("sum=%d\n",z); /* standardfunktion til output fra biblioteket. */ Variabler er nødvendige, hvor det er nødvendigt at gemme information i computerens hukommelse, for eksempel mellemresultater af beregninger osv. Næsten intet program kan undvære dem. En variabel er et område af RAM med et tildelt navn, hvorigennem dette område kan tilgås. Navnet kan være op til 247 tegn langt og skal altid begynde med et bogstav i det latinske alfabet eller en understregning, som kan efterfølges af andre bogstaver, tal og understregninger. Karakterstilfælde betyder noget. Variabler kan lagre forskellige data, og deres type afhænger af dette. Der er en del forskellige typer variabler i C++, de er opdelt i heltal, brøk, logisk og tegn. Der er også en separat type for strenge, men det er en separat diskussion. Heltalstyper omfatter typer såsom int, kort (kort int) og lang. Variabler af typen int optager 32 bit i hukommelsen. Korte variabler er dobbelt så "kortere", som navnet antyder. De optager 16 bits hukommelse. Variabler af typen long er henholdsvis dobbelt så lange og optager 64 bit i hukommelsen. Ud over de anførte heltalstyper er der deres usignerede varianter. Som du måske har bemærket, kan heltalsvariabler antage både positive og negative værdier. Heltalsvariabler uden fortegn kan kun have positive eller nul værdier. For at gøre en variabel uden fortegn, skal du foran typen med nøgleordet unsigned, adskilt af et mellemrum. Brøktyper omfatter henholdsvis flydende og dobbelt - enkelt- og dobbeltpræcisionsbrøktal. Variabler af den første type optager 32 bit i hukommelsen, den anden type - 64. Der er kun én logisk type, og den hedder bool. Som navnet antyder, er denne type designet til at gemme de logiske værdier "true" (true) eller "false" (false). Tegntypen er også den eneste. Det kaldes char og kan gemme ét tegn, mere præcist, dets nummer i ASCII-kodning, i denne henseende er denne type tæt på heltalstyper. Udvalget af værdier for tegntypen er heltal fra -128 til 127 (fra 0 til 255 for tegn uden fortegn), det vil sige alle tegn i det latinske og nationale alfabet, tal, tegnsætningstegn og specialtegn såsom linjeskift , etc. Det skal huskes, at enkelte tegn i C++ er omgivet af apostrof. Strenge som en separat type optrådte kun i C++; i almindelig C var strenge bogstaveligt talt rækker af tegn, og arbejdet med dem svarede på mange måder til at arbejde med arrays. Adresseregning. kan være anderledes: resultat af type int* Pointer og funktioner. Pointere og dynamisk hukommelsesallokering blev kort introduceret i afsnit 2.2. En pointer er et objekt, der indeholder adressen på et andet objekt og tillader indirekte manipulere dette objekt. Typisk bruges pointere til at arbejde med dynamisk oprettede objekter til at bygge relaterede datastrukturer, som f.eks som sammenkædede lister og hierarkiske træer, og til at passere store objekter – arrays og klasseobjekter – som parametre. Hver pointer er forbundet med en eller anden datatype og deres interne repræsentation er uafhængig af den interne type: og størrelsen af hukommelsen optaget af objektet type pointer, og deres værdiområde er det samme5. Forskellen er hvordan compileren opfatter det adresserede objekt. Pointers til forskellige typer kan have den samme værdi, men hukommelsesområdet, hvor de tilsvarende typer er placeret, kan være anderledes: hukommelse 1000-1003 (i et 32-bit system); hukommelse 1000-1007 (i et 32-bit system). Når vi anvender adresseoperatoren (&) på et objekt af typen int, får vi resultat af type int* Efterhånden som dine programmer øges i størrelse og kompleksitet, bør du opdele dem i små, let overskuelige stykker kaldet funktioner. Hver funktion i dit program skal udføre en bestemt opgave. Hvis du for eksempel skriver et betalingsprogram, kan du oprette en funktion, der bestemmer antallet af timer, en medarbejder arbejder, en anden funktion, der bestemmer overtidsbetaling, en tredje funktion, der udskriver osv. Hvis programmet skal udføre en bestemt opgave, kalder den den relevante funktion , og giver denne funktion de oplysninger, den skal bruge under behandlingen. Formater input/output. To funktioner: printf for output og scanf for input (næste afsnit) giver dig mulighed for at konvertere numeriske værdier til symbolsk repræsentation og tilbage. De gør det også muligt at generere og fortolke formatstrenge. Fungere printf(kontrol, arg1, arg2, ...) konverterer argumenterne til tekstform i henhold til de formater, der er angivet i kontrollinjen og udskriver resultat til standard output. Kontrolstrengen indeholder to typer objekter: almindelige tegn, som blot kopieres sendes til outputstrømmen, og konverteringsspecifikationer, som hver især forårsager, at det næste argument konverteres og udskrives. ment printf. Hver konverteringsspecifikation begynder med et "%"-tegn og slutter med et konverteringstegn (det bogstav, der definerer definere transformationstypen). Mellem "%" og konverteringssymbolet kan der være: Et minustegn, der får det konverterede argument til at blive justeret til venstre kant af feltet. En række af tal, der angiver den mindste feltbredde. Det konverterede tal vil blive udskrevet i et felt med mindst denne bredde, og i et bredere felt, hvis det er nødvendigt. Hvis det konverterede argument har færre tegn end den angivne feltbredde, vil det blive polstret til venstre (eller højre, hvis venstrejusteret blev angivet) med udfyldningstegn op til denne bredde. Udfyldningstegnet er normalt et mellemrum, og hvis feltbredden er angivet med et indledende nul, så vil dette tegn være et nul (det indledende nul betyder i dette tilfælde ikke feltets oktale bredde). Punktet, der adskiller feltets bredde fra den næste tallinje. Streng af cifre (præcision); angiver det maksimale antal tegn i en streng, der skal udskrives, eller antallet af cifre, der skal udskrives til højre for decimaltegnet for flydende eller dobbelte variable. Længdemodifikator l, som angiver, at det tilsvarende dataelement er af typen long frem for int. Scanf-funktionen, der udfører input, er analog med printf og giver dig mulighed for at gøre mange ting i den modsatte retning. fra de samme transformationer. Funktionen scanf(control, arg1, arg2, ...) læser tegn fra standardinput, fortolker dem i henhold til formatet angivet i kontrolargumentet og placerer resultaterne i de resterende argumenter. Kontrollinjen er beskrevet nedenfor; de andre argumenter, som hver skal være en pointer, angiver, hvor det korrekt konverterede input skal placeres. Kontrolstrengen indeholder normalt konverteringsspecifikationer, der bruges til direkte fortolkning tilbagetrækning af inputsekvenser. Kontrollinjen kan indeholde: Mellemrum, tabulatorer eller nye linjer ("blanks"), der ignoreres; Almindelige tegn (ikke %), som antages at matche følgende ikke-mellemrumstegn i inputstrømmen; En konverteringsspecifikation bestående af et %-tegn, et valgfrit tildelingsundertrykkelsestegn *, et valgfrit tal, der angiver den maksimale feltbredde, og et konverteringstegn. 48.Linje er en sekvens af tegn, der behandles som ét element. Strengen kan indeholde bogstaver, tal og forskellige specialtegn. I SI er strengliteraler eller konstante strenge omgivet af dobbelte anførselstegn. En streng i SI er en matrix af tegn, der ender med et nul-tegn ('\0'). En streng tilgås via en pointer, der refererer til det første tegn i strengen. Værdien af en streng er adressen på dens første karakter. I SI er det således legitimt at sige, at en streng er, at den er en pointer, faktisk en pointer til det første tegn i en streng. En streng kan i en erklæring tildeles enten en række af tegn eller en variabel af typen char*. Strukturer. I moderne programmeringssprog er der en særlig datatype, der kan kan indeholde flere elementer af enklere (og anderledes!) typer. En struktur er en datatype, der kan indeholde flere felter - elementer forskellige typer (herunder andre strukturer). En af anvendelserne af strukturer er at organisere forskellige databaser, lister osv. Da en struktur er en ny datatype, skal den først deklareres i begyndelsen char titel; // navn, tegnstreng int år; // udgivelsesår, heltal int sider; // antal sider, heltal For at henvise til hele strukturen skal du bruge dens navn og henvise til en person Navnet på dette felt er adskilt af en prik. Strukturelementer indføres sekventielt iflg alene. Du kan udfylde dem i vilkårlig rækkefølge. Du kan arbejde med et strukturfelt på samme måde som og med en variabel af passende type: numeriske variable kan deltage i aritmetik I logiske udtryk kan du udføre alle standardoperationer på strenge. strcpy(b.forfatter, "A.S. Pushkin"); Strukturer tjener til at behandle en stor mængde information, så oftest Programmet bruger arrays af strukturer. De annonceres på samme måde som normalt, men først I det væsentlige (ovenfor) skal du erklære selve strukturen som en ny datatype. For at få adgang til et strukturfelt bruges også et punkt, men nu skal du angive det i en firkant i parentes står også nummeret på den ønskede struktur, f.eks for (i = 0; i< 20; i ++) // цикл по всем структурам в массива puts(A[i].title); // vis bogens titel Strukturer, ligesom alle andre typer, kan være parametre for funktioner og procedurer. Arbejde med filer. Filer kan være tekstfiler (hvori du kun kan skrive bogstaver, tal, parenteser og osv.) og binær (som kan gemme alle tegn fra tabellen). Tekstfiler (samme som for lineære arrays) fejl ved manglende eller utilstrækkelige data i filen. Binære filer Det er praktisk at arbejde med en binær fil, når dataene er skrevet (eller vil blive læst) et andet program, og de behøver ikke ses manuelt. Den største fordel ved denne metode er læse- og skrivehastigheden, da hele arrayet læses (eller skrives) på én gang som en enkelt blok. Beskrivelser af funktioner til at arbejde med filer findes i stdio.h-biblioteket Først skal du oprette en pointer til en variabel af typen FILE (FILE* fil;). Filen åbnes ved at kalde fopen-funktionen (fil = fopen(filnavn, "w");) Den første parameter i denne funktion er filnavnet, den anden specificerer i hvilken tilstand filen skal åbnes. "w" - åben til skrivning, "r" - åben til læsning, "a" - filtilføjelse (disse er de mest brugte tilstande, selvom der er andre). At skrive og læse data fra en fil udføres af følgende funktioner: fputc, fputs, fgetc, fgets, fprintf, fscanf (for en beskrivelse af disse funktioner, se stdio.h). Lukning af en fil sker ved at kalde funktionen fclose (fclose(fil);). Input Output C-sproget i sig selv giver ingen input/output-muligheder. Alle disse mekanismer på højt niveau skal leveres af funktioner, der udtrykkeligt kan kaldes. Output funktioner: Int putchar(int c). Sæt et tegn til stdout Int fputs(int c,FILE *f). Udsender et tegn til fil f Int puts(char *s). Sætter strengen s op til det afsluttende tegn med kode 0 til standard output. Udskriver en ny linje i slutningen Int fputs(char *s,FILE *f). Udsender strengen s op til det efterfølgende tegn med koden i fil f. Int printf() Udskriver tekst i det angivne format til standardoutput. Formatbeskrivelsen begynder med %-symbolet %d er et signeret heltal %u - usigneret heltal %f er et reelt tal %s-tegn Input funktioner: Int getchar(void).læser et tegn fra stdin Int fgetc(FILE *f). Læser et tegn fra fil f Char *fgets(char *s,int size,FILE *f). Læser fra fil f en linje med højst størrelse tegn, inklusive ende-på-linje-tegn, og placerer den på adresse s Int scanf() Læser data fra standardinput i henhold til det angivne format 24 C sprog datatyper. C har typer af heltal af forskellige størrelser, fortegnede og usignerede, flydende komma, tegn, enums og strukturer. Derudover tilbyder C-sproget en unionstype, hvormed du enten kan gemme heterogene data på én hukommelsesplacering, der ikke overlapper i levetiden (dette giver dig mulighed for at spare hukommelse), eller få adgang til indholdet af et hukommelsesområde som data fra forskellige typer (som giver dig mulighed for at ændre datatypefortolkningen uden at ændre selve dataene). Der er flere grundlæggende typer i C: char - enkelt byte, kan indeholde et tegn fra det gyldige tegnsæt; int er et heltal, der normalt repræsenterer maskinens naturlige repræsentation af heltal; flydende - enkelt præcision flydende kommanummer; dobbelt - dobbelt præcision flydende kommanummer. Der er også flere kvalifikationer, der kan bruges sammen med de angivne basistyper. For eksempel gælder de korte og lange kvalifikationer for heltal: lang int tæller; I sådanne erklæringer kan ordet int udelades, hvilket normalt gøres. De signerede eller usignerede kvalifikationer kan anvendes på char-typen og enhver integraltype. Værdier uden fortegn er altid positive eller nul og overholder lovene for modulo 2n aritmetik, hvor n er antallet af bits i typerepræsentationen. Så hvis en char-værdi har 8 bit, så har usigneret char værdier i området fra 0 til 255 og fortegn - fra -128 til 127 (på en binær maskine). numerisk ekstra kode). Hvorvidt værdier af typen blot char er signerede eller usignerede er implementeringsafhængig, men i begge tilfælde er de printbare tegnkoder positive. Den lange dobbelte type er beregnet til højpræcision flydende kommaaritmetik. Som med heltal er størrelserne af flydende kommaobjekter implementeringsafhængige; flyder, dobbelt og lang dobbelt dåse kan se ud til at være én størrelse, eller kan være to eller tre forskellige størrelser. Aritmetiske konstanter. En heltalskonstant, såsom 1234, er af typen int. En lang konstant slutter med bogstavet l eller L, for eksempel 123456789L; Et heltal, der er for stort til at blive repræsenteret som en int, vil blive repræsenteret som en lang. Konstanter uden fortegn slutter med bogstavet u eller U, og slutningen ul eller UL indikerer, at konstantens type er lang uden fortegn. Flydende kommakonstanter har et decimalkomma (123,4) eller en eksponentiel del (1e-2) eller begge dele. Hvis de ikke har en slutning, anses de for at være af typen dobbelt. Endelsen f eller F angiver flydetypen, og 1 eller L angiver den lange dobbelte type. Ud over decimal kan en heltalsværdi have en oktal eller hexadecimal repræsentation. Hvis en konstant starter fra nul, er den repræsenteret i oktal form; hvis den starter fra 0x eller 0X, er den repræsenteret i hexadecimal. For eksempel kan det decimaltal 31 skrives som 037 eller som 0X1F. Oktale og hexadecimale konstanter kan afsluttes med L (for at angive, at typen er lang) og U (for at angive, at konstanten er uden fortegn). For eksempel har konstanten 0XFUL værdien 15, og typen er lang uden fortegn. Karakter- og strengkonstanter. En tegnkonstant er et heltal skrevet som et tegn omgivet af enkelte anførselstegn, såsom "x". Værdien af en tegnkonstant er den numeriske kode for et tegn fra tegnsættet på en given maskine. For eksempel har ASCII-tegnkonstanten "0" værdien 48, hvilket ikke har noget at gøre med den numeriske værdi 0. Når vi skriver "0" frem for en eller anden værdi (for eksempel 48), afhængigt af indkodningsmetoden, gør vi programmet uafhængigt af kodens private betydning, og det er også lettere at læse. Tegnkonstanter kan bruges i taloperationer ligesom ethvert andet heltal, selvom de oftere bruges til at sammenligne med andre tegn. Nogle tegn i tegn- og strengkonstanter er skrevet ved hjælp af escape-sekvenser, såsom \n (ny linje); Sådanne sekvenser er repræsenteret af to symboler, men repræsenterer ét. Derudover kan en vilkårlig oktal kode angives som "\ooo", hvor ooo er et, to eller tre oktale cifre (0...7) eller "\xhh", hvor hh er et, to eller flere hexadecimale cifre ( 0 ...9, a...f, A...F). Så vi kunne skrive #define VTAB "013" /* lodret fane i ASCII */ #define BELL "\007" /* kald til ASCII */ eller i hexadecimal: #define VTAB "\xb" /* lodret fane i ASCII */ #define BELL "\x7" /* kald til ASCII */ Det fulde sæt af escape-sekvenser er som følger: \ et klokkesignal \\ omvendt skråstreg \b tilbage til trin (ned) \f sidefeed \n ny linje \r vogn retur \t vandret fane \v vertikal-fane \? spørgsmålstegn \" enkelt citat \"dobbelt anførselstegn \ooo oktal kode \xhh hexadecimal kode Tegnkonstanten "\0" er et tegn med en nulværdi, det såkaldte nulltegn. I stedet for blot 0 bruges notationen "\0" ofte til at understrege udtrykkets symbolske karakter, selvom notationen i begge tilfælde angiver nul. En strengkonstant, eller streng bogstavelig, er nul eller flere tegn omgivet af dobbelte anførselstegn, såsom "Jeg er en strengkonstant" eller "" (den tomme streng). Citater er ikke inkluderet i strengen, men tjener kun som afgrænsning. Ligesom tegnkonstanter kan escape-sekvenser inkluderes i strenge; \" repræsenterer for eksempel et dobbelt anførselstegn. Strengkonstanter kan sammenkædes ("limet sammen") på kompileringstidspunktet; f.eks. at skrive to strenge "Hej", "verden!" svarer til at skrive en streng som "Hej". , verden!". Denne egenskab giver dig mulighed for at bryde lange linjer i dele og placere disse dele på separate linjer. Faktisk er en strengkonstant en række tegn. Den interne repræsentation af en streng kræver et afsluttende null-tegn "\0", så strengen kræver en byte mere hukommelse end antallet af tegn mellem de dobbelte anførselstegn. Det betyder, at der ikke er nogen grænse for længden af den streng, du angiver, men du skal scanne hele strengen for at bestemme dens længde. Laboratoriearbejde nr. 1 Introduktion til programmeringssproget C++ Målet med arbejdet: 1. Undersøgelse af Visual C++ shell-grænsefladen; 2. Kompilering og oprettelse af eksekverbare filer. 3. Undersøgelse af de grundlæggende datatyper i C++ sproget; Grundlæggende datatyper; Variabler og konstanter; 4. Undersøgelse af operatører: Aritmetik; Logisk; Sammenligninger; Bitvis; Input og output. 5. At erhverve færdigheder til at arbejde i Microsoft Visual C++ 5.0-software. Anvendt udstyr: Personlig computer kompatibel med IBM PC. Brugt software: Windows-operativsystem; Integreret programmeringsmiljø Microsoft Visual C++ 5.0 (ISP Microsoft Visual C++ 5.0). Arbejdsopgave 1.1. Download internetudbyder Microsoft Visual C++ 5.0. 1.2. Lær Microsoft Visual C++ 5.0 ISP-kommandoer. 1.3. Lær de vigtigste datatyper af Microsoft Visual C++ 5.0 COI. 1.4. Gennemfør eksempel 1, eksempel 2, eksempel 3 og lærerens opgave. 1.5. Optag en protokol til at arbejde med det integrerede miljø. Arbejdsordre 2.1. Start Microsoft Visual C++ 5.0. 2.2. Opret en *.cpp-fil i arbejdsmappen. 2.3. Gennemfør eksempel 1, eksempel 2, eksempel 3 og lærerens opgave. 2.4. Lav et algoritmediagram og skriv et program (som instrueret af læreren). Optag en protokol til at arbejde med det integrerede miljø. 2.5. Afslut Microsoft Visual C++ 5.0 og kør programmet. 3.1. Navn på laboratoriearbejde. 3.2. Målet med arbejdet. 3.3. Den teoretiske del. 3.4. Algoritmer for udførte programmer. 3.5. Tekst af udførte programmer. 3.6. Konklusion. Kort jobbeskrivelse 4.1. Start og arbejd i Microsoft Visual C++ 5.0. For at starte Microsoft Visual C++ 5.0 ISP, skal du starte menuen Start - Microsoft Visual C++ 5.0 - Microsoft Visual C++ 5.0. For at begynde at arbejde i C++ skal du først oprette en simpel konsolapplikation, for at gøre dette skal du udføre følgende trin: Ø Start Visual C++ (Start®Programs® Microsoft Visual C++ 5.0.® Microsoft Visual C++ 5.0 .
); Ø Vælg "Ny" fra menuen "Filer". Sørg for, at fanen "Projekter" er valgt i dialogpanelet "Ny". På listen over projekttyper skal du vælge "Win32 Console Application"; Ø Vælg biblioteket for projektet 'Placering' (C:\studerende\'gruppe*) og projektnavnet 'Projektnavn', f.eks. "Først", og klik på "OK". Du vil have "First classes" oprettet; Ø Vælg derefter "Ny" igen, men med fanen "Filer" og vælg "C++ Kildefil". Indstil et navn på 'Filnavn'-listen, for eksempel "First". Klik derefter på "OK" og filen "First.cpp" vil blive oprettet. Generel opbygning af programmet. Vores opgave er at overveje den generelle struktur af et program skrevet i C/C++, det vil sige, at al kildeteksten er placeret i én fil: Ø Preprocessor-direktivområde (inkluder, definere ..); Ø Beskrivelse af brugerdefinerede datatyper; Ø Ufuldstændige funktionserklæringer; Ø Beskrivelse af globale variabler; Ø Funktionserklæring 1; Ø Funktionserklæring 2; Ø Erklæring af main()-funktionen. Denne ordning har ikke så streng en rækkefølge som i Pascal, men den betragtes som traditionel. Et program består af en eller flere procedurer, traditionelt kaldet funktioner. En funktion, der kræves i ethvert program, bør kaldes main. Den tjener som indgangspunkt i programmet og kalder efterfølgende andre funktioner op. Det minimale program ser således ud: Void main(void) Den består af en hovedfunktion, der ikke accepterer eller returnerer parametre (void). Funktionsteksten, omgivet af krøllede seler, indeholder heller ingen nyttige udsagn. Variabler kan deklareres både inde i funktionskroppen og uden for kroppen. I det første tilfælde kan de kun tilgås fra kroppen af en given funktion (lokale erklæringer), og i det andet - fra enhver funktion (globale erklæringer). Programudførelse begynder med hovedfunktionens krop, som kan acceptere et sæt værdier fra kommandolinjen. Hovedteksten indeholder kald til andre funktioner, både fra standardbiblioteker og dem, der er defineret af brugeren i programteksten. Programudførelse slutter som standard, når hovedafslutningen afsluttes, men kan afbrydes på ethvert tidspunkt, hvis der opstår en kritisk fejl, eller i et specificeret tilfælde. For at gøre dette bruger de normalt funktionen exit() fra stdlib-biblioteket. Udskrivning af en streng til skærmen Lad os først og fremmest skrive et program, der udskriver en streng til skærmen. Programmet skal indeholde en funktion kaldet main(). Hun er krediteret med rollen som at starte programmet. Denne funktion er ikke foruddefineret af compileren, den kan ikke overbelastes, og dens type er implementeringsafhængig. Hovedfunktionen kan defineres således: Eksempel 1: // Første program i C++ #omfatte Ugyldig hoved() cout<< “Thise is my first program\n” << endl;
For at udføre et program skal du først gemme det. Gå til menuen Fil og klik der Gem alle. Derefter skal du bygge (kompilere) det; for at gøre dette skal du udføre følgende trin: Ø Lad os gå til menuen ( Build®Build *.exe) eller tastaturgenvej (F7), vil programmet begynde at bygge. Hvis compileren ikke genererer en fejlmeddelelse, som kan ses i vinduet, der vises nedenfor, så kan du trygt køre programmet; Ø Nu skal du blot køre programmet, for at gøre dette skal du gå til menuen ( Build®Execute *.exe.) eller tastaturgenvej (Ctrl+F5); Ø Dit program kører. Linje #omfatte fortæller compileren at aktivere standard input- og outputstream-kapaciteterne, der findes i iostream.h-filen. Uden disse beskrivelser udtrykket cout << "Dette er mit første program" ville ikke give mening. De vigtigste standardbiblioteker er angivet i tabel 1. Tabel 1. Core C/C++ standardbiblioteker Operation<< ("поместить в") пишет свой первый аргумент во второй (в данном случае, строку "Dette er mit første program" for at udskrive standardoutput). En streng er en sekvens af tegn omsluttet af dobbelte anførselstegn. I en streng betegner et skråstreg \ efterfulgt af et andet tegn et enkelt specialtegn; i dette tilfælde er \n et linjeskifttegn. Således , outputtegnene består af " Dette er mit første program" og linjeskift, som definerer en funktion kaldet vigtigste. Hvert program skal indeholde en funktion kaldet vigtigste, og programmet begynder med udførelsen af denne funktion. Tastatur input Følgende (temmelig udførlige) program beder dig om at indtaste antallet af tommer. Når du har gjort dette, udskriver den det tilsvarende antal centimeter. Eksempel 2: #omfatte Ugyldig hoved() int tomme = 0; // tomme - tomme cout<< "inches";
cin >> tomme; cout<< inch;
cout<< " in = ";
cout<< inch*2.54;
cout<< " cm\n";
Første linje i funktionen hoved() beskriver en hel variabel tomme. Dens værdi læses ved hjælp af >> ("tag fra") operationen på standard input cin. I dette eksempel er der én sætning for hver outputkommando; den er for lang. Tilbagetrækningsoperation<< можно применять к ее собственному результату, так что последние четыре команды вывода можно было записать одним оператором: Kommentarer Det er ofte nyttigt at indsætte tekst i et program, der kun er beregnet som en kommentar for den person, der læser programmet, og som ignoreres af compileren i programmet. I C++ kan dette gøres på en af to måder. /*-tegnene begynder en kommentar, der slutter med */-tegnene. Hele denne sekvens af tegn svarer til et mellemrumstegn (f.eks. mellemrumstegnet). Dette er mest nyttigt til kommentarer med flere linjer og fjernelse af dele af et program ved redigering, men husk at /* */ kommentarer ikke kan indlejres. //-tegnene begynder en kommentar, der slutter i slutningen af linjen, hvor de vises. Igen, hele sekvensen af tegn svarer til et hul. Denne metode er mest nyttig til korte kommentarer. //-tegnene kan bruges til at kommentere /* eller */-tegn, og /*-tegnene kan bruges til at kommentere //. 4.6. Datatyper i C++ Før du skriver et program, skal du indstille datatyperne. Der er flere almindeligt anvendte datatyper i C++ (ikke alle): Ø Heltal med numerisk fortegn
(int, kort, char); Ø Brøker med numerisk fortegn
(flyde, dobbelt, lang (i C), lang dobbelt (i C); Ø Usigneret numerisk
- alle ovenstående typer med tilføjelse af Usigneret; Ø Char
kan også bruges som tegntype
. Standardtyperne og størrelserne af de tilsvarende celler er vist nedenfor. En variabel i C/C++ erklæres sådan: Int iMyVariable; I ovenstående sætning er iMyVariable erklæret som en heltalsvariabel. Og her er deklarationen af en typevariabel char
: Char cMyChar; Datatyper som f.eks int
, flyde
, char
Og lang
, er en integreret del af C/C++, og du behøver ikke at skrive nogen kode for at fortælle compileren, hvad disse ord betyder. C/C++ giver dig også mulighed for at deklarere dine egne, specielle datatyper. Eksempel 3 præsenterer et program, der vil udskrive størrelsen af datatyper i bytes. Eksempel 3: #omfatte Void main(void) cout<< " (unsigned)int = " << sizeof(int) << endl;
cout<< " (unsigned)short = " << sizeof(short) << endl;
cout<< " (unsigned)char = " << sizeof(char) << endl;
cout<< " (unsigned)float = " << sizeof(float) << endl;
cout<< " (unsigned)double = " << sizeof(double) << endl;
cout<< " (unsigned)long = " << sizeof(long) << endl;
cout<< " (unsigned)long double = " << sizeof(long double) << endl;
For at finde ud af størrelsen på en celle af den tilsvarende type, skal du bare skrive i programmet størrelse på(type). Faktum er, at for forskellige operativsystemer kan størrelsen af en celle af samme type variere (for eksempel er int-typen i 16-bit og 32-bit OS'er henholdsvis 1 byte og 2 bytes). Operatør størrelse på beregner størrelsen af dens operand i bytes. Operanden skal enten være et udtryk, der ikke evalueres, eller et typenavn i parentes. Til operatøren størrelse på kan ikke anvendes på en funktion, bitfelt, udefineret klasse, void type eller matrix med uspecificerede indeksgrænser. En byte er ikke defineret på nogen måde af sproget ud over resultatet af en operation størrelse på, Nemlig størrelse på(char) er 1. En variabel er navnet på en hukommelsesplacering, der skal bruges til at gemme den værdi, der ændres, for at hukommelsen skal være tilgængelig til brug af programmet, skal den tildeles den. Der er statisk og dynamisk hukommelsesallokering. Statisk hukommelsesallokering sker på kompileringstidspunktet, og blokstørrelsen kan ikke ændres under programafvikling. Dynamisk hukommelse tildeles under kørsel, og dens størrelse kan afhænge af programmets aktuelle tilstand. Hukommelsesområdet, der er tildelt programmet, bruges til at gemme data. Hvis dataene kan ændre sig under drift, så taler de om at bruge variable, hvis de ikke kan, så brug konstanter. For at få adgang til en variabel eller konstant skal du bruge et navn eller en adresse. En variabel er et navngivet hukommelsesområde, hvis værdi kan ændres under programafvikling. Alle variabler skal deklareres til deres brug, for at compileren kan allokere statisk hukommelse, så den skal kende dens nøjagtige størrelse. For at erklære en variabel skal du angive: navn, adresse, størrelse(defineret efter type), betyder. Hvis erklæringen er placeret inde i et par krøllede klammeparenteser (f.eks. inde i en funktions brødtekst), betragtes de erklærede variable som lokale, og hukommelsen allokeres i programstakområdet, og startværdien er udefineret. Hvis en variabel erklæres uden for funktionslegemer, betragtes den som global og placeres i datasegmentet, og dens startværdi er nul. At erklære en variabel og tildele den en startværdi kaldes initialisering. Hvis en funktion har et argument, skal du erklære variabler, der vil tage deres værdier, disse variable kaldes formelle parametre. I C++ er der to klassifikatorer, der styrer adgang og modifikation: konst Og flygtige. En konstant er et navngivet hukommelsesområde, hvis værdi ikke kan ændres under programafvikling. Konstanter tildeles altid en værdi, når de erklæres og kan ikke ændres senere. Indtast variabler konst kan ikke ændres, men de kan initialiseres. Kvalifikation flygtige fortæller compileren, at værdien af en variabel kan ændres implicit. For eksempel, sendes adressen på den globale variabel til operativsystemets timer og bruges til at tælle realtid. I dette tilfælde ændres indholdet af variablen uden eksplicit at udføre nogen tildelingssætning. C/C++ sproget giver kontrolkarakterkonstanter, som er vist i tabel 2. Tabel 2. Kontrolkarakterkonstanter De mest berømte servicekarakterer: linjefeed (kode 13), vognretur (kode 10), fane (kode 9). For at specificere dem i programmet i form af tegnkonstanter, bruges en kombination af to synlige tegn, nemlig henholdsvis "\n", "\r", "\t". Brug konstruktionen "\\" for at repræsentere skråstreg-tegnet Der er fire lagringsspecifikationer i C: ekstern, statisk, register, auto. Disse specifikationer fortæller compileren, hvordan den deklarerede variabel skal lagres. Det generelle udseende af en erklæring, der bruger disse specifikationer, er: Relateret information. I C er tegn omgivet af apostrof. Så når vi tildeler en variabel værdi stegt type char, skal vi skrive broiled = "T"; /* HØJRE */, stegt = T; /* FORKERT */ Hvis apostroferne udelades, "tror" compileren, at vi bruger en variabel kaldet T, som de glemte at beskrive. C-sprogstandarden har vedtaget reglen om, at værdierne af en variabel eller konstant af typen char der kan kun være enkelte tegn. Følgelig er rækkefølgen af udsagn nedenfor ugyldig, fordi den forsøger at tildele til en variabel kvæg en værdi bestående af to tegn: ehar kvæg; bovin = "okse"; /* FORKERT */ Hvis du ser på ASCII-kodetabellen, vil du se, at nogle af "tegnene" i den ikke er udskrevet. For eksempel, når du bruger tegn nummer 7 i et program, giver computerterminalen et bip. Men hvordan bruger man et tegn, der ikke kan skrives på tastaturet? Der er to måder at gøre dette på i C-sproget. I første metode selve ASCII-koden bruges. Du behøver kun at angive tegnnummeret sammen med den foregående skråstreg. Det har vi allerede gjort i vores guldækvivalentprogram. Dette er linjen bip = "07"; Der er to vigtige punkter her, som du klart skal forstå. Den første er, at sekvensen af tegn er omgivet af apostrof på samme måde som et almindeligt tegn. Den anden er, at tegnnummeret skal skrives i oktal. Når du skriver en sekvens af tegn, kan vi ved et uheld udelade nuller i de første positioner; i dette tilfælde, for at repræsentere koden "signal", vi kunne bruge "7"
eller endda "7"
. Men du må under ingen omstændigheder udelade de sidste nuller i dine indtastninger! Karaktersekvens "20"
kan skrives i skemaet "20"
, men ikke "2"
. Når du bruger ASCII-kode, er det vigtigt at bemærke forskellen mellem tal og talsymboler. For eksempel symbolet "4"
svarer til en ASCII-kode på 52. Dette er tegnet "4"
ikke tallet 4. RIS. 3. 4. Former for skrivekonstanter af heltalstyper I den anden vej For at repræsentere "ubekvem" tegn bruges specielle sekvenser af symboler. Disse kaldes escape-sekvenser og ser sådan ud: n nylinje t fane b gå tilbage r vogn retur f indsendelse af formularen omvendt skråstreg() "apostrof (") "citater (") Når der tildeles en karaktervariabel, skal disse sekvenser også være omgivet af apostrof. For eksempel kunne vi skrive udsagnet nerf = "n"; og udskriv derefter variablen nerf; dette vil flytte en linje frem på udskrivningsenheden eller skærmen. De første fem kontrolsekvenser er almindelige tegn designet til at styre betjeningen af udskrivningsenheden: tegnet "ny linje" forårsager en ny linje; "tab"-tegnet flytter markøren eller printhovedet med et bestemt fast antal positioner 5 eller 8; symbolet "trin tilbage" flytter en position tilbage; Karakteren for vognretur vender tilbage til begyndelsen af linjen; "Form feed"-symbolet får papiret til at blive fremført én side. I de sidste tre escape-sekvenser karaktererne , "
, "
kan betragtes som symbolske konstanter [da de tjener til definitioner tegnkonstanter og bruges direkte i sætningen printf(), at bruge dem selv som symboler ville føre til en fejl]. Hvis du vil udskrive en streng. Husk, "karakteren kaldes en omvendt skråstreg." operatøren vil se sådan ud: printf(" Husk, " tegnet kaldes en omvendt skråstreg. " n"); Her kan du have to spørgsmål. For det første, hvorfor satte vi ikke flugtsekvenser i apostrof? For det andet, hvornår skal du bruge ASCII-kode, og hvornår bruger du de escape-sekvenser, vi lige har diskuteret? (Vi håber, det er de spørgsmål, du har, FORDI det er de spørgsmål, vi skal besvare.) Indtil dette punkt har alle de variabler, vi har overvejet, været ikke konstanter. Deres værdier kan til enhver tid ændres. For eksempel: int x(4); // initialisering af variablen x med værdien 4 x = 5; // ændre værdien af x til 5 Nogle gange er det dog nyttigt at bruge variabler, hvis værdier ikke kan ændres - konstanter. For eksempel tyngdekraften på Jorden: 9,8 m/s^2. Det er usandsynligt, at det ændrer sig i den nærmeste fremtid. Brug af en konstant i dette tilfælde er den bedste mulighed, da vi på denne måde vil forhindre enhver (selv utilsigtet) ændring i værdien. Brug nøgleordet for at gøre en variabel til en konstant konst før eller efter variabeltypen. For eksempel: konstant dobbelt tyngdekraft (9,8); // det er at foretrække at bruge const før int datatypen const sidesInSquare ( 4 ); // ok, men ikke at foretrække Selvom C++ vil acceptere const enten før eller efter typen, anbefaler vi at bruge Før type. Konstanter skal initialiseres ved annoncering. Deres værdier kan ikke ændres ved hjælp af tildelingsoperationen. konstant dobbelt tyngdekraft (9,8); tyngdekraft = 9,9; // ikke tilladt - kompileringsfejl Erklæring af en konstant uden initialisering vil også forårsage en kompileringsfejl: konstant dobbelt tyngdekraft; // kompileringsfejl, konstant skal initialiseres Bemærk venligst, at konstanter også kan initialiseres ved hjælp af ikke-konst-værdier: std::cout<< "Enter your age: ";
int age;
std::cin >> alder; const int brugereAlder(alder); // UserAge-variablen kan ikke ændres i fremtiden const er den mest nyttige (og mest brugte) med funktionsparametre: void printInteger(const int myValue) (std::cout<< myValue;
} void printInteger(const int myValue) std::cout<<
myValue
;
Når du kalder en funktion, fortæller konstantparameteren os således, at funktionen ikke vil ændre værdien af minVærdi-variablen. For det andet sikrer det, at funktionen ikke ændrer værdien af myValue. Når du er i gang med at kompilere et program, er dette kompileringstid(kompilere tid)
. Compileren tjekker dit program for syntaksfejl og konverterer derefter koden til objektfiler. Når du er i gang med at starte dit program, eller når programmet allerede kører – dette er køretid(gennemløbstid). Koden udføres linje for linje. Der er to typer konstanter i C++. Konstanter rutidssvarende. Deres værdier bestemmes kun ved kørsel (når programmet kører). Variabler som usersAge og myValue (i koden ovenfor) er runtime-konstanter, fordi compileren ikke kan bestemme deres værdier på kompileringstidspunktet. usersAge afhænger af brugerinput (som kun kan modtages under programafvikling), og myValue afhænger af værdien, der sendes til funktionen (som også bliver kendt under programafvikling). Konstanter compile-tid. Deres værdier bestemmes på kompileringstidspunktet. Jordens tyngdekraft er for eksempel en kompileringstidskonstant; vi bestemte det selv, mens vi skrev programmet. I de fleste tilfælde er det ligegyldigt, hvilken type konstant det er: kompileringstid eller runtime. Der er dog stadig et par situationer, hvor C++ kan kræve en kompileringstidskonstant i stedet for en kørselstidskonstant (f.eks. når man bestemmer længden af et array med fast størrelse - vi vil se på dette senere). Da der er to typer, skal compileren konstant overvåge, hvilken af dem der hører til hvilken variabel. For at gøre denne opgave nemmere introducerer C++11 nøgleordet constexpr, som sikrer, at typen af konstanten er kompileringstid: constexpr dobbelt tyngdekraft (9,8); // ok, værdien bestemmes på kompileringstidspunktet constexpr int sum = 4 + 5; // ok, værdien 4 + 5 bestemmes på kompileringstidspunktet std::cout<< "Enter your age: ";
int age;
std::cin >> alder; constexpr int minAlder = alder; // ikke ok, aldersvariablen er ikke defineret på kompileringstidspunktet Du vil højst sandsynligt ikke bruge det, men det vil ikke skade at vide om det. Regel: Enhver variabel, der ikke skal ændre sin værdi efter initialisering, skal erklæres som const (eller som constexpr). Nogle programmører skriver konstante navne med store bogstaver. Andre bruger almindelige navne, kun med et 'k'-præfiks. Vi vil ikke fremhæve dem på nogen måde, da konstanter er de samme almindelige variabler, bare med faste værdier, det er alt. Der er ingen særlig grund til at fremhæve dem. Dette er dog en sag for den enkelte. I forrige lektion, diskuterede vi "magiske tal" - bogstaver, der bruges i et program som konstanter. Da det er dårlig praksis at bruge dem, hvad skal du så bruge i stedet for? Svar: symbolske konstanter. Symbolsk(eller mere symbolsk) konstant– dette er det samme bogstavelige (magiske tal), kun med en identifikator. Der er to måder at erklære symbolske konstanter i C++. En af dem er god, og en er knap så god. Lad os se på begge dele. Denne metode plejede at være meget brugt, så du kan stadig se den i gamle koder. I Lektion 22 om præprocessorer og direktiver, sagde vi, at makroobjekter har to former - med og uden erstatningstekst. Lad os se på det første tilfælde (med erstatningstekst). Det ser sådan ud: #define identifier substitution_text Når præprocessoren støder på dette direktiv, vil alle yderligere forekomster af 'identifikator' blive erstattet med 'substitution_text'. Identifikationen skrives normalt med store bogstaver med understregninger i stedet for mellemrum. For eksempel: int max_students = antalKlasser * MAX_STUDENTS_PER_CLASS; #define MAX_STUDENTS_PER_CLASS 30 På kompileringstidspunktet vil præprocessoren erstatte alle MAX_STUDENTS_PER_CLASS identifikatorer med bogstaverne 30. Enig, dette er en meget bedre mulighed end at bruge magiske tal, af mindst flere grunde. MAX_STUDENTS_PER_CLASS giver kontekst om, hvad denne værdi er, og hvorfor den er nødvendig, selv uden kommentarer. For det andet, hvis nummeret skal ændres, vil det være nok kun at foretage ændringer i #define-direktivet; alle andre MAX_STUDENTS_PER_CLASS identifikatorer i programmet vil automatisk blive erstattet med den nye værdi ved rekompilering. Lad os se på et andet eksempel: #define MAX_STUDENTS_PER_CLASS 30 #define MAX_NAME_LENGTH 30 int max_students = numClassrooms * MAX_STUDENTS_PER_CLASS; setMax(MAX_NAME_LENGTH); #define MAX_STUDENTS_PER_CLASS 30 #define MAX_NAME_LENGTH 30 int max_elever = antalKlasser * MAX_STUDENTS_PER_CLASS ; setMax(MAX_NAME_LENGTH); Det er tydeligt her, at MAX_STUDENTS_PER_CLASS og MAX_NAME_LENGTH er beregnet til at være forskellige objekter, selvom de har de samme værdier (30). Så hvorfor er denne metode dårlig? Der er to grunde. Først behandles makroer af en præprocessor, som erstatter identifikatorer med specifikke værdier. Disse værdier vises ikke i debuggeren (som viser din faktiske kode). Når den er kompileret, int max_students = numClassrooms * 30; i debuggeren vil du se int max_students = numClassrooms * MAX_STUDENTS_PER_CLASS; . Hvad hvis du har brug for at finde ud af værdien af MAX_STUDENTS_PER_CLASS? Du skal selv finde det i koden. Og dette kan tage lidt tid, afhængigt af programmets størrelse. For det andet har disse direktiver altid et globalt anvendelsesområde (det vil vi tale om senere). Det betyder, at #define værdier i en del af koden kan være i konflikt med #define værdier i en anden del af koden. Regel: Brug ikke #define til at skabe karakterkonstanter. Den bedste måde at skabe en karakterkonstant på er at bruge const: const int maxStudentsPerClass (30); const int maxNameLength (30); const int maxStudentsPerClass (30); const int maxNameLength (30); Sådanne værdier vil blive vist i debuggeren, og de følger også alle reglerne for almindelige variabler (inklusive omfang). Regel: Brugkonstat skabe symbolske konstanter. I mange programmer skal der bruges en tegnkonstant i hele koden (ikke kun ét sted). De kan være fysiske eller matematiske konstanter, der ikke ændrer sig (for eksempel Pi eller Avogadros tal) eller specifikke værdier af dit program. For ikke at skrive dem, hver gang de er nødvendige, skal du definere dem ét sted og bruge dem, hvor det er nødvendigt. På denne måde, hvis du skal ændre dem, vil det være nok at gå ind i én fil og foretage ændringer der, i stedet for at gennemsøge hele programmet. Hvordan gør man dette? Meget simpelt:Rækkevidde Størrelse (Bt)
char -128..127;
usigneret char 0..255;
int -32 768.. 32 767;
usigneret int 0..65535;
lang -2 147 483 648..2 147 483 647;
usigneret lang 0..4 294 967 295;
flyder 3.4e-38..3.4e+38;
dobbelt 1,7e-308..1.7e+308;
lang dobbelt 3.4e-4932..3.4e+4932.
Kompiler tid og køretid
Constexpr
Konstante navne
Karakterkonstanter
Dårlig praksis: Brug af makroobjekter med erstatningstekst som tegnkonstanter
God måde: const variable
Brug af tegnkonstanter i et program