Kann ich max (A, max (B, max (C, D))) mithilfe von Fold-Ausdrücken implementieren?
Beim Versuch, mit C++ 17-Falzausdrücken herumzuspielen, habe ich versucht, max sizeof zu implementieren, wobei das Ergebnis maximal der sizeof der Typen ist . Ich habe eine hässliche Falzversion, die Variable und ein Lambda verwendet, aber ich kann nicht Stellen Sie sich eine Möglichkeit vor, Faltenausdrücke und std::max() zu verwenden, um dasselbe Ergebnis zu erhalten.
Dies ist meine Faltversion:
template<typename... T>
constexpr size_t max_sizeof(){
size_t max=0;
auto update_max = [&max](const size_t& size) {if (max<size) max=size; };
(update_max(sizeof (T)), ...);
return max;
}
static_assert(max_sizeof<int, char, double, short>() == 8);
static_assert(max_sizeof<char, float>() == sizeof(float));
static_assert(max_sizeof<int, char>() == 4);
Ich möchte eine äquivalente Funktion schreiben, indem ich fold-Ausdrücke und std::max()..__ benutze. Zum Beispiel für 3 Elemente sollte es erweitert werden
return std::max(sizeof (A), std::max(sizeof(B), sizeof (C)));
Kann man das machen?
Wahrscheinlich nicht das, was Sie hören wollten, aber nein. Das ist nicht möglich (rein1) mit Falzausdrücken. Ihre Grammatik erlaubt es einfach nicht:
Ein Fold-Ausdruck führt eine Faltung eines Vorlagenparameterpakets über einem .__ aus. binärer Operator.
fold-expression: ( cast-expression fold-operator ... ) ( ... fold-operator cast-expression ) ( cast-expression fold-operator ... fold-operator cast-expression ) fold-operator: one of + - * / % ^ & | << >> += -= *= /= %= ^= &= |= <<= >>= = == != < > <= >= && || , .* ->*
Einfach deshalb, weil ein Funktionsaufrufausdruck kein binärer Operator im Sinne der reinen Grammatik ist.
1 Verweisen Sie auf die anderen hervorragenden Antworten .
Wenn Sie hier Fold-Ausdrücke verwenden möchten, müssen Sie statt eines Funktionsaufrufs irgendwie einen Operator zum Aufrufen von std::max Verwenden. Hier ist ein Beispiel, das operator^ Zu diesem Zweck missbraucht:
namespace detail {
template<typename T, std::size_t N = sizeof(T)>
struct type_size : std::integral_constant<std::size_t, N> { };
template<typename T, auto M, typename U, auto N>
constexpr auto operator ^(type_size<T, M>, type_size<U, N>) noexcept {
return type_size<void, std::max(M, N)>{};
}
}
template<typename... T>
constexpr std::size_t max_sizeof() noexcept {
using detail::type_size;
return (type_size<T>{} ^ ... ^ type_size<void, 0>{});
// or, if you don't care to support empty packs
// return (type_size<T>{} ^ ...);
}
BEARBEITEN: @ Barrys Vorschlag, T aus type_size Zu entfernen (hier umbenannt in max_val):
namespace detail {
template<auto N>
struct max_val : std::integral_constant<decltype(N), N> { };
template<auto M, auto N, auto R = std::max(M, N)>
constexpr max_val<R> operator ^(max_val<M>, max_val<N>) noexcept {
return {};
}
}
template<typename... T>
constexpr std::size_t max_sizeof() noexcept {
using detail::max_val;
return (max_val<sizeof(T)>{} ^ ... ^ max_val<std::size_t{}>{});
// or, if you don't care to support empty packs
// return (max_val<sizeof(T)>{} ^ ...);
}
Äußerlich sind beide Implementierungen gleichwertig; In Bezug auf die Umsetzung bevorzuge ich persönlich die erstere, aber YMMV. : -]
Da dies noch niemand als Antwort veröffentlicht hat, ist der einfachste Weg, dies mit minimalem Aufwand zu tun, die Überladung von std::max() , die für dieses Problem vorbereitet ist, zu verwenden: die, die einen initializer_list benötigt:
template<typename... T>
constexpr size_t max_sizeof() {
return std::max({sizeof(T)...});
}
Nur um mit c ++ 17-fach Ausdrücken zu spielen
template <typename ... Ts>
constexpr std::size_t max_sizeof ()
{
std::size_t ret { 0 };
return ( (ret = (sizeof(Ts) > ret ? sizeof(Ts) : ret)), ... );
}
oder mit der Tatsache, dass std::max()constexpr ab C++ 14 ist (also in C++ 17)
template <typename ... Ts>
constexpr std::size_t max_sizeof ()
{
std::size_t ret { 0 };
return ( (ret = std::max(sizeof(Ts), ret)), ... );
}
Nicht wirklich verschieden von Ihrer ursprünglichen Version.
Sicher kein Problem.
template<class Lhs, class F>
struct foldable_binop_t {
Lhs lhs;
F f;
template<class Rhs>
auto operator*(Rhs&& rhs) &&
-> foldable_binop_t< std::result_of_t<F&(Lhs&&, Rhs&&)>, F >
{
return { f(std::forward<Lhs>(lhs), std::forward<Rhs>(rhs)), std::forward<F>(f) };
}
Lhs operator()() && { return std::forward<Lhs>(lhs); }
operator Lhs() && { return std::move(*this)(); }
Lhs get() && { return std::move(*this); }
};
template<class F>
struct foldable_t {
F f;
template<class Lhs>
friend foldable_binop_t<Lhs, F> operator*( Lhs&& lhs, foldable_t&& self ) {
return {std::forward<Lhs>(lhs), std::forward<F>(self.f)};
}
template<class Rhs>
foldable_binop_t<Rhs, F> operator*( Rhs&& rhs ) && {
return {std::forward<Rhs>(rhs), std::forward<F>(f)};
}
};
template<class F>
foldable_t<F> foldable(F f) { return {std::move(f)}; }
testcode:
template<class...Xs>
auto result( Xs... xs ) {
auto maxer = [](auto&&...args){return (std::max)(decltype(args)(args)...);};
return ((0 * foldable(maxer)) * ... * xs).get();
}
template<class...Xs>
auto result2( Xs... xs ) {
auto maxer = [](auto&&...args){return (std::max)(decltype(args)(args)...);};
return (foldable(maxer) * ... * xs).get();
}
int main() {
int x = result2( 0, 7, 10, 11, -3 ); // or result
std::cout << x << "\n";
}
Persönlich finde ich
auto maxer = [](auto&&...args){return (std::max)(decltype(args)(args)...);};
nervig zu schreiben, so
#define RETURNS(...) \
noexcept(noexcept(__VA_ARGS__)) \
-> decltype(__VA_ARGS__) \
{ return __VA_ARGS__; }
#define OVERLOADS_OF(...) \
[](auto&&...args) \
RETURNS( __VA_ARGS__( decltype(args)(args)... ) )
macht es
template<class...Xs>
auto result3( Xs... xs ) {
return (foldable(OVERLOADS_OF((std::max))) * ... * xs).get();
}
oder auch
template<class...Xs>
constexpr auto result4( Xs... xs )
RETURNS( (foldable(OVERLOADS_OF((std::max))) * ... * xs).get() )
was aussieht ausdrucksstärker, und noexcept/constexpr richtig usw.
Ich möchte eine äquivalente Funktion mit Fold-Ausdrücken und
std::maxSchreiben. Zum Beispiel für 3 Elemente, auf die es erweitert werden soll
return std::max(sizeof (A), std::max(sizeof(B), sizeof (C)));
Eine andere mögliche Lösung (basierend auf der Rekursion nicht des Fold-Ausdrucks) ist die folgende
template <typename T0>
constexpr std::size_t max_sizeof ()
{ return sizeof(T0); }
template <typename T0, typename T1, typename ... Ts>
constexpr std::size_t max_sizeof ()
{ return std::max(sizeof(T0), max_sizeof<T1, Ts...>()); }
Kein Falzausdruck, aber eine andere Möglichkeit, die C++ 17 bietet - if constexpr:
template<class X, class Y, class...Ts>
constexpr std::size_t max_sizeof()
{
auto base = std::max(sizeof(X), sizeof(Y));
if constexpr (sizeof...(Ts) == 0)
{
// nothing
}
else if constexpr (sizeof...(Ts) == 1)
{
base = std::max(base, sizeof(Ts)...);
}
else
{
base = std::max(base, max_sizeof<Ts...>());
}
return base;
}
Nur zum Spaß eine Variation des Themas über die geniale Lösung von ildjarn
namespace detail
{
template <std::size_t N>
struct tSizeH : std::integral_constant<std::size_t, N> { };
template <std::size_t M, std::size_t N>
constexpr tSizeH<std::max(M, N)> operator^ (tSizeH<M>, tSizeH<N>);
}
template <typename ... T>
constexpr std::size_t max_sizeof() noexcept
{ return decltype((detail::tSizeH<sizeof(T)>{} ^ ...))::value; }
Ein wenig vereinfacht, weil (a) die Helfer-Klasse nur die sizeof() des Typs verwendet (direkt in max_sizeof() aufgelöst, (b) keine Verwendung des Endwerts basierend auf void und Null, (c) die operator^() ist deklariert, jedoch nicht implementiert Es ist nicht notwendig, es zu implementieren: Interesse besteht nur für den Rückgabetyp.) und (d) max_sizeof() verwenden decltype() anstelle des Aufrufs von operator^() (es ist also keine Implementierung erforderlich).