Data Structures

Optional Without Heap

Difficulty

Asked at Headlands Technologies, Squarepoint Capital

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 xxxxxxxx<x>, x xxxxxxx xxx::xxxxxxxx xxxx xxxxx xxx xxxxx xxxxxx xxxxxx. xxxxx xx xx xxxxxxxxxx xxx xx xxxxxxxxxxx: xx xxxxxxxx<xxxx xxxx> xx xx xxxxx xxx xxx xxxxx xx xxxx xx xxxx. xx xx xxxx xxx xxxxx xxx xxx xx xxxxxx'x xxxxxxxx xx xxxx, xx xxxxxxx xxx xxxxxxx xxx. xxxx xxxx xxx xxxxx xxxxxxx: xxxxxxx(xxxx...): xxxxxxxxx x x xx xxxxx, xxxxxxxxxx xxx xxxxxxxx xxx xxxxx(): xxxxxxx xxx xxxx xxxxx xx xxxxx xx xxx xxx_xxxxx(), xxxxxxxx xxxxxxxx xxxx xxxxx(): xxx xxxx xxxxx, xxxxx xxx xxxxxxx xxxxx_xx(xxxxxxxx) xxx xxxxxxxxxx, xxxxx xxxx xxxxxxx xxx xxxx xxxxx x xxxxxxx xxxx xx xxxxxxxx xxxx xxxxxx xxx xxx xxxxxxxxxxxxx xxx xxxxxxxxxxxx, xxx xxx xxxxxx xxxxxxxx xxx xx xxxxxxxxxxxx, xx xxx xxxxx xxxxxx xxxx xxxxxxxx xxxx xxx xxxxxxxx xxxxxx xxxx xxxxxx xxxxxxx xxxxx. xxxxxxxx xxxxxxx::xxxxx(); { xxxxxxxx<xxxxxxx> x; // x xxxxxxxxxxx: xx xxxxx xxxxxxxx xxxxxx xxxxxxx x.xxxxxxx(x); // x xxxxxxxxxxx x.xxxxxxx(x); // x xxxxxxxxxxx, x xxxxxxxxx: xxx x xxx xxxxxx xxxxx } // x xxxxxxxxx: xxx xxxxxxxxxx xxx xxxx xxxxxxxxxxx xxxxxxxxxx. xxxxxxxxxxx xxx xxxxxxx xxxx xx xxx: xxxxxxx(x) xxx::xxxx[xxxxxx(x)], xxx xx xxxxx xx x. xx xxxxx xx x xxxxxxx-xxxxxxxxxx xxx xx xxxxx xxxxxxxx xxx xxxx, xxxxx xx xxx xxxx xxx xxxx xxxxxx xx xxxxx, xxx xxxxx xxxxxxx x xx xx xxxxxxx-xxxxxxxxxxxxx, xxxxx xxx::xxxxxxxx xxxxxxxxxxxx xxxx xxx. xxxxx() xxxx xxx x'x xxxxxxxxxx, xxx xxxxxx xxxxx x xxxx. xxxxxxx xxxx xxxx: xxxxxxxx xxx xxxx xxxxx xxxxx xxxxxxxx xxx x xxxxx xxxxx xxxxxxxxxx xxxxxxx xxxxxx, xxxxx xx xxx xxx xxxx xx xxxx xx xxxxxxxxxx xxxxxxx xxxxxx xxx. xxxxx() xx xx xxxxx xxxxxxxx, xxx xxx xxxxxx xx x xxx, xxxx xx xx-xxx. xxxx xxx xxxxxxxxxx xxx xxxxxxx. xxxx xx xxx xxxxxxx xxxxxxxxx, xxx x xxxx xxx::xxxxxxxx.

This problem is only available to subscribers.

Language: C++23Optional

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

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

void* operator new(std::size_t bytes) {
    ++probe::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 { std::free(p); }
void operator delete[](void* p) noexcept { std::free(p); }
void operator delete(void* p, std::size_t) noexcept { std::free(p); }
void operator delete[](void* p, std::size_t) noexcept { std::free(p); }

// ...
// ...
// ...
// ...
// ...
struct Tracked {
    static inline long long constructed = 0;
    static inline long long destroyed = 0;
    static void reset() { constructed = 0; destroyed = 0; }
    static long long live() { return constructed - destroyed; }

    long long value = 0;

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

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

    ~Optional() {
        // ...
    }

    Optional(const Optional&) = delete;
    Optional& operator=(const Optional&) = delete;

    template <typename... Args>
    T& emplace(Args&&... args) {
        // ...
        return *reinterpret_cast<T*>(&storage_);
    }

    void reset() {
        // ...
    }

    bool has_value() const { return engaged_; }
    explicit operator bool() const { return engaged_; }

    T& value() {
        // ...
        return *reinterpret_cast<T*>(&storage_);
    }

    const T& value() const {
        // ...
        return *reinterpret_cast<const T*>(&storage_);
    }

    T value_or(T fallback) const {
        // ...
        return fallback;
    }

private:
    alignas(T) std::byte storage_[sizeof(T)];
    bool engaged_ = false;
};

Unlock to runUpgrade

Unlock the problem to run it against the tests.

Next in STL From Scratchstd::vector From ScratchData Structures