How can I use C ++ algorithms?

Question

Consider the following C ++ program to print the smallest contiguous difference given by a vector of numbers:

#include <iostream>
#include <iterator>
#include <numeric>
#include <vector>

int main()
{
    std::vector<int> numbers = { 10, 1, 43, 59, 78, 46, 63, 12 };

    std::vector<int> deltas;
    std::adjacent_difference( numbers.begin(),
                              numbers.end(),
                              std::back_inserter( deltas ) );

    auto minEl = std::min_element( deltas.begin() + 1,
                                   deltas.end() );

    std::cout << *minEl;
}

I want to get rid of the intermediate vector deltas, but I continue to use std::adjacent_differenceand std::min_element(instead of looping myself).

In functional languages, the definition of intermediate data structures is often called a deforestation (or "fusion"). Is there a general way to do the same in C ++?

, - , , min_element . . , - (Boost?) - ?

Answer 1

( ) , , , :

#include <iostream>
#include <iterator>
#include <numeric>
#include <vector>
#include <algorithm>

template <typename T>
struct min
{
    typedef T element_type;
    min(int& min) : min_(min) { }
    min& operator *() { return *this; }
    min& operator=(const T& t)
    {
        if (first_)
            min_ = t, first_ = false;
        else if (t < min_)
            min_ = t;
    }
    min& operator++() { return *this; }
    bool first_ = true;
    T& min_;
};

template <typename Iterator>
struct skip_take  // i.e. skip some elements, take some elements...
{
    skip_take(Iterator i, size_t skip, size_t take = size_t(-1))
      : i_(i), skip_(skip), take_(take)
    { }
    skip_take& operator *() { return *this; }
    skip_take& operator=(const typename Iterator::element_type& t)
        { if (skip_ == 0 && take_) *i_ = t; }
    skip_take& operator++()
        { if (skip_) --skip_; else if (take_) --take_, ++i_; return *this; }
    Iterator& i_;
    size_t skip_, take_;
};

int main()
{
    std::vector<int> numbers = { 10, 1, 43, 59, 78, 46, 63, 12 };

    int result;
    std::adjacent_difference(numbers.begin(), numbers.end(),
                             skip_take<min<int>>(min<int>(result), 1));

    std::cout << result << '\n';
}

( ideone.com)

, ++ ( - ) - , ) ( , ). "" ++, , , , .

Answer 2

. , . , , , afor loop - .

#include <vector>
#include <iostream>
#include <numeric>

using namespace std;

class Something;

struct SomethingIter {
   SomethingIter(Something* p) : parent(p) {};
   SomethingIter& operator++();
   int& operator* ();
private:
   Something* parent;
};

class Something {
public:   
   Something() : minset(false), first(true), min(0) { }
   SomethingIter storage() {
      SomethingIter ret(this);
      return ret;
   }
   void set() {
      if (first) { first = false; }
      else if (!minset || s < min) {
     min = s;
     minset = true;
      }
   }
   int& value() { return s; }
   int getMin() const { return min; }
private:
   bool first;
   bool minset;
   int min;
   int s;
};

SomethingIter& SomethingIter::operator++() {
   parent->set();
   return *this;
}

int& SomethingIter::operator* () {
   return parent->value();
}


int main() {
   Something s;
   vector<int> values{ 0, 2, 5 };
   adjacent_difference(values.begin(), values.end(), s.storage());
   cout << "min: " << s.getMin() << endl;
   return 0;
}

?

:

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

using namespace std;

int minDiff(const vector<int>& values) {
   size_t len = values.size();
   if (len < 2) { throw runtime_error("Invalid vector"); }
   int mindiff = values[1] - values[0];
   for (size_t i = 2; i<len; ++i) {
      int diff = values[i] - values[i-1];
      if (diff < mindiff) { mindiff = diff; }
   }
   return mindiff;
}

int main() {
   vector<int> values{0, 2, 5};  
   cout << minDiff(values) << endl;      
   return 0;
}

:

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

using namespace std;

int main() {
   vector<string> A{"AB", "BA", "AAA"};

   unsigned int sum = 0;
   for_each (A.begin(), A.end(), [&sum](const string& s) {
     if (s[0] == 'A') { sum += s.length(); } });
   cout << sum << endl;


   return 0;
}