From 74620e64e747e2ce97f498b1ae2a75ef1ff42dc5 Mon Sep 17 00:00:00 2001 From: Phuntsok Drak-pa Date: Tue, 10 Oct 2017 02:30:17 +0200 Subject: [PATCH] initial comit --- .gitignore | 0 CMakeLists.txt | 28 +++++ debug/PhundrakSTL | Bin 0 -> 40728 bytes src/list.hh | 254 ++++++++++++++++++++++++++++++++++++++++++++++ src/test.cc | 18 ++++ src/vector.hh | 214 ++++++++++++++++++++++++++++++++++++++ 6 files changed, 514 insertions(+) create mode 100644 .gitignore create mode 100644 CMakeLists.txt create mode 100755 debug/PhundrakSTL create mode 100644 src/list.hh create mode 100644 src/test.cc create mode 100644 src/vector.hh diff --git a/.gitignore b/.gitignore new file mode 100644 index 0000000..e69de29 diff --git a/CMakeLists.txt b/CMakeLists.txt new file mode 100644 index 0000000..6740124 --- /dev/null +++ b/CMakeLists.txt @@ -0,0 +1,28 @@ +cmake_minimum_required(VERSION 2.8 FATAL_ERROR) +set(CMAKE_LEGACY_CYGWIN_WIN32 0) +set(CMAKE_BUILD_TYPE Debug) + +project("PhundrakSTL") + +set(TGT "PhundrakSTL") +set(${TGT}_VERSION_MAJOR 0) +set(${TGT}_VERSION_MINOR 1) + +set(CXX_COVERAGE_COMPILE_FLAGS "-pedantic -Wall -Wextra -Wold-style-cast -Woverloaded-virtual -Wfloat-equal -Wwrite-strings -Wpointer-arith -Wcast-qual -Wcast-align -Wconversion -Wsign-conversion -Wshadow -Weffc++ -Wredundant-decls -Wdouble-promotion -Winit-self -Wswitch-default -Wswitch-enum -Wundef -Winline -Wunused -Wnon-virtual-dtor -std=c++17") +# set(CXX_COVERAGE_COMPILE_FLAGS "-Weverything") +set(CMAKE_CXX_FLAGS_DEBUG "${CXX_COVERAGE_COMPILE_FLAGS} -g3 -pg") +set(CMAKE_CXX_FLAGS_RELEASE "${CXX_COVERAGE_COMPILE_FLAGS} -O3") + +set(CMAKE_CXX_STANDARD 17) +set(CMAKE_CXX_STANDARD_REQUIRED YES) +set(CMAKE_CXX_EXTENSIONS OFF) + +set(CMAKE_RUNTIME_OUTPUT_DIRECTORY "../bin/") +set(CMAKE_RUNTIME_OUTPUT_DIRECTORY_DEBUG "../debug/") + +set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} ${CXX_COVERAGE_COMPILE_FLAGS}") +set(CMAKE_EXE_LINKER_FLAGS "${CMAKE_EXE_LINKER_FLAGS} ${CXX_COVERAGE_COMPILE_FLAGS}") + +include_directories(include) +file(GLOB SOURCES "src/*") +add_executable(${TGT} ${SOURCES}) diff --git a/debug/PhundrakSTL b/debug/PhundrakSTL new file mode 100755 index 0000000000000000000000000000000000000000..8ee3a1e7d5caf3cd6a500311d30b30e39ac4749d GIT binary patch literal 40728 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 w>3sOr;AhNf>NWf4q#^ +#include +#include + +namespace phundrak { + +using size_type = size_t; + +template > class list { +private: + struct cell { + cell() = default; + cell *p; + cell *n; + T x; + }; + cell *sentry; + +public: + class iterator; + class const_iterator; + + // Member types ////////////////////////////////////////////////////////////// + + list() : list{Allocator()}, sentry{new cell} {} + + explicit list(const Allocator &alloc) { + sentry = new cell; + sentry->p = sentry; + sentry->n = sentry; + } + + list(size_type count, const T &value, const Allocator &alloc = Allocator()) + : list(alloc) { + while (size() < count) + push_back(value); + } + + explicit list(size_type count, const Allocator &alloc = Allocator()) + : list(alloc) { + while (size() < count) + push_back(T()); + } + + template + list(InputIt first, InputIt last, const Allocator &alloc = Allocator()) + : list(alloc) { + while (first != last) + push_back(*first); + } + + list(const list &other) : list() { + for (auto elem : other) + push_back(elem); + } + + list(const list &other, const Allocator &alloc) : list(alloc) { + for (auto elem : other) + push_back(elem); + } + + list(list &&other) : list() { std::swap(other.sentry, sentry); } + + list(list &&other, const Allocator &alloc) : list(alloc) { + std::swap(other.sentry, sentry); + } + + list(std::initializer_list init, const Allocator &alloc = Allocator()) + : list(alloc) { + for (auto elem : init) + push_back(elem); + } + + virtual ~list() { + clear(); + delete sentry; + } + + // Element access //////////////////////////////////////////////////////////// + + T &front() const { return sentry->n->x; } + T &back() const { return sentry->p->x; } + + // Iterators ///////////////////////////////////////////////////////////////// + + iterator begin() noexcept { return iterator{sentry->n}; } + + const_iterator begin() const noexcept { return const_iterator{sentry->n}; } + const_iterator cbegin() const noexcept { return const_iterator{sentry->n}; } + + iterator end() noexcept { return iterator{sentry}; } + const_iterator end() const noexcept { return const_iterator{sentry}; } + const_iterator cend() const noexcept { return const_iterator{sentry}; } + + // Capacity ////////////////////////////////////////////////////////////////// + + // Modifiers ///////////////////////////////////////////////////////////////// + + void clear() { + cell *it = sentry->n; + while (it != sentry) { + cell *todel = it; + it = it->n; + delete todel; + } + } + + list &operator=(const list &other) { + cell *it = other.sentry->n; + while (it != other.sentry) { + push_back(it->x); + it = it->n; + } + return *this; + } + + list &operator=(list &&other) noexcept { + std::swap(other.sentry, sentry); + return *this; + } + + list &operator=(std::initializer_list ilist) { + for (auto elem : ilist) + push_back(elem); + return *this; + } + + bool empty() { return sentry->p == sentry; } + + size_type size() const { + cell *it = sentry->n; + size_type n = 0; + while (it != sentry) { + ++n; + it = it->n; + } + return n; + } + + void push_front(const T &v) { + cell *c = new cell; + c->x = v; + c->n = sentry->n; + c->p = sentry; + sentry->n->p = c; + sentry->n = c; + } + + void push_back(const T &v) { + cell *c = new cell; + c->x = v; + c->p = sentry->p; + c->n = sentry; + sentry->p->n = c; + sentry->p = c; + } + + void pop_front() { + cell *c = sentry->n; + sentry->n = c->n; + c->n->p = sentry; + delete c; + } + + void pop_back() { + cell *c = sentry->p; + sentry->p = c->p; + c->p->n = sentry; + delete c; + } + + class iterator { + public: + iterator() : it{nullptr} {} + explicit iterator(cell *point) : it{point} {} + + iterator(const iterator &other) : it{other.it} {} + + iterator(iterator &&other) { std::swap(it, other.it); } + + iterator &operator=(cell *point) { + it = point; + return *this; + } + iterator &operator=(const iterator &other) { + it = other.it; + return *this; + } + iterator &operator=(iterator &&other) { + std::swap(it, other.it); + return *this; + } + + ~iterator() {} + + iterator &operator++() { // ++i + it = it->n; + return *this; + } + iterator &operator++(int) { // i++ + iterator t; + t.it = it; + // iterator t{*this}; + it = it->n; + return t; + } + + iterator &operator--() { // --i + it = it->p; + return *this; + } + + iterator &operator--(int) { // i-- + iterator t; + t.it = it; + it = it->n; + return t; + } + + bool operator==(cell *point) { return point == it; } + bool operator==(const iterator &other) { return other.it = it; } + bool operator==(iterator &&other) { return other.it == it; } + + bool operator!=(cell *point) { return point != it; } + bool operator!=(const iterator &other) { return other.it != it; } + bool operator!=(iterator &&other) { return other.it != it; } + + T operator*() { return it->x; } + + protected: + cell *it; + }; + + class const_iterator : protected iterator { + public: + const_iterator() : iterator() {} + explicit const_iterator(T *point) : iterator(point) {} + + explicit const_iterator(const iterator &other) : iterator(other) {} + const_iterator(const const_iterator &other) : iterator(other) {} + + explicit const_iterator(iterator &&other) : iterator(std::move(other)) {} + const_iterator(const_iterator &&other) : iterator(std::move(other)) {} + + const_iterator &operator++() = delete; + const_iterator &operator++(int) = delete; + const_iterator &operator--() = delete; + const_iterator &operator--(int) = delete; + + ~const_iterator() {} + }; +}; + +} // namespace phundrak diff --git a/src/test.cc b/src/test.cc new file mode 100644 index 0000000..fffb4fd --- /dev/null +++ b/src/test.cc @@ -0,0 +1,18 @@ +#include "list.hh" +#include "vector.hh" +#include + +using namespace phundrak; + +int main(void) { + + printf("Hello 1!\n"); + list test {'C', 'a', 'r', 't', 'i', 'e', 'r'}; + printf("Hello !\n"); + + for(auto c : test) { + printf("%c\n", c); + } + + return 0; +} diff --git a/src/vector.hh b/src/vector.hh new file mode 100644 index 0000000..9b599b9 --- /dev/null +++ b/src/vector.hh @@ -0,0 +1,214 @@ +#include +#include +#include +#include +#include + +namespace phundrak { + + template + class vector { + public: + + // Member functions /////////////////////////////////////////////////////// + + //! Default constructor + vector() : data_{nullptr}, size_{0}, capacity_{0} {} + + //! Copy constructor + vector(const vector &other) + : data_{new T[other.size_]}, size_{other.size_}, + capacity_{other.capacity_} { + for (size_t i = 0; i < size_; ++i) { + data_[i] = other.data_[i]; + } + } + + //! Move constructor + vector(vector &&other) noexcept { + std::swap(data_, other.data_); + std::swap(size_, other.size_); + std::swap(capacity_, other.capacity_); + } + + //! Destructor + virtual ~vector() noexcept { + delete[] data_; + } + + //! Copy assignment operator + vector& operator=(const vector &other) { + vector w{other}; + std::swap(data_, w.data_); + std::swap(size_, w.size_); + std::swap(capacity_, w.capacity_); + return *this; + } + + //! Move assignment operator + vector &operator=(vector &&other) noexcept { + std::swap(data_, other.data_); + std::swap(size_, other.size_); + std::swap(capacity_, other.capacity_); + return *this; + } + + T &operator=(size_t pos) { return data_[pos]; } + const T &operator=(size_t pos) const { return data_[pos]; } + + void assign(size_t count, const T &value) { + clear(); + reserve(count); + for (size_t i = 0; i < count; ++i) + push_back(value); + } + + template void assign(InputIt first, InputIt last) { + clear(); + capacity_ = std::distance(first, last); + size_ = std::distance(first, last); + data_ = new T[size_]; + for (int i = 0; first != last; ++first, ++i) + data_[i] = *first; + } + + // Element access ///////////////////////////////////////////////////////// + + T &at(size_t pos) { + try { + if (pos >= size_ || pos < 0) + throw std::out_of_range("Out of range"); + } catch (std::out_of_range e) { + std::cout << e.what() << " in phundrak::vector " << this << '\n'; + std::terminate(); + } + return data_[pos]; + } + + const T &at(size_t pos) const { + try { + if (pos >= size_ || pos < 0) + throw std::out_of_range("Out of range"); + } catch (std::out_of_range e) { + std::cout << e.what() << " in phundrak::vector " << this << '\n'; + std::terminate(); + } + + return data_[pos]; + } + + T &operator[](size_t pos) { return data_[pos]; } + const T &operator[](size_t pos) const { return data_[pos]; } + + T &front() { return data_[0]; } + const T &front() const { return data_[0]; } + + T &back() { return data_[size_ - 1]; } + const T &back() const { return data_[size_ - 1]; } + + T *data() noexcept { return data_; } + const T *data() const noexcept { return data_; } + + // Iterators ////////////////////////////////////////////////////////////// + + // I don't know how to create custom iterators :( + + // Capacity /////////////////////////////////////////////////////////////// + + bool empty() const noexcept { + return (size_ <= 0 || data_ == nullptr) ? true : false; + } + + size_t size() const noexcept { return size_; } + + void reserve(size_t new_cap) { + while (capacity_ < new_cap) + double_capacity(); + } + + size_t capacity() const noexcept { return capacity_; } + + void shrink_to_fit() { + T *olddata = data_; + capacity_ = size_; + data_ = new T[capacity_]; + for (size_t i = 0; i < size_; ++i) + data_[i] = olddata[i]; + delete[] olddata; + } + + // Modifiers ////////////////////////////////////////////////////////////// + + void clear() noexcept { + delete[] data_; + data_ = new T[capacity_]; + size_ = 0; + } + + // insert: can't do iterators :( + // emplace: can't do iterators :( + // erase: can't do iterators :( + + void push_back(const T &value) { + ++size_; + reserve(size_); + data_[size_ - 1] = value; + } + + void push_back(T &&value) { + ++size_; + reserve(size_); + data_[size_ - 1] = std::move(value); + } + + // emplace_back: don't know how to use std::allocator_traits + + void pop_back() { + if (size_ > 0) + --size_; + } + + void resize(size_t count, T value = T()) { + if (count < size_) + size_ = count; + else if (count > size_) + reserve(count); + while (size_ < count) + push_back(value); + } + + void swap(vector& other) { + std::swap(capacity_, other.capacity_); + std::swap(size_, other.size_); + std::swap(data_, other.data_); + } + + protected: + + + private: + void double_capacity() { + if(data_) { + T *olddata = data_; + capacity_ <<= 1; + data_ = new T[capacity_]; + for(size_t i = 0; i < size_; ++i) + data_[i] = olddata[i]; + delete[] olddata; + } else { + data_ = new T[1]; + capacity_ = 1; + } + } + + + + T * data_; + size_t size_; + size_t capacity_; + + }; + + + +} // phundrak namespace