Oluline erinevus SI keele ja teiste keelte (PL1, FORTRAN jne) vahel on vaikeprintsiibi puudumine, mis toob kaasa vajaduse deklareerida selgesõnaliselt kõik programmis kasutatavad muutujad koos nende vastavate tüüpidega. .
Muutujate deklaratsioonid on järgmises vormingus:
[mäluklassi spetsifikaator] tüübispetsiifiline deskriptor [= algataja] [,deskriptor [= algataja] ]...
Deskriptor on lihtsa muutuja või keerukama konstruktsiooni identifikaator nurksulgude, sulgude või tärniga (tärnide komplekt).
Tüübi määraja on üks või mitu märksõna, mis määravad deklareeritava muutuja tüübi. SI keelel on standardne andmetüüpide komplekt, mille abil saate luua uusi (unikaalseid) andmetüüpe.
Algataja – määrab algväärtuse või algväärtuste loendi, mis deklareerimisel muutujale omistatakse.
Mäluklassi spetsifikaator – määratakse ühe neljast SI märksõnast: auto, extern, register, static ja näitab ühelt poolt, kuidas deklareeritud muutuja jaoks mälu eraldatakse, ja teiselt poolt selle muutuja ulatust, st millistest programmi osadest sellele juurde pääseb.
1.2.1 Andmetüüpide kategooriad
Märksõnad põhiandmete tüüpide määratlemiseks
Täisarvude tüübid: Float tüübid: char float int double lühike pikk topelt pikk märgiga märgita
Igat tüüpi muutuja võib kuulutada muutmatuks. See saavutatakse, lisades tüübispetsifikaatorile märksõna const. Objektid tüübiga const esindavad kirjutuskaitstud andmeid, st. sellele muutujale ei saa uut väärtust määrata. Pange tähele, et kui sõna const järel ei ole tüübispetsiifikat, siis eeldatakse tüübimäärajat int. Kui märksõna const tuleb enne liittüüpide (massiivi, struktuuri, segu, loenduse) deklareerimist, siis see viib selleni, et iga element peab olema ka muutmatu, s.t. sellele saab väärtuse määrata ainult üks kord.
Const double A=2,128E-2; konst B=286; (konst int B=286 on kaudne)
Allpool käsitletakse liitandmete deklareerimise näiteid.
1.2.2. Täisarvuline andmetüüp
Täisarvu tüüpi andmete määratlemiseks kasutatakse erinevaid märksõnu, mis määravad väärtuste vahemiku ja muutujatele eraldatud mäluala suuruse (tabel 6).
Tabel 6
Pange tähele, et allkirjastatud ja allkirjastamata märksõnad on valikulised. Need näitavad, kuidas deklareeritud muutuja nullbitti tõlgendatakse, st kui märgita märksõna on määratud, siis nullbiti tõlgendatakse arvu osana, vastasel juhul tõlgendatakse nullbitti märgituna. Kui märgita märksõna puudub, loetakse täisarvuline muutuja märgituks. Kui tüübispetsifikaat koosneb allkirjastatud või allkirjastamata võtmetüübist, millele järgneb muutuja identifikaator, käsitletakse seda muutujana int tüüpi. Näiteks:
Signeerimata int n; allkirjastamata int b; int c; (märgitud int c on kaudne); allkirjastamata d; (nähtab allkirjastamata int d); signeeritud f; (märgitud int f on kaudne).
Pange tähele, et char-tüüpi modifikaatorit kasutatakse märgi esitamiseks (märkide massiivi esitusviisist) või stringiliteraalide deklareerimiseks. Char-objekti väärtus on 1-baidine kood, mis vastab märgile, mida see esindab. Vene tähestiku märkide esitamiseks on andmeidentifikaatori tüübi modifikaatoriks märgita char, kuna vene tähtede koodid ületavad 127.
Tuleb teha järgmine märkus: SI keel ei määratle int ja unsigned int tüüpi modifikaatoritega identifikaatorite mälu esitust ega väärtuste vahemikku. Signeeritud int tüüpi modifikaatoriga muutuja mälumaht määratakse masinasõna pikkusega, mis on erinevatel masinatel erineva suurusega. Niisiis, 16-bitistel masinatel on sõna suurus 2 baiti, 32-bitistel masinatel 4 baiti, st. int tüüp on samaväärne lühikese int või pika int tüüpidega, olenevalt kasutatava arvuti arhitektuurist. Seega võib sama programm ühes arvutis õigesti töötada ja teises valesti. Muutuja poolt hõivatud mälu pikkuse määramiseks saate kasutada operaatori SI keele suurust, mis tagastab määratud tüübi modifikaatori pikkuse.
Näiteks:
A = suurus(int); b = suurus(pikk int); c = suurus(märgita pikk); d = suurus(lühike);
Pange tähele ka seda, et kaheksand- ja kuueteistkümnendkonstantidel võib olla ka märgita modifikaator. See saavutatakse prefiksi u või U määramisega pärast konstandit, mis ilma selle eesliiteta loetakse märgituks.
Näiteks:
0xA8C (int signed); 01786l (pika allkirjaga); 0xF7u (int unsigned);
1.2.3. Ujuvad andmed
Ujukomaarvu tähistavate muutujate puhul kasutatakse järgmisi tüübimuutujaid: float, double, long double (mõnes pika topeltkeele rakendustes puudub SI).
Ujuktüübi modifikaatoriga väärtus võtab 4 baiti. Neist 1 bait on eraldatud märgile, 8 bitti ülemäärasele eksponendile ja 23 bitti mantissile. Pange tähele, et mantissi kõige olulisem bitt on alati 1, seega seda ei täideta, seega on ujukomamuutuja väärtuste vahemik ligikaudu 3,14E-38 kuni 3,14E+38.
Topeltväärtus võtab 8 bitti mälu. Selle vorming on sarnane ujuvvorminguga. Mälubitid on jaotatud järgmiselt: 1 bitti märgi jaoks, 11 bitti eksponendi jaoks ja 52 bitti mantissi jaoks. Võttes arvesse mantissa välja jäetud kõrget bitti, on väärtuste vahemik 1,7E-308 kuni 1,7E+308.
Ujuk f, a, b; kahekordne x,y;
1.2.4. Viidad
Osuti on identifikaatori mahutamiseks eraldatud mälu aadress (identifikaator võib olla muutuja, massiivi, struktuuri või stringliteraali nimi). Kui muutuja on deklareeritud osutina, siis sisaldab see mäluaadressi, kus saab paikneda mis tahes tüüpi skalaarväärtus. Kursori tüüpi muutuja deklareerimisel tuleb määrata andmeobjekti tüüp, mille aadressi muutuja sisaldab, ja osuti nimi, millele eelneb tärn (või tärnide rühm). Osuti deklaratsiooni vorm:
tüübispetsifikaator [ modifikaator ] * täpsustaja.
Tüübispetsiifiline määraja määrab objekti tüübi ja võib olla mis tahes põhitüüp, struktuuritüüp, segu (sellest tuleb juttu allpool). Määrates tüübispetsifikaadi asemel märksõna void, saate unikaalsel viisil edasi lükata selle tüübi täpsustamist, millele kursor viitab. Muutujat, mis on deklareeritud viitena tüübile void, saab kasutada mis tahes tüüpi objektile viitamiseks. Et aga oleks võimalik sooritada aritmeetilisi ja loogilisi tehteid osutitega või objektidega, millele need osutavad, tuleb iga toimingu sooritamisel selgesõnaliselt määrata objektide tüüp. Selliseid tüübimääratlusi saab teha tüübivalu operatsiooni abil.
Märksõnu const, near, far, huge saab kasutada kursori deklareerimisel modifikaatoritena. Märksõna const näitab, et kursorit ei saa programmis muuta. Osutina deklareeritud muutuja suurus sõltub arvuti arhitektuurist ja kasutatavast mälumudelist, mille jaoks programm kompileeritakse. Osutajad erinevatele andmetüüpidele ei pea olema ühepikkused.
Kursori suuruse muutmiseks võite kasutada märksõnu lähedal, kaugel, tohutu.
Unsigned int * a; /* muutuja a on kursor unsigned int tippimiseks */ double * x; /* muutuja x tähistab kahekordse täpsusega ujukoma andmetüüpi */ char * fuffer ; /* deklareerib osuti nimega fuffer, mis osutab char tüüpi muutujale */ double nomer; tühi *aadressid; aadressid = &nomer; (topelt *)aadressid++; /* Aadressi muutuja deklareeritakse mis tahes tüüpi objektile osutavana. Seetõttu saab sellele määrata mis tahes objekti aadressi (& on aadressi arvutamise toiming). Kuid nagu eespool märgitud, ei saa osutiga sooritada aritmeetilist toimingut, välja arvatud juhul, kui andmete tüüp, millele see osutab, on selgelt määratud. Seda saab teha, kasutades ülekandetoimingut (topelt *), et teisendada aadressid kursoriks, et tippida topelt, ja seejärel suurendada aadressi. */ const * dr; /* Muutuja dr deklareeritakse konstantse avaldise osutajana, st. Kursori väärtus võib programmi täitmise ajal muutuda, kuid väärtus, millele see osutab, mitte. */ märgita tähemärk * const w = &obj. /* Muutuja w deklareeritakse konstantse osutina märgita märgiandmetele. See tähendab, et w osutab kogu programmi jooksul samale mälukohale. Selle ala sisu võib muutuda. */
1.2.5. Loetletud muutujad
Muutujat, mis võib võtta väärtuse mõnest väärtuste loendist, nimetatakse loendatavaks muutujaks või loendiks.
Loendusdeklaratsioon algab märksõnaga enum ja sellel on kaks esitusvormingut.
Formaat 1. enum [enum-tag-nimi] (enum-loend) deskriptor[,deskriptor...];
Formaat 2. enum enum-silt-nimi deskriptor [,deskriptor..];
Loendamisdeklaratsioon määrab loendusmuutuja tüübi ja defineerib nimeliste konstantide loendi, mida nimetatakse loendusloendiks. Iga loendi nime väärtus on mõni täisarv.
Loenditüüpi muutuja võib võtta ühe loendi nimega konstandi väärtuse. Nimetatud loendi konstandid on tüüpi int. Seega on loendusmuutujale vastav mälu int väärtuse mahutamiseks vajalik mälu.
Enum-tüüpi muutujaid saab kasutada indeksavaldistes ning operandidena aritmeetilistes ja relatsioonioperatsioonides.
Esimeses vormingus 1 on loendite nimed ja väärtused määratud loendusloendis. Valikuline loendisildi nimi on identifikaator, mis nimetab loendusloendis määratletud loendussildi. Deskriptor nimetab loendusmuutujat. Deklaratsioonis saab määrata rohkem kui ühe loenditüübi muutuja.
Loendiloend sisaldab ühte või mitut vormi konstruktsiooni:
identifikaator [= konstantne avaldis]
Iga identifikaator nimetab loendi elemendi. Kõik loendis olevad identifikaatorid peavad olema kordumatud. Kui konstantset avaldist pole, vastab esimene identifikaator väärtusele 0, järgmine identifikaator väärtusele 1 jne. Loendamiskonstandi nimi on samaväärne selle väärtusega.
Konstantse avaldisega seotud identifikaator omandab selle konstantse avaldise määratud väärtuse. Konstantavaldis peab olema int tüüpi ja võib olla kas positiivne või negatiivne. Loendi järgmisele identifikaatorile omistatakse konstantavaldise väärtus pluss 1, kui sellel identifikaatoril ei ole oma konstantset avaldist. Loendielementide kasutamisel tuleb järgida järgmisi reegleid:
1. Muutuja võib sisaldada korduvaid väärtusi.
2. Loendiloendis olevad identifikaatorid peavad erinema kõigist teistest sama ulatusega identifikaatoritest, sealhulgas tavalistest muutujate nimedest ja identifikaatoritest muudest loendusloenditest.
3. Enumtüüpide nimed peavad erinema teistest sama ulatusega enumitüüpide, struktuuride ja segude nimedest.
4. Väärtus võib järgneda loendusloendi viimasele elemendile.
Enum nädal ( SUB = 0, /* 0 */ VOS = 0, /* 0 */ POND, /* 1 */ VTOR, /* 2 */ SRED, /* 3 */ HETV, /* 4 */ PJAT /* 5 */ ) rab_ned ;
Selles näites deklareeritakse loendatav silt nädal koos vastava väärtuste komplektiga ja muutuja rab_ned tüübiga nädal.
Teine vorming kasutab enum-märgendi nime, et viidata kusagil mujal määratletud loenditüübile. Loendamissildi nimi peab viitama juba määratletud loendussildile praeguses ulatuses. Kuna loendusmärgend on deklareeritud kusagil mujal, siis loendusnimekirja deklaratsioonis ei esitata.
Loenduse andmetüübile osutava kursori deklareerimisel ja loenditüüpide tüübimäärangute deklareerimisel saate enne selle loendussildi määratlemist kasutada loendussildi nime. Siiski peab enum definitsioon eelnema typedef deklaratsiooni kursori kasutamisele tüübile. Deklaratsioon ilma järgneva deskriptorite loendita kirjeldab silti või nii-öelda loendusmustrit.
1.2.6. Massiivid
Massiivid on sama tüüpi elementide rühm (double, float, int jne). Massiivi deklaratsioonist peab kompilaator hankima infot massiivi elementide tüübi ja nende arvu kohta. Massiivi deklaratsioonil on kaks vormingut:
tüübispetsifikaatori deskriptor [const - avaldis];
tüübispetsiifiline deskriptor ;
Deskriptor on massiivi identifikaator.
Tüübispetsifikaat määrab deklareeritud massiivi elementide tüübi. Massiivielemendid ei saa olla funktsioonid ega tühised elemendid.
Konstantne avaldis nurksulgudes määrab massiivi elementide arvu. Massiivi deklareerimisel võib konstantse avaldise välja jätta järgmistel juhtudel:
Deklareerimisel massiiv initsialiseeritakse,
Massiiv deklareeritakse funktsiooni formaalse parameetrina,
SI määratleb ainult ühemõõtmelisi massiive, kuid kuna massiivi elemendiks võib olla massiiv, saab defineerida ka mitmemõõtmelisi massiive. Need vormistatakse massiivi identifikaatorile järgnevate konstantide avaldiste loendiga, kusjuures iga konstantne avaldis on suletud oma nurksulgudesse.
Iga konstantne avaldis nurksulgudes määrab elementide arvu selle massiivi dimensiooni ulatuses, nii et kahemõõtmeline massiivi deklaratsioon sisaldab kahte konstanti avaldist, kolmemõõtmeline massiiv kolme jne. Pange tähele, et SI-s on massiivi esimese elemendi indeks 0.
Int a; /* esitatakse maatriksina a a a a a a */ topelt b; /* 10 elemendi vektor tüüpi double */ int w = ( ( 2, 3, 4 ), ( 3, 4, 8 ), ( 1, 0, 9 ) );
Viimases näites deklareeritakse massiiv w. Sulgudes olevad loendid vastavad massiivi stringidele, kui sulgusid ei ole, ei teostata lähtestamist õigesti.
SI-keeles saate kasutada massiivi sektsioone, nagu ka teistes kõrgetasemelistes keeltes (PL1 jne), kuid jaotiste kasutamisele on kehtestatud mitmeid piiranguid. Sektsioonid moodustatakse ühe või mitme nurksulgude paari väljajätmisega. Nurksulgude paare saab langetada ainult paremalt vasakule ja rangelt järjestikku. Massiivide sektsioone kasutatakse arvutusprotsessi korraldamiseks kasutaja poolt välja töötatud SI-funktsioonides.
Kui funktsiooni kutsumisel kirjutada s, edastatakse massiivi s nullstring.
Massiivi b juurde pääsemisel saate kirjutada näiteks b ja neljast elemendist koosnev vektor kantakse üle ning b-le juurdepääsemine annab kahemõõtmelise massiivi suurusega 3 x 4. Te ei saa kirjutada b-d, mis tähendab, et vektor üle kanda, sest see ei vasta massiivi osadele kehtestatud piirangule.
Näide märgimassiivi deklaratsioonist.
char str = "märgimassiivi deklaratsioon";
Pange tähele, et täheliteraalis on veel üks element, kuna viimane element on paojada "\0".
1.2.7. Struktuurid
Struktuurid on liitobjektid, mis sisaldavad mis tahes tüüpi elemente, välja arvatud funktsioonid. Erinevalt massiivist, mis on homogeenne objekt, võib struktuur olla heterogeenne. Struktuuri tüüp määratakse vormi kirjega:
struktuur (definitsioonide loend)
Struktuuris peab olema määratud vähemalt üks komponent. Struktuuride määratlus on järgmine:
andmetüübi deskriptor;
kus andmetüüp määrab deskriptorites määratletud objektide struktuuri tüübi. Kõige lihtsamal kujul on käepidemed identifikaatorid või massiivid.
Struktuur ( topelt x,y; ) s1, s2, sm; struct (int aasta; char moth, day; ) date1, date2;
Muutujad s1, s2 on defineeritud kui struktuurid, millest igaüks koosneb kahest komponendist x ja y. Muutuja sm on defineeritud üheksast struktuurist koosneva massiivina. Kumbki kahest muutujast date1, date2 koosneb kolmest komponendist aasta, koi, päev. >p>On veel üks võimalus nime seostamiseks struktuuritüübiga, see põhineb struktuurisildi kasutamisel. Struktuurimärgend sarnaneb enum-tüüpi sildiga. Struktuurimärgend on määratletud järgmiselt:
struct tag ( kirjelduste loend; );
kus silt on identifikaator.
Allolev näide kirjeldab õpilase identifikaatorit struktuurimärgendina:
Struktuuri õpilane ( char name; int id, vanus; char prp; );
Struktuurimärgendit kasutatakse seda tüüpi struktuuride järgnevaks deklareerimiseks järgmisel kujul:
struct id-list tag;
struct studeut st1,st2;
Struktuurimärgendite kasutamine on vajalik rekursiivsete struktuuride kirjeldamiseks. Järgnevalt käsitletakse rekursiivse struktuuri siltide kasutamist.
Struct node ( int data; struct node * next; ) st1_node;
Struktuurisildi sõlm on tõepoolest rekursiivne, kuna seda kasutatakse oma kirjelduses, st. järgmise osuti vormistamisel. Struktuurid ei saa olla otseselt rekursiivsed, s.t. sõlme struktuur ei saa sisaldada komponenti, mis on sõlme struktuur, kuid igal struktuuril võib olla komponent, mis osutab selle tüübile, nagu on tehtud ülaltoodud näites.
Struktuurikomponentidele pääseb juurde, määrates struktuuri nime ja punktiga eraldatuna valitud komponendi nime, näiteks:
St1.name="Ivanov"; st2.id=st1.id; st1_node.data=st1.age;
1.2.8. Kombinatsioonid (segud)
Liit on sarnane struktuuriga, kuid igal ajal saab kasutada (või teisisõnu reageerida) ainult ühte liidu elementidest. Ühenduse tüübi saab määrata järgmiselt:
Liit ( elemendi 1 kirjeldus; ... elemendi n kirjeldus; );
Ühenduse peamine omadus on see, et iga deklareeritud elemendi jaoks eraldatakse sama mäluala, s.o. need kattuvad. Kuigi sellele mälupiirkonnale pääseb juurde mis tahes elemendi abil, tuleb selleks otstarbeks sobiv element valida nii, et saadud tulemus ei oleks mõttetu.
Ametiühingu liikmetele pääseb ligi samamoodi nagu struktuuridele. Ametiühingusildi saab vormistada täpselt samamoodi nagu struktuurimärgendit.
Ühingut kasutatakse järgmistel eesmärkidel:
Kasutusel oleva mäluobjekti lähtestamine, kui ühel hetkel on aktiivne ainult üks paljudest objektidest;
Tõlgendage ühte tüüpi objekti aluseks olevat esitust nii, nagu sellele objektile oleks määratud teist tüüpi.
Ühenduse tüüpi muutujale vastav mälu määratakse liidu pikima elemendi mahutamiseks vajaliku mahu järgi. Lühema elemendi kasutamisel võib liittüübi muutuja sisaldada kasutamata mälu. Kõik ühenduse elemendid on salvestatud samasse mälupiirkonda, alustades samast aadressist.
Liit (char fio; char aadressid; int vozrast; int telefon; ) teavitama; liit ( int ax; char al; ) ua;
Union tüüpi infoobjekti kasutamisel saab töödelda ainult väärtuse saanud elementi, s.t. Pärast inform.fio elemendile väärtuse määramist pole mõtet teistele elementidele juurde pääseda. Ua konkatenatsioon võimaldab eraldi juurdepääsu kahebaidise numbri ua.ax madala ua.al ja kõrge ua.al baitidele.
1.2.9. Bittide väljad
Struktuuri element võib olla bitiväli, mis annab juurdepääsu üksikutele mälubittidele. Bitivälju ei saa deklareerida väljaspool struktuure. Samuti ei saa te korraldada bitiväljade massiive ja te ei saa väljadele aadressi määramise toimingut rakendada. Üldiselt määratakse bitiväljaga struktuuri tüüp järgmiselt:
Struktuur ( märgita identifikaator 1: välja pikkus 1; märgita identifikaator 2: välja pikkus 2; )
pikkus – väljad määratakse täisarvulise avaldise või konstandiga. See konstant määrab vastavale väljale eraldatud bittide arvu. Nullpikkusega väli näitab joondamist järgmise sõnapiiriga.
Struktuur ( unsigned a1: 1; unsigned a2: 2; unsigned a3: 5; unsigned a4: 2; ) prim;
Bitiväljastruktuurid võivad sisaldada ka märgistatud komponente. Sellised komponendid paigutatakse automaatselt sobivatele sõnapiiridele ja mõned sõnabitid võivad jääda kasutamata.
1.2.10. Muutuva struktuuriga muutujad
Väga sageli kuuluvad mõned programmiobjektid samasse klassi, erinedes vaid mõne detaili poolest. Mõelge näiteks geomeetriliste kujundite kujutamisele. Üldine teave kujundite kohta võib sisaldada selliseid elemente nagu pindala, ümbermõõt. Vastav geomeetriliste mõõtmete teave võib aga olenevalt nende kujust erineda.
Vaatleme näidet, kus teave geomeetriliste kujundite kohta on esitatud struktuuri ja ühenduse kombineeritud kasutamise põhjal.
Struktuurikuju ( topeltala,perimeeter; /* tavalised komponendid */ int tüüp; /* komponendi atribuut */ liit /* komponentide loend */ ( topeltraadius; /* ring */ double a; /* ristkülik */ topelt b ; /* kolmnurk */ ) geom_fig ) fig1, fig2;
Üldiselt koosneb iga joonisobjekt kolmest komponendist: pindala, perimeeter, tüüp. Tüübikomponenti nimetatakse aktiivse komponendi sildiks, kuna seda kasutatakse selleks, et näidata, milline liidu geom_fig komponent on hetkel aktiivne. Seda struktuuri nimetatakse muutujastruktuuriks, kuna selle komponendid muutuvad sõltuvalt aktiivse komponendi sildi väärtusest (tüübi väärtusest).
Pange tähele, et int tüüpi komponendi asemel oleks soovitatav kasutada loendatavat tüüpi. Näiteks niimoodi
Enum figuur_male ( RING, KAST, KOLMNURK ) ;
Konstandid CIRCLE, BOX, TRIANGLE saavad väärtused, mis on vastavalt 0, 1, 2 Tüübi muutuja saab deklareerida loendatud tüübina:
enum figuuri_male tüüp;
Sel juhul hoiatab SI kompilaator programmeerijat potentsiaalselt vigaste määrangute eest, nagu näiteks
figuur.tüüp = 40;
Üldiselt koosneb struktuurimuutuja kolmest osast: tavaliste komponentide komplekt, aktiivse komponendi silt ja muutuvate komponentidega osa. Muutuja struktuuri üldvorm on järgmine:
Struktuur (tavalised komponendid; aktiivse komponendi silt; liit (komponendi kirjeldus 1; komponendi kirjeldus 2; ::: komponendi kirjeldus n; ) liit-identifikaator; ) struktuuri identifikaator;
Struktuurimuutuja nimega helth_record määratlemise näide
Struktuur ( /* üldteave */ märgi nimi ; /* nimi */ int vanus; /* vanus */ täht sugu; /* sugu */ /* aktiivse komponendi silt */ /* (perekonnaseis) */ enum merital_status ins ; /* muutuv osa */ liit ( /* vallaline */ /* komponent puudub */ struct ( /* abielus */ char abikaasa_nimi; int no_lapsed; ) abielu_info; /* lahutatud */ char date_lahutatud; ) abielu_info; enum perekonnaseis ( VALALINE, /* vallaline */ MARRIGO, /* abielus */ LAHKUNUD /* lahutatud */ ) ;
Struktuuri komponentidele pääsete juurde linkide abil:
Helth_record.neme, helth_record.ins, helth_record.marriage_info.marriage_date .
1.2.11. Objektide ja tüüpide määratlemine
Nagu eespool mainitud, tuleb deklareerida kõik SI programmides kasutatavad muutujad. Deklareeritava muutuja tüüp sõltub sellest, millist märksõna kasutatakse tüübispetsifikaatorina ja kas see on lihtne identifikaator või identifikaatori kombinatsioon kursori (tärni), massiivi (nurksulud) või funktsiooni (sulgude) modifikaatoriga.
Lihtsa muutuja, struktuuri, segu või ühenduse või loenduse deklareerimisel on deskriptor lihtne identifikaator. Kursori, massiivi või funktsiooni deklareerimiseks muudetakse identifikaatorit vastavalt: tärn vasakul, ruut või sulud paremal.
Märkigem SI keele olulist tunnust: deklareerimisel saab korraga kasutada rohkem kui üht modifikaatorit, mis võimaldab luua palju erinevaid keerulisi tüübikirjeldusi.
Siiski peame meeles pidama, et mõned modifikaatorite kombinatsioonid on vastuvõetamatud:
Massiivielemendid ei saa olla funktsioonid.
Funktsioonid ei saa tagastada massiive ega funktsioone.
Keeruliste deskriptorite lähtestamisel on nurksulud ja sulud (identifikaatorist paremal) tärni (identifikaatorist vasakul) ees. Ruududel või sulgudel on sama tähtsus ja neid laiendatakse vasakult paremale. Tüübi määrajat võetakse arvesse viimases etapis, kui deskriptor on juba täielikult tõlgendatud. Vajadusel saate tõlgendamise järjekorda muuta sulgudega.
Keeruliste kirjelduste tõlgendamiseks pakutakse välja lihtne reegel, mis kõlab nagu "seest väljapoole" ja koosneb neljast etapist.
1. Alustage identifikaatorist ja vaadake paremale, kas seal on ruut või sulgud.
2. Kui on, siis tõlgendage seda deskriptori osa ja seejärel vaadake tärni otsides vasakule.
3. Kui mis tahes etapis kohtab paremal sulgevat sulgu, siis tuleb esmalt rakendada kõiki neid reegleid sulgudes ja seejärel jätkatakse tõlgendamist.
4. Tõlgendada tüübispetsiifikat.
Int * (* komp ) (); 6 5 3 1 2 4
See näide deklareerib muutuja comp (1) kümne (2) osuti (3) massiivina funktsioonidele (4), mis tagastab osutid (5) täisarvu väärtustele (6).
Char * (* (*var) ()) ; 7 6 4 2 1 3 5
Muutuja var (1) deklareeritakse kui osuti (2) funktsioonile (3), mis tagastab osuti (4) massiivile (5), mis koosneb 10 elemendist, mis on osutid (6) char väärtustele.
Lisaks erinevat tüüpi muutujate deklareerimisele on võimalik deklareerida ka tüüpe. Seda saab teha kahel viisil. Esimene võimalus on määrata struktuuri, liidu või loendi deklareerimisel sildi nimi ja seejärel kasutada seda nime muutujate ja funktsioonide deklaratsioonides viitena sellele märgendile. Teine on tüübi deklareerimiseks märksõna typedef kasutamine.
Kui deklareeritakse koos typedef märksõnaga, on kirjeldatava objekti asemel identifikaator vaadeldava andmetüübi nimi ja seda tüüpi saab seejärel kasutada muutujate deklareerimiseks.
Pange tähele, et märksõna typedef abil saab deklareerida mis tahes tüüpi, sealhulgas osuti, funktsiooni või massiivi tüüpe. Nime, mille märksõna typedef on osuti, struktuuri ja liidutüüpide jaoks, saab deklareerida enne nende tüüpide määratlemist, kuid deklareerija ulatuses.
Typedef double(*MATH)(); /* MATH - uue tüübi nimi, mis tähistab osutit funktsioonile, mis tagastab topeltväärtused*/ MATH cos; /* cos osuti funktsioonile, mis tagastab väärtused tüüpi double */ /* Samaväärse deklaratsiooni saab teha */ double (* cos)(); typedef char FIO /* FIO - neljakümnest märgist koosnev massiiv */ FIO isik; /* Muutuja isik on neljakümnest märgist koosnev massiiv */ /* See on samaväärne deklaratsiooniga */ char person;
Muutujate ja tüüpide deklareerimisel kasutati siin tüübinimesid (MATH FIO). Lisaks saab tüübinimesid kasutada veel kolmel juhul: formaalsete parameetrite loendis, funktsioonide deklaratsioonides, tüübivalutoimingutes ja operatsiooni suuruses (tüübivalu operatsioon).
Põhi-, loendus-, struktuuri- ja segutüüpide tüübinimed on nende tüüpide tüübispetsifikaatorid. Massiivikursori ja funktsioonitüüpide tüübinimed määratakse abstraktsete deskriptorite abil järgmiselt.
abstraktne-deskriptor-tüübispetsifikaator;
Abstraktikäsitleja on mitteidentifitseeriv käepide, mis koosneb ühest või mitmest osutist, massiivist või funktsioonide modifikaatorist. Kursori modifikaator (*) antakse deskriptoris alati enne identifikaatorit ning massiivi ja funktsioonide modifikaatorid () pärast seda. Seega, abstraktse deskriptori õigeks tõlgendamiseks tuleb tõlgendamist alustada kaudse identifikaatoriga.
Abstraktsed kirjeldused võivad olla keerulised. Keeruliste abstraktsete deskriptorite sulud täpsustavad tõlgendamise järjekorda sarnaselt deklaratsioonide keerukate deskriptorite tõlgendamisega.
1.2.12. Andmete initsialiseerimine
Kui muutuja on deklareeritud, saab sellele määrata algväärtuse, lisades deklaraatorile initsiaatori. Algataja algab märgiga "=" ja sellel on järgmised vormid.
Formaat 1: = algataja;
Formaat 2: = (loend – algatajad);
Vormingut 1 kasutatakse põhitüüpide muutujate ja osutite lähtestamisel ning vormingut 2 kasutatakse liitobjektide lähtestamisel.
Tol muutuja initsialiseeritakse märgiga "N".
const pikk megabute = (1024 * 1024);
Mittemuutuv megabuutmuutuja lähtestatakse konstantse avaldisega, mille järel seda muuta ei saa.
staatiline int b = (1,2,3,4);
Initsialiseeritakse b-täisarvust koosnev kahemõõtmeline massiiv, massiivi elementidele määratakse loendist väärtused. Sama initsialiseerimist saab teha järgmiselt:
staatiline int b = ( ( 1,2 ), ( 3,4 ) );
Massiivi lähtestamisel võite ühe või mitu dimensiooni välja jätta
static int b - märgiga tähemärgi jaoks
Vaikimisi loetakse täisarvuline muutuja märgituks. Märkimaks koodis, et muutuja peab olema allkirjastamata, lisatakse vasakul asuvale põhitüübile signed atribuut, s.o. allkirjastamata:
Märgita pikad väärtused; // määrab täisarvu (pika) märgita tüübi.
Loetletud tüübid erinevad ainult salvestamiseks vajaliku mälu suuruse poolest. Kuna C++ keel on üsna masinast sõltuv, tagab keelestandard ainult järgmise tingimuse:
- 1 = tähe suurus ≤ lühike suurus ≤ sisemine suurus ≤ pikk suurus.
Tavaliselt on tüüpide suurused järgmised: char - 1, short - 2, int - 4, long -8, long long - 8 baiti.
Aritmeetilisi toiminguid saate teha täisarvu tüüpi väärtustega: +, -, *, /, %; võrdlustehted: ==, !=,<=, <, >, >=; bititehted: &, |, xor,<<, >>.
Enamikku tehteid, nagu liitmine, korrutamine, lahutamine ja võrdlemine, on lihtne mõista. Mõnikord võib pärast aritmeetiliste toimingute sooritamist tulemus olla väljaspool väärtusvahemikku; sel juhul tekitab programm vea.
Täisarvu jagamine (/) otsib täisarvu osa, mis on jagatud teisega. Näiteks:
- 6 / 4 = 1;
- 2 / 5 = 0;
- 8 / 2 = 4.
Protsendisümbol (%) tähistab kahe täisarvu jaotuse ülejäänud osa määramise toimingut:
- 6 % 4 = 2;
- 10 % 3 = 1.
Raskemini mõistetavad on bitipõhised operatsioonid: & (JA), | (OR), xor (eksklusiivne VÕI),<< (побитовый сдвиг влево), >> (bitipõhine nihe paremale).
Bitioperatsioonid JA, VÕI ja XOR rakendavad igale teabebitile vastavat loogilist operatsiooni:
- 1 10 = 01 2
- 3 10 = 11 2
- 1 10 & 3 10 = 01 2 & 11 2 = 01 2
- 1 10 | 3 10 = 01 2 | 11 2 = 11 2
- 1 10 x või 3 10 = 01 2 x või 11 2 = 10 2
Pilditöötluses kasutatakse värvi jaoks 3 kanalit: punane, sinine ja roheline - pluss läbipaistvus, mis salvestatakse muutujasse int, kuna igal kanalil on väärtuste vahemik 0 kuni 255. Kuueteistkümnendsüsteemis kirjutatakse teatud väärtus järgmiselt: 0x180013FF; siis väärtus 18 16 vastab punasele kanalile, 00 16 - sinine, 13 16 - roheline, FF - alfa kanal (läbipaistvus). Konkreetse kanali valimiseks sellisest täisarvust kasutatakse nn kanalit. mask, kus meid huvitavad positsioonid on F 16 või 1 2. See tähendab, et sinise kanali väärtuse esiletõstmiseks tuleb kasutada maski, st. bitipõhiselt JA:
Int blue_channel = 0x180013FF & 0x00FF0000;
Pärast seda nihutatakse saadud väärtus vajaliku arvu bittide võrra paremale.
Bitinihe nihutab arvu vasakule või paremale nii mitme kahendnumbri võrra, nagu on määratud toimingu paremal küljel. Näiteks märgi tüübi arv 39 kirjutatakse binaarselt järgmiselt: 00100111. Seejärel:
Char binaryNäide = 39; // 00100111 char result = binaryExample<< 2; // сдвигаем 2 бита влево, результат: 10011100
Kui muutuja on märgita tüüpi, on tulemuseks arv 156, märgiga muutuja puhul on see võrdne -100. Pange tähele, et märgiga täisarvu tüüpide puhul on biti esituse kõige olulisemas bitis olev ühik märk sellest, et arv on negatiivne. Sel juhul vastab binaarkujuline väärtus, mis koosneb kõigist ühtedest, väärtusele -1; kui 1 on ainult kõige olulisemas numbris ja ülejäänud numbrid on nullid, siis on sellisel arvul konkreetse tüübi jaoks minimaalne väärtus: tähe puhul on see -128.
2. Ujukoma tüüp (ujuk, topelt (ujuk))
Ujukomaväärtuste komplekt on reaalarvude alamhulk, kuid mitte iga reaalarv ei ole kahendarvuna esitatav, mis mõnikord põhjustab rumalaid vigu:
Ujuv väärtus = 0,2; väärtus == 0,2; // viga, väärtus siin ei võrdu 0,2-ga.
Ujukomamuutujatega töötades ei tohiks programmeerija kasutada võrdsuse või ebavõrdsuse testi, tavaliselt kasutatakse teatud intervalli langemise testi:
Väärtus - 0,2< 1e-6; // ok, подбирать интервал тоже нужно осторожно
Lisaks võrdlustehtetele toetab ujukomatüüp 4 aritmeetilist tehtet, mis vastavad täielikult matemaatilistele tehtetele reaalarvudega.
3. Boole'i (loogiline) tüüp (bool)
Koosneb ainult kahest väärtusest: true (true) ja false (false). Seda tüüpi muutujatega töötamiseks kasutatakse loogilisi tehteid: ! (EI), == (võrdsus), != (ebavõrdsus), && (loogiline JA), || (loogiline VÕI). Iga toimingu tulemuse leiab vastavast tõesuse tabelist. Näiteks:
4. Tähemärgi tüüp (char, wchar_t)
Märgi tüüp pole mitte ainult täisarvu tüüp (tavaliselt nimetatakse seda tüüpi bait), vaid ka märgitüüp, mis salvestab tabelis oleva märginumbri ASCII-märgina. Näiteks kood 0x41 vastab märgile "A" ja 0x71 - "t".
Mõnikord on vaja kasutada märke, mis pole ASCII-tabelites fikseeritud ja nõuavad seetõttu salvestamiseks rohkem kui 1 baiti. Nende jaoks on lai märk (wchar_t).
5.1. Massiivid
Massiivid võimaldavad salvestada sama tüüpi elementide järjestikust komplekti. Massiiv salvestatakse mällu külgneva plokina, seega ei saa massiivi deklareerida ilma selle suurust määramata. Massiivi deklareerimiseks kirjutatakse muutuja nime järele nurksulud (), mis näitab selle suurust. Näiteks:
Int myArray; // 5 täisarvu tüüpi elemendi massiiv
Massiivi lähtestamiseks on väärtused loetletud lokkis sulgudes. Sel viisil saate lähtestada ainult muutuja deklareerimise ajal. Muide, sel juhul pole massiivi suurust vaja määrata:
keskmine koefitsient = (1, 3, 7, 9, 11); // Massiivi lähtestatakse 5 väärtusega
Massiivi (massiivi elemendi) konkreetsele väärtusele juurde pääsemiseks kasutage indeksi juurdepääsutoimingut (), mis näitab elemendi numbrit (numbrid algavad 0-st). Näiteks:
Koefitsiendid; // juurdepääs massiivi esimesele elemendile. Tagastab väärtuse 1 koefitsient; // juurdepääs kolmandale elemendile. Tagastab väärtuse 7 koefitsient = 13; // Massiivi koefitsientide 5. elemendile uue väärtuse määramine; // juurdepääsu viga
5.3. Stringid
Stringi kirjutamiseks kasutavad programmeerijad ideed, et string on märkide järjestikune jada (massiivi). Rea lõpu tuvastamiseks kasutage spetsiaalset rea lõpu märki: '\0'. Neid erimärke, mis koosnevad kaldkriipsust ja identifitseerivast märgist, nimetatakse juht- või paomärkideks. Samuti on näiteks ‘\n’ – uue rea algus, ‘\t’ – tabeldusmärk. Stringi kaldkriipsu kirjutamiseks kasutatakse paoklahvi – märgi enda ette asetatakse teine kaldkriips: ‘\’. Põgenemist kasutatakse ka jutumärkide kirjutamiseks.
Loome stringi muutuja:
Char textExample = ('T', 'e', 's', 't', '\0'); // kirjutatakse string “Test”.
Stringi initsialiseerimiseks on lihtsustatud märge:
Char textExample = "Testi"; // Viimast tähemärki ei kirjutata, aga suurus on ikkagi 5
Üksikasjadesse laskumata on siin veel üks kasulik andmetüüp - string. Stringid
Seda tüüpi saab lisada näiteks:
String tere = "Tere,"; string name = "Max!"; string tere_nimi = tere + nimi; // Hangi string "Tere, Max!"
6. Link
Int a = 2; // muutuja "a" osutab väärtusele 2 int &b = a; // muutuja “b” osutab samale kohale kui “a” b = 4; // muutes b väärtust, muudab programmeerija a väärtust. Nüüd a = 4 int & c = 4; // viga, sa ei saa seda teha, sest viitele ei saa väärtust määrata
7. Indeks
Selle andmetüübi mõistmiseks peate meeles pidama, et paljud seda tüüpi väärtused on nende mälurakkude aadressid, kust andmed algavad. Kursor toetab ka liitmise (+), lahutamise (-) ja viitamise (*) toiminguid.
Aadressid 0x0 tähendab, et kursor on tühi, st. ei viita ühelegi andmetele. Sellel aadressil on oma sõnasõna - NULL:
Int *nullPtr = NULL; // null osuti
Aadressi liitmine ja lahutamine täisarvu või mõne muu aadressiga võimaldab
saate programmi käsutuses olevas mälus ringi liikuda.
Andmete otsimist, mis algab osutisse salvestatud aadressilt, nimetatakse viitamise tühistamiseks (*). Programm loeb vajaliku arvu mälurakke ja tagastab mällu salvestatud väärtuse.
Int valueInMemory = 2; // määrab täisarvu tüüpi muutuja int *somePtr = // kopeeri muutuja aadress, siin & - tagastab muutuja aadressi somePtr; // mäluelemendi aadress, näiteks 0x2F *somePtr; // väärtus salvestatakse 4 lahtrisse: 0x2F, 0x30, 0x31 ja 0x32
Omistamistoiming, mis on süntaktiliselt sama mis kopeerimistoiminguga, pole osutite jaoks saadaval. Teisisõnu saate kopeerida mõne teise osuti aadressi või muutuja aadressi, kuid te ei saa ise aadressi väärtust määrata.
Kursor ise salvestatakse mällu, nagu ka muud tüüpi muutujate väärtused, ja see võtab enda alla 4 baiti, nii et saate luua kursori.
8. Ülekanded
Loendid on ainuke põhitüüp, mille programmeerija on määratlenud. Üldiselt on loend nimega täisarvuliste konstantide järjestatud kogum, mille põhitüüp on loendi nimi.
Enum värv (PUNANE, SININE, ROHELINE);
Vaikimisi PUNANE = 0, SININE = 1, ROHELINE = 2. Seetõttu saab väärtusi omavahel võrrelda, st. PUNANE< BLUE < GREEN. Программист при объявлении перечисления может самостоятельно задать значения каждой из констант:
Enum juurdepääs (LOE = 1, KIRJUTA = 2, EXEC = 4);
Sageli on mugav kasutada loendeid, mille väärtused on kahe astmed, sest binaarses esituses koosneb 2 astmega arv 1-st ja nullidest. Näiteks:
8 10 = 00001000 2
Nende arvude liitmise tulemus näitab alati selgelt, millised numbrid lisati:
37 10 = 00100101 2 = 00000001 2 + 00000100 2 + 00100000 2 = 1 10 + 4 10 + 32 10
Tühine
Süntaktiliselt kuulub tühitüüp põhitüüpide hulka, kuid seda saab kasutada ainult keerukamate tüüpide osana, kuna Tühi tüüpi objekte pole. Tavaliselt kasutatakse seda tüüpi näitamaks, et funktsioonil pole tagastusväärtust, või on see määramata tüüpi objektide kursori põhitüüp:
tühi objekt; // viga, void void tüüpi objekte pole // error, ei ole viiteid void void *ptr; // ok, salvesta kursor tundmatule tüübile
Sageli kasutame käsku void spetsiaalselt selleks, et näidata, et funktsioon ei tagasta väärtust. Tühi tüüpi kursorit kasutatakse siis, kui programmeerija võtab täieliku vastutuse mälu terviklikkuse ja õige tüübi ülekandmise eest.
Cast
Tihti on vaja üht tüüpi muutuja väärtust teisele üle kanda. Juhul, kui algtüübi väärtuste hulk on suuremat tüüpi alamhulk (näiteks int on pika alamhulk ja long on kahekordne), suudab kompilaator kaudselt ( kaudselt) muutke väärtuse tüüpi.
int täisarv = 2; float floating = täisarv; // ujuv = 2,0
Pöördtüüpi cast sooritatakse teabekaoga, nii et ujukomaarvust jääb alles vaid täisarvuline osa, murdosa kaob.
Selle jaoks on võimalik selgesõnaline tüübi teisendus, kirjutage muutuja või algse tüübi väärtusest vasakule sulgudesse tüüp, millele ülekandmine toimub:
Int väärtus = (int) 2,5;
Unaar- ja kahendtehted
Varem tehtud toiminguid nimetatakse binaarseteks: operatsioonisümbolist vasakul ja paremal on väärtused või muutujad, näiteks 2 + 3. Lisaks binaartoimingutele kasutavad programmeerimiskeeled ka muutujatele kehtivaid unaartehteid. . Need võivad asuda muutujast kas vasakul või paremal pool selliseid operatsioone on varem ette tulnud - viitamise eemaldamise operatsioon (*) ja muutuja aadressi võtmine (&) on unaarsed. Operaatorid “++” ja “–” suurendavad ja vähendavad täisarvulise muutuja väärtust vastavalt 1 võrra ning neid saab kirjutada muutujast kas vasakule või paremale.
C++ kasutab binaartehteid ka stenogrammi juhul, kui avaldise vasak ja parem pool sisaldavad sama muutujat, s.t. Muutuja väärtusega tehakse mõni toiming ja operatsiooni tulemus salvestatakse samasse muutujasse:
A += 2; // sama mis a = a + 2; b/= 5; // sama mis b = b / 5; c &= 3; // sama mis c = c & 3;
Muutujaid kasutatakse mitmesuguste andmete salvestamiseks programmeerimiskeeltes. Muutuja on mäluala, millel on nimi, mida muidu nimetatakse identifikaatoriks.
Andes muutujale nime, nimetab programmeerija samal ajal mäluala, kuhu muutuja väärtused salvestamiseks kirjutatakse.
Hea stiil on muutujaid tähendusrikkalt nimetada. Lubatud on kasutada väike- ja suurtähti, numbreid ja allkriipsu, mida loetakse täheks C-s. Esimene märk peab olema täht ja muutuja nimes ei tohi olla tühikuid. Kompilaatorite kaasaegsetes versioonides on nime pikkus praktiliselt piiramatu. Muutuja nimi ei saa vastata reserveeritud märksõnadele. Suur- ja väiketähed muutujate nimedes on erinevad, muutujad a Ja A- erinevad muutujad.
Reserveeritud märksõnad auto double int struct break else pikk lüliti register tupedef char väline tagastamine tühine juhtu
C-s peavad kõik muutujad olema deklareeritud. See tähendab, et esiteks peate iga programmi või funktsiooni alguses esitama loendi kõigist kasutatavatest muutujatest ja teiseks märkima nende iga tüübi.
Kui muutuja on deklareeritud, eraldab kompilaator sellele mäluruumi sõltuvalt selle tüübist. Kasutades standardseid AVR GCC tööriistu, töötab see andmetüüpidega char(märgitüüp) ja int(täisarvu tüüp).
| Muutuvad tüübid |
Sisestage char
char- on kõige ökonoomsem tüüp. Märgi tüüp võib olla märgistatud või märgita. Tähistatakse vastavalt kui " signeeritud char" (allkirjaga tüüp) ja " märgita täht" (märgita tüüp). Signeeritud tüüp võib salvestada väärtusi vahemikus -128 kuni +127. Signeerimata - 0 kuni 255. Char-muutujal on 1 bait mälu (8 bitti).
Märksõnad (muutjad) allkirjastatud Ja allkirjastamata näitavad, kuidas deklareeritud muutuja nullbitti tõlgendatakse, st kui märgita märksõna on määratud, siis nullbiti tõlgendatakse arvu osana, vastasel juhul tõlgendatakse nullbitti märgituna.
Tippige int
Täisarv int Võib olla lühike(lühike) või pikk(pikk).
Märksõna (muutja) lühike asetatakse märksõnade järele allkirjastatud või allkirjastamata. Seega eristatakse järgmisi tüüpe: signed short int, unsigned short int, signed long int, signed long int.
Tüübi muutuja allkirjastatud lühike int(märgiga lühike täisarv) võib võtta väärtusi vahemikus -32768 kuni +32767, allkirjastamata lühike int(märgita lühike täisarv) - 0 kuni 65535. Igaühele on eraldatud täpselt kaks baiti mälu (16 bitti).
Tüübi muutuja deklareerimisel allkirjastatud lühike int märksõnad allkirjastatud Ja lühike võib ära jätta ja sellise muutujatüübi saab lihtsalt deklareerida int. Seda tüüpi on võimalik deklareerida ka ühe märksõnaga lühike.
Muutuv allkirjastamata lühike int saab deklareerida kui allkirjastamata int või allkirjastamata lühike.
Iga suuruse jaoks allkirjastatud pikk int või allkirjastamata pikk int Mälu on eraldatud 4 baiti (32 bitti). Seda tüüpi muutujate väärtused võivad olla vastavalt vahemikus -2147483648 kuni 2147483647 ja 0 kuni 4294967295.
Samuti on sellised muutujad nagu pikk pikk int, mille jaoks on eraldatud 8 baiti mälu (64 bitti). Need võivad olla ka allkirjastatud või allkirjastamata. Märgiga tüübi puhul on väärtuste vahemik vahemikus -9223372036854775808 kuni 9223372036854775807, märgita tüübi puhul - 0 kuni 18446744073709551615. Signeeritud tüübi saab deklareerida lihtsalt kahe märksõna järgi. pikk pikk.
| Tüüp | Vahemik | Kuusnurkne vahemik | Suurus |
| märgita täht | 0 ... 255 | 0x00...0xFF | 8 bitine |
| signeeritud char või lihtsalt char |
-128 ... 127 | -0x80...0x7F | 8 bitine |
| allkirjastamata lühike int või lihtsalt allkirjastamata int või allkirjastamata lühike |
0 ... 65535 | 0x0000 ... 0xFFFF | 16 bitine |
| allkirjastatud lühike int või allkirjastatud int või lihtsalt lühike või int |
-32768 ... 32767 | 0x8000...0x7FFF | 16 bitine |
| allkirjastamata pikk int või lihtsalt allkirjastamata pikk |
0 ... 4294967295 | 0x00000000 ... 0xFFFFFFFF | 32-bitine |
| pikalt allkirjastatud või lihtsalt pikk |
-2147483648 ... 2147483647 | 0x80000000 ... 0x7FFFFFFFF | 32-bitine |
| allkirjastamata pikk pikk | 0 ... 18446744073709551615 | 0x0000000000000000 ... 0xFFFFFFFFFFFFFFFF | 64 bitine |
| allkirjastatud pikk pikk või lihtsalt pikk pikk |
-9223372036854775808 ... 9223372036854775807 | 0x8000000000000000 ... 0x7FFFFFFFFFFFFFFFF | 64 bitine |
Muutujad deklareeritakse deklaratsioonilauses. Deklaratsioonilause koosneb tüübispetsifikatsioonist ja muutujate nimede komadega eraldatud loendist. Lõpus peab olema semikoolon.
Muutuja deklaratsioonil on järgmine vorming:
[muutjad] tüübi_spetsifikaator identifikaator [, identifikaator] ...
Modifikaatorid- märksõnad allkirjastatud, allkirjastamata, lühike, pikk.
Tüübi määraja- märksõna char või int, mis määrab deklareeritud muutuja tüübi.
Identifikaator- muutuja nimi.
Näide: char x; int a, b, c; märgita pikk pikk y;
Nii deklareeritakse muutujad x, a, b, c, y. Muutujale x saab kirjutada väärtusi vahemikus -128 kuni 127. Muutujates a, b, c- alates -32768 kuni +32767. Muutujale y- 0 kuni 18446744073709551615.
Muutuja väärtuse initsialiseerimine deklareerimisel
Kui muutuja on deklareeritud, saab seda initsialiseerida, see tähendab, et sellele saab määrata algväärtuse. Seda saate teha järgmiselt. int x = 100; Seega muutujasse x Teatamisel kirjutatakse kohe arv 100 üles.
Parem on vältida lähtestatud muutujate segamist ühes deklaratsioonilauses, see tähendab, et on parem deklareerida lähtestatud muutujad eraldi ridadel.
| Konstandid |
Igat tüüpi muutuja võib kuulutada muutmatuks. See saavutatakse märksõna lisamisega konst tüübi määrajale. Muutujad koos tüübiga konst on kirjutuskaitstud andmed, mis tähendab, et muutujale ei saa uut väärtust määrata. Kui pärast sõna konst Kui tüübi määrajat pole, käsitletakse konstante märgistatud väärtustena ja neile määratakse tüüp int või pikk int vastavalt konstandi väärtusele: kui konstant on väiksem kui 32768, siis omistatakse sellele tüüp int, muidu pikk int.
Näide: const long int k = 25; konst m = -50; // kaudne konst int m=-50 konst n = 100000; // kaudne konst pikk int n=100000
| Ülesanne |
C-s määramiseks kasutatakse märki "=". Hinnatakse omistamismärgist paremal olevat avaldist ja saadud väärtus omistatakse omistamismärgist vasakul olevale muutujale. Sel juhul kustutatakse muutujasse salvestatud eelmine väärtus ja asendatakse uuega.
Tehtajat "=" ei tohiks mõista võrdsusena.
Näiteks avaldis a = 5; tuleks lugeda kui "määrata muutuja a kuni 5".
Näited: x = 5 + 3; // lisage väärtused 5 ja 3, // määrake tulemus muutujale x (kirjutage muutujale x) b = a + 4; // lisage muutujas a salvestatud väärtusele 4, // määrake saadud tulemus muutujale b (kirjutage muutujale b) b = b + 2; // lisage muutujas b salvestatud väärtusele 2, // määrake saadud tulemus muutujale b (kirjutage muutujale b)
Paremal pool saab muutuja väärtust kasutada mitu korda: c = b * b + 3 * b;
Näide: x = 3; // muutujale x omistatakse väärtus 3 y = x + 5; // muutujas x salvestatud väärtusele lisatakse arv 5, // saadud tulemus kirjutatakse muutujasse y z = x*y; // muutujate x ja y väärtused korrutatakse, // tulemus kirjutatakse muutujasse z z = z - 1; // z muutujas salvestatud väärtusest lahutatakse 1 // tulemus kirjutatakse muutujasse z
Seega muutujas z number 23 salvestatakse
Lisaks lihtsale määramistehterile "=" on C-s veel mitu kombineeritud määramistehterit: "+=", "-=", "*=
Näited: x += y; // sama mis x = x + y; - lisage x ja y // ning kirjutage tulemus muutujasse x x = y; // sama mis x = x - y; - lahutage x-st väärtus y // ja kirjutage tulemus muutujasse x x *= y; // sama mis x = x * y; - korrutage x y-ga // ja kirjutage tulemus muutujasse x x /= y; // sama mis x = x / y; - jagage x y-ga // ja kirjutage tulemus muutujasse x x % = y; // sama mis x = x % y; // arvutada x jagamisel y-ga täisarvu jääk // ja kirjutada tulemus muutujasse x
| Kasvatamine ja vähendamine |
Kui teil on vaja muuta muutuja väärtuseks 1, siis kasutage juurdekasv või vähenemine.
Kasv- muutujas salvestatud väärtuse suurendamise toiming 1 võrra.
Näide: x++; // muutuja x väärtust suurendatakse 1 võrra$WinAVR = ($_GET["avr"]); if($WinAVR) include($WinAVR);?>
Vähendamine- muutujas salvestatud väärtuse vähendamise operatsioon 1 võrra.
Näide: x--; // muutuja x väärtust vähendatakse 1 võrra
Kasv ja vähendamine on määramise operaatorid. Kui kasutate kahandamist ja suurendamist koos määramisoperaatoriga "=", siis kasutage postfiksi (x++) või eesliidet (++x). Esmalt täidetakse eesliite kirje.
Näited: y = x++;
Oletame, et muutujas x väärtus 5 salvestati siis sisse y kirjutatakse väärtus 5, mille järel muutuja väärtus x suurendatakse 1 võrra. Seega in y saab 5 ja sisse x- 6. y = --x;
Kui sisse x Kui väärtus 5 on salvestatud, tehakse esmalt vähendamine x 4-ni ja siis määratakse see väärtus muutujale y. Seega x Ja y omistatakse väärtus 4.
