Metaprogramowanie szablonu C++, obejście "statyczne, jeśli" - czy można je poprawić?

Question

Mam funkcję, która skanuje system plików użytkownika, wypełnia wektor ścieżkami, a następnie sortuje je lub nie. Ponieważ użytkownik powinien móc decydować podczas kompilacji, czy chce sortować wektor, czy nie, używam szablonów i klas pomocniczych w miejsce bardzo pożądanego (ale nieistniejącego) "statycznego jeśli".

Rozważmy następujący kod:

enum class Sort{Alphabetic, Unsorted}; 

template<Sort TS> struct SortHelper; 
template<> struct SortHelper<Sort::Alphabetic> 
{ 
    static void sort(vector<string>& mTarget) { sort(begin(mTarget), end(mTarget)); } 
}; 
template<> struct SortHelper<Sort::Unsorted> 
{ 
    static void sort(vector<string>&) { } 
}; 

template<Sort TS> struct DoSomethingHelper 
{ 
    static void(vector<string>& mTarget) 
    { 
     // do something with mTarget 
     SortHelper<TS>::sort(mTarget); 
    } 
}; 

Kod pisałem powyżej jest znacznie uproszczone od the original, który zajmuje wiele parametrów szablonu, aby umożliwić użytkownikowi dostosowanie jeszcze wyników funkcji w czasie kompilacji .

Czy istnieje alternatywa dla używania wszystkich tych klas pomocników? Robi się naprawdę brudny i trudny do odczytania.

Idealnie, to jest to, co chciałbym napisać:

enum class Sort{Alphabetic, Unsorted}; 
template<Sort TS> struct DoSomethingHelper 
{ 
    static void(vector<string>& mTarget) 
    { 
     // do something with mTarget 
     static_if(TS == Sort::Unsorted) { /* do nothing */ } 
     static_if(TS == Sort::Alphabetic) { sort(begin(mTarget), end(mTarget)); } 
    } 
}; 

Answer 1

Ponieważ wartość jest znany w czasie kompilacji (parametr typu non-template) można doskonale napisać „normalne” if:

template<Sort TS> 
void someFunction(vector<string>& mTarget) 
{ 
    if (TS == Sort::Alphabetic) { sort(begin(mTarget), end(mTarget)); } 
    // else if (TS == Sort::Unsorted) {} 
} 

kompilator wykona stały składany i martwy eliminacja kod (jeśli takie optymalizacje są włączone, oczywiście), a wynik będzie e tak samo jak w przypadku hipotetycznego static_if.

Answer 2

Obawiam się, że doszło do nieporozumienia na temat korzystania z static_if.

Z pewnością możesz użyć static_if (lub jakiejkolwiek sztuczki, którą naprawdę chcesz), aby spróbować uzyskać optymalizację, ale to nie jest jej pierwszy cel.

Pierwszy cel static_if to semantyczny. Pozwól mi zademonstrować to z std::advance. Typowa implementacja std::advance użyje przełącznika typu do wyboru, w czasie kompilacji, między O (1) realizacja (Random Access iteratory) oraz O (n) wdrożenia (dla innych):

template <typename It, typename D> 
void advance_impl(It& it, D d, random_access_iterator_tag) 
{ 
    it += d; 
} 

template <typename It, typename D> 
void advance_impl(It& it, D d, bidirectional_iterator_tag) 
{ 
    if (d > D(0)) { for (D i(0); i < d; ++i) { ++it; } } 
    else   { for (D i(0); i > d; --i) { --it; } } 
} 

template <typename It, typename D> 
void advance_impl(It& it, D d, input_iterator_tag) 
{ 
    for (D i(0); i < d; ++i) { ++it; } 
} 

i wreszcie:

template <typename It, typename D> 
void advance(It& it, D d) 
{ 
    typename std::iterator_traits<It>::iterator_category c; 
    advance_impl(it, d, c); 
} 

Dlaczego nie używać tylko if w tym przypadku? Ponieważ nie skompilowałoby się.

• dwukierunkowym Iterator nie obsługuje +=
• wejście Iterator (lub Forward Iterator) nie obsługuje --

Zatem tylko sposób zaimplementować funkcjonalność jest statycznie wysyłanie do funkcji tylko za pomocą dostępnych operacji na danym typie.

Answer 3

Co ze specjalnością szablonów?

#include <vector> 
#include <iostream> 
#include <algorithm> 

using namespace std; 

enum class Sort { 
    Alphabetic, 
    Unsorted 
}; 

template<Sort TS> struct DoSomethingHelper { 
    static void someFunction(vector<string>& mTarget) 
    {} 
}; 

template<> struct DoSomethingHelper<Sort::Unsorted> { 
    static void someFunction(vector<string>& mTarget) { 

    } 
}; 

template<> struct DoSomethingHelper<Sort::Alphabetic> { 
    static void someFunction(vector<string>& mTarget) { 
     sort(begin(mTarget), end(mTarget)); 
    } 
}; 

int main() { 
    vector<string> v = {{"foo", "bar", "foo2", "superman", ".."}}; 

    DoSomethingHelper<Sort::Alphabetic> helper; 
    helper.someFunction(v); 

    for (string& s : v) { 
     cout << s << endl; 
    } 
    return 0; 
} 

Edit: jestem idiotą.