Ebben a cikkben még egy objektumorientált koncepciót fogunk megvizsgálni, amely megkönnyíti a kezelő kezelését. Vagyis belemerülnénk az Operátor részleteibe Túlterhelés C ++ -ban . A következő hivatkozásokkal foglalkozunk ebben a cikkben,
- Túlterhelés C ++ -ban
- A túlterhelés típusai C ++ - ban
- Miért használják a kezelő túlterhelését?
- Operátor túlterhelés megvalósítása C ++ nyelven
- A túlterheléses megközelítések típusai
- Az Unary operátorok túlterhelése
- A bináris operátorok túlterhelése
Tehát kezdjük el ezt a cikket az Operátor túlterheléséről a C ++ nyelven.
Túlterhelés C ++ -ban
Ha két vagy több tagot hozunk létre ugyanabból az osztályból, ugyanazzal a névvel, de számukban vagy paramétertípusukban különböznek egymástól, akkor ezt C ++ túlterhelésnek nevezzük.
C ++ - ban túlterhelhetjük:
- mód
- kivitelezők
- indexelt tulajdonságok
Ez azért van, mert ezek a tagok csak paraméterekkel rendelkeznek.
Folytatás a C ++ operátor túlterheléséről szóló cikkel.
A túlterhelés típusai C ++ - ban
- Funkció túlterhelése
- A kezelő túlterhelése
Folytatás a C ++ operátor túlterheléséről szóló cikkel.
Miért használják a kezelő túlterhelését?
A C ++ programok az operátor túlterhelésének ismerete nélkül írhatók. A programozók akkor is mélyen használják az operátor üzemeltetését, hogy intuitívvá tegyék a programot. Például,
Cserélhetjük a kódot, például:
számítás = összeadás (osztás (a, b), szorzás (a, b))
Az egyenlethez
számítás = (a / b) + (a * b)
Az operátorok túlterhelése egyszerű és egyszerű módszert kínál új definíciók kidolgozására a legtöbb C ++ operátor számára. Megfelelő tudással szinte új saját nyelvet hozhatunk létre a funkció kreatív alkalmazásával és az operátor túlterhelési technikáival. Túlterhelhetjük a C ++ operátorokat az alábbiak kivételével:
● Hatókör kezelő (: :)
● Méret operátor (Sizeof)
● tagválasztó (.)
● tag mutató választó (*)
● háromhetes operátor (? :)
mi a szinkronizálás a java-ban
Az operátor túlterhelésének szintaxisa
return_type class_name:: operátor op (argumentumlista) {// function body}Ahol a visszatérés típusa a függvény által visszaadott érték típusa. class_name az osztály neve.
Folytatás a C ++ operátor túlterheléséről szóló cikkel.
Operátor túlterhelés megvalósítása C ++ nyelven
A kezelő funkciónak nem statikus (tagfunkció) vagy barát funkciónak kell lennie a túlterheléshez. Az operátor túlterhelési funkciója alkalmazható egy tagfüggvényre, ha a bal operandus az adott osztály objektuma, de ha a bal operandus eltér, akkor az Operátor túlterhelés funkciót nem tagfüggvényként kell meghatározni.
A kezelő túlterhelési funkciója barát funkcióvá tehető, ha ehhez hozzá kell férni az osztály privát és védett tagjaihoz. Például az op operátor olyan operátorfüggvény, ahol op az operátor túlterhelt, és az operátor a kulcsszó. A kezelő túlterhelését olyan funkció megvalósításával érhetjük el, amely lehet tag-, nem tag- vagy barátfunkció.
Mi a különbség a kezelői és a normál funkciók között?
A kezelői funkciók megegyeznek a normál funkciókkal. Az egyetlen különbség az, hogy az operátorfüggvény neve mindig operátor kulcsszó, amelyet az operátor szimbóluma követ, és az operátorfüggvények meghívásra kerülnek, amikor a megfelelő operátort használják.
Folytatás a C ++ operátor túlterheléséről szóló cikkel.
A túlterheléses megközelítések típusai
A kezelő túlterhelését háromféle megközelítéssel lehet elvégezni
- Unary operátor túlterhelése.
- A bináris operátor túlterhelése.
- A bináris operátor túlterhelése egy barát funkcióval.
Folytatás a C ++ operátor túlterheléséről szóló cikkel.
Az Unary Operator túlterhelése
Tekintsük az unáris ‘-’ operátort. Ha mínusz operátort használnak unárisként, akkor csak egy operandusra van szükség. Tudjuk, hogy ez az operátor megváltoztatja az operandus előjelét, amikor egy alapadat-változóra alkalmazzák. Lássuk, hogyan kell túlterhelni ezt az operátort, hogy az ugyanúgy alkalmazható legyen egy objektumra, mint egy int vagy float változóra. Az unárikus mínusz, ha egy objektumra alkalmazzák, csökkentenie kell az egyes adatait.
Példa:
big data fejlesztő munkaköri leírás
#include névtér használatával std class Height {public: // Member Objects int láb, hüvelyk // Konstruktor az objektum értékének inicializálásához Magasság (int f, int i) {feet = f inch = i} // Túlterhelés (-) operátor decrement végrehajtása // Magasság objektum működése void operator- () {feet-- inch-- cout<< 'Feet & Inches after decrement: ' << feet << ' ' ' << inch < Kimenet:
Magyarázat:
A fenti példában túlterheljük a ’-’ unary operátort a Height osztály két változójában történő csökkentés végrehajtására. Két paramétert adunk át a kivitelezőnek, és értékeiket láb és hüvelyk változóban mentjük el. Ezután definiáljuk az operátor túlterhelési függvényét (void operator- ()
), amelyben a két változót egy pozícióval csökkentjük.
Amikor a -h1 értéket írjuk, meghívja az operátor túlterhelési függvényét, és csökkenti a konstruktornak átadott értékeket.
Folytatás a C ++ operátor túlterheléséről szóló cikkel.
A bináris operátor túlterhelése
Két operanduson működő operátor túlterhelése. Vegyük ugyanazt a példát a Height osztályra, de ezúttal adjunk hozzá két h1 és h2 Height objektumot.
Példa:
#include névtér használatával std osztály Magasság {public: int láb, hüvelyk Magasság () {láb = 0 hüvelyk = 0} Magasság (int f, int i) {láb = f hüvelyk = i} // Túlterhelés (+) operátor // két távolságú objektum hozzáadása bináris operátorral Magasság operátor + (Magasság & d2) // Hívás hivatkozással {// Objektum létrehozása a magasság h3 visszaadásához // Láb és hüvelyk hozzáadása h3.feet = láb + d2.feet h3. inch = inch + d2.inch // A kapott objektum visszatérése h3}} int main () {Magasság h1 (3, 7) Magasság h2 (6, 1) Magasság h3 // Túlterhelt operátor használata h3 = h1 + h2 cout<< 'Sum of Feet & Inches: ' << h3.feet << ''' << h3.inch << endl return 0 } Kimenet:
Magyarázat:
Magasság operátor + (Magasság & h2), itt visszatér a_funkció típusa: osztály Magasság, így a Magasság osztályú h3 objektumot adja vissza. A h3 = h1 + h2 sorban h1 meghívja az osztályok objektumainak operátorfüggvényét, és paraméterként h2-t vesz fel, majd h3.feet = láb + d2.feet és h3.inch = inch + d2.inch értéket alkalmazunk, amely a a láb és hüvelyk változó értékeinek összege a h3 objektumhoz társított változókban.
Amikor a „h3 = h1 + h2” utasítás meghívja az operátor túlterhelt függvényét, a h1 objektum felelősséget vállalt a függvény meghívásáért, h2 pedig a függvénynek átadott argumentum szerepét tölti be. A fenti invokációs utasítás ekvivalens a h3 = h1.operator + (h2) értékkel, ezért a h2 adattagjához közvetlenül, a h2 adattagjához (amelyet argumentumként adunk át) a dot operátorral férünk hozzá.
Az üzemeltető túlterhelésének szabályai
- Csak a meglévő operátorokat lehet túlterhelni és az új operátorokat nem lehet túlterhelni
- A túlterhelt operátornak tartalmaznia kell legalább egy operandusot a felhasználó által definiált adattípusból.
- Nem használunk barát funkciót bizonyos operátorok túlterheléséhez. A tagfunkciók azonban felhasználhatók az operátorok túlterhelésére.
- Ha az unáris operátorok túlterheltek egy tagfüggvényen keresztül, akkor nem vesznek fel kifejezett argumentumokat, de ha egy barát függvény terheli őket, akkor egy argumentumot vesznek fel.
- Amikor a bináris operátorok túlterheltek egy tagfüggvényen keresztül, akkor egy explicit argumentumot vesznek fel, és ha egy friend függvényen túlterheltek, akkor két explicit argumentumot vesznek fel.
Így a „Operátor túlterhelése C ++ - ban” c. Cikkünk végéhez értünk. Ha többet szeretne megtudni, nézze meg a Java Training by Edureka, egy megbízható online tanulási társaságot. Edureka's tanfolyamot úgy tervezték, hogy mind az alapvető, mind a fejlett Java-koncepciókra kiképezzen különféle Java-keretrendszereket, például a Hibernate & Spring.
Van egy kérdésünk? Kérjük, említse meg a blog megjegyzés rovatában, és a lehető leghamarabb kapcsolatba lépünk Önnel.