augmented assignment

augmented assignment (tsz. augmented assignments)

1. (informatika) Az augmented assignment (bővített értékadó) kifejezés a C++ nyelvben azokra az értékadásokat kombináló műveletekre utal, amelyek valamilyen műveletet és értékadást egyszerre hajtanak végre. Ezek egyszerűsítik a kódot, növelik az olvashatóságot, és gyakran hatékonyabbak is lehetnek fordítási szinten.

A sima értékadás:

a = a + b;

Bővített (augmented) változata:

a += b;

Ez nem csak rövidebb, hanem gyakran hatékonyabb is, mert a fordító optimalizálhatja.

C++ nyelvben a következő augmented assignment operátorokat ismerjük:

Példa:

int a = 5;
a += 3;  // ugyanaz, mint: a = a + 3;

Fordításkor ez rövidebb assembly utasításokká alakulhat, mint ha külön értékadást és műveletet írnánk.

1. Kód rövidítése: kevesebb gépelés, kisebb hibalehetőség.
2. Kifejezőbb: egyértelműen jelzi, hogy a változó önmagát módosítja.
3. Teljesítmény: egyes esetekben a fordító optimalizálni tudja (pl. nincs szükség ideiglenes változóra).
4. Operator overloading támogatás: osztályokban is testreszabható viselkedés.

C++-ban saját típusokra is írhatunk augmented assignment operátort:

class Vec2 {
public:
    int x, y;

    Vec2(int x=0, int y=0): x(x), y(y) {}

    Vec2& operator+=(const Vec2& rhs) {
        x += rhs.x;
        y += rhs.y;
        return *this;
    }
};

Használat:

Vec2 a(1, 2), b(3, 4);
a += b;  // a == (4, 6)

• Számlálók, ciklusok:

for (int i = 0; i < 10; i += 2)

• Bitműveletek:

flags |= 0x01;  // kapcsoló beállítása

• Tömbindexelés:

int i = 0;
arr += 5;

• Saját típusok kezelésére, mint vektorok, mátrixok stb.

1. Prioritás: a += b * c → a = a + (b * c) (nem a = (a + b) * c).
2. Oldalhatások: ha a vagy b egy függvényhívás, értékelési sorrendre figyelni kell.
3. Overloadnál ne felejtsük el referencia-visszatérést (return *this), különben nem működik jól a láncolás (a += b += c).
4. Konstans objektumokon nem működik, hacsak nem mutable.

A legtöbb STL típus támogatja az augmented operátorokat:

std::string s = "Hello ";
s += "World";  // "Hello World"

std::vector<int> v1 = {1, 2};
std::vector<int> v2 = {3, 4};
// v1 += v2; // NEM működik, mivel nincs definiálva erre az operátor

Ha szükséges, saját overloadot írhatunk, pl.:

template <typename T>
std::vector<T>& operator+=(std::vector<T>& lhs, const std::vector<T>& rhs) {
    lhs.insert(lhs.end(), rhs.begin(), rhs.end());
    return lhs;
}

• Az augmented assignment operátorok a C++ nyelv fontos és hatékony elemei.
• Nemcsak primitív típusokkal használhatók, hanem saját típusokra is testreszabhatók.
• Kódot tisztábbá, rövidebbé és hatékonyabbá tehetnek.
• Fontos figyelni a prioritásra, oldalhatásokra és az overloadolásnál a szintaktikára.

• augmented assignment - Szótár.net (en-hu)
• augmented assignment - Sztaki (en-hu)
• augmented assignment - Merriam–Webster
• augmented assignment - Cambridge
• augmented assignment - WordNet
• augmented assignment - Яндекс (en-ru)
• augmented assignment - Google (en-hu)
• augmented assignment - Wikidata
• augmented assignment - Wikipédia (angol)