prototype pattern

Angol

Főnév

prototype pattern (tsz. prototype patterns)

(informatika) A Prototype tervezési minta (Prototype Design Pattern) egy kreációs minta a Gang of Four (GoF) által definiált 23 tervezési minta egyike. Arra a problémára ad elegáns megoldást, amikor egy objektum új példányát akarjuk létrehozni, de nem akarjuk (vagy nem tudjuk) a konkrét osztály konstruktorát közvetlenül használni, vagy túl költséges lenne az inicializálás. Ehelyett a meglévő példányt klónozzuk.

🔧 Alapötlet

A Prototype minta lényege, hogy:

Létrehozunk egy absztrakt ősosztályt vagy interfészt, amely tartalmaz egy clone() metódust.
Minden konkrét osztály implementálja a clone() metódust, amely visszaadja az adott objektum egy másolatát.
Az objektumokat nem new kulcsszóval hozzuk létre, hanem egy meglévő objektum alapján, klónozással.

📌 Mikor használd?

Ha a példányosítás költséges (pl. sok adatot kell lekérni, vagy sok erőforrást igényel).
Ha sokféle objektum van, és dinamikusan akarjuk példányosítani őket futásidőben.
Ha futásidőben akarjuk módosítani a példányosítás típusát.
Ha nem ismerjük előre a konkrét osztályt, de van egy meglévő példányunk.

🧬 Példák

Példa 1: C++ stílusú pszeudokód

class Prototype {
public:
    virtual Prototype* clone() const = 0;
    virtual void print() const = 0;
    virtual ~Prototype() {}
};

class ConcretePrototype : public Prototype {
private:
    int value;
public:
    ConcretePrototype(int v) : value(v) {}

    Prototype* clone() const override {
        return new ConcretePrototype(*this);  // másolatkészítés
    }

    void print() const override {
        std::cout << "Érték: " << value << std::endl;
    }
};

void clientCode(const Prototype& prototype) {
    Prototype* newObject = prototype.clone();
    newObject->print();
    delete newObject;
}

Ebben a példában egy konkrét objektum klónozásával új példányt készítünk, anélkül hogy a konstruktorát hívnánk közvetlenül.

🧠 Működési elv – Lépések

Prototype interfész (vagy absztrakt osztály):
- Meghatározza a clone() metódust.
ConcretePrototype osztály(ok):
- Megvalósítják a clone() metódust.
- Lehet mély vagy sekély másolat.
Client:
- Egy példányt klónoz a clone() metódussal anélkül, hogy ismerné a konkrét osztályt.

🔍 Sekély vs. mély másolat

Sekély másolat (shallow copy): az objektum mezőit másolja, de ha mezők pointerek vagy referenciák, azok nem másolódnak mélyen.
Mély másolat (deep copy): minden mező értéke, beleértve az összetett objektumokat is, új példányként másolódik.

🌍 Valós példák

Grafikai szerkesztők: egy alakzat másolása, módosítás előtt.
Játékfejlesztés: egy karakter “archetípusa” alapján új NPC példányok generálása.
Dokumentumsablonok: sablon klónozása egyedi dokumentumhoz.
ORM rendszerek: entitások másolása adatbázis-rekordhoz kötve.

🔁 Előnyök

✅ Futásidőben lehet másolatokat készíteni.

✅ Elkerülhető a bonyolult konstruktorhívás.

✅ Elősegíti az objektumalapú megközelítést az osztályalapú helyett.

✅ Jól működik komplex objektumstruktúrákkal.

⚠️ Hátrányok

❌ Bonyolult lehet, ha sokféle objektum van és bonyolult a klónozás (pl. mély másolat).

❌ Platform- vagy nyelvspecifikus támogatás kellhet (pl. Cloneable Java-ban, clone() C++-ban kézzel implementálandó).

🔄 Prototype minta vs. Egyéb tervezési minták

Mintatípus	Leírás
Prototype	Objektum másolatát hozza létre futásidőben.
Factory Method	Osztály példányosítását delegálja alosztályokra.
Abstract Factory	Objektumcsaládokat példányosít.
Builder	Bonyolult objektumokat állít össze lépésről lépésre.

🧪 Gyakorlati implementációk

Java példa

public abstract class Shape implements Cloneable {
    private String id;
    protected String type;

    abstract void draw();

    public String getType() {
        return type;
    }

    public String getId() {
        return id;
    }

    public void setId(String id) {
        this.id = id;
    }

    public Object clone() {
        Object clone = null;
        try {
            clone = super.clone();  // sekély másolat
        } catch (CloneNotSupportedException e) {
            e.printStackTrace();
        }
        return clone;
    }
}

🏗️ Prototype Registry

Gyakran használják a Prototype Registry fogalmát: egy tároló (pl. map<string, Prototype*>), amely előregyártott példányokat tartalmaz, és ezekből lehet klónozni.

class PrototypeRegistry {
private:
    std::map<std::string, Prototype*> prototypes;
public:
    void addPrototype(const std::string& key, Prototype* proto) {
        prototypes[key] = proto;
    }

    Prototype* create(const std::string& key) {
        return prototypes[key]->clone();
    }
};

📚 Összefoglalás

A Prototype minta:

Egy meglévő objektum másolatát készíti el.
Előnyös, ha példányosítás költséges, vagy ha futásidőben kell objektumtípusokat kezelni.
Szekunder nyereség, hogy elkerülhetők a bonyolult konstruktorparaméterek.
Lehetőséget ad a polimorf klónozásra, ha a típus csak a futásidőben ismert.
Jól kombinálható a Factory és Registry mintákkal.

További információk

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