template specialization miatti kód ismétlődés elkerülése

 ( Jester_Racer | 2011. július 5., kedd - 16:46 )

Üdv!

Itt van egy kis kódrészlet:

template < class T >
class List {
public:
    virtual ~List() {}

    virtual unsigned long size() const = 0;
    virtual void add(const T &element) = 0;
    virtual void remove(const T &element) = 0;

    virtual AbstractIterator< T > * createIterator() = 0;
};

template < class T >
class List< T* > {
public:
    virtual ~List() {}

    virtual unsigned long size() const = 0;
    virtual void add(T *element) = 0;
    virtual void remove(const T &element) = 0;

    virtual AbstractIterator< T* > * createIterator() = 0;
};

Amint az látszik, egy nagyon egyszerű lista adatszerkezetet szeretnék megvalósítani, de úgy, hogy pointerekkel is működjön.
A problémám az, hogy a specializáció miatt 4-ből 3 függvényt újra ki kéne fejtenem a specializált változatban, de csak nagyon minimális változtatással, szóval a specializáció miatt nagyon megnőne a kód többszöröződés, nehéz lenne karban tartani a kódot stb.

Vannak esetleg ennek kiküszöbölésére trükkök/módszerek, vagy nem tudom elkerülni ilyen esetben a kód ismétlődést?
Google-ben találtam 1-2 oldalt ahol hasonló kérdéseket tesznek fel, de nem nagyon találtam használható választ.

Hozzászólás megjelenítési lehetőségek

A választott hozzászólás megjelenítési mód a „Beállítás” gombbal rögzíthető.

Miért kell a címhez külön típus? A T lehet T* is.

Ha a felszabadítás miatt: használj shared_ptr-t!
--
http://www.naszta.hu

Minek a virtual?
Minek a T*?

Egyébként ha a fv-ek nagy része ugyanaz, esetleg kiszervezheted egy privát tagfv-é a megegyező részeket ha annak van értelme...

"...handing C++ to the average programmer seems roughly comparable to handing a loaded .45 to a chimpanzee." -- Ted Ts'o

Az első két hozzászólásra válaszolnék:
Őszintén szólva eddig nagyon ritkán akadt dolgom sablonokkal, szóval lehet, hogy nagy hülyeségek vannak a kódban.
A Stroustrup féle könyvet olvasom épp, és az alapján gondoltam azt, hogy ha pointerekkel is használni akarom az osztályt, akkor specializálni kell T*-ra az osztályt. Ezek szerint félreértettem valamit.

A virtual azért kéne, mert ez a List csak egy interfész, ebből származtatnék pl.: LinkedList-et.

Tehát azt szeretném, ha mindkettővel helyesen működne:

List< int > *l = new LinkedList< int >();
l->add(10);

List< Pair * > *l = new LinkedList< Pair * >();
l->add(new Pair("valami", 10));

Emlékeim szerint a Stroustrup féle könyvben csak azért van T*, hogy azt visszavezesse void*-gá, így megszüntetve a kód felesleges többszöri generálását.
Mert alapból minden típusra amivel használod külön kód generálódik.
Ami jó ha a típus int, char meg hasonlók, de kicsit felesleges a különböző mutató típusokra.

De ez elsősorban akkor érdekes, ha az adott osztály elég nagy, és sokszor használod sokféle mutató típussal. Mondjuk egy STL-ben hasznos, egy saját osztálynál ami leginkább tanulásra van kevésbé.

"...handing C++ to the average programmer seems roughly comparable to handing a loaded .45 to a chimpanzee." -- Ted Ts'o

OFF:

Három éve nyugtalanított az a kérdés, hogy annak idején, amikor prog2 gyakorlaton template-ket tanultunk, miért szenvedtünk void *-gal... Köszönöm. :-)

Aki csak prog gyakon tanul C++-t az sikeres ember nem lehet... :)
De komolyan, Stroustrup könyv alap, és azon kívül is van sok jó olvasnivaló, offline és online.

"...handing C++ to the average programmer seems roughly comparable to handing a loaded .45 to a chimpanzee." -- Ted Ts'o

Annyira sosem volt igényem rá... :-) Villamosmérnök létem miatt kicsit más irányba mentem. Egyébként a Bjarne-könyv megvan, meg minden.