Co tyto programy dělají?
Ukazuje se, že druhá implementace je dvakrát rychlejší než první. Čekal jste takový výsledek? jak to vysvětlíš?

Cvičení 3.15

Je něco, co byste mohli zlepšit nebo přidat do sady operací s třídou string v poslední sekci? Vysvětlete své návrhy

3.5. konst specifikátor

Vezměme si následující příklad kódu:

For(int index = 0; index< 512; ++index) ... ;

Při používání literálu 512 jsou dva problémy. Prvním je snadnost vnímání textu programu. Proč by horní mez proměnné smyčky měla být přesně 512? Co se za touto hodnotou skrývá? Vypadá náhodně...
Druhý problém se týká snadnosti úprav a údržby kódu. Předpokládejme, že program se skládá z 10 000 řádků a doslovných 512 se vyskytuje ve 4 % z nich. Řekněme, že v 80 % případů by mělo být číslo 512 změněno na 1024. Dokážete si představit pracnost takové práce a množství chyb, kterých se lze dopustit opravou špatné hodnoty?
Oba tyto problémy jsou vyřešeny současně: potřebujeme vytvořit objekt s hodnotou 512. Když mu dáme smysluplný název, například bufSize, uděláme program mnohem srozumitelnějším: je jasné, co přesně je smyčka proměnná se porovnává s.

Index< bufSize

V tomto případě změna velikosti bufSize nevyžaduje prohlížení 400 řádků kódu pro úpravu 320 z nich. Jak moc se snižuje pravděpodobnost chyb za cenu přidání pouze jednoho objektu! Nyní je hodnota 512 lokalizované.

bufSize = 512; // velikost vstupní vyrovnávací paměti // ... for (int index = 0; index< bufSize; ++index)
// ...

Zůstává jeden malý problém: proměnná bufSize je zde l-hodnota, kterou lze v programu náhodně změnit, což povede k těžko dohledatelné chybě. Zde je jedna z nejčastějších chyb - použití operátoru přiřazení (=) místo porovnání (==):

// náhodná změna hodnoty bufSize if (bufSize = 1) // ...

V důsledku provedení tohoto kódu bude hodnota bufSize rovna 1, což může vést ke zcela nepředvídatelnému chování programu. Chyby tohoto druhu se většinou velmi obtížně odhalují, protože prostě nejsou vidět.
Tento problém řeší použití specifikátoru const. Prohlášením objektu jako

Const int bufSize = 512; // velikost vstupní vyrovnávací paměti

změníme proměnnou na konstantu s hodnotou 512, jejíž hodnotu nelze změnit: takové pokusy zastaví kompilátor: nesprávné použití operátoru přiřazení místo porovnání, jako ve výše uvedeném příkladu, způsobí chybu při kompilaci.

// chyba: pokus o přiřazení hodnoty konstantě if (bufSize = 0) ...

Protože konstantě nelze přiřadit hodnotu, musí být inicializována v místě její definice. Definování konstanty bez její inicializace také způsobí chybu kompilace:

Const double pí; // chyba: neinicializovaná konstanta

Const double min.Mzda = 9,60; // Že jo? chyba?
double *ptr =

Měl by kompilátor povolit toto přiřazení? Vzhledem k tomu, že minWage je konstanta, nelze jí přiřadit hodnotu. Na druhou stranu nám nic nebrání psát:

*ptr+= 1,40; // změna objektu minWage!

Překladač zpravidla není schopen chránit před použitím ukazatelů a nebude schopen signalizovat chybu, pokud budou použity tímto způsobem. To vyžaduje příliš mnoho analýzy logiky programu. Překladač proto jednoduše zakáže přidělovat adresy konstant běžným ukazatelům.
No, jsme ochuzeni o možnost používat ukazatele na konstanty? Ne. K tomu existují ukazatele deklarované se specifikátorem const:

Const double *cptr;

kde cptr je ukazatel na objekt typu const double. Jemnost spočívá v tom, že ukazatel sám o sobě není konstanta, což znamená, že můžeme měnit jeho hodnotu. Například:

Const double *pc = 0; const double minMage = 9,60; // správně: nelze změnit minWage s pc
pc = double dval = 3,14; // správně: nelze změnit minWage s pc
// ačkoli dval není konstanta
pc = // správně dval = 3,14159; //Že jo
*pc = 3,14159; // chyba

Adresa objektu const je přiřazena pouze ukazateli na konstantu. Takovému ukazateli však lze také přiřadit adresu obyčejné proměnné:

PC =

Konstantní ukazatel neumožňuje upravit objekt, který adresuje, nepřímým adresováním. Ačkoli dval není ve výše uvedeném příkladu konstanta, kompilátor nedovolí změnit dval přes pc. (Opět proto, že není schopen určit, jakou adresu by mohl mít ukazatel v kterémkoli bodě provádění programu.)
V reálných programech se jako formální parametry funkcí nejčastěji používají ukazatele na konstanty. Jejich použití zaručuje, že objekt předaný funkci jako skutečný argument nebude touto funkcí modifikován. Například:

// V reálných programech se jako formální parametry funkcí // nejčastěji používají ukazatele na konstanty int strcmp(const char *str1, const char *str2);

(O ukazatelích na konstanty si povíme více v kapitole 7, když mluvíme o funkcích.)
Existují také konstantní ukazatele. (Všimněte si rozdílu mezi konstantním ukazatelem a ukazatelem na konstantu!). Konstantní ukazatel může adresovat jak konstantu, tak proměnnou. Například:

Inter errNumb = 0; int *const currErr =

CurErr je zde konstantní ukazatel na non-const objekt. To znamená, že k němu nemůžeme přiřadit adresu jiného objektu, ačkoli samotný objekt lze upravit. Zde je návod, jak lze použít ukazatel curErr:

Dělej něco(); if (*curErr) (
errorHandler();
*curErr = 0; // správně: resetujte hodnotu errNumb
}

Pokus o přiřazení hodnoty konstantnímu ukazateli způsobí chybu kompilace:

CurErr = // chyba

Konstantní ukazatel na konstantu je spojením dvou uvažovaných případů.

Const double pi = 3,14159; const double *const pi_ptr = π

V programu nelze změnit hodnotu objektu, na který ukazuje pi_ptr, ani hodnotu samotného ukazatele.

Cvičení 3.16

Vysvětlete význam následujících pěti definic. Je některý z nich špatný?

(a) int i; (d) int *const cpi; (b) const int ic; (e) const int *const cpic; (c) const int *pic;

Cvičení 3.17

Které z následujících definic jsou správné? Proč?

(a) int i = -1; (b) const int ic = i; (c) const int *pic = (d) int *const cpi = (e) const int *const cpic =

Cvičení 3.18

Pomocí definic z předchozího cvičení identifikujte správné operátory přiřazení. Vysvětlit.

(a) i = ic; (d) pic = cpic; (b) pic = (i) cpic = (c) cpi = pic; (f) ic = *cpic;

3.6. Typ reference

Referenční typ, někdy nazývaný alias, se používá k přidělení dalšího názvu objektu. Odkaz vám umožňuje nepřímo manipulovat s objektem, stejně jako to dělá ukazatel. Tato nepřímá manipulace však nevyžaduje speciální syntaxi potřebnou pro ukazatele. Obvykle se jako formální parametry funkcí používají odkazy. V této části se podíváme na použití objektů referenčního typu samostatně.
Typ odkazu je indikován uvedením operátoru adresy (&) před názvem proměnné. Odkaz musí být inicializován. Například:

Intival = 1024; // správně: refVal - odkaz na ival int &refVal = ival; // chyba: odkaz musí být inicializován na int

Intival = 1024; // chyba: refVal je typu int, ne int* int &refVal = int *pi = // správně: ptrVal je odkaz na ukazatel int *&ptrVal2 = pi;

Jakmile definujete referenci, nemůžete ji změnit, aby fungovala s jiným objektem (proto musí být reference inicializována v místě její definice). V následujícím příkladu příkaz přiřazení nemění hodnotu refVal, nová hodnota je přiřazena proměnné ival, té, kterou refVal adresuje.

int min_val = 0; // ival získá hodnotu min_val, // not refVal změní hodnotu na min_val refVal = min_val;

RefVal += 2; přidá 2 k ival, proměnné, na kterou odkazuje refVal. Podobně int ii = refVal; nastaví ii na aktuální hodnotu ival, int *pi = inicializuje pi s adresou ival.

// jsou definovány dva objekty typu int int ival = 1024, ival2 = 2048; // definována jedna reference a jeden objekt int &rval = ival, rval2 = ival2; // definován jeden objekt, jeden ukazatel a jedna reference
int inal3 = 1024, *pi = ival3, &ri = ival3; // definovány dvě reference int &rval3 = ival3, &rval4 = ival2;

Konstantní odkaz může být inicializován objektem jiného typu (pokud samozřejmě existuje možnost převodu jednoho typu na jiný), stejně jako neadresnou hodnotou, jako je doslovná konstanta. Například:

dvojitý dval = 3,14159; // true pouze pro odkazy const
const int &ir = 1024;
const int &ir2 = dval;
const double &dr = dval + 1,0;

Pokud bychom specifikátor const nespecifikovali, všechny tři referenční definice by způsobily chybu kompilace. Důvod, proč překladač takové definice nepřeskočí, však není jasný. Zkusme na to přijít.
U literálů je to víceméně jasné: neměli bychom mít možnost nepřímo měnit hodnotu literálu pomocí ukazatelů nebo odkazů. Co se týče objektů jiného typu, překladač převede původní objekt na nějaký pomocný. Pokud například napíšeme:

Double dval = 1024; const int &ri = dval;

pak to kompilátor převede na něco takového:

int temp = dval; const int &ri = temp;

Pokud bychom mohli přiřadit novou hodnotu ri referenci, ve skutečnosti bychom nezměnili dval, ale temp. Hodnota dval by zůstala stejná, což je pro programátora naprosto nesrozumitelné. Proto kompilátor takové akce zakazuje a jediný způsob, jak inicializovat odkaz s objektem jiného typu, je deklarovat jej jako const.
Zde je další příklad odkazu, který je napoprvé obtížně pochopitelný. Chceme definovat odkaz na adresu objektu const, ale naše první možnost způsobí chybu kompilace:

Const int ival = 1024; // chyba: je potřeba konstantní odkaz
int *&pi_ref =

Pokus o vyřešení problému přidáním specifikátoru const se také nezdaří:

Const int ival = 1024; // stále chyba const int *&pi_ref =

Jaký je důvod? Při pozorném čtení definice uvidíme, že pi_ref je odkaz na konstantní ukazatel na objekt typu int. A potřebujeme non-const ukazatel na const objekt, takže následující záznam bude správný:

Const int ival = 1024; // Že jo
int *const &piref=

Mezi referencí a ukazatelem jsou dva hlavní rozdíly. Nejprve musí být odkaz inicializován v místě jeho definice. Za druhé, jakákoli změna v odkazu netransformuje odkaz, ale objekt, na který odkazuje. Podívejme se na příklady. Pokud napíšeme:

int*pi = 0;

ukazatel pi inicializujeme na nulu, což znamená, že pi neukazuje na žádný objekt. Zároveň rekord

const int &ri = 0;
znamená něco takového:
int temp = 0;
const int &ri = temp;

Pokud jde o operaci přiřazení, v následujícím příkladu:

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

proměnná ival, na kterou ukazuje pi, zůstane nezměněna a pi získá hodnotu adresy ival2. Pi i pi2 stále ukazují na stejný objekt ival2.
Pokud pracujeme s odkazy:

Int &ri = ival, &ri2 = ival2; ri = ri2;

// příklad použití odkazů // Hodnota je vrácena v parametru next_value
bool get_next_value(int &next_value); // přetížený Matrix operator+(const Matrix&, const Matrix&);

Intival; while (get_next_value(ival)) ...

int &next_value = ival;

(Použití odkazů jako formálních parametrů funkcí je podrobněji popsáno v kapitole 7.)

Cvičení 3.19

Jsou v těchto definicích nějaké chyby? Vysvětlit. Jak byste je opravil?

(a) int ival = 1,01; (b) int &rvall = 1,01; (c) int &rval2 = ival; (d) int &rval3 = (e) int *pi = (f) int &rval4 = pi; (g) int &rval5 = pi*; (h) int &*prval1 = pi; (i) const int &ival2 = 1; (j) const int &*prval2 =

Cvičení 3.20

Je některé z následujících zadání chybné (s použitím definic z předchozího cvičení)?

(a) rval1 = 3,14159; (b) prval1 = prval2; (c) prval2 = rval1; (d) *prval2 = ival2;

Cvičení 3.21

Hledejte chyby v následujících pokynech:

(a) int ival = 0; const int *pi = 0; const int &ri = 0; (b) pí =
ri =
pí =

3.7. typ bool

Objekt typu bool může nabývat jedné ze dvou hodnot: true a false. Například:

// inicializace řetězce string search_word = get_word(); // inicializace nalezené proměnné
bool nalezen = false; řetězec další_slovo; while (cin >> next_word)
if (další_slovo == hledané_slovo)
nalezeno = pravda;
// ... // zkratka: if (found == true)
pokud (nalezen)
cout<< "ok, мы нашли слово\n";
jinak cout<< "нет, наше слово не встретилось.\n";

Přestože bool je jedním z celočíselných typů, nelze jej deklarovat jako podepsaný, nepodepsaný, krátký nebo dlouhý, takže výše uvedená definice je chybná:

// nalezena chyba short bool = false;

Objekty typu bool jsou implicitně převedeny na typ int. Hodnota true se stane 1 a false se stane 0. Například:

bool nalezen = false; int počet_výskytů = 0; zatímco (/* mumlá */)
{
nalezeno = hledat (/* něco */); // nalezená hodnota se převede na 0 nebo 1
počet_výskytů += nalezeno; )

Stejným způsobem lze hodnoty celočíselných typů a ukazatelů převést na boolovské hodnoty. V tomto případě je 0 interpretováno jako nepravda a vše ostatní jako pravdivé:

// vrátí počet výskytů extern int find(const string&); bool nalezen = false; if (found = find("rosebud")) // správně: found == true // vrací ukazatel na prvek
extern int* find(int hodnota); if (found = find(1024)) // správně: found == true

3.8. Výčty

Často je nutné definovat proměnnou, která nabývá hodnot z určité množiny. Řekněme, že soubor je otevřen v kterémkoli ze tří režimů: pro čtení, pro zápis, pro připojení.
Pro označení těchto režimů lze samozřejmě definovat tři konstanty:

Const int input = 1; const int output = 2; const int append = 3;

a použijte tyto konstanty:

bool open_file(řetězec název_souboru, int otevřený_režim); //...
open_file("Phoenix_and_the_Crane", append);

Toto řešení je přijatelné, ale ne zcela přijatelné, protože nemůžeme zaručit, že argument předaný funkci open_file() je pouze 1, 2 nebo 3.
Použití výčtového typu tento problém řeší. Když píšeme:

Enum open_modes( input = 1, output, append );

definujeme nový typ open_modes. Platné hodnoty pro objekt tohoto typu jsou omezeny na 1, 2 a 3, přičemž každá ze zadaných hodnot má mnemotechnický název. Název tohoto nového typu můžeme použít k definování objektu tohoto typu i typu formálních parametrů funkce:

Void open_file(řetězec název_souboru, otevřené_režimy om);

vstup, výstup a připojení jsou výčtové prvky. Sada prvků výčtu určuje platnou sadu hodnot pro objekt daného typu. Proměnná typu open_modes (v našem příkladu) je inicializována jednou z těchto hodnot, lze jí také přiřadit kteroukoli z nich. Například:

Open_file("Fénix a jeřáb", append);

Pokus o přiřazení hodnoty proměnné tohoto typu, která se liší od jednoho z prvků výčtu (nebo ji předá jako parametr funkci), způsobí chybu kompilace. I když se pokusíme předat celočíselnou hodnotu odpovídající jednomu z prvků výčtu, stále dostaneme chybu:

// chyba: 1 není člen výčtu open_modes open_file("Jonah", 1);

Existuje způsob, jak definovat proměnnou typu open_modes, přiřadit jí hodnotu jednoho z prvků výčtu a předat ji jako parametr funkci:

open_modes om=vstup; // ...om = append; open_file("TailTell", om);

Názvy takových prvků však není možné získat. Pokud napíšeme výstupní příkaz:

Cout<< input << " " << om << endl;

stále dostáváme:

Tento problém je vyřešen definováním pole řetězců, ve kterém bude prvek s indexem rovným hodnotě prvku enum obsahovat svůj název. S takovým polem můžeme napsat:

Cout<< open_modes_table[ input ] << " " << open_modes_table[ om ] << endl Будет выведено: input append

Také nemůžete iterovat přes všechny hodnoty výčtu:

// není podporováno pro (open_modes iter = input; iter != append; ++inter) // ...

Klíčové slovo enum se používá k definování výčtu a názvy prvků jsou uvedeny ve složených závorkách oddělených čárkami. Ve výchozím nastavení je první 0, další 1 a tak dále. Operátor přiřazení může toto pravidlo změnit. V tomto případě bude každý další prvek bez explicitně zadané hodnoty o 1 více než prvek před ním v seznamu. V našem příkladu jsme explicitně zadali hodnotu 1 pro vstup a výstup a připojení budou 2 a 3. Zde je další příklad:

// tvar == 0, koule == 1, válec == 2, mnohoúhelník == 3 enum Forms( share, spere, cylinder, polygon );

Celočíselné hodnoty odpovídající různým prvkům stejného výčtu se nemusí lišit. Například:

// bod2d == 2, bod2w == 3, bod3d == 3, bod3w == 4 enum Body ( bod2d=2, bod2w, bod3d=3, bod3w=4 );

Objekt, jehož typ je enum, lze definovat, použít ve výrazech a předat funkci jako argument. Takový objekt je pouze inicializován hodnotou jednoho z prvků výčtu a je mu přiřazena pouze tato hodnota, buď explicitně, nebo jako hodnota jiného objektu stejného typu. Nelze k němu přiřadit ani celočíselné hodnoty odpovídající platným prvkům výčtu:

Void mumble() ( Body pt3d = bod3d; // správně: pt2d == 3 // chyba: pt3w je inicializováno na typ int Body pt3w = 3; // chyba: mnohoúhelník není ve výčtu bodů pt3w = mnohoúhelník; // správně : oba objekty typu Body pt3w = pt3d; )

V aritmetických výrazech však lze výčet automaticky převést na typ int. Například:

const int velikost_pole = 1024; // správně: pt2w se převede na int
int chunk_size = velikost_pole * pt2w;

3.9. Zadejte "pole"

Pole jsme se již dotkli v sekci 2.1. Pole je množina prvků stejného typu, ke kterým se přistupuje pomocí indexu – pořadového čísla prvku v poli. Například:

Intival;

definuje ival jako proměnnou typu int a instrukce

int ia[10];

určuje pole deseti objektů int. U každého z těchto objektů, popř prvky pole, lze získat přístup pomocí operace převzetí indexu:

Ival = ia[2];

přiřadí proměnné ival hodnotu prvku pole ia s indexem 2. Podobně

la[7] = ival;

nastaví prvek na indexu 7 na ival.

Definice pole se skládá ze specifikátoru typu, názvu pole a velikosti. Velikost určuje počet prvků pole (alespoň 1) a je uzavřena v hranatých závorkách. Velikost pole musí být známa již v době kompilace, a proto musí být konstantním výrazem, i když to nemusí být doslovný. Zde jsou příklady správných a nesprávných definic pole:

extern int get_size(); // konstanty buf_size a max_files
const int buf_size = 512, max_files = 20;
intstaff_size = 27; // správně: konstantní char input_buffer[ buf_size ]; // správně: konstantní výraz: 20 - 3 char *fileTable[ max_files-3 ]; // chyba: nejde o konstantní dvojnásobné platy[ velikost_personálu ]; // chyba: není konstantní výraz int test_scores[ get_size() ];

Objekty buf_size a max_files jsou konstanty, takže definice pole input_buffer a fileTable jsou správné. Ale staff_size je proměnná (i když inicializovaná na konstantu 27), takže platy jsou nezákonné. (Kompilátor nemůže najít hodnotu proměnné staff_size v době, kdy je definováno pole platů.)
Výraz max_files-3 lze vyhodnotit v době kompilace, takže definice pole fileTable je syntakticky správná.
Číslování prvků začíná od 0, takže pro pole 10 prvků není správný rozsah indexu 1 - 10, ale 0 - 9. Zde je příklad iterace přes všechny prvky pole:

int main() ( const int velikost_pole = 10; int ia[ velikost_pole ]; for (int ix = 0; ix< array_size; ++ ix)
ia[ ix] = ix;
}

Při definování pole jej můžete explicitně inicializovat uvedením hodnot jeho prvků ve složených závorkách, oddělených čárkami:

const int velikost_pole = 3; int ia[velikost_matice] = (0, 1, 2);

Pokud explicitně zadáme seznam hodnot, pak nemůžeme specifikovat velikost pole: kompilátor si počet prvků vypočítá sám:

// pole velikosti 3 int ia = ( 0, 1, 2 );

Když jsou explicitně zadány jak velikost, tak seznam hodnot, existují tři možnosti. Když se velikost a počet hodnot shodují, je vše zřejmé. Pokud je seznam hodnot kratší než zadaná velikost, zbývající prvky pole se inicializují na nulu. Pokud je v seznamu více hodnot, kompilátor zobrazí chybovou zprávu:

// ia ==> ( 0, 1, 2, 0, 0 ) const int velikost_pole = 5; int ia[velikost_matice] = (0, 1, 2);

Pole znaků lze inicializovat nejen pomocí seznamu hodnot znaků ve složených závorkách, ale také pomocí řetězcového literálu. Mezi těmito metodami však existují určité rozdíly. Řekněme

Const char cal = ("C", "+", "+" ); const char cal2 = "C++";

Dimenze pole ca1 je 3, dimenze pole ca2 je 4 (v řetězcových literálech je zohledněn ukončovací znak null). Následující definice způsobí chybu kompilace:

// chyba: řetězec "Daniel" se skládá ze 7 prvků const char ch3[ 6 ] = "Daniel";

Pole nelze přiřadit hodnotu jiného pole a inicializace jednoho pole jiným je také nezákonná. Rovněž není povoleno používat pole odkazů. Zde jsou příklady správného a nesprávného použití polí:

const int velikost_pole = 3; int ix, jx, kx; // správně: pole ukazatelů typu int* int *iar = ( &ix, &jx, &kx ); // chyba: referenční pole jsou neplatná int &iar = ( ix, jx, kx ); int main()
{
int ia3( array_size ]; // správně
// chyba: vestavěná pole nelze zkopírovat
ia3 = ia;
návrat 0;
}

Chcete-li zkopírovat jedno pole do druhého, musíte to udělat pro každý prvek samostatně:

const int velikost_pole = 7; int ia1 = (0, 1, 2, 3, 4, 5, 6); int main() (
int ia3[velikost_pole]; for (int ix = 0; ix< array_size; ++ix)
ia2[ ix] = ia1[ ix]; návrat 0;
}

Index pole může být jakýkoli výraz, který dává výsledek typu celé číslo. Například:

int someVal, get_index(); ia2[ get_index() ] = someVal;

Zdůrazňujeme, že jazyk C++ neposkytuje kontrolu nad indexy polí, a to ani v době kompilace, ani v době běhu. Programátor sám musí zajistit, aby index nepřesahoval hranice pole. Chyby indexu jsou poměrně časté. Bohužel není tak těžké najít příklady programů, které se zkompilují a dokonce i spustí, ale přesto obsahují fatální chyby, které dříve nebo později vedou k havárii.

Cvičení 3.22

Které z následujících definic pole obsahují chyby? Vysvětlit.

(a) int ia[velikost_buf]; (d) int ia[ 2 * 7 - 14] (b) int ia[ get_size() ]; (e) char st[ 11 ] = "základní"; (c) int ia[4*7-14];

Cvičení 3.23

Následující fragment kódu by měl inicializovat každý prvek pole hodnotou indexu. Najděte chyby, které jste udělali:

int main() ( const int velikost_pole = 10; int ia[ velikost_pole ]; for (int ix = 1; ix<= array_size; ++ix)
ia[ia] = ix; //...
}

3.9.1. Vícerozměrná pole

V C++ je možné použít vícerozměrná pole, která musí být deklarována s pravou hranicí každé dimenze v samostatných hranatých závorkách. Zde je definice dvourozměrného pole:

Int ia[ 4][3];

První hodnota (4) udává počet řádků, druhá (3) počet sloupců. Objekt ia je definován jako pole čtyř řetězců, každý se třemi prvky. Vícerozměrná pole lze také inicializovat:

Int ia[4][3] = ((0, 1,2), (3, 4, 5), (6, 7, 8), (9, 10, 11));

Vnitřní složené závorky, které rozdělují seznam hodnot na řádky, jsou volitelné a používají se zpravidla pro čitelnost kódu. Následující inicializace je úplně stejná jako v předchozím příkladu, i když méně jasná:

int ia = (0,1,2,3,4,5,6,7,8,9,10,11);

Následující definice inicializuje pouze první prvky každého řádku. Zbývající prvky budou nulové:

Int ia[4][3] = ((0), (3), (6), (9));

Pokud vynecháte vnitřní kudrnatá rovnátka, je výsledek úplně jiný. Všechny tři prvky prvního řádku a první prvek druhého obdrží zadanou hodnotu a zbytek bude implicitně inicializován na 0.

Int ia[4][3] = (0, 3, 6, 9);

Při přístupu k prvkům vícerozměrného pole musíte použít indexy pro každý rozměr (jsou uzavřeny v hranatých závorkách). Takto vypadá inicializace dvourozměrného pole pomocí vnořených smyček:

int main() ( const int rowSize = 4; const int colSize = 3; int ia[ rowSize ][ colSize ]; for (int = 0; i< rowSize; ++i)
for (int j = 0; j< colSize; ++j)
ia[i][j] = i + j j;
}

Design

Ia[1, 2]

je platný z hlediska syntaxe C++, ale neznamená to, co by nezkušený programátor očekával. V žádném případě se nejedná o deklaraci dvojrozměrného pole 1 x 2. Agregát v hranatých závorkách je seznam výrazů oddělených čárkami, jejichž výsledkem bude konečná hodnota 2 (viz operátor „čárka“ v části 4.2 ). Proto je deklarace ia ekvivalentní ia. To je další příležitost udělat chybu.

3.9.2. Vztah mezi poli a ukazateli

Pokud máme definici pole:

Int ia = (0, 1, 1, 2, 3, 5, 8, 13, 21);

co potom znamená jednoduché uvedení jeho jména v programu?

Použití identifikátoru pole v programu je ekvivalentní zadání adresy jeho prvního prvku:

Podobně existují dva způsoby přístupu k hodnotě prvního prvku pole:

// oba výrazy vrátí první prvek *ia; IA;

Abychom převzali adresu druhého prvku pole, napsali bychom:

Jak jsme již zmínili, výraz

také poskytuje adresu druhého prvku pole. Jeho hodnota je nám tedy dána následujícími dvěma způsoby:

*(ia+1); IA;

Všimněte si rozdílu ve výrazech:

*ia+1 a *(ia+1);

Operace dereference má vyšší prioritou než operace sčítání (další informace o prioritě operátorů naleznete v části 4.13). Proto první výraz nejprve dereferencuje proměnnou ia a získá první prvek pole a poté k němu přidá 1. Druhý výraz dodá hodnotu druhého prvku.

Pole můžete iterovat pomocí indexu, jak jsme to udělali v předchozí části, nebo pomocí ukazatelů. Například:

#zahrnout int main() ( int ia = ( 0, 1, 1, 2, 3, 5, 8, 13, 21 ); int *pbegin = ia; int *pend = ia + 9; while (pbegin != pend) ( cout<< *pbegin <<; ++pbegin; } }

Ukazatel pbegin je inicializován adresou prvního prvku pole. Každá iterace smyčkou zvýší tento ukazatel o 1, což znamená, že se přesune na další prvek. Jak zjistit, kde se ubytovat? V našem příkladu jsme definovali druhý pend pointer a inicializovali jej s adresou následující za posledním prvkem pole ia. Jakmile se hodnota pbegin rovná pend, víme, že pole je u konce. Přepišme tento program tak, aby začátek a konec pole byly předány jako parametry nějaké obecné funkci, která dokáže vytisknout pole libovolné velikosti:

#zahrnout void ia_print(int *pbegin, int *pend) (
while (pbegin != pend) (
cout<< *pbegin << " ";
++pbegin;
}
) int main()
{
int ia = (0, 1, 1, 2, 3, 5, 8, 13, 21);
ia_print(ia, ia + 9);
}

Naše funkce se stala univerzálnější, nicméně umí pracovat pouze s poli int. Existuje způsob, jak toto omezení také odstranit: převést danou funkci na šablonu (šablony byly krátce představeny v sekci 2.5):

#zahrnout šablona void print(elemType *pbegin, elemType *pend) ( while (pbegin != pend) ( cout<< *pbegin << " "; ++pbegin; } }

Nyní můžeme zavolat naši funkci print() k tisku polí libovolného typu:

int main() ( int ia = ( 0, 1, 1, 2, 3, 5, 8, 13, 21 ); double da = ( 3,14, 6,28, 12,56, 25,12 ); string sa = ( "prasátko", " eyore", "pú" ); print(ia, ia+9);
print(da,da+4);
tisknout(sa, sa+3);
}

Psali jsme zobecněný funkce. Standardní knihovna poskytuje sadu generických algoritmů (již jsme to zmínili v sekci 3.4) implementovaných tímto způsobem. Parametry takových funkcí jsou ukazatele na začátek a konec pole, se kterým provádějí určité akce. Zde je například uvedeno, jak vypadají volání obecného algoritmu řazení:

#zahrnout int main() ( int ia = ( 107, 28, 3, 47, 104, 76 ); string sa = ( "prasátko", "eeyore", "pú" ); sort(ia, ia+6);
sort(sa, sa+3);
};

(Zobecněné algoritmy podrobně probereme v kapitole 12; příklady jejich použití budou uvedeny v příloze.)
Standardní knihovna C++ obsahuje sadu tříd, které zapouzdřují použití kontejnerů a ukazatelů. (Probrali jsme to v části 2.8.) V další části se podíváme na standardní vektor typu kontejneru, což je objektově orientovaná implementace pole.

3.10. vektorová třída

Použití třídy vector (viz část 2.8) je alternativou k používání vestavěných polí. Tato třída poskytuje mnohem více funkcí, takže její použití je vhodnější. Existují však situace, kdy se pole vestavěného typu nelze obejít. Jednou z těchto situací je zpracování parametrů příkazového řádku předávaných programu, o kterém pojednáme v části 7.8. Třída vector, stejně jako třída string, je součástí standardní knihovny C++.
Chcete-li použít vektor, musíte zahrnout soubor záhlaví:

#zahrnout

Existují dva zcela odlišné přístupy k použití vektoru, nazvěme je idiom pole a idiom STL. V prvním případě se objekt třídy vector používá stejným způsobem jako pole vestavěného typu. Vektor dané dimenze je definován:

vektor< int >ivec(10);

což je stejné jako definování pole vestavěného typu:

int ia[10];

Pro přístup k jednotlivým prvkům vektoru se používá operace převzetí indexu:

Void simp1e_examp1e() ( const int e1em_size = 10; vektor< int >ivec(e1em_velikost); int ia[ e1em_velikost ]; for (int ix = 0; ix< e1em_size; ++ix)
ia[ ix ] = ivec[ ix ]; //...
}

Velikost vektoru můžeme zjistit pomocí funkce size() a zkontrolovat, zda je vektor prázdný, pomocí funkce empty(). Například:

Void print_vector(vektor ivec) ( if (ivec.empty()) return; for (int ix=0; ix< ivec.size(); ++ix)
cout<< ivec[ ix ] << " ";
}

Vektorové prvky jsou inicializovány s výchozími hodnotami. Pro číselné typy a ukazatele je tato hodnota 0. Pokud objekty třídy fungují jako prvky, pak je jejich iniciátor určen výchozím konstruktorem (viz oddíl 2.3). Iniciátor však může být také specifikován explicitně pomocí formuláře:

vektor< int >ivec(10, -1);

Všech deset prvků vektoru se bude rovnat -1.
Pole vestavěného typu lze explicitně inicializovat pomocí seznamu:

int ia[6] = (-2, -1, 0, 1, 2, 1024);

Pro objekt třídy vector není podobná akce možná. Takový objekt však lze inicializovat pomocí pole vestavěného typu:

// 6 prvků ia se zkopíruje do vektoru ivec< int >ivec(ia, ia+6);

Do vektorového konstruktoru ivec jsou předány dva ukazatele - ukazatel na začátek pole ia a na prvek následující za posledním. Jako seznam počátečních hodnot je přípustné zadat ne celé pole, ale některé z jeho rozsahu:

// Kopírují se 3 prvky: ia, ia, ia vector< int >ivec(&ia[2], &ia[5]);

Dalším rozdílem mezi vektorem a polem vestavěného typu je schopnost inicializovat jeden objekt typu vector s jiným a ke kopírování objektů použít operátor přiřazení. Například:

vektor< string >svec; void init_and_assign() ( // jeden vektor je inicializován jiným vektorem< string >user_names(svec); // ... // jeden vektor je zkopírován do druhého
svec = uživatelská_jména;
}

Když už mluvíme o idiomu STL, máme na mysli velmi odlišný přístup k použití vektoru. Místo okamžitého nastavení správné velikosti definujeme prázdný vektor:

vektor< string >text;

Pak do něj pomocí různých funkcí přidáváme prvky. Například funkce push_back() vloží prvek na konec vektoru. Zde je část kódu, která čte sekvenci řádků ze standardního vstupu a přidává je do vektoru:

řetězec; while (cin >> slovo) ( text.push_back(word); // ... )

I když můžeme použít operaci vzít index k iteraci prvků vektoru:

Cout<< "считаны слова: \n"; for (int ix =0; ix < text.size(); ++ix) cout << text[ ix ] << " "; cout << endl;

typičtější v tomto idiomu by bylo použití iterátorů:

Cout<< "считаны слова: \n"; for (vector::iterator it = text.begin(); it != text.end(); ++it) cout<< *it << " "; cout << endl;

Iterátor je standardní třída knihovny, která je ve skutečnosti ukazatelem na prvek pole.
Výraz

dereferencuje iterátor a dává samotný vektorový prvek. Návod

Posune ukazatel na další prvek. Není třeba tyto dva přístupy míchat. Při definování prázdného vektoru postupujte podle idiomu STL:

vektor ivec;

Byla by chyba napsat:

Zatím nemáme jediný prvek vektoru ivec; počet prvků se zjistí pomocí funkce size().

Můžete udělat i opačnou chybu. Pokud jsme definovali vektor nějaké velikosti, například:

vektor ia(10);

Pak vkládání prvků zvětší jeho velikost přidáním nových prvků k existujícím. Ačkoli se to zdá zřejmé, začínající programátor by mohl snadno napsat:

Const int size = 7; int ia[velikost] = (0, 1, 1, 2, 3, 5, 8); vektor< int >ivec(velikost); for (int ix = 0; ix< size; ++ix) ivec.push_back(ia[ ix ]);

To znamenalo inicializaci vektoru ivec s hodnotami prvků ia, místo kterých jsme dostali vektor ivec o velikosti 14.
Podle idiomu STL můžete prvky vektoru nejen přidávat, ale také odebírat. (To vše podrobně a s příklady probereme v kapitole 6.)

Cvičení 3.24

Jsou v následujících definicích chyby?
int ia[7] = (0, 1, 1, 2, 3, 5, 8);

(a) vektor< vector< int >>ivec;
(b) vektor< int >ivec = (0, 1, 1, 2, 3, 5, 8);
(c) vektor< int >ivec(ia, ia+7);
(d) vektor< string >svec = ivec;
(e)vektor< string >svec(10, string("null"));

Cvičení 3.25

Implementujte následující funkci:
bool is_equal(const int*ia, int ia_size,
konstantní vektor &ivec);
Funkce is_equal() porovnává dva kontejnery prvek po prvku. V případě různých velikostí nádob se „ocas“ delší nezohledňuje. Je jasné, že pokud jsou všechny porovnávané prvky stejné, funkce vrací true, pokud se alespoň jeden liší, false. K iteraci prvků použijte iterátor. Napište funkci main(), která volá is_equal().

3.11. komplexní třída

Třída komplexních čísel je další třídou ze standardní knihovny. Jako obvykle, abyste jej mohli použít, musíte zahrnout soubor záhlaví:

#zahrnout

Komplexní číslo má dvě části – reálnou a imaginární. Imaginární část je druhá odmocnina záporného čísla. Komplexní číslo se obvykle zapisuje jako

kde 2 je skutečná část a 3i je imaginární část. Zde jsou příklady komplexních definic objektů:

// čisté imaginární číslo: 0 + 7-i komplex< double >purei(0,7); // imaginární část je 0:3 + komplex Oi< float >real1_num(3); // skutečná i imaginární část jsou 0: 0 + 0-i komplexní< long double >nula; // inicializace jednoho komplexního čísla jiným komplexem< double >purei2(purei);

Protože komplex, stejně jako vektor, je šablona, ​​můžeme ji vytvořit pomocí float, double a long double, jako ve výše uvedených příkladech. Můžete také definovat řadu složitých prvků:

Komplex< double >konjugovat[2] = (komplex< double >(2, 3), komplexní< double >(2, -3) };

Komplex< double >*ptr = komplexní< double >&ref = *ptr;

3.12. směrnice typedef

Direktiva typedef umožňuje zadat synonymum pro vestavěný nebo uživatelem definovaný datový typ. Například:

Typedef dvojnásobné mzdy; typedef vektor vec_int; typedef vec_int test_scores; typedef bool docházka; typedef int *Pint;

Názvy definované direktivou typedef lze použít stejným způsobem jako specifikátory typu:

// double hourly, weekly; mzda hodinová, týdenní; // vektor vecl(10);
vec_int vecl(10); // vektor test0(velikost_c1ass); const int c1ass_size = 34; test_scores test0(c1ass_size); // vektor< bool >účast; vektor< in_attendance >docházka(c1ass_size); // int *tabulka[ 10 ]; Půllitr [ 10 ];

Tato direktiva začíná klíčovým slovem typedef následovaným specifikátorem typu a končí identifikátorem, který se stane aliasem pro zadaný typ.
K čemu slouží názvy definované direktivou typedef? Použitím mnemotechnických názvů pro datové typy můžete usnadnit pochopení svého programu. Je také obvyklé používat taková jména pro složité, jinak těžko srozumitelné komplexní typy (viz příklad v části 3.14), k deklaraci ukazatelů na funkce a členské funkce třídy (viz část 13.6).
Následuje příklad otázky, na kterou téměř každý odpoví špatně. Chyba je způsobena nesprávným pochopením direktivy typedef jako jednoduché textové substituce makra. Definice je dána:

Typedef char *cstring;

Jaký je typ proměnné cstr v následující deklaraci:

extern const cstring cstr;

Odpověď, která se zdá zřejmá, je:

Const char *cstr

To však není pravda. Specifikátor const odkazuje na cstr, takže správnou odpovědí je ukazatel const na char:

Char *const cstr;

3.13. těkavý specifikátor

Objekt je deklarován jako nestálý (nestabilní, asynchronně proměnlivý), pokud lze jeho hodnotu změnit, aniž by si toho kompilátor všiml, jako je například proměnná aktualizována systémovými hodinami. Tento specifikátor říká kompilátoru, aby neoptimalizoval kód pro práci s daným objektem.
Těkavý specifikátor se používá jako specifikátor const:

Volatile int disp1ay_register; volatile Task *curr_task; volatile int ixa[ max_velikost ]; nestálá obrazovka bitmap_buf;

display_register je nestabilní objekt typu int. curr_task je ukazatel na nestabilní objekt Task. ixa je nestabilní pole celých čísel a každý prvek takového pole je považován za nestabilní. bitmap_buf je nestálý objekt třídy Screen, každý jeho datový člen je také považován za nestálý.
Jediným účelem použití nestálého specifikátoru je sdělit kompilátoru, že nemůže určit, kdo a jak může změnit hodnotu daného objektu. Proto by kompilátor neměl optimalizovat kód, který tento objekt používá.

3.14. párová třída

Třída pair standardní knihovny C++ nám umožňuje definovat pár hodnot s jedním objektem, pokud mezi nimi existuje nějaký sémantický vztah. Tyto hodnoty mohou být stejného nebo různého typu. Chcete-li použít tuto třídu, musíte zahrnout soubor záhlaví:

#zahrnout

Například návod

Pár< string, string >autor("James", "Joyce");

vytvoří autorský objekt typu pair, který se skládá ze dvou řetězcových hodnot.
Jednotlivé části páru lze získat pomocí prvního a druhého členu:

String firstBook; if (Joyce.first == "James" &&
Joyce.second == "Joyce")
první kniha = "Stephen Hero";

Pokud potřebujete definovat několik objektů stejného typu této třídy, je vhodné použít direktivu typedef:

Typedef pár< string, string >Autoři; Autoři proust("marcel", "proust"); Autoři joyce("James", "Joyce"); Autoři musil("robert", "musi1");

Zde je další příklad použití páru. První hodnota obsahuje jméno nějakého objektu, druhá je ukazatel na prvek tabulky odpovídající tomuto objektu.

Class EntrySlot; extern EntrySlot* 1ook_up(string); typedef pár< string, EntrySlot* >SymbolEntry; SymbolEntry current_entry("autor", 1ook_up("author"));
// ... if (EntrySlot *it = 1ook_up("editor")) (
current_entry.first = "editor";
aktuální_vstup.sekunda = it;
}

(Vrátíme se k diskusi o párové třídě v kapitole 6 o typech kontejnerů a generických algoritmech v kapitole 12.)

3.15. Typy tříd

Mechanismus třídy umožňuje vytvářet nové datové typy; zavedlo výše uvedené typy řetězců, vektorů, komplexů a párů. V kapitole 2 jsme hovořili o konceptech a mechanismech, které podporují objektově a objektově orientovaný přístup, a jako příklad jsme použili implementaci třídy Array. Zde na základě objektového přístupu vytvoříme jednoduchou třídu String, jejíž implementace pomůže pochopit zejména přetěžování operátorů – o tom jsme hovořili v části 2.3. (Třídy jsou podrobně popsány v kapitolách 13, 14 a 15). Uvedli jsme stručný popis třídy, abychom uvedli zajímavější příklady. Čtenář, který se teprve začíná učit C++, může tuto část přeskočit a počkat na systematičtější popis tříd v dalších kapitolách.)
Naše třída String musí podporovat inicializaci s objektem třídy String, řetězcovým literálem a vestavěným typem řetězce a také operaci přiřazování hodnot těchto typů. Používáme k tomu konstruktory tříd a přetížený operátor přiřazení. Přístup k jednotlivým znakům řetězce bude implementován jako přetížený operátor indexového odběru. Dále potřebujeme: funkci size() pro získání informace o délce řetězce; operace porovnávání objektů typu String a objektu String s řetězcem vestavěného typu; stejně jako I/O operace našeho objektu. Nakonec implementujeme možnost přístupu k interní reprezentaci našeho řetězce jako vestavěný typový řetězec.
Definice třídy začíná klíčovým slovem class následovaným identifikátorem, názvem třídy nebo typu. Obecně se třída skládá z částí, kterým předcházejí slova public (otevřená) a private (uzavřená). Otevřená sekce obvykle obsahuje sadu operací podporovaných třídou, nazývaných metody nebo členské funkce třídy. Tyto členské funkce definují veřejné rozhraní třídy, jinými slovy, sadu akcí, které lze provádět s objekty této třídy. Soukromá sekce obvykle zahrnuje datové členy, které poskytují interní implementaci. V našem případě mezi interní členy patří _string - ukazatel na char, stejně jako _size typu int. _size bude ukládat informace o délce řetězce a _string je dynamicky alokované pole znaků. Takto vypadá definice třídy:

#zahrnout třída String; istream& operátor>>(istream&, String&);
stream a operátor<<(ostream&, const String&); class String {
veřejnost:
// sada konstruktorů
// pro automatickou inicializaci
// Stringstrl; // tětiva()
// String str2("doslovný"); // String(const char*);
// String str3(str2); // String(const String&); tětiva();
string(const char*);
String(const String&); // destruktor
~řetězec(); // operátory přiřazení
// strl = str2
// str3 = "řetězcový literál" String& operator=(const String&);
String& operator=(const char*); // operátory rovnosti
// strl == str2;
// str3 == "řetězcový literál"; bool operator==(const String&);
bool operator==(const char*); // přetížení přístupového operátora indexem
// strl[ 0 ] = str2[ 0 ]; char& operator(int); // přístup ke členům třídy
int size() ( return _size; )
char* c_str() ( return _string; ) private:
int_size;
char*_string;
}

Třída String má tři konstruktory. Jak je uvedeno v části 2.3, mechanismus přetížení umožňuje definovat více implementací funkcí se stejným názvem, pokud se všechny liší v počtu a/nebo typech svých parametrů. První konstruktér

Je to výchozí konstruktor, protože nevyžaduje explicitní počáteční hodnotu. Když píšeme:

Pro str1 se takový konstruktor nazývá.
Dva zbývající konstruktory mají každý jeden parametr. Ano, pro

String str2("řetězec znaků");

Zavolá se konstruktor

string(const char*);

řetězec str3(str2);

Konstruktér

String(const String&);

Typ volaného konstruktoru je určen typem skutečného argumentu. Poslední konstruktor, String(const String&), se nazývá kopírovací konstruktor, protože inicializuje objekt s kopií jiného objektu.
Pokud napíšete:

stringstr4(1024);

To způsobí chybu kompilace, protože neexistuje žádný konstruktor s parametrem typu int.
Deklarace přetíženého operátora má následující formát:

operátor návratového_typu op(seznam_parametrů);

Kde operátor je klíčové slovo a op je jeden z předdefinovaných operátorů: +, =, == atd. (Přesnou definici syntaxe naleznete v kapitole 15.) Zde je deklarace přetíženého operátoru dolního indexu:

Char& operator(int);

Tento operátor má jeden parametr typu int a vrací odkaz na char. Přetížený operátor může být sám přetížen, pokud se seznamy parametrů jednotlivých instancí liší. Pro naši třídu String vytvoříme každý dva různé operátory přiřazení a rovnosti.
Chcete-li volat členskou funkci, použijte operátory přístupu členů tečka (.) nebo šipka (->). Řekněme, že máme deklarace objektů typu String:

String object("Danny");
String *ptr = new String("Anna");
Stringarray;
Takto vypadá volání funkce size() pro tyto objekty:
vektor velikosti(3);

// přístup členů pro objekty (.); // objekty mají 5 velikostí[ 0 ] = object.size(); // přístup členů pro ukazatele (->)
// ptr má velikost 4
velikosti[ 1 ] = ptr->velikost(); // přístup členů (.)
// pole má velikost 0
size[ 2 ] = array.size();

Vrací 5, 4 a 0 v tomto pořadí.
Přetížené operátory jsou aplikovány na objekt stejným způsobem jako normální operátory:

String name("Yadie"); Stringname2("Yodie"); // bool operátor==(const String&)
if (jméno == jméno2)
vrátit se;
jiný
// String& operator=(const String&)
jmeno=jméno2;

Deklarace členské funkce musí být uvnitř definice třídy a definice funkce může být uvnitř nebo vně definice třídy. (Velikost() i c_str() jsou definovány uvnitř třídy.) Pokud je funkce definována mimo třídu, musíme mimo jiné určit, do které třídy patří. V tomto případě je definice funkce umístěna do zdrojového souboru, řekněme String.C, a definice samotné třídy je umístěna do hlavičkového souboru (v našem příkladu String.h), který by měl být zahrnut ve zdrojovém souboru:

// obsah zdrojového souboru: String.C // včetně definice třídy String
#include "String.h" // zahrnout definici funkce strcmp().
#zahrnout
bool // návratový typ
String:: // třída, do které funkce patří
operator== // název funkce: operátor rovnosti
(const String &rhs) // seznam parametrů
{
if (_velikost != rhs._size)
vrátit false;
return strcmp(_stringq, rhs._string) ?
nepravda: pravda;
}

Připomeňme, že strcmp() je standardní funkce knihovny C. Porovnává dva vestavěné řetězce typu, přičemž vrací 0, pokud jsou řetězce stejné, a nenulové, pokud ne. Podmíněný operátor (?:) testuje hodnotu před otazníkem. Pokud je to pravda, vrátí se hodnota výrazu nalevo od dvojtečky, jinak je napravo od dvojtečky. V našem příkladu je hodnota výrazu nepravdivá, pokud strcmp() vrátila nenulovou hodnotu, a pravdivá, pokud je null. (Podmíněný operátor je uveden v části 4.7.)
Porovnávací operace se používá poměrně často, funkce, která ji implementuje, se ukázala jako malá, proto je užitečné tuto funkci deklarovat jako zabudovanou (inline). Kompilátor místo volání nahradí text funkce, takže na takové volání nestráví žádný čas. (Vestavěné funkce jsou popsány v části 7.6.) Členská funkce definovaná v rámci třídy je ve výchozím nastavení vestavěná. Pokud je definováno mimo třídu, k jeho deklaraci jako inline musíte použít klíčové slovo inline:

Inline bool String::operator==(const String &rhs) ( // ditto )

Definice vložené funkce musí být v hlavičkovém souboru obsahujícím definici třídy. Předefinováním operátoru == jako vestavěného operátoru musíme přesunout samotný text funkce ze souboru String.C do souboru String.h.
Následuje implementace operace porovnávání objektu String s vestavěným typem řetězce:

Inline bool String::operator==(const char *s) ( return strcmp(_string, s) ? false: true; )

Název konstruktoru je stejný jako název třídy. Nepovažuje se za návratovou hodnotu, takže návratovou hodnotu nemusíte zadávat ani v její definici, ani v jejím těle. Konstruktorů může být více. Jako každá jiná funkce mohou být deklarovány jako inline.

#zahrnout // výchozí vložený konstruktor String::String()
{
_size=0;
_string=0;
) inline String::String(const char *str) ( if (! str) ( _size = 0; _string = 0; ) else ( _size = str1en(str); strcpy(_string, str); ) // kopírovat konstruktor
inline String::String(const String &rhs)
{
velikost = rhs._size;
if(!rhs._string)
_string=0;
jiný(
_string = nový znak[_velikost + 1];
} }

Vzhledem k tomu, že jsme dynamicky alokovali paměť pomocí operátoru new, musíme ji uvolnit voláním smazání, když již nepotřebujeme objekt String. K tomuto účelu slouží další speciální členská funkce, destruktor, který je automaticky volán pro objekt, když tento objekt přestane existovat. (Viz kapitola 7 o životnosti objektu.) Název destruktoru je tvořen znakem vlnovky (~) a názvem třídy. Zde je definice destruktoru třídy String. Zde voláme operaci odstranění, abychom uvolnili paměť alokovanou v konstruktoru:

Vložený řetězec: :~String() ( smazat _string; )

Oba přetížené operátory přiřazení používají speciální klíčové slovo this.
Když píšeme:

String name("orville"), name2("wilbur");
name = "Orville Wright";
toto je ukazatel adresující objekt name1 v těle funkce operace přiřazení.
to vždy ukazuje na objekt třídy, přes který je funkce volána. Li
ptr->velikost();
obj[1024];

Pak uvnitř size() bude jeho hodnota adresa uložená v ptr. Uvnitř operace get index obsahuje adresu obj. Dereferencováním tohoto (pomocí *this) získáme samotný objekt. (Tento ukazatel je podrobně popsán v části 13.4.)

Inline String& String::operator=(const char *s) ( if (! s) ( _size = 0; delete _string; _string = 0; ) else ( _size = str1en(s); delete _string; _string = new char[ _size + 1 ]; strcpy(_string, s); ) return *toto; )

Při implementaci operace přiřazení dochází poměrně často k jedné chybě: zapomínají zkontrolovat, zda kopírovaný objekt není stejný, do kterého se kopíruje. Tuto kontrolu provedeme pomocí stejného ukazatele:

Inline String& String::operator=(const String &rhs) ( // ve výrazu // name = *pointer_to_string // toto je jméno1, // rhs - *pointer_to_string. if (toto != &rhs) (

Zde je úplný text operace pro přiřazení objektu stejného typu k objektu String:

Inline String& String::operator=(const String &rhs) ( if (toto != &rhs) ( smazat _string; _size = rhs._size; if (! rhs._string)
_string=0;
jiný(
_string = nový znak[_velikost + 1];
strcpy(_string, rhs._string);
}
}
vrátit *toto;
}

Operace dolního indexu je téměř stejná jako implementace pro pole, které jsme vytvořili v sekci 2.3:

#zahrnout vložený znak&
String::operator (prvek int)
{
tvrdit(elem >= 0 && el< _size);
return _string[elem];
}

Vstupní a výstupní operátory jsou implementovány jako samostatné funkce, nikoli členové třídy. (Důvody probereme v části 15.2. Části 20.4 a 20.5 pojednávají o přetížení vstupních a výstupních operátorů knihovny iostream.) Náš vstupní operátor nemůže číst více než 4095 znaků. setw() je předdefinovaný manipulátor, který čte daný počet znaků mínus 1 ze vstupního toku, čímž zajišťuje, že nepřetečeme náš interní inBuf buffer. (Kapitola 20 podrobně pojednává o manipulátoru setw().) Chcete-li použít manipulátory, musíte zahrnout příslušný soubor záhlaví:

#zahrnout inline istream& operator>>(istream &io, String &s) ( // umělý limit: 4096 znaků const int 1imit_string_size = 4096; char inBuf[ limit_string_size ]; // setw() je součástí knihovny iostream // omezuje blok čtení size to 1imit_string_size -l io >> setw(1imit_string_size) >> inBuf; s = mBuf; // String::operator=(const char*); return io; )

Výstupní příkaz potřebuje přístup k interní reprezentaci řetězce. Od operátora<< не является функцией-членом, он не имеет доступа к закрытому члену данных _string. Ситуацию можно разрешить двумя способами: объявить operator<< дружественным классу String, используя ключевое слово friend (дружественные отношения рассматриваются в разделе 15.2), или реализовать встраиваемую (inline) функцию для доступа к этому члену. В нашем случае уже есть такая функция: c_str() обеспечивает доступ к внутреннему представлению строки. Воспользуемся ею при реализации операции вывода:

Inline ostream & operátor<<(ostream& os, const String &s) { return os << s.c_str(); }

Následuje příklad programu, který používá třídu String. Tento program bere slova ze vstupního proudu a počítá jejich celkový počet, stejně jako počet slov „the“ a „it“ a registruje samohlásky, se kterými se setká.

#zahrnout #include "String.h" int main() ( int aCnt = 0, eCnt = 0, iCnt = 0, oCnt = 0, uCnt = 0, theCnt = 0, itCnt = 0, wdCnt = 0, notVowel = 0; / / Slova "The" a "It"
// zkontrolujeme operátorem==(const char*)
String but, the("the"), it("it"); // operátor>>(ostream&, String&)
while (cin >> buf) (
++wdCnt; // operátor<<(ostream&, const String&)
cout<< buf << " "; if (wdCnt % 12 == 0)
cout<< endl; // String::operator==(const String&) and
// String::operator==(const char*);
if (buf == the | | buf == "The")
++theCnt;
jiný
if (buf == to || buf == "To")
++itCnt; // vyvolá String::s-ize()
for (int ix = 0; ix< buf.sizeO; ++ix)
{
// vyvolá řetězec:: operátor(int)
switch(buf[ix])
{
případ "a": případ "A": ++aCnt; přestávka;
případ "e": případ "E": ++eCnt; přestávka;
případ "i": případ "I": ++iCnt; přestávka;
případ "o": případ "0": ++oCnt; přestávka;
případ "u": případ "U": ++uCnt; přestávka;
výchozí: ++notVowe1; přestávka;
}
}
) // operátor<<(ostream&, const String&)
cout<< "\n\n"
<< "Слов: " << wdCnt << "\n\n"
<< "the/The: " << theCnt << "\n"
<< "it/It: " << itCnt << "\n\n"
<< "согласных: " < << "a: " << aCnt << "\n"
<< "e: " << eCnt << "\n"
<< "i: " << ICnt << "\n"
<< "o: " << oCnt << "\n"
<< "u: " << uCnt << endl;
}

Pojďme si program vyzkoušet: nabídneme mu odstavec z dětského příběhu, který napsal jeden z autorů této knihy (s tímto příběhem se setkáme v 6. kapitole). Zde je výstup z programu:

Alice Emma má dlouhé rozpuštěné zrzavé vlasy. Její tatínek říká, že když jí vítr fouká do vlasů, vypadají skoro jako živé, jako ohnivý pták v letu. Krásný ohnivý pták, říká jí, kouzelný, ale nezkrotný. "Tati, šup, nic takového neexistuje," říká mu a zároveň chce, aby jí řekl víc. Plaše se zeptá: "Myslím, tati, je tam?" Slova: 65
the/The: 2
to/to: 1
souhlásky: 190
a:22
e:30
já:24
asi: 10
ty:7

Cvičení 3.26

V našich implementacích konstruktorů a operátorů přiřazení se hodně opakuje. Zvažte přesunutí opakujícího se kódu do samostatné soukromé členské funkce, jak jsme to udělali v části 2.3. Ujistěte se, že nová možnost funguje.

Cvičení 3.27

Upravte testovací program tak, aby počítal i souhlásky b, d, f, s, t.

Cvičení 3.28

Napište členskou funkci, která počítá počet výskytů znaku v řetězci pomocí následující deklarace:

Class String ( public: // ... int count(char ch) const; // ... );

Cvičení 3.29

Implementujte operátor zřetězení řetězců (+) tak, aby zřetězil dva řetězce a vrátil výsledek v novém objektu String. Zde je deklarace funkce:

Class String ( public: // ... Operátor řetězce+(const String &rhs) const; // ... );

Datový typ v programování je kolekce dvou sad: sada hodnot a sada operací, které na ně lze použít. Například nezáporný celočíselný datový typ, který se skládá z konečné množiny přirozených čísel, lze použít na operace sčítání (+), násobení (*), dělení celého čísla (/), zbytek (%) a odčítání (-).

Programovací jazyk má obvykle sadu primitivních datových typů – typů poskytovaných programovacím jazykem jako základní vestavěná jednotka. V C++ nazývá tvůrce jazyka takové typy základními typy. Základní typy v C++ jsou:

• boolean (bool);
• znak (např. char);
• celé číslo (např. int);
• plovoucí desetinná čárka (např. plovoucí);
• výčty (definované programátorem);
• prázdnota

Kromě výše uvedeného jsou vytvořeny následující typy:

• ukazatele (např. int*);
• pole (např. char);
• odkaz (např. double&);
• jiné struktury.

Přejděme ke konceptu literálu (např. 1, 2.4F, 25e-4, ‚a‘ atd.): literál je záznam ve zdrojovém kódu programu, který představuje pevnou hodnotu. Jinými slovy, literál je jednoduše reprezentace objektu (hodnoty) nějakého typu v kódu programu. C++ má schopnost zapisovat celočíselné hodnoty, hodnoty s pohyblivou řádovou čárkou, znakové, booleovské, řetězcové hodnoty.

Literál typu celé číslo lze zapsat jako:

• 10. číselná soustava. Například 1205;
• 8. číselná soustava ve formátu 0 + číslo. Například 0142;
• 16. číselná soustava ve formátu 0x + číslo. Například 0x2F .

24, 030, 0x18 jsou všechny položky stejného čísla v různých číselných soustavách.
Pro zápis čísel s plovoucí desetinnou čárkou se používá tečkový zápis: 0,1, 0,5, 4. - buď v
exponenciální zápis - 25e-100. V takovém záznamu by neměla být žádná mezera.

Název, se kterým můžeme spojit hodnoty zapsané literály, se nazývá proměnná. Proměnná je pojmenované nebo jinak adresovatelné místo v paměti, jehož adresu lze použít pro přístup k datům. Tato data jsou během provádění programu určitým způsobem zapsána, přepsána a vymazána v paměti. Proměnná umožňuje kdykoli přistupovat k datům a v případě potřeby je měnit. Data, která lze načíst z názvu proměnné, se nazývají hodnota proměnné.
Aby bylo možné v programu použít proměnnou, musí být deklarována a v případě potřeby může být definována (= inicializována). Deklarace proměnné v textu programu nutně obsahuje 2 části: základní typ a deklarátor. Specifikátor a inicializátor jsou volitelné části:

const int příklad = 3; // zde const - specifikátor // int - základní typ // příklad - název proměnné // = 3 - inicializátor.

Název proměnné je posloupnost znaků z písmen latinské abecedy (malá a velká), čísel a/nebo podtržítek, ale první znak nemůže být číslice. Název proměnné by měl být zvolen tak, aby bylo vždy snadné uhodnout, co ukládá, například „monthPayment“. Abstraktně i v praxi budeme pro pravidla pro zápis proměnných používat notaci CamelCase. Název proměnné se nemůže shodovat se slovy vyhrazenými v jazyce, příklady takových slov: if, while, function, goto, switch atd.

Deklarátor může kromě názvu proměnné obsahovat další znaky:

• * - ukazatel; před jménem
• *const - konstantní ukazatel; před jménem
• & - odkaz; před jménem
• - pole; za jménem;
• () - funkce; za jménem.

Inicializátor umožňuje definovat hodnotu proměnné bezprostředně po deklaraci. Inicializátor začíná literálem rovná se (=) a poté probíhá proces nastavení hodnoty proměnné. Obecně řečeno, rovnítko v C++ označuje operaci přiřazení; lze jej použít k nastavení a změně hodnoty proměnné. U různých typů se může lišit.

Specifikátor určuje další atributy jiné než typ. Specifikátor const uvedený v příkladu umožňuje zakázat následné změny hodnoty proměnné. Takové neměnné proměnné se nazývají konstantní nebo konstantní.

Deklarování konstanty bez inicializace nebude fungovat z logických důvodů:

Const int EMPTY_CONST; // chyba, konstantní proměnná není inicializována const int PŘÍKLAD = 2; // konstanta s hodnotou 2 EXAMPLE = 3; // chyba, pokuste se přiřadit hodnotu konstantní proměnné

Pro pojmenování konstant je zvykem používat pouze velká písmena, slova oddělující znakem podtržítka.

Základní datové typy v C++

Při rozboru každého typu musí čtenář pamatovat na definování datového typu.

1. Typ celého čísla (char, short(int), int, long(int), long long)

Z názvu je snadné pochopit, že množina hodnot se skládá z celých čísel. Také sada hodnot každého z uvedených typů může být podepsána (podepsána) nebo nepodepsána (nepodepsána). Počet prvků obsažených v sadě závisí na velikosti paměti, která se používá k uložení hodnoty daného typu. Například pro proměnnou typu char je přidělen 1 bajt paměti, takže celkový počet prvků bude:

• 2 8N = 2 8 * 1 = 256, kde N je množství paměti v bajtech pro uložení hodnoty

V takovém případě jsou rozsahy dostupných celých čísel následující:

• - pro nepodepsané char
• [-128..127] - pro podepsané char

Ve výchozím nastavení je proměnná celočíselného typu považována za podepsanou. Aby bylo v kódu uvedeno, že proměnná má být bez znaménka, je základnímu typu vlevo přiřazen znaménko se znaménkem, tzn. nepodepsaný:

dlouhé hodnoty bez znaménka; // definuje celočíselný (dlouhý) typ bez znaménka.

Uvedené typy se liší pouze velikostí paměti potřebné pro uložení. Protože jazyk C++ je spíše strojový jazykový standard, zaručuje pouze následující podmínku:

• 1 = velikost znaku ≤ krátká velikost ≤ velikost int ≤ dlouhá velikost.

Obvykle jsou velikosti typů následující: char - 1, krátký - 2, int - 4, dlouhý - 8, dlouhý dlouhý - 8 bajtů.

Můžete provádět aritmetické operace s hodnotami typu celé číslo: +, -, *, /, %; srovnávací operace: ==, !=,<=, <, >, >=; bitové operace: &, |, xor,<<, >>.
Většina operací, jako je sčítání, násobení, odčítání a porovnávání, je snadno pochopitelná. Někdy po provedení aritmetických operací může být výsledek mimo rozsah hodnot; v tomto případě program ohlásí chybu.
Celočíselné dělení (/) najde celočíselnou část dělení jednoho celého čísla druhým. Například:

• 6 / 4 = 1;
• 2 / 5 = 0;
• 8 / 2 = 4.

Symbol procenta (%) označuje operaci určení zbytku dělení dvou celých čísel:

• 6 % 4 = 2;
• 10 % 3 = 1.

Obtížněji pochopitelné operace jsou bitově: & (AND), | (OR), xor (exkluzivní OR),<< (побитовый сдвиг влево), >> (bitový posun doprava).

Bitové operace AND, OR a XOR aplikují odpovídající logickou operaci na každý bit informace:

• 1 10 = 01 2
• 3 10 = 11 2
• 1 10 & 3 10 = 01 2 & 11 2 = 01 2
• 1 10 | 3 10 = 01 2 | 11 2 = 11 2
• 1 10 x nebo 3 10 = 01 2 x nebo 11 2 = 10 2

Při zpracování obrazu se pro barvu používají 3 kanály: červený, modrý a zelený - plus průhlednost, které jsou uloženy v proměnné typu int, protože každý kanál má rozsah hodnot od 0 do 255. V hexadecimální soustavě je hodnota zapsána následovně: 0x180013FF; pak hodnota 18 16 odpovídá červenému kanálu, 00 16 - modrý, 13 16 - zelený, FF - alfa kanál (průhlednost). Pro výběr určitého kanálu z takového celého čísla použijte tzv. maska, kde pozice, které nás zajímají, jsou F 16 nebo 1 2 . To znamená, že pro zvýraznění hodnoty modrého kanálu musíte použít masku, tzn. bitově A:

int blue_channel = 0x180013FF & 0x00FF0000;

Poté se přijatá hodnota posune doprava o požadovaný počet bitů.

Bitový posun posune doleva nebo doprava tolik bitů čísla, kolik je uvedeno na pravé straně operace. Například číslo 39 pro typ char v binárním tvaru je zapsáno takto: 00100111. Potom:

Binární znak Příklad = 39; // 00100111 výsledek znaku = binaryExample<< 2; // сдвигаем 2 бита влево, результат: 10011100

Pokud je proměnná typu unsigned, pak výsledkem bude číslo 156, pro proměnnou se znaménkem je rovno -100. Všimněte si, že pro typy celých čísel se znaménkem je jednotka v horním řádu bitové reprezentace znamením, že číslo je záporné. V tomto případě hodnota v binárním tvaru sestávající ze všech jedniček odpovídá -1; pokud je 1 pouze na nejvýznamnější číslici a zbývající číslice jsou nuly, pak má takové číslo minimální hodnotu pro určitý typ hodnoty: pro char je to -128.

2. Typ s pohyblivou řádovou čárkou (float, double (float))

Sada hodnot s pohyblivou řádovou čárkou je podmnožinou reálná čísla, ale ne každé reálné číslo může být reprezentováno binárně, což někdy vede k hloupým chybám:

plovoucí hodnota = 0,2; hodnota == 0,2; // chyba, hodnota zde nebude rovna 0,2.

Při práci s proměnnými s plovoucí desetinnou čárkou by programátor neměl používat operaci rovnosti nebo nerovnosti, místo toho obvykle používá test k dosažení určitého intervalu:

Hodnota - 0,2< 1e-6; // ok, подбирать интервал тоже нужно осторожно

Kromě operací porovnávání podporuje typ s plovoucí desetinnou čárkou 4 aritmetické operace, které jsou plně v souladu s matematickými operacemi s reálnými čísly.

3. Booleovský (logický) typ (bool)

Skládá se pouze ze dvou hodnot: true (true) a false (false). Pro práci s proměnnými tohoto typu se používají logické operace: ! (NE), == (rovnost), != (nerovnost), && (logické AND), || (logické NEBO). Výsledek každé operace lze nalézt v odpovídající pravdivostní tabulce. Například:

4. Typ znaku (char, wchar_t)

Typ char není pouze celočíselný typ (obvykle se takový typ nazývá byte), ale také typ znaku, který ukládá číslo znaku z tabulky jako znak ASCII. Například kód 0x41 odpovídá znaku 'A' a 0x71 - 't'.

Někdy je nutné použít znaky, které nejsou v tabulce ASCII pevně dané, a proto vyžadují uložení více než 1 bajt. Existuje pro ně široký znak (wchar_t).

5.1. Pole

Pole umožňují uložit sekvenční sadu prvků stejného typu. Pole je uloženo v paměti v souvislém bloku, takže pole nelze deklarovat bez určení jeho velikosti. Chcete-li pole deklarovat, za název proměnné napište hranaté závorky () označující její velikost. Například:

int myArray; // Pole 5 prvků typu integer

Pro inicializaci pole jsou hodnoty uvedeny ve složených závorkách. Tímto způsobem můžete inicializovat pouze v době deklarace proměnné. Mimochodem, v tomto případě není nutné specifikovat velikost pole:

int odds = (1, 3, 7, 9, 11); // Pole je inicializováno 5 hodnotami

Chcete-li získat přístup ke konkrétní hodnotě v poli (prvku pole), použijte operaci přístupu k indexu () s číslem prvku (čísla začínají od 0). Například:

šance; // přístup k prvnímu prvku pole. Vrátí hodnotu 1 odds; // přístup ke třetímu prvku. Vrátí hodnotu 7 odds = 13; // Přiřadí novou hodnotu 5. prvku pole odds; // chyba přístupu

5.3. Struny

K zápisu řetězce programátoři používají myšlenku, že řetězec je po sobě jdoucí řada (pole) znaků. K identifikaci konce řádku použijte zvláštní charakter konec řádku: '\0'. Tyto speciální znaky sestávající ze zpětného lomítka a identifikačního znaku se nazývají řídicí nebo únikové znaky. Stále existuje například '\n' - začátek nového řádku, '\t' - tabelování. Pro zaznamenání zpětného lomítka na řádek se používá escapování - před samotný znak se vloží další lomítko: '\'. Escapování se také používá k psaní uvozovek.

Vytvořme řetězcovou proměnnou:

Char textExample = ('T', 'e', ​​​​'s', 't', '\0'); // je zapsán řetězec "Test".

Pro inicializaci řetězce existuje zjednodušený zápis:

Znak textExample = "Test"; // Poslední znak není zapsán, ale velikost je stále 5

Aniž bychom zacházeli do podrobností, zde je další užitečný datový typ - řetězec. Struny
tohoto typu můžete například přidat:

Řetězec hello = "Ahoj,"; stringname = "Max!"; řetězec ahoj_jméno = ahoj + jméno; // Získejte řetězec "Ahoj, Max!"

6. Odkaz

Int a = 2; // proměnná "a" ukazuje na hodnotu 2 int &b = a; // proměnná "b" ukazuje na stejné místo jako "a" b = 4; // změnou hodnoty b změní programátor hodnotu a. Nyní a = 4 int &c = 4; // chyba, nemůžete to udělat, protože referenci nelze přiřadit hodnotu

7. Ukazatel

Pro práci s tímto typem dat je nutné si uvědomit, že množinou hodnot tohoto typu jsou adresy paměťových buněk, odkud data začínají. Ukazatel také podporuje operace sčítání (+), odčítání (-) a dereferencování (*).

Adresy 0x0 znamená, že ukazatel je prázdný, tzn. neukazuje na žádná data. Tato adresa má svůj vlastní literál - NULL:

Int *nullPtr = NULL; // nulový ukazatel

Umožňuje sčítání a odečítání adresy s celým číslem nebo jinou adresou
pohybovat po paměti dostupné programu.

Operace získávání dat začínajících na adrese uložené v ukazateli se nazývá dereferencování (*). Program načte požadovaný počet paměťových buněk a vrátí hodnotu uloženou v paměti.

Int hodnotaInMemory = 2; // nastaví proměnnou celočíselného typu int *somePtr = // zkopíruje adresu proměnné, zde & - vrátí adresu proměnné somePtr; // adresa paměťové buňky, například 0x2F *somePtr; // hodnota je uložena ve 4 buňkách: 0x2F, 0x30, 0x31 a 0x32

U ukazatelů není k dispozici operace přiřazení, která je syntakticky stejná jako operace kopírování. Jinými slovy, můžete zkopírovat adresu jiného ukazatele nebo adresu proměnné, ale nemůžete sami určit hodnotu adresy.

Samotný ukazatel je uložen v paměti, stejně jako hodnoty proměnných jiných typů, a zabírá 4 bajty, takže můžete vytvořit ukazatel na ukazatel.

8. Převody

Výčty jsou jediným základním typem definovaným programátorem. Celkově je výčet uspořádaná sada pojmenovaných celočíselných konstant, přičemž název výčtu je základní typ.

Enumcolor (ČERVENÁ, MODRÁ, ZELENÁ);

Standardně ČERVENÁ = 0, MODRÁ = 1, ZELENÁ = 2. Hodnoty lze tedy vzájemně porovnávat, tzn. ČERVENÉ< BLUE < GREEN. Программист при объявлении перечисления может самостоятельно задать значения каждой из констант:

Enum access(READ=1, WRITE=2, EXEC=4);

Často je vhodné používat výčty, jejichž hodnoty jsou mocninou dvou, protože v binární reprezentaci se číslo, které je mocninou 2, bude skládat z 1. jednotky a nul. Například:

8 10 = 00001000 2

Výsledek sčítání těchto čísel vždy jasně ukazuje, která čísla byla přidána:

37 10 = 00100101 2 = 00000001 2 + 00000100 2 + 00100000 2 = 1 10 + 4 10 + 32 10

Neplatné

Syntakticky je typ void jedním ze základních typů, ale lze jej použít pouze jako součást složitějších typů, protože objekty typu void neexistují. Obvykle se tento typ používá k informování, že funkce nemá návratovou hodnotu, nebo jako základní typ ukazatele na objekty nedefinovaných typů:

prázdný objekt; // chyba, nejsou zde žádné objekty typu void void // chyba, nejsou zde žádné odkazy na void void *ptr; // ok, ulož ukazatel na neznámý typ

Často budeme používat void specificky k označení, že funkce nevrací žádnou hodnotu. Ukazatel typu void se zpracuje, když programátor převezme plnou odpovědnost za integritu paměti a správné přetypování.

Obsazení

Často je nutné přetypovat hodnotu proměnné jednoho typu na jiný. V případě, kdy je množina hodnot původního typu podmnožinou většího typu (například int je podmnožinou long a long je double), může kompilátor implicitně ( implicitně) změnit typ hodnoty.

int celé číslo = 2; plovoucí plovoucí = celé číslo; // plovoucí = 2,0

Typová konverze bude provedena se ztrátou informace, takže z čísla s plovoucí desetinnou čárkou zůstane pouze celočíselná část, zlomková část se ztratí.

Existuje možnost explicitní (explicitní) konverze typu, za tímto účelem vlevo od proměnné nebo nějaké hodnoty původního typu v závorce napište typ, na který bude přetypováno:

hodnota int = (int) 2,5;

Unární a binární operace

Operace, které jsme provedli dříve, se nazývají binární: vlevo a vpravo od symbolu operace jsou hodnoty nebo proměnné, například 2 + 3. Kromě binárních operací používají programovací jazyky také unární operace které se týkají proměnných. Mohou být buď nalevo, nebo napravo od proměnné, několik takových operací se již setkalo - operace dereference (*) a převzetí adresy proměnné (&) jsou unární. Operátory "++" a "-" zvyšují a snižují hodnotu celočíselné proměnné o 1 a mohou být zapsány vlevo nebo vpravo od proměnné.

C++ také používá zkrácený zápis pro binární operace, když levá a pravá strana výrazu obsahují stejnou proměnnou, tzn. nějaká operace se provede s hodnotou proměnné a výsledek operace se uloží do stejné proměnné:

A+= 2; // stejné jako a = a + 2; b/= 5; // stejné jako b = b / 5; c &= 3; // stejné jako c = c & 3;

Datové typy v C jsou třídou dat, jejichž hodnoty mají podobné vlastnosti. Typ definuje vnitřní reprezentaci dat v paměti. Nejzákladnější datové typy jsou boolean, integer, floating point, string, pointer.

Při dynamickém psaní je proměnná přidružena k typu v době inicializace. Ukazuje se, že proměnná v různých částech kódu může mít různé typy. Dynamické psaní podporují Java Script, Python, Ruby, PHP.

Statické psaní je opakem dynamického psaní. Když je proměnná deklarována, obdrží typ, který se v budoucnu nezmění. Jazyky C a C++ jsou přesně takové. Tato metoda je nejvhodnější pro psaní složitého kódu a mnoho chyb je eliminováno ve fázi kompilace.

Jazyky se neformálně dělí na silně a slabě typizované. Silné psaní znamená, že kompilátor vyvolá chybu, pokud se očekávané a skutečné typy neshodují.

x = 1 + "2"; //chyba - k číslu nelze přidat znak

Příklad slabého psaní.

Kontrolu typové konzistence provádí systém typové bezpečnosti. K chybě při psaní dochází například při pokusu o použití čísla jako funkce. Existují jazyky bez typu. Na rozdíl od psaných vám umožňují provádět libovolnou operaci s každým objektem.

Třídy paměti

Proměnné, bez ohledu na svůj typ, mají svůj rozsah a životnost.

Třídy paměti:

• auto;
• statický;
• externí;
• Registrovat.

Všechny proměnné v C jsou ve výchozím nastavení lokální. Lze je použít pouze uvnitř funkce nebo bloku. Když funkce skončí, jejich hodnota je zničena.

Statická proměnná je také lokální, ale mimo svůj blok může mít jinou hodnotu a mezi voláními funkcí je zachována.

Externí proměnná je globální. Je k dispozici v jakékoli části kódu a dokonce i v jiném souboru.

Specifikátory datových typů v C mohou být vynechány v následujících případech:

1. Všechny proměnné uvnitř bloku nejsou proměnnými; pokud se tedy předpokládá použití této konkrétní třídy úložiště, pak není specifikátor auto specifikován.
2. Všechny funkce deklarované mimo blok nebo funkci jsou ve výchozím nastavení globální, takže externí specifikátor je volitelný.

Chcete-li zadat jednoduché typy, jsou určeny specifikátory int, char, float nebo double. Proměnné lze nahradit modifikátory unsigned (unsigned), signed (signed), short, long, long long.

Ve výchozím nastavení jsou všechna čísla podepsána, takže mohou být pouze v rozsahu kladných čísel. Chcete-li definovat proměnnou typu char jako podepsanou, napište podepsaný char. Dlouhé, dlouhé dlouhé a krátké označují, kolik paměti je přiděleno pro úložiště. Největší je dlouhý dlouhý, nejmenší je krátký.

Char je nejmenší datový typ v C. Pro ukládání hodnot je přidělen pouze 1 bajt paměti. Proměnné typu charakter jsou obvykle přiřazeny znaky, méně často číslice. Hodnoty znaků jsou uzavřeny v uvozovkách.

Typ int ukládá celá čísla, jeho velikost není definována – zabírá až 4 bajty paměti v závislosti na architektuře počítače.

Explicitní převod proměnné bez znaménka je dán takto:

Implicitní vypadá takto:

Float a double definují čísla s tečkou. Floaty jsou reprezentovány jako -2,3 nebo 3,34. Double se používá pro větší přesnost - za oddělovačem desetinných míst je uvedeno více číslic. Tento typ zabírá více místa v paměti než float.

Void má prázdnou hodnotu. Definuje funkce, které nic nevrací. Tento specifikátor určuje prázdnou hodnotu v argumentech metody. Ukazatele, které mohou mít jakýkoli datový typ, jsou také definovány jako neplatné.

Booleovský typ

Používá se při stavových testech a smyčkách. Má pouze dva významy:

• skutečný;
• lhát.

Booleovské hodnoty lze převést na hodnotu int. True se rovná jedné, nepravda se rovná nule. Konverze typu je poskytována pouze mezi bool a int, jinak kompilátor vygeneruje chybu.

if (x) ( //Chyba: "Nelze implicitně převést typ 'int' na 'bool""

if (x != 0) // Způsob C#

Řetězce a pole

Pole jsou komplexní datové typy v C. JS nepracuje s řetězci stejným způsobem jako Javascript nebo Ruby. V C jsou všechny řetězce pole prvků znakové hodnoty. Řetězce končí nulovým bajtem “

Prohlášení Operátoři

SI konstanty

V C můžete také vytvářet proměnné, které mají konstantní hodnotu (jejich hodnotu nelze měnit). Deklarace takových "proměnných" má následující syntaxi: const typ jméno1=hodnota1[,jméno2=hodnota2[,...]]; Příklady:
const unsigned int x=80, y=25;
const double pi=3,1415;

Operátor pro vytváření datových typů v SI