Lloji me humbjen më të vogël të informacionit i jepet përparësia më e lartë. Nuk duhet të abuzoni me konvertimin e nënkuptuar të tipit, pasi mund të lindin të gjitha llojet e situatave të papritura.

• Konvertimi i qartë në krahasim me të bërë në mënyrë implicite nga programuesi. Ka disa mënyra për ta bërë këtë:

1. Konvertimi në stile C: (noton) a
2. Konvertimi në stile C ++: noton ()

Gjithashtu, konvertimet e tipit mund të kryhen duke përdorur operacionet e mëposhtme:

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

static_cas- kryen konvertimin e llojeve të të dhënave të lidhura. Ky operator hedh lloje sipas rregullave të zakonshme, të cilat mund të kërkohen kur përpiluesi nuk kryen konvertim automatik. Sintaksa do të duket si kjo:

Lloji static_cast<Тип>(nje objekt);

Duke përdorur static_cast, nuk mund të hiqni qëndrueshmërinë nga një ndryshore, por kjo është brenda fuqisë së deklaratës së mëposhtme. const_cast- përdoret vetëm kur është e nevojshme të hiqen konstantet nga objekti. Sintaksa do të duket si kjo:

Lloji iconst_cast< Lloji i> (nje objekt);

reinterpret_cast- përdoret për të kthyer lloje të ndryshme, numra të plotë në një tregues dhe anasjelltas. Nëse shihni fjalën e re "tregues" - mos u shqetësoni! ky është gjithashtu një lloj i të dhënave, por ne nuk do të punojmë me të së shpejti. Sintaksa këtu është e njëjtë si për operatorët e konsideruar më parë:

Lloji iriinterpretojnë_cast< Lloji i> (nje objekt);

dinamik_cast- përdoret për konvertimin e tipit dinamik, zbaton hedhjen e pointerëve ose lidhjeve. Sintaksë:

Lloji idinamike _cast< Lloji i> (nje objekt);

Personazhet e kontrollit

Ju tashmë jeni njohur me disa nga këto "karaktere kontrolli" (për shembull, me \ n). Ata të gjithë fillojnë me një vijë të prapme dhe janë gjithashtu të rrethuar nga thonjëza të dyfishta.

Një ndryshim i rëndësishëm midis gjuhës C dhe gjuhëve të tjera (PL1, FORTRAN, etj.) është mungesa e një parimi të paracaktuar, i cili çon në nevojën për të deklaruar të gjitha variablat e përdorura në program në mënyrë eksplicite së bashku me treguesin e llojeve të tyre përkatëse. .

Deklaratat e ndryshueshme kanë formatin e mëposhtëm:

[memory-class-specifier] specifikues tip-specifier [= iniciator] [, specifikues [= iniciator]] ...

Një përshkrues është një identifikues i një ndryshoreje të thjeshtë ose një konstruksioni më kompleks me kllapa katrore, kllapa ose një yll (një grup ylli).

Një specifikues tipi është një ose më shumë fjalë kyçe që përcaktojnë llojin e ndryshores që deklarohet. Gjuha C ka një grup standard të llojeve të të dhënave që mund të përdoren për të ndërtuar lloje të reja (unike) të të dhënave.

Iniciator - specifikon një vlerë fillestare ose një listë të vlerave fillestare që (të cilat) i caktohen një ndryshoreje kur deklarohet.

Specifikimi i klasës së kujtesës përcaktohet nga një nga katër fjalët kyçe të gjuhës C: auto, extern, regjistër, statik dhe tregon se si do të ndahet memoria për variablin e deklaruar, nga njëra anë, dhe nga ana tjetër, shtrirja e kjo variabël, pra nga cilat pjesë të programit mund t'i referoheni.

1.2.1 Kategoritë e llojeve të të dhënave

Fjalë kyçe për përcaktimin e llojeve bazë të të dhënave

Llojet e numrave të plotë: Llojet lundruese: char float int dyfish i shkurtër i gjatë dyfish i gjatë i nënshkruar i panënshkruar

Një variabël i çdo lloji mund të deklarohet i pamodifikueshëm. Kjo arrihet duke shtuar fjalën kyçe const në specifikuesin e tipit. Objektet Const përfaqësojnë të dhëna vetëm për lexim, d.m.th. kësaj ndryshore nuk mund t'i caktohet një vlerë e re. Vini re se nëse nuk ka lloj-specifikues pas fjalës const, atëherë supozohet specifikuesi i tipit int. Nëse kryefjala const vjen para deklarimit të llojeve të përbëra (arresë, strukturë, përzierje, numërim), atëherë kjo çon në faktin se çdo element duhet të jetë gjithashtu i pamodifikueshëm, d.m.th. mund t'i caktohet një vlerë vetëm një herë.

Const dyfish A = 2,128E-2; konst B = 286; (nënkupton konstancën int B = 286)

Shembujt e deklarimit të të dhënave të përbëra do të diskutohen më poshtë.

1.2.2. Lloji i të dhënave me numër të plotë

Për të përcaktuar të dhënat e një lloji të plotë, përdoren fjalë kyçe të ndryshme që përcaktojnë gamën e vlerave dhe madhësinë e zonës së kujtesës të caktuar për variablat (Tabela 6).

Tabela 6

Vini re se fjalët kyçe të nënshkruara dhe të panënshkruara janë opsionale. Ato tregojnë se si interpretohet biti zero i variablës së deklaruar, pra nëse specifikohet fjala kyçe e panënshkruar, atëherë biti zero interpretohet si pjesë e numrit, përndryshe biti zero interpretohet si i nënshkruar. Nëse fjala kyçe e panënshkruar mungon, ndryshorja numër i plotë konsiderohet e nënshkruar. Në rast se specifikuesi i tipit përbëhet nga lloji i çelësit i nënshkruar ose i panënshkruar dhe më pas vijon identifikuesi i ndryshores, atëherë ai do të konsiderohet si një variabël i tipit int. Për shembull:

I panënshkruar int n; i panënshkruar int b; int c; (nënshkrimi int c nënkuptohet); e panënshkruar d; (nënkupton int d të panënshkruar); nënshkruar f; (nënkuptohet me nënshkrimin f).

Vini re se modifikuesi char përdoret për të përfaqësuar një karakter (nga një grup paraqitjesh karakteresh) ose për të deklaruar vargje literale. Vlera e një objekti të tipit char është një kod (1 bajt në madhësi) që korrespondon me karakterin që duhet të përfaqësohet. Për të përfaqësuar karakteret e alfabetit rus, modifikuesi i llojit të identifikuesit të të dhënave ka formën e shkronjave të panënshkruara, pasi kodet e shkronjave ruse tejkalojnë vlerën 127.

Duhet bërë vërejtja e mëposhtme: gjuha C nuk përcakton një paraqitje të memories dhe një gamë vlerash për identifikuesit me modifikues int dhe int të panënshkruar. Madhësia e kujtesës për një ndryshore me një modifikues int të nënshkruar përcaktohet nga gjatësia e fjalës së makinës, e cila ka madhësi të ndryshme në makina të ndryshme. Pra, në makinat 16-bit, madhësia e fjalës është e barabartë me 2 bajt, në makinat 32-bit, përkatësisht, me 4 bajt, d.m.th. lloji int është ekuivalent me llojet short int, ose long int, në varësi të arkitekturës së kompjuterit të përdorur. Kështu, i njëjti program mund të funksionojë siç duhet në një kompjuter dhe të mos funksionojë siç duhet në një tjetër. Për të përcaktuar gjatësinë e memories së zënë nga një variabël, mund të përdorni funksionin sizeof të gjuhës C, e cila kthen vlerën e gjatësisë së llojit të modifikuesit të specifikuar.

Për shembull:

A = madhësia e (int); b = madhësia (e gjatë int); c = madhësia (e gjatë e panënshkruar); d = madhësia (e shkurtër);

Vini re gjithashtu se konstantet oktale dhe heksadecimal mund të kenë gjithashtu modifikuesin e panënshkruar. Kjo arrihet duke specifikuar parashtesën u ose U pas konstantes; një konstante pa këtë parashtesë konsiderohet e nënshkruar.

Për shembull:

0xA8C (int nënshkruar); 01786l (e nënshkruar gjatë); 0xF7u (int e panënshkruar);

1.2.3. Të dhëna lundruese

Për variablat që përfaqësojnë një numër me pikë lundruese, përdoren modifikuesit e mëposhtëm të tipit: float, double, long double (në disa zbatime të gjuhës C, long double mungon).

Një vlerë float merr 4 bajt. Nga këto, 1 bajt është rezervuar për shenjën, 8 bit për eksponentin e tepërt dhe 23 bit për mantisa. Vini re se pjesa më e rëndësishme e mantisës është gjithmonë 1, kështu që nuk është e mbushur; prandaj, diapazoni i vlerave për variablin e pikës lundruese është afërsisht 3.14E-38 deri në 3.14E + 38.

Një dyshe zë 8 bit në memorie. Formati i tij është i ngjashëm me atë të float. Bitët e memories ndahen si më poshtë: 1 bit për shenjën, 11 bit për eksponentin dhe 52 bit për mantisa. Duke marrë parasysh pjesën e hequr të rendit të lartë të mantisës, diapazoni i vlerave është nga 1.7E-308 në 1.7E + 308.

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

1.2.4. Treguesit

Një tregues është adresa e memories së caktuar për vendosjen e identifikuesit (emri i një ndryshoreje, grupi, strukture ose vargu literal mund të përdoret si identifikues). Në rast se një ndryshore deklarohet si tregues, atëherë ajo përmban një adresë memorie në të cilën mund të gjendet një vlerë skalare e çdo lloji. Me rastin e deklarimit të një variabli të tipit të treguesit, është e nevojshme të përcaktohet lloji i objektit të të dhënave, adresa e të cilit do të përmbajë variablin dhe emrin e treguesit, të paraprirë nga një yll (ose një grup yjesh). Formati i deklaratës së treguesit:

tip-specifikues [modifikues] * specifikues.

Specifikuesi i tipit specifikon llojin e objektit dhe mund të jetë i çdo lloji bazë, lloj strukture, përzierje (kjo do të diskutohet më poshtë). Duke specifikuar fjalën kyçe void në vend të specifikuesit të tipit, është e mundur në një mënyrë të veçantë të shtyhet specifikimi i llojit të cilit i referohet treguesi. Një variabël i deklaruar si një tregues për të tipit void mund të përdoret për t'iu referuar një objekti të çdo lloji. Sidoqoftë, për të qenë në gjendje të kryeni veprime aritmetike dhe logjike në tregues ose në objektet në të cilat ata tregojnë, është e nevojshme të përcaktohet në mënyrë eksplicite lloji i objekteve gjatë kryerjes së secilit operacion. Përkufizime të tilla të tipit mund të kryhen duke përdorur një operacion cast.

Fjalët kyçe konst, afër, larg, i madh mund të përdoren si modifikues kur deklaroni një tregues. Fjala kyçe const tregon se treguesi nuk mund të ndryshohet në program. Madhësia e një variabli të deklaruar si tregues varet nga arkitektura e kompjuterit dhe nga modeli i memories së përdorur për të cilin do të kompilohet programi. Treguesit për lloje të ndryshme të dhënash nuk duhet të kenë të njëjtën gjatësi.

Fjalët kyçe afër, larg, i madh mund të përdoren për të modifikuar madhësinë e treguesit.

I panënshkruar int * a; / * ndryshorja a është një tregues për llojin int të panënshkruar (numra të plotë të panënshkruar) * / double * x; / * ndryshorja x tregon llojin e të dhënave me pikë lundruese me saktësi të dyfishtë * / char * fuffer; / * deklarohet një tregues me emrin fuffer i cili tregon një variabël të tipit char * / double nomer; void * adresat; adresat = & nomer; (dopio *) adresat ++; / * Ndryshorja adresa deklarohet si tregues për një objekt të çdo lloji. Prandaj, mund t'i caktohet adresa e çdo objekti (& është operacioni i llogaritjes së një adrese). Megjithatë, siç u përmend më lart, asnjë operacion aritmetik nuk mund të kryhet në një tregues derisa lloji i të dhënave që ai tregon të përcaktohet në mënyrë eksplicite. Kjo mund të bëhet duke përdorur një operacion cast (double *) për të kthyer adresat në një tregues për të dyfishuar dhe më pas për të rritur adresën. * / konst * dr; / * Ndryshorja dr deklarohet si tregues për një shprehje konstante, d.m.th. vlera e një treguesi mund të ndryshojë gjatë ekzekutimit të programit, por vlera në të cilën tregon jo. * / char i panënshkruar * const w = & obj. / * Ndryshorja w deklarohet si një tregues konstant për të dhënat e tipit char unsigned. Kjo do të thotë që gjatë gjithë programit do të tregojmë në të njëjtën zonë të memories. Përmbajtja e kësaj zone mund të ndryshohet. * /

1.2.5. Variablat e numëruar

Një variabël që mund të marrë një vlerë nga një listë vlerash quhet një ndryshore e numëruar ose një numërim.

Një deklaratë numërimi fillon me fjalën kyçe enum dhe ka dy formate prezantimi.

Formati 1. enum [enum-tag-emër] (numërimi-lista) përshkruesi [, përshkruesi ...];

Formati 2. përshkruesi enum enum-tag-emri [, përshkruesi ..];

Një deklaratë numërimi specifikon llojin e një ndryshoreje numërimi dhe përcakton një listë të konstantave të emërtuara të quajtura listë e numërimit. Vlera e çdo emri liste është një numër i plotë.

Një variabël i llojit të numërimit mund të marrë vlerat e njërës prej konstanteve të emërtuara në listë. Konstantet e listave të emërtuara janë të tipit int. Kështu, memoria që korrespondon me variablin e numërimit është memoria e nevojshme për të akomoduar një vlerë int.

Variablat e tipit enum mund të përdoren në shprehjet e indeksit dhe si operandë në operacionet aritmetike dhe relacionale.

Në formatin e parë 1, emrat dhe vlerat e numërimit specifikohen në listën e numërimit. Emri i etiketës opsionale enumeration është një identifikues që emërton etiketën e numërimit të përcaktuar nga lista e numërimit. Përshkruesi emërton një ndryshore numëruese. Më shumë se një ndryshore e llojit të numërimit mund të specifikohet në një deklaratë.

List-numërimi përmban një ose më shumë konstruksione të formës:

identifikues [= shprehje konstante]

Çdo identifikues emërton një element të numërimit. Të gjitha ID-të në listën e numërimit duhet të jenë unike. Në mungesë të një shprehjeje konstante, identifikuesi i parë korrespondon me vlerën 0, identifikuesi tjetër me vlerën 1, e kështu me radhë. Emri i një konstante numërimi është ekuivalent me vlerën e saj.

Identifikuesi i lidhur me një shprehje konstante merr vlerën e specifikuar nga ajo shprehje konstante. Një shprehje konstante duhet të jetë e tipit int dhe mund të jetë pozitive ose negative. Identifikuesit tjetër në listë i caktohet një vlerë shprehje konstante plus 1 nëse ai identifikues nuk ka një shprehje konstante. Përdorimi i anëtarëve të numërimit duhet t'u bindet rregullave të mëposhtme:

1. Një variabël mund të përmbajë vlera të dyfishta.

2. Identifikuesit në një listë numërimi duhet të jenë të dallueshëm nga të gjithë identifikuesit e tjerë në të njëjtin shtrirje, duke përfshirë emrat e ndryshoreve të zakonshme dhe identifikuesit nga listat e tjera të numërimit.

3. Emrat e llojeve të numërimit duhet të jenë të ndryshëm nga emrat e tjerë të llojeve, strukturave dhe përzierjeve të numërimit në të njëjtin shtrirje.

4. Vlera mund të ndjekë elementin e fundit të listës së numërimit.

Një javë (SUB = 0, / * 0 * / VOS = 0, / * 0 * / POND, / * 1 * / VTOR, / * 2 * / SRED, / * 3 * / HETV, / * 4 * / PJAT / * 5 * /) rab_ned;

Në këtë shembull, deklarohet etiketa e numëruar javë, me grupin përkatës të vlerave, dhe ndryshorja rab_ned deklarohet të jetë e tipit week.

Formati i dytë përdor emrin e etiketës së numërimit për t'iu referuar një lloji numërimi që është përcaktuar diku tjetër. Emri i etiketës së numërimit duhet t'i referohet një etikete numërimi të përcaktuar tashmë brenda fushëveprimit aktual. Për shkak se etiketa enum është deklaruar diku tjetër, numërimi nuk është i pranishëm në deklaratë.

Në deklarimin e një treguesi për një lloj të dhënash të numërimit dhe deklarimin e tipareve për llojet e numërimit, mund të përdorni emrin e një etikete numërimi përpara se të përcaktohet ai etiketë numërimi. Sidoqoftë, përkufizimi i një numërimi duhet t'i paraprijë çdo veprimi të treguesit të përdorur ndaj llojit të deklaratës typedef. Një deklaratë pa një listë të mëvonshme përshkruesish përshkruan një etiketë, ose, nëse mund të them kështu, një model numërimi.

1.2.6. Vargjeve

Vargjet janë një grup elementësh të të njëjtit lloj (double, float, int, etj.). Nga deklarimi i një vargu, përpiluesi duhet të marrë informacion për llojin e elementeve të grupit dhe numrin e tyre. Një deklaratë grupi ka dy formate:

përshkruesi i tipit specifikues [konstante - shprehje];

doreza e specifikuesit të tipit;

Një përshkrues është një identifikues i grupit.

Specifikuesi i tipit specifikon llojin e elementeve të grupit të deklaruar. Elementet e grupit nuk mund të jenë funksione dhe elemente të pavlefshme.

Shprehja konstante me kllapa specifikon numrin e elementeve në grup. Shprehja e konstitit mund të hiqet kur deklarohet një grup në rastet e mëposhtme:

Kur deklarohet, grupi inicializohet,

Vargu deklarohet si parametër formal i funksionit,

Në gjuhën C, përcaktohen vetëm vargje njëdimensionale, por meqenëse një element i grupit mund të jetë një grup, ju gjithashtu mund të përcaktoni vargje shumëdimensionale. Ato formalizohen nga një listë e shprehjeve konstante që ndjekin identifikuesin e grupit, me secilën shprehje konstante të mbyllur në kllapat e veta katrore.

Çdo shprehje konstante në kllapa katrore përcakton numrin e elementeve për një dimension të caktuar të vargut, kështu që një deklaratë dydimensionale e vargut përmban dy shprehje konstante, një tredimensionale, e kështu me radhë. Vini re se në gjuhën C, elementi i parë i një grupi ka një indeks të barabartë me 0.

Int a; / * e përfaqësuar si një matricë a a a a a a * / dyfish b; / * vektor i 10 elementeve të tipit të dyfishtë * / int w = ((2, 3, 4), (3, 4, 8), (1, 0, 9));

Shembulli i fundit deklaron një grup w. Listat e mbyllura në kllapa kaçurrelë korrespondojnë me vargjet e vargjeve; nëse nuk ka kllapa, inicializimi nuk do të kryhet si duhet.

Në gjuhën C, mund të përdorni feta grupesh, si në gjuhët e tjera të nivelit të lartë (PL1, etj.), Sidoqoftë, një sërë kufizimesh vendosen në përdorimin e fetave. Seksionet formohen duke hequr një ose më shumë palë kllapa katrore. Çiftet e kllapave katrore mund të hidhen vetëm nga e djathta në të majtë dhe në mënyrë strikte në mënyrë të njëpasnjëshme. Seksionet e vargjeve përdoren në organizimin e procesit llogaritës në funksionet e gjuhës C, të zhvilluara nga përdoruesi.

Nëse, gjatë thirrjes së një funksioni, shkruhet s, atëherë vargu zero i vargut s do të kalohet.

Kur hyni në grupin b, mund të shkruani, për shembull, b dhe do të kalohet një vektor me katër elementë, dhe qasja në b do të japë një grup dydimensional prej 3 me 4. Ju nuk mund të shkruani b, duke nënkuptuar se një vektor do të jetë kaloi, sepse kjo nuk përputhet me kufizimin e vendosur në seksionet e përdorimit të grupit.

Një shembull i deklarimit të një grupi karakteresh.

char str = "deklarimi i një grupi karakteresh";

Vini re se ka një element më shumë në një karakter literal, pasi elementi i fundit është sekuenca e arratisjes "\ 0".

1.2.7. Strukturat

Strukturat janë një objekt i përbërë që përmban elementë të çdo lloji, përveç funksioneve. Ndryshe nga një grup, i cili është një objekt homogjen, struktura mund të jetë heterogjene. Lloji i strukturës përcaktohet nga një procesverbal i formularit:

struct (lista e përkufizimeve)

Struktura duhet të përmbajë të paktën një komponent. Përkufizimi i strukturave është si më poshtë:

përshkrues i tipit të të dhënave;

ku tipi i të dhënave tregon llojin e strukturës për objektet e përcaktuara në përshkruesit. Në formën e tyre më të thjeshtë, përshkruesit janë identifikues ose vargje.

Struktura (x dyfishtë, y;) s1, s2, sm; struct (int viti; char mole, dita;) date1, date2;

Variablat s1, s2 përcaktohen si struktura, secila prej të cilave përbëhet nga dy komponentë x dhe y. Ndryshorja sm përkufizohet si një grup prej nëntë strukturash. Secila prej dy variablave date1, date2 përbëhet nga tre komponentë vit, molë, ditë. > p> Ekziston një mënyrë tjetër për të lidhur një emër me një lloj strukture, ajo bazohet në përdorimin e etiketës së strukturës. Një etiketë strukture është e ngjashme me një etiketë të numëruar. Etiketa e strukturës përcaktohet si më poshtë:

etiketa struct (lista e përshkrimeve;);

ku etiketa është një identifikues.

Në shembullin më poshtë, ID-ja e studentit përshkruhet si një etiketë strukture:

Nxënësi strukt (emri char; int id, mosha; char prp;);

Etiketa e strukturës përdoret për të deklaruar më pas strukturat e një lloji të caktuar në formën:

struct identifikuesit e listës së etiketave;

struct Studeut st1, st2;

Përdorimi i etiketave të strukturës është i nevojshëm për të përshkruar strukturat rekursive. Përdorimi i etiketave të strukturës rekursive është diskutuar më poshtë.

Nyja e strukturës (të dhënat int; nyja e strukturës * tjetër;) st1_nyja;

Etiketa e strukturës së nyjeve është me të vërtetë rekursive pasi përdoret në përshkrimin e vet, d.m.th. në formalizimin e treguesit të ardhshëm. Strukturat nuk mund të jenë drejtpërdrejt rekursive, d.m.th. një strukturë nyje nuk mund të përmbajë një komponent që është një strukturë nyje, por çdo strukturë mund të ketë një komponent që është një tregues për llojin e saj, siç është bërë në shembullin e mësipërm.

Komponentët e strukturës aksesohen duke specifikuar emrin e strukturës dhe në vijim, të ndarë me një pikë, emrin e komponentit të zgjedhur, për shembull:

St1.emri = "Ivanov"; st2.id = st1.id; st1_node.data = st1.moshë;

1.2.8. Shoqatat (përzierjet)

Një bashkim është i ngjashëm me një strukturë, megjithatë, në çdo kohë të caktuar, vetëm një nga elementët e bashkimit mund të përdoret (ose, me fjalë të tjera, të jetë i përgjegjshëm). Lloji i bashkimit mund të specifikohet si më poshtë:

Bashkimi (përshkrimi i elementit 1; ... përshkrimi i elementit n;);

Karakteristika kryesore e bashkimit është se e njëjta zonë memorie ndahet për secilin nga elementët e deklaruar, d.m.th. ato mbivendosen. Megjithëse qasja në këtë zonë të memories është e mundur duke përdorur cilindo element, elementi për këtë qëllim duhet të zgjidhet në mënyrë që rezultati të mos jetë i pakuptimtë.

Anëtarët e sindikatës aksesohen në të njëjtën mënyrë si strukturat. Etiketa union mund të zyrtarizohet në të njëjtën mënyrë si etiketa e strukturës.

Bashkimi përdoret për qëllimet e mëposhtme:

Inicializimi i objektit të memories së përdorur, nëse në një moment të caktuar vetëm një objekt nga shumë është aktiv;

Interpretoni paraqitjen bazë të një objekti të një lloji sikur objektit t'i ishte caktuar një lloj tjetër.

Kujtesa që korrespondon me një variabël të llojit të bashkimit përcaktohet nga sasia e nevojshme për të akomoduar anëtarin më të gjatë të bashkimit. Kur përdoret një element më i shkurtër, një variabël e tipit union mund të përmbajë memorie të papërdorur. Të gjithë elementët e bashkimit ruhen në të njëjtën zonë memorie, duke filluar nga e njëjta adresë.

Union (char fio; char adres; int vozrast; int telefon;) informoj; bashkim (int ax; char al;) ua;

Kur përdorni objektin infor të tipit union, mund të përpunoni vetëm elementin që ka marrë vlerën, d.m.th. pasi t'i caktohet një vlerë elementit inform.fio, nuk ka kuptim t'i referohemi elementeve të tjerë. Kombinimi i ua lejon akses të veçantë në bajtin e poshtëm ua.al dhe atë të sipërm ua.al të numrit ua.ax me dy bajtë.

1.2.9. Fushat bit

Anëtari i strukturës mund të jetë një fushë biti që ofron akses në pjesët individuale të memories. Fushat bit nuk mund të deklarohen jashtë strukturave. Ju gjithashtu nuk mund të organizoni grupe fushash bit dhe nuk mund të aplikoni operacionin e përcaktimit të adresës në fusha. Në përgjithësi, lloji i një strukture me një fushë bit specifikohet si më poshtë:

Struktura (identifikuesi i panënshkruar 1: gjatësia e fushës 1; identifikuesi i panënshkruar 2: gjatësia e fushës 2;)

gjatësia - fushat përcaktohen si shprehje me numër të plotë ose konstante. Kjo konstante përcakton numrin e biteve të caktuara në fushën përkatëse. Një fushë me gjatësi zero tregon shtrirjen me kufirin e fjalës tjetër.

Struct (i panënshkruar a1: 1; i panënshkruar a2: 2; i panënshkruar a3: 5; i panënshkruar a4: 2;) prim;

Strukturat Bitfield mund të përmbajnë gjithashtu komponentë karakteresh. Komponentë të tillë vendosen automatikisht në kufijtë e duhur të fjalëve dhe disa pjesë të fjalëve mund të mbeten të papërdorura.

1.2.10. Variabla me strukturë të ndryshueshme

Shumë shpesh, disa objekte programi i përkasin të njëjtës klasë, që ndryshojnë vetëm në disa detaje. Konsideroni, për shembull, paraqitjen e formave gjeometrike. Informacioni i përgjithshëm rreth formave mund të përfshijë elementë të tillë si zona, perimetri. Megjithatë, informacioni përkatës për dimensionet gjeometrike mund të ndryshojnë në varësi të formës së tyre.

Konsideroni një shembull në të cilin informacioni rreth formave gjeometrike paraqitet bazuar në përdorimin e kombinuar të strukturës dhe bashkimit.

Figura e strukturës (zona e dyfishtë, perimetri; / * komponentët e zakonshëm * / lloji int; / * atributi i komponentit * / bashkimi / * numërimi i përbërësve * / (rrezja e dyfishtë; / * rrethi * / dyfishi a; / * drejtkëndëshi * / dyfishi b ; / * trekëndësh * /) gjeom_fig;) fig1, fig2;

Në përgjithësi, çdo objekt i figurës do të përbëhet nga tre komponentë: zona, perimetri, lloji. Komponenti i tipit quhet etiketa e komponentit aktiv sepse përdoret për të treguar se cili komponent i bashkimit geom_fig është aktualisht aktiv. Një strukturë e tillë quhet strukturë e ndryshueshme sepse përbërësit e saj ndryshojnë në varësi të vlerës së etiketës së komponentit aktiv (vlera e tipit).

Vini re se në vend të komponentit tip të tipit int, do të ishte e këshillueshme të përdorni një tip të numëruar. Për shembull, të tilla

Njerëz figura_shah (RRETH, KUTI, TREKËNDËSH);

Konstantat CIRCLE, BOX, TRIANGLE do të marrin respektivisht vlerat 0, 1, 2. Variabla tip mund të deklarohet se ka një tip të numëruar:

shifër enum_lloji shahu;

Në këtë rast, përpiluesi C do të paralajmërojë programuesin për caktime të mundshme të gabuara, si p.sh.

figura.lloji = 40;

Në përgjithësi, një ndryshore e strukturës do të përbëhet nga tre pjesë: një grup përbërësish të zakonshëm, një etiketë përbërëse aktive dhe një pjesë me komponentë të ndryshueshëm. Forma e përgjithshme e një strukture të ndryshueshme është si më poshtë:

Struktura (komponentët e zakonshëm; etiketa e komponentit aktiv; bashkimi (përshkrimi i komponentit 1; përshkrimi i komponentit 2; ::: përshkrimi i komponentit n;) identifikuesi i bashkimit;) identifikuesi i strukturës;

Një shembull i përcaktimit të një ndryshoreje strukture të quajtur helth_record

Struktura (/ * informacion i përgjithshëm * / emri i karakterit; / * emri * / mosha int; / * mosha * / seksi i karakterit; / * gjinia * / / * etiketa e komponentit aktiv * / / * (statusi martesor) * / numër merital_status ; / * pjesë e ndryshueshme * / bashkim (/ * beqar * / / * nuk ka komponentë * / struct (/ * i martuar * / char marripge_date; char spouse_name; int no_children;) wedding_info; / * i divorcuar * / char data_divorced;) marital_info; ) rekordi_shëndetësor; enum marital_status (BASHKËR, / * beqar * / MARRIGO, / * i martuar * / I DIVORUR / * i divorcuar * /);

Ju mund t'i referoheni përbërësve të strukturës duke përdorur lidhjet:

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

1.2.11. Përcaktimi i objekteve dhe llojeve

Siç u përmend më lart, të gjitha variablat e përdorur në programet C duhet të deklarohen. Lloji i ndryshores së deklaruar varet nga cila fjalë kyçe përdoret si specifikues i tipit dhe nëse specifikuesi është një identifikues i thjeshtë ose një kombinim i një identifikuesi me një modifikues tregues (yll), një grup (kllapa katrore), ose një funksion (kllapa ).

Kur deklaroni një ndryshore të thjeshtë, strukturë, përzierje ose bashkim, ose një numërim, një përshkrues është një identifikues i thjeshtë. Për të deklaruar një tregues, grup ose funksion, identifikuesi modifikohet në përputhje me rrethanat: me një yll në të majtë, katror ose kllapa në të djathtë.

Vini re një veçori të rëndësishme të gjuhës C, kur deklaroni më shumë se një modifikues mund të përdoret njëkohësisht, gjë që bën të mundur krijimin e shumë përshkruesve të ndryshëm të tipit kompleks.

Sidoqoftë, duhet të mbahet mend se disa kombinime të modifikuesve nuk lejohen:

Elementet e grupit nuk mund të jenë funksione,

Funksionet nuk mund të kthejnë vargje ose funksione.

Kur inicializohen përshkruesit kompleksë, kllapat katrore dhe kllapat (në të djathtë të identifikuesit) kanë përparësi ndaj yllit (në të majtë të identifikuesit). Kllapat ose kllapat kanë të njëjtën përparësi dhe zgjerohen nga e majta në të djathtë. Specifikuesi i tipit merret parasysh në hapin e fundit, kur specifikuesi tashmë është interpretuar plotësisht. Ju mund të përdorni kllapa për të ndryshuar rendin e interpretimit sipas nevojës.

Për interpretimin e përshkrimeve komplekse, propozohet një rregull i thjeshtë, i cili tingëllon si "nga brenda jashtë" dhe përbëhet nga katër hapa.

1. Filloni me një identifikues dhe shikoni në të djathtë për të parë nëse ka kllapa ose kllapa.

2. Nëse janë, atëherë interpretoni këtë pjesë të përshkruesit dhe më pas shikoni majtas për një yll.

3. Nëse në ndonjë fazë në të djathtë ka një kllapë mbyllëse, atëherë së pari është e nevojshme të zbatohen të gjitha këto rregulla brenda kllapave, dhe më pas të vazhdohet interpretimi.

4. Interpretoni specifikuesin e tipit.

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

Në këtë shembull, ndryshorja comp (1) deklarohet si një grup prej dhjetë (2) treguesish (3) në funksionet (4) duke i kthyer treguesit (5) në vlerat e numrave të plotë (6).

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

Ndryshorja var (1) deklarohet si një tregues (2) në një funksion (3) që kthen një tregues (4) në një grup (5) me 10 elementë, të cilët janë tregues (6) për vlerat char.

Përveç deklarimit të variablave të llojeve të ndryshme, është e mundur të deklarohen edhe lloje. Kjo mund të bëhet në dy mënyra. Mënyra e parë është të jepni një emër tag kur deklaroni një strukturë, bashkim ose numërim, dhe më pas përdorni atë emër në deklaratat e variablave dhe funksioneve si referencë për atë etiketë. E dyta është përdorimi i fjalës kyçe typedef për të deklaruar llojin.

Kur deklarohet me fjalën kyçe typedef, identifikuesi në vend të objektit që përshkruhet është emri i llojit të të dhënave që merret në konsideratë dhe më pas ky lloj mund të përdoret për të deklaruar variablat.

Vini re se çdo lloj mund të deklarohet duke përdorur fjalën kyçe typedef, duke përfshirë tipet e treguesve, funksioneve ose grupeve. Një emër me fjalën kyçe typedef për tipet e treguesit, strukturës, bashkimit mund të deklarohet përpara se të përcaktohen këto lloje, por brenda fushëveprimit të deklaruesit.

Typedef double (* MATH) (); / * MATH - emri i tipit të ri që përfaqëson një tregues në një funksion që kthen vlera të dyfishta * / MATH cos; / * cos është një tregues për një funksion që kthen vlerat e tipit double * / / * Mund të bëhet një deklaratë ekuivalente * / double (* cos) (); typedef char FIO / * FIO - grup prej dyzet karakteresh * / person FIO; / * Personi i ndryshueshëm është një grup prej dyzet karakteresh * / / * Kjo është e barabartë me deklarimin * / person char;

Gjatë deklarimit të variablave dhe llojeve, këtu janë përdorur emrat e tipave (MATH FIO). Për më tepër, emrat e tipave mund të përdoren në tre raste të tjera: në listën e parametrave formalë, në deklarimin e funksioneve, në operacionet e tipit casting dhe në operacionin sizeof (operacioni i tipit casting).

Emrat e llojeve për llojet bazë, llojet e numërimit, strukturat dhe përzierjet janë specifikuesit e tipit për ato lloje. Emrat e tipave për treguesit e grupeve dhe llojet e funksioneve janë specifikuar duke përdorur përshkruesit abstraktë si më poshtë:

tip-specifikues abstrakt-përshkrues;

Një abstrakt përshkruesi është një përshkrues pa një identifikues që përbëhet nga një ose më shumë tregues, vargje ose modifikues funksioni. Modifikuesi i treguesit (*) jepet gjithmonë përpara identifikuesit në përshkrues, dhe modifikuesit e vargut dhe funksionit () specifikohen gjithmonë pas tij. Kështu, për të interpretuar saktë një përshkrues abstrakt, duhet të filloni me një identifikues të nënkuptuar.

Përshkruesit abstraktë mund të jenë të ndërlikuar. Kllapat në përshkruesit kompleksë abstraktë përcaktojnë rendin e interpretimit, ashtu siç bënë kur interpretonin përshkruesit kompleksë në deklarata.

1.2.12. Inicializimi i të dhënave

Kur deklaroni një ndryshore, mund t'i caktoni një vlerë fillestare duke i bashkangjitur një iniciator përshkruesit. Iniciatori fillon me një shenjë "=" dhe ka format e mëposhtme.

Formati 1: = iniciator;

Formati 2: = (lista - iniciatorët);

Formati 1 përdoret kur inicializohen variabla të llojeve dhe treguesve bazë, dhe formati 2 përdoret kur inicializohen objektet e përbëra.

Variabla tol inicializohet me "N".

konst i gjatë megabute = (1024 * 1024);

Ndryshorja e pamodifikueshme megabute inicializohet me një shprehje konstante pas së cilës nuk mund të ndryshohet.

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

Inicializohet një grup dy-dimensionale me numra të plotë b; elementëve të grupit u caktohen vlera nga lista. I njëjti inicializim mund të bëhet si më poshtë:

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

Kur inicializoni një grup, mund të hiqni një ose më shumë dimensione

static int b type_ identifikues specifikues [, identifikues] ...

Modifikuesit - fjalë kyçe të nënshkruara, të panënshkruara, të shkurtra, të gjata.
Specifikuesi i tipit është një fjalë kyçe char ose int që përcakton llojin e ndryshores që deklarohet.
Identifikuesi është emri i ndryshores.

Char x; int a, b, c; i panënshkruar i gjatë i gjatë y;

Kur deklaroni një ndryshore, mund të inicializoni, domethënë t'i caktoni një vlerë fillestare.

Int x = 100;

Kur deklarohet, numri 100 do të shkruhet menjëherë në ndryshoren x. Është më mirë të deklarohen variablat e inicializuar në rreshta të veçantë.

Llojet e të dhënave. Një program në gjuhët procedurale, të cilit C i përket, është një përshkrim i operacioneve mbi vlera të llojeve të ndryshme. Një lloj përcakton grupin e vlerave që një vlerë mund të marrë dhe grupin e operacioneve në të cilat ajo mund të marrë pjesë.

Në C, llojet shoqërohen me emrat (identifikuesit) e vlerave, domethënë me variabla. Një qelizë memorie shoqërohet me një variabël në gjuhën C. Lloji i një ndryshoreje specifikon madhësinë e qelizës, metodën e kodimit të përmbajtjes së saj dhe transformimet e lejuara mbi vlerën e kësaj ndryshore. Të gjitha variablat duhet të deklarohen përpara përdorimit të tyre. Çdo variabël duhet të deklarohet vetëm një herë.

Përshkrimi përbëhet nga një specifikues tipi i ndjekur nga një listë variablash. Variablat në listë ndahen me presje. Në fund të përshkrimit vendoset një pikëpresje.

Shembuj përshkrimesh:

char a, b; / * Variablat a dhe b janë të tipit

char * / intх; / * Variabli x - i tipit int

* / char sym; / "Përshkruhen variablat sym të tipit char;

* / int count.num; / * numri dhe numri i tipit int * /

Variablave mund t'u caktohen vlera fillestare brenda deklaratave të tyre. Nëse emri i ndryshores ndiqet nga një shenjë e barabartë dhe një konstante, atëherë ajo konstante shërben si iniciator.

Shembuj: char backch = "\ 0";

Le të shqyrtojmë llojet kryesore në gjuhën C.

int - e tërë ("numër i plotë"). Vlerat e këtij lloji janë numra të plotë nga një gamë e kufizuar (zakonisht nga 32768 në 32767). Gama përcaktohet nga madhësia e qelizës për llojin dhe varet nga kompjuteri specifik. Përveç kësaj, ka fjalë të veçanta që mund të përdoren me llojin int: short int ("short integer"), unsigned int ("numër i plotë i panënshkruar" - "numër i plotë i panënshkruar"), long int ("numër i plotë i gjatë" ), të cilat shkurtojnë ose, anasjelltas, zgjeroni gamën e paraqitjes së numrave.

karakter- karakter ("karakter"). Vlera e vlefshme për këtë lloj është një karakter (të mos ngatërrohet me tekstin!). Personazhi është shkruar me apostrofa.

Shembuj:"x" 2 "?"

Në kujtesën e kompjuterit, një karakter zë një bajt. Në fakt, nuk ruhet një karakter, por një numër - një kod karakteri (nga 0 në 255). Të gjithë karakteret e vlefshme dhe kodet e tyre përkatëse tregohen në tabela të veçanta të kodimit.

Në gjuhën C, lejohet të përdoret lloji char si numerik, domethënë të kryeni veprime me kodin e karakterit, duke përdorur specifikuesin e llojit të plotë në kllapa - (int).

float - real (pikë lundruese). Vlerat e këtij lloji janë numra, por ndryshe nga char dhe int, ato nuk janë domosdoshmërisht numra të plotë.

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

numra realë me saktësi të dyfishtë. Ky lloj është i ngjashëm me llojin float, por ka një gamë shumë më të gjerë vlerash (për shembull, për sistemin e programimit Borland-C nga 1.7E-308 në 1.7E + 308 në vend të diapazonit nga 3.4E-38 në 3.4E + 38 për tipin float). Sidoqoftë, një rritje në diapazonin dhe saktësinë e paraqitjes së numrave çon në një ulje të shpejtësisë së ekzekutimit të programit dhe përdorimin e kotë të RAM-it të kompjuterit.

Vini re mungesën e një lloji vargu në këtë listë. Nuk ka asnjë lloj të veçantë në C që mund të përdoret për të përshkruar vargjet. Në vend të kësaj, vargjet përfaqësohen si një grup elementesh char. Kjo do të thotë që karakteret në varg do të vendosen në vendndodhje të afërta të memories.

Duhet të theksohet se elementi i fundit i grupit është karakteri \ 0. Është një karakter null dhe përdoret në C për të shënuar fundin e një rreshti. Karakteri null nuk është shifra 0; nuk printohet dhe numërohet në tabelën ASCII me 0. Prania e karakterit null nënkupton që numri i qelizave në grup duhet të jetë. të paktën një më shumë se numri i karaktereve që do të ndahen në memorie.

Le të japim një shembull të përdorimit të vargjeve.

Programi 84

# përfshijnë kryesore ()

scanf ("% s", varg);

printf ("% s", varg);

Ky shembull përshkruan një grup prej 31 qelizave memorie, 30 prej të cilave mund të strehojnë një element të tipit char. Futet kur thirret funksioni scanf ("% s", varg); "&" mungon kur specifikoni një grup karakteresh.

Treguesit. Pointer - një paraqitje simbolike e adresës së memories së caktuar për variablin.

Për shembull, & emri është një tregues për emrin e ndryshores;

Këtu dhe është operacioni i marrjes së një adrese. Adresa aktuale është një numër, dhe përfaqësimi simbolik i & emrit është një konstante treguese.

Në gjuhën C ka edhe variabla të tipit pointer. Ashtu si vlera e një ndryshoreje të tipit char është një karakter, dhe vlera e një ndryshoreje të tipit int është një numër i plotë, vlera e një ndryshoreje të tipit pointer është adresa e një farë vlere.

Nëse i japim treguesit emrin ptr, mund të shkruajmë një operator si ky:

ptr = / * i cakton adresën e emrit ndryshores ptr * /

Themi në këtë rast se prt është një emër "tregues për". Dallimi midis ptr dhe & name është se prt është një ndryshore, ndërsa & name është një konstante. Nëse është e nevojshme, mund ta vendosni ndryshoren ptr në një objekt tjetër:

ptr= / * Ptr tregon bah, jo emrin * /

Tani vlera e ndryshores prt është adresa e ndryshores bah. Supozoni se e dimë se ndryshorja ptr përmban një referencë për ndryshoren bah. Më pas, për të hyrë në vlerën e kësaj ndryshoreje, mund të përdorni operacionin "adresim indirekt" *:

val = * ptr; / * përcaktoni vlerën e treguar nga ptr * / Dy operatorët e fundit, të marrë së bashku, janë ekuivalent me sa vijon:

Pra, kur pas shenjës & e ndjekur nga emri i ndryshores, rezultati i operacionit është adresa e ndryshores së specifikuar; & infermierja jep adresën e variablit infermiere; kur * pasohet nga një tregues drejt një ndryshoreje, rezultati i operacionit është vlera e vendosur në vendndodhjen e memories në adresën e specifikuar.

Shembull: infermiere = 22;

ptr = /* tregues për infermieren * /

Rezultati është caktimi i vlerës 22 në ndryshoren val.

Nuk mjafton të thuhet se një variabël është një tregues. Përveç kësaj, është e nevojshme të informohet se cilit lloj variabli i referohet ky tregues. Arsyeja është se variablat e llojeve të ndryshme zënë një numër të ndryshëm vendndodhjesh memorie, ndërsa disa operacione që përfshijnë tregues kërkojnë të dihet sasia e memories së alokuar.

Shembuj të përshkrimi i saktë i treguesve: int * pi; char * pc;

Specifikimi i tipit përcakton llojin e variablit të cilit i referohet treguesi, dhe karakteri * përcakton vetë variablin si tregues. Përshkrimi i formës int * pi; thotë se pi është një tregues dhe se * pi është një int.

Gjuha C ofron mundësinë për të përcaktuar emrat e llojeve të të dhënave. Ju mund t'i caktoni një emër çdo lloji të dhënash duke përdorur përkufizimin typedef dhe ta përdorni këtë emër në të ardhmen kur përshkruani objekte.

Formati: typedef<старый тип> <новый тип> Shembull: typedef i gjatë LARGE; / * përcakton të mëdha, e cila është e barabartë me të gjatë * /

Përkufizimi typedef nuk prezanton ndonjë lloj të ri, ai vetëm shton një emër të ri për llojin tashmë ekzistues. Variablat e përshkruar në këtë mënyrë kanë saktësisht të njëjtat veti si variablat e përshkruar në mënyrë eksplicite. Riemërtimi i tipit përdoret për të futur emra kuptimplotë ose të shkurtuar të tipeve për të përmirësuar kuptueshmërinë e programit dhe për të përmirësuar transportueshmërinë e programit (emrat e të njëjtit lloj të dhënash mund të ndryshojnë në kompjuterë të ndryshëm).

Operacionet. Gjuha C dallohet nga një shumëllojshmëri e gjerë operacionesh (më shumë se 40). Këtu do të shqyrtojmë vetëm ato kryesore, skedën. 3.3.

Veprimet aritmetike. Kjo perfshin

Shtesa (+),

Zbritja (binare) (-),

Shumëzimi (*),

Divizioni (/),

Pjesa e mbetur e pjesëtimit (%),

Zbritja (unare) (-).

Në gjuhën C, ekziston një rregull: nëse dividenti dhe pjesëtuesi janë të tipit int, atëherë ndarja kryhet tërësisht, domethënë, pjesa e pjesshme e rezultatit hidhet poshtë.

Si zakonisht, në shprehje, veprimet e shumëzimit, pjesëtimit dhe gjetjes së mbetjes kryhen para mbledhjes dhe zbritjes. Përdorni kllapa për të ndryshuar rendin e veprimeve.

Programi 85

#përfshi

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);

Rezultati i ekzekutimit të programit: 11 1 0 1

Tabela 3.3 Vjetërsia dhe rendi i operacioneve

Bazat e gjuhës

Kodi i programit dhe të dhënat e manipuluara nga programi shkruhen në memorien e kompjuterit si një sekuencë bitash. Bit- Ky është elementi më i vogël i memories kompjuterike, i aftë për të ruajtur ose 0 ose 1. Në nivel fizik, kjo korrespondon me një tension elektrik, i cili, siç e dini, ekziston ose jo. Duke parë përmbajtjen e memories së kompjuterit, ne shohim diçka të tillë:
...

Është shumë e vështirë të kuptojmë këtë sekuencë, por ndonjëherë duhet të manipulojmë të dhëna të tilla të pastrukturuara (zakonisht kjo nevojitet kur programojmë drejtuesit e pajisjeve harduerike). C ++ ofron një sërë operacionesh për të punuar me të dhëna bit. (Ne do të flasim për këtë në Kapitullin 4.)
Si rregull, një strukturë imponohet në një sekuencë bitesh, duke i grupuar bitet në byte dhe fjalët... Një bajt përmban 8 bit dhe një fjalë përmban 4 bit, ose 32 bit. Sidoqoftë, përkufizimi i një fjale mund të jetë i ndryshëm në sisteme të ndryshme operative. Tani ka filluar kalimi në sistemet 64-bit dhe kohët e fundit sistemet me fjalë 16-bit ishin të zakonshme. Megjithëse madhësia e bajtit është e njëjtë në shumicën dërrmuese të sistemeve, ne ende do t'i referohemi këtyre vlerave si të varura nga makina.

Tani mund të flasim, për shembull, për bajtin me adresën 1040 ose fjalën me adresën 1024 dhe pohojmë se bajt me adresën 1032 nuk është i barabartë me bajtin me adresën 1040.
Megjithatë, ne nuk e dimë se çfarë është ndonjë bajt, çdo fjalë makinerie. Si të kuptoni kuptimin e 8 biteve të caktuara? Për të interpretuar në mënyrë të qartë kuptimin e këtij bajt (ose fjalë, ose grup tjetër bit), ne duhet të dimë llojin e të dhënave të përfaqësuara nga ky bajt.
C ++ ofron një grup llojesh të dhënash të integruara: karakter, numër i plotë, real - dhe një grup llojesh të përbëra dhe të zgjeruara: vargje, vargje, numra kompleksë. Përveç kësaj, ekziston një grup bazë operacionesh për operacionet me këto të dhëna: krahasimi, aritmetika dhe operacione të tjera. Ekzistojnë gjithashtu operatorë kërcimi, loop dhe të kushtëzuar. Këta elementë të gjuhës C ++ përbëjnë grupin e blloqeve ndërtuese nga të cilat mund të ndërtoni një sistem të çdo kompleksiteti. Hapi i parë në zotërimin e C ++ do të jetë studimi i elementeve bazë të listuara, të cilit i kushtohet Pjesa II e këtij libri.
Kapitulli 3 ofron një përmbledhje të llojeve të integruara dhe të zgjeruara, si dhe mekanizmat me anë të të cilave mund të krijohen lloje të reja. Në thelb, ky është, natyrisht, mekanizmi i klasës i prezantuar në seksionin 2.3. Kapitulli 4 diskuton shprehjet, operacionet e integruara dhe përparësinë e tyre dhe konvertimet e tipit. Kapitulli 5 flet për udhëzimet gjuhësore. Së fundi, Kapitulli 6 prezanton bibliotekën standarde C ++ dhe llojet e kontejnerëve - vargun vektorial dhe shoqërues.

3. Llojet e të dhënave C ++

Ky kapitull ofron një përmbledhje të ngulitura, ose elementare, llojet e të dhënave të gjuhës C ++. Fillon me një përkufizim fjalë për fjalë, të tilla si 3.14159 ose pi, dhe më pas koncepti e ndryshueshme, ose Objekt të jetë një nga llojet e të dhënave. Pjesa tjetër e këtij kapitulli i kushtohet një përshkrimi të detajuar të çdo lloji të integruar. Ai gjithashtu rendit llojet e të dhënave të derivuara për vargjet dhe vargjet e ofruara nga biblioteka standarde C ++. Edhe pse këto lloje nuk janë elementare, ato janë shumë të rëndësishme për të shkruar programe reale në C ++ dhe ne duam t'i prezantojmë sa më shpejt lexuesit. Ne do t'i quajmë lloje të tilla të dhënash zgjerimi Llojet bazë të C ++.

3.1. Literale

C ++ ka një grup të llojeve të të dhënave të integruara për përfaqësimin e numrave të plotë, numrave realë, simboleve dhe llojit të të dhënave "vargu i karaktereve", i cili përdoret për të ruajtur vargjet e karaktereve. Lloji char përdoret për të ruajtur karaktere të vetme dhe numra të plotë të vegjël. Ai zë një bajt makinerie. Llojet short, int dhe long janë krijuar për të përfaqësuar numra të plotë. Këto lloje ndryshojnë vetëm në gamën e vlerave që numrat mund të marrin, dhe madhësitë specifike të llojeve të listuara varen nga zbatimi. Zakonisht shkurt është gjysma e një fjale makine, int është një fjalë, e gjatë është një ose dy fjalë. Në sistemet 32-bit, int dhe long janë zakonisht të njëjtat madhësi.

Llojet float, double dhe long double janë të destinuara për numrat me pikë lundruese dhe ndryshojnë në saktësinë e paraqitjes (numri i shifrave domethënëse) dhe diapazoni. Në mënyrë tipike, float (përpikëri e vetme) merr një fjalë makinerie, dyfishi (përpikëri e dyfishtë) merr dy, dhe dyfishi i gjatë (përpikëri i zgjeruar) merr tre.
char, short, int dhe long së bashku bëjnë llojet e numrave të plotë e cila, nga ana tjetër, mund të jetë ikonike(nënshkruar) dhe e panënshkruar(i panënshkruar). Në llojet e nënshkruara, biti më i majtë përdoret për të ruajtur shenjën (0 - plus, 1 - minus), dhe bitet e mbetura përmbajnë vlerën. Në llojet e panënshkruara, të gjitha bitet përdoren për vlerën. Karakteri i nënshkruar i tipit 8-bit mund të përfaqësojë vlera nga -128 në 127, dhe char i panënshkruar mund të përfaqësojë vlera nga 0 në 255.

Kur një numër i caktuar shfaqet në program, për shembull 1, atëherë thirret ky numër fjalë për fjalë, ose konstante fjalë për fjalë... Një konstante, sepse nuk mund ta ndryshojmë vlerën e saj, dhe një literale, sepse vlera e saj shfaqet në tekstin e programit. Një literal është një sasi e paadresuar: megjithëse në realitet, natyrisht, ruhet në kujtesën e makinës, nuk ka asnjë mënyrë për të ditur adresën e saj. Çdo fjalë për fjalë ka një lloj specifik. Pra, 0 është e tipit int, 3.14159 është e tipit double.

Literalet e numrave të plotë mund të shkruhen në shënime dhjetore, oktale dhe heksadecimal. Ja si duket numri 20, i përfaqësuar nga fjalë për fjalë dhjetore, oktale dhe heksadecimale:

20 // dhjetore
024 // oktal
0x14 // gjashtëkëndor

Nëse literali fillon me 0, trajtohet si oktal, nëse fillon me 0x ose 0X, atëherë si heksadecimal. Shënimi i zakonshëm trajtohet si numër dhjetor.
Si parazgjedhje, të gjitha literalet e numrave të plotë nënshkruhen int. Ju mund të përcaktoni në mënyrë eksplicite një numër të plotë literal për aq kohë sa duke bashkangjitur shkronjën L në fund të numrit (përdoren të dyja shkronjat L të mëdha dhe l të vogla, por për lexueshmëri nuk duhet të përdorni shkronja të vogla: mund të ngatërrohet lehtësisht me

1). U (ose u) në fund e përkufizon fjalë për fjalë si int të panënshkruar, dhe dy shkronjat UL ose LU si të gjata të panënshkruara. Për shembull:

128u 1024UL 1L 8Lu

Literalet që përfaqësojnë numrat realë mund të shkruhen ose me presje dhjetore ose me shënim shkencor (eksponencial). Si parazgjedhje, ato janë të tipit double. Për të treguar në mënyrë eksplicite llojin float, duhet të përdorni prapashtesën F ose f, dhe për dyfishin e gjatë - L ose l, por vetëm në rastin e shkrimit me një pikë dhjetore. Për shembull:

3,14159F 0 / 1f 12,345L 0,0 3el 1,0E-3E 2,1,0L

Fjalët e vërtetë dhe false janë fjalë për fjalë të tipit bool.
Konstantet e përfaqësueshme të karaktereve letrare shkruhen si karaktere brenda thonjëzave të vetme. Për shembull:

"a" "2" "," "" (hapësirë)

Karakteret speciale (tab, kthimi i karrocës) shkruhen si sekuenca ikjeje. Sekuencat e tilla të mëposhtme janë përcaktuar (ato fillojnë me një karakter të kundërt):

Linja e re \ n skeda horizontale \ t hapësirë ​​e pasme \ b skeda vertikale \ v kthimi i karrocës \ r furnizim \ f thirrje \ një vijë e prapme \\ pyetje \? citim i vetëm \ "kuotim i dyfishtë\"

sekuenca e përgjithshme e arratisjes është \ ooo, ku ooo është një deri në tre shifra oktale. Ky numër është kodi i karakterit. Duke përdorur kodin ASCII, ne mund të shkruajmë fjalë për fjalë:

\ 7 (telefonatë) \ 14 (linja e re) \ 0 (null) \ 062 ("2")

Një karakter literal mund të parashtesohet me L (për shembull, L "a"), që do të thotë një lloj i veçantë wchar_t - një lloj karakteri me dy bajtë që përdoret për të ruajtur karaktere nga alfabetet kombëtare nëse ato nuk mund të përfaqësohen nga një lloj karakteri i zakonshëm , të tilla si shkronja kineze ose japoneze.
Një varg literal është një varg karakteresh i mbyllur në thonjëza të dyfishta. Një literal i tillë mund të përfshijë disa rreshta, në të cilin rast futet një vijë e prapme në fund të rreshtit. Personazhet speciale mund të përfaqësohen nga sekuencat e tyre të arratisjes. Këtu janë shembuj të literaleve të vargjeve:

"" (rresht bosh) "a" "\ nCC \ toptions \ tfile. \ n" "një fjalë për fjalë \ vargje me shumë rreshta sinjalizon vazhdimin e tij \ me një vijë të prapme"

Në fakt, një varg literal është një grup konstantesh karakteresh, ku, sipas konventës së C dhe C ++, elementi i fundit është gjithmonë karakteri special me kodin 0 (\ 0).
Fjalë për fjalë "A" specifikon një karakter të vetëm A, dhe vargu literal "A" është një grup prej dy elementësh: "A" dhe \ 0 (karakter bosh).
Meqenëse ekziston një lloj wchar_t, ka fjalë për fjalë të këtij lloji, të shënuara, si në rastin e karaktereve individuale, me parashtesën L:

L "një varg i gjerë fjalë për fjalë"

Një varg literal i tipit wchar_t është një grup me përfundim null i të njëjtit lloj.
Nëse dy ose më shumë literale vargjesh (të tilla si char ose wchar_t) shkojnë me radhë në një test programi, përpiluesi i bashkon ato në një varg. Për shembull, teksti i mëposhtëm

"dy" "disa"

do të gjenerojë një grup prej tetë karakteresh - dyshe dhe një karakter null fundor. Rezultati i bashkimit të vargjeve të llojeve të ndryshme është i papërcaktuar. Nëse shkruani:

// kjo nuk është një ide e mirë "dy" L "disa"

atëherë në ndonjë kompjuter rezultati do të jetë një linjë kuptimplotë, dhe në një tjetër mund të jetë diçka krejtësisht e ndryshme. Programet që përdorin veçoritë e zbatimit të një përpiluesi ose sistemi operativ të caktuar nuk janë të lëvizshëm. Ne dekurajojmë fuqimisht përdorimin e modeleve të tilla.

Ushtrimi 3.1

Shpjegoni ndryshimin në përkufizimet e fjalëve të mëposhtme:

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

Ushtrimi 3.2

Çfarë gabimesh janë bërë në shembujt e mëposhtëm?

(a) "Kush shkon me F \ 144rgus? \ 014" (b) 3.14e1L (c) "dy" L "disa" (d) 1024f (e) 3.14UL (f) "koment me shumë rreshta"

3.2. Variablat

Le të imagjinojmë se po zgjidhim problemin e ngritjes së 2 në fuqinë e 10. Ne shkruajmë:

#përfshi
int main () (
// një zgjidhje e parë
cout<< "2 raised to the power of 10: ";
cout<< 2 * 2 * 2 * 2 * 2 * 2 * 2 * 2 * 2 * 2;
cout<< endl;
kthimi 0;
}

Problemi është zgjidhur, megjithëse na u desh të kontrollonim vazhdimisht nëse fjalë për fjalë 2 përsëritet në të vërtetë 10 herë. Ne nuk gabuam duke shkruar këtë sekuencë të gjatë dyshe, dhe programi ktheu rezultatin e saktë - 1024.
Por tani na u kërkua të ngrinim 2 në fuqinë e 17-të, dhe më pas në 23. Është jashtëzakonisht e papërshtatshme të modifikosh tekstin e programit çdo herë! Dhe, edhe më keq, është shumë e lehtë të bësh një gabim duke shkruar një dy shtesë ose duke e lënë jashtë… Por, çka nëse duhet të printosh një tabelë me dy fuqi nga 0 në 15? Përsëritni 16 herë dy rreshta që kanë një pamje të përgjithshme:

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

ku X është rritur në mënyrë sekuenciale me 1, dhe numri i kërkuar i literaleve zëvendësohet në vend të elipsës?

Po, ne e kemi përballuar detyrën. Klienti nuk ka gjasa të gërmojë në detaje, duke qenë i kënaqur me rezultatin. Në jetën reale, kjo qasje shpesh funksionon, për më tepër, është e justifikuar: problemi u zgjidh larg nga mënyra më elegante, por në kohën e dëshiruar. Kërkimi për një opsion më të mirë dhe më inteligjent mund të jetë një humbje jopraktike e kohës.

Në këtë rast, metoda brute-force jep përgjigjen e saktë, por sa e pakëndshme dhe e mërzitshme është të zgjidhësh një problem në këtë mënyrë! Ne e dimë saktësisht se çfarë hapash duhet të ndërmerren, por vetë hapat janë të thjeshtë dhe monoton.

Përfshirja e mekanizmave më kompleksë për të njëjtën detyrë, si rregull, rrit ndjeshëm kohën e fazës përgatitore. Përveç kësaj, sa më të sofistikuara të përdoren mekanizmat, aq më e madhe është gjasat e gabimeve. Por edhe përkundër gabimeve të pashmangshme dhe lëvizjeve të gabuara, përdorimi i “teknologjisë së lartë” mund të sjellë përfitime në shpejtësinë e zhvillimit, për të mos përmendur faktin se këto teknologji zgjerojnë ndjeshëm aftësitë tona. Dhe - çfarë është interesante! - vetë procesi i vendimmarrjes mund të bëhet tërheqës.
Le të kthehemi te shembulli ynë dhe të përpiqemi të "përmirësojmë teknologjikisht" zbatimin e tij. Ne mund të përdorim një objekt të emërtuar për të ruajtur vlerën e shkallës në të cilën duam të rrisim numrin tonë. Gjithashtu, në vend të një sekuence të përsëritur të literaleve, ne përdorim operatorin e ciklit. Kështu do të duket:

#përfshi
int main ()
{
// objekte të tipit int
vlera int = 2;
int pow = 10;
cout<< value << " в степени "
<< pow << ": \t";
int res = 1;
// operatori i ciklit:
// përsëris llogaritjen e res
// derisa cnt të jetë më i madh se pow
për (int cnt = 1; cnt<= pow; ++cnt)
res = res * vlera;
cout<< res << endl;
}

vlera, pow, res dhe cnt janë variabla që ju lejojnë të ruani, modifikoni dhe merrni vlera. Deklarata e ciklit for përsërit linjën e vlerësimit të kohëve të rezultatit.
Pa dyshim, ne kemi krijuar një program shumë më fleksibël. Megjithatë, ky ende nuk është një funksion. Për të marrë një funksion real që mund të përdoret në çdo program për të llogaritur fuqinë e një numri, duhet të zgjidhni pjesën e përgjithshme të llogaritjeve dhe të vendosni vlera specifike me parametra.

Int pow (int val, int exp) (për (int res = 1; exp> 0; --exp) res = res * val; return res;)

Tani marrja e ndonjë shkalle të numrit të dëshiruar nuk do të jetë e vështirë. Ja se si zbatohet detyra jonë e fundit - të printoni një tabelë me dy fuqi nga 0 në 15:

#përfshi extern int pow (int, int); int main () (int val = 2; int exp = 15;
cout<< "Степени 2\n";
për (int cnt = 0; cnt<= exp; ++cnt)
cout<< cnt << ": "
<< pow(val, cnt) << endl;
kthimi 0;
}

Sigurisht, funksioni ynë pow () nuk është ende mjaftueshëm i përgjithësuar dhe mjaft i fortë. Nuk mund të funksionojë me numra realë, gabimisht ngre numrat në një fuqi negative - gjithmonë kthen 1. Rezultati i rritjes së një numri të madh në një fuqi të madhe mund të mos përshtatet në një ndryshore të tipit int dhe më pas do të kthehet një vlerë e gabuar e rastësishme . A e shihni sa e vështirë rezulton të jenë funksionet e shkrimit të krijuara për përdorim të gjerë? Shumë më e vështirë sesa zbatimi i një algoritmi specifik që synon zgjidhjen e një problemi specifik.

3.2.1. Çfarë është një variabël

E ndryshueshme, ose nje objekt- kjo është një zonë e emërtuar e kujtesës në të cilën ne kemi akses nga programi; vlerat mund të vendosen atje dhe më pas të merren. Çdo variabël C ++ ka një lloj specifik që karakterizon madhësinë dhe vendndodhjen e asaj zone memorie, gamën e vlerave që mund të ruajë dhe grupin e operacioneve të zbatueshme për atë ndryshore. Këtu është një shembull i përcaktimit të pesë objekteve të llojeve të ndryshme:

Int student_count; paga e dyfishtë; bool on_loan; strins_rruga_adresa; kufizues char;

Një variabël, si një literal, ka një lloj specifik dhe ruan vlerën e tij në një zonë të caktuar të memories. Adresueshmëria- kjo është ajo që i mungon fjalë për fjalë. Ka dy sasi të lidhura me një ndryshore:

• vlera aktuale, ose vlera r (nga vlera e lexuar - vlera për lexim), e cila ruhet në këtë zonë memorie dhe është e natyrshme si në ndryshoren ashtu edhe në atë literale;
• vlera e adresës së zonës së memories së lidhur me variablin, ose l-vlera (nga vlera e vendndodhjes) - vendi ku ruhet vlera r; është e qenësishme vetëm në objekt.

Në shprehje

Ch = ch - "0";

ndryshorja ch ndodhet si në të majtë ashtu edhe në të djathtë të simbolit të caktimit. Në të djathtë është vlera për t'u lexuar (ch dhe karakteri fjalë për fjalë "0"): të dhënat e lidhura me variablin lexohen nga zona përkatëse e memories. Në të majtë është vlera e vendndodhjes: rezultati i zbritjes vendoset në zonën e kujtesës të lidhur me ndryshoren ch. Në përgjithësi, operandi i majtë i një caktimi duhet të jetë një vlerë l. Nuk mund të shkruajmë shprehjet e mëposhtme:

// gabimet e përpilimit: vlerat në të majtë nuk janë vlera l // gabim: fjalë për fjalë nuk është l-vlera 0 = 1; // gabim: shprehja aritmetike nuk është një rrogë me vlerë l + pagë * 0.10 = paga_re;

Deklarata e përkufizimit të ndryshores cakton memorie për të. Meqenëse një objekt ka vetëm një zonë memorie të lidhur me të, një deklaratë e tillë mund të ndodhë vetëm një herë në një program. Problemet lindin nëse një ndryshore e përcaktuar në një skedar burimor do të përdoret në një tjetër. Për shembull:

// file module0.C // përcakton një objekt Emri i skedarit vargu Emri i skedarit; // ... cakto një vlerë për emrin e skedarit
// skedar module1.C
// përdor objektin Emri i skedarit
// mjerisht, nuk përpilohet:
// Emri i skedarit nuk është përcaktuar në modulin1.C
ifstream input_file (emri i skedarit);

C ++ kërkon që një objekt të njihet përpara se t'i qaset fillimisht. Kjo është për shkak të nevojës për të siguruar që objekti të përdoret në mënyrë korrekte sipas llojit të tij. Në shembullin tonë, module1.C do të shkaktojë një gabim përpilimi sepse ndryshorja e skedarit Emri nuk është përcaktuar në të. Për të shmangur këtë gabim, ne duhet t'i tregojmë kompajlerit për variablin e përcaktuar tashmë fileName. Kjo bëhet me një deklaratë deklarimi të ndryshueshme:

// skedari module1.C // përdor objektin Emri i skedarit // Emri i skedarit është deklaruar, domethënë, programi merr
// informacion rreth këtij objekti pa përcaktimin e tij dytësor
emri i skedarit të vargut të jashtëm; ifstream input_file (emri i skedarit)

Deklarata e ndryshores i tregon kompajlerit se një objekt i emrit të dhënë, i llojit të caktuar, është përcaktuar diku në program. Asnjë memorie nuk ndahet për një variabël kur deklarohet. (Fjala kyçe e jashtme diskutohet në seksionin 8.2.)
Një program mund të përmbajë sa më shumë deklarata të së njëjtës variabël sipas dëshirës, ​​por ai mund të përcaktohet vetëm një herë. Është i përshtatshëm për të vendosur deklarata të tilla në skedarët e kokës, duke i përfshirë ato në ato module që e kërkojnë atë. Kështu që ne mund të ruajmë informacionin rreth objekteve në një vend dhe të sigurojmë lehtësinë e modifikimit të tij nëse është e nevojshme. (Ne do të flasim më shumë për skedarët e kokës në seksionin 8.2.)

3.2.2. Emri i ndryshores

Emri i ndryshores, ose identifikues, mund të përbëhet nga shkronja latine, numra dhe karakteri i nënvizuar. Shkronjat e mëdha dhe të vogla në emra janë të ndryshme. Gjuha C ++ nuk e kufizon gjatësinë e identifikuesit, por është e papërshtatshme të përdoren emra shumë të gjatë si gosh_this_is_an_impossibly_name_to_type.
Disa fjalë janë fjalë kyçe në C ++ dhe nuk mund të përdoren si identifikues; Tabela 3.1 ofron një listë të plotë të tyre.

Tabela 3.1. C ++ fjalë kyçe

Për ta bërë më të lehtë të kuptueshëm tekstin e programit tuaj, ju rekomandojmë t'u përmbaheni konventave të pranuara përgjithësisht për emërtimin e objekteve:

• emri i variablit zakonisht shkruhet me shkronja të vogla, për shembull indeksi (për krahasim: Index është një emër tipi, dhe INDEX është një konstante e përcaktuar duke përdorur direktivën e paraprocesorit #define);
• identifikuesi duhet të ketë një kuptim, duke shpjeguar qëllimin e objektit në program, për shembull: data_lindja ose paga;

nëse një emër i tillë përbëhet nga disa fjalë, të tilla si, për shembull, data_lindja, atëherë është zakon që ose të ndahen fjalët me një nënvizim (data_lindja), ose të shkruhet çdo fjalë tjetër me një shkronjë të madhe (data e lindjes). Është vënë re se programuesit e mësuar me qasjen e orientuar drejt objekteve preferojnë të shkruhen me shkronja të mëdha, ndërsa ata që kanë shkruar shumë në C përdorin karakterin nënvizues. Cila nga të dyja është më e mirë është çështje shije.

3.2.3. Përkufizimi i objektit

Në rastin më të thjeshtë, deklarata e përkufizimit të objektit përbëhet nga specifikues i tipit dhe emri i objektit dhe përfundon me një pikëpresje. Për shembull:

Paga e dyfishtë; paga e dyfishtë; muaji int; ditë int; viti int; distanca e largët e panënshkruar;

Disa objekte të të njëjtit lloj mund të përcaktohen në një deklaratë. Në këtë rast, emrat e tyre renditen të ndarë me presje:

Paga e dyfishtë, paga; në muajin, ditën, vitin; distanca e largët e panënshkruar;

Përkufizimi i thjeshtë i një ndryshoreje nuk përcakton vlerën e saj fillestare. Nëse një objekt përkufizohet si global, specifikimi C ++ garanton që ai do të inicializohet në zero. Nëse ndryshorja është lokale ose e alokuar në mënyrë dinamike (duke përdorur operatorin e ri), vlera e saj fillestare është e padefinuar, domethënë mund të përmbajë një vlerë të rastësishme.
Përdorimi i variablave si këto është një gabim shumë i zakonshëm dhe i vështirë për t'u zbuluar. Rekomandohet që të specifikoni në mënyrë eksplicite vlerën fillestare të një objekti, të paktën në rastet kur nuk e dini nëse objekti mund të inicializohet. Mekanizmi i klasës prezanton konceptin e një konstruktori të paracaktuar, i cili përdoret për të caktuar vlerat e paracaktuara. (Ne kemi folur tashmë për këtë në seksionin 2.3. Ne do të vazhdojmë të flasim për konstruktorët e paracaktuar pak më vonë, në seksionet 3.11 dhe 3.15, ku do të zbërthejmë vargjet dhe klasat komplekse nga biblioteka standarde.)

Int main () (// objekt lokal i pa inicializuar int ival;
// objekti i tipit string është inicializuar
// konstruktori i paracaktuar
projekt string;
// ...
}

Vlera fillestare mund të specifikohet drejtpërdrejt në deklaratën e përkufizimit të ndryshores. Në C ++, lejohen dy forma të inicializimit të variablave - të qarta, duke përdorur operatorin e caktimit:

Int ival = 1024; string project = "Fantasia 2000";

dhe të nënkuptuar, me vlerën fillestare në kllapa:

Int ival (1024); projekt string ("Fantasia 2000");

Të dy opsionet janë ekuivalente dhe inicializojnë ivalin e plotë në 1024 dhe vargun e projektit në "Fantasia 2000".
Inicializimi i qartë mund të përdoret gjithashtu kur përcaktohen variablat me një listë:

Paga e dyfishtë = 9999,99, paga = paga + 0,01; muaji int = 08; dita = 07, viti = 1955;

Variabli bëhet i dukshëm (dhe i vlefshëm në program) menjëherë pas përcaktimit të tij, kështu që ne mund të inicializojmë variablin paga me shumën e variablit paga që sapo përcaktuam me një konstante. Pra, përkufizimi është:

// i saktë, por i pakuptimtë int bizarre = i çuditshëm;

është sintaksisht e vlefshme, ndonëse e pakuptimtë.
Llojet e integruara të të dhënave kanë një sintaksë të veçantë për të specifikuar një vlerë null:

// ival merr vlerën 0, dhe dval merr 0.0 int ival = int (); dyfish dval = dyfish ();

Në përkufizimin e mëposhtëm:

// int () zbatohet për secilin prej 10 elementeve vektoriale< int >ivec (10);

inicializimi me int () zbatohet për secilin nga dhjetë elementët e vektorit. (Ne folëm për klasën e vektorit në seksionin 2.8. Shih seksionin 3.10 dhe kapitullin 6 për më shumë rreth kësaj.)
Një variabël mund të inicializohet me një shprehje të çdo kompleksiteti, duke përfshirë thirrjet e funksioneve. Për shembull:

#përfshi #përfshi
çmimi dyfish = 109,99, zbritja = 0,16;
dyfishi_çmimi i shitjes (çmimi * zbritje);
kafshë shtëpiake me varg ("rrudhat"); extern int get_value (); int val = fit_vlera ();
abs_val i panënshkruar = abs (val);

abs () është një funksion standard që kthen vlerën absolute të një parametri.
get_value () është një funksion i personalizuar që kthen një vlerë të plotë.

Ushtrimi 3.3

Cili nga përkufizimet e variablave të mëposhtëm përmban gabime sintaksore?

(a) int car = 1024, auto = 2048; (b) int ival = ival; (c) int ival (int ()); (d) paga e dyfishtë = paga = 9999,99; (e) cin >> int_input_value;

Ushtrimi 3.4

Shpjegoni ndryshimin midis vlerës l dhe vlerës r. Jep shembuj.

Ushtrimi 3.5

Gjeni ndryshimet në përdorimin e variablave të emrit dhe studentit në rreshtin e parë dhe të dytë të secilit shembull:

(a) emri i vargut të jashtëm; emri i vargut ("ushtrimi 3.5a"); (b) vektor i jashtëm studentë; vektoriale studentë;

Ushtrimi 3.6

Cilët emra objektesh janë të pavlefshëm në C ++? Modifikojini ato në mënyrë që të jenë sintaksisht të sakta:

(a) int double = 3,14159; (b) vektor< int >_; (c) emri i vargut; (d) kapja e vargut-22; (e) char 1_ose_2 = "1"; (f) float Float = 3.14f;

Ushtrimi 3.7

Cili është ndryshimi midis përkufizimeve të variablave globale dhe lokale të mëposhtme?

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

3.3. Treguesit

Treguesit dhe shpërndarja dinamike e memories u prezantuan shkurtimisht në seksionin 2.2. TreguesiËshtë një objekt që përmban adresën e një objekti tjetër dhe ju lejon të manipuloni në mënyrë indirekte atë objekt. Në mënyrë tipike, treguesit përdoren për të punuar me objekte të krijuara në mënyrë dinamike, për të ndërtuar struktura të lidhura të të dhënave, si lista të lidhura dhe pemë hierarkike, dhe për të kaluar objekte të mëdha - vargje dhe objekte të klasës - te funksionet si parametra.
Çdo tregues është i lidhur me një lloj të caktuar të dhënash, dhe përfaqësimi i tyre i brendshëm nuk varet nga lloji i brendshëm: si madhësia e kujtesës e zënë nga një objekt i llojit të treguesit, ashtu edhe diapazoni i vlerave janë të njëjta. Dallimi është se si përpiluesi interpreton objektin e referuar. Treguesit për lloje të ndryshme mund të kenë të njëjtin kuptim, por zona e kujtesës ku ndodhen llojet përkatëse mund të jetë e ndryshme:

• një tregues në një int që përmban vlerën e adresës 1000 drejtohet në zonën e memories 1000-1003 (në një sistem 32-bit);
• një tregues në një dyshe që përmban vlerën e adresës 1000 drejtohet në zonën e memories 1000-1007 (në një sistem 32-bit).

Ketu jane disa shembuj:

Int * ip1, * ip2; komplekse * cp; varg * pstring; vektoriale * pvec; dyfish * dp;

Indeksi tregohet me një yll përpara emrit. Në përcaktimin e variablave me një listë, një yll duhet të vijë përpara çdo treguesi (shih më lart: ip1 dhe ip2). Në shembullin më poshtë, lp është një tregues për një objekt të gjatë, dhe lp2 është një objekt i gjatë:

E gjatë * lp, lp2;

Në rastin e mëposhtëm, fp interpretohet si një objekt float, dhe fp2 është një tregues për të:

Float fp, * fp2;

Operatori i dereferencës (*) mund të ndahet me hapësira nga emri dhe madje edhe drejtpërdrejt ngjitur me fjalën kyçe të tipit. Prandaj, përkufizimet e mësipërme janë sintaksisht të sakta dhe plotësisht ekuivalente:

// vëmendje: ps2 nuk është një tregues për një varg! varg * ps, ps2;

Mund të supozohet se si ps ashtu edhe ps2 janë tregues, megjithëse treguesi është vetëm i pari prej tyre.
Nëse vlera e treguesit është 0, atëherë ai nuk përmban asnjë adresë objekti.
Le të jepet një ndryshore e tipit int:

Int ival = 1024;

Më poshtë janë shembuj të përcaktimit dhe përdorimit të treguesve për int pi dhe pi2:

// pi është inicializuar në zero int * pi = 0;
// pi2 inicializohet me adresën ival
int * pi2 =
// e saktë: pi dhe pi2 përmbajnë adresën ival
pi = pi2;
// pi2 përmban një adresë zero
pi2 = 0;

Një treguesi nuk mund t'i caktohet një vlerë që nuk është një adresë:

// gabim: pi nuk mund të jetë int pi = ival

Në mënyrë të ngjashme, nuk mund të caktoni një tregues të një lloji në një vlerë që është adresa e një objekti të një lloji tjetër. Nëse përcaktohen variablat e mëposhtëm:

dval i dyfishtë; dyfish * ps =

atëherë të dyja shprehjet e caktimit më poshtë do të shkaktojnë një gabim përpilimi:

// gabime në kompilim // caktim i pavlefshëm i llojeve të të dhënave: int *<== double* pi = pd pi = &dval;

Çështja nuk është se ndryshorja pi nuk mund të përmbajë adresat e objektit dval - adresat e objekteve të llojeve të ndryshme kanë të njëjtën gjatësi. Operacione të tilla të përzierjes së adresave janë të ndaluara qëllimisht, sepse interpretimi i objekteve nga përpiluesi varet nga lloji i treguesit për to.
Sigurisht, ka raste kur na intereson vlera e vetë adresës, dhe jo objekti në të cilin ajo tregon (le të themi se duam ta krahasojmë këtë adresë me ndonjë tjetër). Për të zgjidhur situata të tilla, u prezantua një tregues special i zbrazët, i cili mund të tregojë çdo lloj të dhënash dhe shprehjet e mëposhtme do të jenë të sakta:

// korrekt: void * mund të përmbajë // adresa të çdo lloji void * pv = pi; pv = pd;

Lloji i objektit të drejtuar nga void * është i panjohur dhe ne nuk mund ta manipulojmë këtë objekt. Gjithçka që mund të bëjmë me një tregues të tillë është t'i caktojmë vlerën e tij një treguesi tjetër ose ta krahasojmë atë me ndonjë vlerë adrese. (Ne do të flasim më shumë për treguesin e zbrazëtisë në seksionin 4.14.)
Për t'iu referuar një objekti që ka adresën e tij, duhet të përdorni operacionin e dereferencimit, ose adresimin indirekt, të shënuar me një yll (*). Duke pasur përkufizimet e variablave të mëposhtëm:

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

// duke i caktuar në mënyrë indirekte vlerën ival2 ndryshores ival * pi = ival2;
// përdorimi i tërthortë i ival si rvalue dhe lvalue
* pi = abs (* pi); // ival = abs (ival);
* pi = * pi + 1; // ival = ival + 1;

Kur aplikojmë operacionin e marrjes së adresës (&) në një objekt të tipit int, marrim rezultatin e tipit int *
int * pi =
Nëse zbatojmë të njëjtin veprim për një objekt të tipit int * (pointer to int), marrim një pointer në pointer në int, d.m.th. int **. int ** është adresa e një objekti që përmban adresën e një objekti të tipit int. Duke mos referuar ppi, marrim një objekt int * që përmban adresën ival. Për të marrë vetë objektin ival, operacioni i dereferencimit ppi duhet të zbatohet dy herë.

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

Treguesit mund të përdoren në shprehjet aritmetike. Vini re shembullin e mëposhtëm, ku dy shprehje bëjnë gjëra krejtësisht të ndryshme:

Int i, j, k; int * pi = // i = i + 2
* pi = * pi + 2; // rrit adresën e përfshirë në pi me 2
pi = pi + 2;

Ju mund t'i shtoni një vlerë të plotë treguesit, gjithashtu mund të zbrisni prej tij. Shtimi i 1 në një tregues rrit vlerën që ai përmban nga madhësia e zonës së kujtesës të caktuar për një objekt të llojit përkatës. Nëse lloji char zë 1 bajt, int - 4 dhe double - 8, atëherë shtimi i 2 në treguesit në char, int dhe double do të rrisë vlerën e tyre me 2, 8 dhe 16. Si mund të interpretohet kjo? Nëse objektet e të njëjtit lloj ndodhen në memorie njëri pas tjetrit, atëherë rritja e treguesit me 1 do të bëjë që ai të tregojë tek objekti tjetër. Prandaj, operacionet aritmetike me tregues përdoren më shpesh gjatë përpunimit të vargjeve; në çdo rast tjetër, vështirë se justifikohen.
Kështu duket një shembull tipik i përdorimit të aritmetikës së adresave kur përsëritet mbi elementët e një grupi duke përdorur një përsëritës:

Int ia; int * iter = int * iter_fund =
ndërsa (iter! = iter_fund) (
bëj_diçka_me_vlerë (* iter);
++ iter;
}

Ushtrimi 3.8

Janë dhënë përkufizimet e variablave:

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

Çfarë ndodh kur kryeni veprimet e mëposhtme të caktimit? A ka ndonjë gabim në këta shembuj?

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

Ushtrimi 3.9

Puna me tregues është një nga aspektet më të rëndësishme të C dhe C ++, por është e lehtë të bësh një gabim në të. Për shembull kodin

Pi = pi = pi + 1024;

pothuajse me siguri do të bëjë që pi të tregojë në një rajon të rastësishëm të memories. Çfarë bën ky operator caktimi dhe në cilin rast nuk do të rezultojë në një gabim?

Ushtrimi 3.10

Ky program përmban një gabim në lidhje me përdorimin e gabuar të treguesve:

Int foobar (int * pi) (* pi = 1024; kthim * pi;)
int main () (
int * pi2 = 0;
int ival = foobar (pi2);
kthimi 0;
}

Cili është gabimi? Si mund ta rregulloni?

Ushtrimi 3.11

Gabimet nga dy ushtrimet e mëparshme manifestohen dhe çojnë në pasoja fatale për shkak të mungesës së vërtetimit të vlerave të treguesit në C ++ gjatë ekzekutimit të programit. Pse mendoni se nuk u zbatua një kontroll i tillë? A mund të jepni disa udhëzime të përgjithshme për t'i bërë treguesit më të sigurt?

3.4. Llojet e vargjeve

C ++ mbështet dy lloje vargjesh - llojin e integruar të trashëguar nga C dhe klasën e vargjeve nga biblioteka standarde C ++. Klasa e vargjeve ofron shumë më tepër mundësi dhe për këtë arsye është më e përshtatshme për t'u përdorur, por në praktikë shpesh ka situata kur duhet të përdorni një lloj të integruar ose të keni një kuptim të mirë se si funksionon. (Një shembull do të ishte analizimi i parametrave të linjës së komandës të kaluar në main (). Ne do ta mbulojmë atë në Kapitullin 7.)

3.4.1. Lloji i vargut të integruar

Siç u përmend tashmë, lloji i vargut të integruar kaloi në C ++ me trashëgimi nga C. Një varg karakteresh ruhet në memorie si një grup dhe aksesohet duke përdorur një tregues char *. Biblioteka standarde C ofron një sërë funksionesh për manipulimin e vargjeve. Për shembull:

// kthen gjatësinë e vargut int strlen (const char *);
// krahason dy vargje
int strcmp (const char *, const char *);
// kopjon një rresht në tjetrin
char * strcpy (char *, const char *);

Biblioteka standarde C është pjesë e bibliotekës C ++. Për ta përdorur atë, ne duhet të përfshijmë një skedar kokë:

#përfshi

Treguesi për char, me të cilin i referohemi vargut, tregon grupin e karaktereve që i korrespondojnë vargut. Edhe kur shkruajmë një varg literal like

Const char * st = "Çmimi i një shishe vere \ n";

kompajleri i vendos të gjitha karakteret në varg në një varg dhe më pas i cakton st adresën e elementit të parë në grup. Si mund të punohet me një varg duke përdorur një tregues të tillë?
Në mënyrë tipike, aritmetika e adresës përdoret për të përsëritur karakteret në një varg. Meqenëse vargu përfundon gjithmonë me një karakter null, ju mund ta rritni treguesin me 1 derisa karakteri tjetër të bëhet null. Për shembull:

Ndërsa (* st ++) (...)

st është çreferencuar dhe vlera që rezulton kontrollohet për të vërtetën. Çdo vlerë jozero konsiderohet e vërtetë, dhe për këtë arsye cikli përfundon kur arrihet karakteri me kodin 0. Operatori i rritjes ++ shton 1 në treguesin st dhe kështu e zhvendos atë në karakterin tjetër.
Kështu mund të duket zbatimi i një funksioni që kthen gjatësinë e një vargu. Vini re se meqenëse një tregues mund të përmbajë një vlerë null (të mos tregojë asgjë), ai duhet të kontrollohet përpara se të çreferencohet:

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

Një varg i tipit të integruar mund të konsiderohet bosh në dy raste: nëse treguesi i vargut ka një vlerë null (atëherë nuk kemi fare varg) ose tregon në një grup të përbërë nga një karakter null (d.m.th., në një varg që nuk përmban një karakter të vetëm domethënës).

// pc1 nuk adreson asnjë varg karakteresh char * pc1 = 0; // pc2 adreson një karakter null const char * pc2 = "";

Për një programues fillestar, përdorimi i vargjeve të integruara është i mbushur me gabime, sepse niveli i zbatimit është shumë i ulët dhe është e pamundur të bëhet pa aritmetikë adresash. Më poshtë do të tregojmë disa gabime tipike të bëra nga fillestarët. Detyra është e thjeshtë: llogaritni gjatësinë e vargut. Versioni i parë është i pasaktë. Korrigjoje.

#përfshi const char * st = "Çmimi i një shishe vere \ n"; int main () (
int len ​​= 0;
ndërsa (st ++) ++ len; cout<< len << ": " << st;
kthimi 0;
}

Në këtë version, treguesi st nuk është i çreferencuar. Prandaj, nuk është karakteri i treguar nga st ai që kontrollohet për barazi, por vetë treguesi. Meqenëse fillimisht ky tregues kishte një vlerë jo zero (adresa e vargut), ai kurrë nuk do të bëhet i barabartë me zero dhe cikli do të funksionojë pafundësisht.
Ky gabim është eliminuar në versionin e dytë të programit. Programi përfundon me sukses, por rezultati është i pasaktë. Ku e kemi gabim këtë herë?

#përfshi const char * st = "Çmimi i një shishe vere \ n"; int main ()
{
int len ​​= 0;
ndërsa (* st ++) ++ len; cout<< len << ": " << st << endl;
kthimi 0;
}

Gabimi është se pas përfundimit të ciklit, treguesi st nuk adreson karakterin origjinal literal, por karakterin e vendosur në memorie pas zeros përfundimtare të kësaj literale. Çdo gjë mund të jetë në këtë vend, dhe dalja e programit do të jetë një sekuencë e rastësishme karakteresh.
Mund të përpiqeni të rregulloni këtë gabim:

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

Tani programi ynë prodhon diçka kuptimplote, por jo plotësisht. Përgjigja duket si kjo:

18: ena shishe vere

Ne harruam të merrnim parasysh se karakteri null pasues nuk ishte përfshirë në gjatësinë e llogaritur. st duhet të kompensohet me gjatësinë e vargut plus 1. Këtu është operatori i saktë më në fund:

St = st - len - 1;

dhe këtu është rezultati i saktë:

18: Çmimi i një shishe verë

Megjithatë, nuk mund të themi se programi ynë duket elegant. Operatori

St = st - len - 1;

shtohet për të korrigjuar një gabim të bërë në një fazë të hershme të hartimit të programit - rritja e drejtpërdrejtë e treguesit st. Ky operator nuk përshtatet në logjikën e programit dhe kodi tani është i vështirë për t'u kuptuar. Rregullimet e këtij lloji shpesh quhen arna - diçka e krijuar për të futur një vrimë në një program ekzistues. Një zgjidhje shumë më e mirë do të ishte rimendimi i logjikës. Një nga opsionet në rastin tonë do të ishte përcaktimi i një treguesi të dytë të inicializuar me vlerën st:

Const char * p = st;

Tani p mund të përdoret në një lak gjatësie, duke e lënë st të pandryshuar:

Ndërsa (* p ++)

3.4.2. Klasa e vargjeve

Siç e pamë sapo, përdorimi i llojit të vargut të integruar është i prirur ndaj gabimeve dhe i papërshtatshëm sepse zbatohet në një nivel shumë të ulët. Prandaj, është mjaft e zakonshme të zhvilloni klasën ose klasat tuaja për të përfaqësuar llojin e vargut - pothuajse çdo kompani, departament ose projekt individual kishte zbatimin e vet të vargut. Çfarë mund të them, ne kemi bërë të njëjtën gjë në dy botimet e mëparshme të këtij libri! Kjo shkaktoi probleme të përputhshmërisë dhe transportueshmërisë. Zbatimi i standardit të vargjeve nga biblioteka standarde C ++ kishte për qëllim t'i jepte fund kësaj shpikjeje të biçikletave.
Le të përpiqemi të specifikojmë grupin minimal të operacioneve që duhet të ketë klasa e vargut:

• inicializimi me një grup karakteresh (një varg i tipit të integruar) ose një objekt tjetër të tipit varg. Lloji i integruar nuk ka opsionin e dytë;
• kopjimi i një rreshti në tjetrin. Për një lloj të integruar, duhet të përdorni funksionin strcpy ();
• qasje në karaktere individuale të vargut për lexim dhe shkrim. Në grupin e integruar, kjo bëhet duke përdorur funksionin e marrjes së indeksit ose adresimin indirekt;
• krahasimi i dy vargjeve për barazi. Për një lloj të integruar, përdoret funksioni strcmp ();
• bashkimi i dy vargjeve, duke marrë rezultatin ose si vargu i tretë, ose në vend të njërit prej atyre origjinale. Për një lloj të integruar, përdoret funksioni strcat (), por për të marrë rezultatin në një linjë të re, duhet të përdorni në mënyrë sekuenciale funksionet strcpy () dhe strcat ();
• duke llogaritur gjatësinë e vargut. Ju mund të zbuloni gjatësinë e një vargu të një lloji të integruar duke përdorur funksionin strlen ();
• aftësia për të gjetur nëse një varg është bosh. Për këtë qëllim, vargjet e integruara duhet të kontrollojnë dy kushte: char str = 0; // ... nëse (! str ||! * str) kthehen;

Klasa e vargut të Bibliotekës Standarde C ++ zbaton të gjitha këto operacione (dhe shumë më tepër, siç do të shohim në Kapitullin 6). Në këtë seksion, ne do të mësojmë se si të përdorim operacionet bazë të kësaj klase.
Për të përdorur objektet e klasës së vargut, duhet të përfshini skedarin përkatës të kokës:

#përfshi

Këtu është një shembull i një vargu nga seksioni i mëparshëm, i përfaqësuar nga një objekt vargu dhe një varg karakteresh i inicializuar:

#përfshi st string ("Çmimi i një shishe vere \ n");

Gjatësia e vargut kthehet nga funksioni anëtar i madhësisë () (gjatësia nuk përfshin karakterin null përfundimtar).

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

Forma e dytë e përkufizimit të vargut specifikon një varg bosh:

String st2; // rresht bosh

Si e dimë nëse një rresht është bosh? Sigurisht, ju mund ta krahasoni gjatësinë e tij me 0:

Nëse (! St.size ()) // e saktë: bosh

Sidoqoftë, ekziston gjithashtu një metodë speciale e zbrazët () që kthen true për një varg bosh dhe false për një varg jo bosh:

Nëse (st.zbrazët ()) // e saktë: bosh

Forma e tretë e konstruktorit inicializon një objekt të tipit string me një objekt tjetër të të njëjtit lloj:

String st3 (st);

Vargu st3 inicializohet me vargun st. Si mund të sigurohemi që këto rreshta të jenë të njëjta? Le të përdorim operatorin e krahasimit (==):

Nëse (st == st3) // inicializimi funksionoi

Si mund të kopjoj një rresht në tjetrin? Me operacionin e zakonshëm të caktimit:

St2 = st3; // kopjoni st3 në st2

Për të bashkuar vargjet, përdorni operacionet e mbledhjes (+) ose të mbledhjes dhe caktimit (+ =). Le të jepen dy rreshta:

Vargu s1 ("përshëndetje"); vargu s2 ("bota \ n");

Mund të marrim rreshtin e tretë, i përbërë nga lidhja e dy të parave, si kjo:

Vargu s3 = s1 + s2;

Nëse duam të shtojmë s2 në fund të s1, duhet të shkruajmë:

S1 + = s2;

Operacioni i mbledhjes mund të bashkojë objektet e klasës së vargut jo vetëm me njëri-tjetrin, por edhe me vargje të një lloji të integruar. Ju mund ta rishkruani shembullin e mësipërm në mënyrë që karakteret speciale dhe shenjat e pikësimit të përfaqësohen nga një lloj i integruar, dhe fjalët domethënëse të përfaqësohen nga objektet e klasës së vargut:

Const char * pc = ","; vargu s1 ("përshëndetje"); vargu s2 ("bota");
vargu s3 = s1 + pc + s2 + "\ n";

Shprehje si këto funksionojnë sepse përpiluesi di të konvertojë automatikisht objektet e tipit të integruar në objekte të klasës së vargut. Një caktim i thjeshtë i një vargu inline në një objekt vargu është gjithashtu i mundur:

Vargu s1; const char * pc = "një grup karakteresh"; s1 = pc; // djathtas

Megjithatë, konvertimi i kundërt nuk funksionon. Përpjekja për të bërë inicializimin e mëposhtëm të një vargu të tipit të integruar do të shkaktojë një gabim përpilimi:

Char * str = s1; // gabim përpilimi

Për të kryer këtë konvertim, duhet të thërrisni në mënyrë eksplicite një funksion anëtar me emrin disi të çuditshëm c_str ():

Char * str = s1.c_str (); // pothuajse e saktë

Funksioni c_str () kthen një tregues në një grup karakteresh që përmban vargun e objektit të vargut siç do të ishte në një lloj vargu të integruar.
Shembulli i mësipërm i inicializimit të një treguesi char * str ende nuk është plotësisht i saktë. c_str () kthen një tregues në një grup konstant për të parandaluar mundësinë e modifikimit të drejtpërdrejtë të përmbajtjes së një objekti përmes këtij treguesi të tipit

Konst char *

(Ne do të mbulojmë fjalën kyçe konst në seksionin tjetër.) Opsioni i saktë i inicializimit duket si ky:

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

Karakteret individuale të një objekti të tipit varg, si dhe një lloj i integruar, mund të aksesohen duke përdorur funksionin e marrjes së indeksit. Për shembull, këtu është një copë kodi që zëvendëson të gjitha pikat me nënvizat:

String str ("fa.disney.com"); madhësia int = str.madhësia (); për (int ix = 0; ix< size; ++ix) if (str[ ix ] == ".")
str [ix] = "_";

Kjo është gjithçka që donim të thonim për klasën e vargjeve tani. Në fakt, kjo klasë ka shumë veti dhe aftësi më interesante. Le të themi se shembulli i mëparshëm zbatohet gjithashtu duke thirrur një funksion të vetëm zëvendësues ():

Replace (rr.fillim (), str.fund (), ".", "_");

zëvendësimi () është një nga algoritmet gjenerike që pamë në seksionin 2.8 dhe do të trajtohet në detaje në kapitullin 12. Ky funksion funksionon nga fillimi () në fund (), i cili kthen treguesit në fillim dhe në fund të një vargu dhe zëvendëson elemente të barabarta me parametrin e tretë të tij, me të katërtin.

Ushtrimi 3.12

Kërkoni për gabime në deklaratat e mëposhtme:

(a) char ch = "Rruga e gjatë dhe gjarpëruese"; (b) int ival = (c) char * pc = (d) st 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;

Ushtrimi 3.13

Shpjegoni ndryshimin në sjelljen e deklaratave të ciklit të mëposhtëm:

Ndërsa (st ++) ++ cnt;
ndërsa (* st ++)
++ cnt;

Ushtrimi 3.14

Janë dhënë dy programe ekuivalente semantike. E para përdor llojin e vargut të integruar, e dyta përdor klasën e vargut: