Przekazywanie operacji zwiększania/zmniejszania do funkcji

Question

Mam tę samą funkcję z tą różnicą, że będzie ona zwiększać lub zmniejszać. Chciałbym to uogólnić.

template<typename O> 
void f(int& i, O op){ 
    op(i); 
} 

int main() { 
    int i; 
    f(i,operator++); 
    f(i,operator--); 
    return 0; 
} 

Jak mogę to ułatwić?

moją drugą opcją jest użycie funkcjonalnego std :: plus lub posiadanie dwóch funkcji, ale wolę to rozwiązanie, jeśli to możliwe. Dziękuję Ci.

Answer 1

Wystarczy użyć lambda:

template<typename O> 
void f(int& i, O op){ 
    op(i); 
} 

int main() { 
    int i; 
    f(i,[] (int& x) { ++x; }); 
    f(i,[] (int& x) { --x; }); 
    return 0; 
} 

Także to nie jest jasne, czy chcesz post- lub preincrement.

Jak odnotowano w @ T.C. jeśli chcesz zachować semantykę zwykłego operatora, możesz dodać instrukcję return.

Answer 2

Oto jedna opcja (istnieje wiele możliwych rozwiązań), który działa również pre-C++ 11:

enum OpType { increment, decrement }; 

template <OpType op> void f(int &i); 
template<> void f<increment>(int &i) { ++i; } 
template<> void f<decrement>(int &i) { --i; } 

Zastosowanie:

f<increment>(i); 

Aby utrzymać codebase schludny prawdopodobnie chcesz użyj jednak pewnych zakresów, więc użyj enum z zakresu w C++ 11 lub w przestrzeni nazw.

Answer 3

w przypadku użycia dajesz, typename O to jednoskładnikowa funkcja bez państwa, które mogą być modelowane za pomocą prostego wskaźnika funkcji:

#include <iostream> 

int& increment(int& i) { 
    ++i; 
    return i; 
} 

int& decrement(int& i) { 
    --i; 
    return i; 
} 

template<typename O> 
void f(int& i, O op){ 
    op(i); 
} 

using namespace std; 

int main() 
{ 
    int i = 0; 
    f(i, increment); 
    cout << i << endl; 

    f(i, decrement); 
    cout << i << endl; 
    return 0; 
} 

wyjściowa:

1 
0