pointer operator

Angol

Főnév

pointer operator (tsz. pointer operators)

1. (informatika) A -> (pointer operátor) C++-ban egy speciális operátor, amelyet pointerek által mutatott objektumok tagfüggvényeinek és adattagjainak elérésére használunk.

---

1. Mi az a -> operátor?

A -> operátor egy rövidített forma a pointereken keresztüli tageléréshez.

Ha van egy pointer egy objektumhoz, akkor: - (*ptr).tag helyett használhatjuk a ptr->tag szintaxist.

Ezáltal a -> operátor egyenértékű az alábbi kifejezéssel:

ptr->tag  ≡  (*ptr).tag

---

2. Alapvető használata (-> vs. .)

Normál objektum (. operátor használata)

Ha egy nem pointerként tárolt objektummal dolgozunk, a . operátort használjuk:

#include <iostream>
using namespace std;

class Auto {
public:
    string marka;
    void mutat() {
        cout << "Márka: " << marka << endl;
    }
};

int main() {
    Auto a;
    a.marka = "Toyota";
    a.mutat();  // "Márka: Toyota"
    return 0;
}

Pointeres objektum (-> operátor használata)

Ha az objektumot pointerként tároljuk, akkor a -> operátort használjuk:

#include <iostream>
using namespace std;

class Auto {
public:
    string marka;
    void mutat() {
        cout << "Márka: " << marka << endl;
    }
};

int main() {
    Auto* a = new Auto();  // Pointerrel foglalunk egy objektumot
    a->marka = "BMW";      // `a->` használata
    a->mutat();            // "Márka: BMW"
    
    delete a;  // Felszabadítás
    return 0;
}

Miért van szükség a -> operátorra? - Ha *a.mutat(); próbálnánk írni, az hibás lenne. - (*a).mutat(); működik, de hosszabb és kevésbé olvasható.

---

3. Struktúrák és a -> operátor

Struktúrák esetén is használható a -> operátor.

Struktúra példa -> operátorral

#include <iostream>
using namespace std;

struct Ember {
    string nev;
    int kor;
};

int main() {
    Ember* e = new Ember{"Anna", 25};
    cout << e->nev << " " << e->kor << " éves." << endl;

    delete e;
    return 0;
}

Kimenet:

Anna 25 éves.

Ha pointerekkel dolgozunk, a -> operátor sokkal átláthatóbb, mint (*e).nev.

---

4. Dinamikus objektumok és ->

Ha dinamikusan foglalunk egy objektumot, a -> operátor nélkül nem tudnánk egyszerűen elérni a tagjait.

#include <iostream>
using namespace std;

class Ember {
public:
    string nev;
    Ember(string n) { nev = n; }
    void koszont() {
        cout << "Helló, " << nev << "!" << endl;
    }
};

int main() {
    Ember* e = new Ember("Gábor");
    e->koszont();  // "Helló, Gábor!"
    
    delete e;
    return 0;
}

---

5. Tömbök és -> operátor

Ha egy objektumtömböt hozunk létre pointerként, az indexeléssel ([]) kombinálhatjuk a -> operátort.

#include <iostream>
using namespace std;

class Ember {
public:
    string nev;
    Ember() { nev = "Ismeretlen"; }
};

int main() {
    Ember* emberek = new Ember[3];  // 3 elemű objektumtömb
    emberek[0].nev = "Péter";
    emberek[1].nev = "Judit";
    emberek[2].nev = "Tamás";

    cout << emberek[1].nev << endl;  // "Judit"

    delete[] emberek;  // Fontos a tömb felszabadítása!
    return 0;
}

Itt a -> nem szükséges, mert az emberek[i] már maga is egy objektum.

---

6. Osztályok mutatókkal és this

A this egy implicit pointer, amely az aktuális objektumra mutat. A this segítségével az osztály saját tagjaihoz is hozzáférhetünk.

this és -> használata

#include <iostream>
using namespace std;

class Ember {
public:
    string nev;
    
    Ember(string nev) { 
        this->nev = nev;  // `this->` használata az osztálytagok elérésére
    }
    
    void mutat() {
        cout << "Nev: " << this->nev << endl;
    }
};

int main() {
    Ember e("Kata");
    e.mutat();  // "Nev: Kata"
    return 0;
}

Itt a this->nev = nev; azt jelenti, hogy a bal oldali osztálytag, míg a jobb oldali a függvény paramétere.

---

7. Smart Pointerek és ->

Modern C++-ban az okos pointerek (std::unique_ptr, std::shared_ptr) automatikusan kezelik a memóriafelszabadítást.

unique_ptr használata -> operátorral

#include <iostream>
#include <memory>  // Smart pointer könyvtár

using namespace std;

class Ember {
public:
    void koszont() {
        cout << "Helló!" << endl;
    }
};

int main() {
    unique_ptr<Ember> e = make_unique<Ember>();
    e->koszont();  // "Helló!"  (-> operátorral)
    
    return 0;  // Automatikusan felszabadul!
}

Miért jobb az std::unique_ptr? - Nem kell delete-et hívni. - Nem okoz memóriaszivárgást.

---

8. Összegzés

Kifejezés	Mit csinál?
obj.tag	Az objektum tag tagját éri el
ptr->tag	A pointer által mutatott objektum tag tagját éri el
(*ptr).tag	Ugyanaz, mint ptr->tag, de hosszabb
this->tag	Az aktuális objektum tag tagját éri el

Mikor használjuk a -> operátort?

✅ Ha egy pointerrel mutatunk egy objektumra
✅ Ha dinamikusan foglaltunk memóriát (new)
✅ Ha smart pointereket (unique_ptr, shared_ptr) használunk

---

Konklúzió

A -> operátor pointereken keresztüli tagelérést tesz lehetővé, ami tisztább és olvashatóbb szintaxist eredményez, mint a (*ptr).tag használata. Modern C++-ban az okos pointerek (std::unique_ptr, std::shared_ptr) még biztonságosabb és egyszerűbb kezelést nyújtanak.

További információk

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