Was sollte ich anstelle von Vorlagen verwenden?

Question

In meinem Code verwende ich etwas wie folgt aus:

enum { 
    foo = sizeof(some_type_t) < 32 ? 1 : 2, 
    bar = some_constexpr_function() - N, 
    baz = foo + bar, 
    // etc. 
} 

für eine Reihe von Kompilierung-Konstanten, für die ich dort sicherstellen wollen, wird keine Laufzeitspeicher sein; und ich habe ein paar Funktionen, die diese Konstanten verwenden. N ist eine Konstante, die wir von woanders bekommen.

Nun möchte ich meinen Code nehmen und ihn templatisieren: N ist keine globale Konstante mehr, sondern ein numerischer Template-Parameter. Nun, wenn ich das tat:

template <size_t N> f() 
{ 
    enum { 
     foo = sizeof(some_type_t) < 32 ? 1 : 2, 
     bar = some_constexpr_function() - N, 
     baz = foo + bar, 
     // etc. 
    } 
} 

Das würde funktionieren; aber - es beschränkt mich darauf, diese Konstanten in einer einzigen Funktion zu verwenden; Ich möchte mehrere haben. In C++ können wir nicht haben

template <size_t N> 
    enum { 
     foo = sizeof(some_type_t) < 32 ? 1 : 2, 
     bar = some_constexpr_function() - N, 
     baz = foo + bar, 
     // etc. 
    } 

Was würde eine elegante, oder vielleicht die idiomatische, Art und Weise das Äquivalent dieser templatization zu erreichen?

Answer 1

Was ich tue, so weit meine Enum in einer Dummy-Halter-Klasse setzt, die kann Templat werden:

template <size_t N> 
struct params 
{ 
    enum { 
     foo = sizeof(some_type_t) < 32 ? 1 : 2, 
     bar = some_constexpr_function() - N, 
     baz = foo + bar, 
    }; 
} 

Aber dann habe ich params::foo, schreiben params::bar überall, das mühsam ist:

do_stuff_with(params::foo, params::bar) 

statt

do_stuff_with(foo, bar); 

Answer 2

Genau wie Sie in den Kommentaren gesagt wurden, sehe ich keinen Punkt darauf, diese benannten Konstanten unter einem Enum zu haben. Haben Sie einfach eine Reihe von constexpr Variablen in einem einzigen Namespace-Bereich. Sie können den gleichen Netto-Effekt erhalten:

namespace constants { 
    namespace detail { 
       using underlying_t = int; 
    } 
    template<size_t N> 
    constexpr detail::underlying_t foo = sizeof(some_type_t) < 32 ? 1 : 2; 

    template<size_t N> 
    constexpr detail::underlying_t bar = some_constexpr_function() - N; 

    template<size_t N> 
    constexpr detail::underlying_t baz = foo<N> + bar<N>; 
} 

Sie sind alle constexpr, so dass sie leicht Zeitkonstanten laufen, und Sie können den zugrunde liegenden Typ in einem einzigen Ort steuern, wenn Sie benötigen. Sie können auch entweder mit einer vollständig qualifizierten ID auf sie zugreifen oder sie alle mit einer using-Direktive einbinden.

Answer 3

Vielleicht überladen Komma constexprly würde Ihren Bedürfnissen entsprechen?

#include <utility> 

enum params { 
    foo = 1, 
    bar = 2, 
    baz = 3 
}; 


struct some_type_t { }; 
constexpr std::size_t some_constexpr_function() { 
    return 0; 
} 


constexpr std::size_t operator ,(params P, std::size_t N) { 
    switch (P) { 
     case foo: 
      return sizeof(some_type_t) < 32 ? 1 : 2; 
     case bar: 
      return some_constexpr_function() - N; 
     case baz: 
      return (foo, N) - (bar, N); 
    } 
    return 0; 
} 


template <std::size_t> 
struct example { }; 

int main() { 
    example<(baz, 2)>{}; 
} 

[live demo]