Ugrás a tartalomhoz

interface data type

A Wikiszótárból, a nyitott szótárból
(interface abstract data type szócikkből átirányítva)

Angol


Főnév

interface data type (tsz. interface data types)

  1. (informatika) A C++ nyelv egyik legerősebb és legkomplexebb eleme az objektum-orientált programozás (OOP), amelynek egyik alapfogalma az absztrakció. Az absztrakció célja, hogy elrejtsük a bonyolult implementációs részleteket és csak azokat az információkat jelenítsük meg, amelyek szükségesek a használathoz.

Az absztrakt adattípus (ADT) és az interfész fogalma szorosan összefonódik az osztály absztrakciójával, és mindkettő kulcsszerepet játszik abban, hogy hogyan tervezünk bővíthető, karbantartható és jól strukturált kódot.


🔍 Absztrakt adattípus (ADT) fogalma

Egy absztrakt adattípus nem egy konkrét adatszerkezet, hanem egy logikai modell, amely az adatok tárolásának és manipulációjának módját írja le, függetlenül az implementációtól.

Példák absztrakt adattípusokra:

  • Lista
  • Verem (stack)
  • Sor (queue)
  • Prioritási sor
  • Halmaz
  • Szótár (map)

Egy ADT műveleteket definiál, de nem határozza meg, hogy ezek hogyan vannak implementálva. Például egy verem (stack) műveletei:

  • push(x) – elem hozzáadása
  • pop() – legutolsó elem eltávolítása
  • top() – a legutolsó elem lekérdezése


👓 Interfész (interface) C++-ban

A C++ nyelvben nincs beépített interface kulcsszó (mint pl. Java-ban), de az interfész funkcionálisan megvalósítható absztrakt osztályokkal.

📌 Interfész = teljesen absztrakt osztály

Egy interfészt C++-ban egy olyan osztályként definiálunk, amely csak tisztán virtuális függvényeket tartalmaz:

class IShape {
public:
    virtual double area() const = 0;
    virtual double perimeter() const = 0;
    virtual ~IShape() {}
};

Ez az osztály egy interfészt definiál, amely bármilyen „alakzat” típusú objektum közös viselkedését írja le, anélkül, hogy tudnánk, hogyan működik a háttérben.


🎭 Osztály absztrakciója

Az osztály absztrakciója azt jelenti, hogy elválasztjuk a „mit csinál” kérdést a „hogyan csinálja” kérdéstől.

Példa:

class Stack {
public:
    virtual void push(int x) = 0;
    virtual int pop() = 0;
    virtual bool isEmpty() const = 0;
    virtual ~Stack() {}
};

Itt a Stack egy absztrakt osztály, ami az absztrakt adattípus (verem) interfésze is egyben. Ez nem mondja meg, hogy az adatok egy tömbben vagy láncolt listában vannak tárolva – ezt majd a konkrét megvalósítás adja.


🧩 Implementáció (példa konkrét osztállyal)

class ArrayStack : public Stack {
private:
    int arr[100];
    int topIndex;
public:
    ArrayStack() : topIndex(-1) {}
    
    void push(int x) override {
        arr[++topIndex] = x;
    }
    
    int pop() override {
        return arr[topIndex--];
    }
    
    bool isEmpty() const override {
        return topIndex == -1;
    }
};

Itt az ArrayStack egy konkrét implementációja a veremnek, amely egy tömböt használ.

A kód felhasználója azonban csak a Stack* típuson keresztül éri el:

void process(Stack* s) {
    s->push(10);
    s->push(20);
    cout << s->pop(); // 20
}

Ez lehetővé teszi a polimorfizmust: ugyanaz az interfész többféle implementációra alkalmazható.


🧠 Miért hasznos ez?

1. Modularitás

Különválaszthatók az implementációk és az interfészek, ami jobb kódkarbantartást és kódújrafelhasználást tesz lehetővé.

2. Bővíthetőség

Könnyen hozzáadhatsz új implementációkat anélkül, hogy a meglévő kódot módosítanád.

3. Unit tesztelhetőség

Mock objektumokkal tesztelheted az interfészt, anélkül hogy a konkrét megvalósítást használnád.


🎨 Interfészek a gyakorlatban

Példa 2: IShape interfész használata

class Circle : public IShape {
    double radius;
public:
    Circle(double r) : radius(r) {}
    double area() const override { return 3.14 * radius * radius; }
    double perimeter() const override { return 2 * 3.14 * radius; }
};

class Rectangle : public IShape {
    double width, height;
public:
    Rectangle(double w, double h) : width(w), height(h) {}
    double area() const override { return width * height; }
    double perimeter() const override { return 2 * (width + height); }
};

void printShapeInfo(const IShape& shape) {
    cout << "Area: " << shape.area() << endl;
    cout << "Perimeter: " << shape.perimeter() << endl;
}

Ez a kód teljesen független attól, hogy shape milyen konkrét osztályból jön. Ez absztrakció a javából.


🧱 Összegzés

Fogalom Jelentés
ADT Logikai leírás műveletekkel, de konkrét implementáció nélkül
Interfész Absztrakt osztály tisztán virtuális metódusokkal
Absztrakció A részletek elrejtése, és a lényeg kiemelése
Polimorfizmus Egy interfészen keresztül többféle viselkedés megvalósítása


🧩 TL;DR

A C++ interfészek absztrakt osztályokon keresztül valósulnak meg. Egy absztrakt adattípus (ADT) meghatározza az elvárt viselkedést, míg az interfész ezt C++-ban deklarálja. Az osztály absztrakciója segít elrejteni az implementációs részleteket, és támogatja a moduláris, rugalmas és jól tesztelhető kódot.


További információk

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