Data Structures

std::vector From Scratch

Difficulty

Theory: Data Structures You Implement, Not Import

Read the problem, hints and solution here. The editor needs a bigger screen: open this page on a laptop to write and run your code.

xxxxxxxxx xxxxxx<x>, x xxxxxxxx xxxxx xxx xxx xxxxxxx xxxx, xxxx xxx xxxxxxx xxxx xxx xxxxxxxx xxxxxxxx, xxxx xxxxxxx xxx xxxxxxxxx xxx xxxxxxx xx xxxx. xxxxx xxx::xxxxxx, xxx::xxxxx xx x xxxxx xxxxxxx xxxxxx xx xx xxxxxx. x xxxxxxxx xxxxx xx xxx xx x xxxxx xxxxxxxx. xxx xxxx xxx xx xxxx xxxxxxx x xxx xx xxx xxxx: xx xxx xxxx xx xxxxxxx xxxxxxxxxxx, xx xxx xx xxxx-xxxx, xxx xxx xxxx xxx xxxxx xxxxxxx xxxxxxx x xxxxxxxxxxxx. xxx::xxxxxx xxxxxxxx xxxx x xxxxxx xxxx_xxxx xxxxxx xxx xxxxxx xxxxxxx xx xx xxx, xxx xxxxxxx xxxx xxxxxxx xx xxxx xxxxxxx xxxxxxx xxxxxx xxxxx xxxx xxxxxxxx xx xxxxxx xxxx. xxx xxxxxxxx xxxxxxx xxxxx xxxxx xxxxx xxx xx xxxxx xxxxxxxxxx xx xxxxxxx, xx xxx xxxxx xxx xxxx xxxx xxxx xxx xxx xxx xxxx xxx xxxxxx. xxxxxx(): xxxxxxxxx xxxxxxx. xxxxxxxx() xx x. ~xxxxxx(): xxxxxxxx xxxxx xxxxxxx xxx xxxxx xxx xxxxxxx. xxxx xxxxxxx(xxx::xxxx_x xxxxxx): xx xxxxxx xx xxxxx xxx xxxxxxxx, xxxxxxxxxxx xx xxxxxxx xxxxxx xxx xxxxxxxxx xxx xxxxxxxx xxx xxxx xxx xxxxxx xxxx (xxx xxxxxx xxxxx). xx xxxxxxxxxx xxxxxxx xxx. xxxxxxxxx xx xxxx xxxxxxx. xxxxxxxx <xxxxxxxx... xxxx> x& xxxxxxx_xxxx(xxxx&&... xxxx): xxxxxxxxxx x(xxx::xxxxxxx<xxxx>(xxxx)...) xx xxxxx xx xxx xxx, xxxx xxxxxxxxxxx xx xxx::xxxxxx xxxx, xxx xxxxxxx xx. xxxxxx xxxxx xxxx xx xxxxxxxxxxx_xxxx xxxxxxxxxxx: xxxxxxx_xxxx(x, 'x') xx x xxxxxx<xxx::xxxxxx> xxxx xxxx "xxxx". xxxx xxxx_xxxx(xxxxx x& xxxxx) xxx xxxx xxxx_xxxx(x&& xxxxx). xxxx xxx_xxxx(): xxxxxxxx xxx xxxx xxxxxxx xx xxxx. xxx xxxxxxxx xxxxx. xxxx xxxxx(): xxxxxxxx xxxxx xxxxxxx. xxx xxxxxxxx xxxxx. xxx::xxxx_x xxxx() xxxxx, xxx::xxxx_x xxxxxxxx() xxxxx, xxxx xxxxx() xxxxx. xxxxxxxx[], xxxx(), xxxxx() xxx xxx(): xxxxx xxx xxxxxxx. xxx xxxxxxxxx xxx xxxxx xxxxxxxx, xxx xxxxx xxx xxx xxxxxxxx xx xxx xxxxxxxx. xxxxxx. x xxxx xxxxxx xxxxxxx: x, x, x, x, x. xxxxxx xxxxxx xxx xxx xxxxxxx xxxxx, xxxx xxxxxxxxx xxx xxx xxxx xxxx xxx::xxxx_xx_xxxxxxxx, xxxx xxxxxxxx xxxx xxx xxxxx xxx xxx xxxxxxx. xxx xxxxxx xxxxx x xxxx xxxx xx x'x xxxx xxxxxx xxxxx, xx xx x xxx xx xxxx xx xxx. xxx xxxx xx xxxx. xxxx xxxxxxxxxxx: x xxxx xxxx, xxxx xxxxxxxx xxxxxxx xxxxx.xxxx(). xxxxxxx xx xxxxx xxxxxx xxxxxxxxx xxxxxxx. xxxx xxxxxxxxxx: xxxxxx x xxxx xxxx xxxxx, xxxx xxxxx xx xx, xx x xxxxxxxx xxxx xxxxxx xxx xxxxxx xxxxxxxxx. xxx xxxxxxxx xxxxxxxxxx xx xxxxxxx xxxxx.xxxx(). xxxx-xxxxxxxxxx xxxxxxx xxxxxxx. xxxx xxxxxxxxxxx xxx xxxx xxxxxxxxxx: xxxxxxxx. xxxx xxxx xxx xxxxxxx xxxxx, xxxx xx xxxxxxx xxxxxxx xxx xx xxxxxxxxxx, xxx xxxxx xxx xxxxxx xxxx xxxx xxx xxxxxxxx x. xxxx xxxxxxxxxx xxxxxxxx xxxx xxx xxxxxx xxxx xxx xxxxx xxx xxxxxxx. x xxxx-xxxx xxxxxxx xxxxxxx. xxxxxxxx xxxxxx<xxxx xxxx> x; xxx (xxx x = x; x < x; ++x) { x.xxxx_xxxx(x); x.xxxxxxxx(); // x, x, x, x, x } xxxxxxx::xxxxx(); // xxxxxxx'x xxxx xx xxxxxxxx xxxxxx<xxxxxxx> x; xxx (xxx x = x; x < x; ++x) x.xxxxxxx_xxxx(x); xxxxxxx::xxxxx; // x: xxxxxx xxxxx x, xxxx x, xxxx x xxxxxxxx xxxxxxx::xxxxxx; // x xxxxxxx::xxxxx(); // xxxxxx'x xxxx xxx xxxxx xxxxxx<xxxxxx> x; xxx (xxx x = x; x < x; ++x) x.xxxxxxx_xxxx(x); xxxxxxx::xxxxx; // x xxxxxxx::xxxxxx; // x: x xxxxxxxx xxxx xxxxx xxxx xxx xxxxxxxx xxxxxxxxxxx xxx xxxxxxx xxxx xx xxx, xxxx ::xxxxxxxx xxx(xxxxx) xx xxx::xxxxxxxxx<x>. xxxxxxxx xxx xxxx xx xxxxxxx xxxxxxxxxxx, xxx xxxxxxx(xxxx) xxxx xxxxxxxxx xxxxxxx. xxx x[x] xxxxx xx xxxx xxxxxx. xxx xxxxx xxxxx xxx xxxxx xx xxx xxxxxx xxxxxxxx xxx, xxxxx xxxx xx xxxxx xxxxx. xx x xxxx xx x xxxxxxxxxxx xxxxxx xxxxxx xxxxxxx_xxxx xx xxxx_xxxx, xxx xxxxxx xx xxxxxxx xx xx xxx: xxxx xxxx, xxxx xxxxxxxx, xxxx xxxx(), xxxx xxxxxx. xxxxxxxxxx xxxxx xx xxx xxx xxxx xxxxxxxxx, xxx xxx xxx xxxxx xxx xxxx xxxxx. xxx xxxxxx xxxxx xxxxx xxxx xxx xxx xxxx xx x xxxxxxxxxxxx xxx xxxx xxx xxxxxxxx. xxx xxxxxxxx xxx xx xxxxxx xxx xxxxxx. x.xxxx_xxxx(x[x]) xx x xxxx xxxxxx xxx xx xxxx, xxx xx xxxx x.xxxx_xxxx(xxx::xxxx(x[x])). xxxx xx xxx xxxxxx xxxxxx xxx xxx xxxxxxx xxxxxx xx xxxxxxx xxx xxx xxxx. xxxx xxxx xxxxxxxxxxx xxxx xx xxxxxxxx xxx x xxxxxx<xxxxxx<x>> xx xxxx xxx xxxxxxxx xx xxxxxx. xxx xxxx xxxxxxxx xx. xxxx-xxxxxxx xxxxx, xxxxxx, xxxxx, xxxxxx, xxxxxxxxx xxxxxxxxxx xxx xxxxxx<xxxx> xxx xxx xxxx xx xxxx xxxxxxx. xxxxxxxxxxx: xxx xxxxxxx xxxx_xxxx xxxxx xx xxxx xxxx, xxxxx xx xxxxxxxxxxx. x xxxxxx xxxx xxxxx xxx xxxx xx x xxxx xxxxx xxxxx xxx xxxxxxxx xxxxxxxx.

This problem is only available to subscribers.

Language: C++23Vector

#include <cstddef>
#include <cstdlib>
#include <new>
#include <stdexcept>
#include <string>
#include <type_traits>
#include <utility>

// ...
// ...
// ...
namespace probe {
inline long long& alloc_counter() {
    static long long calls = 0;
    return calls;
}
inline long long& free_counter() {
    static long long calls = 0;
    return calls;
}
inline long long allocations() { return alloc_counter(); }
inline long long frees() { return free_counter(); }
inline void reset() {
    alloc_counter() = 0;
    free_counter() = 0;
}
}  // ...

void* operator new(std::size_t bytes) {
    ++probe::alloc_counter();
    void* p = std::malloc(bytes ? bytes : 1);
    if (!p) throw std::bad_alloc();
    return p;
}
void* operator new[](std::size_t bytes) { return ::operator new(bytes); }
void operator delete(void* p) noexcept {
    if (p) ++probe::free_counter();
    std::free(p);
}
void operator delete[](void* p) noexcept { ::operator delete(p); }
void operator delete(void* p, std::size_t) noexcept { ::operator delete(p); }
void operator delete[](void* p, std::size_t) noexcept { ::operator delete(p); }

// ...
// ...
// ...
// ...
// ...
// ...
// ...
// ...
// ...
// ...
// ...
// ...
// ...
struct Tracked {
    static inline long long constructed = 0;
    static inline long long copies = 0;
    static inline long long moves = 0;
    static inline long long destroyed = 0;
    static inline long long throw_on_copy = 0;
    static void reset() {
        constructed = copies = moves = destroyed = throw_on_copy = 0;
    }
    static long long live() { return constructed + copies + moves - destroyed; }
    static void on_copy() {
        if (throw_on_copy && --throw_on_copy == 0) throw std::runtime_error("copy failed");
        ++copies;
    }
};

template <bool NothrowMove>
struct Element {
    long long value;
    explicit Element(long long v) : value(v) { ++Tracked::constructed; }
    Element(const Element& other) : value(other.value) { Tracked::on_copy(); }
    Element(Element&& other) noexcept(NothrowMove) : value(other.value) {
        other.value = -1;
        ++Tracked::moves;
    }
    Element& operator=(const Element&) = delete;
    Element& operator=(Element&&) = delete;
    ~Element() { ++Tracked::destroyed; }
};

using Movable = Element<true>;
using Copied = Element<false>;

struct MoveOnly {
    long long value;
    explicit MoveOnly(long long v) : value(v) { ++Tracked::constructed; }
    MoveOnly(const MoveOnly&) = delete;
    MoveOnly(MoveOnly&& other) : value(other.value) {
        other.value = -1;
        ++Tracked::moves;
    }
    MoveOnly& operator=(const MoveOnly&) = delete;
    MoveOnly& operator=(MoveOnly&&) = delete;
    ~MoveOnly() { ++Tracked::destroyed; }
};

// ...
// ...
// ...
// ...
template <typename T>
class Vector {
public:
    Vector() noexcept = default;

    ~Vector() {
        // ...
    }

    Vector(const Vector& other) {
        // ...
        (void)other;
    }

    Vector(Vector&& other) noexcept {
        // ...
        (void)other;
    }

    Vector& operator=(const Vector& other) {
        // ...
        (void)other;
        return *this;
    }

    Vector& operator=(Vector&& other) noexcept {
        // ...
        // ...
        (void)other;
        return *this;
    }

    void reserve(std::size_t wanted) {
        // ...
        (void)wanted;
    }

    template <typename... Args>
    T& emplace_back(Args&&... args) {
        // ...
        ((void)args, ...);
        return *data_;
    }

    void push_back(const T& value) {
        // ...
        (void)value;
    }

    void push_back(T&& value) {
        // ...
        (void)value;
    }

    void pop_back() {
        // ...
    }

    void clear() {
        // ...
    }

    std::size_t size() const noexcept { return size_; }
    std::size_t capacity() const noexcept { return capacity_; }
    bool empty() const noexcept { return size_ == 0; }

    T& operator[](std::size_t i) { return data_[i]; }
    const T& operator[](std::size_t i) const { return data_[i]; }

    T* data() noexcept { return data_; }
    const T* data() const noexcept { return data_; }

    T* begin() noexcept { return data_; }
    T* end() noexcept { return data_ + size_; }
    const T* begin() const noexcept { return data_; }
    const T* end() const noexcept { return data_ + size_; }

private:
    T* data_ = nullptr;
    std::size_t size_ = 0;
    std::size_t capacity_ = 0;
};

Unlock to runUpgrade

Unlock the problem to run it against the tests.

Next in STL From ScratchIntrusive ListData Structures