Tip sa najmanjim gubitkom informacija dobija najveći prioritet. Ne biste trebali zloupotrebljavati implicitnu konverziju tipa, jer se mogu pojaviti sve vrste nepredviđenih situacija.

• Eksplicitna konverzija za razliku od implicitnog, izvodi programer. Postoji nekoliko načina da izvršite ovu konverziju:

1. Pretvaranje u stilove C: (plutati) a
2. Pretvaranje u stilove C++: float()

Izlijevanje tipa se također može izvršiti pomoću sljedećih operacija:

static_cast<>() const_cast<>() reinterpret_cast<>() dynamic_cast<> ()

static_cas- pretvara povezane tipove podataka. Ovaj operator izbacuje tipove prema uobičajenim pravilima, što može biti neophodno kada kompajler ne izvrši automatsku konverziju. Sintaksa će izgledati ovako:

static_cast type<Тип>(objekat);

Koristeći static_cast, ne možete ukloniti konstantnost iz varijable, ali to je unutar moći sljedeće izjave. const_cast- koristi se samo kada trebate ukloniti konstantnost iz objekta. Sintaksa će izgledati ovako:

Tipconst_cast< Tip> (objekat);

reinterpret_cast- koristi se za pretvaranje različitih tipova, cijeli broj u pokazivač i obrnuto. Ako vidite novu riječ "pokazivač" - nemojte se uplašiti! ovo je također tip podataka, ali nećemo uskoro raditi s njim. Ovdje je sintaksa ista kao i za prethodno razmatrane operatore:

Tipreinterpretirati_cast< Tip> (objekat);

dynamic_cast- koristi se za dinamičku konverziju tipova, implementira kasting pokazivača ili reference. sintaksa:

Tipdinamičan _cast< Tip> (objekat);

Kontrolni znakovi

Već ste upoznati sa nekim od ovih „kontrolnih znakova“ (na primjer, sa \n). Svi počinju sa obrnutom kosom crtom i također su okruženi dvostrukim navodnicima.

Važna razlika između jezika C i drugih jezika (PL1, FORTRAN, itd.) je odsustvo zadanog principa, što dovodi do potrebe da se sve varijable koje se koriste u programu eksplicitno deklarišu zajedno sa naznakom njihovih odgovarajućih tipova .

Deklaracija varijable ima sljedeći format:

[specifier-klase-pohrane] deskriptor-specifikator tipa [= pokretač] [, deklarator [= pokretač] ]...

Deskriptor je jednostavan identifikator varijable ili složenija konstrukcija sa uglastim zagradama, zagradama ili zvjezdicom (skup zvjezdica).

Specifikator tipa je jedna ili više ključnih riječi koje definiraju tip varijable koja se deklarira. Jezik C ima standardni skup tipova podataka koji se mogu koristiti za konstruisanje novih (jedinstvenih) tipova podataka.

Inicijator - specificira početnu vrijednost ili listu početnih vrijednosti koje (koje) se dodjeljuju varijabli kada je deklarirana.

Specifikator memorijske klase je definiran jednom od četiri ključne riječi SI jezika: auto, extern, register, static i pokazuje kako će memorija biti alocirana za deklariranu varijablu, s jedne strane, a s druge, opseg ove varijable, odnosno iz kojih dijelova programa joj možete pristupiti.

1.2.1 Kategorije tipova podataka

Ključne riječi za definiranje osnovnih tipova podataka

Tipovi cjelobrojnih: Plutajući tipovi: char float int duplo kratko dugo dvostruko dugo bez predznaka

Varijabla bilo kojeg tipa može biti deklarirana kao nepromjenjiva. Ovo se postiže dodavanjem ključne riječi const u specificator tipa. Objekti tipa const predstavljaju podatke samo za čitanje, tj. ovoj varijabli se ne može dodijeliti nova vrijednost. Imajte na umu da ako ne postoji specificator tipa iza riječi const, onda se podrazumijeva specificator tipa int. Ako ključna riječ const dolazi ispred deklaracije kompozitnih tipova (niz, struktura, mješavina, nabrajanje), onda to dovodi do činjenice da svaki element mora biti i nepromjenjiv, tj. može mu se dodijeliti vrijednost samo jednom.

Const dupli A=2.128E-2; const B=286; (pretpostavljajući const int B=286)

Primjeri deklariranja složenih podataka bit će razmotreni u nastavku.

1.2.2. Cjelobrojni tip podataka

Za definiranje podataka cjelobrojnog tipa koriste se različite ključne riječi koje određuju raspon vrijednosti i veličinu memorijskog područja dodijeljenog varijablama (tablica 6).

Tabela 6

Imajte na umu da su potpisane i nepotpisane ključne riječi opcione. Oni određuju kako se tumači nulti bit deklarirane varijable, tj. ako je specificirana neoznačena ključna riječ, onda se nulti bit tumači kao dio broja, u suprotnom se nulti bit tumači kao znak. U nedostatku ključne riječi unsigned, integer varijabla se smatra potpisanom. Ako se specifikacija tipa sastoji od potpisanog ili nepotpisanog tipa ključa praćenog identifikatorom varijable, tada će se tretirati kao varijabla tipa int. Na primjer:

unsigned intn; unsigned int b; int c; (pod pretpostavkom da je potpisan int c); unsigned d; (pretpostavljajući unsigned int d); potpisan f; (pod pretpostavkom da je potpisan int f).

Imajte na umu da se modifikator tipa char koristi za predstavljanje karaktera (iz prikaza niza znakova) ili za deklarisanje literala niza. Vrijednost char objekta je kod (veličine 1 bajt) koji odgovara predstavljenom znaku. Za predstavljanje znakova ruskog alfabeta, modifikator tipa identifikatora podataka je unsigned char, budući da kodovi ruskih slova prelaze vrijednost 127.

Treba imati na umu sljedeću napomenu: jezik C ne definira memorijski prikaz i raspon vrijednosti za identifikatore sa modifikatorima tipa int i unsigned int. Veličina memorije za modifikator tipa int s predznakom određena je dužinom strojne riječi, koja ima različitu veličinu na različitim strojevima. Dakle, na 16-bitnim mašinama veličina riječi je 2 bajta, na 32-bitnim mašinama, respektivno, 4 bajta, tj. tip int je ekvivalentan tipovima short int ili long int u zavisnosti od arhitekture korišćenog računara. Dakle, isti program može raditi ispravno na jednom računaru, a neispravno na drugom. Da biste odredili dužinu memorije koju zauzima varijabla, možete koristiti operaciju sizeof jezika C, koja vraća vrijednost dužine specificiranog modifikatora tipa.

Na primjer:

A = sizeof(int); b = sizeof(long int); c = sizeof(unsigned long); d = sizeof(short);

Imajte na umu da oktalne i heksadecimalne konstante također mogu imati modifikator bez predznaka. To se postiže navođenjem prefiksa u ili U nakon konstante, a konstanta bez ovog prefiksa se smatra potpisanom.

Na primjer:

0xA8C (int signed); 01786l (dugo potpisan); 0xF7u (int unsigned);

1.2.3. float podaci

Za varijable koje predstavljaju broj s pomičnim zarezom, koriste se sljedeći modifikatori tipa: float, double, long double (nema SI u nekim implementacijama long double jezika).

Vrijednost sa modifikatorom tipa float zauzima 4 bajta. Od toga, 1 bajt je dodijeljen za predznak, 8 bita za eksponent viška i 23 bita za mantisu. Imajte na umu da je najznačajniji bit mantise uvijek 1, tako da nije dopunjen, tako da je raspon varijable s pomičnim zarezom otprilike 3,14E-38 do 3,14E+38.

Dvostruka vrijednost zauzima 8 bita u memoriji. Njegov je format sličan float formatu. Memorijski bitovi se dodjeljuju na sljedeći način: 1 bit za predznak, 11 bita za eksponent i 52 bita za mantisu. S obzirom na izostavljeni visoki dio mantise, raspon vrijednosti je od 1,7E-308 do 1,7E+308.

Float f, a, b; duplo x,y;

1.2.4. Pointers

Pointer je adresa memorije koja je dodijeljena za postavljanje identifikatora (identifikator može biti ime varijable, niza, strukture, string literala). Ako je varijabla deklarirana kao pokazivač, tada sadrži memorijsku adresu na kojoj se može pronaći skalarna vrijednost bilo kojeg tipa. Prilikom deklarisanja varijable tipa pokazivača, potrebno je definisati tip objekta podataka čiju će adresu varijabla sadržavati, te naziv pokazivača kojem prethodi zvjezdica (ili grupa zvjezdica). Format deklaracije pokazivača:

specificator tipa [ modifikator ] * deskriptor.

Specifikator tipa specificira tip objekta i može biti bilo kog osnovnog tipa, tipa strukture, mješavine (o tome će biti riječi u nastavku). Navođenjem void umjesto specificatora tipa, možete nekako odgoditi specifikaciju tipa na koji upućuje pokazivač. Varijabla deklarirana kao pokazivač na tip void može se koristiti za upućivanje na objekt bilo kojeg tipa. Međutim, da bi se mogle izvoditi aritmetičke i logičke operacije nad pokazivačima ili objektima na koje ukazuju, potrebno je eksplicitno definirati tip objekata prilikom izvođenja svake operacije. Takva određivanja tipa mogu se izvesti korištenjem operacije cast.

Ključne riječi const, near, far, huge mogu djelovati kao modifikatori prilikom deklariranja pokazivača. Ključna riječ const označava da se pokazivač ne može promijeniti u programu. Veličina varijable deklarirane kao pokazivač ovisi o arhitekturi računala i o korištenom memorijskom modelu za koji će se program kompajlirati. Pokazivači na različite tipove podataka ne moraju biti iste dužine.

Blizu, daleku, veliku ključne riječi mogu se koristiti za promjenu veličine pokazivača.

unsigned int * a; /* varijabla a je pokazivač za tip unsigned int (neoznačeni cijeli brojevi) */ double * x; /* varijabla x ukazuje na tip podataka s pomičnim zarezom dvostruke preciznosti */ char * fuffer ; /* deklarisati pokazivač pod nazivom fuffer koji ukazuje na varijablu tipa char */ double numberer; void *adrese; adresa = &broj; (dvostruko *) adresa ++; /* Varijabla adresa je deklarirana kao pokazivač na objekt bilo kojeg tipa. Stoga mu se može dodijeliti adresa bilo kojeg objekta (& je operacija izračunavanja adrese). Međutim, kao što je gore navedeno, nijedna aritmetička operacija se ne može izvesti na pokazivaču sve dok tip podataka na koji ukazuje nije eksplicitno definiran. Ovo se može učiniti korištenjem operacije cast (double *) za pretvaranje adrese u pokazivač u dvostruku i zatim povećanje adrese. */ const *dr; /* Varijabla dr je deklarirana kao pokazivač na konstantni izraz, tj. vrijednost pokazivača se može promijeniti tokom izvršavanja programa, ali vrijednost na koju pokazuje ne. */ unsigned char * const w = &obj. /* Varijabla w je deklarirana kao konstantni pokazivač na char neoznačene podatke. To znači da će w pokazivati ​​na isto područje memorije kroz cijeli program. Sadržaj ove oblasti je podložan promjenama. */

1.2.5. Nabrojane varijable

Varijabla koja može preuzeti vrijednost s neke liste vrijednosti naziva se varijabla nabrojanog tipa ili nabrajanje.

Deklaracija nabrajanja počinje ključnom riječi enum i ima dva formata predstavljanja.

Format 1. enum [enum-tag-name] (enum-list) deskriptor[, deskriptor...];

Format 2. enum enum-tag-name deskriptor [, deskriptor..];

Enum deklaracija specificira tip enum varijable i definira listu imenovanih konstanti koja se zove enum-list. Vrijednost svakog imena liste je cijeli broj.

Varijabla tipa enum može uzeti vrijednosti jedne od imenovanih konstanti liste. Konstante imenovane liste su tipa int. Dakle, memorija koja odgovara varijabli nabrajanja je memorija potrebna za pohranjivanje int vrijednosti.

Varijabla tipa enum može se koristiti u indeksnim izrazima i kao operandi u aritmetičkim i relacijskim operacijama.

U prvom formatu 1, imena i vrijednosti enuma su specificirani u listi enuma. Opcioni enum-tag-name je identifikator koji imenuje enum tag definisan enum-listom. Deskriptor imenuje varijablu nabrajanja. Više od jedne varijable tipa enum može biti definirano u deklaraciji.

Enum-lista sadrži jednu ili više konstrukcija oblika:

identifikator [= konstantni izraz]

Svaki identifikator imenuje enum element. Svi identifikatori u enum listi moraju biti jedinstveni. U nedostatku konstantnog izraza, vrijednost 0 odgovara prvom identifikatoru, vrijednost 1 odgovara sljedećem identifikatoru i tako dalje. Ime konstante nabrajanja je ekvivalentno njenoj vrijednosti.

Identifikator povezan s konstantnim izrazom poprima vrijednost specificiranu tim konstantnim izrazom. Konstantni izraz mora biti tipa int i može biti pozitivan ili negativan. Sljedećem identifikatoru na listi dodjeljuje se vrijednost jednaka konstantnom izrazu plus 1 ako taj identifikator nema svoj vlastiti konstantni izraz. Upotreba elemenata nabrajanja mora se pridržavati sljedećih pravila:

1. Varijabla može sadržavati duple vrijednosti.

2. Identifikatori u popisnoj listi moraju se razlikovati od svih ostalih identifikatora u istom opsegu, uključujući obična imena varijabli i identifikatore iz drugih popisnih lista.

3. Imena enum tipova moraju se razlikovati od drugih imena enum tipova, struktura i mješavina u istom opsegu.

4. Vrijednost može pratiti posljednji element popisne liste.

Enum sedmica ( SUB = 0, /* 0 */ VOS = 0, /* 0 */ POND, /* 1 */ VTOR, /* 2 */ SRED, /* 3 */ HETV, /* 4 */ PJAT /* 5 */ ) slave_ned ;

U ovom primjeru, deklarirana je nabrojana oznaka sedmica, s odgovarajućim skupom vrijednosti, a deklarirana je varijabla rab_ned, koja ima tip sedmice.

Drugi format koristi ime enum oznake za upućivanje na tip enuma definiran na drugom mjestu. Ime enum oznake mora se odnositi na već definiranu enum oznaku unutar trenutnog opsega. Pošto je enum tag deklarisan negdje drugdje, lista enum nije prisutna u deklaraciji.

U deklariranju pokazivača na enum tip podataka iu typedef deklaracijama za enum tipove, možete koristiti ime enum oznake prije nego što se definira enum oznaka. Međutim, definicija nabrajanja mora prethoditi bilo kojoj akciji korištenog pokazivača na tip deklaracije typedef. Deklaracija bez naknadne liste deskriptora opisuje oznaku ili, ako mogu tako reći, šablon za nabrajanje.

1.2.6. Nizovi

Nizovi su grupa elemenata istog tipa (double, float, int, itd.). Iz deklaracije niza, prevodilac mora dobiti informacije o tipu elemenata niza i njihovom broju. Deklaracija niza ima dva formata:

deskriptor specificatora tipa [const - izraz];

deskriptor specificatora tipa;

Deskriptor je identifikator niza.

Specifikator tipa specificira tip elemenata deklariranog niza. Elementi niza ne mogu biti funkcije ili void elementi.

Konstantni izraz u uglastim zagradama specificira broj elemenata u nizu. Konstantni izraz može biti izostavljen iz deklaracije niza u sljedećim slučajevima:

Kada je deklarisan, niz se inicijalizira,

Niz je deklarisan kao parametar formalne funkcije,

C definira samo jednodimenzionalne nizove, ali pošto element niza može biti niz, možete definirati i višedimenzionalne nizove. Oni su formalizovani kao lista konstantnih izraza koji prate identifikator niza, pri čemu je svaki konstantni izraz zatvoren u sopstvene uglaste zagrade.

Svaki konstantni izraz u uglastim zagradama definira broj elemenata u datoj dimenziji niza, tako da deklaracija dvodimenzionalnog niza sadrži dva konstantna izraza, trodimenzionalna deklaracija niza sadrži tri, i tako dalje. Imajte na umu da u jeziku C prvi element niza ima indeks 0.

int a; /* predstavljen kao matrica a a a a a a */ double b; /* vektor od 10 dvostrukih elemenata */ int w = ( ( 2, 3, 4 ), ( 3, 4, 8 ), ( 1, 0, 9 ) );

U posljednjem primjeru, deklarisan je niz w. Liste zatvorene u vitičaste zagrade odgovaraju nizovima niza; ako nema zagrada, inicijalizacija će biti izvršena pogrešno.

Odjeljci niza mogu se koristiti u C, kao iu drugim jezicima visokog nivoa (PL1, itd.), ali postoje brojna ograničenja u korištenju sekcija. Sekcije se formiraju izostavljanjem jednog ili više parova uglastih zagrada. Parovi uglastih zagrada mogu se ispuštati samo s desna na lijevo i to striktno uzastopno. Sekcije nizova se koriste u organizaciji računskog procesa u funkcijama SI jezika koje je razvio korisnik.

Ako upišete s kada pozivate funkciju, tada će biti proslijeđen nulti niz niza s.

Kada se pozivate na niz b, možete napisati, na primjer, b, i vektor od četiri elementa će biti proslijeđen, a upućivanje na b će dati dvodimenzionalni niz veličine 3 puta 4. Ne možete napisati b, što implicira da bit će proslijeđen vektor, jer to nije u skladu sa ograničenjem nametnutim sekcijama niza korištenja.

Primjer deklariranja niza znakova.

char str = "deklaracija niza znakova";

Imajte na umu da postoji još jedan element u literalu znakova, budući da je posljednji element "\0" izlazni niz.

1.2.7. strukture

Strukture su složeni objekt koji uključuje elemente bilo kojeg tipa, s izuzetkom funkcija. Za razliku od niza, koji je homogeni objekat, struktura može biti heterogena. Tip strukture utvrđuje se zapisom obrasca:

struktura ( lista definicija )

Struktura mora sadržavati najmanje jednu komponentu. Definicija strukture je sljedeća:

deskriptor tipa podataka;

gdje tip podataka specificira tip strukture za objekte definirane u deskriptorima. U svom najjednostavnijem obliku, deskriptori su identifikatori ili nizovi.

Struktura (dvostruki x,y; ) s1, s2, sm; struktura (int godina; char mol, dan; ) datum1, datum2;

Varijable s1, s2 su definirane kao strukture, od kojih se svaka sastoji od dvije komponente x i y. Varijabla sm je definirana kao niz od devet struktura. Svaka od dvije varijable date1, date2 sastoji se od tri komponente godina, mjesec, dan. >p>Postoji još jedan način povezivanja imena sa tipom strukture, baziran je na korištenju oznake strukture. Oznaka strukture je slična oznaci nabrojanog tipa. Oznaka strukture je definirana na sljedeći način:

struct tag ( lista opisa; );

gdje je oznaka identifikator.

U primjeru ispod, identifikator student je opisan kao struct tag:

Strukturirajte učenik (char name; int id, age; char prp; );

Oznaka strukture se koristi za naknadno deklarisanje struktura ove vrste u obliku:

struct tag id-list;

struct student st1,st2;

Upotreba oznaka strukture je neophodna za opisivanje rekurzivnih struktura. U nastavku je opisana upotreba oznaka rekurzivne strukture.

Čvor strukture ( int podaci; struct čvor * sljedeći; ) st1_node;

Oznaka strukture čvora je zaista rekurzivna, jer se koristi u svom opisu, tj. u formalizaciji sljedećeg pokazivača. Strukture ne mogu biti direktno rekurzivne, tj. čvor strukture ne može sadržavati komponentu koja je čvor strukture, ali svaka struktura može imati komponentu koja je pokazivač na njen tip, kao što je učinjeno u gornjem primjeru.

Komponentama strukture se pristupa navođenjem imena strukture nakon čega slijedi naziv odabrane komponente odvojen točkom, na primjer:

St1.name="Ivanov"; st2.id=st1.id; st1_node.data=st1.age;

1.2.8. Asocijacije (mješavine)

Sindikat je sličan strukturi, međutim, samo jedan od elemenata unije se može koristiti (ili, drugim riječima, odgovoriti) u bilo kojem trenutku. Tip sindikata se može specificirati na sljedeći način:

Unija (opis elementa 1; ... opis elementa n; );

Glavna karakteristika unije je da se ista memorijska oblast dodjeljuje za svaki od deklariranih elemenata, tj. oni se preklapaju. Iako je pristup ovom području memorije moguć korištenjem bilo kojeg od elemenata, element za tu svrhu mora biti odabran tako da dobijeni rezultat ne bude besmislen.

Članovima sindikata se pristupa na isti način kao i strukturama. Oznaka unije se može formalizirati na potpuno isti način kao i oznaka strukture.

Udruženje se koristi u sljedeće svrhe:

Inicijalizacija korištenog memorijskog objekta ako je u bilo kojem trenutku aktivan samo jedan objekt od mnogih;

Interpretacije osnovnog prikaza objekta jednog tipa kao da je objektu dodijeljen drugi tip.

Pohrana koja odgovara varijabli tipa sindikata određena je količinom koja je potrebna za smještaj najdužeg člana sindikata. Kada se koristi element manje dužine, varijabla tipa unije može sadržavati neiskorištenu memoriju. Svi elementi ujedinjenja pohranjeni su u istom memorijskom području, počevši od iste adrese.

Union (char fio; char adres; int vozrast; int telefon; ) inform; unija ( int ax; char al; ) ua;

Kada koristite infor objekat tipa unije, možete obraditi samo element koji je primio vrijednost, tj. nakon dodjeljivanja vrijednosti elementu inform.fio, nema smisla upućivati ​​se na druge elemente. Ua konkatenacija vam omogućava da zasebno pristupite malim ua.al i visokim ua.al bajtovima dvobajtnog broja ua.ax.

1.2.9. Bit polja

Element strukture može biti polje bitova koje omogućava pristup pojedinačnim bitovima memorije. Bitova polja se ne mogu deklarisati izvan struktura. Također ne možete organizirati nizove bitnih polja i ne možete primijeniti operaciju traženja adrese na polja. U opštem slučaju, tip strukture sa bitnim poljem je dat u sledećem obliku:

Struktura (nepotpisani identifikator 1: dužina polja 1; nepotpisani identifikator 2: dužina polja 2; )

dužina - polje je specificirano cjelobrojnim izrazom ili konstantom. Ova konstanta specificira broj bitova dodijeljenih odgovarajućem polju. Polje nulte dužine označava poravnanje prema sljedećoj granici riječi.

Struktura ( unsigned a1: 1; unsigned a2: 2; unsigned a3: 5; unsigned a4: 2; ) prim;

Strukture bitfielda također mogu sadržavati potpisane komponente. Takve komponente se automatski postavljaju na odgovarajuće granice riječi, a neki dijelovi riječi ostaju neiskorišteni.

1.2.10. Varijable sa promjenjivom strukturom

Vrlo često neki programski objekti pripadaju istoj klasi, razlikuju se samo u nekim detaljima. Razmotrimo, na primjer, reprezentaciju geometrijskih oblika. Opće informacije o oblicima mogu uključivati ​​elemente kao što su površina, perimetar. Međutim, odgovarajuće informacije o geometrijskim dimenzijama mogu se razlikovati ovisno o njihovom obliku.

Razmotrimo primjer u kojem su informacije o geometrijskim oblicima predstavljene na temelju kombinirane upotrebe strukture i sjedinjenja.

Strukturna figura (dvostruka površina,perimetar; /* uobičajene komponente */ tip int; /* atribut komponente */ unija /* nabrajanje komponente */ (dvostruki radijus; /* krug */ duplo a; /* pravougaonik */ dupli b; /* trougao */ ) geom_fig; ) fig1, fig2 ;

Općenito, svaki objekat tipa figure sastojat će se od tri komponente: površine, perimetra, tipa. Komponenta tipa naziva se oznaka aktivne komponente jer se koristi za označavanje koja komponenta geom_fig unije je trenutno aktivna. Takva struktura se naziva promjenjiva struktura jer se njene komponente mijenjaju ovisno o vrijednosti oznake aktivne komponente (vrijednosti tipa).

Imajte na umu da bi umjesto komponente tipa tipa int bilo preporučljivo koristiti nabrojani tip. Na primjer, takav

Enum figure_chess ( CIRCLE, BOX, TROANGLE ) ;

Konstante CIRCLE, BOX, TROANGLE će dobiti vrijednosti jednake 0, 1, 2, respektivno. Tip varijable se može deklarirati kao da ima nabrojani tip:

enum tip figure_chess;

U ovom slučaju, C prevodilac će upozoriti programera na potencijalno pogrešne zadatke, kao što je

figura.tip = 40;

Generalno, varijabla strukture će se sastojati od tri dijela: skupa zajedničkih komponenti, oznaka aktivne komponente i dijelova sa promjenjivim komponentama. Opšti oblik strukturne varijable je sljedeći:

Struktura ( zajedničke komponente; oznaka aktivne komponente; unija ( deklaracija komponente 1 ; deklaracija komponente 2 ; ::: deklaracija komponente n ; ) identifikator unije; ) struct-identifier;

Primjer definiranja varijable strukture pod nazivom helth_record

Struktura ( /* opće informacije */ char ime ; /* ime */ int starost; /* starost */ char spol; /* spol */ /* oznaka aktivne komponente */ /* (bračni status) */ enum merital_status ins ; /* varijabilni dio */ unija ( /* neoženjen */ /* bez člana */ struct ( /* vjenčani */ char marripge_date; char supružnika; int no_children; ) brak_info; /* razveden */ char date_divorced; ) marital_info; ) zdravstveni_dosije; enum marital_status ( SINGLE, /* neoženjen */ MARRIGO, /* oženjen */ RAZVOD /* razveden */ ) ;

Komponentama strukture može se pristupiti putem linkova:

helth_record.neme, helth_record.ins, helth_record.marriage_info.marriage_date .

1.2.11. Definiranje objekata i tipova

Kao što je gore spomenuto, sve varijable koje se koriste u C programima moraju biti deklarirane. Tip varijable koja se deklarira ovisi o tome koja se ključna riječ koristi kao specifikacija tipa i da li je deklarator jednostavan identifikator ili kombinacija identifikatora sa pokazivačem (zvjezdica), nizom (uglatim zagradama) ili modifikatorom funkcije (zagrade). .

Prilikom deklarisanja jednostavne varijable, strukture, mješavine ili unije, ili nabrajanja, deskriptor je jednostavan identifikator. Da biste deklarirali pokazivač, niz ili funkciju, identifikator se mijenja u skladu s tim: sa zvjezdicom na lijevoj strani, kvadratom ili zagradama na desnoj strani.

Primjećujemo važnu osobinu jezika C, kada deklarirate, možete koristiti više od jednog modifikatora u isto vrijeme, što omogućava stvaranje mnogo različitih složenih deskriptora tipa.

Međutim, moramo imati na umu da neke kombinacije modifikatora nisu dozvoljene:

Elementi niza ne mogu biti funkcije,

Funkcije ne mogu vratiti nizove ili funkcije.

Prilikom inicijalizacije složenih deskriptora, kvadrat i zagrade (desno od identifikatora) imaju prednost nad zvjezdicom (lijevo od identifikatora). Kvadrat ili zagrade imaju isti prioritet i proširuju se s lijeva na desno. Specifikator tipa se razmatra u zadnjem koraku, kada je deskriptor već u potpunosti interpretiran. Možete koristiti zagrade za promjenu redoslijeda tumačenja po potrebi.

Za tumačenje složenih opisa predlaže se jednostavno pravilo koje zvuči kao "iznutra prema van", a sastoji se od četiri koraka.

1. Počnite od ID-a i pogledajte desno za uglaste zagrade ili zagrade.

2. Ako postoje, onda protumačite taj dio deskriptora i zatim pogledajte lijevo za zvjezdicu.

3. Ako u bilo kojoj fazi na desnoj strani postoji završna zagrada, tada morate prvo primijeniti sva ova pravila unutar zagrada, a zatim nastaviti s tumačenjem.

4. Interpretirajte specifikaciju tipa.

int * (* comp ) (); 6 5 3 1 2 4

U ovom primjeru, varijabla comp (1) je deklarirana kao niz od deset (2) pokazivača (3) na funkcije (4) koje vraćaju pokazivače (5) na cjelobrojne vrijednosti (6).

Char * (* (* var) ()) ; 7 6 4 2 1 3 5

Varijabla var (1) je deklarirana kao pokazivač (2) na funkciju (3) koja vraća pokazivač (4) na niz (5) od 10 elemenata, koji su pokazivači (6) na vrijednosti char.

Pored deklaracija varijabli različitih tipova, moguće je deklarirati i tipove. Ovo se može uraditi na dva načina. Prvi način je da navedete ime oznake kada deklarirate strukturu, uniju ili enum, a zatim koristite to ime u deklaracijama varijable i funkcije kao referencu na tu oznaku. Drugi je korištenje ključne riječi typedef za deklariranje tipa.

Kada je deklarisan sa ključnom reči typedef, identifikator na mestu objekta koji se opisuje je ime tipa podataka koji se razmatra, a ovaj tip se onda može koristiti za deklarisanje varijabli.

Imajte na umu da se bilo koji tip može deklarirati pomoću ključne riječi typedef, uključujući tipove pokazivača, funkcije ili niza. Ime sa ključnom riječi typedef za tipove pokazivača, strukture, unije može se deklarirati prije nego što se ovi tipovi definiraju, ali unutar opsega deklaratora.

typedef double(*MATH)(); /* MATH - ime novog tipa koje predstavlja pokazivač na funkciju koja vraća vrijednosti tipa double */ MATH cos; /* cos pokazivač na funkciju koja vraća vrijednosti tipa double */ /* Može se napraviti ekvivalentna deklaracija */ double (* cos)(); typedef char FIO /* FIO je niz od četrdeset znakova */ FIO osoba; /* Promenljiva person je niz od četrdeset karaktera */ /* Ovo je ekvivalentno deklaraciji */ char person;

Prilikom deklarisanja varijabli i tipova, ovdje su korištena imena tipova (MATH FIO). Pored toga, imena tipova se mogu koristiti u tri druga slučaja: u listi formalnih parametara, u deklaraciji funkcija, u operacijama konverzije tipa i u operaciji sizeof (operacija konverzije tipa).

Imena tipova za osnovne, nabrajanje, strukturu i tipove mješavine su specifikatori tipa za te tipove. Imena tipova za niz i tipove pokazivača funkcije specificiraju se pomoću apstraktnih deskriptora kako slijedi:

apstraktni-deklarator specificatora tipa;

Apstraktni deskriptor je deskriptor bez identifikatora, koji se sastoji od jednog ili više pokazivača, niza ili modifikatora funkcije. Modifikator pokazivača (*) je uvijek specificiran prije identifikatora u deskriptoru, a niz i modifikator funkcije () su uvijek navedeni iza njega. Dakle, da bi se pravilno protumačio apstraktni deskriptor, mora se početi sa impliciranim identifikatorom.

Apstraktni deskriptori mogu biti složeni. Zagrade u složenim apstraktnim specifikacijama određuju redosled interpretacije, baš kao što su to činili kada se tumače složeni specifikacije u deklaracijama.

1.2.12. Inicijalizacija podataka

Kada je varijabla deklarirana, može joj se dati početna vrijednost pričvršćivanjem inicijatora na ručku. Inicijator počinje znakom "=" i ima sljedeće oblike.

Format 1: = pokretač;

Format 2: = ( lista - inicijatori );

Format 1 se koristi prilikom inicijalizacije varijabli osnovnih tipova i pokazivača, a format 2 kada se inicijaliziraju složeni objekti.

Varijabla tol se inicijalizira simbolom "N".

const long megabute = (1024 * 1024);

Nepromjenjiva varijabla megabute se inicijalizira u konstantni izraz nakon čega se ne može promijeniti.

statički int b = (1,2,3,4);

Inicijalizira se dvodimenzionalni niz od b cijelih brojeva; elementima niza se dodjeljuju vrijednosti sa liste. Ista inicijalizacija se može uraditi ovako:

static int b = ( ( 1,2 ), ( 3,4 ) );

Možete izostaviti jednu ili više dimenzija prilikom inicijalizacije niza

static int b typespecifier id [, id] ...

Modifikatori su ključne riječi signed, unsigned, short, long.
Specifikator tipa je ključna riječ char ili int koja specificira tip varijable koja se deklarira.
Identifikator je ime varijable.

Charx; int a, b, c; unsigned long long y;

Kada deklarišete varijablu, možete je inicijalizirati, odnosno dodijeliti joj početnu vrijednost.

int x = 100;

Broj 100 će odmah biti upisan u varijablu x nakon deklaracije. Bolje je deklarirati inicijalizirane varijable u posebnim redovima.

Tipovi podataka. Program u proceduralnim jezicima, kojem C pripada, je opis operacija nad vrijednostima različitih tipova. Tip definira skup vrijednosti koje vrijednost može preuzeti i skup operacija u kojima može sudjelovati.

U jeziku C, tipovi su povezani sa imenima (identifikatorima) vrednosti, odnosno sa varijablama. Varijabla u C je povezana s memorijskom lokacijom. Tip varijable specificira veličinu ćelije, način na koji je njen sadržaj kodiran i dozvoljene transformacije preko vrijednosti ove varijable. Sve varijable moraju biti deklarirane prije nego što se koriste. Svaka varijabla mora biti deklarirana samo jednom.

Opis se sastoji od specificatora tipa iza kojeg slijedi lista varijabli. Varijable na listi su odvojene zarezima. Tačka i zarez se stavlja na kraj opisa.

Primjeri opisa:

char a,b; /* Varijable a i b imaju tip

char */intx; /* Varijabla x - tip int

*/ char simbol; /" Opisane su varijable sym tipa char;

*/ int count.num; /* broj i broj tipa int */

Varijablama se mogu dodijeliti početne vrijednosti unutar njihovih deklaracija. Ako ime varijable prati znak jednakosti i konstanta, ta konstanta služi kao inicijalizator.

primjeri: char backch = "\0";

Razmotrite osnovne tipove u jeziku C.

int - cijeli broj ("cijeli broj"). Vrijednosti ovog tipa su cijeli brojevi iz nekog ograničenog raspona (obično - 32768 do 32767). Opseg je određen veličinom ćelije za tip i specifičan je za mašinu. Osim toga, postoje pomoćne riječi koje se mogu koristiti sa tipom int: short int ("kratki cijeli broj" - "kratki cijeli broj"), unsigned int ("unsigned integer" - "unsigned integer"), long int ("dugi cijeli broj" "), koji smanjuju ili, obrnuto, proširuju raspon predstavljanja brojeva.

char- karakter ("karakter"). Važeća vrijednost za ovaj tip je jedan znak (ne smije se brkati s tekstom!). Simbol je napisan apostrofima.

primjeri:"x" 2 "?"

Jedan znak zauzima jedan bajt u memoriji računara. U stvari, ne pohranjuje se znak, već broj - kod karaktera (od 0 do 255). U posebnim tablicama kodiranja su naznačeni svi važeći znakovi i njihovi odgovarajući kodovi.

U jeziku C dozvoljeno je korištenje tipa char kao numeričkog tipa, odnosno izvođenje operacija sa kodom znakova, uz korištenje specificatora cjelobrojnog tipa u zagradama - (int).

float - real (pokretni zarez). Vrijednosti ovog tipa su brojevi, ali, za razliku od char i int, nisu nužno cijeli brojevi.

12,87 -316,12 -3,345e5 12,345e-15

realni brojevi dvostruke - dvostruke preciznosti. Ovaj tip je sličan tipu float, ali ima mnogo veći raspon vrijednosti (na primjer, za programski sistem Borland-C od 1.7E-308 do 1.7E+308 umjesto raspona od 3.4E-38 do 3.4E+38 za plutajući tip). Međutim, povećanje opsega i tačnosti predstavljanja brojeva dovodi do smanjenja brzine izvršavanja programa i rasipničkog korišćenja računarske RAM memorije.

Obratite pažnju na nedostatak tipa stringa na ovoj listi. Ne postoji poseban tip u C-u koji se može koristiti za opisivanje stringova. Umjesto toga, stringovi su predstavljeni kao niz char elemenata. To znači da će se znakovi u nizu nalaziti u susjednim memorijskim ćelijama.

Treba napomenuti da je posljednji element niza karakter \0. Ovo je "nul karakter" i koristi se u C za označavanje kraja niza. Null karakter nije cifra 0; nije ispisan i ima broj 0 u tablici ASCII kodova. Prisustvo nul znaka znači da bi broj ćelija u nizu trebao biti. najmanje jedan više od broja znakova koji će biti pohranjeni u memoriji.

Dajemo primjer korištenja stringova.

Program 84

#include main()

scanf("%s",string) ;

printf("%s",string);

Ovaj primjer opisuje niz od 31 memorijske lokacije, od kojih 30 može sadržavati jedan char element. Unosi se kada se pozove funkcija scanf("%s",string);. "&" nedostaje kada se navodi niz znakova.

Pointers. Pointer - neki simbolički prikaz adrese memorijske ćelije dodijeljene varijabli.

Na primjer, &name je pokazivač na varijablu imena;

Ovdje & je operacija dobivanja adrese. Stvarna adresa je broj, a simbolički prikaz adrese i imena je konstanta pokazivača.

C jezik takođe ima varijable pokazivača. Kao što je vrijednost char varijable znak, a vrijednost int varijable cijeli broj, vrijednost varijable pokazivača je adresa neke vrijednosti.

Ako pokazivaču damo ime ptr, možemo napisati sljedeću izjavu:

ptr = /* dodjeljuje adresu imena ptr */

U ovom slučaju kažemo da je prt "pokazivač na" ime. Razlika između dvije notacije ptr i &name je u tome što je prt varijabla dok je &name konstanta. Ako je potrebno, možete učiniti da varijabla ptr pokazuje na neki drugi objekt:

ptr= /* ptr ukazuje na bah, a ne na ime */

Sada je vrijednost varijable prt adresa varijable bah. Pretpostavimo da znamo da varijabla ptr sadrži referencu na varijablu bah. Zatim, da biste pristupili vrijednosti ove varijable, možete koristiti operaciju “indirektnog adresiranja” * :

val = *ptr; /* određuje vrijednost na koju ukazuje ptr */ Posljednje dvije izjave zajedno su ekvivalentne sljedećem:

Dakle, kada je znak & ime varijable slijedi, rezultat operacije je adresa navedene varijable; &nurse daje adresu varijable nurse; kada nakon * slijedi pokazivač na varijablu, rezultat operacije je vrijednost smještena u memorijsku lokaciju na navedenoj adresi.

primjer: medicinska sestra = 22;

ptr= /* pokazivač na medicinsku sestru */

Rezultat je dodjela vrijednosti 22 varijabli val.

Nije dovoljno reći da je neka varijabla pokazivač. Osim toga, morate reći na koji tip varijable se ovaj pokazivač odnosi. Razlog je taj što različite vrste varijabli zauzimaju različit broj memorijskih lokacija, dok neke operacije pokazivača zahtijevaju da znate količinu dodijeljene memorije.

Primjeri ispravan opis pokazivača: int *pi; char*pc;

Specifikacija tipa specificira tip varijable na koju upućuje pokazivač, a simbol * definira samu varijablu kao pokazivač. Opis tipa int *pi; kaže da je pi pokazivač i da je *pi int vrijednost.

C jezik pruža mogućnost definiranja imena tipova podataka. Bilo kojem tipu podataka može se dati ime korištenjem definicije typedef i ovo ime se može koristiti kasnije pri opisivanju objekata.

Format: typedef<старый тип> <новый тип> primjer: typedef long LARGE; /* veliki tip je definiran, što je ekvivalentno dugom */

Typedef ne uvodi nikakve nove tipove, on samo dodaje novo ime za već postojeći tip. Varijable deklarirane na ovaj način imaju potpuno ista svojstva kao i eksplicitno deklarirane varijable. Preimenovanje tipa se koristi za uvođenje smislenih ili skraćenih naziva tipova, što poboljšava razumljivost programa i za poboljšanje prenosivosti programa (nazivi istog tipa podataka mogu se razlikovati na različitim računarima).

Operacije. Jezik C odlikuje se širokim spektrom operacija (više od 40). Ovdje razmatramo samo glavne, tabelu. 3.3.

Aritmetičke operacije. Oni uključuju

Dodatak(+),

Oduzimanje (binarno) (-),

množenje (*),

divizija (/),

Ostatak od cjelobrojnog dijeljenja (%),

Oduzimanje (unarno) (-) .

U jeziku C je prihvaćeno pravilo: ako su dividenda i djelitelj tipa int, tada se podjela vrši u potpunosti, odnosno razlomak rezultata se odbacuje.

Kao i obično, u izrazima se operacije množenja, dijeljenja i ostatka izvode prije sabiranja i oduzimanja. Zagrade se koriste za promjenu redoslijeda akcija.

Program 85

#include

5 = -3 + 4 * 5 - 6; printf("%d\n",s);

s = -3 + 4%5 - 6; printf("%d\n",s);

s = -3 * 4% - 6/5; printf("%d\n",s);

s= (7 + 6)%5/2; printf("%d\n",s);

Rezultat izvršenja programa: 11 1 0 1

Tabela 3.3 Starost i redoslijed izvođenja operacija

Osnove jezika

Kod programa i podaci kojima program manipuliše upisuju se u memoriju računara kao niz bitova. Bit- ovo je najmanji element kompjuterske memorije, sposoban da pohrani ili 0 ili 1. Na fizičkom nivou, to odgovara električnom naponu, koji, kao što znate, ili postoji ili nema. Gledajući sadržaj memorije računara, videćemo nešto poput:
...

Vrlo je teško shvatiti takav niz, ali ponekad moramo manipulirati takvim nestrukturiranim podacima (obično se potreba za tim javlja prilikom programiranja drajvera hardverskih uređaja). C++ pruža skup operacija za rad sa bitnim podacima. (O tome ćemo govoriti u 4. poglavlju.)
Po pravilu, neka struktura se nameće nizu bitova, grupirajući bitove u bajtova I riječi. Bajt sadrži 8 bita, a riječ 4 bajta ili 32 bita. Međutim, definicija riječi može biti različita na različitim operativnim sistemima. Prelazak na 64-bitne sisteme sada počinje, a sistemi sa 16-bitnim riječima su nedavno bili uobičajeni. Iako je veličina bajta ista u velikoj većini sistema, i dalje ćemo ove vrijednosti nazivati ​​specifičnim za stroj.

Sada možemo govoriti o, na primjer, bajtu na adresi 1040 ili riječi na adresi 1024 i reći da bajt na adresi 1032 nije jednak bajtu na adresi 1040.
Međutim, ne znamo šta predstavlja bilo koji bajt, bilo koja mašinska riječ. Kako razumjeti značenje određenih 8 bitova? Da bismo nedvosmisleno protumačili značenje ovog bajta (ili riječi, ili drugog skupa bitova), moramo znati vrstu podataka predstavljenih ovim bajtom.
C++ pruža skup ugrađenih tipova podataka: karakterni, cijeli broj, realni i skup kompozitnih i proširenih tipova: nizovi, nizovi, kompleksni brojevi. Osim toga, za radnje s ovim podacima postoji osnovni skup operacija: poređenje, aritmetičke i druge operacije. Tu su i prijelazi, petlje, uvjetni iskazi. Ovi elementi jezika C++ čine skup gradivnih blokova od kojih možete izgraditi sistem bilo koje složenosti. Prvi korak u savladavanju C++-a je učenje ovih osnovnih elemenata, čemu je i posvećen Drugi dio ove knjige.
Poglavlje 3 pruža pregled ugrađenih i proširenih tipova i mehanizama pomoću kojih možete kreirati nove tipove. U osnovi, to je, naravno, mehanizam klasa uveden u Odjeljku 2.3. Poglavlje 4 bavi se izrazima, ugrađenim operatorima i njihovim prioritetom, te konverzijama tipova. Poglavlje 5 govori o jezičkim uputstvima. Konačno, Poglavlje 6 predstavlja standardnu ​​biblioteku C++ i tipove kontejnera, vektor i asocijativni niz.

3. C++ tipovi podataka

Ovo poglavlje daje pregled ugrađen, ili osnovno, tipovi podataka jezika C++. Počinje sa definicijom literals, kao što je 3,14159 ili pi, a zatim i pojam varijabla, ili objekt, koji mora biti jedan od tipova podataka. Ostatak poglavlja posvećen je detaljnom opisu svakog ugrađenog tipa. Takođe navodi izvedene tipove podataka za nizove i nizove koje obezbeđuje standardna biblioteka C++. Iako ovi tipovi nisu elementarni, veoma su važni za pisanje pravih C++ programa i želimo da čitaoca upoznamo sa njima što je ranije moguće. Nazvat ćemo takve tipove podataka proširenje C++ osnovni tipovi.

3.1. Literali

C++ ima skup ugrađenih tipova podataka za predstavljanje cijelih i realnih brojeva, znakova, kao i tip podataka „niz znakova“ koji se koristi za pohranjivanje nizova znakova. Tip char se koristi za pohranjivanje pojedinačnih znakova i malih cijelih brojeva. Zauzima jedan bajt mašine. Tipovi short, int i long su dizajnirani da predstavljaju cijele brojeve. Ovi tipovi se razlikuju samo u rasponu vrijednosti koje brojevi mogu uzeti, a specifične veličine navedenih tipova zavise od implementacije. Obično kratko je pola mašinske riječi, int je jedna riječ, dugo je jedna ili dvije riječi. Na 32-bitnim sistemima, int i long su generalno iste veličine.

Tipovi float, double i long double su za brojeve s pomičnim zarezom i razlikuju se po preciznosti reprezentacije (broj značajnih cifara) i rasponu. Tipično, float (jednostruka preciznost) uzima jednu mašinsku riječ, dvostruka (dvostruka preciznost) dvije, a long double (proširena preciznost) tri.
char, short, int i long zajedno čine cjelobrojni tipovi, što zauzvrat može biti iconic(potpisano) i nepotpisan(nepotpisano). Kod tipova sa znakom, krajnji lijevi bit se koristi za pohranjivanje predznaka (0 je plus, 1 je minus), a preostali bitovi sadrže vrijednost. U neoznačenim tipovima, svi bitovi se koriste za vrijednost. 8-bitni znakovni znak može predstavljati vrijednosti od -128 do 127, a neoznačeni znak može predstavljati vrijednosti od 0 do 255.

Kada se u programu naiđe na broj, kao što je 1, ovaj broj se poziva doslovno, ili doslovna konstanta. Konstanta, jer ne možemo promijeniti njenu vrijednost, i literal, jer se njegova vrijednost pojavljuje u tekstu programa. Literal je vrijednost koja se ne može adresirati: iako je, naravno, zapravo pohranjena u memoriji mašine, ne postoji način da se zna njegova adresa. Svaki literal ima specifičan tip. Dakle, 0 je tipa int, 3.14159 je tipa double.

Literali cjelobrojnog tipa mogu se pisati u decimalnom, oktalnom i heksadecimalnom obliku. Evo kako broj 20 izgleda kao decimalni, oktalni i heksadecimalni literal:

20 // decimalni
024 // oktal
0x14 // hex

Ako literal počinje sa 0, tretira se kao oktalno, ako počinje sa 0x ili 0X, tretira se kao heksadecimalno. Uobičajena notacija se tretira kao decimalni broj.
Prema zadanim postavkama, svi literali s cijelim brojevima su potpisani int. Možete eksplicitno definirati cjelobrojni literal da je tipa long dodavanjem slova L na kraj broja (koriste se i velika slova L i mala slova l, ali zbog čitljivosti, mala slova se ne bi trebala koristiti: lako je pomiješati s

jedan). U (ili u) na kraju definiše literal kao unsigned int, a dva slova UL ili LU kao neoznačeno dugo. Na primjer:

128u 1024UL 1L 8Lu

Literali koji predstavljaju realne brojeve mogu se pisati ili sa decimalnim zarezom ili u naučnoj (eksponencijalnoj) notaciji. Po defaultu su tipa double. Da biste eksplicitno odredili tip float, morate koristiti sufiks F ili f, a za duge duple - L ili l, ali samo u slučaju zapisa sa decimalnim zarezom. Na primjer:

3.14159F 0/1f 12.345L 0.0 3el 1.0E-3E 2.1.0L

Riječi true i false su literali tipa bool.
Reprezentabilne literalne karakterne konstante se pišu kao jednostruki navodnici. Na primjer:

"a" "2" "," " " (razmak)

Specijalni znakovi (tabulator, vraćanje nosioca) se zapisuju kao izlazne sekvence. Definirane su sljedeće sekvence (počinju sa obrnutom kosom crtom):

Novi red \n horizontalni jezičak \t backspace \b vertikalni jezičak \v povratak nosača \r ubacivanje lista \f zvono \a obrnuta kosa crta \\ pitanje \? jednostruki navodnik \"dvostruki navodnik \"

Opšti izlazni niz je oblika \ooo, gdje je ooo jedna do tri oktalne cifre. Ovaj broj je kod karaktera. Koristeći ASCII kod, možemo napisati sljedeće literale:

\7 (poziv) \14 (novi red) \0 (null) \062("2")

Literal znakova može imati prefiks L (na primjer, L"a"), što znači poseban tip wchar_t, dvobajtni tip znakova koji se koristi za pohranjivanje znakova nacionalnih abeceda ako se ne mogu predstaviti uobičajenim tipom char , kao što su kineska ili japanska slova.
Literal stringa je niz znakova zatvoren u dvostruke navodnike. Takav literal može se prostirati na nekoliko redova, u kom slučaju se na kraju reda stavlja obrnuta kosa crta. Posebni znakovi mogu biti predstavljeni njihovim vlastitim izlaznim sekvencama. Evo primjera string literala:

"" (prazan niz) "a" "\nCC\options\tfile.\n" "višeredni \ string literal signalizira njegov \ nastavak sa obrnutom kosom crtom"

U stvari, string literal je niz znakovnih konstanti, gdje je, prema konvenciji jezika C i C++, posljednji element uvijek poseban znak sa kodom 0 (\0).
Literal "A" specificira jedan znak A, a string literal "A" specificira niz od dva elementa: "A" i \0 (prazan znak).
Pošto postoji tip wchar_t, postoje literali ovog tipa, označeni, kao iu slučaju pojedinačnih znakova, prefiksom L:

L "široki literalni niz"

Literal stringa tipa wchar_t je niz znakova istog tipa koji se završava nulom.
Ako se dva ili više string literala (tipa char ili wchar_t) pojavljuju u redu u testu programa, kompajler ih spaja u jedan string. Na primjer, sljedeći tekst

"dva" "neki"

će proizvesti niz od osam znakova - dva i završni null karakter. Rezultat spajanja nizova različitih tipova je nedefiniran. ako napišete:

// ovo nije dobra ideja "dva" L"neki"

onda će na nekom računaru rezultat biti neki smisleni niz, a na drugom može ispasti nešto sasvim drugo. Programi koji koriste karakteristike implementacije određenog kompajlera ili operativnog sistema nisu prenosivi. Snažno obeshrabrujemo upotrebu ovakvih struktura.

Vježba 3.1

Objasnite razliku u definicijama sljedećih literala:

(a) "a", L"a", "a", L"a" (b) 10, 10u, 10L, 10uL, 012, 0*C (c) 3.14, 3.14f, 3.14L

Vježba 3.2

Koje su greške u primjerima u nastavku?

(a) "Ko ide s F\144rgusom?\014" (b) 3.14e1L (c) "dva" L"neki" (d) 1024f (e) 3.14UL (f) "komentar u više redaka"

3.2. Varijable

Zamislite da rješavamo problem dizanja 2 na stepen 10. Pišemo:

#include
int main() (
// prvo rješenje
cout<< "2 raised to the power of 10: ";
cout<< 2 * 2 * 2 * 2 * 2 * 2 * 2 * 2 * 2 * 2;
cout<< endl;
return 0;
}

Problem je riješen, iako smo morali više puta provjeriti da li se literal 2 zaista ponavlja 10 puta. Nismo pogriješili u pisanju ovog dugačkog niza dvojki, a program je vratio tačan rezultat - 1024.
Ali sada je zatraženo da podignemo 2 na stepen 17, a zatim na 23. Izuzetno je nezgodno svaki put mijenjati tekst programa! I, što je još gore, vrlo je lako pogriješiti ako napišete dodatna dva ili ga preskočite... Ali šta ako treba da odštampate tabelu stepena dvojke od 0 do 15? Ponovite 16 puta dva reda koja imaju zajednički oblik:

Cout<< "2 в степени X\t"; cout << 2 * ... * 2;

gdje se X uzastopno povećava za 1, a traženi broj literala zamjenjuje se umjesto tačke?

Da, obavili smo posao. Malo je vjerovatno da će kupac ulaziti u detalje, jer je zadovoljan rezultatom. U stvarnom životu ovaj pristup često funkcionira, štoviše, opravdan je: problem se rješava daleko ne na najelegantniji način, već u željenom vremenskom okviru. Traženje ljepše i kompetentnije opcije može biti nepraktičan gubitak vremena.

U ovom slučaju “metoda grube sile” daje tačan odgovor, ali kako je neugodno i dosadno rješavati problem na ovaj način! Znamo tačno koje korake treba preduzeti, ali sami koraci su jednostavni i monotoni.

Uključivanje složenijih mehanizama za isti zadatak, po pravilu, značajno produžava vrijeme pripremne faze. Osim toga, što se koriste složeniji mehanizmi, veća je vjerovatnoća grešaka. Ali i pored neizbježnih grešaka i pogrešnih poteza, upotreba „visoke tehnologije“ može donijeti prednosti u brzini razvoja, a da ne govorimo o činjenici da ove tehnologije uvelike proširuju naše mogućnosti. I – šta je zanimljivo! Sam proces odlučivanja može postati privlačan.
Vratimo se našem primjeru i pokušajmo "tehnološki poboljšati" njegovu implementaciju. Možemo koristiti imenovani objekat da pohranimo vrijednost snage do koje želimo povećati svoj broj. Također, umjesto ponavljajućeg niza literala, možemo koristiti operator petlje. Evo kako će to izgledati:

#include
int main()
{
// objekti tipa int
int vrijednost = 2;
int pow = 10;
cout<< value << " в степени "
<< pow << ": \t";
int res = 1;
// operator petlje:
// ponoviti izračun rez
// dok cnt ne bude veći od pow
za (int cnt=1; cnt<= pow; ++cnt)
res = res * vrijednost;
cout<< res << endl;
}

value, pow, res i cnt su varijable koje vam omogućavaju pohranjivanje, modificiranje i preuzimanje vrijednosti. Naredba petlje for ponavlja vrijeme pow niza rezultata izračunavanja.
Bez sumnje, napravili smo mnogo fleksibilniji program. Međutim, to još uvijek nije funkcija. Da biste dobili stvarnu funkciju koja se može koristiti u bilo kojem programu za izračunavanje stepena broja, potrebno je istaknuti opći dio proračuna i postaviti određene vrijednosti kao parametre.

int pow(int val, int exp) (za (int res = 1; exp > 0; --exp) res = res * val; vrati res; )

Sada neće biti teško dobiti bilo koji stepen željenog broja. Evo kako se implementira naš posljednji zadatak - ispisati tablicu potencija dva od 0 do 15:

#include eksterni int pow(int,int); int main() (int val = 2; int exp = 15;
cout<< "Степени 2\n";
za (int cnt=0; cnt<= exp; ++cnt)
cout<< cnt << ": "
<< pow(val, cnt) << endl;
return 0;
}

Naravno, naša pow() funkcija još uvijek nije dovoljno opća i nije dovoljno pouzdana. Ne može da radi na realnim brojevima, pogrešno podiže brojeve na negativan stepen - uvek vraća 1. Rezultat podizanja velikog broja na veliki stepen možda neće stati u int promenljivu, i tada će se vratiti neka nasumična pogrešna vrednost. Vidite koliko teško može biti pisati funkcije koje su namijenjene širokoj upotrebi? Mnogo je teže nego implementirati određeni algoritam koji ima za cilj rješavanje određenog problema.

3.2.1. Šta je varijabla

Varijabilna, ili objekat- ovo je imenovana oblast memorije kojoj imamo pristup iz programa; možete staviti vrijednosti tamo i zatim ih dohvatiti. Svaka C++ varijabla ima specifičan tip koji karakterizira veličinu i lokaciju te memorijske oblasti, raspon vrijednosti koje može pohraniti i skup operacija primjenjivih na tu varijablu. Evo primjera definiranja pet objekata različitih tipova:

int student_count; dupla plata; bool on_loan; strins street_address; char delimiter;

Varijabla, poput literala, ima određeni tip i pohranjuje svoju vrijednost u nekom području memorije. Adresabilnost- to je ono što doslovno nedostaje. Postoje dvije vrijednosti povezane s varijablom:

• sama vrijednost, ili r-vrijednost (od pročitana vrijednost - vrijednost za čitanje), koja je pohranjena u ovoj memorijskoj oblasti i inherentna je i promjenljivoj i literalnoj;
• vrijednost adrese memorijskog područja povezanog s promjenljivom, ili l-vrijednost (od vrijednosti lokacije - vrijednost lokacije) - mjesto gdje je pohranjena r-vrijednost; pripada samo objektu.

U izrazu

Ch = ch - "0";

varijabla ch je i lijevo i desno od simbola dodjele. Na desnoj strani je pročitana vrijednost (ch i literal znakova "0"): podaci povezani s promjenljivom čitaju se iz odgovarajuće memorijske oblasti. Na lijevoj strani je vrijednost lokacije: rezultat oduzimanja se stavlja u memorijsko područje povezano s promjenljivom ch. Općenito, lijevi operand operatora dodjeljivanja mora biti l-vrijednost. Ne možemo napisati sljedeće izraze:

// greške pri kompilaciji: vrijednosti na lijevoj strani nisu l-vrijednosti // greška: literal nije l-vrijednost 0 = 1; // greška: aritmetički izraz nije l-vrijednost plata + plata * 0,10 = nova_plata;

Operator definicije varijable dodjeljuje memoriju za to. Budući da objekt ima samo jedno memorijsko područje povezano s njim, takav operator se može pojaviti samo jednom u programu. Ako se varijabla definirana u jednoj izvornoj datoteci mora koristiti u drugoj, nastaju problemi. Na primjer:

// file module0.C // definira fileName objekt string fileName; // ... postavi fileName na vrijednost
// module1.C datoteka
// koristi fileName objekt
// nažalost, ne kompajlira:
// Ime datoteke nije definirano u modulu1.C
ifstream ulazna_datoteka(ime datoteke);

C++ zahtijeva da objekt bude poznat prije nego mu se prvi put pristupi. To je zbog potrebe da se osigura da se objekt pravilno koristi prema njegovom tipu. U našem primjeru, module1.C će uzrokovati grešku kompilacije jer ime datoteke nije definirano u njemu. Da bismo izbjegli ovu grešku, moramo reći kompajleru o već definiranoj varijabli fileName. Ovo se radi pomoću izjave deklaracije varijable:

// file module1.C // koristi objekt fileName // fileName je deklariran, tj. program prima
// informacije o ovom objektu bez njegove sekundarne definicije
eksterni string fileName; ifstream input_file(ime datoteke)

Deklaracija varijable govori kompajleru da je objekat sa datim imenom i datim tipom definisan negdje u programu. Memorija se ne dodjeljuje za varijablu kada je deklarirana. (Ključna riječ extern je razmatrana u Odjeljku 8.2.)
Program može sadržavati bilo koji broj deklaracija iste varijable, ali se može definirati samo jednom. Takve deklaracije se zgodno stavljaju u datoteke zaglavlja, uključujući ih u module koji ih zahtijevaju. Tako možemo pohraniti informacije o objektima na jednom mjestu i pružiti pogodnost modifikacije ako je potrebno. (Više ćemo o datotekama zaglavlja govoriti u odjeljku 8.2.)

3.2.2. Ime varijable

ime varijable, ili identifikator, može se sastojati od latiničnih slova, cifara i znaka donje crte. Velika i mala slova u nazivima se razlikuju. Jezik C++ ne ograničava dužinu identifikatora, ali upotreba predugačkih imena kao što je gosh_this_is_an_impossibly_name_to_type je nezgodna.
Neke riječi su ključne riječi u C++ i ne mogu se koristiti kao identifikatori; Tabela 3.1 daje potpunu njihovu listu.

Tabela 3.1. Ključne riječi C++

Kako biste tekst vašeg programa učinili razumljivijim, preporučujemo da slijedite općeprihvaćene konvencije za imenovanje objekata:

• ime varijable se obično piše malim slovima, na primjer indeks (za poređenje: Indeks je ime tipa, a INDEX je konstanta definirana pomoću direktive preprocesora #define);
• identifikator mora imati neko značenje, objašnjavajući svrhu objekta u programu, na primjer: datum_rođenja ili plata;

ako se takvo ime sastoji od nekoliko riječi, kao što je datum_rođenja, tada je uobičajeno da se riječi odvoje podvlakom (datum_rođenja) ili svaka slijedeća riječ piše velikim slovima (datum rođenja). Primećeno je da programeri koji su navikli na objektno orijentisani pristup preferiraju pisanje reči velikim slovom, dok oni_koji_su_napisali_C često koriste znak donje crte. Koja je od ove dvije metode bolja, stvar je ukusa.

3.2.3. Definicija objekta

U svom najjednostavnijem slučaju, operator definicije objekta sastoji se od specificator tipa I naziv objekta i završava se tačkom i zarezom. Na primjer:

dupla plata; dupla nadnica; int mjesec; int dan; int godina; nepotpisana duga udaljenost;

Možete definirati više objekata istog tipa u jednom iskazu. U ovom slučaju, njihova imena su navedena odvojena zarezima:

Dvostruka plata, nadnica; int mjesec, dan, godina; nepotpisana duga udaljenost;

Jednostavno definiranje varijable ne postavlja njenu početnu vrijednost. Ako je objekt definiran kao globalni, C++ specifikacija jamči da će biti inicijaliziran na null. Ako je varijabla lokalna ili dinamički alocirana (pomoću novog operatora), njena početna vrijednost nije definirana, odnosno može sadržavati neku nasumične vrijednosti.
Korišćenje ovakvih varijabli je vrlo česta greška, a takođe ju je teško uočiti. Preporučuje se eksplicitno navesti početnu vrijednost objekta, barem u slučajevima kada nije poznato može li se objekt inicijalizirati. Mehanizam klase uvodi koncept zadanog konstruktora, koji se koristi za dodeljivanje podrazumevanih vrednosti. (Već smo govorili o ovome u odjeljku 2.3. Nastavit ćemo govoriti o default konstruktorima malo kasnije u odjeljcima 3.11 i 3.15, gdje ćemo raspravljati o stringovima i složenim klasama iz standardne biblioteke.)

int main() ( // neinicijalizirani lokalni objekt int ival;
// objekt tipa string je inicijaliziran
// zadani konstruktor
string project;
// ...
}

Početna vrijednost se može specificirati direktno u izrazu definicije varijable. U C++-u su dozvoljena dva oblika inicijalizacije varijable - eksplicitna, koristeći operator dodjeljivanja:

Intival = 1024; string project = "Fantasia 2000";

i implicitno, sa početnom vrijednošću navedenom u zagradama:

Intival(1024); string project("Fantasia 2000");

Obje opcije su ekvivalentne i postavljaju početne vrijednosti za cjelobrojnu varijablu ival na 1024 i za niz projekta da bude "Fantasia 2000".
Eksplicitna inicijalizacija se također može koristiti kada se varijable definiraju kao lista:

Dvostruka plata = 9999,99, plata = plata + 0,01; int mjesec = 08; dan=07, godina=1955;

Varijabla postaje vidljiva (i važeća u programu) čim je definirana, tako da možemo inicijalizirati varijablu plaće sa zbirom novodefinirane varijable plaće sa nekom konstantom. Dakle, definicija je:

// ispravno, ali besmisleno int bizarre = bizarre;

sintaktički je validan, iako besmislen.
Ugrađeni tipovi podataka imaju posebnu sintaksu za postavljanje null vrijednosti:

// ival je postavljen na 0, a dval na 0.0 int ival = int(); double dval = double();

U sljedećoj definiciji:

// int() se primjenjuje na svaki od 10 elemenata vektora< int >ivec(10);

svaki od deset elemenata vektora je inicijaliziran sa int(). (Već smo govorili o vektorskoj klasi u Odjeljku 2.8. Vidi odjeljak 3.10 i Poglavlje 6 za više o tome.)
Varijabla se može inicijalizirati izrazom bilo koje složenosti, uključujući pozive funkcija. Na primjer:

#include #include
dupla cijena = 109,99, popust = 0,16;
dvostruka prodajna_cijena(cijena * popust);
string pet("bore"); extern int get_value(); intval = get_value();
unsigned abs_val = abs(val);

abs() je standardna funkcija koja vraća apsolutnu vrijednost parametra.
get_value() je neka korisnički definirana funkcija koja vraća cjelobrojnu vrijednost.

Vježba 3.3

Koja od sljedećih definicija varijable sadrži sintaksičke greške?

(a) int auto = 1024, auto = 2048; (b) int ival = ival; (c) int ival(int()); (d) dupla plata = plata = 9999,99; (e) cin >> int input_value;

Vježba 3.4

Objasnite razliku između l-vrijednosti i r-vrijednosti. Navedite primjere.

Vježba 3.5

Pronađite razlike u korištenju varijabli name i student u prvom i drugom redu svakog primjera:

(a) ime vanjskog stringa; stringname("vježba 3.5a"); (b) eksternvektor studenti; vektor studenti;

Vježba 3.6

Koja imena objekata nisu dozvoljena u C++? Promijenite ih tako da budu sintaktički ispravni:

(a) int double = 3,14159; (b) vektor< int >_; (c) string namespace; (d) hvatanje žice-22; (e) char 1_or_2 = "1"; (f) float Float = 3,14f;

Vježba 3.7

Koja je razlika između sljedećih definicija globalnih i lokalnih varijabli?

String global_class; int global_int; int main() (
int local_int;
string lokalna_klasa; // ...
}

3.3. Pointers

Pokazivači i dinamička alokacija memorije su ukratko predstavljeni u odjeljku 2.2. Pointer je objekat koji sadrži adresu drugog objekta i omogućava vam da manipulišete tim objektom indirektno. Obično se pokazivači koriste za rad sa dinamički kreiranim objektima, za konstruisanje povezanih struktura podataka kao što su povezane liste i hijerarhijska stabla, i za prosleđivanje velikih objekata – nizova i objekata klasa – kao parametara funkcijama.
Svaki pokazivač je povezan s nekom vrstom podataka, a njihova interna reprezentacija ne ovisi o internom tipu: i veličina memorije koju zauzima objekt tipa pokazivača i raspon vrijednosti su isti za njih. Razlika je u tome kako kompajler tretira adresirani objekt. Pokazivači na različite tipove mogu imati istu vrijednost, ali memorijska lokacija na kojoj se nalaze odgovarajući tipovi može biti različita:

• pokazivač na int koji sadrži adresnu vrijednost 1000 usmjerava se na memorijsku oblast 1000-1003 (na 32-bitnom sistemu);
• pokazivač na double koji sadrži adresnu vrijednost 1000 usmjerava se na memorijsku oblast 1000-1007 (na 32-bitnom sistemu).

Evo nekoliko primjera:

int *ip1, *ip2; kompleks *cp; string*pstring; vektor *pvec; duplo *dp;

Pokazivač je označen zvjezdicom ispred imena. Prilikom definisanja varijabli liste, zvjezdica mora prethoditi svakom pokazivaču (vidi gore: ip1 i ip2). U primjeru ispod, lp je pokazivač na objekt tipa long, a lp2 je objekt tipa long:

Dugi *lp, lp2;

U sljedećem slučaju, fp se tumači kao float objekat, a fp2 je pokazivač na njega:

Float fp, *fp2;

Operator dereferenciranja (*) može biti odvojen razmacima od imena, pa čak i direktno pored ključne riječi tipa. Stoga su sljedeće definicije sintaktički ispravne i potpuno ekvivalentne:

//upozorenje: ps2 nije pokazivač na string! string* ps, ps2;

Može se pretpostaviti da su i ps i ps2 pokazivači, iako je pokazivač samo prvi od njih.
Ako je vrijednost pokazivača 0, onda ne sadrži nijednu adresu objekta.
Neka je data varijabla tipa int:

Intival = 1024;

Slijede primjeri definiranja i korištenja pokazivača na int pi i pi2:

//pi inicijaliziran na nultu adresu int *pi = 0;
// pi2 inicijaliziran adresom ival
int *pi2 =
// ispravno: pi i pi2 sadrže adresu ival
pi = pi2;
// pi2 sadrži adresu nula
pi2 = 0;

Pokazivaču se ne može dodijeliti vrijednost koja nije adresa:

// greška: pi ne može biti int pi = ival

Slično, ne možete dodijeliti pokazivač jednog tipa vrijednosti koja je adresa objekta drugog tipa. Ako su definirane sljedeće varijable:

double dval; duplo *ps =

tada će oba izraza dodjeljivanja dolje uzrokovati grešku kompilacije:

// greške pri kompilaciji // nevažeća dodjela tipa podataka: int*<== double* pi = pd pi = &dval;

Nije da varijabla pi ne može sadržavati adresu dval objekta - adrese objekata različitih tipova imaju istu dužinu. Takve operacije miješanja adresa su namjerno zabranjene, jer kompajlerova interpretacija objekata zavisi od tipa pokazivača na njih.
Naravno, ponekad nas zanima vrijednost same adrese, a ne objekta na koji ona ukazuje (recimo da želimo da uporedimo ovu adresu sa nekom drugom). Za rješavanje ovakvih situacija uvodi se poseban void pokazivač koji može ukazivati ​​na bilo koji tip podataka, a sljedeći izrazi će biti ispravni:

// ispravno: void* može sadržavati // adrese bilo kojeg tipa void *pv = pi; pv=pd;

Tip objekta na koji ukazuje void* je nepoznat i ne možemo manipulirati ovim objektom. Sve što možemo učiniti s takvim pokazivačem je dodijeliti njegovu vrijednost drugom pokazivaču ili ga uporediti s nekom vrijednošću adrese. (Više ćemo govoriti o pokazivaču void u odjeljku 4.14.)
Da biste upućivali na objekat koji ima svoju adresu, morate primijeniti operaciju dereferenciranja, ili indirektno adresiranje, označenu zvjezdicom (*). Imaju sljedeće definicije varijabli:

int ival = 1024;, ival2 = 2048; int*pi =

// indirektna dodjela ival ival2 *pi = ival2;
// indirektna upotreba ival kao rvalue i lvalue
*pi = abs(*pi); // ival = abs(ival);
*pi = *pi + 1; // ival = ival + 1;

Kada primijenimo operaciju adrese (&) na objekt tipa int, dobijamo rezultat tipa int*
int*pi =
Ako se ista operacija primeni na objekat tipa int* (pokazivač na int), dobijamo pokazivač na pokazivač na int, tj. int**. int** je adresa objekta koji sadrži adresu objekta tipa int. Dereferenciranjem ppi, dobijamo objekat tipa int* koji sadrži adresu ival. Da biste dobili sam objekat ival, operacija dereferenciranja ppi mora se primijeniti dvaput.

int **ppi = π int *pi2 = *ppi;
cout<< "Значение ival\n" << "явное значение: " << ival << "\n"
<< "косвенная адресация: " << *pi << "\n"
<< "дважды косвенная адресация: " << **ppi << "\n"

Pokazivači se mogu koristiti u aritmetičkim izrazima. Obratite pažnju na sljedeći primjer, gdje dva izraza izvode potpuno različite radnje:

Int i, j, k; int *pi = // i = i + 2
*pi = *pi + 2; // povećaj adresu sadržanu u pi za 2
pi = pi + 2;

Pointeru možete dodati cjelobrojnu vrijednost, a možete i oduzeti od nje. Dodavanje 1 pokazivaču povećava njegovu vrijednost za veličinu memorijskog područja dodijeljenog objektu odgovarajućeg tipa. Ako char zauzima 1 bajt, int 4, a double 8, tada će dodavanje 2 pokazivačima na char, int i double povećati njihovu vrijednost za 2, 8, odnosno 16. Kako se ovo može protumačiti? Ako se objekti istog tipa nalaze u memoriji jedan za drugim, povećanje pokazivača za 1 će uzrokovati da on pokazuje na sljedeći objekt. Stoga se aritmetika pokazivača najčešće koristi u obradi niza; u drugim slučajevima teško da su opravdani.
Evo kako izgleda tipičan primjer korištenja adresne aritmetike kada se iterira preko elemenata niza pomoću iteratora:

intia; int *iter = int *iter_end =
dok (iter != iter_end) (
do_something_with_value(*iter);
++iter;
}

Vježba 3.8

Date su definicije varijabli:

int ival = 1024, ival2 = 2048; int *pi1 = &ival, *pi2 = &ival2, **pi3 = 0;

Šta se događa kada se izvrše sljedeće operacije dodjele? Ima li grešaka u ovim primjerima?

(a) ival = *pi3; (e) pi1 = *pi3; (b) *pi2 = *pi3; (f) ival = *pi1; (c) ival = pi2; (g) pi1 = ival; (d) pi2 = *pi1; (h) pi3 =

Vježba 3.9

Manipulacija pokazivačem je jedan od najvažnijih aspekata C i C++, ali je lako napraviti greške. Na primjer, kod

Pi = pi = pi + 1024;

će gotovo sigurno uzrokovati da pi pokazuje na nasumično područje memorije. Šta radi ovaj operator dodjeljivanja i u kojem slučaju neće rezultirati greškom?

Vježba 3.10

Ovaj program sadrži grešku koja se odnosi na nepravilnu upotrebu pokazivača:

int foobar(int *pi) ( *pi = 1024; povratak *pi; )
int main() (
int*pi2 = 0;
int ival = foobar(pi2);
return 0;
}

u čemu je greška? Kako to mogu popraviti?

Vježba 3.11

Pojavljuju se greške iz prethodne dvije vježbe i dovode do fatalnih posljedica zbog C++-ovog nedostatka validacije vrijednosti pokazivača u vremenu izvođenja. Zašto mislite da takva provjera nije provedena? Možete li ponuditi neke opće smjernice za sigurnije rukovanje pokazivačem?

3.4. Vrste nizova

C++ podržava dva tipa stringova, ugrađeni tip naslijeđen od C-a i string klasu iz standardne biblioteke C++. String klasa pruža mnogo više mogućnosti i stoga je praktičnija za korištenje, ali u praksi često postoje situacije kada trebate koristiti ugrađeni tip ili dobro razumjeti kako on funkcionira. (Jedan primjer bi bio raščlanjivanje opcija komandne linije proslijeđenih funkciji main(). Ovo ćemo pokriti u 7. poglavlju.)

3.4.1. ugrađeni tip stringa

Kao što je već spomenuto, ugrađeni tip stringa proslijeđen je u C++ naslijeđen od C. Niz znakova je pohranjen u memoriji kao niz, a pristupa mu se pomoću pokazivača tipa char*. C standardna biblioteka pruža skup funkcija za manipulaciju stringovima. Na primjer:

// vraća dužinu stringa int strlen(const char*);
// uspoređuje dva niza
int strcmp(const char*, const char*);
// kopira jedan niz u drugi
char* strcpy(char*, const char*);

C standardna biblioteka je dio C++ biblioteke. Da bismo ga koristili, moramo uključiti datoteku zaglavlja:

#include

Pointer na char, pomoću kojeg pristupamo nizu, pokazuje na niz znakova koji odgovaraju stringu. Čak i kada napišemo string literal kao

Const char *st = "Cijena boce vina\n";

kompajler stavlja sve znakove u nizu u niz, a zatim dodjeljuje st adresu prvog elementa u nizu. Kako se može raditi sa stringom koristeći takav pokazivač?
Obično se aritmetika adresa koristi za nabrajanje znakova niza. Budući da se niz uvijek završava nultim karakterom, možete povećati pokazivač za 1 dok sljedeći znak ne bude nul. Na primjer:

Dok (*st++) ( ... )

st se dereferencira i rezultirajuća vrijednost se provjerava da li je istinita. Bilo koja vrijednost različita od nule smatra se istinitom, i stoga se petlja završava kada se dostigne znak sa kodom 0. Operacija povećanja ++ dodaje 1 pokazivaču st i tako ga prebacuje na sljedeći znak.
Evo kako bi mogla izgledati implementacija funkcije koja vraća dužinu niza. Imajte na umu da budući da pokazivač može sadržavati null vrijednost (ne pokazivati ​​ni na što), treba ga provjeriti prije operacije dereferenciranja:

int string_length(const char *st) (int cnt = 0; if (st) while (*st++) ++cnt; return cnt; )

Niz ugrađenog tipa može se smatrati praznim u dva slučaja: ako je pokazivač na niz null (onda uopće nemamo ni jedan niz) ili ako ukazuje na niz koji se sastoji od jednog null karaktera (tj. string koji ne sadrži nijedan značajan karakter).

// pc1 ne adresira nijedan niz znakova char *pc1 = 0; // pc2 adresira null karakter const char *pc2 = "";

Za programera početnika, korištenje nizova ugrađenog tipa prepuno je grešaka zbog preniskog nivoa implementacije i nemogućnosti bez aritmetike adresa. U nastavku ćemo pokazati neke tipične greške početnika. Zadatak je jednostavan: izračunajte dužinu niza. Prva verzija je netačna. Popravi je.

#include const char *st = "Cijena boce vina\n"; int main() (
intlen = 0;
dok (st++) ++len; cout<< len << ": " << st;
return 0;
}

U ovoj verziji, st pokazivač nije dereferenciran. Stoga se ne provjerava jednakost sa 0 karakteru na koji ukazuje st, već sam pokazivač. Pošto je ovaj pokazivač prvobitno imao vrijednost različitu od nule (adresa reda), nikada neće postati nula, a petlja će se izvoditi neograničeno.
U drugoj verziji programa ova greška je eliminisana. Program se uspješno završava, ali rezultat nije tačan. Gdje griješimo ovaj put?

#include const char *st = "Cijena boce vina\n"; int main()
{
intlen = 0;
dok (*st++) ++len; cout<< len << ": " << st << endl;
return 0;
}

Greška je u tome što nakon završetka petlje, pokazivač st ne adresira originalni karakterni literal, već karakter koji se nalazi u memoriji nakon završne nule ovog literala. Bilo šta može biti na ovom mjestu, a izlaz programa će biti nasumični niz znakova.
Možete pokušati popraviti ovu grešku:

St = st - len; cout<< len << ": " << st;

Sada naš program proizvodi nešto značajno, ali ne u potpunosti. Odgovor izgleda ovako:

18: ena boca vina

Zaboravili smo da uzmemo u obzir da završni nul karakter nije uključen u izračunatu dužinu. st bi trebao biti pomjeren za dužinu niza plus 1. Evo konačno ispravne izjave:

St \u003d st - len - 1;

i evo tačnog rezultata:

18: Cijena boce vina

Međutim, ne možemo reći da naš program izgleda elegantno. Operater

St \u003d st - len - 1;

dodano da ispravi grešku napravljenu u ranoj fazi dizajna programa - direktno povećanje st pokazivača. Ova izjava se ne uklapa u logiku programa, a kod je sada teško razumjeti. Popravke ove vrste se često nazivaju zakrpama—nešto dizajnirano da začepi rupu u postojećem programu. Mnogo bolje rješenje bi bilo ponovno promišljanje logike. Jedna opcija u našem slučaju bi bila da definiramo drugi pokazivač inicijaliziran vrijednošću st:

Const char *p = st;

Sada se p može koristiti u petlji dužine, ostavljajući vrijednost st nepromijenjenom:

dok (*p++)

3.4.2. string class

Kao što smo upravo vidjeli, korištenje ugrađenog tipa stringa je sklono greškama i nije baš zgodno zbog činjenice da je implementirano na preniskom nivou. Zbog toga je prilično uobičajeno da se razvije sopstvena klasa ili klase za predstavljanje tipa stringa - skoro svaka kompanija, odeljenje ili pojedinačni projekat imali su sopstvenu implementaciju niza. Šta reći, isto smo radili u prethodna dva izdanja ove knjige! To je dovelo do problema kompatibilnosti i prenosivosti programa. Implementacija standardne string klase od strane standardne biblioteke C++ imala je za cilj da stavi tačku na ovaj izum bicikala.
Pokušajmo odrediti minimalni skup operacija koje klasa string treba da ima:

• inicijalizacija nizom znakova (string ugrađenog tipa) ili drugim objektom tipa string. Ugrađeni tip nema drugu mogućnost;
• kopiranje jednog reda u drugi. Za ugrađeni tip, morate koristiti funkciju strcpy();
• pristup pojedinačnim znakovima niza za čitanje i pisanje. U ugrađenom nizu, ovo se radi pomoću operacije subscript ili indirektnog adresiranja;
• poređenje dva niza za jednakost. Za ugrađeni tip koristite funkciju strcmp();
• spajanje dva niza, dobivajući rezultat ili kao treći niz ili umjesto jednog od originalnih. Za ugrađeni tip koristi se funkcija strcat(), ali da biste dobili rezultat u novom redu, morate koristiti funkcije strcpy() i strcat() u nizu;
• izračunavanje dužine niza. Možete saznati dužinu niza ugrađenog tipa koristeći strlen() funkciju;
• mogućnost saznanja da li je niz prazan. Za ugrađene stringove, dva uslova moraju biti provjerena u tu svrhu: char str = 0; //... if (! str || ! *str) return;

Klasa stringova standardne biblioteke C++ implementira sve ove operacije (i mnogo više, kao što ćemo vidjeti u poglavlju 6). U ovom dijelu ćemo naučiti kako koristiti osnovne operacije ove klase.
Da biste koristili objekte klase string, morate uključiti odgovarajući fajl zaglavlja:

#include

Evo primjera niza iz prethodnog odjeljka, predstavljenog objektom tipa string i inicijaliziranog nizom znakova:

#include string st("Cijena boce vina\n");

Duljinu stringa vraća funkcija člana size() (dužina ne uključuje završni null karakter).

Cout<< "Длина " << st << ": " << st.size() << " символов, включая символ новой строки\n";

Drugi oblik definicije stringa specificira prazan niz:

String st2; // prazan red

Kako znamo da li je niz prazan? Naravno, možete uporediti njegovu dužinu sa 0:

if (! st.size()) // ispravno: prazno

Međutim, postoji i posebna metoda empty() koja vraća true za prazan niz i false za neprazan:

if (st.empty()) // ispravno: prazno

Treći oblik konstruktora inicijalizira objekat tipa string sa drugim objektom istog tipa:

String st3(st);

String st3 je inicijaliziran stringom st. Kako možemo osigurati da se ovi nizovi podudaraju? Koristimo operator poređenja (==):

If (st == st3) // inicijalizacija je uspjela

Kako kopirati jednu liniju u drugu? Sa uobičajenim operatorom dodjele:

st2 = st3; // kopiraj st3 u st2

Za spajanje nizova koristite operator sabiranja (+) ili operator zbrajanja-dodjela (+=). Neka su data dva reda:

String s1("zdravo, "); string s2("svijet\n");

Možemo dobiti treći niz koji se sastoji od konkatenacije prva dva, ovako:

String s3 = s1 + s2;

Ako želimo dodati s2 na kraj s1, moramo napisati:

S1 += s2;

Operacija sabiranja može konkatenirati objekte string klase ne samo među sobom, već i sa nizovima ugrađenog tipa. Možete prepisati gornji primjer tako da posebni znakovi i interpunkcija budu predstavljeni ugrađenim tipom, a značajne riječi su objekti stringa klase:

Const char *pc = ", "; string s1("zdravo"); string s2("svijet");
string s3 = s1 + pc + s2 + "\n";

Takvi izrazi funkcioniraju jer kompajler zna kako automatski pretvoriti objekte ugrađenog tipa u string objekte. Također je moguće jednostavno dodijeliti ugrađeni string objektu stringa:

String s1; const char *pc = "niz znakova"; s1=kom; // desno

Obrnuta transformacija, međutim, ne funkcionira. Pokušaj da se izvrši sljedeća inicijalizacija niza ugrađenog tipa će uzrokovati grešku kompilacije:

Char*str = s1; // greška kompilacije

Da biste izvršili ovu konverziju, morate eksplicitno pozvati funkciju člana sa pomalo čudnim imenom c_str():

Char *str = s1.c_str(); // skoro tačno

Funkcija c_str() vraća pokazivač na niz znakova koji sadrži string objekta string, kao što bi bio u ugrađenom tipu stringa.
Gornji primjer inicijalizacije char *str pokazivača još uvijek nije sasvim ispravan. c_str() vraća pokazivač na const niz kako bi spriječio da se sadržaj objekta direktno modificira preko ovog pokazivača, koji ima tip

Konstantni znak *

(O ključnoj riječi const ćemo govoriti u sljedećem odjeljku.) Ispravna inicijalizacija izgleda ovako:

Const char *str = s1.c_str(); // desno

Pojedinačnim znakovima string objekta, poput ugrađenog tipa, može se pristupiti korištenjem operacije indeksa. Na primjer, evo isječka koda koji zamjenjuje sve tačke podvlakama:

Stringstr("fa.disney.com"); int size = str.size(); za (int ix = 0; ix< size; ++ix) if (str[ ix ] == ".")
str[ix] = "_";

To je sve što smo sada htjeli reći o string klasi. U stvari, ova klasa ima mnogo više zanimljivih svojstava i mogućnosti. Recimo da je prethodni primjer također implementiran pozivanjem jedne funkcije replace():

Zamijeni(str.begin(), str.end(), ".", "_");

replace() je jedan od generičkih algoritama koje smo uveli u Odjeljku 2.8 i biće detaljno obrađen u Poglavlju 12. Ova funkcija iterira u rasponu od begin() do end(), koji vraća pokazivače na početak i kraj string, i zamjenjuje elemente , jednake njegovom trećem parametru, četvrtim.

Vježba 3.12

Potražite greške u sljedećim izjavama:

(a) char ch = "Dugačak i krivudavi put"; (b) int ival = (c) char *pc = (d) string st(&ch); (e) pc = 0; (i) pc = "0";
(f) st = pc; (j) st =
(g) ch = pc; (k) ch = *pc;
(h) pc = st; (l) *pc = ival;

Vježba 3.13

Objasnite razliku u ponašanju sljedećih naredbi petlje:

Dok (st++) ++cnt;
dok (*st++)
++cnt;

Vježba 3.14

Daju se dva semantički ekvivalentna programa. Prvi koristi ugrađeni tip stringa, drugi koristi string klasu: