Ganz viele Oder || vereinfachen

camper

Was SeppJ vorschlägt.

Wenn es nur gelegentlich vorkommt, und sich die einführung von zus. Containern nicht recht lohnt, kann nat. auch ein bisschen spielen

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).
Erweiterung auf ganze Zahlenbereiche ist ebenso möglich.

Anwendung

if ( is_in<4, 7, 14, 15, 16, 17, 18>(selection) )

Effektiv fasst du hier die selections in Gruppen mit gemeinsamen Eigenschaften zusammen. Diesen Gruppen sollte man einfach entsprechende Namen geben:

bool activatableGroup = selection==1 || selection ==2 || selection==3;
if (activatableGroup)
	activate();
else if (printableGroup)
	printGroup();

Dann hat man auch einen Überblick welche selections in welchen Gruppen sind und wie darauf reagiert wird. Den is_in-Kram kann man noch zusätzlich verwenden.

SeppJ

nwp3 schrieb:

Effektiv fasst du hier die selections in Gruppen mit gemeinsamen Eigenschaften zusammen. Diesen Gruppen sollte man einfach entsprechende Namen geben:

Gute Idee. Gruppe, das ist doch fast das gleiche Wort wie Menge. Menge ist sogar genauer, denn das Wort Gruppe impliziert auch eine Art Beziehung, die hier aber nicht gegeben ist. Hmm, Mengen nennt man im Englischen set. Irgendwo habe ich das Wort doch schon einmal gehört . Wenn man einem Element einer Menge etwas zuordnet, zum Beispiel eine Aktion, dann nennt der Mathematiker das eine Abbildung. Die englischen Mathematiker nennen es map. Wieder so ein Wort, dass ich auch schon woanders einmal gehört habe.

(Ich will mich nicht über den Vorschlag lustig machen, sondern nur zeigen, dass es der erste Schritt auf dem Weg zu meinem Vorschlag ist, denn als nächstes fragst du dich nämlich, ob man diese "Gruppen" nicht auch irgendwie formalisieren kann, a la campers is_in-Vorschlag und als übernachstes entwickelst du dann ein Konzept, wie man die Bindung von Gruppenelement an Aktion abstrahieren könnte.)

if-schleife

(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.