La spécification d'un type pour tous les arguments passés à variadic fonction ou variadic template fonction w/out à l'aide du tableau, vecteur, les structures, etc?

Je crée une fonction (éventuellement en fonction de membre de, pas que c'est important... peut-être que c'est?) qui doit accepter un nombre indéterminé d'arguments, mais je veux tous à être le même type. Je sais que je pourrais passer dans une matrice ou un vecteur, mais je veux être en mesure d'accepter la liste des arguments directement, sans structure supplémentaire ou même entre parenthèses supplémentaires. Il ne ressemble pas à variadic fonctions par eux-mêmes sont typesafe, et je ne savais pas vraiment comment aller à ce sujet w/variadic template fonctions. Voici en gros ce que je vise (plus que probablement pas le code est correct, et totalement non dans le but d'obtenir des listes de dragons, lol):

//typedef for dragon_list_t up here somewhere.

enum Maiden {
    Eunice
    , Beatrice
    , Una_Brow
    , Helga
    , Aida
};

dragon_list_t make_dragon_list(Maiden...) {
    //here be dragons
}

template<Maiden... Maidens> dragon_list_t make_dragon_list(Maidens...) {
    //here be dragons
}

UTILISATION

dragon_list_t dragons_to_slay
    = make_dragon_list(Maiden.Eunice, Maiden.Helga, Maiden.Aida)
;

Essayé quelques choses de similaire à la déjà au-dessus, pas de dés. Des Suggestions? Évident oublis, j'ai peut être fait? Je sais que cela peut ne pas être une affaire énorme pour ce faire à la place:

dragon_list_t make_dragon_list(std::array<Maiden> maidens) {
    //here be dragons.
}
dragon_list_t dragons_to_slay
    = make_dragon_list({Maiden.Eunice, Maiden.Helga, Maiden.Aida})
;

mais je préfère être en mesure de faire la première manière, si possible.

InformationsquelleAutor Brett Rossier | 2010-09-13

c++c++11 parameters templates variadic-functions

30

Que vous pouvez accepter les arguments avancés par les variadic template et laissez-le typage vérifier la validité plus tard, lorsqu'ils sont convertis.

Vous pouvez vérifier la convertibilité sur la fonction de l'interface de niveau, mais de rendre l'utilisation de la résolution de surcharge pour les rejeter d'emblée mauvais arguments par exemple, en utilisant SFINAE
```
template<typename R, typename...> struct fst { typedef R type; };

template<typename ...Args>
typename fst<void, 
  typename enable_if<
    is_convertible<Args, ToType>::value
  >::type...
>::type 
f(Args...);
```
Pour votre cas d'utilisation si vous connaissez les étapes pour passer d'un std::array<> à votre dragon_list_t, alors vous avez déjà résolu bien que, selon la première option ci-dessus ("convertir plus tard"):
```
template<typename ...Items>
dragon_list_t make_dragon_list(Items... maidens) {
    std::array<Maiden, sizeof...(Items)> arr = {{ maidens ... }};
    //here be dragons
}
```
Si vous combinez cela avec le ci-dessus is_convertible approche que vous avez un rejet précoce modèle qui fait aussi de la résolution de surcharge sur les arguments et les rejette si non applicable.
- +1 pour donner OP exactement ce qu'il a demandé, même si c'est pour le meilleur ou pour le pire
- Je n'ai pas joué avec les variadic templates assez pour savoir si le début de l'convertibles est de mise, mais +1 std::array conversion, n'est-ce pas pensé à ça.
- Hmm, je pense que le rejeter-début du modèle n'est pas bon pour le cas général. Si le Dragon est une classe de base, alors votre premier argument (ou à tous vos arguments), peut-être une classe dérivée, et donc non convertibles les unes des autres. Lorsque le dragon est un enum, il pourrait être la même chose si votre première classe est convertible de type entier, mais pas un type entier lui-même. Je pense que s'appuyant sur la surcharge est plus extensible.
- le rejeter-début du modèle ne vérifie que la convertibilité des arguments à ToType (Dragon), pas des arguments les uns des autres. Donc D1->B est vérifiée et D2->B aussi, mais D1->D2 n'est pas cochée.
- Ah, raté. la droite.
- Par curiosité, si la conversion de dernière option, ont été mis en œuvre dans une bibliothèque qu'un autre dev a l'aide, ce genre d'erreur seraient-ils voir si ils n'avaient pas la mise en œuvre de make_dragon_list, juste un en-tête, et ils ont nourri les mauvais types? Ne serait-ce pas même être une préoccupation valable, ou serait-ce une raison de favoriser le rejeter-début de l'option?
- je n'ai aucune idée. Cela dépend vraiment de la très de code dans le modèle. Mais il ne sera pas agréable je pense
InformationsquelleAutor Johannes Schaub - litb
12

Si vous n'utilisez pas template sur le paramètre qui n'est pas dans le pack de la variadic fonction permettra de résoudre à avoir tous les arguments du même type.

Voici un exemple pour une longue max fonction qui n'accepte ints (ou types convertibles int).
```
int maximum(int n) //last argument must be an `int`
{
    return n;
}

template<typename... Args>
int maximum(int n, Args... args) //first argument must be an int
{
    return std::max(n, maximum(args...));
}
```
Explication: Lorsque vous déballez l'argument pack (args...) le compilateur recherche pour le meilleur de la surcharge. Si le pack a qu'un seul paramètre, alors le meilleur candidat est maximum(int) de sorte que le seul paramètre doit être de type int (ou convertibles à int). Si il y a plusieurs éléments dans le pack alors le seul candidat est maximum(int, typename...) donc le premier argument doit être de type int (ou convertibles à int). Il est simple de prouver par induction que tous les types dans le pack doit être d'un type convertible int).
- Intéressant... ne peux pas dire que je comprends pourquoi cela fonctionne, des infos/liens sur qui?
InformationsquelleAutor Motti
11

Depuis que vous avez inclus le C++0x balise, la réponse la plus évidente serait de rechercher initialiseur de listes. Un initialiseur liste vous permet de spécifier un certain nombre d'arguments de la ctor qui sera automatiquement convertie en une seule structure de données pour le traitement par le ctor.

Leur principal (exclusif?) l'utilisation est exactement le genre de situation que vous avez mentionné, en passant, un certain nombre d'arguments du même type à utiliser dans la création d'une sorte de liste/tableau/la collecte des autres objets. Il va être pris en charge par (pour un exemple) std::vector, de sorte que vous pouvez utiliser quelque chose comme:
```
std::vector<dragon> dragons_to_slay{Eunice, Helga, Aida};
```
de créer un vecteur de trois dragon objets. La plupart (tous?) de l'autre, les collections comprennent la même chose, donc si vous avez vraiment insister sur une liste de dragons vous devriez être en mesure d'obtenir ce assez facilement ainsi.
- N'ai même pas pensé à regarder à l'initialisation des listes, merci pour la suggestion. Toujours à mâcher sur toutes ces réponses :\
InformationsquelleAutor Jerry Coffin

J'ai récemment eu besoin de contraindre un paramètre pack à un seul type, ou au moins convertibles à ce type. J'ai fini par trouver une autre façon:

#include <type_traits>
#include <string>

template <template<typename> class Trait, typename Head, typename ...Tail> 
struct check_all {
  enum { value = Trait<Head>::value && check_all<Trait, Tail...>::value };
};

template <template<typename> class Trait, typename Head>
struct check_all<Trait, Head> {
  enum { value = Trait<Head>::value };
};

template <typename ...Args> 
struct foo {
  //Using C++11 template alias as compile time std::bind
  template <typename T>
  using Requirement = std::is_convertible<double, T>;
  static_assert(check_all<Requirement, Args...>::value, "Must convert to double");
};

int main() {
  foo<int, char, float, double>();
  foo<int, std::string>(); //Errors, no conversion
}

La chose que j'ai aimé à propos de cette solution est que je peux appliquer check_all à d'autres traits trop.

InformationsquelleAutor Flexo

2

Bien que la question est étiqueté C++11, je pense que C++17 + des concepts de solution serait intéressant d'ajouter, vu qu'il est désormais en charge du CCAG, et d'autres vont bientôt suivre.

d'abord définir un concept simple
```
class mytype{};

template<typename T>
concept bool MyType = std::is_same<T, mytype>::value;
```
puis il suffit d'utiliser variadic template parameters
```
template<MyType ... Args>
void func(Args &&... args){
    //do something here
}
```
Beaucoup plus facile avec l'avènement des concepts!
- Des Concepts qui ont fait en C++2a (pour l'instant) de ne pas inclure cette. Voir ici.
InformationsquelleAutor CoffeeandCode
1

Ça dépend vraiment de ce que vous essayez de mettre en œuvre, exactement.

Généralement enum indique exécution des sous-types d'une classe particulière, ou une victime de l'union (boost::variant). Mais dans ce cas, vous souhaitez passer la enum directement. En outre, vous disposez d'un ensemble limité de valeurs possibles, et chaque appel de fonction, forme un sous-ensemble. Vraiment ce que vous représentez, c'est un sous-ensemble, et non pas plusieurs paramètres à tous.

Le meilleur moyen de représenter un sous-ensemble d'un ensemble fini est un bitset. De grands ensembles devraient utiliser std::bitset; petits jeux pouvez simplement utiliser unsigned long.
```
enum Maiden_set {
    Eunice = 1,
    , Beatrice = 2
    , Una_Brow = 4
    , Helga = 8
    , Aida = 16
};

dragon_list_t make_dragon_list(Maiden_set) {
    //here be dragons
}

make_dragon_list( Eunice + Beatrice + Helga );
```
ou, puisque vous avez l'air de vouloir gérer les variations au moment de la compilation,
```
template< int Maidens > //parameter is not a Maiden_set because enum+enum=int
dragon_list_t make_dragon_list() {
    //here be dragons
}

make_dragon_list< Eunice + Beatrice + Helga >(); //+ promotes each enum to int
```
Il devrait être possible de générer des puissances de 2 automatiquement à l'aide d'un operator+ surchargé sur le enum type. Mais je ne suis pas sûr que je suis sur la bonne voie.
- Vous pouvez au moment de la compilation bitshift, qui est, enum { first_value = 1, second_value = 1 << 1, third_value = 1 << 2 };
- J'aimerais écrire de cette façon, mais vous seriez surpris de voir comment beaucoup de lecteurs n'ont jamais vu que l'opérateur avant.
- J'ai, mais par curiosité, y aurait-il des préoccupations au sujet de bit-boutisme? Je sais que c'est probablement obscur. Je ne sais pas ce Cpu qui serait un problème, et ce n'est pas comme je suis en train de construire quelque chose qui est 100% croix-plate-forme ou quoi que ce soit. Juste curieux.
- Eh bien, puisque vous n'avez pas de soins qui bit est défini, seulement que chaque indicateur correspond à un bit, alors il n'y a pas de raison que l'endianness ou de portabilité doit casser le code. Tant que vous n'essayez pas de régler plus de bits que exister dans le type de dossier, vous êtes fine.
- Non, un bitset encodage est juste un nombre comme les autres, donc (Eunice+Beatrice+Helga) = 1+2+8 = 11 n'est pas plus endianness sensible que de simplement écrire le numéro 11.
InformationsquelleAutor Potatoswatter
1

Je voudrais essayer de garder les choses simples, et la solution la plus simple je pense est de simplement en utilisant un simple vieux vecteur. À l'aide de C++0x fonctionnalités que vous pouvez obtenir une syntaxe qui est semblable (même si pas exactement) ce que vous voulez:
```
void foo( std::vector<int> const & v ) {
   std::copy( v.begin(), v.end(), std::ostream_iterator<int>(std::cout, " ") );
}
int main() {
  foo({ 1, 2, 3, 4, 5, 6 }); //note the extra {}
}
```
InformationsquelleAutor David Rodríguez - dribeas
1

En bref, vous devriez probablement juste de créer un vecteur. Il n'est pas beaucoup au-dessus, surtout si vous utilisez quelque chose comme boost::list_of ou C++0x l'initialiseur de liste. La sémantique des frais généraux est minime, et il est plus souple (vous pouvez passer de la liste avec un nombre d'arguments connue qu'à l'exécution).

Si tu le voulais vraiment, vous pouvez utiliser variadic template parameters pour ce faire:
```
//Using pass-by-value since I'm assuming it is primitive:

template< typename T, typename... Args>
void make_dragon_list_internal( dragon_list_t* dragon_list, T t, Args... args )
{
   //add T to dragon_list.
   make_dragon_list_internal( dragon_list, args... );
}

void make_dragon_list_internal( dragon_list_t* dragon_list )
{
   //Finalize dragon_list.
}

template<typename... Args>
dragon_list_t make_dragon_list( Args... args )
{
  dragon_list_t dragon_list;
  make_dragon_list_internal( &dragon_list, args... );
  return dragon_list;
}
```
C'est typesafe, et extensible (vous pouvez faire ce prendre d'autres choses que de dragons, si vous en avez envie).
- L'erreur, et par typesafe, je veux dire, comme typesafe que le type sous-jacent, qui, pour un non-classe enum n'est pas très grande.
InformationsquelleAutor Todd Gardner

Je pense que le code suivant est utile pour votre cas:

template <class...>
struct IsAllSame {};

template <class T, class B1>
struct IsAllSame<T, B1> {
  static constexpr const bool kValue = std::is_same<T, B1>::value;
};

template <class T, class B1, class... Bn>
struct IsAllSame<T, B1, Bn...> {
  static constexpr const bool kValue =
      IsAllSame<T, B1>::kValue ? IsAllSame<T, Bn...>::kValue : false;
};

IsAllSame<int>::kValue == true
IsAllSame<bool, int>::kValue == false
IsAllSame<bool, int, int>::kValue == false

InformationsquelleAutor Nan Hua

0

Une proposition récente, Homogène variadic fonctions, les adresses en faisant quelque chose comme votre première construction juridique. Sauf, bien sûr, utiliser le paramètre pack vous permettra d'avoir un nom. Aussi la syntaxe exacte n'a pas l'air très encore en béton.

Donc, en vertu de la proposition, ce sera effectivement juridique (vous pouvez voir une semblable construction dans le paragraphe "Le modèle d'introduction" dans le document):
```
dragon_list_t make_dragon_list(Maiden... maidens) {
    //here be dragons
}
```
InformationsquelleAutor Jan Hošek

Vous devez vous connecter pour publier un commentaire.