phundrak/phundrakstl
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity

worked some more on vectors

Browse Source
This commit is contained in:
Phuntsok Drak-pa 2017-10-28 10:35:27 +02:00
parent 2edac15430
commit 7bb0ab619c
3 changed files with 985 additions and 809 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

38
src/list.hh
View File

@ -6,11 +6,11 @@
namespace phundrak {
using size_type = size_t;
using size_type = std::size_t;
template <class T, class Allocator = std::allocator<T>> class list {
template <class T, class Allocator = std::allocator<T>> class list {
public:
public:
class iterator;
class reverse_iterator;
class const_iterator;
@ -18,15 +18,15 @@ namespace phundrak {
// using const_iterator = const iterator;
// using const_reverse_iterator = const reverse_iterator;
private:
private:
// data structure ///////////////////////////////////////////////////////////
struct cell {
cell() = default;
explicit cell(const T &value) : x{value}, p{nullptr}, n{nullptr} {}
explicit cell(T &&value) : x{value}, p{nullptr}, n{nullptr} {}
explicit cell(const T &value) : x{value} {}
explicit cell(T &&value) : x{value} {}
cell(const cell &other) : x{other.x}, p{other.p}, n{other.n} {}
cell(cell &&other) : x{T{}}, p{nullptr}, n{nullptr} {
cell(cell &&other) {
std::swap(x, other.x);
std::swap(p, other.p);
std::swap(n, other.n);
@ -43,26 +43,26 @@ namespace phundrak {
std::swap(p, other.p);
return *this;
}
cell *p;
cell *n;
T x;
cell *p = nullptr;
cell *n = nullptr;
T x = T();
};
// members //////////////////////////////////////////////////////////////////
cell *sentry;
const Allocator alloc_;
cell *sentry = new cell{};
const Allocator alloc_ = Allocator{};
public:
public:
/////////////////////////////////////////////////////////////////////////////
// Member functions //
/////////////////////////////////////////////////////////////////////////////
// Constructors /////////////////////////////////////////////////////////////
list() : list{Allocator()}, sentry{new cell{}} {}
list() {}
explicit list(const Allocator &alloc) : sentry{new cell{}}, alloc_{alloc} {
explicit list(const Allocator &alloc) : alloc_{alloc}{
sentry->p = sentry;
sentry->n = sentry;
}
@ -82,7 +82,7 @@ namespace phundrak {
template <class InputIt>
list(InputIt first, InputIt last, const Allocator &alloc = Allocator())
: list{alloc} {
for (;first != last; ++first)
for (; first != last; ++first)
push_back(*first);
}
@ -660,10 +660,10 @@ namespace phundrak {
class iterator {
protected:
cell *it;
cell *it = nullptr;
public:
iterator() : it{nullptr} {}
iterator() {}
explicit iterator(cell *point) : it{point} {}
iterator(const iterator &other) : it{other.it} {}
@ -781,6 +781,6 @@ namespace phundrak {
: reverse_iterator{other} {}
virtual ~const_reverse_iterator() { ~reverse_iterator(); }
};
};
};
} // namespace phundrak

12
src/test.cc
View File

@ -10,21 +10,13 @@ int main(void) {
cout << "\n\nTest vecteur\n";
vector<char> testvec;
testvec.push_back('C');
testvec.push_back('a');
testvec.push_back('r');
testvec.push_back('t');
testvec.push_back('i');
testvec.push_back('e');
testvec.push_back('r');
vector<char> testvec{'C', 'a', 'r', 't', 'i', 'e', 'r'};
for(size_t i = 0; i < testvec.size(); ++i) {
for (size_t i = 0; i < testvec.size(); ++i) {
cout << testvec[i] << " ";
}
cout << std::endl;
cout << "\n\nTest list\n";
list<char> test{'C', 'a', 'r', 't', 'i', 'e', 'r'};

248
src/vector.hh
View File

@ -1,3 +1,4 @@
#include <algorithm>
#include <cstdio>
#include <iostream>
#include <iterator>
@ -6,7 +7,7 @@
#include <type_traits>
namespace phundrak {
using size_type = size_t;
using size_type = std::size_t;
template <class T, class Allocator = std::allocator<T>> class vector {
@ -25,10 +26,10 @@ private:
}
}
T *data_;
size_t size_;
size_t capacity_;
Allocator alloc_;
T *data_ = nullptr;
size_t size_ = 0;
size_t capacity_ = 0;
Allocator alloc_ = Allocator{};
public:
///////////////////////////////////////////////////////////////////////////
@ -37,27 +38,25 @@ public:
// constructor ////////////////////////////////////////////////////////////
vector() noexcept(noexcept(Allocator()))
: vector{Allocator()} {}
vector() noexcept(noexcept(Allocator())) {}
explicit vector(const Allocator &alloc) noexcept
: data_{nullptr}, size_{0}, capacity_{0}, alloc_{alloc} {}
explicit vector(const Allocator &alloc) noexcept : alloc_{alloc} {}
vector(size_type count, const T &value, const Allocator &alloc = Allocator())
: vector{alloc}, data_{nullptr}, size_{0}, capacity_{0} {
: vector{alloc} {
for (size_t i = 0; i < count; ++i)
push_back(value);
}
explicit vector(size_type count, const Allocator &alloc = Allocator())
: data_{nullptr}, size_{0}, capacity_{0}, alloc_{alloc} {
: alloc_{alloc} {
for (size_type i = 0; i < count; ++i)
push_back(T{});
}
template <class InputIt>
vector(InputIt first, InputIt last, const Allocator &alloc = Allocator())
: data_{nullptr}, size_{0}, capacity_{0}, alloc_{alloc} {
: alloc_{alloc} {
for (; first != last; ++first)
push_back(*first);
}
@ -105,13 +104,12 @@ public:
vector(vector &&other, const Allocator &alloc) {
if (alloc != other.alloc_) {
capacity_ = other.capacity_;
size_ = other.size_;
std::swap(capacity_, other.capacity_);
std::swap(size_, other.size_);
data_ = new T[capacity_];
alloc_ = alloc;
for (size_type i = 0; i < size_; ++i) {
for (size_type i = 0; i < size_; ++i)
data_[i] = std::move(other.data_[i]);
}
} else {
std::swap(capacity_, other.capacity);
std::swap(size_, other.size);
@ -120,28 +118,52 @@ public:
}
}
//! Destructor
// Constructor by initializer list //////////////////////////////////////////
vector(std::initializer_list<T> init, const Allocator &alloc = Allocator())
: vector{alloc} {
for (auto &elem : init)
push_back(std::move(elem));
}
// Destructor ///////////////////////////////////////////////////////////////
virtual ~vector() noexcept { delete[] data_; }
//! Copy assignment operator
vector &operator=(const vector<T> &other) {
vector<T> w{other};
std::swap(data_, w.data_);
std::swap(size_, w.size_);
std::swap(capacity_, w.capacity_);
// Copy assignment operator /////////////////////////////////////////////////
vector &operator=(const vector &other) {
delete[] data_;
size_ = other.size_;
capacity_ = other.capacity_;
data_ = new T[capacity_];
for (size_type i = 0; i < size_; ++i)
data_[i] = other.data_[i];
return *this;
}
//! Move assignment operator
vector &operator=(vector &&other) noexcept {
std::swap(data_, other.data_);
std::swap(alloc_, other.alloc_);
std::swap(size_, other.size_);
std::swap(capacity_, other.capacity_);
std::swap(data_, other.data_);
return *this;
}
T &operator=(size_t pos) { return data_[pos]; }
const T &operator=(size_t pos) const { return data_[pos]; }
vector &operator=(std::initializer_list<T> ilist) {
delete[] data_;
size_ = ilist.size();
capacity_ = size_;
data_ = new T[capacity_];
size_type i = 0;
std::for_each(std::begin(ilist), std::end(ilist), [&i, this](T &elem) {
data_[i] = std::move(elem);
++i;
});
return *this;
}
// assign ///////////////////////////////////////////////////////////////////
void assign(size_t count, const T &value) {
clear();
@ -162,7 +184,25 @@ public:
data_[i] = *first;
}
// Element access /////////////////////////////////////////////////////////
void assign(std::initializer_list<T> ilist) {
delete[] data_;
size_ = ilist.size();
capacity_ = ilist.size();
data_ = new T[size_];
size_type i = 0;
for (auto pos = ilist.begin(); pos != ilist.end(); ++pos, ++i)
data_[i] = std::move(*pos);
}
// get_allocator ////////////////////////////////////////////////////////////
Allocator get_allocator() const { return alloc_; }
/////////////////////////////////////////////////////////////////////////////
// Element access //
/////////////////////////////////////////////////////////////////////////////
// at ///////////////////////////////////////////////////////////////////////
T &at(size_t pos) {
try {
@ -187,21 +227,31 @@ public:
return data_[pos];
}
T &operator[](size_t pos) { return data_[pos]; }
const T &operator[](size_t pos) const { return data_[pos]; }
// operator[] ///////////////////////////////////////////////////////////////
T &operator[](size_type pos) { return data_[pos]; }
const T &operator[](size_type pos) const { return data_[pos]; }
// front ////////////////////////////////////////////////////////////////////
T &front() { return data_[0]; }
const T &front() const { return data_[0]; }
// back /////////////////////////////////////////////////////////////////////
T &back() { return data_[size_ - 1]; }
const T &back() const { return data_[size_ - 1]; }
// data /////////////////////////////////////////////////////////////////////
T *data() noexcept { return data_; }
const T *data() const noexcept { return data_; }
// Iterators //////////////////////////////////////////////////////////////
/////////////////////////////////////////////////////////////////////////////
// Iterators //
/////////////////////////////////////////////////////////////////////////////
// I don't know how to create custom iterators :(
// TODO: iterator functions
// Capacity ///////////////////////////////////////////////////////////////
@ -271,6 +321,140 @@ public:
std::swap(data_, other.data_);
}
/////////////////////////////////////////////////////////////////////////////
// //
// //
// ITERATOR CLASS //
// //
// //
/////////////////////////////////////////////////////////////////////////////
class iterator {
protected:
T *it;
public:
iterator() : it{nullptr} {}
explicit iterator(T *point) : it{point} {}
iterator(const iterator &other) : it{other.it} {}
iterator(iterator &&other) { std::swap(it, other.it); }
iterator &operator=(T *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() {
// delete it;
}
iterator &operator++() { // ++i
++it;
return *this;
}
iterator operator++(int) { // i++
// iterator t;
// t.it = it;
iterator t{*this};
++it;
return t;
}
iterator &operator--() { // --i
--it;
return *this;
}
iterator operator--(int) { // i--
// iterator t;
// t.it = it;
iterator t{it};
--it;
return t;
}
bool operator==(T *point) { return point == it; }
bool operator==(const iterator &other) { return other.it == it; }
bool operator==(iterator &&other) { return other.it == it; }
bool operator!=(T *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; }
friend class vector;
};
class const_iterator : public 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 T &operator*() { return this->it; }
};
class reverse_iterator : public iterator {
public:
reverse_iterator() : iterator() {}
explicit reverse_iterator(T *point) : iterator(point) {}
reverse_iterator(const reverse_iterator &other) : iterator(other) {}
reverse_iterator(reverse_iterator &&other) : iterator(std::move(other)) {}
reverse_iterator &operator++() {
++this->it;
return *this;
}
reverse_iterator operator++(int) {
reverse_iterator t{*this};
++this->it;
;
return t;
}
reverse_iterator &operator--() {
--this->it;
return *this;
}
reverse_iterator operator--(int) {
reverse_iterator t{*this};
--this->it;
return t;
}
~reverse_iterator() {}
};
class const_reverse_iterator : public reverse_iterator {
public:
const_reverse_iterator() : reverse_iterator() {}
explicit const_reverse_iterator(T *point) : reverse_iterator{point} {}
explicit const_reverse_iterator(const reverse_iterator &other)
: reverse_iterator{other} {}
const_reverse_iterator(const const_reverse_iterator &other)
: reverse_iterator{other} {}
explicit const_reverse_iterator(reverse_iterator &&other)
: reverse_iterator{other} {}
virtual ~const_reverse_iterator() { ~reverse_iterator(); }
};
protected:
};