Posledná aktualizácia: 08.10.2017

Okrem premenných a metód, ktoré priamo súvisia s objektom, vám C++ umožňuje definovať premenné a metódy, ktoré priamo súvisia s triedou alebo inak. statických členov trieda. Statické premenné a metódy sa vo všeobecnosti vzťahujú na celú triedu. Na ich definovanie sa používa kľúčové slovo statické.

Napríklad banka môže mať veľa rôznych vkladov, ale všetky vklady budú mať nejaké spoločné úrokové sadzby. Na opísanie bankového účtu teda definujeme a používame nasledujúcu triedu:

#include class Účet ( public: Account(double sum) ( this->sum = sum; ) static int getRate() (rate rate; ) static void setRate(int r) (rate = r; ) double getIncome() ( return sum + suma * sadzba / 100; ) private: double sum; static int rate; ); int Account::rate = 8; int main() ( Account account1(20000); Account account2(50000); Account::setRate(5); // reset rate std::cout<< "Rate: " << Account::getRate() << std::endl; std::cout << "Rate: " << account1.getRate() << " Income: " << account1.getIncome() << std::endl; std::cout << "Rate: " << account2.getRate() << " Income: " << account2.getIncome() << std::endl; return 0; }

Trieda Account definuje jednu statickú premennú, sadzbu a dve statické funkcie na správu tejto premennej. Pri definovaní statických funkcií treba mať na pamäti, že v ich vnútri môžeme použiť len statické premenné triedy, ako je napríklad premenná sadzba. Nestatické premenné nemožno použiť v statických funkciách.

Okrem toho nemôžete použiť tento ukazovateľ v statických funkciách, čo je v princípe zrejmé, pretože ukazuje na aktuálny objekt a statické funkcie odkazujú na celú triedu ako celok.

Je tiež dôležité, že ak trieda obsahuje statické premenné, musia byť dodatočne definované mimo triedy:

Int Account::rate = 8;

Premennej nie je potrebné priraďovať počiatočnú hodnotu.

Za zmienku tiež stojí, že keďže statické členy odkazujú na celú triedu ako celok, na statické členy sa odkazuje pomocou názvu triedy, za ktorým nasleduje operátor ::. Alebo môžeme tiež pristupovať k verejným členom triedy prostredníctvom premenných tejto triedy:

Account::getRate() account1.getRate()

Výstup programu na konzolu:

Sadzba: 5 Sadzba: 5 Príjem: 21000 Sadzba: 5 Príjem: 52500

V triedach sa často používajú aj statické konštanty. Napríklad, urobme z variabilnej sadzby konštantnú v triede Account:

#include trieda Účet ( public: const static int rate = 8; Account(double sum) ( this->sum = sum; ) double getIncome() ( return sum + sum * rate / 100; ) private: double sum; ); int main() ( účet účet1(20000); účet účet2(50000); std::cout<< "Rate: " << account1.rate << "\tIncome: " << account1.getIncome() << std::endl; std::cout << "Rate: " << account2.rate << "\tIncome: " << account2.getIncome() << std::endl; return 0; }

Na rozdiel od statických premenných nie je potrebné statické konštanty ďalej definovať mimo triedy.

Okrem modifikátora prístupu môžete pred názov poľa, metódy alebo vlastnosti napísať kľúčové slovo statické .
« statické “ znamená, že dané pole, metóda alebo vlastnosť nebude patriť každému objektu triedy, ale všetkým spolu.

Klasický príklad: ako zistiť, koľko objektov tej istej triedy bolo vytvorených? Na vyriešenie tohto problému stačí slúžiť statické polia a metódy.

Pozrime sa na príklad tigrov. Definujme triedu" Tiger". Ak pole triedy napíšeme takto: verejný počet int; potom bude mať každý objekt toto pole a každý objekt bude mať svoje vlastné. Navyše, ak nie je vytvorený jediný objekt, potom toto pole nebude existovať vôbec.
Preto urobme toto pole statické ( statické).

Vytvorme si konštruktor, v ktorom budeme inkrementovať počítadlo počítať pri vytváraní každého nového objektu:
public Tiger() ( count++; ).
Tu môžeme nastaviť aj jednotlivé vlastnosti tigra: hmotnosť, výška, prezývka.

Napíšeme aj statickú metódu, ktorá zobrazí počet vytvorených objektov:
public static void ShowNumberOfObjects().

Potom bude mať naša konzolová aplikácia dve triedy:

Verejná trieda Tiger ( public static int count; public static Tiger() ( count++; ) public static void ShowNumberOfObjects() ( Console.WriteLine("Tigers = (0)", Tiger.count.ToString()); ) ) class Program ( static void Main(string args) ( // Aký je počet tigrov bez vytvorenia objektov? Tiger.ShowNumberOfObjects(); // 0, pretože ešte sme nevytvorili objekty // Vytvorenie 3 tigrov Tiger t1 = new Tiger (); Tiger t2 = nový tiger (); Tiger t3 = nový tiger (); Tiger.ShowNumberOfObjects(); // Vyjdú 3 tigre Console.ReadLine(); ) )

Výsledok: 3.

Záver. Statická metóda vám umožňuje volať ju bez toho, aby ste mali k dispozícii akýkoľvek objekt. Namiesto názvu objektu sa pri volaní metódy zadáva názov triedy Tiger: Tiger.ShowNumberOfObjects();

Rozdiely medzi statickou metódou a nestatickou metódou:

1. Na volanie statickej metódy nepotrebujete objekt.
2. V rámci statickej metódy nie je dostupná premenná this smerujúca na objekt, preto nie sú dostupné všetky nestatické polia tejto triedy, pretože ako žiadny predmet.
3. Vo vnútri normálnej metódy sú dostupné statické aj nestatické polia.
4. Počnúc C# 4.0 bolo možné urobiť samotnú triedu statickou.

Niekedy vytvárate triedy, ktoré pozostávajú iba zo statických metód, ako napríklad trieda Math. V skutočnosti sú takéto triedy kontajnermi globálnych funkcií, čo sa však líši od konceptu OOP. Taktiež nebude možné vytvárať, respektíve inštancie statickej triedy.

Teraz sa poďme zaoberať pojmom „štruktúra“ a zistime jej rozdiel od triedy.

Posledná aktualizácia: 25.12.2018

Okrem bežných polí, metód, vlastností môže mať trieda statické polia, metódy, vlastnosti. Statické polia, metódy, vlastnosti sa vzťahujú na celú triedu a na prístup k podobným členom triedy nie je potrebné vytvárať inštanciu triedy. Napríklad:

Účet triedy ( verejný statický desiatkový bonus = 100; verejný desiatkový celkový súčet; verejný účet (desatinný súčet) ( celkový súčet = súčet + bonus; ) ) triedny program ( statický neplatný Hlavný(reťazcové argumenty) ( Console.WriteLine(Účet.bonus); / / 100 Účet.bonus += 200;Účet účtu1 = nový účet(150);Console.WriteLine(účet1.celkový súčet); // 450 účet účet2 = nový účet(1000);Console.zápis(účet2.celkový súčet); // 1300 Console.ReadKey(); ) )

V tomto prípade má trieda Účet dve polia: bonus a celkový súčet. Bonusové pole je statické, takže ukladá stav triedy ako celku, nie jedného objektu. A tak môžeme na toto pole odkazovať názvom triedy:

Console.WriteLine(Účet.bonus); Účet.bonus += 200;

Na úrovni pamäte pre statické polia sa vytvorí pamäťová oblasť, ktorá bude spoločná pre všetky objekty triedy.

Pamäť pre statické premenné je zároveň alokovaná aj vtedy, ak nebol vytvorený žiadny objekt tejto triedy.

Statické vlastnosti a metódy

Podobne môžeme vytvárať a používať statické metódy a vlastnosti:

Účet triedy ( verejný účet (desatinná suma, desatinná sadzba) ( if (sum< MinSum) throw new Exception("Недопустимая сумма!"); Sum = sum; Rate = rate; } private static decimal minSum = 100; // минимальная допустимая сумма для всех счетов public static decimal MinSum { get { return minSum; } set { if(value>0) minSum = hodnota; ) ) public decimal Suma ( get; private set; ) // suma na účte public decimal Sadzba ( get; private set; ) // úroková sadzba // výpočet sumy na účte po určitom období pri určitej sadzbe public static decimal GetSum(desatinný súčet , desiatková sadzba, int obdobie) ( desiatkový výsledok = súčet; for (int i = 1; i<= period; i++) result = result + result * rate / 100; return result; } }

Premenná minSum, vlastnosť MinSum a metóda GetSum sú tu definované kľúčovým slovom static, čo znamená, že sú statické.

Premenná minSum a vlastnosť MinSum predstavujú minimálnu sumu, ktorá je povolená na vytvorenie faktúry. Tento ukazovateľ sa nevzťahuje na žiadny konkrétny účet, ale vzťahuje sa na všetky účty vo všeobecnosti. Ak zmeníme tento ukazovateľ pre jeden účet, potom sa musí zmeniť aj pre druhý účet. To znamená, že na rozdiel od vlastností Sum a Rate, ktoré ukladajú stav objektu, premenná minSum ukladá stav pre všetky objekty danej triedy.

To isté pri metóde GetSum – vypočíta sumu na účte po určitom období pri určitej úrokovej sadzbe za určitú počiatočnú sumu. Volanie a výsledok tejto metódy nezávisí od konkrétneho objektu alebo jeho stavu.

Premenné a vlastnosti, ktoré uchovávajú spoločný stav pre všetky objekty triedy, by teda mali byť definované ako statické. A tiež metódy, ktoré definujú správanie spoločné pre všetky objekty, by mali byť tiež deklarované ako statické.

Statické členy triedy sú spoločné pre všetky objekty tejto triedy, takže sa na ne musí odkazovať názvom triedy:

Všimnite si, že statické metódy môžu pristupovať iba k statickým členom triedy. Nemôžeme odkazovať na nestatické metódy, polia, vlastnosti vnútri statickej metódy.

Na uloženie počítadiel sa často používajú statické polia. Povedzme napríklad, že máme triedu User a chceme mať počítadlo, ktoré nám povie, koľko používateľských objektov bolo vytvorených:

Class User ( private static int counter = 0; public User() ( counter++; ) public static void DisplayCounter() ( Console.WriteLine($"Created (counter) User objects"); ) ) class Program ( static void Main(string) argumenty) ( Používateľ používateľ1 = nový používateľ(); Používateľ používateľ2 = nový používateľ(); Používateľ používateľ3 = nový používateľ(); Používateľ používateľ4 = nový používateľ(); Používateľ používateľ5 = nový používateľ(); User.DisplayCounter(); / / 5 Console.ReadKey(); ) )

Statický konštruktor

Okrem bežných konštruktorov môže mať trieda aj statické konštruktory. Statické konštruktory majú tieto charakteristické znaky:

Statické konštruktory nesmú mať modifikátor prístupu a nesmú mať žiadne parametre

Rovnako ako pri statických metódach, statické konštruktory nemôžu použiť kľúčové slovo this na odkazovanie na aktuálny objekt triedy a môžu pristupovať iba k statickým členom triedy.

Statické konštruktory nemožno v programe volať manuálne. Vykonajú sa automaticky pri prvom vytvorení objektu tejto triedy alebo pri prvom prístupe k jeho statickým členom (ak existujú)

Statické konštruktory sa zvyčajne používajú na inicializáciu statických údajov alebo vykonávajú akcie, ktoré je potrebné vykonať iba raz.

Definujme statický konštruktor:

Class User ( static User() ( Console.WriteLine("Prvý používateľ je vytvorený"); ) ) class Program ( static void Main(string args) ( User user1 = new User(); // tu bude fungovať statický konštruktor User user2 = new User(); Console.Read(); ) )

Statické triedy

Statické triedy sú deklarované so statickým modifikátorom a môžu obsahovať iba statické polia, vlastnosti a metódy. Napríklad, ak trieda Account mala iba statické premenné, vlastnosti a metódy, potom by mohla byť deklarovaná ako statická:

Statická trieda Účet ( súkromný statický desiatkový minSum = 100; // minimálna povolená suma pre všetky účty verejný statický desiatkový MinSum ( get ( return minSum; ) set ( if(value>0) minSum = value; ) ) // výpočet účtu suma po určitom období pri určitej sadzbe verejné statické desiatkové GetSum(desiatkový súčet, desatinná sadzba, int obdobie) ( desiatkový výsledok = súčet; for (int i = 1; i<= period; i++) result = result + result * rate / 100; return result; } }

V C# je dobrým príkladom statickej triedy trieda Math, ktorá sa používa na rôzne matematické operácie.

Lekcia 25

Doteraz mal každý objekt, ktorý vytvoríte, svoju vlastnú množinu dátových prvkov. V závislosti od účelu vašej aplikácie môžu nastať situácie, keď objekty rovnakej triedy musia zdieľať jeden alebo viacero údajových členov. Predpokladajme napríklad, že píšete platobný program, ktorý sleduje pracovný čas 1 000 zamestnancov. Na určenie sadzby dane musí program poznať podmienky, v ktorých každý zamestnanec pracuje. Použime na to premennú triedy stav_práce. Ak však všetci zamestnanci pracujú za rovnakých podmienok, váš program môže zdieľať tento dátový prvok pre všetky objekty typu zamestnanca. Takže váš program znižuje požadované množstvo pamäte tým, že vyhodí 999 kópií rovnakých informácií. Ak chcete zdieľať prvok triedy, musíte tento prvok deklarovať ako statický (statický). Táto lekcia obsahuje kroky, ktoré musíte vykonať na zdieľanie prvku triedy medzi viacerými objektmi. Na konci tejto lekcie si osvojíte nasledujúce základné pojmy:

C++ vám umožňuje mať objekty rovnakého typu, ktoré zdieľajú jedného alebo viacerých členov triedy.

Ak váš program priradí hodnotu zdieľanému prvku, všetky objekty tejto triedy majú okamžite prístup k tejto novej hodnote.

Ak chcete vytvoriť člen zdieľaných údajov triedy, musíte pred názov člena triedy zadať kľúčové slovo statické.

Potom, čo program deklaruje člena triedy ako statický, musí deklarovať globálnu premennú (mimo definície triedy), ktorá zodpovedá danému členu zdieľanej triedy.

Vaše programy môžu použiť kľúčové slovo statický, aby bola metóda triedy volateľná, zatiaľ čo program ešte nemusel deklarovať žiadne objekty tejto triedy.

ZDIEĽANÉ POLOŽKY

Zvyčajne, keď vytvoríte objekty určitej triedy, každý objekt získa svoju vlastnú množinu údajových členov. Môžu však nastať situácie, v ktorých objekty rovnakej triedy potrebujú zdieľať jeden alebo viacero dátových prvkov. (statický napr dátové položky). V takýchto prípadoch deklarujte dátových členov ako všeobecné bahno a súkromné, a potom pridajte pred typ kľúčové slovo statický, ako je uvedené nižšie:

private: static int shared_value;

Po deklarovaní triedy musíte prvok deklarovať ako globálnu premennú mimo triedy, ako je uvedené nižšie:

int názov_triedy::zdieľaná_hodnota;

Nasledujúci program SHARE_IT.CPP definuje triedu knižná_séria, prvok zdieľania page_count, ktorý je rovnaký pre všetky objekty (knihy) triedy (série). Ak program zmení hodnotu tohto prvku, zmena sa okamžite prejaví vo všetkých objektoch triedy:

#include

#include

triedna kniha_seriál

( public: book_series(char *, char *, float); void show_book(void); void set_pages(int) ; private: static int page_count; char title; char autor[ 64 ]; float price; );

int book_series::page__count;

void book_series::set_pages(int pages)

( počet_strán = strany; )

book_series::book_series(znak *názov, znak *autor, pohyblivá cena)

( strcpy(séria_knihy::názov, názov); strcpy(séria_knihy::autor, autor); séria_knihy::cena = cena; )

void book_series::show_book(void)

(cout<< "Заголовок: " << title << endl; cout << "Автор: " << author << endl; cout << "Цена: " << price << endl; cout << "Страницы: " << page_count << endl; }

( book_series programming("Učíme sa programovať v C++", "Jamsa", 22.95); book_series word("Učíme sa používať Word pre Windows", "Wyatt", 19.95); word.set_pages(256); programming.show_book () ; word.show_book() ; cout<< endl << "Изменение page_count " << endl; programming.set_pages(512); programming.show_book(); word.show_book(); }

Ako vidíte, trieda vyhlasuje počet_strán ako statický int. Ihneď po definícii triedy program deklaruje prvok počet_strán ako globálna premenná. Keď program zmení prvok page_count, zmena sa okamžite prejaví vo všetkých objektoch triedy knižná_séria.

Zdieľanie členov triedy

V závislosti od vášho programu môžu nastať situácie, keď budete musieť zdieľať určité údaje medzi viacerými inštanciami objektu. Ak to chcete urobiť, deklarujte takýto prvok ako statický. Ďalej deklarujte tento prvok mimo triedy ako globálnu premennú. Akékoľvek zmeny, ktoré vykoná váš program v tomto prvku, sa okamžite prejavia v objektoch tejto triedy.

Používanie prvkov s atribútmiverejné statické ak objekty neexistujú

Ako ste sa práve dozvedeli, pri deklarovaní člena triedy ako statické tento prvok zdieľajú všetky objekty danej triedy. Môžu však nastať situácie, keď program ešte nevytvoril objekt, ale potrebuje prvok použiť. Ak chcete použiť prvok, váš program ho musí deklarovať ako verejnosti a statické. Napríklad nasledujúci program USE_MBR.CPP používa prvok počet_strán z triedy knižná_séria, aj keď objekty tejto triedy neexistujú:

#include

#include

triedna kniha_seriál

( public: static int page_count; private: char title ; char autor; float price; );

int séria_knihy::počet_strán;

void main(void) ( book_series::page_count = 256; cout<< "Текущее значение page_count равно " << book_series::page_count << endl; }

V tomto prípade, keďže trieda definuje prvok triedy počet_strán ako verejnosť, program môže odkazovať na tento prvok triedy, aj keď objekty triedy knižná_séria neexistuje.

POUŽÍVANIE FUNKCIÍ STATICKÉHO ČLENA

Predchádzajúci program ilustroval použitie statické dátové prvky. Podobne vám C++ umožňuje definovať statickéčlenské funkcie (metódy). Ak tvoríte statické váš program môže volať túto metódu, aj keď neboli vytvorené žiadne objekty. Napríklad, ak trieda obsahuje metódu, ktorú možno použiť na údaje mimo triedy, môžete vytvoriť túto metódu statické. Nižšie je trieda Ponuka, ktorý používa sekvenciu esc ovládača ANSI na vymazanie obrazovky displeja. Ak máte vo svojom systéme nainštalovaný ovládač ANSI.SYS, môžete túto metódu použiť clear_screen na vyčistenie obrazovky. Pretože táto metóda je deklarovaná ako statický, program ho môže použiť aj v prípade objektov typu Ponuka neexistuje. Nasledujúci program CLR_SCR.CPP používa metódu clear_screen na čistenie obrazovky:

#include

( public: static void clear_screen(void); // Ostatné metódy by tu mali byť private: int number_of_menu_options; );

void menu::clear_screen(void)

(cout<< "\033" << "}