C ++-Ohjelmointi/ Johdanto C ++-Wikibooks, ilmaisten opetus-, kiinteistö- ja erikoiskirjojen kokoelma (2024)

Johdanto C ++: een

Kohderyhmä:

Aloittelijoiden ohjelmointi, yhteenveto riittää vaihtamiseen.

Oppimistavoite:
Peruselementit C ++: ssa

On vanha perinne avata uusi ohjelmointikieli "Hello World" -ohjelmalla.Tämän kirjan ei pitäisi myöskään rikkoa perinteitä, tässä on "Hello World" -ohjelma C ++:

#sisältää // Syöttö- ja lähtökirjastoint pää-() { // päätoiminto std:::nyrkkeily << "Hei, sinä kaunis maailma!" << std:::endl; // lähtö palata 0 -; // Valinnainen paluu käyttöjärjestelmään}

Hei, sinä kaunis maailma!

Tosin se ei ole alkuperäinen versio, vaan alkuperäinen versio "Hello World".Jos suoritat ohjelman, saat tekstin "Hei, kaunis maailma!"Etkö tiedä kuinka voit suorittaa ohjelman?Lue sitten lukuKääntäjä.

#sisältää Anna tarvittavat komennot syöttö- ja ulostuloon.Seuraavaksi "päätoiminto" alkaapää-().Tätä päätehtävää kutsutaan, kun ohjelma suoritetaan.Joten se on ohjelman keskeinen ydin.Muuten, jos funktiot mainitaan tekstissä, aina takertuu, jotta ne voidaan erottaa paremmin muista kielikomponenteista, kuten muuttujista.

std:::nyrkkeilykuvaa vakiolähtövirtaa.Teksti näkyy yleensä päätelaitteessa (jos lähtöä ei ohjata tiedostoon tai toiseen ohjelmaan).Kaksi nuolta (<<) merkitsevät, että vakiopainon takana oleva teksti on "työnnetty".Sestd:::endlRivin tauko ja varmistaa, että teksti on nyt tulossa näytöllä.

palata 0 -Ohjelma päättyy ja osoittaa, että se suoritettiin onnistuneesti.Yksityiskohdat käsitellään yksityiskohtaisesti seuraavissa luvuissa (tai osioissa).Tämä rivi on valinnainen;Jos sitä ei ole määritetty, kääntäjä palauttaa toistuvasti 0.

Tällä hetkellä sinun on muistettava, että jokainen C ++ -komento puolipisteellä (;) on valmis ja söpöt suluet ({...}) Symboloi yhteenkuuluvuutta - myös päätoiminnossa.Kaikki, mikä seisoo kiharakiinnikkeiden välillä, kuuluu hänelle.Tiloilla, tabic -merkkeillä ja linjakatkoksilla ei ole roolia C ++ -kääntäjälle.Voit kääntää seuraavan ohjelman sekä sen helpon -lue -version yllä olevasta:

#sisältää  int pää- ( -A {std ::: nyrkkeily << "Hei, sinä kaunis maailma!"<<std ::: endl;palata 0 -; }

Hei, sinä kaunis maailma!

Sinun pitäisi olla varovainen linjojen kanssaHioalkaa.Tilat ja välilehdet ovat täällä myös merkityksettömiä, mutta linjakatkoja ei saa tapahtua.

Muuten, ei ole merkitystä (tietokoneellesi), pidätkö jotain sellaista// Syöttö- ja lähtökirjastoKirjoita ohjelmallesi vai ei.Nämä ovat niin kutsuttuja kommentteja, jotka tutustuvat pian tarkemmin.Muuten, sinun on huomattava, että C ++ on merkityksellinen C ++: lle.Vakiokirjaston avainsanat ja nimet on aina kirjoitettu.On olemassa tiettyjä yleissopimuksia itse määrittelemien nimien tärkeimmistä/pienistä kirjoittamisesta, joita käsitellään myöhemmässä luvussa.

Yksittäiset ja poistumistilot antavat sinulle mahdollisuuden olla vuorovaikutuksessa ohjelman kanssa.Tässä luvussa käsitellään C ++ -konsolin näppäimistöä ja lähtöä tyypillisessä muodossa.Tutustu C -varianttiin myöhemmin.

Jotta voit käyttää C ++ -sertiota ja lähtöä, tarvitset kirjastoniostreamintegroitu.Se tapahtuu:

#sisältää 

Sen jälkeen komennot on ilmoitettava siitä, koska ne ovat nimihuoneessa (englanti.nimitila) ehto.Saat selville, mitkä nimet ovat ja mitä käytät heille myöhempää käyttöä varten.Syöttö- ja lähtötaulun käyttämiseksi sinun on kerrottava kääntäjälle: käytä nimihuonettastd.Tätä varten on kaksi vaihtoehtoa: Voit käyttää seuraavaa riviä kaikkiin nimiin nimen huoneestastdAsettaa:

käyttäminen nimitila std;

Tai voit tehdä nimihuoneen "std”Ilmoita aina suoraan.Se sisältää kaikki C ++ -standardikirjaston komponentit.Tämän kirjan ohjelmissa nimihuone annetaan aina suoraan.Tämä tarkoittaa esimerkiksi, jos objektia on käytettävä, joka nimihuoneessa "std"Valheita, hän tulee"std:::”Ennustettu.Kaksi kaksinkertaista pistettä kutsutaan alueoperaattoriksi.

Varianttikäyttäminen nimitilatulisi yleensä käyttää vain funktioissa, koska käytettynä globaalissa nimihuoneessa koko nimikeskeet vanhentuvat.Sitä käytetään usein maailmanlaajuisesti painetuissa kirjoissa, koska tämä säästää tilaa ja mitä tällaisissa kirjoissa on vähän.Älä lykkää sitä, se on huono tyyli.

Helppo painos[[Muokata-

Nyt haluamme vihdoin tehdä jotain käytännöllistä.Tosin mitään maapallon puristavaa ja periaatteessa edes jotain todella uutta, koska olemme jo antaneet tekstiä "Hello World" -ohjelmassa.

#sisältää int pää-() { std:::nyrkkeily << "Tämä teksti on nyt komentorivillä!"; std:::nyrkkeily << "Tämä teksti seuraa suoraan .."; std:::nyrkkeily << '.';}

Tämä teksti on nyt komentorivillä! Tämä teksti seuraa suoraan ...

Kuten itse teksti sanoi, se näkyy komentorivillä ja toinen seuraa keskeytystä.Viimeinen kolmesta viimeisestä kohdasta on lisälinja osoittaa, että et laita yksittäisiä merkkejä lainausmerkeihin, vaan apostrofiseen.Tämä koskee kuitenkin vain yksittäisiä merkkejä, kahdesta merkistä se on jo merkkijono ja sitten käytät normaaleja lainausmerkkejä.

Jos haluat lisätä linjatauko merkkijonoon, on kaksi vaihtoehtoa.VoitPoistumisjärjestys \nAseta se merkkijonoon taiManipulaattori endl(loppulinja) käytä.Se, mitä paeta -sekvenssejä tai manipulaattoreita tarkalleen on, on myöhemmän luvun aihe, mutta seuraava esimerkki osoittaa linjan tauon käytön:

#sisältää int pää-() { std:::nyrkkeily << "Teksti komentorivillä!\ n"; // Escape -sekvenssi \ n std:::nyrkkeily << "Tämä teksti seuraa ...\ n"; // se on erillisellä viivalla std:::nyrkkeily << std:::endl; // Tyhjä viiva ENDL: n avulla std:::nyrkkeily << "Teksti komentorivillä!" << std:::endl; // linjatauko Endlin kanssa std:::nyrkkeily << "Tämä teksti liittyy ..." << std:::endl; // se on erillisellä viivalla}

Teksti komentorivillä!Tämä teksti seuraa ...Teksti komentorivillä!Tämä teksti seuraa ...

Molemmilla menetelmillä näyttää olevan sama vaikutus.Käytä Escape -sekvenssimenetelmää"\ n".std:::endlSe on hitaampaa, koska se ei vain viettää linjataukoa, vaan myös tyhjentää lähtöpuskurin.Tämä selitetään yksityiskohtaisemmin myöhemmin.

Helppo syöttö[[Muokata-

Syöttöön on käytettävä vähän, koska jotain lukeminen on välttämätöntä lukemisen tallentamiseksi.Tätä "säilöä" kutsutaan muuttujaksi.Ensin on luotava muuttuja.On parasta selittää syöttö esimerkillä:

#sisältää int pää-() { int kokonaisluku; std:::nyrkkeily << "Käyttäjän syöttö:"; std:::elokuvateatteri >> kokonaisluku; std:::nyrkkeily << "Heillä on " << kokonaisluku << "Astui sisään.";}

Käyttäjän syöttö: 643Sinulla on 643.

Kuten jo mainittiin, muuttuja luodaan (int kokonaisluku;), jolle sitten annetaan arvo (elokuvateatteri >> kokonaisluku;).Tämä toinen rivi tarkoittaa jotain: Lue kokonaismäärä näppäimistöä ja tallenna ne muuttujaankokonaisluku.

elokuvateatteri(puhuttuc-in) on näppäimistö niin sanotusti,kokonaislukuOn muuttuja ja>>tarkoittaa jotain "jälkeen".Yhdessä on "näppäimistö muuttujalle", joten muuttujan näppäimistön "sisältö" tulee muuttujaksikokonaislukuviive.Muuten se, että näppäimistöltä luetaan kokonaisluku, riippuu muuttujien tietotyypistä, mutta enemmän siitä myöhemmin.

Muuttujien sisällön antamiseksi uudelleen sinun on tehtävä muuta kuin sinä toisella liukuvalla operaattorilla (<<) takananyrkkeily(puhuttuC-O-O-).On helposti mahdollista vaihtaa useita tällaisia ​​liukuoperaattoreita peräkkäin, kunhan sinulla on vain viimeinen lisäys tai lähtö puolipisteellä (;) saattaa loppuun.Sisäänpääsyessä tietysti>>-Operaattori<<-Operaattoria voidaan käyttää.Tällaisten rakenteiden lisäys- tai lähtöjärjestys vastaa lähdetekstiä syötettyä jaksoa.Mitä ensin takananyrkkeilytaielokuvateatteriseisoo, joten se suoritetaan myös ensin.

int kokonaisluku;std:::elokuvateatteri << kokonaisluku;

#sisältää int pää-() { int kokonaisluku; std:::elokuvateatteri >> kokonaisluku; std:::nyrkkeily << "Heillä on " << kokonaisluku << "Astui sisään.";}

Kaikilla ohjelmointikielillä on mahdollisuus tehdä muistiinpanoja lähdetekstiin.Muille tai itsellesi, koska muutaman viikon kuluttua et ehkä pysty ymmärtämään omaa lähdetekstiäsi ilman lisäilmoitusta.Kommentit auttavat sinua ja muita parempia ja ennen kaikkea nopeammin lähteen tekstin aiheuttamat.K ++: ssa on kaksi varianttia kommenttien kirjoittamiseen:

// Kommentti, joka aloitetaan kahdella viivalla, nousee linjan loppuun/* Tällainen kommentti voiyli useita linjojalaajentaa tai ... */eräs = b - /* ... ennen linjan loppua.*/ Tai c;

Ensimmäinen lajike, joka koskee linjan loppua, on moderni kommenttitapa.Se on yleensä parempi, koska sillä on joitain etuja verrattuna vanhaan varianttiin, joka tulee edelleen C.Toista lajiketta (jota joskus kutsutaan myös C-commentiksi) monirivisessä muodossaan tulisi käyttää vain paikoissa, joissa pidempiä tekstikohteita on ja mahdollisuuksien mukaan, ei koodin välillä.Tällaisia ​​kommentteja käytetään usein tiedoston alussa sisällön lyhyesti yhteenvetoksi tai lisenssilain sääntelemiseksi.

Multi -linjan kommenttien tärkein haitta on, että et voi "pesästä".Esimerkiksi lähdekoodin osia kommentoidaan usein testitarkoituksiin.Seuraavan esimerkin tulisi osoittaa tämä:

#sisältää / * Syöttö- ja lähtökirjasto */int pää-() { / * Päätoiminto *//*Std :: cout << "Hei, sinä kaunis maailma!"<< std :: endl;/ * Lähtö */*/}

Se ei toimisi.Jos muita kommentteja käytetään, tällaisia ​​ongelmia ei kuitenkaan ole:

#sisältää // Syöttö- ja lähtökirjastoint pää-() { // päätoiminto /*Std :: cout << "Hei, sinä kaunis maailma!"<< std :: endl;// lähtö*/}

Ensimmäisessä esimerkissä/ * Lähtö */Yksinkertaisesti huomiotta.Viimeinen osa lopettaa kommentin, jonka on tarkoitus kommentoida koodirinjaa, ja todellinen johtopäätös johtaa kokoamisvirheeseen.Tosin tämä ei ole liian huono, koska tällainen virhe löytyy nopeasti, mutta sen välttäminen alusta alkaen on vielä enemmän aikaa.Muuten, vähemmän on kirjoitettava yhden linjan kommenttien tapauksessa.Poikkeus on kommentteja, jotka ovat yksinkertaisesti liian pitkiä kirjoittaa ne yhdelle riville.Siitä huolimatta heidän pitäisi myös käydä läpi//Kommentit toteutuvat.

// Olen esimerkki pitkästä kommentista, joka on kopioitu// Selausnauhat useiden linjojen yli.Olisin tiedoston alussa// Olisin todennäköisesti varustettu muilla kommentteilla,// Mutta koska minua ympäröi selvästi valtava määrä lähdetekstiä,// päätit // lisääntyneestä kirjoitustyöstä huolimatta

Tässä luvussa tietokoneemme tulisi tehdä mitä se voi tehdä parhaiten: Laske.Sillä välin istumme ja katsomme tai pikemminkin, teemme sen, kun olemme kertoneet hänelle mitä odottaa.

Helppo aritmeettinen[[Muokata-

#sisältää int pää-() { std:::nyrkkeily << "7 + 8 =" << 7 Tai 8 << std:::endl; // laskun painos}

7 + 8 = 15

Tosin olisit todennäköisesti voinut ratkaista tämän laskun päähän, mutta miksi sinun pitäisi tehdä sinusta niin tarpeettomasti uupunut.Tietokoneesi toimittaa myös oikean tuloksen, ja jos yhdistät tämän numeroiden merkinnän kanssa, voit lisätä kaksi eri numeroa jopa jokaisen ohjelman kanssa:

#sisältää int pää-() { int Summa1- Määrä2; // Luo kaksi muuttujaa std:::elokuvateatteri >> Summa1 >> Määrä2; // Kirjoita kaksi numeroa std:::nyrkkeily << Summa1 << " +" << Määrä2 // Vietä molemmat erikseen " +" << "=" // lähtö "=" << Summa1 Tai Määrä2 // Laske ja kuluta tulos << std:::endl; // Uusi rivi}

Käyttäjän syöttö: 774Käyttäjän syöttö: 123774 + 123 = 897

Tulos voi tietysti myös tallentaa muuttujaan.Seuraava esimerkki osoittaa tämän mahdollisuuden:

#sisältää int pää-() { int Summa1- Määrä2- tulos; // Luo kolme muuttujaa std:::elokuvateatteri >> Summa1 >> Määrä2; // Kirjoita kaksi numeroa tulos = Summa1 Tai Määrä2; // Laske tulos std:::nyrkkeily << Summa1 << " +" << Määrä2 // Vietä molemmat erikseen " +" << "=" // lähtö "=" << tulos // Lähtötulos << std:::endl; // Uusi rivi}

Käyttäjän syöttö: 400Käyttäjän syöttö: 300400 + 300 = 700

Neljä suuria[[Muokata-

C ++ hallitsee neljää perusaritmeettista perusainetta: lisäys (Tai), Vähennys (-), Kertolasku (*) ja divisioona (-).Aivan kuten matematiikassa, sääntöä sovelletaan C ++: Point -laskelmaan kulkee kaiken ennen linjan laskelman ja sulujen menevän.Seuraavan esimerkin tulisi osoittaa monimutkaisempi lasku:

#sisältää int pää-() { int tulos; // Luo muuttuja tulos = (((3 Tai 3*4-A-5 - 1-A*512 - 768; // Laske tulos std:::nyrkkeily << "((3 + 3*4)/5 - 1)*512 - 768 =" // lähtötehtävä << tulos // Lähtötulos << std:::endl; // Uusi rivi}

((3 + 3*4)/5 - 1)*512 - 768 = 256

Tässä järjestyksessä odotetaan:

3 * 4 = 12 3 + 12 = 15 15/5 = 3 3 - 1 = 2 2 * 512 = 10241024 - 768 = 256

Sinun tulisi varmistaa, että sinulla on aina sama määrä avoimia ja sulkemiskiinnikkeitä, koska tämä on suosittu virhe, jota aloittelijat yleensä eivät löydä niin nopeasti.Tällaisissa tapauksissa kääntäjät tuovat usein raportteja, jotka ovat joitain rivejä todellisen virheen alapuolella.

Yhdistelmäoperaattorit[[Muokata-

C ++ on kieli laiskoille ihmisille.Siksi on mahdollista yhdistää aritmeettiset operaattorit toimeksiannon operaattoriin.Tämä näyttää sitten tältä:

määrä = 22;määrä += 5; // numero = numero + 5;määrä -= = 7; // Numero = numero - 7;määrä *= 2; // numero = numero * 2;määrä /= 4; // numero = numero / 4;

Voit nähdä kommentin kirjoitetun pitkän version.Tämä ei tarkoita lyhyesti, että laskentatoimenpide vasemmalla olevilla muuttujilla ja oikealla puolella oleva arvo ja vasemmalla olevien muuttujien tulos määritetään allokaatiooperaattorille.Sinun tulisi mieluummin yksityiskohtaisesti, koska se ei vain suojaa sormeasi, vaan on myös hiukan nopeampi.

On parasta ymmärtää tämä, jos vain kokeilet sitä.Jos oikealla on muita aritmeettisia operaatioita, ne suoritetaan ensin.Koko asia esitetään sitten seuraavasti:

määrä = 5;määrä *= 3 Tai 4; // numero = numero * (3 + 4);

Lisäys ja asetus[[Muokata-

Lisäys tarkoittaa muuttujan arvon lisäämistä 1: llä, vastaavasti se tarkoittaa laskentaa laskua 1.Muuten, C ++ velkaa lisäysoperaattorin nimen.Kaksi operaattoria on saatavana etuliitteessä ja Postfix -variantissa.Operaattoreita on yhteensä neljä:

määrä = 5;määrä++; // lisäys PostFix (numero == 6)++määrä; // lisäys etuliite (numero == 7)määrä-; // Alennus postFix (numero == 6)-määrä; // Decorder -etuliite (numero == 5)

Ero lisäyksen välillä (++) ja decorder (-) on tunnistettavissa ilman suurempaa ajattelua.Etuliitteen ja PostFixin merkitys puolestaan ​​ei ole välittömästi syntynyt.

Ero etuliitteen ja PostFix: n välillä on palautusarvossa.Etuliitevariantti lisää numeron arvoa 1 ja palauttaa tämän uuden arvon.PostFix -variantti lisää myös muuttujien arvoa 1: llä, mutta palauttaa arvon, joka muuttujalla oli ennen kasvua.

Seuraava pieni ohjelma näyttää eron:

#sisältää int pää-() { int määrä; // Luo muuttuja std:::nyrkkeily << "Anna numero suoraan:\ n"; määrä = 5; // Määritä arvo 5 std:::nyrkkeily << määrä << '' '' '' '' '; // Lähtöluku määrä++; // lisäys PostFix (numero == 6) std:::nyrkkeily << määrä << '' '' '' '' '; // Lähtöluku ++määrä; // lisäys etuliite (numero == 7) std:::nyrkkeily << määrä << '' '' '' '' '; // Lähtöluku määrä-; // Alennus postFix (numero == 6) std:::nyrkkeily << määrä << '' '' '' '' '; // Lähtöluku -määrä; // Decorder -etuliite (numero == 5) std:::nyrkkeily << määrä << '' '' '' '' '; // Lähtöluku std:::nyrkkeily << "\ nPaljasta operaattorin palautusarvo:\ n"; määrä = 5; // Määritä arvo 5 std:::nyrkkeily << määrä << '' '' '' '' '; // Lähtöluku std:::nyrkkeily << määrä++ << '' '' '' '' '; // lisäys PostFix (numero == 6) std:::nyrkkeily << ++määrä << '' '' '' '' '; // lisäys etuliite (numero == 7) std:::nyrkkeily << määrä- << '' '' '' '' '; // Alennus postFix (numero == 6) std:::nyrkkeily << -määrä << '' '' '' '' '; // Decorder -etuliite (numero == 5) std:::nyrkkeily << "\ nNumeron lopullinen arvo: " << määrä << std:::endl;}

Anna numero suoraan:5 6 7 6 5Paljasta operaattorin palautusarvo:5 5 7 7 5Numeron lopullinen arvo: 5

Numero = (500 - 100*(2 + 1))*5 Numero = (numero - 700) /3 Numero + = 50*2 Numero*= 10 - 8 Numero - 200 - 200

#sisältää  int pää-() { int määrä;  määrä = (500 - 100*(2 Tai 1))*5; // 1000 määrä = (määrä - 700-A-3; // 100 määrä += 50*2; // 200 määrä *= 10 - 8; // 400 määrä /= määrä - 200; // 2  std:::nyrkkeily << "Numero:" << määrä;}

Numero 2

muuttujatovat arvojen säilöjä, ne niin sanovat, että ne tarjoavat ohjelman muistin.VakioOvat erityisiä muuttujia, ne eivät koskaan muuta arvoaan.SeTietotyyppiMuuttuja tai vakio kuvaa, kuinka sisältö on ymmärrettävä.

Tietokone tuntee vain kaksi perustilaa: 0 ja 1. Tällaisten olosuhteiden sarjojen mukaan voidaan edustaa enemmän erilaisia ​​arvoja.Kahdeksan linjattuun olosuhteeseen (= 8bit = 1byte), 256 erilaista arvoa voidaan jo näyttää.Nämä arvot voidaan tulkita esimerkiksi kokonaislukuina (kirjoitettuina) merkkeinä, totuuden arvo tai liukuvalmiste.Tietotyyppi tarjoaa siis tietoja siitä, mikä se on.

C ++ -standardissa ei määrätä, että tavun on koostettava tarkalleen 8-bittisestä, tämä luku on laajalle levinnyt.Siksi on mahdollista, että erityisprosessoriarkkitehtuurille asetetaan joukko 10 bitistä "tavua".Tämä on kuitenkin erittäin harvinaista, joten oletamme, että tavu koostuu 8 -bittisestä.

Tietotyypit[[Muokata-

Ensinnäkin C ++: n tietotyypit tulisi kuvata, koska ne ovat perustavanlaatuisia muuttujalle tai vakioille.Neljä tärkeintä (ryhmäryhmää) ovat: totuuden arvot, merkit, kokonaisluvut ja liukuvat pilkut.

Totuusarvot[[Muokata-

Totuuden arvojen tietotyyppi kutsutaan C ++: ssaboolMikä on lyhenne Booleanille.Hän voi hyväksyä vain kaksi ehtoa:totta(tosi) taiväärä(väärä).Vaikka 1 -bittinen todella riittää, onboolAinakin yksi tavun koko (ts. 8 -bittinen), koska 1 -byte on pienin osoitettavissa oleva yksikkö ja siten vähimmäiskoko jokaiselle tietotyypille.On myös täysin mahdollista, että aboolEsimerkiksi 4 -tavua miehitetty, koska tämä lisää pääsyn nopeutta joidenkin prosessoriarkkitehtuurien kohdalla.

Merkki[[Muokata-

Merkit ovat tosiasiallisesti kokonaislukuja.Ne eroavat heistä vain lisäyksen ja tuotoksen suhteen.Jokaiselle numerolle osoitetaan merkki.Numerot voidaan laskea normaaliksi, mutta määritetty merkki näkyy näytöllä.Käytetty merkkijoukko määritetään, minkä merkin luvusta vastaa.

Suurin osa merkkisarjoista sisältää SO -nimisenAscii-koodi(Eräsmeri -merikalvoSTakaraCoodia jtkMinänimeäMinäVaihto), joka vie merkit 0–127.Se sisältää 32 ohjausmerkkiä (0–31) ja 96 tulostettavaa merkkiä (32–127).

hiiltyäon merkkien vakiotietotyyppi.Se on yleensä 1 -tavua ja voi siksi edustaa 256 eri merkkiä.Nämä ovat riittäviä laajennettuun ASCII -koodiin, joka esimerkiksi määrittelee myös saksalaiset umlautit.Tietotyypit ovat saatavilla Unicode -merkeillechar16_tKooltaan 2 tavua jachar32_tKoko 4byte.Aikaisemmin tietotyyppiä käytettiin myös Unicodewchar_tmikä oli hienoa järjestelmästä 2 tai 4byte.Tätä tietotyyppiä ei kuitenkaan pidä enää käyttää.Seuraava luettelo sisältää hyödyllisiä linkkejä Wikipedian artikkeleihin:

• Ascii
• Unicode(UTF-8-UTF-16-UTF-32-A
• ISO 8859-1(Latina-1)
• CodePage 437(DOS / DOS-Box)

K ++: ssa on 4 rakennettua tietotyyppiä merkkejä varten:

• hiiltyä
• char16_t
• char32_t
• wchar_t(vanhentunut)

Täysin[[Muokata-

C ++ määrittelee seuraavat rakennetut -tietotyypit kokonaislukuille:

Kaikki oikeinkirjoitukset ovat identtisiä määritetyn tyypin kanssa.Tyyppisarakkeessa käytetty oikeinkirjoitus on tässä kirjassa käytetty oikeinkirjoitus.Käytännössä kuitenkin riippuen siitä, kuka kirjoitti koodin, löydät myös ensimmäisen sarakkeen vastaavat oikeinkirjoitukset.

Tarkka bittien lukumäärä riippuu toteutuksesta ja on yleensätietomallinimetty.Neljädatamallitovat laajalle levinnyt:

• 32 -bittinen järjestelmä
  • LP32tai2/4/4(inthattu 16 bittiä,pitkäja käsillä on 32 bittiä)
    • Win16 tuli
  • Bittitai4/4/4(int-pitkäja käsillä on 32 bittiä)
    • Win32 tuli
    • Unix- ja Unixoid Systems (Linux, Mac OS X)
• 64 -bittinen järjestelmä
  • LLP64tai4/4/8(intjapitkäon 32 bittiä, käsillä on 64 bittiä)
    • Win64 API
  • LP64tai8.4.2018(inthattu 32 bittiä,pitkäja käsissä on 64 bittiä)
    • Unix- ja Unixoid Systems (Linux, Mac OS X)

Allekirjoitettujen tyyppien arvoalue (»allekirjoitettu«) Laske:

Signaalit tyypeille (»allekirjoittamaton«) Hänet lasketaan:

Nämä kaksi ovat silmiinpistäviä taulukossahiiltyä-Päivätyypit.Päinvastoin kuin muut tietotyypit, täällä ei ole oikeinkirjoitusta, jossa lopulta yksiintseisoo.Ja mikä on vielä tärkeämpääallekirjoitettu hiiltyäei pidähiiltyäolla lyhennetty!Siksi koskahiiltyäMerkkien tietotyyppi on samalla kunallekirjoitettu hiiltyäjaallekirjoittamaton hiiltyäYleensä edustavat numeroita.Historiallisesti C ++: n hahmojen ja lukujen välinen ero on valitettavasti erittäin epäpuhdas, mikä on erityisesti tapaushiiltyä-Päivätyypit näkyvät.

Yhtä hyvin kuinallekirjoitettu hiiltyä, yhtä hyvin kuinallekirjoittamaton hiiltyäkäsitelläintvalettu (muunnetaan, lisää luvussaValaistus) täytyy tulla.Tietotyyppihiiltyävoi olla joko arvoalueelta kääntäjästä riippuenallekirjoitettu hiiltyätaiallekirjoittamaton hiiltyäolla identtinen.On kuitenkin huomattava, ettähiiltyäSilti itsenäinen tyyppi!Tämä ero ei ole niin tärkeä tällä hetkellä, mutta palaamme takaisin tähän (tärkeään) yksityiskohtaan (tärkeätä mallin yhteydessä).

Tällä hetkellä sinun tulee muistaa: Jos haluat edustaa numeroa, jolla on 1 tavun muuttuja, käytä sittenallekirjoitettu hiiltyätaiallekirjoittamaton hiiltyäJos haluat edustaa merkkiä, käytähiiltyä.

ValitseintJos tämä tyyppi voi tallentaa tarvittavan arvoalueen kaikki numerot, käytä signless -numeroitaallekirjoittamaton.Tämä arvoalue ei ole riittävä ja onpitkäisompi, ota sittenpitkä(tai.allekirjoittamaton pitkä).lyhytjaallekirjoittamaton lyhyttulisi käyttää vain, jos säilytystilaa on vähän, esimerkiksi käytettäessä suuria taulukkoja tai jos matalan tason tietorakenteita on käytettävä.Varmista, että sen muuttujan teoreettisesti suurin arvo ei ylitä suurinta mahdollista arvoa.Sama koskee tietysti myös pienimmän mahdollisen arvon laskua.

Muuten, alempi tai ylivuoto on täysin mahdollista.Useimmat kääntäjät tarjoavat mahdollisuuden luoda virhe tällaisessa tapauksessa, mutta tämä vaihtoehto ei ole oletuksena aktiivinen.Seuraavassa pienessä esimerkissä tietotyypit ovatlyhyt(Min: -32768, Max: 32767) jaallekirjoittamaton lyhytKäytetään ja molemmissa suoritetaan yksi alempi ja ylivuoto:

#sisältää int pää-() { lyhyt muuttuja1 = 15000; allekirjoittamaton lyhyt muuttuja2 = 15000; std:::nyrkkeily << "Lyhyt muuttuja:" << muuttuja1 << std:::endl << "Allekirjoittamaton lyhyt muuttuja:" << muuttuja2 << std:::endl << "+30000\ n \ n"; muuttuja1 += 30000; muuttuja2 += 30000; std:::nyrkkeily << "Lyhyt muuttuja:" << muuttuja1 << "(Ylivuoto)" << std:::endl << "Allekirjoittamaton lyhyt muuttuja:" << muuttuja2 << std:::endl << "+30000\ n \ n"; muuttuja1 += 30000; muuttuja2 += 30000; std:::nyrkkeily << "Lyhyt muuttuja:" << muuttuja1 << std:::endl << "Allekirjoittamaton lyhyt muuttuja:" << muuttuja2 << "(Ylivuoto)" << std:::endl << "-30000\ n \ n"; muuttuja1 -= = 30000; muuttuja2 -= = 30000; std:::nyrkkeily << "Lyhyt muuttuja:" << muuttuja1 << std:::endl << "Allekirjoittamaton lyhyt muuttuja:" << muuttuja2 << "(Alempi ulottuvuus)" << std:::endl << "-30000\ n \ n"; muuttuja1 -= = 30000; muuttuja2 -= = 30000; std:::nyrkkeily << "Lyhyt muuttuja:" << muuttuja1 << "(Alempi ulottuvuus)" << std:::endl << "Allekirjoittamaton lyhyt muuttuja:" << muuttuja2 << std:::endl;}

Lyhyt muuttuja: 15000Allekirjoittamaton lyhyt muuttuja: 15000+30000Lyhyt muuttuja: -20536 (ylivuoto)Allekirjoittamaton lyhyt muuttuja: 45000+30000Lyhyt muuttuja: 9464Allekirjoittamaton lyhyt muuttuja: 9464 (ylivuoto)-30000Lyhyt muuttuja: -20536Allekirjoittamaton lyhyt muuttuja: 45000 (alempi ulottuvuus)-30000Lyhyt muuttuja: 15000 (alempi ulottuvuus)Allekirjoittamaton lyhyt muuttuja: 15000

Tämä ilmiö tulee ymmärrettävämmäksi, jos numerot ovat binaarisia (Kaksoisnumerojärjestelmä).Yksinkertaisuuden vuoksi alamme kuvataallekirjoittamaton lyhytMuuttujat, kaksi ensimmäistä 300 000 lisäystä: kumpikin:

Lisäys kaksoisjärjestelmäänallekirjoittamaton lyhytData -symbolina 1 0011101010011000 |15000 + | 011101100110000 |30000 ------------------------------------------------- --- --------------------- = | 10101111001000 |45000 Laskenta 2 | 10101111001000 |45000 + | 01110101110000 |30000 ------------------------------------------------- ------------ --------------------- = 1 0010011111000 |9464

Molemmilla laskuilla ei ole erityisominaisuuksia.Koska vain viimeiset 16 numeroa havaitaan (2byte = 16 -bittinen), 1 poistetaan toisessa laskussa ennen pystysuoraa viivaa, mikä tarkoittaa, että tulos (desimaalin oikeinkirjoituksessa) 9464 ja ei 75 000 onallekirjoittamaton lyhyt-In -ganz -luku vähennettiin 30 000 kukin:

Vähennys kaksoisjärjestelmässäallekirjoittamaton lyhytData -symbolina 3 | 001001111000 |9464 - | 011101100110000 |30000 ------------------------------------------------- ------ ---------------------------- = ... 1 | 10101111001000 |45000 Laskenta 4 | 10101111001000 |45000 - | 01110101110000 |30000 ------------------------------------------------- --- ------------------------- = | 00111010011000 |15000

Tässä tapauksessa toinen lasku on huomaamaton.Ensimmäisessä laskussa toisaalta pienemmältä vähennetään suuri määrä, mikä johtaisi negatiiviseen tulokseen - tai parempaan -, koska alaraja on tässä tapauksessa 0.Tämä ei missään nimessä ole vain kaksoislukujen tapaus.Jos desimaalijärjestelmässä vedät suuren määrän pienempää kirjallisen vähennysten tavanomaisten sääntöjen mukaan, saat samanlaisen tuloksen:

24-31 ------------ Markit ... 1 ------------ = ... 993

Ohjelma sisältää allekirjoitetun kokonaisluvunlyhyt-Muuntaiset, myös neljä laskua.Heidän kaksoisesitys on hyvin tuttu:

Lisäys kaksoisjärjestelmäänlyhytData -symbolina 1 | 0111010011000 |15000 + | 0 | 1110100110000 |30000 ------------------------------------------------- ----------- ----------------------- = | 1 | 0101111001000 |-20536 Laskenta 2 |-20536 + | 0 | 1110100110000 |30000 ------------------------------------------------- --------------------- ------------------------- = 1 | | 010011111000 |9464 Vähennys kaksoisjärjestelmässälyhytData -symbolissa 3 | 010011111000 |9464 - | 0 | 1110100110000 |30000 ------------------------------------------------- ------------ -------------------------------- = ... 1 | 0101111001000 |-20536 Laskenta 4 |-20536 - | 0 | 1110100110000 |30000 ------------------------------------------------- --- --------------------------- = | 0 |15000

Kaksinumero ovat täsmälleen samat koko ajan, ainoa ero on, että negatiiviset luvutKahden täydennys-juhlat.Tämä johtaa muuttuneeseen esitykseen desimaalijärjestelmässä.

Yleensä on parempi, jos asetat tietotyyppien tarkan koon.Tätä varten otsikon oncstdintintegroitu.Siinä alias-nimet on määritelty sisäänrakennetuille tietotyypeille:

• std:::int8_t _valinnainen
• std:::int16_t _valinnainen
• std:::int32_t _valinnainen
• std:::int64_t _valinnainen
• std:::int_fast8_t
• std:::int_fast16_t
• std:::int_fast32_t
• std:::int_fast64_t
• std:::int_least8_t
• std:::int_least16_t
• std:::int_least32_t
• std:::int_least64_t
• std:::intmax_t
• std:::intptr_t _valinnainen
• std:::uint8_t _valinnainen
• std:::uint16_t _valinnainen
• std:::uint32_t _valinnainen
• std:::uint64_t _valinnainen
• std:::uint_fast8_t
• std:::uint_fast16_t
• std:::uint_fast32_t
• std:::uint_fast64_t
• std:::uint_least8_t
• std:::uint_least16_t
• std:::uint_least32_t
• std:::uint_least64_t
• std:::uintmax_t
• std:::uintptr_t _valinnainen

Kaikki tietotyypitintAloita, seisoaallekirjoitettuTietotyypit, kaikki kukauinaaloittaa jtkallekirjoittamatonTietotyypit."Valinnaisella" merkityt tietotyypit määritetään vain, jos alusta tukee niitä luonnollisesti.Tämä on kuitenkin aina edellä viitattujen järjestelmien tapauksessa.Ongelmia voi tapahtua vain mikro -ohjaimissa tai vastaavissa.

Kuollavähiten-Päivätyypit vastaavat pienintä kaveria, jolla on ainakin yhtä monta bittiänopeasti-Katsutyyppiä nopein tietotyyppi, jolla on vähintään yhtä monta bittiä.Semax-Päivätyypit vastaavat suurinta käytettävissä olevaa tietotyyppiä.Septr-Päivätyypeillä on täsmälleen yhtä monta osoitinta (katso lukuosoitin) ja siksi ne ovat myös saatavilla vain, jos laitteisto tukee vastaavaa kokonaislukutietotyyppiä.

Pääsääntöisesti on järkevin käyttää tarkkoja tietotyyppejä, ts.std:::uint16_tJos haluat tietotyypin, jossa on 16 -bittinen ja joka on merkityksetön.Senopeasti-Tatiittityyppejä voidaan käyttää nopeuden optimointiin toimintojen sisällä tarvittaessa.

Liukuva[[Muokata-

Liukuva pilkkumuuttuja muistaa tietyn määrän numeroita ja pilkujen sijainnin.Tietäminen tällaisen määrän sisäisestä rakenteesta on todennäköisesti harvoin tai sitä ei koskaan tarvita, joten tässä vaiheessa se onWikipedia -artikkeli Gleit -pilkujen numeroistaviitattu.C ++: ssa käytät liukuvia pilkuja/muuttujia aritmeettiselle pilkkujen lukumäärällä.Liukuvien pilkujen numeroille on kolme tietotyyppiä, jotka on lueteltu seuraavassa taulukossa niiden tavallisilla arvoilla:

Tyypillinen	Varastotila	Arvoalue	Pienin positiivinen luku	tarkkuus
kellua	4 -byttte			6 sijaintia
kaksinkertainen	8byte			12 asemaa
pitkä kaksinkertainen	10Byte			18 asemaa

Liukuvan commadate -tyypin valinta on vähemmän yksinkertainen kuin kokonaisluku.Jos et tiedä tarkalleen mitä ottaa, onkaksinkertainenYleensä hyvä valinta.Kun sinulla on tarpeeksi kokemusta, sinun on helpompi arvioidakelluataipitkä kaksinkertainenEhkä parempi valinta ongelmaan.

muuttujat[[Muokata-

Ennen kuin muuttujaa voidaan käyttää, se on ilmoitettava kääntäjälle.Tätä kutsutaan muuttujien julistukseksi.Muuttujan todellista luomista, niin että kääntäjän tallennustilavarantoja kutsutaan määritelmään.Määritelmä on aina ilmoitus, ja muuttujien kanssa ero ilmoituksen ja määritelmän välillä on hiukan liian monimutkainen selittämään sitä tässä vaiheessa.Opi ensin termit toimintojen yhteydessä ja myöhemmin myös muuttujille.Sinun on kuitenkin jo muistettava, että käyttämämme muuttujat ovat aina määritelmiä.Tämä on tärkeää siinä mielessä, että määritelmä voidaan kirjoittaa vain kerran, kun taas julistus voidaan suorittaa mahdollisimman usein.Vertailun todelliseen maailmaan haluamme tarkastella uuden elämän syntymistä.Voit kertoa niin usein kuin haluat, että tietty lapsi syntyy.Itse asiassa tämä voi tapahtua vain kerran.Edellisessä luvussa meillä on jo tyypin muuttujiaintodotettu.Nyt sinun tulisi oppia, kuinka muuttujat luodaan C ++: een.Yleinen syntaksi on:

««Tietotyyppi» ««Nimi»;

On myös mahdollista luoda useita samantyyppisiä muuttujia peräkkäin:

««Tietotyyppi» ««Muuttuja1»- ««Muuttuja2»- ««Muuttuja3»;

Voit myös antaa alkuperäisen arvon alkuperäisen arvon, tätä kutsutaan alustukseksi.Alustamisissa on kaksi syntaktista mahdollisuutta (oikeinkirjoituksia), jotka käyttävät aintMuuttuja on näytettävä:

int määrä=100; // Mahdollisuus numero 1int määrä(100) // Mahdollisuus 2

Ensimmäinen variantti on laajalle levinnyt, mutta ei välttämättä parempi.C ++: n perustavanlaatuisilla tietotyypeillä ei ole merkitystä, mitä varianttia käytät, mutta monimutkaisemmille tietotyypeille (luokat) sekaannus määritysoperaattori voi tapahtua, jos käytät mahdollisuutta 1.Opit tuntemaan tarkan eron alustamisen ja tehtävän välillä heti, kun kyse on luokista.Tällä hetkellä sinun tulee valita yksi kahdesta variantista.Suuri jakauma ja siihen liittyvä intuitiivinen käyttö puhuvat mahdollisuudesta 1.Tässä kirjassa käytämme tätä ensimmäistä menetelmää ja annamme luokkien yhteydessä myös suosituksen, kun tämä menetelmä voi lisätä lähdekoodin parempaa katsausta.Toisaalta mahdollisuudessa 2 puhuu, että tämä syntaksi on aina voimassa alustuksille.Lisäksi tämä menetelmä tekee selväksi, että se on alustaminen.

Alkuarvojen muuttujat voidaan tietenkin luoda myös peräkkäin, mikäli niillä on sama tietotyyppi, mutta se ei ole suositeltavaa selkeyden vuoksi.

int yli(77), numero 2- Naarmu=58; // kolme int-muuttujaa, joista kahdella alkuperäisellä arvolla on

Jos et anna alkuperäistä arvoa alkuperäisille muuttujille, sinun on määritettävä sinulle arvo myöhemmin ohjelmassa ennen kuin työskentelet sen kanssa (ts. Laske se tai sinulla on sisältötulos).Jos sinulla ei ole tällaisen muuttujan arvoa ja käytä sitä, sisältö voi olla satunnainen.Tarkkaan ottaen silloin bittisekvenssi seisoi varastossa, jossa muuttujasi luotiin.C ++ -säännöissä on sääntöjä, joissa kääntäjä alustaa muuttujan implisiittisesti ilman nimenomaista alustusta ja kun nykyinen muistin sisältö yksinkertaisesti pysähtyy.Nämä säännöt ovat kuitenkin niin monimutkaisia, että niitä ei kannata muistaa.Koska jos toinen ohjelmoija lukee koodisi, hänen on myös tiedettävä säännöt koodin ymmärtämiseksi välittömästi.Seuraava pieni ohjelma osoittaa tapauksen, jossa C ++ toteaa, että implisiittistä alustusta ei tapahdu 0: ssa.

#sisältää // Syöttö/lähtöint pää-() { int määrä; // Kokonaislukumuuttuja kaksinkertainen Pilkku numero1- comezahl2; // gleitkommvariables hiiltyä merkki; // Allekirjoittaa muuttuja std:::nyrkkeily << "Numero:" << määrä << std:::endl // arvojen painos << "Pilkku numero1:" << Pilkku numero1 << std:::endl // mikä kuitenkin << "Comzahl2:" << comezahl2 << std:::endl // ei korjattu << "Kyltti:" << merkki << std:::endl; // tuli}

Numero: -1211024315Lehti1: 4.85875E-270Hämmästyttävä: s. 32394 J-39Merkki: f

Lähtö voi olla erilainen jokaisen ohjelman suorittamisen yhteydessä.Jos näin ei ole, samat arvot ovat sattumalta vain muistin pisteessä, jonka vastaava muuttuja todistaa.Tietokoneesi uudelleenkäynnistyksen jälkeen viimeistään on todennäköisesti erilainen ongelma.Esimerkiksi on järkevää antaa muuttujia, jos ne olivatstd:::elokuvateatteriArvon lukeminen muuttujassa.Siitä huolimatta se ei aiheuta vaurioita tässä tapauksessa, jos alustat muuttujat 0: lla 0: lla.

#sisältää // Syöttö/lähtö int pää-() { int määrä; // Kokonaislukumuuttuja kaksinkertainen Pilkku numero1- comezahl2; // gleitkommvariables hiiltyä merkki; // Allekirjoittaa muuttuja std:::nyrkkeily << "Antakaa kokonaisluku erikseen tiloilla, kaksi pilkkua" "Ja merkki:\ n"; std:::elokuvateatteri >> määrä // Kirjoita arvot >> Pilkku numero1 //, jolla neljä >> comezahl2 // muuttuja täytetty >> merkki; // tulla std:::nyrkkeily << "Numero:" << määrä << std:::endl // arvojen painos << "Pilkku numero1:" << Pilkku numero1 << std:::endl // kumpi ennen << "Comzahl2:" << comezahl2 << std:::endl // astui sisään << "Kyltti:" << merkki << std:::endl; // tuli}

Kirjoita kokonaisluku, kaksi pilkku- ja merkkiä välilyönteillä erikseen:Käyttäjän syöttö: 6 8,4 6,0 gNumero: 6Pilkku numero1: 8.4Comezahl2: 6Merkki: g

Vakio[[Muokata-

Kuten edellä on jo kuvattu, vakiot ovat muuttujia, jotka eivät muuta niiden arvoa.Tästä seuraa, että vakio voidaan antaa arvo vain tarkalleen kerran;C ++: ssa tämä on alustettava alkuperäisellä arvolla, muuten heillä olisi vakio, jolla on satunnainen arvo ja sillä on tuskin mitään järkeä.Avainsana muuttujan tekemiseksi vakiona onkonsertti.Se kuuluu aina siihen, mikä siitä on jäljellä, ellei hänestä ole mitään jäljellä, niin 'const' kuuluu oikealla puolella olevaan termiin.Tämä kuulostaa monimutkaiselta, mutta se ei oikeastaan ​​ole ollenkaan.Meille se tarkoittaa vain sitä, että sinulla on kaksi tapaa tehdä muuttujasta vakio:

konsertti int määrä(400) // Vaihtoehtoisesti: const int numero = 400;// taiint konsertti määrä(400) // Vaihtoehtoisesti: int const Number = 400;

Molemmilla on sama vaikutus, jälleen ensimmäinen variantti on laajalle levinnyt ja jälleen kerran monimutkaisempien tietotyyppien paremman luettavuuden toinen variantti (osoitimien taukot vakiona jäsenfunktioissa ...).Valitse parempaan tapaan ja käytä sitä.On tärkeää, että pysyt totta variantille, josta valitset, ainakin projektin ajan.Koska koodia, jossa kirjoitustyyli muuttuu jatkuvasti, on vaikeampaa lukea.

Kirjaimet ja niiden tietotyypit[[Muokata-

EräsKirjaimellisestion merkki lähdekoodista, joka osoittaa tietyn arvon ja jolla on yksi yllä kuvattujen tietotyyppien.

#sisältää // Syöttö/lähtöint pää-() { std:::nyrkkeily << 100 << std:::endl // 100 on int-literaal << 4.7 << std:::endl // 4.7 on kaksinkertainen kirjaimellinen << 'H' << std:::endl // 'H' on char -kirjaimellinen << totta << std:::endl; // tosi on bool kirjaimellinen}

1004.7h1

Antaessaan on huomattava, että Boolen arvot 0 (väärä) tai 1 (totta).

Tietotyypin automaattinen määrittäminen[[Muokata-

Koska tyypin määrittäminen kokonaislukuarvolle on jonkin verran vaikeampaa kuin muiden kanssa, käsittelemme niitä äskettäin.Liukuvan muodikkaiden kirjaimien tapauksessa on määritetty, että se onkaksinkertainen-Walen toimii.Liukuva -tasaisen saamiseksi erityyppisellä tyypillä on välttämätöntä niin kutsuttu jälkiliite.

5.0 // kaksinkertainenMinä // kellua2.6f // kelluay. // pitkä kaksinkertainen4,0L // pitkä kaksinkertainen

Numero pilkulla (.Joten) on akaksinkertainen-Arvo.Seuraa numeroaftai aFTuleeko hänestä yksikellua-arvo ja seuraa häntälenstai aLensTuleeko hänestä yksipitkä kaksinkertainen-Arvo.Sleit -pisteitä voidaan käyttää myöstieteellinen oikeinkirjoitusedustettuna.

KhZ.ze-zZ -z4.A-4 F

Kuten kaksi viimeistä esimerkkiä osoittavat, tietotyypin jälkiliitteitä voidaan käyttää myös.

Saada merkki tai merkkijonoketjuchar16_ttai.char32_tMerkitsemiseksi laitat pienenoatai isoOaEteenpäin.Puolestawchar_tkäytät isoaLens.

'A' // charoa'B' // char16_tOa'B' // char32_tLens'B' // wchar_t"Olen teksti" // char const*oa"Olen teksti" // char16_t const*Oa"Olen teksti" // char32_t const*Lens"Olen teksti" // wchar_t const*

Mikä tähti (*) Kommentin tietotyypin takana saat selville myöhemmässä luvussa.boolvoi hyväksyä vain kaksi ehtoa, vastaavasti niitä on vain kaksibool-Lite:tottajaväärä.

Nyt kokonaislukuille.Numeroiden desimaalin tarkkuudella on myös mahdollisuusBinääri-OctalesjaHeksadesimaaliKuvaus.Merkitys numero binaarina, a0 -b -tai0 -B -edeltävä, vain Oktalille0 -(Nolla) edelsi ja heksadesimaaliluku0 -xtai0 -Xedeltävä.Suuri/pieni kuvaus heksadesimaalisista numeroistaeräsbisfei haittaa.

756 // Desimaali, desimaali: 7560B10 // binaari, desimaali: 20B111 // binaari, desimaali: 7046 // Oktaali, desimaali: 380757 // Octal, desimaali: 4950xffff // heksadetsimal, dismimal: 655350x1234abcd // heksadetsimal, dismimal: 305441741

Tietotyyppi määritetään arvon koon mukaan, jolloin seuraavaa tilausta sovelletaan:int-allekirjoittamaton int-pitkä-allekirjoittamaton pitkä-pitkä pitkä-allekirjoittamaton pitkä pitkä.Lisäksi jokainen kokonaisluku voi nimenomaisesti jälkiliitteenoataiOapuolestaallekirjoittamatonjalenstaiLenspuolestapitkätai alltaiLlpuolestapitkä pitkäolla kiinnitetty.Tilaus muuttuu jälkiliitteiden määrittelemien kriteerien mukaisesti.

selkeämpi[[Muokata-

On myös mahdollista tehdä kokonaisluku kirjaimellisesti missään paikoissa merkin kautta'Erottaa yleiskatsauksen parantamiseksi.Tämä voi olla erityisen hyödyllistä binaarilateroille, koska ne ovat usein erittäin pitkiä.

9'756'432'108 // 'tuhannesta erottimesta978'3'446'43981'8 // 'ISBN -numeron erotusmerkkinä0B1111'0000'1010'0101 // 'erottelomerkkinä 16 -bittiselle arvolle 4 ryhmällä

Tarvitset todennäköisesti harvoin tietotyyppien tietoa litroista, joten riittää "kuullessasi siitä" ja tarvittaessa sen uudelleen.

Tiedät nyt C ++: n tietotyypit ja sinulla on joint-Muariat lasketaan.Tässä luvussa saat selville, kuinka odottaa muuttujia erityyppisiä.Joten se on vähemmän itse tuloksesta kuin paljon enemmän siitä, mikä tulostietotyyppi on.

Täysin[[Muokata-

Kokonaislukujen laskenta on helppo ymmärtää."Pienet" tietotyypit ovat niinintkäsitellään.Suurimpien tietotyyppi päättää tulostyypistä.Seuraava luettelo näyttää yhteydet:

char + char => int |wchar_t + char => intchar + wchar_t => int |wchar_t + wchar_t => intchar + allekirjoitettu char => int |wchar_t + allekirjoitettu char => intchar + allekirjoittamaton char => int |wchar_t + allekirjoittamaton char => intchar + lyhyt => int |wchar_t + lyhyt => intchar + allekirjoittamaton lyhyt => int |wchar_t + allekirjoittamaton lyhyt => intchar + int => int |wchar_t + int => intchar + allekirjoittamaton int => allekirjoittamaton int |wchar_t + allekirjoittamaton int => allekirjoittamaton intchar + pitkä => pitkä |wchar_t + pitkä => longchar + allekirjoittamaton pitkä => allekirjoittamaton pitkä |wchar_t + allekirjoittamaton pitkä => allekirjoittamaton pitkäaikaiset char + char => int |allekirjoittamaton char + char => intSIGNED CHAR + wchar_t => int |allekirjoittamaton char + wchar_t => intSIGNED CHAR + allekirjoitettu char => int |allekirjoittamaton char + allekirjoitettu char => allekirjoitettu char + allekirjoittamaton char => int |allekirjoittamaton char + allekirjoittamaton char => allekirjoitettu char + lyhyt => int |allekirjoittamaton char + lyhyt => allekirjoitettu char + allekirjoittamaton lyhyt => int |allekirjoittamaton char + allekirjoittamaton lyhyt => allekirjoitettu char + int => int |allekirjoittamaton char + int => allekirjoitettu char + allekirjoittamaton int => allekirjoittamaton int |allekirjoittamaton char + allekirjoittamaton int => allekirjoittamaton intStrated char + pitkä => pitkä |allekirjoittamaton char + pitkä => pitkään allekirjoitettu char + allekirjoittamaton pitkä => allekirjoittamaton pitkä |Allekirjoittamaton char + allekirjoittamaton pitkä => allekirjoittamaton pitkäpoisto + char => int |allekirjoittamaton lyhyt + char => inhothort + wchar_t => int |allekirjoittamaton lyhyt + wchar_t => inhShort + allekirjoitettu char => int |Allekirjoittamaton lyhyt + allekirjoitettu char => inhort + allekirjoittamaton char => int |Allekirjoittamaton lyhyt + allekirjoittamaton char => inhort + lyhyt => int |allekirjoittamaton lyhyt + lyhyt => inhort + allekirjoittamaton lyhyt => int |allekirjoittamaton lyhyt + allekirjoittamaton lyhyt => inhort + int => int |allekirjoittamaton lyhyt + int => inhort + allekirjoittamaton int => allekirjoittamaton int |allekirjoittamaton lyhyt + allekirjoittamaton int => allekirjoittamaton intHort + pitkä => pitkä |Allekirjoittamaton lyhyt + pitkä => Longshort + allekirjoittamaton pitkä => allekirjoittamaton pitkä |allekirjoittamaton lyhyt + allekirjoittamaton pitkä => allekirjoittamaton longint + char => int |allekirjoittamaton int + char => allekirjoittamaton intInt + wchar_t => int |allekirjoittamaton int + wchar_t => allekirjoittamaton intint + allekirjoitettu char => int |allekirjoittamaton int + allekirjoitettu char => allekirjoittamaton inttint + allekirjoittamaton char => int |allekirjoittamaton int + allekirjoittamaton char => allekirjoittamaton inttint + lyhyt => int |allekirjoittamaton int + lyhyt => allekirjoittamaton inttint + allekirjoittamaton lyhyt => int |allekirjoittamaton int + allekirjoittamaton lyhyt => allekirjoittamaton intint + int => int |allekirjoittamaton int + int => allekirjoittamaton intri + allekirjoittamaton int => allekirjoittamaton int |allekirjoittamaton int + allekirjoittamaton int => allekirjoittamaton intinti + pitkä => pitkä |Allekirjoittamaton int + pitkä => pitkä oder allekirjoittamaton LongInt + allekirjoittamaton pitkä => allekirjoittamaton pitkä |allekirjoittamaton int + allekirjoittamaton pitkä => allekirjoittamaton pitkäaikainen + char => pitkä |allekirjoittamaton pitkä + char => allekirjoittamaton pitkäaikainen + wchar_t => pitkä |allekirjoittamaton pitkä + wchar_t => allekirjoittamaton pitkäaikainen + allekirjoitettu char => pitkä |Allekirjoittamaton pitkä + allekirjoitettu char => allekirjoittamaton pitkäaikainen + allekirjoittamaton char => pitkä |Allekirjoittamaton pitkä + allekirjoittamaton char => allekirjoittamaton pitkäaikainen + lyhyt => pitkä |allekirjoittamaton pitkä + lyhyt => allekirjoittamaton pitkäaikainen + allekirjoittamaton lyhyt => pitkä |Allekirjoittamaton pitkä + allekirjoittamaton lyhyt => allekirjoittamaton pitkäaikainen + int => pitkä |allekirjoittamaton pitkä + int => allekirjoittamaton pitkäaikainen + allekirjoittamaton int => allekirjoittamaton pitkä |Allekirjoittamaton pitkä + allekirjoittamaton int => allekirjoittamaton pitkäaikainen + pitkä => pitkä |Allekirjoittamaton pitkä + pitkä => allekirjoittamaton pitkäaikainen + allekirjoittamaton pitkä => allekirjoittamaton pitkä |allekirjoittamaton pitkä + allekirjoittamaton pitkä => allekirjoittamaton pitkä

Tosin tämä näyttää olevan ylivoimainen, mutta sitä ei oikeastaan ​​ole vaikea ymmärtää.Jokaisella aritmeettisella operaatiolla jokaisella kahdella operandilla ja laskun seurauksena on tietotyyppi:

#sisältää int pää-() { hiiltyä yli=22; lyhyt numero 2=40; std:::nyrkkeily << yli * numero 2 << std:::endl; // 22 * ​​40 = 880 // char + lyhyt => int}

Voiteluaine[[Muokata-

Kun lasketaan liukuvilla pilkuilla, samoja sääntöjä sovelletaan periaatteessa kuin kokonaislukuja.Tulostyyppi vastaa myös operandin tyyppiä "suuremman" kaverin kanssa.Nouseva järjestys on:kellua-kaksinkertainen-pitkä kaksinkertainen.Joten se pätee:

Float + kelluva => floatfloat + kaksinkertainen => kaksoisfloat + pitkä kaksinkertainen => pitkä kaksinkertainen tuplari + float => kaksinkertainen + kaksinkertainen => kaksinkertainen + pitkä kaksinkertainen => pitkä doubblong kaksinkertainen + kellu => pitkä doubblong kaksinkertainen + kaksinkertainen => pitkä doubblelong kaksois+ pitkä kaksinkertainen => pitkä kaksinkertainen

Valu[[Muokata-

Tässä yhteydessä valu tarkoittaa tietotyypin muuttamista toiseen.Tämän tyyppinen muuntaminen voi tapahtua sekä automaattisesti (implisiittisesti) että ohjelmoijan määrittelemä (nimenomaisesti).

Implisiittinen tyyppimuunnos[[Muokata-

Heillä oli jo paljon tekemistä implisiittisen tyyppisen muuntamisen kanssa, koska sitä voidaan odottaa vain numeroilla, joilla on samantyyppinen.

Esimerkkejä:

char + int => int |int + int => intShort + allekirjoittamaton int => allekirjoittamaton int |allekirjoittamaton int + allekirjoittamaton int => allekirjoittamaton intfloat + kaksinkertainen => kaksinkertainen |kaksinkertainen + kaksinkertainen => kaksinkertainen

Vähittäiskaupan säännöt[[Muokata-

Monet binaariset operaattorit, jotka odottavat aritmeettisia tai luettelo -operaattoreita, aiheuttavat tuloksia ja johtavat tuloksiin samalla tavalla.Tarkoituksena on löytää yhteinen tulostyyppi.Tätä mallia kutsutaan "tavanomaisiksi aritmeettisiksi muunnoiksi", jotka on määritelty seuraavasti:

"Dia Comma":

• Jos tyyppinen operandipitkä kaksinkertainenon, niin toinen on myöspitkä kaksinkertainenmuunnetaan.
• Muuten, jos tyyppinen operandikaksinkertainenon, niin toinen on myöskaksinkertainenmuunnetaan.
• Muuten, jos tyyppinen operandikelluaon, niin toinen on myöskelluamuunnetaan.

Jos voiteluainetyyppiä ei ole mukana, seuraavia kokonaislukumuunnoksia sovelletaan molempiin operandeihin:

• Jos tyyppinen operandiallekirjoittamaton pitkäon, niin toinen on myösallekirjoittamaton pitkämuunnetaan.
• Muuten, jos tyyppinen operandipitkäja toinen tyyppiallekirjoittamaton intsitten, jos apitkäKaikki yhden arvotallekirjoittamaton intvoi edustaaallekirjoittamaton intMyös operandpitkämuuttunut;Muuten molemmat operandit ovat liianallekirjoittamaton pitkämuunnetaan.
• Muuten, jos tyyppinen operandipitkäon, niin toinen on myöspitkämuunnetaan.
• Muuten, jos tyyppinen operandiallekirjoittamaton inton, niin toinen on myösallekirjoittamaton intmuunnetaan.

Huomaa: Ainoa jäljellä oleva tapaus on, että molemmat tyypin operandit ovat.

Nämä säännöt asetettiin siten, että tietotyyppi muunnetaan aina erilaiseksi tietotyypiksi "suuremmalla" arvoalueella.Tämä varmistaa, että arvotappioita ei aiheudu nousun noususta.Kuitenkin muuntaessasi kokonaislukujakellua-Walenin pyöristämisvirheitä esiintyy:

std:::nyrkkeily << "17000000 + 1,0F =" << std:::kiinteä << 17000000 Tai 1,0f << std:::endl;

17000000 + 1,0F = 17000000.000000

Laskelmaa varten molemmat operandit ovat ensin tietotyypissäkelluamuunnetaan ja lisätty sitten.Tulos on jälleenkelluaJa siksi ei pysty säästämään 17 miljoonan numeron määrää tarvittavalla tarkkuudella 17000 000 - 17000001 erottamiseksi.Lisäyksen tulos on siis jälleen 1700000.

Nimenomainen tyyppimuunnos[[Muokata-

C ++: ssa on kaksi vaihtoehtoa.Toisaalta C: stä otettu näyttelijä(Tyypillinen-AKiskoJa toisaalta neljä (uusi) C ++ -valtaa.

staattinen< Kohdetyyppi -(Muuttuva-Aconst_cast< Kohdetyyppi -(Muuttuva-Adynaaminen< Kohdetyyppi -(Muuttuva-Atulkita uudelleen< Kohdetyyppi -(Muuttuva-A

Täysin numero- ja liukupisteiden numerot[[Muokata-

Jos kokonaisluku ja liukupiste lasketaan, saman tyyppinen tulos on samantyyppinen kuin liukupisteen numero.

Laskea merkkejä[[Muokata-

Merkkien luottaminen on erityisen käytännöllistä.Esimerkiksi koko aakkosen tulostaminen yksinkertaisesti lasketaan kirjaimesta'A'kunnes lopulta'Z'-

#sisältää int pää-() { puolesta(hiiltyä minä = 'A'; minä <= 'Z'; ++minä) { std:::nyrkkeily << minä; }}

Abcdefghijklmnopqrstuvwxyz

Luku lue lue yllä olevasta lähdekoodista selitysJauhaa.

Jos käytät binaarioperaattoreita merkkeihin, tulos on (ainakin) tyypinint.Seuraavassa esimerkissä liittyvä kirjeen sijastaAsciiAnnettu arvo.Joten viettääksesi kyltin uudelleen, sinun on palattava piirustustyyppiinValeta.(Huomaa seuraavassa esimerkissä, että muuttujaminä- Päinvastoin kuin edellinen esimerkki - ei tyyppihiiltyäOn):

#sisältää int pää-() { hiiltyä merkki = 'A'; puolesta(int minä = 0 -; minä < 26; ++minä) { std:::nyrkkeily << merkki Tai minä << '' '' '' '' '; // tulos int } std:::nyrkkeily << std:::endl; puolesta(int minä = 0 -; minä < 26; ++minä) { std:::nyrkkeily << staattinen< hiiltyä -(merkki Tai minä) // tulos char }}

65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90Abcdefghijklmnopqrstuvwxyz

Haara (ehdollinen ohje,ehdollinen lausunto) Osoitetaan ohjelman jakaminen useisiin polkuihin.Esimerkiksi käyttäjän merkinnät voidaan reagoida.Ohjelmaprosessi muuttuu käyttäjän sisäänkäynnin mukaan.

Putoaminen[[Muokata-

Purktiot ovat avainsanallajosalkoi.Yksinkertaisimmassa muodossa se näyttää tältä:

jos(««Kunto»-A ««Ohje»

JosKuntoon täytetty,OhjeSuoritetaan, muuten se ohitetaan.Jos ei vain yksi, mutta useita ohjeita on suoritettava, ymmärrät ne{...}Lohkotiedotuksen muodostaminen:

jos(««Kunto») { ««ohjeet»}

KunKuntoMitä tahansa lauseketta voidaan käyttää tuotaboolpalautukset tai sen tulos on yhdessäboolvoidaan muuntaa.Kokonaisluku- ja liukuvien pilkkujen tietotyyppejä voidaan seurataboolMuunna, sääntö on: jos numero (tarkalleen) on 0, se onvääräarvioitu, muuten kutentotta.

int minä;elokuvateatteri >> minä;jos(minä) { nyrkkeily << "Käyttäjä on kirjoittanut arvon 0\ n";}

Muuten[[Muokata-

AvainsanamuuLaajentaa haaran käyttöä.Kun taas normaali (ts. Henkilö)josLaita tietty osa koodista, jos ehto täyttyymuuLaajennus muun koodin suorittamiseksi, jos ehtoa ei täytetä.

int minä;elokuvateatteri >> minä;jos (minä-A nyrkkeily << "Olet antanut arvon 0!\ n";muu nyrkkeily << "Annoit 0!\ n";

Tietysti myös täällä, molemmatjosSekämuu-Säyttö, ohjekohko.Jos tiedät Pascalin tai vastaavan ohjelmointikielen, huomaat, että ohjeet ennenmuuon valmis puolipisteellä.Koska ajos- taimuu-vain yksi ohje ainataiOhjekohtoa voidaan väistämättä käyttää heti sen jälkeenmuupysyäjosmääritetään.

Voit myös määrittää enemmän kuin kaksi vaihtoehtoa ohjeiden haarassa:

int minä;elokuvateatteri >> minä; jos (minä == 10-A nyrkkeily << "Tulit kymmenen\ n";muu jos (minä == 11-A nyrkkeily << "Sisoit yksitoista\ n"; muu nyrkkeily << "Et ole tullut kymmenen tai yksitoista\ n";

Mitä tahansa määrää haaroita voidaan käyttäämuu jostapahtua.On kuitenkin tavallista valita erilainen sisennys, jos sellainen "jos-muu-Trumit ”laajennetaan:

int minä;elokuvateatteri >> minä; jos (minä == 10-A nyrkkeily << "Tulit kymmenen\ n";muu jos (minä == 11-A nyrkkeily << "Sisoit yksitoista\ n";muu nyrkkeily << "Et ole tullut kymmenen tai yksitoista\ n";

On myös suositeltavaa käyttää käskylohkoa jopa ohjeen aikana.Viime kädessä toiminnallisuus on aina sama, mutta tällaiset lohkot lisäävät selkeyttä ja jos haluat myöhemmin määrittää useita ohjeita sen sijaan, että määrität vain sellaisen, sinun ei tarvitse huolehtia mistään kiinnikkeistä, koska ne ovat jo käytettävissä.

int minä;elokuvateatteri >> minä; jos (minä == 10-A { nyrkkeily << "Tulit kymmenen\ n";} muu jos(minä == 11-A { nyrkkeily << "Sisoit yksitoista\ n";} muu { nyrkkeily << "Et ole tullut kymmenen tai yksitoista\ n";}

Muuten, he tapaavat usein toisen variantin sulujen sijoittamiselle:

int minä;elokuvateatteri >> minä; jos (minä == 10-A{ nyrkkeily << "Tulit kymmenen\ n";}muu{ jos (minä == 11-A { nyrkkeily << "Sisoit yksitoista\ n"; } muu { nyrkkeily << "Et ole tullut kymmenen tai yksitoista\ n"; }}

Jotkut ohjelmoijat löytävät tämän selkeämmän, mutta tälle kirjalle käytettiin variantti, jossa oli avauskiinnikkeet ilman ylimääräistä riviä.Tällä on etuna, että vähemmän tilaa tarvitaan ja koska sisällyttäminen osoittaa kuulumisen joka tapauksessa, ylimääräinen merkintä ei ole ehdottoman välttämätöntä.

Muuten, lähdetekstiviivojen sisällyttämisellä ei ole merkitystä kääntäjälle.Se on vain graafinen esitys ohjelmoijalle.Tässä kirjassa valitun neljän välilyönteen syvyys on myös valinnainen, monet ohjelmoijat käyttävät vain kahta tilaa.Toisaalta toiset ovat vakuuttuneita siitä, että kahdeksan on ihanteellinen valinta.Mutta riippumatta siitä, mitä valitset, on tärkeää, että pidät tyylisi etkä muuta tyyliäsi jatkuvasti.Tämä ei vain sekava, mutta ei myöskään näytä hyvältä.

Vertailevat operaattorit[[Muokata-

Yllä olevassa esimerkissä vertailuoperaattori tuli jo==käytettäväksi.C ++: ssa on yhteensä kuusi vertailuoperaattoria.He kukin toimittavat arvontottaJos kaksi operandia (jotka ovat operaattorin vasemmalla ja oikealla puolella) täyttävät vertailukriteerin, muuten arvoväärä.

int eräs = 5- b - = 8;jos (eräs = b --A nyrkkeily << "5 on 8.";

5 on 8.

Loogiset operaattorit[[Muokata-

Loogisten operaattoreiden avulla voit yhdistää useita ehtoja lausekkeeseen.C ++ tarjoaa seuraavat vaihtoehdot:

Operaattoreita voidaan kuvata selvästi totuuden levyillä (tässä valitussa esityksessä jokainen sarake voidaan lukea itse):

Esimerkki kolmannesta sarakkeesta:KanssaA = vääräjab = tottakullattuA && b -> väärä.

Esimerkki:

int minä = 10- j - = 20;jos (minä == 10 Th j - == 10-A { nyrkkeily << "Molemmat arvot ovat kymmenen\ n";}jos (minä == 10 || j - == 10-A { nyrkkeily << "Arvo tai molemmat arvot ovat kymmenen\ n";}

Arvo tai molemmat arvot ovat kymmenen

Luettavuuden syistä vertailulausekkeita tulisi periaatteessa ympäröimä suluissa.Siksi yllä oleva koodi näyttäisi tältä:

int minä = 10- j - = 20;jos (((minä == 10-A Th (j - == 10)) { nyrkkeily << "Molemmat arvot ovat kymmenen\ n";}jos (((minä == 10-A || (j - == 10)) { nyrkkeily << "Arvo tai molemmat arvot ovat kymmenen\ n";}

Arvo tai molemmat arvot ovat kymmenen

MolemmatTh-Operaattorit (logiikka ja) sekä||-Operaattori (logiikka tai) ala-ilmaisut ovatvasemmalta oikealleArvioitu, ja vain siihen asti, kunnes tulos määritetään.Jos esim.Th-HUSTUSEräs Th B - Th CEnsimmäinen ehto 'A' on jo väärässä, 'b' ja 'c' ei enää tutkita, koskaThKyllä kaikki olosuhteettottaon oltava.bool.

Siksi se löytyy satunnaisesti:

jos ( (muutuble_ist_gueltig-A Th (Muuttuja täyttää lisämahdollisuuden-A -A { / * tee jotain */ }

Voidaanko muuttuja tapaa yksityiskohtia vain tarkistaa, jos se sisältää kelvollisen arvon.Ensimmäinen pätevyyden ehto suojaa siten seuraavaa työskentelyä virheellisillä arvoilla.

int minä = 10- j - = 20;// Odotettu tilaus (((i == 10) || (j == 20)) && (j == 20)) && (i == 5))// todellinen järjestys ((i == 10) || (((j == 20) && (j == 20)) && (i == 5))))jos (minä == 10 || j - == 20 Th j - == 20 Th minä == 5-A { nyrkkeily << "Olen kymmenen ja viisi tai (J on kaksikymmentä ja viisi)!\ n";} muu { nyrkkeily << "En ole kymmenen tai (J on kaksikymmentä tai en viisi)!\ n";}

Olen kymmenen ja viisi tai (J on kaksikymmentä ja viisi)!

Ehdollinen ilmaisu[[Muokata-

Arvostuksia käytetään usein tehtävän tekemiseen lausekkeen arvosta riippuen.Voit tehdä sen valintaoperaattorilla? ... - ...muotoilee myös helpommin:

mini = eräs < b - ? eräs - b -;// Vaihtoehtoisesti mennä:jos (eräs < b --A { mini = eräs;} muu { mini = b -;}

Graafisesti se näyttää tältä:

Muuttujaminitulee pienemmäksi, kaksi arvoaeräsjab -määritetty.Analogisesti loogisten operaattoreiden käyttäytymisen kanssa arvioidaan vain "haaraa", että tilan arvioinnin jälkeen (olosuhteet (eräs < b -) suoritetaan tosiasiallisesti.

Ehtooperaattoria voidaan käyttää myös seuraavasti:

(määräProsentti2-A ? painatus("outo"-A - painatus("suoraan")

Toisin kuinjos...muu-tässä ei ole mahdollista antaa vain ohjeita riippuen ehdostamuu-Päästä sen yksinkertaisesti pois:

jos(eräs-A tehdä(b -) //oikea(eräs-A ? tehdä(b -)//väärä

Tämä johtuu siitä, että kuntooperaattori?:ei ole ohjausrakenne todellisessa merkityksessä.

Pikemminkin(eräs-A ? tehdä(b --A - tehdä(c)lauseke "laskee", jolla on oltava arvojos-voi voidaan liuottaa ohjeet loogisesti "tu-ei-polku".

Se, mitä olet tähän mennessä oppinut, sen pitäisi olla helppo harjoitus, jos sinulla on numerot yhdestä kymmeneen.Tätä ohjelma voisi näyttää:

#sisältää int pää-() { std:::nyrkkeily << "1\ n"; std:::nyrkkeily << "2\ n"; std:::nyrkkeily << "3\ n"; std:::nyrkkeily << "4\ n"; std:::nyrkkeily << "5\ n"; std:::nyrkkeily << "6\ n"; std:::nyrkkeily << "7\ n"; std:::nyrkkeily << "8\ n"; std:::nyrkkeily << "9\ n"; std:::nyrkkeily << "10\ n";}

12345678910

Tämä ohjelma on yksinkertainen - mutta entä jos numerot tulevat tulostamaan miljoonaan?Tai mikä pahempaa - kyllä, se toimii vielä pahemmin: lähtö riippuu käyttäjän syöttämisestä.Sitten sinun on otettava suurin mahdollinen numero (allekirjoittamaton intYleensä 4 224,967,295) ja tarkista myös jokaisen ongelman jälkeen, saavutetaanko käyttäjän syöttämä numero.

#sisältää int pää-() { allekirjoittamaton minä = 1; // Luo 2 muuttujaa allekirjoittamaton käyttäjä = 0 -; std:::elokuvateatteri >> käyttäjä; // Käyttäjä tulee numeroon jos (minä <= käyttäjä-A { // Käyttäjän syöttö saavutettiin? std:::nyrkkeily << "1\ n"; // Numeron 1 lähtö ++minä; // Laskeluvut } muu { palata 0 -; // Sulje sovellus } jos (minä <= käyttäjä-A { // Käyttäjän syöttö saavutettiin? std:::nyrkkeily << "2\ n"; // Numeron 2 lähtö ++minä; // Laskeluvut } muu { palata 0 -; // Sulje sovellus } // ... jos (minä <= käyttäjä-A { // Käyttäjän syöttö saavutettiin? std:::nyrkkeily << "4294967295\ n"; // Numeron 4294967295 painos ++minä; // Laskeluvut } muu { palata 0 -; // Sulje sovellus } // Jos kääntäjäsi on saavutettava tämä asema, tarvitset voimakkaan // Tietokone ja vankka käyttöjärjestelmä. // ratkaistaksesi tämän ongelman vain istua seuraavassa aikakoneessa // ja tilaa tietokone vuodesta 2030!}

Kaiken kaikkiaan yli 17,1MiljarditRivikoodi.

Tässä vaiheessa silmukat tulevat peliin.Toistaiseksi kaikki ohjelmat on yksinkertaisesti käsitelty keskiarvoissa ja eri haarojen välillä on voitu seurata.Silmukan avulla voit varmistaa, että ohjelmaosa käsitellään useita kertoja.C ++ tarjoaa kolme silmukkarakennetta.Pääkontrolloitusillä aikaa-LLOOP, jalka -kontrolloitutehdä-sillä aikaa-LLOP ja (myös pääkontrolloitu)puolesta-Nauha.Saat selville, mikä pää- ja jalkaohjatut silmukot ovat pian.Ehkä tiedät sen jo luvusta "Peruselementit", osiosta "aloittelijoille".

Kuollasillä aikaa-Nauha[[Muokata-

Yksisillä aikaa-Chreifellä on seuraava yleinen muoto:

sillä aikaa(««Kunto»-A ««Ohje»

Tietenkin, kuten oksien kohdalla, voit jälleen tehdä yhteenvedon useista ohjeista ohjekohdasta, koska tätä pidetään ohjeena:

sillä aikaa(««Kunto»-A { ««ohjeet»}

Niin kauan kuin ehto täyttyy, ohje tai käskylohko suoritetaan.Koska tämä on pääkontrolloitu silmukka,ensimmäinenArvioitu tila.Jos tämä täyttyy, näinsittenSuoritettu käsky.Jos seuraava ehdon katsaus on positiivinen, silmukan runko suoritetaan uudelleen ja niin edelleen.Jos ehtoa ei täytetä, silmukkapitoisuus ohitetaan ja jatketaan lähdekstillä silmukan jälkeen.Siksi voi tapahtua, että silmukan runko ei suoriteta ollenkaan - jos tilaa ei täytetä alussa.

Voit selvittää, mitä jalka -ohjattu silmukka tekee otsikon allatehdä-sillä aikaa.Tämän luvun yhteenvedossa on vertailu kahdesta silmukasta.

Mutta nyt takaisin silmukkatehtävämme 17,1 miljardilla koodilla.Koska kääntäjäsi ei vieläkään ole valmis kääntämään yllä esitettyä ratkaisua, yritämme nyt tehdä koko asian yhdelläsillä aikaa-Loop ratkaista.

#sisältää int pää-() { allekirjoittamaton minä = 1; // Luo 2 muuttujaa allekirjoittamaton käyttäjä = 0 -; std:::elokuvateatteri >> käyttäjä; // Käyttäjä tulee numeroon sillä aikaa (minä <= käyttäjä-A { // Käyttäjän syöttö saavutettiin? std:::nyrkkeily << minä << std:::endl; // I -painos ja linjatauko minä++; // Lisää yksi kerrallaan (-> Laskeluku) }}

No, se näyttää jotenkin ylhäältä, vain melkein 4,3 miljardiajosOhjeet on poistettu ja niissä on yksi melkein identtinen rakenteen kanssasillä aikaa-CHinde teki tilaa.Nyt meillä on tietysti ongelma: Super -tietokoneesi vuodesta 2020 on edelleen kiireinen kääntämällä ensimmäinen ohjelmaversio ja se todennäköisesti pysyy keksinnönsä saakka.Onneksi sinulla on edelleen vanha tietokone vuodesta 1980. Joten yritä kääntää ja suorittaa ohjelma siihen.Itse asiassa.Se toimii.On hämmästyttävää, että tällainen vanha laatikko ohittaa tietokoneen, joka sinun on toimitettava tulevaisuudesta saadaksesi maksimaalisen suorituskyvyn.

Jos sinulla on vaikeuksia ymmärtää esimerkkiä, katso numeroiden silmukkaversiota 1-10.

#sisältää int pää-() { int minä = 1; // Luo i sillä aikaa (minä <= 10-A { // Olenko vielä pienempi, 10? std:::nyrkkeily << minä << std:::endl; // I: n ja uuden linjan painos minä++; // lisään yhdellä }}

12345678910

Joten koko asia näyttää paljon kompaktemmalta ja ehkä vielä selkeämmalta kuin ylhäältä oleva versio.Lähtö puolestaan ​​on täysin identtinen.Täällä onminäasetettu yhteen alussa.Joten ehto (yksi on pienempi tai kymmenen tai kymmenen) täyttyy.Silmukan runko suoritetaan."1" annetaan.Seuraava linjatauko.Sittenminälisääntynyt yhdellä.Sitten tarkistetaan uudelleen, täyttyykö ehto.SielläminäNyt kaksi on, että tila "kaksi on pienempi tai kymmenen", koska tämä on todellinen lausunto, silmukan runko suoritetaan uudelleen.Tämä toistetaan kunnesminäViimeinkin on yksitoista.Edellytys on sitten "yksitoista on pienempi tai kymmenen", tämä lausunto on epäilemättä väärä.Siksi silmukan runko ohitetaan nyt ja jatketaan sen takana olevan koodin kanssa.Koska esimerkissämme ei ole enää koodia, ohjelma päättyy.

Yhteenveto:

1. Lähdeteksti silmukan edessä
2. Silmukka
   • Täyttää:
     1. Silmukka
     2. Jatka 2: lla
   • Ei täytetty:
     1. Jatka 3: lla
3. Lähdeteksti silmukan jälkeen

Kuollatehdä-sillä aikaa-Nauha[[Muokata-

Kuten luvattiin, tuuletamme nyt salaisuuden jalan hallitsemasta hiomista.tehdä-sillä aikaaJos jalkavalvottu silmukka on, ts. Ensimmäinen asia on suorittaa silmukan runko, sitten ehto tarkistetaan ja sitten ehto riippuen, runko suoritetaan uudelleen (ehto täyttyy) tai jatketaan lähteen kanssa Teksti silmukan jälkeen (ehto ei täytetty).Jalkapäällystetylle silmukkaa on ominaista se, että silmukan runko suoritetaan ainakin kerran.

tehdä ««Ohje» sillä aikaa(««Kunto»)

Tämän silmukan avulla löydämme harvoin yllä olevan syntaksin, koska täällä oleva silmukka runko kahden avainsanan välillätehdäjasillä aikaaJulkaisut, ohjekohtoa käytetään melkein aina, vaikka vain yksi ohje olisi käytettävissä.Tietysti tällä ei ole merkitystä kääntäjällesi, mutta se on selkeämpää henkilölle, joka lukee lähdetekstiä.

tehdä{ ««ohjeet»} sillä aikaa(««Kunto»)

Alkuperäinen jättiläinen ohjelmamme näkee yhdentehdä-sillä aikaaPiirittää näin:

#sisältää int pää-() { allekirjoittamaton minä = 1; // Luo 2 muuttujaa allekirjoittamaton käyttäjä = 0 -; std:::elokuvateatteri >> käyttäjä; // Käyttäjä tulee numeroon tehdä { // Alku std:::nyrkkeily << minä << std:::endl; // I -painos ++minä; // Laskeluvut } sillä aikaa (minä <= käyttäjä) // Käyttäjän syöttö saavutettiin?}

Huomaat, että tämän ohjelman tulos on tulostettusillä aikaa-Schrifeeniversio vastaa.Huomaat eron, kun syötät 0: kunsillä aikaaVersio ei tee tulosta, tämä tarjoaa tämäntehdä-sillä aikaa-Version "1" ja linjan linja, koska silmukka runko suoritetaan aina ensin, vasta sitten ehto tarkistetaan ja päätetään, onko se suoritettava uudelleen.

Yhteenveto:

1. Lähdeteksti silmukan edessä
2. Silmukka
3. Silmukka
   • Täytetty: Jatka 2: lla
   • Ei täytetty: Jatka 4: llä
4. Lähdeteksti silmukan jälkeen

Kuollapuolesta-Nauha[[Muokata-

Kuollapuolesta-Silmä on hiukan monimutkaisempi kuin kaksi edellistä silmukkaa.Se on jaettu osiin:

puolesta(««Alustusosa»; ««Ehdollinen osa»; ««Ohjeet»-A ««Silmukka»

Kuten aina, silmukan runko voi olla yksi käsky tai {} -käskylohko.Tilan kunto käyttäytyy täsmälleen kutensillä aikaa- jatehdä-sillä aikaa-Schand tai sanotaan melkein samalla tavalla, koska on pieni, mutta hieno ero.Sillä aikaasillä aikaajatehdä-sillä aikaaOdota aina ehtoa, apuolesta-VIEDOT EI VASTAA EDELLEEN.Jos ehtoa ei määritetä, oletetaan yksinkertaisesti, että ehto on aina täyttynyt, saat loputtoman silmukan.Saat selville, kuinka tätä käytetään järkevästi.

Voit suorittaa kaikki ohjeet käskyosassa, tätä osaa käytetään usein muuttujien laskemiseen ylös tai alas jokaisessa hiontapäässä.Tämä osoitetaan myös seuraavassa esimerkissä.On myös mahdollista määritellä useita tällaisia ​​"korkean tai laskenta" -ohjeiden erikseen pilkkua, mutta sitä ei tehdä seuraavassa esimerkissä.Muuten, ohjeosa suoritetaan heti silmukan rungon jälkeen ja ennen seuraavaa ehto -testiä.Alustusosa on samanlainen kuin ohjeet, koska kaikki ohjeet voidaan suorittaa myös täällä.Lisäksi se on edelleen mahdollista täälläyksiTietotyypin luominen.Joten voit helposti 2int-Variaatiot, mutta ei yhtäint- ja ahiiltyä-Muutos.Alustusosa suoritetaan vain kerran silmukan alussa.

#clude  int main () {allekirjoittamaton käyttäjä = 0;// Käyttäjän syöttömuuttujat std :: cin >> käyttäjä;// Käyttäjä antaa numeron (allekirjoittamaton i = 1; i <= käyttäjä; ++ i) // for-loop std :: cout << i << std :: endl;// I} painos

Yhteenveto:

1. Lähdeteksti silmukan edessä
2. Alustan osa silmukasta
3. Silmukka
   • Täyttää:
     a) Loop Hull
     b) Ohjeosa
     c) Jatka 3: lla
   • Ei täytetty: Jatka 4: llä
4. Lähdeteksti silmukan jälkeen

For («elementti»: «säilö») «Loop Hull»

Kuollatauko-Ohje[[Muokata-

Nyt on aika paljastaa loputtomien silmukoiden järkevän käytön salaisuus.Setauko-Johdistuksia käytetään silmukoissa silmukan lopettamiseksi välittömästi.Lähdetekstiä jatketaan sitten normaalisti silmukan jälkeen.taukoVoit käyttää jokaisessa kolmessa silmukassa.Seuraava esimerkki osoittaatauko, tämän luvun suosikkiohjelmamme perusteella.

#clude  int main () {allekirjoittamaton i = 1;// 2 muuttujaa Luo allekirjoittamaton käyttäjä = 0;Std :: cin >> käyttäjä;// Käyttäjä antaa numeron a// I ++ i: n painos;// lisää muuttujaa, jos (i> käyttäjä) tauko;// Peruuta, jos ehto täyttää}}

Voit tehdä loputtoman silmukan jokaisesta silmukasta, täälläpuolesta-Kuoppa, joka on valittu näyttämään miltä se näyttää ilman ehtoa.Aassasillä aikaa- taitehdä, kun-Tie Loop voisit esimerkiksitottamääritä ehto.Muuten, silmukka osoittaa nyt saman käyttäytymisen kuin yksitehdä, kun-Nauha.Voit myös käyttää helposti yhtä tai kahta osaa silmukkapäästäpuolesta-Vidosilmukka on vain tärkeä, että määrität aina kaksi puolipistettä, koska kerrot kääntäjälle, mikä on silmukkapään osa.

Nyt tiedät vähän enemmänpuolesta, sen pitäisi olla tämän otsikon allataukomennä.Kuten näette, kaikki kaikki liittyvät toisiinsa, ja siten on usein vaikea luoda oikea rajaa.

Kuollajatkaa-Ohje[[Muokata-

Toinen tärkeä avainsana silmukoille onjatkaa.Sitä käytetään täsmälleen kutentaukoei kuitenkaan katkaise silmukkaa kokonaan, vaan jatkaa koodiversiota silmukan rungon lopussa.Puolestasillä aikaajatehdä, kunTämä tarkoittaa ehtokoettapuolesta-LOOP ohjeosassa.KanssajatkaaJoten voit ohittaa loput nykyisestä hionta -ajoista.Tarkastelemme tätä uudelleen esimerkin avulla.

#clude  int main () {allekirjoittamaton käyttäjä = 0;// Käyttäjän syöttömuuttujat std :: cin >> käyttäjä;// Käyttäjä antaa numeron (allekirjoittamaton i = 1; i <= käyttäjä; ++ i) {// for-silmukka, jos (i% 2 == 0) jatka;// Ohita kaikki suorat numerot std :: cout << i << std :: endl;// I}} painos

Tässä on vain tangradeja, koskaProsentti-Operaattori (toimittaa loput kokonaislukujaosta) kaikissa suorissa numeroissa (jos jaat 2 loput, vain 0 tai 1 on mahdollista) 0 ja siten takaisin ja siten takaisin ja sitenjatkaaon esitetty.

Tietysti voit tehdä sen eri tavalla.Mutta Roomaan johtavan ohjelmoinnin on monia tapoja, kuten tässä luvussa, se on jo todistettu eri silmukoiden perusteella.Valitettavasti on vielä enemmän tapoja, jotka johtavat Rooman ohi suoraan ... mutta tässä on polku esimerkistä esimerkistä, joka johtaa turvallisesti Roomaan:

#clude  int main () {allekirjoittamaton int käyttäjä = 0;// Käyttäjän syöttömuuttujat std :: cin >> käyttäjä;// Käyttäjä antaa numeron (allekirjoittamaton i = 1; i <= käyttäjä; i += 2) // silmukka 2 vaiheella std :: cout << i << std :: endl;// I} painos

Jäsennelty ohjelmointi[[Muokata-

Ohjeet 'tauko' ja 'jatkuu' pidetään "saastainen", ne melkein aina on vaikea ymmärtää ohjelmaa.

Luvun kiinnitys[[Muokata-

#include  int main () {int min, max;// MUUTITUKSET MAHDOLLISESTI NUMERO -ALUE INT -luvulle;// Numero, jonka tietokone epäilee std :: cout << "Mistä numerosarja alkaa?:";// Kyselynumero Alue :: Cin >> min;// Lue käyttäjän syöttö std :: cout << "Missä numerosarja pysähtyy?:";// Kyselynumero alue STD :: CIN >> Max;// lyijykäyttäjän syöttö (char input = '0'; input! = '=';) {// jos syöttö '=' on numero = min + (max - min)/ 2;// Laske keskimääräinen luku STD :: cout << "Ajattele" << "?";// Ilmaise oletus std :: cin >> syöttö;// Lue vastaus, jos (input == '<') // Onko numero pienempi?max = numero;// Max luottaa liian suureen määrään muuta, jos (input == '>') // Onko numero suurempi?min = numero;// luottaa minin pieneen arvonumeroon muuten, jos (input! = '=') // ei myöskään ole syötetty tasa -arvoa std :: cout << "Olet syöttänyt tutkittamattoman merkin! \ n";// Ilmoita väärä syöttö, jos (min+1> = max) {// ei enää numero kelvollisella alueella std :: cout << "Olet valehtelija! \ N";// Ohjelma on erittäin kauhistunut tauko;// Loop peruutetaan}} std :: cout << "Tapasi numero on" << "!"<< std :: endl;// arvatun numeron painos}

Mistä numerosarja alkaa?: 0wo pysäyttää numerosarjan?: 100 ajattelemalla noin 50? Ajatteletko 37: tä? Ajatteletko 34: tä? Ajatteletko 33?= Tapaamasi numero on 33!