Esercizio - Quiz e domande su spostamento, passaggio dei parametri e contenitori STL (primo appello 2023-24, teoria)

#include <algorithm>
#include <iostream>
#include <utility>
#include <vector>

// Un array dinamico di int che conta quanti ELEMENTI vengono copiati: cosi' si vede
// la differenza di costo tra copia e spostamento.
class Buffer {
public:
    static long element_copies;                           // contatore globale di copie di elementi

    Buffer() : n_{0}, data_{nullptr} {}                   // costruttore di default
    explicit Buffer(std::size_t n) : n_{n}, data_{new int[n]{}} {}
    ~Buffer() { delete[] data_; }                         // distruttore

    Buffer(const Buffer& o) : n_{o.n_}, data_{new int[o.n_]}          // copia profonda: costa O(n)
    {
        std::copy(o.data_, o.data_ + n_, data_);
        element_copies += static_cast<long>(n_);
    }
    Buffer& operator=(const Buffer& o)
    {
        if (this != &o) {
            int* fresh = new int[o.n_];
            std::copy(o.data_, o.data_ + o.n_, fresh);
            element_copies += static_cast<long>(o.n_);
            delete[] data_;
            data_ = fresh;
            n_ = o.n_;
        }
        return *this;
    }

    Buffer(Buffer&& o) noexcept : n_{o.n_}, data_{o.data_}            // spostamento: "ruba" il buffer, costa O(1)
    {
        o.n_ = 0;
        o.data_ = nullptr;                                            // la sorgente resta valida e vuota
    }
    Buffer& operator=(Buffer&& o) noexcept
    {
        if (this != &o) {
            delete[] data_;                                           // libera il proprio buffer
            data_ = o.data_;                                          // prende quello della sorgente
            n_ = o.n_;
            o.data_ = nullptr;
            o.n_ = 0;
        }
        return *this;
    }

    std::size_t size() const { return n_; }

private:
    std::size_t n_;
    int* data_;
};
long Buffer::element_copies = 0;

Buffer make(std::size_t n) { Buffer b{n}; return b; }                 // restituzione per valore

int main()
{
    Buffer a{1000};
    std::cout << "costruiti 1000 elementi, copie finora: " << Buffer::element_copies << '\n';

    Buffer b = a;                                                     // costruttore di COPIA (a e' un lvalue)
    std::cout << "copia:      copie = " << Buffer::element_copies << ", a.size = " << a.size() << '\n';

    Buffer c = std::move(a);                                          // costruttore di SPOSTAMENTO
    std::cout << "spostamento: copie = " << Buffer::element_copies << ", a.size = " << a.size()
              << ", c.size = " << c.size() << '\n';

    Buffer d;
    d = std::move(b);                                                 // assegnamento di SPOSTAMENTO
    std::cout << "assegn. spost.: copie = " << Buffer::element_copies << ", b.size = " << b.size()
              << ", d.size = " << d.size() << '\n';

    Buffer e;
    e = c;                                                            // assegnamento di COPIA (c e' un lvalue)
    std::cout << "assegn. copia: copie = " << Buffer::element_copies << '\n';

    Buffer f = make(500);                                             // temporaneo: spostamento o elisione, nessuna copia
    std::cout << "da funzione: copie = " << Buffer::element_copies << ", f.size = " << f.size() << '\n';

    std::vector<Buffer> v;                                            // il vector, riallocando, sposta se e' noexcept
    long prima = Buffer::element_copies;
    for (int i = 0; i < 5; ++i) v.push_back(Buffer{100});            // rvalue: push_back(Buffer&&)
    std::cout << "5 push_back di temporanei: copie aggiunte = " << Buffer::element_copies - prima << '\n';
}

costruiti 1000 elementi, copie finora: 0
copia:      copie = 1000, a.size = 1000
spostamento: copie = 1000, a.size = 0, c.size = 1000
assegn. spost.: copie = 1000, b.size = 0, d.size = 1000
assegn. copia: copie = 2000
da funzione: copie = 2000, f.size = 500
5 push_back di temporanei: copie aggiunte = 0

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

void per_valore(int x)            { x = 100; cout << "  nella funzione x = " << x << '\n'; }   // lavora su una COPIA
void per_riferimento(int& x)      { x = 100; }                 // lavora sull'originale
void per_const_ref(const int& x)  { cout << "  const&: leggo " << x << " senza copiare\n"; }
void per_puntatore(int* p)        { if (p) *p = 100; }         // lavora sull'originale, puo' essere nullptr
void per_ptr_const(const int* p)  { cout << "  const*: leggo " << *p << '\n'; }

void somma_grande(const vector<int>& v, int& totale)           // uso tipico: grande in ingresso, risultato in uscita
{
    totale = 0;
    for (int x : v) totale += x;
}

void riassegna_puntatore(int* p, int* altro)                   // il puntatore e' copiato: la riassegnazione e' locale
{
    p = altro;
    cout << "  nella funzione p punta ad altro: " << (p == altro) << '\n';
}

int main()
{
    int a = 1, b = 1, c = 1, d = 1;
    per_valore(a);
    per_riferimento(b);
    per_puntatore(&c);
    cout << "dopo le chiamate: a = " << a << " (valore), b = " << b << " (riferimento), c = " << c
         << " (puntatore)\n";

    per_const_ref(a);
    per_ptr_const(&b);
    per_puntatore(nullptr);                                    // lecito: il puntatore puo' non puntare a niente
    // per_riferimento(5);                                     // errore: un rvalue non si lega a int&
    per_const_ref(5);                                          // ok: const& si lega anche a un temporaneo

    vector<int> v{1, 2, 3, 4};
    int totale;
    somma_grande(v, totale);
    cout << "somma = " << totale << '\n';

    int *p = &c, *q = &d;
    riassegna_puntatore(p, q);                                 // p, nel main, e' ancora &c
    cout << "p punta ancora a c: " << (p == &c) << '\n';
}

  nella funzione x = 100
dopo le chiamate: a = 1 (valore), b = 100 (riferimento), c = 100 (puntatore)
  const&: leggo 1 senza copiare
  const*: leggo 100
  const&: leggo 5 senza copiare
somma = 10
  nella funzione p punta ad altro: 1
p punta ancora a c: 1

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

// Una sola funzione per qualsiasi contenitore: parla solo con gli iteratori [first, last)
template <typename Iterator>
int conta_maggiori(Iterator first, Iterator last, int soglia)
{
    int n = 0;
    for (Iterator p = first; p != last; ++p)
        if (*p > soglia) ++n;
    return n;
}

int main()
{
    vector<int> v{5, 12, 7, 20};
    list<int> l{3, 30, 8};
    int a[] = {50, 1, 60};

    cout << conta_maggiori(v.begin(), v.end(), 6) << ' '       // vector: 3
         << conta_maggiori(l.begin(), l.end(), 6) << ' '       // list: 2
         << conta_maggiori(a, a + 3, 6) << '\n';               // array C: 2

    // gli algoritmi STL usano la stessa interfaccia
    cout << (find(v.begin(), v.end(), 7) != v.end()) << (find(l.begin(), l.end(), 7) != l.end()) << '\n';  // 1 0

    // insert / erase: stessa notazione, costi diversi (vector sposta, list no)
    v.insert(v.begin() + 1, 99);
    l.insert(++l.begin(), 99);
    cout << v[1] << ' ' << *++l.begin() << '\n';
}