Comment utiliser std :: transformer avec des templates

Question

J'ai du mal à trouver pourquoi je ne peux pas transformer pour travailler avec un template template.

Voici une version simplifiée de la classe de modèle:

template<typename T> 
class base 
{ 
public : 
    base() : all_() {} 
    ~base() {} 
public: 
    bool add(T t) 
    { 
    typename vector<T>::iterator itr 
     = lower_bound(all_.begin(), all_.end(), t); 
    if (itr == all_.end() || *itr != t) 
     { 
     all_.push_back(t); 
     cout << "ok" << endl; 
     return true; 
     } 
    cout << "failed" << endl; 
    return false; 
    } 
    static bool addTo(base<T> *c, T t) 
    { 
    return c->add(t); 
    } 
private : 
    vector<T> all_; 
}; 

Et c'est là que je suis en train d'utiliser transformer pour capturer toute la sortie bool de la fonction de membre d'ajouter:

main() 
{ 
    base<int> test; 
    vector<bool> results; 
    vector<int> toAdd; 
    toAdd.push_back(10); 
    toAdd.push_back(11); 
    toAdd.push_back(10); 
    transform(toAdd.begin(), toAdd.end(), 
      back_inserter(results), 
      bind1st((bool(*)(base<int>*,int))base<int>::addTo, &test)); 
} 

Le Le but est d'insérer chaque membre du conteneur toAdd en utilisant base :: add ou base :: addTo, et de capturer les résultats bool dans les résultats vectoriels

Answer 1

Essayez:

transform(toAdd.begin(), toAdd.end(), 
     back_inserter(results), 
     bind1st(mem_fun(&base<int>::add), &test)); 

Le problème est pas le modèle, il est que bind1st repose sur un soutien supplémentaire au travail (voir http://www.sgi.com/tech/stl/AdaptableBinaryFunction.html). AFAIK il ne peut jamais fonctionner sur de simples pointeurs de fonction.

boost::bind peut faire plus de choses, si vous voulez apporter que pour cette situation, vous n'avez pas besoin, cependant. mem_fun tourne une fonction membre non statique en une fonction binaire adaptable. addTo n'est donc pas non plus nécessaire, mais si vous avez besoin d'utiliser une fonction membre statique dans une situation similaire, alors il y a ptr_fun.

Answer 2

Ajouter ce qui suit à votre classe de base:

typedef base<T>* first_argument_type; 
typedef T second_argument_type; 
typedef bool result_type; 

bool operator() (base<T> *c, T t) const { 
    return c->add(t); 
} 

et le changement de transform:

transform(toAdd.begin(), toAdd.end(), 
      back_inserter(results), bind1st(base<int>(), &test));