Mit jelent a statikus c. Statikus módszerek Java-ban (statikus módszerek). Adatelem megosztása

Ezután közvetlenül elérhetjük őket az osztálynév és a hatókör felbontás operátorán keresztül. De mi van akkor, ha a statikus tagváltozók privátak? Vegye figyelembe a következő kódot:

Ebben az esetben nem érhetjük el közvetlenül a Anything::s_value-t a main()-ból, mivel ez a tag privát. Az osztály privát tagjai általában nyilvános metódusokon keresztül érhetők el. Míg létrehozhatnánk egy normál metódust az s_value eléréséhez, akkor a metódus használatához létre kell hoznunk egy objektumot az osztályból! Van egy jobb lehetőség: statikussá tehetjük a metódust.

Hasonlóan a statikus tagváltozókhoz, statikus módszerek nem kötődnek egyetlen osztályobjektumhoz sem. Íme a fenti példa, de statikus módszerrel:

class Bármi ( private: static int s_value; public: static int getValue() ( return s_value; ) // statikus metódus ); int Bármi::s_value = 3; // az int main() osztály statikus tagváltozójának meghatározása ( std::cout<< Anything::getValue() << "\n"; }

Mivel a statikus metódusok nincsenek egy adott objektumhoz kötve, közvetlenül az osztálynéven és a hatókör-feloldó operátoron, valamint az osztályobjektumokon keresztül hívhatók meg (de ez nem ajánlott).

A statikus metódusoknak nincs *this mutatója

A statikus módszereknek két érdekes tulajdonsága van. Először is, mivel a statikus metódusok nincsenek objektumhoz kötve, nem rendelkeznek ! Ennek van értelme, mivel a *this mutató mindig arra az objektumra mutat, amelyen a metódus működik. Előfordulhat, hogy a statikus módszerek nem működnek egy objektumon keresztül, ezért a *this mutatóra nincs szükség.

Másodszor, a statikus módszerek közvetlenül hozzáférhetnek más statikus tagokhoz (változókhoz vagy függvényekhez), de nem férhetnek hozzá a nem statikus tagokhoz. Ez azért van így, mert a nem statikus tagok az osztályobjektumhoz tartoznak, a statikus metódusok viszont nem!

Még egy példa

A statikus metódusok az osztálytörzsön kívül is definiálhatók. Ez ugyanúgy működik, mint a hagyományos módszereknél. Például:

#beleértve class IDGenerator ( private: static int s_nextID; // statikus tagváltozó deklarációja public: static int getNextID(); // statikus metódus deklarációja ); // A statikus tagváltozó definíciója kívül esik az osztálytörzsön. Kérjük, vegye figyelembe, hogy itt nem a statikus kulcsszót használjuk // Kezdje el az azonosítók generálását int IDGenerator::s_nextID = 1; // A statikus metódus definíciója kívül esik az osztálytörzsön. Felhívjuk figyelmét, hogy itt nem használjuk a statikus kulcsszót int IDGenerator::getNextID() ( return s_nextID++; ) int main() ( for (int count=0; count< 4; ++count) std::cout << "The next ID is: " << IDGenerator::getNextID() << "\n"; return 0; }

A fenti program futtatásának eredménye:

A következő azonosító: 1
A következő azonosító: 2
A következő azonosító: 3
A következő azonosító: 4

Kérjük, vegye figyelembe, hogy mivel ennek az osztálynak az összes változója és függvénye statikus, nem kell létrehoznunk egy objektumot ebből az osztályból, hogy dolgozhassunk vele! A következő hozzárendelendő azonosító értékének tárolására egy statikus tagváltozó szolgál, az azonosító visszaadására és növelésére pedig egy statikus metódus szolgál.

Figyelmeztetés az összes statikus tagot tartalmazó osztályokról

Legyen óvatos, amikor minden statikus tagot tartalmazó osztályokat ír. Bár az ilyen "tisztán statikus osztályok" hasznosak lehetnek, vannak hátrányai is.

Először is, mivel minden statikus tag csak egyszer jön létre, egy „tisztán statikus osztályból” nem lehet több másolat (az osztály klónozása, majd átnevezése nélkül). Például, ha két független objektumra van szükségünk az IDGenerator osztályból, akkor ez egy „tisztán statikus” osztályon keresztül nem lesz lehetséges.

A C++ nem támogatja a statikus konstruktorokat

Ha inicializálni tud egy normál tagváltozót a segítségével, akkor logikailag képesnek kell lennie a statikus tagváltozók inicializálására egy statikus konstruktoron keresztül. És bár néhány modern nyelv valóban támogatja a statikus konstruktorokat erre a célra, a C++ sajnos nem tartozik ezek közé.

Ha a statikus változó közvetlenül inicializálható, akkor nincs szükség konstruktorra: definiálhatunk statikus tagváltozót akkor is, ha az privát. Ezt a fenti példában az s_nextID-vel tesszük. Íme egy másik példa:

osztály Valami ( public: static std::vector s_mychars; ); std::vektor Valami::s_mychars = ( "o", "a", "u", "i", "e" ); // statikus tagváltozó definiálása

Ha a statikus tagváltozó inicializálásához kód végrehajtása szükséges (például ciklus), akkor ennek többféle módja van. A következő módszer a legjobb:

#beleértve #beleértve osztály Valami ( privát: statikus std::vektor s_mychars; public: class _nested // egy _nested nevű beágyazott osztály meghatározása ( public: _nested() // a _nested konstruktor inicializálja a statikus tagváltozónkat ( s_mychars.push_back("o"); s_mychars.push_back("a"); s_mychars.push_back ("u"); s_mychars.push_back("i"); // Statikus metódus s_mychars static void getSomething() ( for (auto const &element: s_mychars) std::cout<< element << " "; } private: static _nested s_initializer; // используем статический объект класса _nested для гарантии того, что конструктор _nested выполнится }; std::vectorValami::s_mychars; // statikus tagváltozónk meghatározása Valami::_nested Valami::s_initializer; // határozza meg a statikus s_initializerünket, amely meghívja a _nested konstruktort az s_mychars inicializálására int main() ( Something::getSomething(); return 0; )

A legtöbb C++ kulcsszó egy dolgot csinál. Az int segítségével egész változót deklarálhatunk, akár akkor, ha egy függvény egész értéket ad vissza, vagy egy egész számot vesz argumentumként. Az új operátort használja a memória lefoglalására, a törlés operátort pedig a felszabadítására. A const segítségével jelezheti, hogy egy változó értéke nem módosítható. Ironikus módon a statikus kulcsszónak, bár jelentése „változhatatlan”, több (és látszólag nem kapcsolódó) felhasználása van. A statikus kulcsszó három fő kontextusban használható:

• függvényen belül;
• osztálydefiníción belül;
• egy globális változó előtt egy többfájlos programot alkotó fájlban.

A függvényen belüli statika használata a legegyszerűbb. Ez egyszerűen azt jelenti, hogy a változó inicializálása után a memóriában marad a program végéig. Tekinthetjük olyan változónak, amely megtartja értékét a program befejezéséig. Például egy statikus változó segítségével rögzítheti, hogy egy függvényt hányszor hívtak meg, egyszerűen hozzáadva a static int count = 0 sorokat; és számol++; függvénybe. Mivel a count statikus változó, a line static int count = 0; csak egyszer kerül végrehajtásra. A függvény meghívásakor a count az utolsó értéket kapja.

A statikus használatot is használhatja oly módon, hogy megakadályozza a változó újrainicializálását a cikluson belül. Például a következő kódban a number_of_times változó 100 lesz, még akkor is, ha a static int number_of_times = 0; egy cikluson belül található, ahol úgy tűnik, hogy minden alkalommal lefut, amikor a program eléri a ciklust. A trükk az, hogy a statikus kulcsszó megakadályozza a változó újrainicializálását. A statikus kulcsszó használatában az egyik dolog az, hogy automatikusan nullára állítja a változót – de ne hagyatkozz erre (ez tisztázatlanná teszi a szándékaidat).

For(int ix=0; ix< 10; ix++) { for(int iy = 0; iy < 10; iy++) { static int number_of_times = 0; number_of_times++; } }

Statikus változók segítségével tárolhatja a függvény által visszaadott utolsó értékre vonatkozó információkat, például ha egy függvény által kiszámított maximális értéket akarja tárolni. Ha egy karakterláncot értelmez, eltárolhatja a függvény által visszaadott utolsó karaktert is, így meghívhatja egy argumentummal, amely azt jelzi, hogy az utolsó karaktert kell visszaadnia.

A static második használata egy osztálydefiníción belül található. Bár az osztályon belül deklarált változók többsége eltérő értékű lehet az osztály minden példányában, az osztály statikus mezőinek ugyanaz lesz a jelentése az adott osztály minden példányánál, és nem is kell létrehozni egy példányt az adott osztályból. Hasznos a statikus osztályváltozókra úgy gondolni, mint amelyek az új objektumok létrehozásához szükséges információkat tartalmazzák (például egy osztálygyárban). Például, ha meg szeretné számozni egy osztály példányait, akkor statikus változóval nyomon követheti az utoljára használt számot. Fontos megjegyezni, hogy a statikus osztályváltozók használatának bevált gyakorlata a class_name::x; , nem az_osztály_példánya.x; . Ez emlékezteti a programozót arra, hogy a statikus változók nem tartoznak egy osztály egyetlen példányához, és hogy nem kell létrehoznia egy példányt az osztályból. Amint azt már észrevette, használhatja a :: hatókör operátort a static eléréséhez, amikor az osztálynéven keresztül éri el.

Fontos szem előtt tartani, amikor egy program hibakeresését vagy statikus implementációját használja, hogy az osztályon belül nem inicializálható. Valójában, ha úgy dönt, hogy az összes osztálykódot egy fejlécfájlba írja, még egy statikus változót sem fog tudni inicializálni a fejlécfájlban; tegye ezt a .cpp fájlban. Ezenkívül inicializálnia kell az osztály statikus tagjait, különben nem lesznek hatókörben. (A szintaxis kissé furcsa: type_name::static_variable = érték .)

Statikus osztályfüggvényei is lehetnek. A statikus függvények olyan függvények, amelyekhez nincs szükség egy osztály példányára, és a statikus változókkal analógiával azonos módon hívjuk meg az osztály nevével, nem pedig az objektum nevével. Például a_class::static_function(); , nem egy_példány.függvény(); . A statikus függvények csak egy osztály statikus tagjain működhetnek, mivel nem hivatkoznak az osztály meghatározott példányaira. A statikus függvények a statikus változók megváltoztatására, értékük nyomon követésére használhatók – például használhat statikus függvényt, ha úgy dönt, hogy számlálót használ, hogy egy osztály minden példányának egyedi azonosítót adjon.

Használhatja például a következő kódot:

Osztályfelhasználó ( private: int id; static int next_id; public: static int next_user_id() ( next_id++; return next_id; ) // egyéb metódusok a user() osztályhoz // osztálykonstruktor ( id = user::next_id++; / / vagy metódushívás, id = user.next_user_id(); int user::next_id = 0;

Ne feledje, hogy a statikus változó típusát a beállításkor meg kell adni!

Felhasználó a_user;

beállítja az azonosítót a következő azonosítószámra, amelyet semmilyen más felhasználói objektum nem használ. Vegye figyelembe, hogy jó stílus az azonosítót állandóként deklarálni.

A static utoljára globális változóként használatos egy kódfájlban. Ebben az esetben a statikus használata azt jelzi, hogy a projekt részét képező más fájlok forráskódja nem fér hozzá a változóhoz. Csak ugyanazon fájlon belüli kód láthatja a változót (hatóköre a fájlra korlátozódik). Ez a technika objektum-orientált kód modellezésére használható, mivel korlátozza a változók láthatóságát, és így segít elkerülni az elnevezési ütközéseket. A statikus használatának ez a módja a C ereklyéje.

Utolsó frissítés: 2018.12.25

A szokásos mezők, metódusok és tulajdonságok mellett egy osztálynak lehetnek statikus mezői, metódusai és tulajdonságai is. A statikus mezők, metódusok, tulajdonságok a teljes osztályra vonatkoznak, és az ilyen osztálytagok eléréséhez nem szükséges az osztály példányát létrehozni. Például:

Osztályszámla ( nyilvános statikus decimális bónusz = 100; nyilvános decimális totalSum; nyilvános számla (tizedes összeg) ( totalSum = összeg + bónusz; ) ) osztályú program ( static void Main(string args) ( Console.WriteLine(Account.bonus); / / 100 Account.bonus += 200 Account account(150 Console.WriteLine) // 450 Account account2 = new Account(1000);

Ebben az esetben a Számla osztálynak két mezője van: bónusz és összösszeg. A bónuszmező statikus, tehát az osztály egészének állapotát tárolja, nem pedig egy egyedi objektumot. Így erre a mezőre osztálynévvel hivatkozhatunk:

Console.WriteLine(Account.bonus); Számla.bónusz += 200;

A statikus mezők memória szintjén létrejön egy memóriahely, amely közös lesz az osztály összes objektumával.

Ebben az esetben a statikus változók memóriája akkor is le van foglalva, ha nem jön létre objektum ebből az osztályból.

Statikus tulajdonságok és módszerek

Hasonló módon statikus metódusokat és tulajdonságokat is létrehozhatunk és használhatunk:

Osztályszámla ( nyilvános számla (tizedes összeg, decimális árfolyam) ( if (összeg< 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 = érték; ) ) nyilvános decimális Összeg ( get; privát halmaz; ) // számlán lévő összeg nyilvános decimális Kamatláb ( get; privát halmaz; ) // kamatláb // a számlán lévő összeg kiszámítása egy bizonyos időszak után meghatározott kamatláb mellett statikus decimális GetSum(tizedes összeg, decimális arány, int periódus) ( decimális eredmény = összeg; for (int i = 1; i<= period; i++) result = result + result * rate / 100; return result; } }

A minSum változó, a MinSum tulajdonság és a GetSum metódus itt a static kulcsszóval van definiálva, vagyis statikusak.

A minSum változó és a MinSum tulajdonság azt a minimális összeget jelöli, amely számla készítéséhez engedélyezett. Ez a mutató nem vonatkozik egyetlen konkrét számlára sem, de általában minden számlára vonatkozik. Ha megváltoztatjuk ezt a mutatót az egyik fióknál, akkor a másik fióknál is változnia kell. Vagyis ellentétben a Sum és Rate tulajdonságokkal, amelyek egy objektum állapotát tárolják, a minSum változó egy adott osztály összes objektumának állapotát tárolja.

Ugyanez a helyzet a GetSum módszerrel – egy bizonyos időszak után egy bizonyos kezdeti összegre meghatározott kamattal számítja ki a számlán lévő összeget. A metódus hívása és eredménye nem függ egy adott objektumtól vagy annak állapotától.

Így azokat a változókat és tulajdonságokat, amelyek egy osztály összes objektumára közös állapotot tárolnak, statikusként kell definiálni. És az összes objektumra jellemző viselkedést meghatározó metódusokat is statikusnak kell deklarálni.

Egy osztály statikus tagjai az adott osztály összes objektumában közösek, ezért az osztálynévvel kell hivatkozni rájuk:

Vegye figyelembe, hogy a statikus metódusok csak egy osztály statikus tagjaihoz férhetnek hozzá. A statikus metóduson belül nem érhetünk el nem statikus metódusokat, mezőket, tulajdonságokat.

A statikus mezőket gyakran használják a számlálók tárolására. Tegyük fel például, hogy van egy User osztályunk, és szeretnénk egy számlálót, amely jelzi, hogy hány User objektumot hoztak létre:

Class User ( private static int counter = 0; public User() ( counter++; ) public static void DisplayCounter() ( Console.WriteLine($"Létrehozott (számláló) felhasználói objektumok"); ) ) class Program ( static void Main(string args) ( User user1 = new User(); User user2 = new User(); User user3 = new User(); User user4 = new User(); User user5 = new User(); User.DisplayCounter(); / / 5 Console.ReadKey();

Statikus konstruktor

A szokásos konstruktorokon kívül egy osztálynak statikus konstruktorai is lehetnek. A statikus konstruktorok a következő jellemzőkkel rendelkeznek:

A statikus konstruktoroknak nem lehet hozzáférésmódosítójuk, és nem vehetnek fel paramétereket

A statikus módszerekhez hasonlóan a statikus konstruktorok nem használhatják ezt a kulcsszót az aktuális osztályobjektumra való hivatkozáshoz, és csak az osztály statikus tagjaihoz férhetnek hozzá

A statikus konstruktorok nem hívhatók meg manuálisan egy programban. Ezek automatikusan végrehajtásra kerülnek, amikor egy adott osztály objektumát először létrehozzák, vagy amikor először hozzáférnek annak statikus tagjaihoz (ha vannak).

A statikus konstruktorokat általában statikus adatok inicializálására vagy olyan műveletek végrehajtására használják, amelyeket csak egyszer kell végrehajtani

Határozzuk meg a statikus konstruktort:

Class User ( statikus User() ( Console.WriteLine("Az első felhasználó létrejött"); ) ) class Program ( static void Main(string args) ( User user1 = new User(); // a statikus konstruktor működni fog itt User user2 = new User();

Statikus osztályok

A statikus osztályokat a statikus módosítóval deklaráljuk, és csak statikus mezőket, tulajdonságokat és metódusokat tartalmazhatnak. Például, ha az Account osztály csak statikus változókkal, tulajdonságokkal és metódusokkal rendelkezik, akkor statikusként deklarálható:

Statikus osztály Számla ( privát statikus decimális minSum = 100; // minimálisan megengedett összeg minden fiókhoz public static decimális MinSum ( get ( return minSum; ) set ( if(value>0) minSum = érték; ) ) // az összeg számlálása a számla egy bizonyos időszak után bizonyos árfolyamon public static decimális GetSum(tizedes összeg, decimális ráta, int periódus) ( decimális eredmény = összeg; for (int i = 1; i<= period; i++) result = result + result * rate / 100; return result; } }

A C#-ban a statikus osztály szemléltető példája a Math osztály, amelyet különféle matematikai műveletekhez használnak.

25. lecke Statikus függvények és adattagok

Eddig minden létrehozott objektumnak saját adatelemkészlete volt. Az alkalmazás céljától függően előfordulhatnak olyan helyzetek, amikor az azonos osztályba tartozó objektumoknak meg kell osztaniuk egy vagy több adatelemet. Tegyük fel például, hogy egy bérszámfejtő programot ír, amely nyomon követi 1000 alkalmazott munkaidejét. Az adókulcs meghatározásához a programnak ismernie kell az egyes alkalmazottak munkakörülményeit. Ehhez használjunk osztályváltozót munkaállapot. Ha azonban minden alkalmazott azonos feltételek mellett dolgozik, a program megoszthatja ezt az adatelemet az összes típusú objektum között munkavállaló.Így a program csökkenti a memóriaigényt azáltal, hogy 999 másolatot dob ​​ki ugyanazon információkból. Egy osztályelem megosztásához az elemet a következőként kell deklarálnia statikus (statikus). Ez az oktatóanyag az osztályelemek több objektum közötti megosztásához szükséges lépéseket ismerteti. A lecke végére a következő alapfogalmakat sajátítja el:

A C++ lehetővé teszi, hogy azonos típusú objektumok legyenek, amelyek egy vagy több tagot osztanak meg egy osztályban.

Ha a program értéket rendel egy megosztott elemhez, akkor az adott osztály minden objektuma azonnal hozzáfér az új értékhez.

Megosztott osztályadattag létrehozásához meg kell előznie az osztálytag nevét egy kulcsszóval statikus.

Miután a program deklarált egy osztályelemet, mint statikus deklarálnia kell egy globális változót (az osztálydefiníción kívül), amely megfelel az adott megosztott osztálytagnak.

A programjai használhatják a kulcsszót statikus hogy egy osztálymetódus hívható legyen, miközben a program még nem deklarálta az adott osztály egyetlen objektumát sem.

ADATELEM MEGOSZTÁSA

Általában egy adott osztály objektumainak létrehozásakor minden objektum saját adattagkészletet kap. Előfordulhatnak azonban olyan helyzetek, amikor az azonos osztályba tartozó objektumoknak meg kell osztaniuk egy vagy több adatelemet (statikus e adatelemek). Ilyen esetekben az adatelemeket mint általános iszapÉs magán, majd írja elő a típust a kulcsszóval statikus az alábbi:

privát: statikus int megosztott_érték;

Az osztály deklarálása után az elemet globális változóként kell deklarálnia az osztályon kívül, az alábbiak szerint:

int osztálynév::megosztott_érték;

A következő SHARE_IT.CPP program határozza meg az osztályt könyv sorozat, megosztó elem page_count, amely az osztály (sorozat) összes objektumára (könyvére) ugyanaz. Ha egy program megváltoztatja ennek az elemnek az értékét, a változás azonnal tükröződik az osztály összes objektumában:

#beleértve

#beleértve

osztályú könyv_sorozat

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

int könyv_sorozat::oldal__szám;

void book_series::set_pages(int pages)

( oldalszám = oldalak; )

book_series::book_series(char *cím, karakter *szerző, változó ár)

( strcpy(könyvsorozat::cím, cím); strcpy(könyvsorozat::szerző, szerző); könyvsorozat::ár = ár; )

érvénytelen könyvsorozat:: show_book (érvénytelen)

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

( book_series programing("Programozás megtanulása C++-ban", "Jamsa", 22.95); book_series word("Word for Windows", "Wyatt", 19.95); word.set_pages(256); programing.show_book ( ); word.show_book() ;<< endl << "Изменение page_count " << endl; programming.set_pages(512); programming.show_book(); word.show_book(); }

Amint látja, az osztály kijelenti oldalszám Hogyan statikus int. Közvetlenül az osztálydefiníció után a program deklarál egy elemet oldalszám mint globális változó. Amikor egy program elemet változtat page_count, a változás azonnal tükröződik az osztály összes objektumában könyv sorozat.

Osztálytagok megosztása

A programtól függően előfordulhatnak olyan helyzetek, amikor bizonyos adatokat meg kell osztania egy objektum több példánya között. Ehhez deklarálja az elemet statikusnak. Ezután deklarálja ezt az elemet az osztályon kívül globális változóként. A program által ezen az elemen végrehajtott változtatások azonnal megjelennek az osztály objektumaiban.

Elemek használata attribútumokkalnyilvános statikus ha objektumok nem léteznek

Ahogy most megtanulta, egy osztályelem mint statikus ezt az elemet egy adott osztály összes objektuma megosztja. Előfordulhatnak azonban olyan helyzetek, amikor a program még nem hozta létre az objektumot, de használnia kell az elemet. Egy elem használatához a programnak a következőként kell deklarálnia nyilvánosÉs statikus. Például a következő USE_MBR.CPP program használja az elemet oldalszám osztályból könyv sorozat, még akkor is, ha ennek az osztálynak az objektumai nem léteznek:

#beleértve

#beleértve

osztályú könyv_sorozat

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

int könyvsorozat::oldalszám;

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

Ebben az esetben mivel az osztály az osztály egy elemét határozza meg oldalszám Hogyan nyilvános a program akkor is hozzáférhet ehhez az osztályelemhez, ha az osztály objektumai könyv sorozat nem létezik.

STATIKUS ELEM FUNKCIÓK HASZNÁLATA

Az előző program szemléltette a használatot statikus adatelemek. Hasonlóképpen, a C++ lehetővé teszi a definiálást statikus elemfüggvények (módszerek). Ha alkotsz statikus metódus esetén a program akkor is hívhat ilyen metódust, ha az objektumok még nem jöttek létre. Például, ha egy osztály olyan metódust tartalmaz, amely az osztályon kívüli adatokon használható, elkészítheti ezt a metódust statikus. Alul az osztály látható menü amely az ANSI illesztőprogram esc szekvenciáját használja a képernyő törlésére. Ha az ANSI.SYS illesztőprogram telepítve van a rendszerére, használhatja a módszert clear_screen a képernyő tisztításához. Mivel ez a módszer úgy van deklarálva statikus, egy program akkor is használhatja, ha az objektumok típusúak menü nem létezik. A következő CLR_SCR.CPP program használja a módszert clear_screen A képernyő törléséhez:

#beleértve

( public: static void clear_screen(void); // Legyenek itt más módszerek is private: int_menu_options_száma; );

void menü::clear_screen(void)

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