Parametr lambda z opcjonalną wartością zwracaną

Question

Próbuję napisać funkcję podobną do std::for_each, która oprócz zwykłego użycia może również przyjąć wartość std::function<bool (param)>. Wartość false return oznacza, że ​​chcę wyjść z pętli. Poniższy kod jest tym, co dostałem do tej pory.

Drugie połączenie z a.visit([&](int) -> void) nie kompiluje podczas oceniania! Odwiedzającego (i). Czy można wykonać tę pracę, czy też szczerzę złe drzewo?

Używam MSVC 2010, ale chcę, aby kod był ogólnie zgodny z C++ 11.

#include <list> 
#include <string> 
#include <iostream> 

struct A 
{ 
    std::list<int> _lst; 

    template<typename _F> 
    void visit(_F visitor) 
    { 
     for(std::list<int>::const_iterator it = _lst.begin(), end = _lst.end() ; it != end ; it++) { 
      int i = *it; 
      if (std::is_void<decltype(visitor(i))>::value) { 
       visitor(i); 
      } else { 
       if (!visitor(i)) { // <----- error C2171: '!' : illegal on operands of type 'void' 
        break; 
       } 
      } 
     } 
    } 

}; 

int main(int argc, char* argv[]) 
{ 
    A a; 
    // populate a 
    for (int i = 0 ; i < 10 ; i++) { 
     a._lst.push_back(i); 
    } 

    a.visit([](int i) -> bool { 
     std::cout << i << std::endl; 
     return i < 5; 
    }); 

    a.visit([](int i) { 
     std::cout << i << std::endl; 
    }); 
} 

Answer 1

Oto w jaki sposób zaimplementować for_almost_each; Jestem using namespace std plus aliasy typów dla celów czytelności.

#include <algorithm> 
#include <iterator> 
#include <functional> 

using namespace std; 

template<class Iter, class Func> 
Iter 
for_almost_each_impl(Iter begin, Iter end, Func func, std::true_type) 
{ 
    for (auto i = begin; i!=end; ++i) 
     if (!func(*i)) 
      return i; 
    return end; 
} 

template<class Iter, class Func> 
Iter 
for_almost_each_impl(Iter begin, Iter end, Func func, std::false_type) 
{ 
    for_each(begin, end, func); 
    return end; 
} 


template<class Iter, class Func> 
Iter for_almost_each(Iter begin, Iter end, Func func) 
{ 
    using Val = typename iterator_traits<Iter>::value_type; 
    using Res = typename result_of<Func(Val)>::type; 
    return for_almost_each_impl(begin, end, 
           func, 
           is_convertible<Res, bool>{}); 
} 

użyłem is_convertible, gdyż wydaje się bardziej sensowne niż is_same.

Answer 2

Ten lambda nie zwraca wartości, dlatego dostajesz błąd, że „gość” zwraca void:

a.visit([](int i) { 
    std::cout << i << std::endl; 
}); 

można zrobić tę pracę przez przepisywanie jako:

a.visit([](int i) -> bool { 
    std::cout << i << std::endl; 
    return true; 
}); 

Answer 3

Twoje std :: is_void musi być wykonane w czasie kompilacji i nie może być wykonane wewnątrz treści funkcji. Takie wykorzystanie funkcji przeciążenia zadziała:

#include <list> 
#include <string> 
#include <iostream> 
#include <type_traits> // missing header 

struct A 
{ 
    std::list<int> _lst; 

    // wrapper for bool returning visitor 
    template<typename _F, typename Iter> 
    bool do_visit(_F visitor, Iter it, std::true_type) 
    { 
     return visitor(*it); 
    } 

    // wrapper for non-bool returning visitor 
    template<typename _F, typename Iter> 
    bool do_visit(_F visitor, Iter it, std::false_type) 
    { 
     visitor(*it); 
     return true; 
    } 

    template<typename _F> 
    void visit(_F visitor) 
    { 
     for (auto it = _lst.begin(), end = _lst.end() ; it != end ; it++) { 
      // select correct visitor wrapper function using overloading 
      if (!do_visit(visitor, it, std::is_same<bool, decltype(visitor(0))>())) { 
       break; 
      } 
     } 
    } 
}; 

int main(int argc, char* argv[]) 
{ 
    A a; 
    // populate a 
    for (int i = 0 ; i < 10 ; i++) { 
     a._lst.push_back(i); 
    } 

    a.visit([](int i) -> bool { 
     std::cout << i << std::endl; 
     return i < 5; 
    }); 

    a.visit([](int i) { 
     std::cout << i << std::endl; 
    }); 
}