Esercizio - Classe Image con buffer dinamico (terzo appello 2023-24, programmazione)

#ifndef IMAGE_H
#define IMAGE_H

// Immagine di w x h pixel, ciascuno un int, memorizzati per righe in un buffer allocato dinamicamente.
// Invarianti: il buffer ha esattamente w * h elementi; data_ e' nullptr se e solo se w == 0 (e h == 0),
// stato che si ha solo in un oggetto spostato (ogni costruzione normale richiede dimensioni positive).
class Image {
public:
    Image(int width = 100, int height = 100);          // dimensioni di default 100 x 100; lancia se <= 0
    Image(const Image& other);                         // copia profonda
    Image& operator=(const Image& other);
    Image(Image&& other) noexcept;                     // spostamento: other diventa 0 x 0
    Image& operator=(Image&& other) noexcept;
    ~Image();

    void set(int value);                               // scrive value in tutti i pixel
    // Cambia le dimensioni. Se aumentano, i pixel nuovi copiano il pixel esistente piu' vicino
    // (le coordinate fuori dall'immagine vecchia sono "bloccate" al bordo): in un'immagine uniforme
    // restano tutti uguali. Se diminuiscono, si tiene l'angolo in alto a sinistra.
    void resize(int new_width, int new_height);

    int width() const { return w_; }
    int height() const { return h_; }
    int& at(int x, int y) { return data_[y * w_ + x]; }              // x = colonna, y = riga
    int at(int x, int y) const { return data_[y * w_ + x]; }

private:
    void swap(Image& other) noexcept;
    int w_;
    int h_;
    int* data_;
};

#endif // IMAGE_H

#include "image.h"
#include <algorithm>
#include <stdexcept>
#include <utility>

Image::Image(int width, int height) : w_{width}, h_{height}, data_{nullptr}
{
    if (width <= 0 || height <= 0) throw std::invalid_argument("Image: dimensioni non positive");
    data_ = new int[static_cast<std::size_t>(w_) * h_]{};         // pixel inizializzati a 0
}

Image::Image(const Image& other)
    : w_{other.w_}, h_{other.h_}, data_{other.data_ ? new int[static_cast<std::size_t>(other.w_) * other.h_] : nullptr}
{
    std::copy(other.data_, other.data_ + static_cast<std::size_t>(w_) * h_, data_);
}

Image& Image::operator=(const Image& other)
{
    Image copy{other};                  // puo' lanciare: *this e' ancora intatto
    swap(copy);                         // commit senza eccezioni; la vecchia memoria la libera copy
    return *this;
}

Image::Image(Image&& other) noexcept : w_{0}, h_{0}, data_{nullptr}
{
    swap(other);                        // other resta 0 x 0, valido e distruggibile
}

Image& Image::operator=(Image&& other) noexcept
{
    swap(other);
    return *this;
}

Image::~Image() { delete[] data_; }

void Image::set(int value)
{
    std::fill(data_, data_ + static_cast<std::size_t>(w_) * h_, value);
}

void Image::resize(int new_width, int new_height)
{
    if (new_width <= 0 || new_height <= 0) throw std::invalid_argument("Image::resize: dimensioni non positive");
    Image next{new_width, new_height};                              // buffer nuovo: se new fallisce, nulla cambia
    for (int y = 0; y < new_height; ++y)
        for (int x = 0; x < new_width; ++x)
            next.at(x, y) = at(std::min(x, w_ - 1), std::min(y, h_ - 1));   // coordinate bloccate al bordo
    swap(next);                                                    // il vecchio buffer passa a next e muore con lui
}

void Image::swap(Image& other) noexcept
{
    std::swap(w_, other.w_);
    std::swap(h_, other.h_);
    std::swap(data_, other.data_);
}

#include <iostream>
#include <utility>
#include "image.h"

namespace {
void print(const char* title, const Image& im)
{
    std::cout << title << " (" << im.width() << "x" << im.height() << ")\n";
    for (int y = 0; y < im.height(); ++y) {
        std::cout << "  ";
        for (int x = 0; x < im.width(); ++x) std::cout << im.at(x, y) << (x + 1 < im.width() ? ' ' : '\n');
    }
}
}

int main()
{
    Image def;                                              // costruttore con argomenti di default
    std::cout << "default: " << def.width() << "x" << def.height() << '\n';
    def.set(7);
    def.resize(150, 120);                                   // immagine uniforme: i pixel nuovi valgono ancora 7
    std::cout << "dopo resize: " << def.width() << "x" << def.height()
              << ", pixel(149,119) = " << def.at(149, 119) << ", pixel(0,0) = " << def.at(0, 0) << '\n';

    Image im{3, 2};
    for (int y = 0; y < 2; ++y)
        for (int x = 0; x < 3; ++x) im.at(x, y) = x + 10 * y;
    print("3x2", im);
    im.resize(5, 3);                                        // allarga: i pixel nuovi copiano il bordo
    print("resize 5x3", im);
    im.resize(2, 1);                                        // restringe: resta l'angolo in alto a sinistra
    print("resize 2x1", im);

    Image a{2, 2};
    a.set(1);
    Image b = a;                                            // copia: buffer separati
    a.set(9);
    std::cout << "copia: a(0,0) = " << a.at(0, 0) << ", b(0,0) = " << b.at(0, 0) << '\n';
    b = a;                                                  // assegnamento di copia
    std::cout << "dopo b = a: b(1,1) = " << b.at(1, 1) << '\n';
    Image& same = b;
    b = same;                                               // auto-assegnamento innocuo
    Image c = std::move(a);                                 // spostamento: a diventa 0x0
    std::cout << "spostata: c = " << c.width() << "x" << c.height() << ", a = " << a.width() << "x" << a.height() << '\n';
    a = std::move(c);                                       // assegnamento di spostamento
    std::cout << "a = " << a.width() << "x" << a.height() << ", c = " << c.width() << "x" << c.height() << '\n';
}

default: 100x100
dopo resize: 150x120, pixel(149,119) = 7, pixel(0,0) = 7
3x2 (3x2)
  0 1 2
  10 11 12
resize 5x3 (5x3)
  0 1 2 2 2
  10 11 12 12 12
  10 11 12 12 12
resize 2x1 (2x1)
  0 1
copia: a(0,0) = 9, b(0,0) = 1
dopo b = a: b(1,1) = 9
spostata: c = 2x2, a = 0x0
a = 2x2, c = 0x0