DRY up-Code, der nur in const unterscheidet

Question

Gibt es eine Möglichkeit, dies (ohne Makros) zu trocknen?

void clear_tp_vec(vector<const Tk*>& tps){ 
    for(auto it=tps.begin();it!=tps.end();++it){ 
     const ValT* vp=dynamic_cast<const ValT*>(*it); 
     if(vp!=NULL) 
      delete vp; 
    } 
    tps.clear(); 
}; 

void clear_tp_vec(vector<Tk*>& tps){ 
    for(auto it=tps.begin();it!=tps.end();++it){ 
     ValT* vp=dynamic_cast<ValT*>(*it); 
     if(vp!=NULL) 
      delete vp; 
    } 
    tps.clear(); 
}; 

Das einzige, was die zweite Überlast in sich unterscheidet, ist die const Qualifier (das Fehlen davon). Das Auskommentieren einer der beiden Versionen unterbricht meinen Code.

Answer 1

Kommentare (@ Cup „es eine Vorlage machen“, @ user1764961 der NULL-Test „des loswerden“) haben dazu geführt, Ich auf die folgende, sehr offensichtliche, modifizierte Version:

template<typename T> 
void clear_tp_vec(vector<T>& tps) { 
     for(auto it=tps.begin(); it!=tps.end(); ++it) 
      delete dynamic_cast<const ValT*>(*it); 
     tps.clear(); 
} 

Answer 2

Sie können folgende Template-Funktion verwenden:

template < typename T > 
void clear_tp_vec(vector< T* >& tps) 
{ 
    typedef typename conditional< is_const<T>::value, const ValT, ValT >::type OUT; 
    for (auto it = tps.begin(); it != tps.end(); ++it) 
    { 
     OUT* vp = dynamic_cast< OUT* >(*it); 
     if (vp != NULL) 
      delete vp; 
    } 
    tps.clear(); 
}; 

Answer 3

können Sie auf NULL-Werte löschen rufen so Test nicht benötigt wird. Auch sollten Sie Standard-Algorithmen für Iteratoren verwenden, nicht selbst iterieren.

Sie können Boost.Lambda verwenden, um etwas sehr allgemein hier mit Platzhalter schreiben:

#include <boost/lambda/bind.hpp> 
#include <boost/lambda/lambda.hpp> 
... 
using namespace boost::lambda; 
std::for_each(tps.begin(), tps.end(), bind(std::ptr_fun(operator delete), *_1));