Jak złożyć pojemnik STL?

Question

Potrzebuję analogu funkcji Haskella do funkcji foldl, aby złożyć wszystkie pojemniki STL. Oczekiwany podpis jest następujący:

template Iterator, FoldingFunction, Result 
Result foldl(
    Iterator begin, 
    Iterator end, 
    FoldingFunction f, 
    Result initValue); 

Standardowy STL nie ma takiej funkcji. Czy Boost ma jakieś?

Wiem, że jest to łatwe do wdrożenia, ale chciałbym się dowiedzieć, czy istnieje jakaś gotowa, wystandaryzowana implementacja.

I jeszcze jedno pytanie: jak zwykle składa się listy danych w C++/STL?

Answer 1

STL ma taką funkcję: std::accumulate. Jednak jest w nagłówku <numeric>, a nie <algorithm>.

Faktycznie Wikipedia page on "Fold" już wymienione funkcje foldl/ na większości języków programowania, w tym C++.

Answer 2

Czy obejrzałeś std::accumulate w nagłówku <numeric>?

Answer 3

Mimo, że std:: accumulate wydaje się być najlepszym kandydatem, myślę, że wymaganie to można osiągnąć również za pomocą starego dobrego for_each.

Wziąłem przykłady z linku w answer of KennyTM i przetłumaczyłem je wszystkie na for_each. The full code is posted at codepad po jakiś fragment:

struct result_functor { 
    result_functor(int initial, int multiplier) : 
     result_(initial), multiplier_(multiplier) { 
    } 
    int operator()(int x) { 
     result_ += multiplier_ * x; 
     return result_; 
    } 
    int result_; 
    int multiplier_; 
}; 

const int init = 100; 
const int numbers[] = { 10, 20, 30 }; 

const int accum_sum = std::accumulate(numbers, numbers + 3, init); 
const result_functor for_sum = for_each( 
    numbers, numbers + 3, result_functor(init, +1)); 
assert(accum_sum == for_sum.result_); 

Answer 4

oto moja realizacja za pomocą std :: gromadzić

template<typename collection, typename operation> 
typename collection::value_type reduce(collection col, operation op) 
{ 
    return accumulate(col.begin(), col.end(), typename collection::value_type(), op); 
} 

reduce środki te krotnie w Haskell. A ten szablon funkcji może sprawić, że program będzie bardziej funkcjonalny :)

Answer 5

dlaczego nie tylko;

b_t foldl(b_t (*f)(b_t,a_t),b_t base_case,a_t * in_list){ 
int l = sizeof(inList)/sizeof(a_t); 
b_t carry = base_case; 
for(int i = 0;i<l;i++){ 
    carry = f(carry,in_list[i]); 
    } 
return carry; 
} 

lub rekurencyjnie; // może mógłbyś mi pomóc z poprawną składnią ...

b_t foldl(b_t (*f)(b_t,a_t),b_t base_case,a_t * in_list){ 
return foldl(f,f(base_case,in_list[0]),in_list + 1);  
}