[c++] Pomoč pri izdelavi std::vector "wrapperja"

Živjo,

Rad bi naredil en razred, ki bi bil ubistvu "ovojnica" std::vectorja, za lažje programiranje recimo takole

template<class T>
class TarVectorWrapper {
    private:
        vector<T> FVector; 
    public:    
        TarVectorWrapper() {};      
        virtual ~TarVectorWrapper() { Clear(); };
        void Clear() { FVector.clear(); };
        void PushBack(T AItem) { FVector.push_back(AItem); };
};    

Dodal bi še metode Get(unsigned int AIndex), Delete(unsigned int AIndex) in podobno. Zaustavi pa se mi pri metodi Clear() (ali pa delete). V primeru če bi shranjeval v vector kazalce (

 TarVectorWrapper<string*> 

), bi rad da mi metoda Clear tudi uniči shranjeni objekt in ne samo pobriše kazalce. Kako naj to izpeljem, če je sploh mogoče, ali se da preverit če je shranjeni podatatek v vectorju kazelec ali navadna spremenljivka. In v primeru da je kazalec se sprehodim čez vector in uničim objekte na katere kažejo kazalci v vektorju.

Hvala za odgovore

Hvala za izčrpen odgovor, vendar imam vseeno še nekaj vprašanj,

Vse knjige tudi odsvetujejo hranjenje pointerjev v vektorju, predvsem zaradi varnosti pred memory leaki. Primer leaka:
Nekdo mi je svetoval, naj v vektorju vedno uporabim pointerje na objekte razen za recimo double, int, long itd... ampak pustmo to...
Če prav razumem so v vektorju nanizani iteratorji, ki so v bistvu kazalci na objekte in sklepam, da je res brezveze uporabiti pointerje.
Ali se motim. Kle bi mi prav prišel kakšen nasvet (se bom pa potrudil in tudi sam prebra lkakšen Effective STL... )

Ko se govori o templateih bos pa od mene dobil vedno izcrpen odgovor Sej vem, character flaw

Najbolje je ce si std::vector predstavljas kot navadno tabelo. Le da namesto int tabela[100] (ali pa int* tabela = new int[100]) napises

std::vector<int> tabela(100)

Uporaba vectorja je sedaj lahko popolnoma identicna uporabi obicajnega arraya. Tudi implementacija je skoraj identicna. V vectorju je pac dinamicno alocirana tabela. Zato so tudi fancy iteratorji u bistvu le navadni pointerji. A tega ne sedaj narobe razumeti. Nima vsak element tabele svojega kosa alociranega pomnilnika, ki bi ga lahko posebej zbrisal (unicil). Vsi si delijo en kos pomnilnika, v njem pa so enostavno zaporedno nametani (tako kot v int* tabela). Torej prakticno identicna koda:

// c way
int* tabela = new int[100];
for (int* iter = tabela; iter < tabela + 100; ++iter) {
   std::cout << *iter;
}
delete[]tabela;
// pa se c++ way
std::vector<int> tabela(100);
for (std::vector<int>::iterator iter = tabela.begin(); iter != tabela.end(); ++iter) {
   std::cout << *iter;
}

Sedaj pa dodatki vektorja. Vsi elementi so vedno initializirani. To v primeru intov pomeni da imajo vrednost 0, v primeru tvojih razredov pa, da se vedno klice default konstruktor. Zadevo je zelo enostavno kadarkoli povecati, (funkcije resize, push_back). In navsezadnje ob unicenju tabele (ki ga ni treba explicitno klicati) se unicijo vsi elementi (klicejo se destruktorji).

To, da so ti rekli, da je bolje dajati pointerje v vector se nanasa lahko le na pocasnost pri dinamicnem vecanju (imas tabelo z 1M elementi, dodas se enega, sistem bo naredil novo tabelo z 2M elementi, skopiral elemente v to novo tabelo, unicil elemente stare tabele, unicil staro tabelo). Ce so v tabeli le pointerji je tudi to se vedno dokaj hitro. Ce pa imas notri velike in komplexne razrede s obilnimi konstruktorji in destruktorji bo stvar pokleknila. Zato pa obstaja funkcija reserve(size), ki vectorju ze vnaprej doloci dovolj rama (ce ves priblizno koliko elementov nameravas vtakniti vanjo).

Samo tko, zdej sem naredil na tak način, da imam še na preverjanje napak pri možnem out of range. Če mate kakšno
pripombo....

//------------------------------------------------------------------------------
// TarVector
//------------------------------------------------------------------------------

template<class T>
class TarVector : public vector<T> {                        
    public: 
        // Default ctor
        TarVector() {};  
        virtual ~TarVector() {};  
        // GetItem        
        bool GetItem(size_t Index, T& Item)  
        {  
            try
            {
                Item = at(Index);
                return true;
            }
            catch (out_of_range &e)
            {
                cerr << "Exception: " << e.what() << ", index: " << Index << endl;
                return false;
            }
        };
        
        // Delete 
        void DeleteItem(size_t Index)
        {
            try
            {
                T* iter = begin() + Index;
                erase(iter);
            }
            catch (out_of_range &e)
            {
                cerr << "Exception: " << e.what() << ", index: " << Index << endl;
            }               
        }            
};

U hvala za komentar, moram rect da takih stvari u knjigah bolj malo piše....
Drugače pa v sluzbi programiramo v Delphiju...