Itération sur différents types

Question

Étant donné le code suivant :

struct Window{
    void show();
    //stuff
}w1, w2, w3;

struct Widget{
    void show();
    //stuff
}w4, w5, w6;

struct Toolbar{
    void show();
    //stuff
}t1, t2, t3;

Je veux show un tas d'articles :

for (auto &obj : {w3, w4, w5, t1})
    obj.show();

Cependant, cela ne compile pas, car le std::initializer_list<T> dans le for -La boucle ne peut pas déduire T et en fait, il n'y a pas vraiment de T qui conviendrait. Je ne veux pas créer un type d'effacement en raison de la quantité de code nécessaire et de la surcharge inutile du temps d'exécution. Comment puis-je écrire correctement ma boucle pour que le type de obj est déduit pour chaque élément de la liste conceptuelle séparément ?

Answer 1

En C++17 ou mieux, vous utiliserez expressions pliées pour "parcourir" vos arguments hétérogènes en appliquant la fonction membre :

auto Printer = [](auto&&... args) {
    (args.show(), ...);
};

Printer(w1, w2, w3, w4, w5, w6, t1, t2, t3);

Démo

Vous pouvez lire plus sur ce sujet dans mon blog

Answer 2

Boost::fusion est génial mais oldskool - il répond aux déficiences de c++03.

L'expansion variadique des modèles de c++11 à la rescousse !

#include <iostream>

struct Window{
    void show() {
        std::cout << "Window\n";
    }
    //stuff
}w1, w2, w3;

struct Widget{
    void show() {
        std::cout << "Widget\n";
    }
    //stuff
}w4, w5, w6;

struct Toolbar{
    void show()
    {
        std::cout << "Toolbar\n";
    }
    //stuff
}t1, t2, t3;

template<class...Objects>
void call_show(Objects&&...objects)
{
    using expand = int[];
    (void) expand { 0, ((void)objects.show(), 0)... };
}

auto main() -> int
{
    call_show(w3, w4, w5, t1);
    return 0;
}

résultat attendu :

Window
Widget
Widget
Toolbar

un autre moyen, plus générique (nécessite c++14) :

// note that i have avoided a function names that look like
// one in the standard library.

template<class Functor, class...Objects>
void for_all(Functor&& f, Objects&&... objects)
{
    using expand = int[];
    (void) expand { 0, (f(std::forward<Objects>(objects)), 0)... };

}

appelé comme ça :

for_all([](auto& thing) { thing.show(); }, w3, w4, w5, t1);

Answer 3

Une autre option consiste à utiliser boost::tuple ou std::tuple et boost::fusion::for_each algorithme :

#include <boost/fusion/algorithm/iteration/for_each.hpp>
#include <boost/fusion/adapted/boost_tuple.hpp>

boost::fusion::for_each(
    boost::tie(w1, w2, w3, w4, w5, w6, t1, t2, t3), // by reference, not a copy
    [](auto&& t) { t.show(); } 
    );

---

Juste par curiosité, j'ai comparé le résultat de l'assemblage généré par la méthode de Richard Hodges avec la méthode ci-dessus. Avec gcc-4.9.2 -Wall -Wextra -std=gnu++14 -O3 -march=native le code d'assemblage produit est identique.

Answer 4

Sur la base de https://stackoverflow.com/a/6894436/3484570 cela fonctionne sans créer une fonction supplémentaire, un boost ou un héritage.

En-tête :

#include <tuple>
#include <utility> 

template<std::size_t I = 0, typename FuncT, typename... Tp>
inline typename std::enable_if<I == sizeof...(Tp), void>::type
  for_each(const std::tuple<Tp...> &, FuncT) // Unused arguments are given no names.
  { }

template<std::size_t I = 0, typename FuncT, typename... Tp>
inline typename std::enable_if<I < sizeof...(Tp), void>::type
  for_each(const std::tuple<Tp...>& t, FuncT f)
  {
    f(std::get<I>(t));
    for_each<I + 1, FuncT, Tp...>(t, f);
  }

template<std::size_t I = 0, typename FuncT, typename... Tp>
inline typename std::enable_if<I == sizeof...(Tp), void>::type
  for_each(std::tuple<Tp...> &&, FuncT) // Unused arguments are given no names.
  { }

template<std::size_t I = 0, typename FuncT, typename... Tp>
inline typename std::enable_if<I < sizeof...(Tp), void>::type
  for_each(std::tuple<Tp...>&& t, FuncT f)
  {
    f(std::get<I>(t));
    for_each<I + 1, FuncT, Tp...>(std::move(t), f);
  }

.cpp :

struct Window{
    void show(){}
    //stuff
}w1, w2, w3;

struct Widget{
    void show(){}
    //stuff
}w4, w5, w6;

struct Toolbar{
    void show(){}
    //stuff
}t1, t2, t3;

int main() {
    for_each(std::tie(w3, w4, w5, t1), [](auto &obj){
        obj.show();
    });
}

Answer 5

Window , Widget et Toolbar partagent une interface commune, de sorte que vous pouvez créer une classe abstraite et faire en sorte que d'autres classes en héritent :

struct Showable {
    virtual void show() = 0; // abstract method
};

struct Window: Showable{
    void show();
    //stuff
}w1, w2, w3;

struct Widget: Showable{
    void show();
    //stuff
}w4, w5, w6;

struct Toolbar: Showable{
    void show();
    //stuff
}t1, t2, t3;

Ensuite, vous pouvez créer un tableau de pointeurs vers Showable et itérer sur celui-ci :

int main() {
    Showable *items[] = {&w3, &w4, &w5, &t1};
    for (auto &obj : items)
        obj->show();
}

Voir le fonctionnement en ligne