Groups | Search | Server Info | Keyboard shortcuts | Login | Register [http] [https] [nntp] [nntps]

Groups > de.comp.lang.iso-c++ > #1955 > unrolled thread

typedef auf variadic template

Back to article view | Back to de.comp.lang.iso-c++

Contents

  typedef auf variadic template Markus Donath <nntp@online.de> - 2016-11-18 16:51 +0100
    Re: typedef auf variadic template Stefan Reuther <stefan.news@arcor.de> - 2016-11-20 11:14 +0100
      Re: typedef auf variadic template Markus Donath <nntp@online.de> - 2016-11-21 08:58 +0100
      Re: typedef auf variadic template Markus Donath <nntp@online.de> - 2016-11-21 11:45 +0100
      Re: typedef auf variadic template Thomas Dorner <td-dclic01@th-dorner.de> - 2016-11-21 15:42 +0100
        Re: typedef auf variadic template Markus Donath <nntp@online.de> - 2016-11-22 10:07 +0100
    Re: typedef auf variadic template nntp@mailinator.com - 2016-12-20 09:54 +0000
      Re: typedef auf variadic template Markus Donath <nntp@online.de> - 2016-12-22 14:30 +0100
    Re: typedef auf variadic template ram@zedat.fu-berlin.de (Stefan Ram) - 2016-12-20 13:58 +0000
      Re: typedef auf variadic template Markus Donath <nntp@online.de> - 2016-12-22 14:34 +0100
      Re: typedef auf variadic template Markus Donath <nntp@online.de> - 2016-12-22 14:39 +0100

#1955 — typedef auf variadic template

Ich benötige häufig eine Überprüfung, ob ein Wert in einer Reihe von 
Werten vorkommt. Dabei finde ich:

if(n==3 || n==5 || n==27 || n==-1327)

unschön.

Deshalb habe ich mir gebaut:

template<typename T, T ... items>
inline bool is_in(const T& item) {
   T match_items[sizeof...(items)] = { items... };
   for(int i = 0; i < sizeof...(items); ++i)
     if(item == match_items[i])
       return true;
   return false;
}

Und kann somit prüfen:

if(is_in<int, 3, 5, 27, -1327>(n))

Was mir jetzt noch fehlt ist ein typedef um im Aufruf nicht den Typ 
mitgeben zu müüsen, also:

if(is_in_ints<3, 5, 27, -1327>(n))

aber ich bekomme diesen typedef nich hin

typedef is_in<int, int ... items> is_in_ints;

funktioniert schon mal nicht. Was mache ich falsch?


Markus

[toc] | [next] | [standalone]

#1957

Am 18.11.2016 um 16:51 schrieb Markus Donath:
> template<typename T, T ... items>
> inline bool is_in(const T& item) {
>   T match_items[sizeof...(items)] = { items... };
>   for(int i = 0; i < sizeof...(items); ++i)
>     if(item == match_items[i])
>       return true;
>   return false;
> }

Wie wär's damit:
    template<typename T>
    inline bool is_in(const T& item, const T& value)
    {
        return item == value;
    }

    template<typename T, typename... Values>
    inline bool is_in(const T& item, const T& value, Values... values)
    {
        return item == value || is_in(item, values...);
    }

Aufruf als 'is_in(n, 3, 5, 27, -1327)'. Nachteil: da der Typ nicht
angegeben ist, müssen die Parametertypen halt von vornherein passen.


  Stefan

[toc] | [prev] | [next] | [standalone]

#1959

On 11/20/2016 11:14, Stefan Reuther wrote:
>
> Wie wär's damit:
>     template<typename T>
>     inline bool is_in(const T& item, const T& value)
>     {
>         return item == value;
>     }
>
>     template<typename T, typename... Values>
>     inline bool is_in(const T& item, const T& value, Values... values)
>     {
>         return item == value || is_in(item, values...);
>     }
>
> Aufruf als 'is_in(n, 3, 5, 27, -1327)'. Nachteil: da der Typ nicht
> angegeben ist, müssen die Parametertypen halt von vornherein passen.
>
>
>   Stefan
>

Vielen Dank. Den Nachteil sehe ich eher als Vorteil. Wird ein falscher 
Typ übergeben, gibt es einen Compiler-Fehler.

Markus

[toc] | [prev] | [next] | [standalone]

#1960

On 11/20/2016 11:14, Stefan Reuther wrote:
>
> Wie wär's damit:
>     template<typename T>
>     inline bool is_in(const T& item, const T& value)
>     {
>         return item == value;
>     }
>
>     template<typename T, typename... Values>
>     inline bool is_in(const T& item, const T& value, Values... values)
>     {
>         return item == value || is_in(item, values...);
>     }
>
> Aufruf als 'is_in(n, 3, 5, 27, -1327)'. Nachteil: da der Typ nicht
> angegeben ist, müssen die Parametertypen halt von vornherein passen.
>
>
>   Stefan
>


Bzw:

template<typename T, typename... Values>
inline bool is_in(const T& item, const T& value, Values... values)
{
	return item == value || is_in<T>(item, values...);
}


Markus

[toc] | [prev] | [next] | [standalone]

#1965

>    template<typename T>
>    inline bool is_in(const T& item, const T& value)
>    {
>        return item == value;
>    }
>
>    template<typename T, typename... Values>
>    inline bool is_in(const T& item, const T& value, Values... values)
>    {
>        return item == value || is_in(item, values...);
>    }
>
>Aufruf als 'is_in(n, 3, 5, 27, -1327)'. Nachteil: da der Typ nicht
>angegeben ist, müssen die Parametertypen halt von vornherein passen.

Nette Lösung und nettes Problem.  Ich hätte noch eine Variante
vorzuschlagen, die auch Unterschiede zwischen den Typen von Variable und
Werten erlaubt:

template<typename T1, typename T2>
inline bool is_in(const T1& item, const T2& value)
{
    return item == value;
}
template<typename T1, typename T2, typename... Values>
inline bool is_in(const T1& item, const T2& value, Values... values)
{
    return item == value || is_in(item, values...);
}

Dann funktioniert das Ganze sogar mit standard C++ Strings gegen
Stringliterale (oder anderen Klassen, die operator== implementieren):

    std::string aString(...);
    if (is_in(aString, "OK", "true"))

Achtung, nicht für standard C "char*" Strings geeignet, da sich "=="
nicht entsprechend verhält.

Aber für C++ 11 enums geht es (aber da klappt wohl auch schon die
ursprüngliche Variante):

    enum class Traffic { green, yellow, red };
    Traffic light = Traffic::red;
    if (is_in(light, Traffic::red, Traffic::yellow))

Viele Grüße, Thomas

[toc] | [prev] | [next] | [standalone]

#1967

On 11/21/2016 15:42, Thomas Dorner wrote:
>
> Nette Lösung und nettes Problem.  Ich hätte noch eine Variante
> vorzuschlagen, die auch Unterschiede zwischen den Typen von Variable und
> Werten erlaubt:
>
> template<typename T1, typename T2>
> inline bool is_in(const T1& item, const T2& value)
> {
>     return item == value;
> }
> template<typename T1, typename T2, typename... Values>
> inline bool is_in(const T1& item, const T2& value, Values... values)
> {
>     return item == value || is_in(item, values...);
> }
>
> Dann funktioniert das Ganze sogar mit standard C++ Strings gegen
> Stringliterale (oder anderen Klassen, die operator== implementieren):
>
>     std::string aString(...);
>     if (is_in(aString, "OK", "true"))
>
> Achtung, nicht für standard C "char*" Strings geeignet, da sich "=="
> nicht entsprechend verhält.
>
> Aber für C++ 11 enums geht es (aber da klappt wohl auch schon die
> ursprüngliche Variante):
>
>     enum class Traffic { green, yellow, red };
>     Traffic light = Traffic::red;
>     if (is_in(light, Traffic::red, Traffic::yellow))
>
> Viele Grüße, Thomas
>

Super. Jetzt is es perfekt.

Markus

[toc] | [prev] | [next] | [standalone]

#1979

Markus Donath <nntp@online.de> schrieb:
> Ich benötige häufig eine Überprüfung, ob ein Wert in einer Reihe von 
> Werten vorkommt. Dabei finde ich:
>
> if(n==3 || n==5 || n==27 || n==-1327)
>
> unschön.

Das Benutzen von std::set<int>::find() ist keine Alternative?

[toc] | [prev] | [next] | [standalone]

#1983

On 12/20/2016 10:54, nntp@mailinator.com wrote:
> Das Benutzen von std::set<int>::find() ist keine Alternative?
>


Also anstelle von
if(n==3 || n==5 || n==27 || n==-1327)
   // do something

const std::set<int> comp_numbers { 3, 5, 27, -1327 };
if(comp_numbers.find(n) != comp_numbers.end())
   // do something

Nein, wirklich nicht. Ich wollte ja weniger Schreibarbeit haben, nicht mehr.

Markus

[toc] | [prev] | [next] | [standalone]

#1980

Markus Donath <nntp@online.de> writes:
>Ich benötige häufig eine Überprüfung, ob ein Wert in einer Reihe von 
>Werten vorkommt. Dabei finde ich:
>if(n==3 || n==5 || n==27 || n==-1327)
>unschön.

  Wobei man auch 

switch( n )
{ case     3:
  case     5:
  case    27:
  case -1327: ...

  nicht unerwähnt lassen sollte. Das versteht der Optimierer eventuell.

[toc] | [prev] | [next] | [standalone]

#1981

On 12/20/2016 14:58, Stefan Ram wrote:
> Markus Donath <nntp@online.de> writes:
>> Ich benötige häufig eine Überprüfung, ob ein Wert in einer Reihe von
>> Werten vorkommt. Dabei finde ich:
>> if(n==3 || n==5 || n==27 || n==-1327)
>> unschön.
>
>   Wobei man auch
>
> switch( n )
> { case     3:
>   case     5:
>   case    27:
>   case -1327: ...
>
>   nicht unerwähnt lassen sollte. Das versteht der Optimierer eventuell.
>


Das ist aber nicht wirklich eine Abkürzung...

Markus

[toc] | [prev] | [next] | [standalone]

#1982

On 12/20/2016 14:58, Stefan Ram wrote:
> Markus Donath <nntp@online.de> writes:
>> Ich benötige häufig eine Überprüfung, ob ein Wert in einer Reihe von
>> Werten vorkommt. Dabei finde ich:
>> if(n==3 || n==5 || n==27 || n==-1327)
>> unschön.
>
>   Wobei man auch
>
> switch( n )
> { case     3:
>   case     5:
>   case    27:
>   case -1327: ...
>
>   nicht unerwähnt lassen sollte. Das versteht der Optimierer eventuell.
>


... und funktioniert nur für Ganzzahltypen.

Markus

[toc] | [prev] | [standalone]

Back to top | Article view | de.comp.lang.iso-c++

csiph-web