Ugrás a tartalomhoz

decrement operator

A Wikiszótárból, a nyitott szótárból

Angol


Főnév

decrement operator (tsz. decrement operators)

  1. (informatika) A C++ programozási nyelv egyik alapvető operátora a decrement operátor (--), amely egy adott változó értékét egyel csökkenti. Ez a művelet rendkívül gyakran fordul elő ciklusokban, iterációs folyamatokban, számlálók kezelésénél, vagy algoritmusok implementálásakor, ahol visszafelé kell lépegetni.

Két fő típusa létezik:

  • Prefix decrement (--változó)
  • Postfix decrement (változó--)

Habár mindkettő ugyanazt az eredményt adja, működésük, és az általuk visszaadott értékek különböznek egymástól.


Alapvető működés

A decrement operátor (--) az alábbi műveletek rövidített változata:

változó = változó - 1;
// vagy még rövidebben
változó -= 1;

A fenti két megoldás ugyanazt az eredményt hozza, de a decrement operátor egyszerűbbé és olvashatóbbá teszi a kódot.

Példa a decrement operátor alapvető használatára:

int szam = 10;
szam--;  // érték most: 9
--szam;  // érték most: 8

Prefix decrement (--változó)

Prefix decrement esetén a változó értéke először csökken, majd a csökkentett értéket adja vissza. Ez azt jelenti, hogy a decrement azonnal megtörténik, mielőtt még a kifejezés értékét tovább használnánk.

Példa a prefix decrement használatára:

int a = 10;
int b = --a;
// most 'a' értéke: 9
// 'b' értéke: 9

A példában a értéke azonnal csökken, majd az új, csökkentett érték kerül a b változóba.


Postfix decrement (változó--)

A postfix decrement a változó értékét szintén csökkenti, de előtte visszaadja a változó eredeti (csökkentés előtti) értékét. Tehát a postfix változatnál először használódik fel a változó eredeti értéke, és csak utána történik meg a tényleges csökkentés.

Példa postfix decrement használatára:

int a = 10;
int b = a--;
// 'a' értéke most: 9
// 'b' értéke még mindig: 10

Itt a b értékadás pillanatában még a régi értéket (10-et) kapja, majd a csökken egy értékkel.


A decrement operátor belső működése és teljesítmény

A decrement operátor belső működését megértve láthatóvá válik, hogy a postfix decrement egy ideiglenes objektummásolat létrehozását igényli, míg a prefix decrement közvetlenül módosítja az eredeti objektumot. Ezért a postfix verzió bizonyos esetekben kevésbé hatékony lehet, mint a prefix, különösen akkor, ha összetett objektumok esetén történik használat.


Saját osztályok és a decrement operátor implementációja

C++ nyelvben saját osztályokhoz is definiálhatjuk a decrement operátort, aminek során külön kell implementálni a prefix és postfix verziót.

Példa egy egyszerű osztály decrement operátorára:

class Szamlalo {
    int ertek;
public:
    Szamlalo(int kezdo = 0) : ertek(kezdo) {}

    // prefix decrement
    Szamlalo& operator--() {
        --ertek;
        return *this;
    }

    // postfix decrement
    Szamlalo operator--(int) {
        Szamlalo regiAllapot = *this;
        ertek--;
        return regiAllapot;
    }

    int getErtek() const {
        return ertek;
    }
};

Használata:

Szamlalo sz(5);
--sz;  // sz értéke most: 4
sz--;  // sz értéke most: 3

A postfix verzió különlegessége, hogy egy dummy int paramétert kap, hogy a fordító megkülönböztesse a két operátort.


Gyakori hibák decrement operátorok használata során

Hiba példa:

Az egyik gyakori hiba, amikor a postfix decrement-et összekeverjük a prefix decrement működésével, például ciklusoknál vagy tömbök indexelésénél:

int i = 5;
int tomb[5] = {1, 2, 3, 4, 5};

// Hibás vagy nehezen érthető
while(i > 0) {
    cout << tomb[i--] << " "; 
    // Figyelem: tomb[5] hibás, mert 0-tól indexelünk, ez túlindexeléshez vezet!
}

// Helyesen így lenne érthető:
for(int i = 4; i >= 0; --i) {
    cout << tomb[i] << " ";
}

Ez a hiba gyakran vezet túlindexeléshez vagy logikai hibákhoz, ezért különösen figyelni kell az ilyen esetekben.


Decrement operátor teljesítmény-optimalizálása

Amikor primitív típusokat használunk (például int, char), a prefix és postfix decrement között nincs lényeges teljesítménykülönbség, hiszen a fordítóprogram általában optimalizálja a kódot. Ugyanakkor komplex osztályok esetében a postfix decrement használata lassabb lehet az ideiglenes másolatok miatt.

Ezért általános szabály, hogy ha nincs különösebb oka a postfix decrement használatának, érdemesebb a prefix verziót használni teljesítményoptimalizálási okokból.


Ajánlások a decrement operátor használatához:

  • Mindig figyeljünk arra, hogy prefix és postfix decrement milyen értéket ad vissza.
  • Egyszerű típusoknál nincs nagy különbség, de összetett típusoknál érdemes prefix decrement-et preferálni.
  • Kerüljük a komplex kifejezésekben való túlzott használatot, mert csökkenti az olvashatóságot.


Összegzés

A decrement operátor (--) a C++ nyelvben elengedhetetlen eszköz, ha értékeket kell csökkentenünk ciklusokban vagy egyéb algoritmusok során. A prefix decrement először csökkenti az értéket, majd a csökkentett értéket használja, míg a postfix decrement a korábbi értéket adja vissza, majd csökkent.

A két verzió közti különbséget mindig tartsuk szem előtt, mert bizonyos esetekben jelentős eltéréseket eredményezhet a működésben és teljesítményben egyaránt. A decrement operátorok pontos megértése segít tiszta, hatékony, jól olvasható C++ kód írásában.

További információk

A lap eredeti címe: „https://hu.wiktionary.org/w/index.php?title=decrement_operator&oldid=3490495”