Ganz viele Oder || vereinfachen

(wobei der Begriff in diesem Zusammenhang nicht einmal so falsch ist)

Sieht so aus als müsse ich noch ein paar Jahre lernen bevor ich deine Antworten verstehen kann, zumal mir völlig unklar ist wie set und selection->Aktion das Veroderungsproblem löst.
Hoffen wir, dass robozer eine deutlich schnellere Auffassungsgabe hat.

camper schrieb:

template <int... i>
bool is_in(int v)
{
    bool result = false;
    bool res[sizeof...(i)+1] = { result = result || v == i ... };
    return result;
}

(das constexpr zu machen ist ein bisschen komplizierter)

Ist kaum schwerer, nur mehr Boilerplate.

constexpr bool is_in(int) { return false; } // Anker
template <int i> constexpr bool is_in(int v) { return v==i; } // Aktion
template <int i, int a, int... b> constexpr bool is_in(int v)
{ return is_in<i>(v) || is_in<a, b...>(v); } // Verknüpfung

Der TE will aber mehr:

template <int L, int R> struct range {
  static constexpr bool check(int v) { return L<=v && v<R; }
};
template <int... i> struct one_of {
  static constexpr bool check(int v) { return is_in<i...>(v); }
};
template <int i> using single = range<i, i+1>; // ev. noch optimieren, dass == benutzt wird

struct impair { static constexpr bool check(int v) { return v%2; } }; // just for fun

template <typename T> constexpr bool is_in(int v) { return T::check(v); }
template <typename T, typename Q, typename... R> constexpr bool is_in(int v)
{ return is_in<T>(v) || is_in<Q, R...>(v); }

Jetzt kann er schreiben

for (int sel = 0; sel <= 20; ++sel) {
  bool a = is_in<4, 7, 14, 15, 16, 17, 18>(sel);
  bool b = is_in<single<4>, single<7>, range<14, 19>>(sel);
  bool c = is_in<one_of<4, 7>, range<14, 19>>(sel);
  assert(a==b&&b==c);
  assert((is_in<impair, single<2>>(sel) == sel%2||sel==2));
}

pumuckl

Mit C++11 könnte man auch sowas machen:

for (auto i : {1,2,3,5,6,9,22})
  if (selection == i)
  {
    dosomething();
    break;
  }

http://liveworkspace.org/code/2oA5y8$0

Sone

Explizit rekursiv geht viel einfacher, templer:

template <int i1>
constexpr bool is_in(int v)
{ return v == i1; }

template <int i1,
          int... in,
          typename = typename std::enable_if<sizeof...(in)>::type>
constexpr bool is_in(int v)
{ return v == i1 || is_in<in...>(v); }

(Unschön, aber so simpel wie es scheint ist es mir gar nicht gewesen)

Sone

pumuckl schrieb:

Mit C++11 könnte man auch sowas machen:

for (auto i : {1,2,3,5,6,9,22})
  if (selection == i)
  {
    dosomething();
    break;
  }

if( std::set{1,2,3,5,6,9,22}.count(selection) )
   dosomething();

Klar, Performance-Killer, aber...

1979:
http://upload.wikimedia.org/wikipedia/commons/7/71/Redhead_Beach_Bell_Bottoms.jpg

is_in;

2013:

template <int L, int R> struct range {
  static constexpr bool check(int v) { return L<=v && v<R; }
};
template <int... i> struct one_of {
  static constexpr bool check(int v) { return is_in<i...>(v); }
};
template <int i> using single = range<i, i+1>; // ev. noch optimieren, dass == benutzt wird

struct impair { static constexpr bool check(int v) { return v%2; } }; // just for fun

template <typename T> constexpr bool is_in(int v) { return T::check(v); }
template <typename T, typename Q, typename... R> constexpr bool is_in(int v)
{ return is_in<T>(v) || is_in<Q, R...>(v); }

is_in;

Ja, ich habe heute einen unlustigen Clown geabendgegessen

Sone schrieb:

if( std::set{1,2,3,5,6,9,22}.count(selection) )
   dosomething();
Klar, Performance-Killer, aber...

performance killer ?
abgesehn davon das das set static const sein koennte

ist es beweisbar das die recursiven template loesungen welche hier gepostet wurden mit einer zur compile time unbekannten selection schneller sind?

volkard

kurze_frage schrieb:

ist es beweisbar das die recursiven template loesungen welche hier gepostet wurden mit einer zur compile time unbekannten selection schneller sind?

Schade, daß hier immer so ein Mist kommt.

#include <iostream>

int main()
{
    using namespace std;
    unsigned selection;
    cin>>selection;
    if(selection<31 &&
       selection["\0\0\1\1\0\1\0\1\0\0\0\1\0\1\0\0\0\1\0\1\0\0\0\1\0\0\0\0\0\1\0"])
        cout<<selection<<" ist eine Primzahl unter 32.\n";
}

Sone

volkard schrieb:

kurze_frage schrieb:

ist es beweisbar das die recursiven template loesungen welche hier gepostet wurden mit einer zur compile time unbekannten selection schneller sind?

Schade, daß hier immer so ein Mist kommt.

Sieh dir mal deinen Code an. Flüchtigkeitsfehler?

volkard

Sone schrieb:

Sieh dir mal deinen Code an. Flüchtigkeitsfehler?

Nö, läuft doch.
(Gebe ja zu, daß die Form ein Scherzchen ist. )
Wollte einwerfen, daß ein Arraynachgucker auch nicht gerade lahm ist.

Sone

Funktioniert aber nicht für 31. Siehe zweiter Upload auf Ideone.

Gebe ja zu, daß die Form ein Scherzchen ist.

Genau diese Form habe ich auch zum Spaß in einer Spielerei verwendet, aber ohne Escape-Sequenzen sondern mit den ASCII-Zeichen 0 und 1 und dafür dahinter ein -'0'. Ist einfacher zu lesen.