STL - algoritmi, predicati e lambda

template<typename In, typename T>
// In: iteratore di input; T deve essere confrontabile con *In
In find(In first, In last, const T& val)
{
    while (first != last && *first != val) ++first;
    return first;
}

void f(vector<int>& v, int x)      { auto p = find(v.begin(), v.end(), x); if (p != v.end()) { /* trovato */ } }
void f(list<string>& v, string x)  { auto p = find(v.begin(), v.end(), x); if (p != v.end()) { /* trovato */ } }

template<typename In, typename Pred>
In find_if(In first, In last, Pred pred)
{
    while (first != last && !pred(*first)) ++first;
    return first;
}

class Larger_than {
    double v;
public:
    Larger_than(double vv) : v{vv} {}                 // salvataggio dell'argomento
    bool operator()(double x) const { return x > v; } // confronto
};

#include <algorithm>
#include <iostream>
#include <list>
#include <vector>
using namespace std;

// ---- 1) predicato = funzione che restituisce bool ----
bool odd(int x) { return x % 2; }

// ---- 2) il criterio "maggiore di un valore" con una variabile globale (da evitare) ----
double v_val;
bool larger_than_v(double x) { return x > v_val; }

// ---- 3) function object: il valore e' un dato membro ----
class Larger_than {
    double v;
public:
    Larger_than(double vv) : v{vv} {}                 // salva l'argomento
    bool operator()(double x) const { return x > v; } // function call operator
};

// versione delle slide: operator()(int) -> converte i double in int (errore)
class Larger_than_int {
    int v;
public:
    Larger_than_int(int vv) : v{vv} {}
    bool operator()(int x) const { return x > v; }
};

int main()
{
    vector<int> vi{2, 4, 7, 8, 9};
    auto p = find_if(vi.begin(), vi.end(), odd);      // si passa il NOME della funzione (puntatore)
    cout << "primo dispari: " << *p << '\n';
    cout << "nessun dispari in [2,4): " << (find_if(vi.begin(), vi.begin() + 2, odd) == vi.begin() + 2) << '\n';

    list<double> ld{30.5, 31.5, 40.0};

    v_val = 31;                                        // scrittura sulla variabile globale
    auto q = find_if(ld.begin(), ld.end(), larger_than_v);
    cout << "globale, > 31: " << *q << '\n';

    auto r = find_if(ld.begin(), ld.end(), Larger_than(31));    // function object
    cout << "function object, > 31: " << *r << '\n';
    auto s = find_if(ld.begin(), ld.end(), Larger_than(35));
    cout << "function object, > 35: " << *s << '\n';

    auto t = find_if(ld.begin(), ld.end(), Larger_than_int(31));   // x convertito a int: 31.5 -> 31
    cout << "versione con int, > 31: " << *t << "  (31.5 e' stato scartato!)\n";

    int soglia = 35;
    auto u = find_if(ld.begin(), ld.end(), [soglia](double x) { return x > soglia; });   // lambda
    cout << "lambda, > soglia: " << *u << '\n';

    cout << "count(odd) = " << count_if(vi.begin(), vi.end(), odd)
         << ", count(9) = " << count(vi.begin(), vi.end(), 9) << '\n';
}

primo dispari: 7
nessun dispari in [2,4): 1
globale, > 31: 31.5
function object, > 31: 31.5
function object, > 35: 40
versione con int, > 31: 40  (31.5 e' stato scartato!)
lambda, > soglia: 40
count(odd) = 2, count(9) = 1

#include <algorithm>
#include <iostream>
#include <vector>
using namespace std;

void func5(vector<double>& v, const double& epsilon)
{
    transform(v.begin(), v.end(), v.begin(),
              [epsilon](double d) -> double {           // epsilon catturata per valore
                  if (d < epsilon) return 0;
                  else return d;
              });
}

int main()
{
    vector<double> v{0.001, 2.5, 0.0002, 7.0};
    func5(v, 0.01);
    for (double d : v) cout << d << ' ';
    cout << '\n';

    int a = 1, b = 10;
    auto per_valore = [=]() { return a + b; };          // copia al momento della creazione
    auto per_ref = [&]() { return a + b; };             // vede i valori correnti
    a = 100;
    cout << "per valore: " << per_valore() << ", per riferimento: " << per_ref() << '\n';

    int contatore = 0;
    for_each(v.begin(), v.end(), [&contatore](double) { ++contatore; });   // modifica la variabile locale
    cout << "contatore = " << contatore << '\n';

    int soglia = 5;
    auto prima = count_if(v.begin(), v.end(), [soglia](double d) { return d > soglia; });
    soglia = 1;                                         // la lambda ha la sua copia: non cambia
    auto dopo = count_if(v.begin(), v.end(), [soglia](double d) { return d > soglia; });
    cout << "maggiori di 5: " << prima << ", maggiori di 1 (nuova lambda): " << dopo << '\n';
}

0 2.5 0 7
per valore: 11, per riferimento: 110
contatore = 4
maggiori di 5: 1, maggiori di 1 (nuova lambda): 2

template<typename Ran>
// Ran deve avere un random_access_iterator
void sort(Ran first, Ran last);                    // ordina con operator<

template<typename Ran, typename Cmp>
void sort(Ran first, Ran last, Cmp cmp);          // ordina con un criterio

#include <algorithm>
#include <cstring>
#include <iostream>
#include <string>
#include <vector>
using namespace std;

struct Record {
    string name;
    char addr[24];
};

struct Cmp_by_name {
    bool operator()(const Record& a, const Record& b) const { return a.name < b.name; }
};
struct Cmp_by_addr {
    bool operator()(const Record& a, const Record& b) const { return strncmp(a.addr, b.addr, 24) < 0; }
};

Record make(const char* n, const char* a)
{
    Record r;
    r.name = n;
    strncpy(r.addr, a, sizeof(r.addr) - 1);
    r.addr[sizeof(r.addr) - 1] = '\0';
    return r;
}

void stampa(const char* titolo, const vector<Record>& vr)
{
    cout << titolo << ':';
    for (const Record& r : vr) cout << ' ' << r.name << '(' << r.addr << ')';
    cout << '\n';
}

int main()
{
    vector<Record> vr{make("Carla", "via Roma 3"), make("Anna", "via Dante 9"), make("Bruno", "via Alfieri 1")};

    sort(vr.begin(), vr.end(), Cmp_by_name());         // function object
    stampa("per nome", vr);
    sort(vr.begin(), vr.end(), Cmp_by_addr());
    stampa("per indirizzo", vr);

    sort(vr.begin(), vr.end(),                          // criterio per nome con una lambda
         [](const Record& a, const Record& b) { return a.name < b.name; });
    stampa("lambda per nome", vr);

    vector<int> v{9, 4, 7, 1, 8, 3};
    sort(v.begin(), v.begin() + v.size() / 2);          // solo la prima meta': 9 4 7 -> 4 7 9
    for (int x : v) cout << x << ' ';
    cout << '\n';
    sort(v.begin(), v.end(), [](int a, int b) { return a > b; });   // decrescente
    for (int x : v) cout << x << ' ';
    cout << '\n';
}

per nome: Anna(via Dante 9) Bruno(via Alfieri 1) Carla(via Roma 3)
per indirizzo: Bruno(via Alfieri 1) Anna(via Dante 9) Carla(via Roma 3)
lambda per nome: Anna(via Dante 9) Bruno(via Alfieri 1) Carla(via Roma 3)
4 7 9 1 8 3
9 8 7 4 3 1

template<typename In, typename Out>
Out copy(In first, In last, Out res)
{
    while (first != last) { *res = *first; ++res; ++first; }
    return res;
}

void f(vector<double>& vd, list<int>& li)
{
    if (vd.size() < li.size()) error("Target container too small\n");
    copy(li.begin(), li.end(), vd.begin());
}

#include <algorithm>
#include <functional>
#include <iostream>
#include <iterator>
#include <list>
#include <numeric>
#include <vector>
using namespace std;

template <typename C>
void stampa(const char* t, const C& c)
{
    cout << t << ':';
    for (const auto& x : c) cout << ' ' << x;
    cout << '\n';
}

int main()
{
    vector<int> v{5, 3, 5, 1, 3, 3, 8};
    cout << "find(8): posizione " << find(v.begin(), v.end(), 8) - v.begin()
         << ", find(99) == end: " << (find(v.begin(), v.end(), 99) == v.end()) << '\n';
    cout << "count(3) = " << count(v.begin(), v.end(), 3) << '\n';

    // copy: la destinazione deve avere SPAZIO
    list<int> l(v.size());                              // 7 elementi a 0
    copy(v.begin(), v.end(), l.begin());
    stampa("copy in list", l);

    vector<int> grandi;                                 // vuoto: si usa back_inserter
    copy_if(v.begin(), v.end(), back_inserter(grandi), [](int x) { return x > 3; });
    stampa("copy_if > 3 (back_inserter)", grandi);

    vector<int> v2(v.size());                           // come nelle slide: dimensione fissa
    copy_if(v.begin(), v.end(), v2.begin(), [](int x) { return x > 3; });
    stampa("copy_if in v2 gia' dimensionato", v2);      // gli elementi non scritti restano 0

    sort(v.begin(), v.end());
    stampa("sort", v);
    vector<int> senza;
    unique_copy(v.begin(), v.end(), back_inserter(senza));
    stampa("unique_copy", senza);

    vector<int> a{1, 4, 9}, b{2, 3, 10}, m(6);
    merge(a.begin(), a.end(), b.begin(), b.end(), m.begin());
    stampa("merge", m);

    auto er = equal_range(v.begin(), v.end(), 3);       // v e' ordinato: ricerca binaria
    cout << "equal_range(3): " << er.second - er.first << " elementi, dalla posizione " << er.first - v.begin() << '\n';

    cout << "equal(a,a) = " << equal(a.begin(), a.end(), a.begin()) << '\n';
    cout << "accumulate = " << accumulate(a.begin(), a.end(), 100) << " (100 + 1 + 4 + 9)\n";
    cout << "prodotto con op: " << accumulate(a.begin(), a.end(), 1, multiplies<int>()) << '\n';
    cout << "inner_product = " << inner_product(a.begin(), a.end(), b.begin(), 0) << " (1*2 + 4*3 + 9*10)\n";
}

find(8): posizione 6, find(99) == end: 1
count(3) = 3
copy in list: 5 3 5 1 3 3 8
copy_if > 3 (back_inserter): 5 5 8
copy_if in v2 gia' dimensionato: 5 5 8 0 0 0 0
sort: 1 3 3 3 5 5 8
unique_copy: 1 3 5 8
merge: 1 2 3 4 9 10
equal_range(3): 3 elementi, dalla posizione 1
equal(a,a) = 1
accumulate = 114 (100 + 1 + 4 + 9)
prodotto con op: 36
inner_product = 104 (1*2 + 4*3 + 9*10)