używanie deklaracji w szablonie wariacyjnym
To pytanie jest inspirowane następującym rozwiązaniem do wielokrotnego dziedziczenia przeciążania pseudo-dwuznaczności, co jest miłym sposobem na zaimplementowanie odwiedzających lambda dla boost:: variant zgodnie z propozycją w ta odpowiedź :
Chcę zrobić coś takiego:
template <typename ReturnType, typename... Lambdas>
struct lambda_visitor : public boost::static_visitor<ReturnType>, public Lambdas... {
using Lambdas...::operator(); //<--- doesn't seem to work
lambda_visitor(Lambdas... lambdas) : boost::static_visitor<ReturnType>() , Lambdas(lambdas)... { }
};
Nie jestem pewien, jaka byłaby właściwa składnia dodawania klauzul dla list typu spakowanego. Klauzula using
jest kluczowa, aby powstrzymać kompilator przed narzekaniem, że {[2] } są niejednoznaczne, które zupełnie nie są, ponieważ mają różne podpisy.
2 answers
Ok znalazłem całkiem przyzwoite rozwiązanie:
W zasadzie muszę rozpakować jeden dodatkowy przypadek lambda i zastosować klauzulę using
do rozpakowanej lambda i reszty, ale w tym przypadku, ponieważ najwyraźniej nie mogę zrobić zmiennej listy używających deklaracji (przynajmniej nie znam składni, jeśli jest to możliwe), reszta jest owinięta dziedziczeniem z przypadku 'rest', tak jak to:
template <typename ReturnType, typename... Lambdas>
struct lambda_visitor;
template <typename ReturnType, typename Lambda1, typename... Lambdas>
struct lambda_visitor< ReturnType, Lambda1 , Lambdas...>
: public lambda_visitor<ReturnType, Lambdas...>, public Lambda1 {
using Lambda1::operator();
using lambda_visitor< ReturnType , Lambdas...>::operator();
lambda_visitor(Lambda1 l1, Lambdas... lambdas)
: Lambda1(l1), lambda_visitor< ReturnType , Lambdas...> (lambdas...)
{}
};
template <typename ReturnType, typename Lambda1>
struct lambda_visitor<ReturnType, Lambda1>
: public boost::static_visitor<ReturnType>, public Lambda1 {
using Lambda1::operator();
lambda_visitor(Lambda1 l1)
: boost::static_visitor<ReturnType>(), Lambda1(l1)
{}
};
template <typename ReturnType>
struct lambda_visitor<ReturnType>
: public boost::static_visitor<ReturnType> {
lambda_visitor() : boost::static_visitor<ReturnType>() {}
};
Więc mogę to zrobić indukcyjnie, umieszczając dwie deklaracje, jedną z rozpakowanego typu lambda i kolejny z klasy rodzica, który jest w rzeczywistości tą samą klasą z jedną lambdą mniej.
Warning: date(): Invalid date.timezone value 'Europe/Kyiv', we selected the timezone 'UTC' for now. in /var/www/agent_stack/data/www/doraprojects.net/template/agent.layouts/content.php on line 54
2012-02-02 17:27:09
To stare pytanie i świetna odpowiedź. Jest jeszcze jedna rzecz, którą możemy zrobić, aby ją poprawić IMHO.
W c++14 i lepszych nie musimy określać typu return-można to wydedukować.
#include <boost/variant.hpp>
#include <type_traits>
namespace detail {
template<typename... Lambdas>
struct lambda_visitor;
template<typename Lambda1, typename... Lambdas>
struct lambda_visitor<Lambda1, Lambdas...>
: public lambda_visitor<Lambdas...>,
public Lambda1
{
using Lambda1::operator ();
using lambda_visitor<Lambdas...>::operator ();
lambda_visitor(Lambda1 l1, Lambdas... lambdas)
: Lambda1(l1)
, lambda_visitor<Lambdas...>(lambdas...) {}
};
template<typename Lambda1>
struct lambda_visitor<Lambda1>
:
public Lambda1
{
using Lambda1::operator ();
lambda_visitor(Lambda1 l1)
: Lambda1(l1) {}
};
}
template<class...Fs>
auto compose(Fs&& ...fs)
{
using visitor_type = detail::lambda_visitor<std::decay_t<Fs>...>;
return visitor_type(std::forward<Fs>(fs)...);
};
Przypadek użycia:
boost::variant<int, std::string> x = "foo", y = 4;
auto visitor = compose([](const int& i)
{
std::cout << i << std::endl;
},
[](const std::string& s)
{
std::cout << s << std::endl;
});
boost::apply_visitor(visitor, x);
boost::apply_visitor(visitor, y);
Warning: date(): Invalid date.timezone value 'Europe/Kyiv', we selected the timezone 'UTC' for now. in /var/www/agent_stack/data/www/doraprojects.net/template/agent.layouts/content.php on line 54
2017-09-04 10:21:02