Перебор различных типов

Question

Учитывая следующий код:

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

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

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

Я хочу show кучу вещей:

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

Однако это не компилируется, так как std::initializer_list<T> в for -loop не может вывести T и на самом деле нет действительно T, который подойдет. Я не хочу создавать тип стирания типа из-за количества требуемого кода и ненужных служебных данных во время выполнения. Как правильно написать мой цикл, чтобы тип obj был выведен для каждого элемента в концептуальном списке отдельно?

Answer 1

boost :: fusion is awesome, но oldskool - он удовлетворяет недостатки C++ 03.

C++ расширенное расширение шаблона 11 + на помощь!

#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; 
} 

ожидается выход:

Window 
Widget 
Widget 
Toolbar 

другой, более общий способ (требуется 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)... }; 

} 

называется так:

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

Answer 2

основе https://stackoverflow.com/a/6894436/3484570 это работает без создания дополнительная функция, усиление или наследование.

Заголовок:

#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 3

Другой вариант заключается в использовании boost::tuple или std::tuple и boost::fusion::for_each алгоритм:

#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(); } 
    ); 

---

Просто из с uriosity, сравнил сгенерированную сборку выхода метода Ричарда Ходжеса с вышеизложенным. С gcc-4.9.2 -Wall -Wextra -std=gnu++14 -O3 -march=native произведенный код сборки идентичен.

Answer 4

В современном C++ вы бы использовать кратные выражения, чтобы «пройти через» ваши разнородные аргументы применения функции члена:

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

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

Demo

Вы можете прочитать подробнее об этом в моей blog

Answer 5

Я рекомендую Boost.Hana, который ИМХО является лучшей и наиболее гибкой библиотекой метапрограмм.

#include <boost/hana/ext/std/tuple.hpp> 
#include <boost/hana.hpp> 

namespace hana = boost::hana; 

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

Answer 6

Window, Widget и Toolbar доля общий интерфейс, так что вы можете создать абстрактный класс и сделать другие классы наследуют от него:

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; 

Затем вы можете создать массив указателей на Showable и итерация над ним:

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

See it working online

Answer 7

Думаю, boost::variant стоит упомянуть. Тем более у него есть шансы стать std::variant в C++ 17.

int main() 
{ 
    std::vector<boost::variant<Window*, Widget*, Toolbar*>> items = { &w1, &w4, &t1 }; 

    for (const auto& item : items) 
    { 
    boost::apply_visitor([](auto* v) { v->show(); }, item); 
    } 
    return 0; 
} 

Answer 8

Поздний ответ, но вот общее решение с C++ 14, который работает как boost::fusion::for_each но не требует подталкивание:

#include <tuple> 

namespace detail { 
template<typename Tuple, typename Function, std::size_t... Is> 
void tuple_for_each_impl(Tuple&& tup, Function&& fn, std::index_sequence<Is...>) { 
    using dummy = int[]; 
    static_cast<void>(dummy { 
     0, (static_cast<void>(fn(std::get<Is>(std::forward<Tuple>(tup)))), 0)... 
    }); 
} 
} 

template<typename Function, typename... Args> 
void tuple_for_each(std::tuple<Args...>&& tup, Function&& fn) { 
    detail::tuple_for_each_impl(std::forward<std::tuple<Args...>>(tup), 
      std::forward<Function>(fn), std::index_sequence_for<Args...>{}); 
} 

int main() { 
    tuple_for_each(std::tie(w1, w2, w3, w4, w5, w6, t1, t2, t3), [](auto&& arg) { 
     arg.show(); 
    }); 
} 

Если вы хотите добиться более или менее То же самое без std::tuple, вы можете создать одну функцию вариант кода выше:

#include <utility> 

template<typename Function, typename... Args> 
void va_for_each(Function&& fn, Args&&... args) { 
    using dummy = int[]; 
    static_cast<void>(dummy { 
     0, (static_cast<void>(fn(std::forward<Args>(args))), 0)... 
    }); 
} 

int main() { 
    auto action = [](auto&& arg) { arg.show(); }; 
    va_for_each(action, w1, w2, w3, w4, w5, w6, t1, t2, t3); 
} 

Недостатком т второй пример заключается в том, что для этого сначала необходимо указать функцию обработки, поэтому не имеет такого же вида, как хорошо известный std::for_each. В любом случае с моим компилятором (GCC 5.4.0) с использованием уровня оптимизации -O2, они производят те же assembly output.