// Cuenta las reservas con new[] y las liberaciones con delete[] de todo el programa.
// Reemplaza esos operadores globales, así que se incluye en un solo .cpp de cada programa.
#ifndef ALLOC_COUNT_H
#define ALLOC_COUNT_H

#include <cstddef>
#include <new>

inline std::size_t& array_news() {
    static std::size_t count = 0;
    return count;
}

inline std::size_t& array_deletes() {
    static std::size_t count = 0;
    return count;
}

void* operator new[](std::size_t bytes) {
    ++array_news();
    return ::operator new(bytes);
}

void operator delete[](void* block) noexcept {
    if (block != nullptr) {
        ++array_deletes();
    }
    ::operator delete(block);
}

void operator delete[](void* block, std::size_t) noexcept {
    if (block != nullptr) {
        ++array_deletes();
    }
    ::operator delete(block);
}

#endif

// new T[n] construye los n elementos al reservar, aunque todavía nadie los use.
#include <iostream>

class Counted {
public:
    Counted() {
        constructed()++;
    }
    ~Counted() {
        destroyed()++;
    }
    static int& constructed() {
        static int count = 0;
        return count;
    }
    static int& destroyed() {
        static int count = 0;
        return count;
    }
};

void report(const char* step) {
    std::cout << step << ": construidos=" << Counted::constructed()
              << " destruidos=" << Counted::destroyed() << "\n";
}

int main() {
    Counted* items = new Counted[1000];
    report("después de new[]");
    delete[] items;
    report("después de delete[]");
    return 0;
}

// IntBuffer convertido en template: arreglo de tamaño fijo, de cualquier tipo T.
#ifndef BUFFER_H
#define BUFFER_H

#include <cassert>
#include <cstddef>
#include <utility>

// Exige que T tenga constructor sin argumentos, porque new T[size]() construye todos los
// elementos al reservar, y que se pueda asignar, porque la copia copia elemento por elemento.
//
// Invariante: data_ == nullptr si y solo si size_ == 0.
template <typename T>
class Buffer {
public:
    explicit Buffer(std::size_t size) : data_(size == 0 ? nullptr : new T[size]()), size_(size) {}

    ~Buffer() {
        delete[] data_;
    }

    Buffer(const Buffer& other) : Buffer(other.size_) {
        for (std::size_t i = 0; i < size_; i++) {
            data_[i] = other.data_[i];
        }
    }

    Buffer& operator=(const Buffer& other) {
        Buffer copy(other);
        swap(copy);
        return *this;
    }

    Buffer(Buffer&& other) noexcept : data_(other.data_), size_(other.size_) {
        other.data_ = nullptr;
        other.size_ = 0;
    }

    Buffer& operator=(Buffer&& other) noexcept {
        Buffer taken(std::move(other));
        swap(taken);
        return *this;
    }

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

    T& at(std::size_t index) {
        assert(index < size_);
        return data_[index];
    }

    const T& at(std::size_t index) const {
        assert(index < size_);
        return data_[index];
    }

    void swap(Buffer& other) noexcept {
        std::swap(data_, other.data_);
        std::swap(size_, other.size_);
    }

    void check_invariants() const {
        assert((data_ == nullptr) == (size_ == 0));
    }

private:
    T* data_;
    std::size_t size_;
};

#endif

// Ayuda mínima para las pruebas: anuncia cada prueba y confirma que todas terminaron.
#ifndef CHECK_H
#define CHECK_H

#include <iostream>

template <typename Test>
void run_test(const char* name, Test test) {
    test();
    std::cout << "ok " << name << "\n";
}

#endif

// Copia profunda y copy and swap, con las reservas contadas.
#include <iostream>

#include "alloc_count.h"
#include "int_buffer.h"

void report(const char* step, const IntBuffer& a, const IntBuffer& b) {
    std::cout << step << ": a.at(0)=" << a.at(0) << " b.at(0)=" << b.at(0)
              << " | new[]=" << array_news() << " delete[]=" << array_deletes() << "\n";
}

int main() {
    IntBuffer a(3);
    a.at(0) = 10;
    IntBuffer b(a);
    report("copia", a, b);

    b.at(0) = 99;
    report("cambio b", a, b);

    IntBuffer c(5);
    c.at(0) = 7;
    b = c;
    report("b = c", a, b);
    std::cout << "b.size()=" << b.size() << "\n";

    IntBuffer& same = b;
    b = same;
    report("b = b", a, b);
    std::cout << "b.size()=" << b.size() << "\n";
    return 0;
}

// Declarar un destructor apaga el movimiento implícito: "mover" termina copiando.
#include <iostream>
#include <utility>

#include "traced.h"

class OnlyMember {
public:
    Traced member{"m"};
};

class WithDestructor {
public:
    ~WithDestructor() {}
    Traced member{"m"};
};

int main() {
    std::cout << "sin destructor declarado:\n";
    OnlyMember a;
    OnlyMember b = std::move(a);
    std::cout << "con destructor declarado:\n";
    WithDestructor c;
    WithDestructor d = std::move(c);
    std::cout << "fin de main\n";
    return 0;
}

#include "int_buffer.h"

#include <cassert>
#include <utility>

IntBuffer::IntBuffer(std::size_t size)
    : data_(size == 0 ? nullptr : new int[size]()), size_(size) {}

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

IntBuffer::IntBuffer(const IntBuffer& other) : IntBuffer(other.size_) {
    for (std::size_t i = 0; i < size_; i++) {
        data_[i] = other.data_[i];
    }
}

IntBuffer& IntBuffer::operator=(const IntBuffer& other) {
    IntBuffer copy(other);
    swap(copy);
    return *this;
}

IntBuffer::IntBuffer(IntBuffer&& other) noexcept
    : data_(other.data_), size_(other.size_) {
    other.data_ = nullptr;
    other.size_ = 0;
}

IntBuffer& IntBuffer::operator=(IntBuffer&& other) noexcept {
    IntBuffer taken(std::move(other));
    swap(taken);
    return *this;
}

std::size_t IntBuffer::size() const {
    return size_;
}

int& IntBuffer::at(std::size_t index) {
    assert(index < size_);
    return data_[index];
}

int IntBuffer::at(std::size_t index) const {
    assert(index < size_);
    return data_[index];
}

void IntBuffer::swap(IntBuffer& other) noexcept {
    std::swap(data_, other.data_);
    std::swap(size_, other.size_);
}

void IntBuffer::check_invariants() const {
    assert((data_ == nullptr) == (size_ == 0));
}

// Arreglo de enteros de tamaño fijo, owner de su memoria.
#ifndef INT_BUFFER_H
#define INT_BUFFER_H

#include <cstddef>

// Invariantes:
//   1. data_ == nullptr si y solo si size_ == 0.
//   2. Si size_ > 0, data_ apunta a un bloque de size_ enteros, y este objeto es su único owner.
class IntBuffer {
public:
    explicit IntBuffer(std::size_t size);
    ~IntBuffer();
    IntBuffer(const IntBuffer& other);
    IntBuffer& operator=(const IntBuffer& other);
    IntBuffer(IntBuffer&& other) noexcept;
    IntBuffer& operator=(IntBuffer&& other) noexcept;

    std::size_t size() const;
    int& at(std::size_t index);
    int at(std::size_t index) const;
    void swap(IntBuffer& other) noexcept;
    void check_invariants() const;

private:
    int* data_;
    std::size_t size_;
};

#endif

// Tras mover, un string o un vector es válido, pero su valor no está especificado.
#include <iostream>
#include <string>
#include <utility>
#include <vector>

int main() {
    std::string text = "un texto bastante largo para no caber en el objeto";
    std::string other = std::move(text);
    std::cout << "text.size()=" << text.size() << " other.size()=" << other.size() << "\n";

    text = "de nuevo";
    std::cout << text << "\n";

    std::vector<int> numbers{1, 2, 3};
    std::vector<int> taken = std::move(numbers);
    numbers.clear();
    numbers.push_back(9);
    std::cout << "numbers.size()=" << numbers.size() << " taken.size()=" << taken.size() << "\n";
    return 0;
}

// Máximo genérico con un template: el tipo se comprueba y se genera una versión por tipo.
#include <cassert>
#include <cstddef>
#include <iostream>
#include <string>
#include <vector>

template <typename T>
const T& max_of(const std::vector<T>& items) {
    assert(!items.empty());
    const T* best = &items[0];
    for (std::size_t i = 1; i < items.size(); i++) {
        if (items[i] > *best) {
            best = &items[i];
        }
    }
    return *best;
}

int main() {
    std::vector<int> numbers{3, 9, 4};
    std::vector<std::string> names{"Ana", "Zoila", "Beto"};
    std::cout << max_of(numbers) << "\n";
    std::cout << max_of(names) << "\n";
    return 0;
}

// Máximo genérico al estilo de CS201: void *, tamaños y un puntero a función.
#include <stddef.h>
#include <stdio.h>

typedef int (*compare_fn)(const void *, const void *);

const void *max_of(const void *items, size_t count, size_t size, compare_fn compare) {
    const char *bytes = items;
    const void *best = items;
    for (size_t i = 1; i < count; i++) {
        const void *item = bytes + i * size;
        if (compare(item, best) > 0) {
            best = item;
        }
    }
    return best;
}

int compare_int(const void *a, const void *b) {
    int x = *(const int *)a;
    int y = *(const int *)b;
    return (x > y) - (x < y);
}

int compare_double(const void *a, const void *b) {
    double x = *(const double *)a;
    double y = *(const double *)b;
    return (x > y) - (x < y);
}

int main(void) {
    int numbers[] = {3, 9, 4};
    const int *best = max_of(numbers, 3, sizeof numbers[0], compare_int);
    printf("%d\n", *best);

    double prices[] = {1.5, 0.25, 7.75};
    const double *top = max_of(prices, 3, sizeof prices[0], compare_double);
    printf("%.2f\n", *top);
    return 0;
}

// std::move solo es un cast: quien mueve es el constructor o la asignación que se elige.
#include <iostream>
#include <utility>

#include "alloc_count.h"
#include "int_buffer.h"

void report(const char* step) {
    std::cout << step << ": new[]=" << array_news() << " delete[]=" << array_deletes() << "\n";
}

int main() {
    IntBuffer a(1000);
    a.at(0) = 42;
    report("a creado");

    IntBuffer&& same = std::move(a);
    report("solo std::move(a)");
    std::cout << "same.size()=" << same.size() << " a.size()=" << a.size() << " a.at(0)=" << a.at(0) << "\n";

    IntBuffer b = std::move(a);
    report("constructor de movimiento");
    std::cout << "a.size()=" << a.size() << " b.size()=" << b.size() << " b.at(0)=" << b.at(0) << "\n";
    a.check_invariants();

    IntBuffer c(10);
    report("c creado");
    c = std::move(b);
    report("asignación de movimiento");
    std::cout << "b.size()=" << b.size() << " c.size()=" << c.size() << " c.at(0)=" << c.at(0) << "\n";
    b.check_invariants();

    b = c;
    report("se reutiliza b, con una copia");
    std::cout << "b.size()=" << b.size() << " b.at(0)=" << b.at(0) << "\n";

    const IntBuffer d(20);
    report("d creado, const");
    IntBuffer e = std::move(d);
    report("std::move de un const");
    std::cout << "d.size()=" << d.size() << " e.size()=" << e.size() << "\n";
    return 0;
}

// new y delete: un objeto, y un arreglo. Cada new con su delete del mismo tipo.
#include <cstddef>
#include <iostream>
#include <string>

int main() {
    int* one = new int(7);
    std::string* name = new std::string("pila");
    std::cout << *one << " " << *name << " " << name->size() << "\n";
    delete one;
    delete name;

    std::size_t n = 4;
    int* zeros = new int[n]();
    std::string* words = new std::string[n];
    words[1] = "hola";
    std::cout << zeros[3] << " [" << words[0] << "] [" << words[1] << "]\n";
    delete[] zeros;
    delete[] words;

    int* nothing = nullptr;
    delete nothing;
    std::cout << "delete de nullptr: no hace nada\n";
    return 0;
}

// std::vector no necesita un constructor sin argumentos para push_back: separa reservar de construir.
#include <iostream>
#include <string>
#include <vector>

class Student {
public:
    explicit Student(const std::string& name) : name_(name) {}
    const std::string& name() const {
        return name_;
    }

private:
    std::string name_;
};

int main() {
    std::vector<Student> students;
    students.push_back(Student("Ana"));
    std::cout << students[0].name() << "\n";
    return 0;
}

// El owner como convención: nada en el tipo obliga a llamar a int_array_free.
#include <stdio.h>
#include <stdlib.h>

struct int_array {
    int *data;
    size_t size;
};

struct int_array int_array_new(size_t size) {
    struct int_array array;
    array.data = calloc(size, sizeof *array.data);
    array.size = array.data == NULL ? 0 : size;
    return array;
}

void int_array_free(struct int_array *array) {
    free(array->data);
    array->data = NULL;
    array->size = 0;
}

int main(void) {
    struct int_array numbers = int_array_new(4);
    if (numbers.data == NULL) {
        return 1;
    }
    numbers.data[0] = 7;
    printf("%d\n", numbers.data[0]);
    int_array_free(&numbers);
    return 0;
}

// Calculadora en notación postfija: un uso de la pila que no sabe cómo está hecha.
#include <cassert>
#include <iostream>
#include <string>
#include <vector>

#include "vector_stack.h"

int eval_postfix(const std::vector<std::string>& tokens) {
    VectorStack<int> values;
    for (const std::string& token : tokens) {
        if (token == "+" || token == "-" || token == "*") {
            assert(values.size() >= 2);
            int right = values.top();
            values.pop();
            int left = values.top();
            values.pop();
            if (token == "+") {
                values.push(left + right);
            } else if (token == "-") {
                values.push(left - right);
            } else {
                values.push(left * right);
            }
        } else {
            values.push(std::stoi(token));
        }
    }
    assert(values.size() == 1);
    return values.top();
}

int main() {
    std::cout << eval_postfix({"3", "4", "+", "2", "*"}) << "\n";
    std::cout << eval_postfix({"10", "2", "3", "*", "-"}) << "\n";
    return 0;
}

// Muestra cuándo corre cada destructor.
#include <iostream>
#include <string>

class Noisy {
public:
    explicit Noisy(const std::string& name) : name_(name) {
        std::cout << "  crea " << name_ << "\n";
    }
    ~Noisy() {
        std::cout << "  destruye " << name_ << "\n";
    }

private:
    std::string name_;
};

int first_positive(int a, int b) {
    Noisy guard("guard");
    if (a > 0) {
        return a;
    }
    return b;
}

int main() {
    std::cout << "bloque:\n";
    {
        Noisy x("x");
        Noisy y("y");
        std::cout << "  fin del bloque\n";
    }
    std::cout << "retorno temprano:\n";
    int result = first_positive(5, 6);
    std::cout << "  resultado " << result << "\n";
    std::cout << "new y delete:\n";
    Noisy* z = new Noisy("z");
    std::cout << "  z sigue vivo\n";
    delete z;
    std::cout << "fin de main\n";
    return 0;
}

// Enteros siempre ordenados. Un ejemplo de invariante que sí cuesta comprobar.
#ifndef SORTED_INTS_H
#define SORTED_INTS_H

#include <cassert>
#include <cstddef>
#include <vector>

// Invariante: items_[i - 1] <= items_[i] para todo i válido.
class SortedInts {
public:
    void insert(int value) {
        items_.push_back(value);
        std::size_t i = items_.size() - 1;
        while (i > 0 && items_[i - 1] > value) {
            items_[i] = items_[i - 1];
            i--;
        }
        items_[i] = value;
    }

    int smallest() const {
        assert(!items_.empty());
        return items_[0];
    }

    std::size_t size() const {
        return items_.size();
    }

    void check_invariants() const {
        for (std::size_t i = 1; i < items_.size(); i++) {
            assert(items_[i - 1] <= items_[i]);
        }
    }

private:
    std::vector<int> items_;
};

#endif

// Qué función especial elige el compilador en cada línea.
#include <iostream>
#include <utility>

#include "traced.h"

Traced make_traced() {
    Traced local("local");
    return local;
}

int main() {
    std::cout << "Traced a(\"a\");\n";
    Traced a("a");
    std::cout << "Traced b = a;\n";
    Traced b = a;
    std::cout << "Traced c = std::move(a);\n";
    Traced c = std::move(a);
    std::cout << "b = c;\n";
    b = c;
    std::cout << "b = std::move(c);\n";
    b = std::move(c);
    std::cout << "Traced d = make_traced();\n";
    Traced d = make_traced();
    std::cout << "fin de main\n";
    return 0;
}

// Clase que escribe qué función especial corre en cada momento.
#ifndef TRACED_H
#define TRACED_H

#include <iostream>
#include <string>
#include <utility>

class Traced {
public:
    explicit Traced(const std::string& name) : name_(name) {
        std::cout << "  constructor " << name_ << "\n";
    }
    ~Traced() {
        std::cout << "  destructor " << name_ << "\n";
    }
    Traced(const Traced& other) : name_(other.name_ + "+c") {
        std::cout << "  constructor de copia, desde " << other.name_ << "\n";
    }
    Traced& operator=(const Traced& other) {
        std::cout << "  asignación de copia, " << name_ << " = " << other.name_ << "\n";
        return *this;
    }
    Traced(Traced&& other) noexcept : name_(other.name_ + "+m") {
        std::cout << "  constructor de movimiento, desde " << other.name_ << "\n";
    }
    Traced& operator=(Traced&& other) noexcept {
        std::cout << "  asignación de movimiento, " << name_ << " = " << other.name_ << "\n";
        return *this;
    }

private:
    std::string name_;
};

#endif

// Al crecer, std::vector mueve sus elementos solo si mover no puede lanzar una excepción.
#include <iostream>
#include <type_traits>
#include <utility>
#include <vector>

struct Counts {
    int copies = 0;
    int moves = 0;
};

class SafeMove {
public:
    explicit SafeMove(Counts& counts) : counts_(&counts) {}
    SafeMove(const SafeMove& other) : counts_(other.counts_) {
        counts_->copies++;
    }
    SafeMove(SafeMove&& other) noexcept : counts_(other.counts_) {
        counts_->moves++;
    }

private:
    Counts* counts_;
};

class RiskyMove {
public:
    explicit RiskyMove(Counts& counts) : counts_(&counts) {}
    RiskyMove(const RiskyMove& other) : counts_(other.counts_) {
        counts_->copies++;
    }
    RiskyMove(RiskyMove&& other) : counts_(other.counts_) {
        counts_->moves++;
    }

private:
    Counts* counts_;
};

template <typename T>
void grow(const char* name) {
    Counts counts;
    std::vector<T> items;
    items.reserve(1000);
    for (int i = 0; i < 1000; i++) {
        items.emplace_back(counts);
    }
    std::cout << name << " nothrow=" << std::is_nothrow_move_constructible_v<T>
              << " antes de crecer: copias=" << counts.copies << " movimientos=" << counts.moves << "\n";
    items.reserve(2000);
    std::cout << name << " después de crecer: copias=" << counts.copies
              << " movimientos=" << counts.moves << "\n";
}

int main() {
    grow<SafeMove>("SafeMove");
    grow<RiskyMove>("RiskyMove");
    return 0;
}

// La misma pila, sobre std::vector. Otra implementación del mismo tipo abstracto.
#ifndef VECTOR_STACK_H
#define VECTOR_STACK_H

#include <cassert>
#include <cstddef>
#include <utility>
#include <vector>

// No declara ninguna de las cinco funciones: std::vector ya se encarga (regla de cero).
template <typename T>
class VectorStack {
public:
    void push(T value) {
        items_.push_back(std::move(value));
    }

    void pop() {
        assert(!empty());
        items_.pop_back();
    }

    T& top() {
        assert(!empty());
        return items_.back();
    }

    bool empty() const {
        return items_.empty();
    }

    std::size_t size() const {
        return items_.size();
    }

    // Sin invariantes propios: cualquier estado de items_ es una pila válida.
    void check_invariants() const {}

private:
    std::vector<T> items_;
};

#endif

// No compila: una asignación por valor choca con una asignación de movimiento.
#include <utility>

class Both {
public:
    Both() = default;
    Both(const Both&) = default;
    Both(Both&&) noexcept = default;
    Both& operator=(Both) {
        return *this;
    }
    Both& operator=(Both&&) noexcept {
        return *this;
    }
};

int main() {
    Both a;
    Both b;
    b = std::move(a);
    return 0;
}

// Error: insert deja de correr elementos un paso antes. El invariante lo descubre.
#include <cassert>
#include <cstddef>
#include <iostream>
#include <vector>

class SortedInts {
public:
    void insert(int value) {
        items_.push_back(value);
        std::size_t i = items_.size() - 1;
        while (i > 1 && items_[i - 1] > value) {
            items_[i] = items_[i - 1];
            i--;
        }
        items_[i] = value;
    }

    std::size_t size() const {
        return items_.size();
    }

    void check_invariants() const {
        for (std::size_t i = 1; i < items_.size(); i++) {
            assert(items_[i - 1] <= items_[i]);
        }
    }

private:
    std::vector<int> items_;
};

int main() {
    SortedInts sorted;
    sorted.insert(5);
    sorted.check_invariants();
    sorted.insert(3);
    sorted.check_invariants();
    std::cout << "tamaño " << sorted.size() << "\n";
    return 0;
}

// No compila: declarar un constructor de movimiento borra la copia implícita.
#include <utility>

class OnlyMoves {
public:
    OnlyMoves() = default;
    OnlyMoves(OnlyMoves&&) noexcept {}
};

int main() {
    OnlyMoves a;
    OnlyMoves b = a;
    return 0;
}

// Error: un bloque de new[] se libera con delete, sin corchetes.
int main() {
    int* numbers = new int[4]();
    numbers[0] = 1;
    delete numbers;
    return 0;
}

// No compila: new T[size] necesita construir sin argumentos, y Student no lo permite.
#include <string>

#include "../buffer.h"

class Student {
public:
    explicit Student(const std::string& name) : name_(name) {}

private:
    std::string name_;
};

int main() {
    Buffer<Student> students(3);
    return 0;
}

// No compila: max_of usa >, y Point no lo tiene. El error aparece al usar el template con Point.
#include <cassert>
#include <cstddef>
#include <vector>

template <typename T>
const T& max_of(const std::vector<T>& items) {
    assert(!items.empty());
    const T* best = &items[0];
    for (std::size_t i = 1; i < items.size(); i++) {
        if (items[i] > *best) {
            best = &items[i];
        }
    }
    return *best;
}

struct Point {
    int x;
    int y;
};

int main() {
    std::vector<Point> points{{1, 2}, {3, 4}};
    max_of(points);
    return 0;
}

// Aviso: std::move en el return impide la elisión de la copia. Compila, pero es peor.
#include <utility>

#include "../traced.h"

Traced make_traced() {
    Traced local("local");
    return std::move(local);
}

int main() {
    Traced d = make_traced();
    return 0;
}

// Error: la asignación libera primero. Con a = a, destruye los datos que iba a copiar.
#include <cstddef>
#include <iostream>

class IntBuffer {
public:
    explicit IntBuffer(std::size_t size) : data_(new int[size]()), size_(size) {}
    ~IntBuffer() {
        delete[] data_;
    }
    int& at(std::size_t index) {
        return data_[index];
    }
    IntBuffer(const IntBuffer& other) : data_(new int[other.size_]), size_(other.size_) {
        for (std::size_t i = 0; i < size_; i++) {
            data_[i] = other.data_[i];
        }
    }
    IntBuffer& operator=(const IntBuffer& other) {
        delete[] data_;
        data_ = new int[other.size_];
        size_ = other.size_;
        for (std::size_t i = 0; i < size_; i++) {
            data_[i] = other.data_[i];
        }
        return *this;
    }

private:
    int* data_;
    std::size_t size_;
};

int main() {
    IntBuffer a(3);
    a.at(0) = 10;
    std::cout << "antes: " << a.at(0) << "\n";
    IntBuffer& same = a;
    a = same;
    std::cout << "después: " << a.at(0) << "\n";
    return 0;
}

// Error: la asignación por defecto pierde el bloque del destino y comparte el del origen.
#include <cstddef>

class IntBuffer {
public:
    explicit IntBuffer(std::size_t size) : data_(new int[size]()), size_(size) {}
    ~IntBuffer() {
        delete[] data_;
    }

private:
    int* data_;
    std::size_t size_;
};

int main() {
    IntBuffer a(3);
    IntBuffer b(5);
    b = a;
    return 0;
}

// Error: la clase tiene destructor, pero la copia por defecto copia el puntero.
#include <cstddef>
#include <iostream>

class IntBuffer {
public:
    explicit IntBuffer(std::size_t size) : data_(new int[size]()), size_(size) {}
    ~IntBuffer() {
        delete[] data_;
    }
    int& at(std::size_t index) {
        return data_[index];
    }
    std::size_t size() const {
        return size_;
    }

private:
    int* data_;
    std::size_t size_;
};

int main() {
    IntBuffer a(3);
    a.at(0) = 10;
    IntBuffer b = a;
    b.at(0) = 99;
    std::cout << "a.at(0) = " << a.at(0) << "\n";
    return 0;
}

// Error: con un destructor declarado no hay movimiento implícito; std::move termina en la copia superficial.
#include <cstddef>
#include <utility>

class IntBuffer {
public:
    explicit IntBuffer(std::size_t size) : data_(new int[size]()), size_(size) {}
    ~IntBuffer() {
        delete[] data_;
    }

private:
    int* data_;
    std::size_t size_;
};

int main() {
    IntBuffer a(3);
    IntBuffer b = std::move(a);
    return 0;
}

// No compila: el tipo que devuelve el template no se convierte en otro tipo sin relación.
#include <cassert>
#include <cstddef>
#include <vector>

template <typename T>
const T& max_of(const std::vector<T>& items) {
    assert(!items.empty());
    const T* best = &items[0];
    for (std::size_t i = 1; i < items.size(); i++) {
        if (items[i] > *best) {
            best = &items[i];
        }
    }
    return *best;
}

int main() {
    std::vector<double> prices{1.5, 0.25, 7.75};
    const int* top = &max_of(prices);
    return top == nullptr;
}

// Error: se lee un elemento de un objeto del que ya se movió.
#include <iostream>
#include <utility>

#include "../int_buffer.h"

int main() {
    IntBuffer a(3);
    IntBuffer b = std::move(a);
    std::cout << "b.size() = " << b.size() << "\n";
    std::cout << a.at(0) << "\n";
    return 0;
}

// Error: un arreglo de double con la comparación de int. Compila sin avisos y responde mal.
#include <stddef.h>
#include <stdio.h>

typedef int (*compare_fn)(const void *, const void *);

const void *max_of(const void *items, size_t count, size_t size, compare_fn compare) {
    const char *bytes = items;
    const void *best = items;
    for (size_t i = 1; i < count; i++) {
        const void *item = bytes + i * size;
        if (compare(item, best) > 0) {
            best = item;
        }
    }
    return best;
}

int compare_int(const void *a, const void *b) {
    int x = *(const int *)a;
    int y = *(const int *)b;
    return (x > y) - (x < y);
}

int main(void) {
    double prices[] = {1.5, 0.25, 7.75};
    const double *top = max_of(prices, 3, sizeof prices[0], compare_int);
    printf("%.2f\n", *top);
    return 0;
}

// Error: al compilar este archivo nadie pide Box<int>, así que no se genera nada.
#include "box.h"

template <typename T>
Box<T>::Box(T value) : value_(value) {}

template <typename T>
const T& Box<T>::value() const {
    return value_;
}

// El template se declara aquí, pero se define en box.cpp.
#ifndef BOX_H
#define BOX_H

template <typename T>
class Box {
public:
    explicit Box(T value);
    const T& value() const;

private:
    T value_;
};

#endif

// Pide Box<int>, pero desde aquí no se ve el cuerpo de sus métodos.
#include <iostream>

#include "box.h"

int main() {
    Box<int> box(5);
    std::cout << box.value() << "\n";
    return 0;
}

// Pruebas de Buffer<T>, con int, std::string y un tipo cuya copia puede fallar.
#include <cassert>
#include <stdexcept>
#include <string>
#include <utility>

#include "buffer.h"
#include "check.h"

// Lanza una excepción en la copia número fail_at. El contador va en la clase, sin variables globales.
class Fragile {
public:
    Fragile() = default;
    Fragile& operator=(const Fragile& other) {
        value_ = other.value_;
        if (++assignments() == fail_at()) {
            throw std::runtime_error("copia fallida");
        }
        return *this;
    }
    static int& assignments() {
        static int count = 0;
        return count;
    }
    static int& fail_at() {
        static int position = 0;
        return position;
    }
    int value_ = 0;
};

int main() {
    run_test("int", [] {
        Buffer<int> a(3);
        assert(a.at(2) == 0);
        a.at(2) = 7;
        Buffer<int> b(a);
        b.at(2) = 8;
        assert(a.at(2) == 7 && b.at(2) == 8);
    });
    run_test("string", [] {
        Buffer<std::string> a(2);
        a.at(0) = "uno";
        Buffer<std::string> b(1);
        b = a;
        a.at(0) = "dos";
        assert(b.at(0) == "uno" && b.size() == 2);
        Buffer<std::string> c(std::move(a));
        assert(c.at(0) == "dos" && a.size() == 0);
        a.check_invariants();
        Buffer<std::string>& same = c;
        c = same;
        c = std::move(same);
        assert(c.at(0) == "dos");
    });
    run_test("si la copia falla, el constructor no deja fuga", [] {
        Buffer<Fragile> source(4);
        Fragile::assignments() = 0;
        Fragile::fail_at() = 2;
        bool thrown = false;
        try {
            Buffer<Fragile> copy(source);
        } catch (const std::runtime_error&) {
            thrown = true;
        }
        assert(thrown);
    });
    run_test("si la copia falla, el destino de la asignación no cambia", [] {
        Buffer<Fragile> source(4);
        Buffer<Fragile> target(2);
        target.at(0).value_ = 123;
        Fragile::assignments() = 0;
        Fragile::fail_at() = 2;
        bool thrown = false;
        try {
            target = source;
        } catch (const std::runtime_error&) {
            thrown = true;
        }
        assert(thrown);
        assert(target.size() == 2 && target.at(0).value_ == 123);
        Fragile::fail_at() = 0;
    });
    return 0;
}

// Pruebas de IntBuffer: copia, autoasignación, movimiento y cuántas reservas hace cada uno.
#include <cassert>
#include <type_traits>
#include <utility>

#include "alloc_count.h"
#include "check.h"
#include "int_buffer.h"

static_assert(std::is_nothrow_move_constructible_v<IntBuffer>);
static_assert(std::is_nothrow_move_assignable_v<IntBuffer>);

int main() {
    run_test("copia independiente", [] {
        IntBuffer a(3);
        a.at(1) = 5;
        IntBuffer b(a);
        b.at(1) = 6;
        assert(a.at(1) == 5 && b.at(1) == 6);
    });
    run_test("asignación de copia reserva una vez", [] {
        IntBuffer a(3);
        IntBuffer b(8);
        a.at(0) = 1;
        std::size_t before = array_news();
        b = a;
        assert(array_news() == before + 1);
        assert(b.size() == 3 && b.at(0) == 1);
        a.at(0) = 2;
        assert(b.at(0) == 1);
    });
    run_test("autoasignación", [] {
        IntBuffer a(3);
        a.at(2) = 4;
        IntBuffer& same = a;
        a = same;
        assert(a.size() == 3 && a.at(2) == 4);
    });
    run_test("mover no reserva y deja vacío", [] {
        IntBuffer a(3);
        a.at(0) = 8;
        std::size_t before = array_news();
        IntBuffer b(std::move(a));
        assert(array_news() == before);
        assert(a.size() == 0 && b.at(0) == 8);
        a.check_invariants();
        IntBuffer c(1);
        before = array_news();
        c = std::move(b);
        assert(array_news() == before);
        assert(b.size() == 0 && c.size() == 3 && c.at(0) == 8);
        b.check_invariants();
    });
    run_test("automovimiento", [] {
        IntBuffer a(2);
        a.at(1) = 3;
        IntBuffer& same = a;
        a = std::move(same);
        assert(a.size() == 2 && a.at(1) == 3);
        a.check_invariants();
    });
    run_test("un objeto movido se puede volver a usar", [] {
        IntBuffer a(2);
        IntBuffer b(std::move(a));
        a = b;
        assert(a.size() == 2);
        IntBuffer c(std::move(a));
        a = IntBuffer(4);
        assert(a.size() == 4);
    });
    run_test("reservas y liberaciones se emparejan", [] {
        std::size_t news = array_news();
        std::size_t deletes = array_deletes();
        {
            IntBuffer a(3);
            IntBuffer b(a);
            IntBuffer c(std::move(a));
            b = c;
            c = std::move(b);
        }
        assert(array_news() - news == array_deletes() - deletes);
    });
    return 0;
}