game-engine-design-exercises/Main.cpp

#include <cassert>
#include <iostream>
#include <vector>

struct A {
    static int instances;
    int a;
    A(int a) : a(a) {
        // std::cout << "construct A " << a << "\n";
        instances += a;
    }

    A(const A& other) : a(other.a) {
        // std::cout << "copy construct A " << a << "\n";
        instances += a;
    }

    A(A&& other) : a(other.a) {
        // std::cout << "move construct A " << a << "\n";
        instances += a;
    }

    A& operator=(const A& other) {
        instances -= a;
        a = other.a;
        instances += a;
        // std::cout << "copy assignment A " << a << "\n";
        return *this;
    }

    A& operator=(A&& other) {
        instances -= a;
        a = other.a;
        instances += a;
        // std::cout << "move assignment A " << a << "\n";
        return *this;
    }

    ~A() {
        // std::cout << "destruct A " << a << "\n";
        instances -= a;
    }
};

int A::instances = 0;

template<typename T>
class Vector {
    char* data;
    int capacity;
    int elements;

public:
    Vector() : data(nullptr), capacity(0), elements(0) {
    }

    ~Vector() {
        destroy();
    }

    // allocate new storage for copies
    Vector(const Vector& other) : data(allocate(other.capacity)), capacity(other.capacity), elements(other.elements) {
        // copy data into new storage
        other.copyTo(data);
    }

    Vector& operator=(const Vector& other) {
        if(this != &other) {
            // clear current resources
            destroy();
            // allocate new storage for copies
            data = allocate(other.capacity);
            capacity = other.capacity;
            elements = other.elements;
            // copy data into new storage
            other.copyTo(data);
        }
        return *this;
    }

    // acquire the given other vector
    Vector(Vector&& other) : data(other.data), capacity(other.capacity), elements(other.elements) {
        // remove everything from the other vector
        other.reset();
    }

    Vector& operator=(Vector&& other) {
        if(this != &other) {
            // clear current resources
            destroy();
            // acquire the given other vector
            data = other.data;
            capacity = other.capacity;
            elements = other.elements;
            // remove everything from the other vector
            other.reset();
        }
        return *this;
    }

    void reserve(int size) {
        if(size <= capacity) {
            return;
        }
        capacity = size;
        char* newData = allocate(capacity);
        // nothing todo without any old data
        if(data == nullptr) {
            data = newData;
            return;
        }
        // there are elements which need to be moved
        moveTo(newData);
        destroy();
        data = newData;
    }

    void resize(int size, const T& t) {
        if(size > elements) {
            // move existing object to new storage
            char* newData = allocate(size);
            moveTo(newData);
            destroy();
            data = newData;
            capacity = size;
            // fill the rest with the given object
            for(int i = elements; i < size; i++) {
                push_back(t);
            }
        } else if(size < elements) {
            // remove objects until the size matches
            for(int i = size; i < elements; i++) {
                (*pointer(data, i)).~T();
            }
            elements = size;
        }
    }

    void resize(int size) {
        resize(size, T());
    }

    void push_back(const T& t) {
        ensureCapacity();
        new(pointer(data, elements++)) T(t);
    }

    void push_back(T&& t) {
        ensureCapacity();
        // && would be lost without std::move
        new(pointer(data, elements++)) T(std::move(t));
    }

    T& operator[](int index) {
        return *pointer(data, index);
    }

    const T& operator[](int index) const {
        return *pointer(data, index);
    }

    T& at(int index) {
        // std states "at" is [] with range check
        assert(index >= 0 && index < elements);
        return (*this)[index];
    }

    const T& at(int index) const {
        // std states "at" is [] with range check
        assert(index >= 0 && index < elements);
        return (*this)[index];
    }

    int size() const {
        return elements;
    }

    T* begin() {
        return pointer(data, 0);
    }

    T* end() {
        return pointer(data, elements);
    }

    const T* begin() const {
        return pointer(data, 0);
    }

    const T* end() const {
        return pointer(data, elements);
    }

    void erase(T* from, T* to) {
        T* remove = from;
        T* move = to;
        T* stop = end();
        // fill the hole by moving following objects as long as possible
        while(remove != to && move != stop) {
            *remove = std::move(*move);
            remove++;
            move++;
        }
        // remove left over objects
        while(remove != stop) {
            remove->~T();
            remove++;
            elements--;
        }
    }

    void erase(T* start) {
        erase(start, start + 1);
    }

    T* as_array() {
        return begin();
    }

    const T* as_array() const {
        return begin();
    }

private:
    static char* allocate(int length) {
        return new char[sizeof(T) * length];
    }

    static T* pointer(char* data, int index) {
        return reinterpret_cast<T*>(data) + index;
    }

    static const T* pointer(const char* data, int index) {
        return reinterpret_cast<const T*>(data) + index;
    }

    void ensureCapacity() {
        if(elements >= capacity) {
            // doubling the size amortizes costs
            reserve(capacity == 0 ? 1 : capacity * 2);
        }
    }

    void copyTo(char* newData) const {
        for(int i = 0; i < elements; i++) {
            new(pointer(newData, i)) T(*pointer(data, i));
        }
    }

    void moveTo(char* newData) {
        for(int i = 0; i < elements; i++) {
            new(pointer(newData, i)) T(std::move(*pointer(data, i)));
        }
    }

    void destroy() {
        callDestructors();
        delete[] data;
    }

    void reset() {
        data = nullptr;
        capacity = 0;
        elements = 0;
    }

    void callDestructors() {
        // placement new needs explicit destructor calling
        for(int i = 0; i < elements; i++) {
            (*pointer(data, i)).~T();
        }
    }
};

void printError(int number) {
    std::cout << "\033[0;31mError " << number << "\033[0m\n";
}

template<typename V>
void test() {
    {
        const int elements = 2;
        V v;
        for(int i = 0; i < elements; i++) {
            v.push_back(A(i));
        }
        const V& cv = v;
        for(int i = 0; i < elements; i++) {
            if(v[i].a != i || cv[i].a != i || v.at(i).a != i || cv.at(i).a != i) {
                printError(1);
            }
        }
        if(v.size() != elements) {
            printError(2);
        }
    }
    {
        V v1;
        v1.push_back(A(10));
        V v2 = v1;
        V v3;
        v3.push_back(A(20));
        v3 = v1;
        if(v1[0].a != 10 || v2[0].a != 10 || v3[0].a != 10) {
            printError(3);
        }

        V v4 = std::move(v1);
        V v5(std::move(v2));
        V v6;
        v6 = std::move(v3);

        if(v1.size() != 0 || v2.size() != 0 || v3.size() != 0 || v4.size() != 1 || v5.size() != 1 || v6.size() != 1) {
            printError(4);
        }
    }
    {
        V v;
        v.resize(1, A(8));
        v.resize(3, A(9));
        if(v.size() != 3 || v[0].a != 8 || v[1].a != 9 || v[2].a != 9) {
            printError(5);
        }
        v.resize(1, A(10));
        if(v.size() != 1 || v[0].a != 8) {
            printError(6);
        }
    }
    {
        V v;
        v.push_back(A(20));
        v.push_back(A(21));
        v.push_back(A(22));
        v.erase(v.begin() + 1);
        if(v.size() != 2 || v[0].a != 20 || v[1].a != 22) {
            printError(7);
        }
        v.erase(v.begin(), v.end());
        if(v.size() != 0) {
            printError(8);
        }
    }
    if(A::instances != 0) {
        std::cout << "object counter is not 0: " << A::instances << "\n";
    }
}

int main() {
    test<Vector<A>>();
    std::cout << "--------------------------\n";
    test<std::vector<A>>();
}