Corso C++ 23 - lezione 29

#pragma region IntelliSense_Fix
#ifdef __INTELLISENSE__
#include <print>
#include <string>
#include <chrono>
#endif
#pragma endregion

import std;



auto oggi() -> std::string {
    auto time_point_100ns = std::chrono::system_clock::now();
    auto time_point_gg = std::chrono::floor<std::chrono::days>(time_point_100ns);
    return std::format("{:%d/%m/%Y}", time_point_gg );
}

struct Movimento {
    std::string data{ oggi() };
    int importo{};
};

auto stampa_vector(const std::vector<Movimento> &vec) -> void
{
    for (auto mov : vec)
    {
        std::println("Data: {} - Importo: {}", mov.data, mov.importo);
    }
}

auto prepara_vector(std::vector<Movimento> &vec)
{
    if (!vec.empty()) //vec.size()>0     empty() sempre O(1)
    {
        vec.front().data = "1-1-2026";  //vec[0].data = ecc
        vec.front().importo = 1;

        vec.back().data = "31-12-2026";  //vec[vec.size()-1]
        vec.back().importo = 365;

    }

    if (vec.size() >= 10)
    {
        vec[9].data = "10-1-2026";
        vec[9].importo = 10;
    }



}

auto main() -> int
{
    //CREAZIONE
    // vector con zero elementi
    //std::vector<Movimento> movimenti{};

    //con lista di inizializzazione non vuota
    std::vector<Movimento> movimenti{
           {},
           {"12-01-2026", 340},
           Movimento{ "13-1-26", -800},
           Movimento{.data = "14-1-26", .importo = -200}
    };

    //AGGIUNGERE ELEMENTI
    movimenti.push_back(Movimento{"09-07-2026", -180 });
    movimenti.push_back({"09-07-2026", -360});
    movimenti.emplace_back("", 100);

    Movimento m{ "ULTIMO", -540 };
    movimenti.push_back(m);


    //auto [data, importo] = movimenti.emplace_back("09-07-2027", 300);
    //std::println("Il vector contiene ora {} elementi", movimenti.size());
    //std::println("Il vector ha ora una capienza di {} elementi", movimenti.capacity());

    //movimenti = std::vector<Movimento>();
    //movimenti.resize(10000);

    //for (int i = 0, old_capacity=movimenti.capacity(); i < 10000; i++)
    //{
    //  movimenti.push_back({});
    //  if (old_capacity < movimenti.capacity())
    //  {
    //      std::println("N. elementi: {}. Vecchia capacity: {} - nuova capacity: {}",
    //          movimenti.size(), old_capacity, movimenti.capacity());

    //      old_capacity = movimenti.capacity();
    //  }
    //}

    //movimenti.resize(100);
    //std::println("N. elementi: {}. Capacity: {}",
    //  movimenti.size(), movimenti.capacity());

    //INSERIMENTO
    movimenti.insert(movimenti.begin(), {"PRIMO", 100}); //movimenti[0]
    movimenti.insert(movimenti.begin() + 2, { "TERZO", 100 }); //movimenti[2]

    //diminuisco dopo le prove il numero di elementi clonati per non avere stampe troppo lunghe
    movimenti.insert(movimenti.begin() + 2, 5, { "CLONI DI TERZO", 10 });

    movimenti.insert(movimenti.end() - 2, movimenti.begin(), movimenti.begin() + 5);

    movimenti.insert(movimenti.begin(), { {"1", 0}, {"2", 0}, {"3", 0} });

    stampa_vector(movimenti);

    std::println("{}", std::string(50, '-'));

    auto it_prima = movimenti.begin();
    std::println("Con iteratore prima dell'espansione{}", it_prima->data);

     //disabilito inserimento dei 500 movimenti per non avere troppi elementi nel vector
    /*auto it =
        movimenti.insert(
            movimenti.begin() + 2,
            500,
            { "BLOCCO INSERITO", {}}
        );

    std::println("Data elemento che precede il blocco {}", (it - 1) -> data);
    std::println("Stringa del primo elemento elemento del blocco {}", it->data);*/

    //ora it_prima non è piu valido
    //std::println("Con iteratore  invalidato{}", it_prima->data);


    //stampa_vector(movimenti);

    //movimenti.resize(200);
    //std::println("size {} =  capacity {}", movimenti.size(), movimenti.capacity());

    //movimenti.shrink_to_fit();
    //std::println("size {} =  capacity {}", movimenti.size(), movimenti.capacity());


    /*movimenti.emplace(movimenti.begin() + 2, "data_emplace", 2000);
    stampa_vector(movimenti);*/

    //modifico alcuni dati per evidenziare i movimenti su cui agiro con i prossimi comandi
    //nel caso avessi bisogno di 'resettare' il vector per altre prove uso una funzione
    prepara_vector(movimenti);
    stampa_vector(movimenti);

    //ACCESSO AGLI ELEMENTI
    // - front() vedi funzione prepara_vector
    // - back() vedi funzione prepara_vector
    movimenti[10].importo = 999;
    movimenti.at(10).data = "4-4-1971";


    try {
        movimenti.at(100).importo = 222;
    }
    catch (...)
    {
        std::println("Problema!");
    }

    auto i_dati = movimenti.data();
    std::println("{}", i_dati[9].data);

    //SCANSIONE ELEMENTI

    std::println("{}", std::string(50, '*'));

    //begin()  end()
    for (auto it = movimenti.cbegin(); it != movimenti.cend(); it++)
    {
        //it->data = "lsdjffld"; NO! iteratore COSTANTE

        std::println("{} {}", it->data, it->importo);
    }

    std::println("{}", std::string(50, '='));

    for (auto it = movimenti.crbegin(); it != movimenti.crend(); it++)
    {
        //it->data = "lsdjffld"; NO! iteratore COSTANTE

        std::println("{} {}", it->data, it->importo);
    }


    //ranges
    for (const auto &mov: movimenti)
    {
        std::println("{} {}", mov.data, mov.importo);
    }

    //LEGACY, NON USARE
    for(std::size_t i=0; i<movimenti.size(); i++)
    {
        std::println("{} {}", movimenti[i].data, movimenti[i].importo);
    }


    //ELIMINARE ELEMENTI
    system("cls");
    std::println("{}", std::string(50, '|'));
    movimenti.pop_back();
    stampa_vector(movimenti);
    std::println("{}", std::string(50, '|'));

    auto it = movimenti.erase(movimenti.begin(), movimenti.begin() + 3);
    stampa_vector(movimenti);

    std::println("{}", it->data);

    std::vector<int> v = { 1, 3, 2, 3, 4, 3, 5 };
    v.erase(std::remove(v.begin(), v.end(), 3), v.end()); //[1, 2, 5, 3, 5]

    std::erase(v, 3);

    std::erase_if(v, [](int n) { return n % 2 == 0; });

    std::vector<Movimento> movimenti_copia(movimenti);
    movimenti_copia.erase(movimenti_copia.begin(), movimenti_copia.begin() + 10);
    system("cls");
    stampa_vector(movimenti_copia);

    movimenti.swap(movimenti_copia);
    stampa_vector(movimenti);
    std::println("{}", std::string(50, '-'));
    stampa_vector(movimenti_copia);


    //CARATTERISTICHE MODERNE
    std::list<Movimento> lista_movimenti{
           {},
           {"12-01-2026", 340},
           Movimento{ "13-1-26", -800},
           Movimento{.data = "14-1-26", .importo = -200}
    };

    std::vector<Movimento> movimenti3(std::from_range, lista_movimenti);

    movimenti3.assign_range(lista_movimenti);
    movimenti.append_range(lista_movimenti);
    movimenti.insert_range(movimenti.begin() + 5, lista_movimenti);

    //
    //
    ////std::vector<Movimento> movimenti2(10);
    //std::vector<Movimento> movimenti2(10, {"1-1-2020", 500});
    //for (auto [data, importo] : movimenti2)
    //{
    //  std::println("Data: {} - Importo: {}", data, importo);
    //}


    //copiando da un altra collezione
    //array tradizionale di movimenti
    //Movimento mov2[]{ {"1-1-26", 200}, {"1-1-26", 300}, {"1-1-26", -300}, {"2-1-26", 1200} };

}