Du Suchst Übung!?

Gustl schrieb:

@Eine Frage der Umsetzung: Javascript aktiviert ist die syntax highlighting sichtbar.

Also so statisches Zeugs wie Syntax Highlighting kriegst du doch sicher auch ohne Javascript hin.
Bei mir ist JS aus Sicherheitsgründen deaktiviert.

Thema Übersicht, diese ist noch nicht entwickelt. Deine Tipps werde ich aber dann berücksichtigen.

Danke.

Sone

So, Lösung eingereicht.
Möchte jemand noch hier sehen?
Aber erst, nachdem mir die Punkte verliehen worden sind

Hehe, nice! Jetzt schon 830 Punkte!
Damit stehe ich auf Platz 6. Bald bin ich 2. >:D

camper

Sone schrieb:

So, Lösung eingereicht.
Möchte jemand noch hier sehen?

Zeigt mal filter. Der Rest ist nicht so interessant.

Sone

camper schrieb:

Sone schrieb:

So, Lösung eingereicht.
Möchte jemand noch hier sehen?

Zeigt mal filter. Der Rest ist nicht so interessant.

Ja, tatsächlich hatte ich bei filter einige Schwierigkeiten.

template<typename TL, typename TL2> struct merge {};

  template<typename ... args, typename ... args2>
  struct merge< type_list<args...>, type_list<args2...> >
  {
      typedef type_list<args ..., args2 ...> merged_list;
  };

  template<template <typename> class Pred, typename TL> struct filter_impl {};
  template<template <typename> class Pred, typename first, typename ...args>
  struct filter_impl<Pred, type_list<first, args...>>
  {
      typedef typename std::conditional< Pred<first>::value, typename merge< type_list<first>, typename filter_impl< Pred, type_list<args...> >::filtered_list>::merged_list,
                                                             typename filter_impl< Pred, type_list<args...> >::filtered_list>::type filtered_list;
  };

  template<template <typename> class Pred>
  struct filter_impl<Pred, type_list<>> { typedef type_list<> filtered_list; };

  template <typename TL, template <typename> class Pred=identity>
  using filter = typename filter_impl<Pred, TL>::filtered_list;

Aber wahrscheinlich ist mein Code völliger Blödsinn, voller Mankos und Bugs :xmas2:

Edit: Stop! Jetzt klaut es bestimmt jeder (außer camper, weil der sowieso eine bessere Lösung hat)

Sone

Sag, camper, hast du dich eigentlich dort angemeldet? Wahrscheinlich nicht, oder?

Ganz nett Sone, entspricht ziemlich genau meiner Implementierung.

template <typename T> struct identity_ { using type = T; };

  template <typename T, typename TL> struct cons_ {};
  template <typename T, typename... Ts>
  struct cons_<T, type_list<Ts...> > : identity_<type_list<T, Ts...> > {};

  template <typename T, template <typename> class Pred=identity> struct filter_ {};
  template <typename T, typename ... Ts, template <typename> class Pred>
  struct filter_<type_list<T, Ts...>, Pred> {
    using Rest = typename filter_<type_list<Ts...>, Pred>::type;
    using type = typename std::conditional<Pred<T>::value, typename cons_<T, Rest>::type, Rest>::type;
  };
  template <template <typename> class Pred> struct filter_<type_list<>, Pred> : identity_<type_list<> > {};

Hehe, auf Basis dieser Grundalgorithmen gabs jetzt eine ganz fiese Aufgabe ^^

Sone

templer schrieb:

Hehe, auf Basis dieser Grundalgorithmen gabs jetzt eine ganz fiese Aufgabe ^^

Wo? :hechel:

Gut, bis Gustl die Aufgabe freigeschaltet hat, hier die Kurzform:

template <typename... Ts> struct all_equal;
template <typename T, typename... Ts> struct all_equal<T, Ts...> {
  static constexpr bool value = tmpalg::all_of<tmpalg::type_list<Ts...>, ???>::value; };
template <> struct all_equal<> : std::true_type {};

static_assert(all_equal<int, int, int, int>::value, "");
static_assert(!all_equal<float, int, int, int>::value, "");
static_assert(!all_equal<int, int, short, int>::value, "");
static_assert(all_equal<>::value, "");

Ersetzte die ??? mit dem passenden Ausdruck. Es dürfen maximal 3 zusätzliche Zeilen gebraucht werden.

Btw: Es reichen 73 Zeichen für alles inkl ????
So schwierig ist das doch nicht.

camper

Habe meine Lösung nochmal etwas überarbeitet:

template <typename T>
  struct identity_ {
    using type = T;
  };
  template <typename T>
  using identity = T;

  template <typename... T>
  struct type_list
    : identity_<type_list<T...>> {};

  template <typename... TL>
  struct concat_type_lists_;
  template <typename... TL>
  using concat_type_lists = typename concat_type_lists_<TL...>::type;
  template <typename... T, typename... U, typename... TL>
  struct concat_type_lists_<type_list<T...>, type_list<U...>, TL...>
    : concat_type_lists<type_list<T..., U...>, TL...> {};
  template <typename... T>
  struct concat_type_lists_<type_list<T...>>
    : type_list<T...> {};

  template <typename TL, template <typename> class Pred>
  struct filter_;
  template <typename TL, template <typename> class Pred>
  using filter = typename filter_<TL, Pred>::type;
  template <typename... T, template <typename> class Pred>
  struct filter_<type_list<T...>, Pred>
    : concat_type_lists<typename std::conditional<Pred<T>::value, type_list<T>, type_list<>>::type...> {};

Eigentlich wollte ich ohne eine merge/cons/concat-Funktion auskommen. Das muss ich aber erst nochmal überschlafen.

Sone

templer schrieb:

Btw: Es reichen 73 Zeichen für alles inkl ????
So schwierig ist das doch nicht.

Das ist es auch überhaupt nicht. Habe meine Lösung gleich fertig.

Eigentlich wollte ich ohne eine merge/cons/concat-Funktion auskommen. Das muss ich aber erst nochmal überschlafen.

Genau das dachte ich auch.

Sone

Btw: Wieso kann man nicht ein verschachteltes Klassentemplate as ganz normales Klassentemplate benutzen? camper, hilf!
Edit: Ach, doch es geht. Man muss nur ::template schreiben ^^

So, bin fertig! Willste sehen?

Sone schrieb:

So, bin fertig! Willste sehen?

Gerne. Die ::template -Lösung hatte ich ursprünglich auch (das war die Schwierigkeit).

Sone

Das war die Schwierigkeit? lol

template<typename T> struct all_equal_impl
{ template<typename InnerT> struct equal_to : public std::is_same<T, InnerT> {}; };

template <typename... Ts> struct all_equal;
template <typename T, typename... Ts> struct all_equal<T, Ts...> {
  static constexpr bool value = tmpalg::all_of<tmpalg::type_list<Ts...>, all_equal_impl<T>::template equal_to>::value; };
template <> struct all_equal<> : std::true_type {};

Nice. Kommst du auch auf die Lösung mit using, die keine extra struct benötigt?

Sone

templer schrieb:

Nice. Kommst du auch auf die Lösung mit using, die keine extra struct benötigt?

In welcher Hinsicht? Für all_equal_impl oder all_equal ?
Edit: Du wirst wohl ersteres meinen.

Sone schrieb:

Edit: Du wirst wohl ersteres meinen.

Erraten. Wie gesagt, die Vorlage ohne "???" mit 70 zusätzliche Zeichen (Leerzeichen mitgezählt).

Sone

templer schrieb:

Nice. Kommst du auch auf die Lösung mit using, die keine extra struct benötigt?

Klar:

template <typename... Ts> struct all_equal;
template <typename T, typename... Ts> struct all_equal<T, Ts...>
{
  template<typename T2> using all_equal_impl = std::is_same<T, T2>;
  static constexpr bool value = tmpalg::all_of<tmpalg::type_list<Ts...>, all_equal_impl >::value;
};
template <> struct all_equal<> : std::true_type {};

Edit: Ein bisschen eingerückt komme ich auf 65 :p (Edit²:) Mit langem Namen!