C++ - typedef "inside" arguments de modèle?

Question

Imaginez que j'ai une fonction de modèle comme celui-ci:

template<typename Iterator> 
void myfunc(Iterator a, typename Iterator::value_type b) 
{ ... } 

est-il un moyen de mettre en œuvre la même chose en déclarer un typedef pour Iterator :: valuetype que je peux utiliser dans la signature de la fonction? Par exemple, je préfère être en mesure de faire quelque chose comme ceci:

template< 
    typename Iterator, 
    typedef Iterator::value_type type> 
void myfunc(Iterator a, type b) 
{ ... } 

Jusqu'à présent, j'ai eu recours à l'aide d'arguments de modèle par défaut et Boost concept de vérification pour assurer la valeur par défaut est toujours utilisé:

template< 
    typename Iterator, 
    typename type = typename Iterator::value_type > 
void myfunc(Iterator a, type b) 
{ 
    BOOST_STATIC_ASSERT((
     boost::is_same< 
      typename Iterator::value_type, 
      type 
     >::value 
    )); 
    ... 
} 

... mais ce serait bien s'il y avait un support dans la langue pour ce genre de chose.

Modifier

Je devrais probablement avoir utilisé une classe au lieu d'une fonction, étant donné que les arguments par défaut ne sont pas standard pour les fonctions.

template< 
    typename T, 
    typename V = typename T::value_type> 
class A : public B<T, V> 
{ 
    BOOST_STATIC_ASSERT((boost::is_same<typename T::value_Type, V>::type)); 
}; 

Answer 1

Vous cherchez un typedef à utiliser basé sur un modèle dans une définition de fonction basé sur un modèle. Je ne pense pas que vous pouvez faire ...

Vous pouvez avoir une classe avec une fonction basé sur un modèle statique & de typedefs ... Mais son utilisation devient laid:

template<typename Iterator> 
class arbitraryname 
{ 
public: 
    typedef typename Iterator::value_type value; 

    static void myfunc(Iterator a, value b) 
    { 
    value c = b; 
    cout << "Test" << c << endl;  
    } 
}; 

struct Foo 
{ 
    typedef int value_type; 
}; 

int main() 
{ 
    Foo f; 
    myfunc<Foo>(f,2); // Old way. 
    arbitraryname<Foo>::myfunc(f,3); // With templated class. 
} 

Personnellement, dans ce cas, Je vais avec un #define ...

#define VALUE_TYPE typename Iterator::value_type 
template<typename Iterator> 
void myfunc(Iterator a, VALUE_TYPE b) 
#undef VALUE_TYPE 
{ 
    typedef typename Iterator::value_type bar; 
    bar z = b; 
    cout << "Test" << z << endl; 
} 

Bien sûr #define « s sont laids et pécheurs. Mais le code est douloureusement obtus à lire ...

p.s. Pour être sûr, vous pouvez ajouter:

#ifdef VALUE_TYPE 
#error "VALUE_TYPE already defined!" 
#endif 

Answer 2

Vous pouvez utiliser typename dans la liste des paramètres:

template <typename Iterator> 
void myfunc(Iterator a, typename Iterator::value_type b) 
{ 
}