Compiler Explorer

Source code

// (c) 2021 by dbj@dbj.org
// dynamic buffer of trivially copyable types
// by no means finished either in design or in implementation
#include <assert.h>
#include <errno.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>

#define FX(F, X) printf("\n%4d : %32s : " F, __LINE__, (#X), (X))

#include <type_traits>
#include <utility>

// forward declaration of a constrained template
#if __cplusplus >= 202002L
// C++20 (and later) code
template <typename T>
requires  // requires-clause (ad-hoc constraint)
    std::is_trivially_copyable_v<T>
class not_a_vector;
#else   // < C++ 20
template <typename T,
          std::enable_if_t<std::is_trivially_copyable_v<T>, int> = 0>
class not_a_vector;
#endif  // < C++20

// forward declaration is enough for wrong types to be barred
// from being defined. For example this produces
// no warning even if -Wall is used if not_a_vector would not be constrained
// but static_assert would be used instead
//
// using should_not_compile_and_it_does_not =   not_a_vector<std::string>;
//
// users now can do this without worying will this
// instantiate or not err the future code
using should_compile_and_it_does = not_a_vector<bool>;

// implementation  of constrained template
#if __cplusplus >= 202002L
// C++20 (and later) code
template <typename T>
requires  // requires-clause (ad-hoc constraint)
    std::is_trivially_copyable_v<T>
class not_a_vector
#else   // < C++ 20
template <typename T,
          /* becuas of forward declaration above we do not do  `= 0` here*/
          std::enable_if_t<std::is_trivially_copyable_v<T>, int> >
class not_a_vector
#endif  // < C++20
{
    using value_type = T;
    using type = not_a_vector;
    // this is left in to show the problem with using static_assert
    // to try and constrain a type
    // this can not ever happen since we do not allow for defining a type
    // from this template if it is not trivially copiable
    //
    //   static_assert(std::is_trivially_copyable_v<T>,
    //                 "\n\nnot_a_vector<>T -- realloc can handle only trivially
    //                 " "copiable types!\n\n");

constexpr static size_t initial_capacity_ = 0xFF;
    constexpr static size_t capacity_increment_ = 2;
    size_t size_ = 0;
    size_t capacity_ = 0;
    T *arr_ = nullptr;

public:
    size_t size() noexcept { return this->size_; }

template <size_t N>
    static type make(const T (&arr)[N]) {
        assert(N > 0);

type retval_;

if constexpr (!std::is_same_v<char, T>) {
            retval_.resize_(N);
            memcpy(retval_.arr_, arr, N);
            retval_.size_ = N;
        } else {
            // string literals are "special" because of '\0' hidden last char
            // and we do not want to copy it in
            retval_.resize_(N - 1);
            memcpy(retval_.arr_, arr, N - 1);
            retval_.size_ = N - 1;
        }

return retval_;
    }

// contructors and destructors
    not_a_vector() noexcept : size_(0), capacity_(0), arr_(nullptr) {
        resize_(type::initial_capacity_);
    }
    ~not_a_vector() noexcept {
        if (this->arr_ != nullptr) {
            std::free(this->arr_);
            this->arr_ = nullptr;
        }
        size_ = 0;
        capacity_ = 0;
    }

// deliberately no copy
    not_a_vector(not_a_vector const &) noexcept = delete;
    not_a_vector &operator=(not_a_vector const &) noexcept = delete;

not_a_vector(not_a_vector &&other_) noexcept {
        if (other_.size_ > 0) this->resize_(other_.size_);
        this->arr_ = other_.arr_;
        this->size_ = other_.size_;
        other_.arr_ = nullptr;
    }

not_a_vector &operator=(not_a_vector &&other_) &noexcept {
        if (this != &other_) {
            if (other_.size_ > 0) this->resize_(other_.size_);
            this->arr_ = other_.arr_;
            this->size_ = other_.size_;
            other_.arr_ = nullptr;
        }
        return *this;
    }

///////////////////////////////////////////////////////

T &operator[](size_t idx) {
        if (idx > this->size_) {
            errno = EINVAL;
            perror("Bad index!");
            exit(EXIT_FAILURE);
        }

return this->arr_[idx];
    }

const T &operator[](size_t idx) const noexcept {
        if (idx > this->size_) {
            errno = EINVAL;
            perror("Bad index!");
            exit(EXIT_FAILURE);
        }

return this->arr_[idx];
    }

operator const T * const() const noexcept { return this->arr_; }

const T *const data(void) const noexcept { return this->arr_; }

// change value functions
    type &push_back(T &&value) noexcept {
        assert(capacity_ > 0);
        if ((this->size_) >= capacity_)
            resize_(capacity_ * capacity_increment_);
        arr_[this->size_] = value;
        size_ += 1;
        return *this;
    }

private:
    // better resize
    void resize_(std::size_t newSize) {
        assert(newSize > 0);  // this check is not strictly needed,
                              // but zero-size realloc is deprecated in C
        if (void *mem = std::realloc(this->arr_, newSize))
            this->arr_ = static_cast<T *>(mem);
        else {
            errno = ENOMEM;
            perror("Not enough memory");
            exit(EXIT_FAILURE);
        }
        this->capacity_ = newSize;
        // this->size_ = this->capacity_ ;
    }
};  //////////////////////////////////////////////////////////

// move in move out
decltype(auto) hammer = [](auto &&nv_) {
    return std::move(nv_);  // no copy
};

int main() {
    using nvc = not_a_vector<char>;
    nvc vec_, v2;

vec_ = nvc::make("PAYLOAD");
    // no copy allowed --> v2 = vec_ ;
    // move is allowed
    v2 = std::move(vec_);
    FX("%s", vec_.data());
    v2 = hammer(v2);
    FX("%s", v2.data());

v2.push_back('A');
    v2.push_back('B');
    v2.push_back('C');
    v2.push_back(0);  // must zero terminate
    FX("%s", v2.data());

return 42;
}

#define MORE_EDUCATION 1
#if MORE_EDUCATION
// how to properly constraint the type
// few more educational snippets
// https://github.com/unterumarmung/hyper_log_log/blob/master/hll/hyper_log_log.hxx

template <typename T, std::size_t k>
class hyper_log_log {
   public:
    static_assert(k >= 4 && k <= 30, "k must be in a range [4; 30]");
};

// type decalration compiles today 
// but using it will noty at any future point
using timebomb_type = hyper_log_log<bool, 1>;

// few months (or years) after:
// timebomb_type does a boom ;

// forward declaration of a type constrained template
template <typename T, std::size_t k,
          std::enable_if_t<k >= 4 && k <= 30, int> = 0>
class better_hyper_log_log;

// can not happen to be used few months or years down the line
// becuase it does not compile today
// using impossible_type = better_hyper_log_log<bool, 1> ;

using ok_type = better_hyper_log_log<bool, 13>;

template <typename T, std::size_t k>
#if __cplusplus >= 202002L
// C++20 (and later) code
requires  // requires-clause (ad-hoc constraint)
    (k >= 4 && k <= 30)
#endif
        class constrained_hyper_log_log;

// using this type will always compile, future tense
using constrained_derived_type = constrained_hyper_log_log<bool, 13>;

#endif  // MORE_EDUCATION