worked some more on vectors

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

File diff suppressed because it is too large Load Diff

View File

@ -10,27 +10,19 @@ int main(void) {
cout << "\n\nTest vecteur\n"; cout << "\n\nTest vecteur\n";
vector<char> testvec; vector<char> testvec{'C', 'a', 'r', 't', 'i', 'e', 'r'};
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');
for(size_t i = 0; i < testvec.size(); ++i) { for (size_t i = 0; i < testvec.size(); ++i) {
cout << testvec[i] << " "; cout << testvec[i] << " ";
} }
cout << std::endl; cout << std::endl;
cout << "\n\nTest list\n"; cout << "\n\nTest list\n";
list<char> test{'C', 'a', 'r', 't', 'i', 'e', 'r'}; list<char> test{'C', 'a', 'r', 't', 'i', 'e', 'r'};
for (auto c : test) for (auto c : test)
cout << c << " "; cout << c << " ";
cout << "\n"; cout << "\n";

View File

@ -1,3 +1,4 @@
#include <algorithm>
#include <cstdio> #include <cstdio>
#include <iostream> #include <iostream>
#include <iterator> #include <iterator>
@ -6,7 +7,7 @@
#include <type_traits> #include <type_traits>
namespace phundrak { namespace phundrak {
using size_type = size_t; using size_type = std::size_t;
template <class T, class Allocator = std::allocator<T>> class vector { template <class T, class Allocator = std::allocator<T>> class vector {
@ -25,10 +26,10 @@ private:
} }
} }
T *data_; T *data_ = nullptr;
size_t size_; size_t size_ = 0;
size_t capacity_; size_t capacity_ = 0;
Allocator alloc_; Allocator alloc_ = Allocator{};
public: public:
/////////////////////////////////////////////////////////////////////////// ///////////////////////////////////////////////////////////////////////////
@ -37,27 +38,25 @@ public:
// constructor //////////////////////////////////////////////////////////// // constructor ////////////////////////////////////////////////////////////
vector() noexcept(noexcept(Allocator())) vector() noexcept(noexcept(Allocator())) {}
: vector{Allocator()} {}
explicit vector(const Allocator &alloc) noexcept explicit vector(const Allocator &alloc) noexcept : alloc_{alloc} {}
: data_{nullptr}, size_{0}, capacity_{0}, alloc_{alloc} {}
vector(size_type count, const T &value, const Allocator &alloc = Allocator()) 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) for (size_t i = 0; i < count; ++i)
push_back(value); push_back(value);
} }
explicit vector(size_type count, const Allocator &alloc = Allocator()) 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) for (size_type i = 0; i < count; ++i)
push_back(T{}); push_back(T{});
} }
template <class InputIt> template <class InputIt>
vector(InputIt first, InputIt last, const Allocator &alloc = Allocator()) vector(InputIt first, InputIt last, const Allocator &alloc = Allocator())
: data_{nullptr}, size_{0}, capacity_{0}, alloc_{alloc} { : alloc_{alloc} {
for (; first != last; ++first) for (; first != last; ++first)
push_back(*first); push_back(*first);
} }
@ -105,13 +104,12 @@ public:
vector(vector &&other, const Allocator &alloc) { vector(vector &&other, const Allocator &alloc) {
if (alloc != other.alloc_) { if (alloc != other.alloc_) {
capacity_ = other.capacity_; std::swap(capacity_, other.capacity_);
size_ = other.size_; std::swap(size_, other.size_);
data_ = new T[capacity_]; data_ = new T[capacity_];
alloc_ = alloc; 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]); data_[i] = std::move(other.data_[i]);
}
} else { } else {
std::swap(capacity_, other.capacity); std::swap(capacity_, other.capacity);
std::swap(size_, other.size); 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_; } virtual ~vector() noexcept { delete[] data_; }
//! Copy assignment operator // Copy assignment operator /////////////////////////////////////////////////
vector &operator=(const vector<T> &other) {
vector<T> w{other}; vector &operator=(const vector &other) {
std::swap(data_, w.data_); delete[] data_;
std::swap(size_, w.size_); size_ = other.size_;
std::swap(capacity_, w.capacity_); capacity_ = other.capacity_;
data_ = new T[capacity_];
for (size_type i = 0; i < size_; ++i)
data_[i] = other.data_[i];
return *this; return *this;
} }
//! Move assignment operator
vector &operator=(vector &&other) noexcept { vector &operator=(vector &&other) noexcept {
std::swap(data_, other.data_); std::swap(alloc_, other.alloc_);
std::swap(size_, other.size_); std::swap(size_, other.size_);
std::swap(capacity_, other.capacity_); std::swap(capacity_, other.capacity_);
std::swap(data_, other.data_);
return *this; return *this;
} }
T &operator=(size_t pos) { return data_[pos]; } vector &operator=(std::initializer_list<T> ilist) {
const T &operator=(size_t pos) const { return data_[pos]; } 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) { void assign(size_t count, const T &value) {
clear(); clear();
@ -162,7 +184,25 @@ public:
data_[i] = *first; 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) { T &at(size_t pos) {
try { try {
@ -187,21 +227,31 @@ public:
return data_[pos]; return data_[pos];
} }
T &operator[](size_t pos) { return data_[pos]; } // operator[] ///////////////////////////////////////////////////////////////
const T &operator[](size_t pos) const { return data_[pos]; }
T &operator[](size_type pos) { return data_[pos]; }
const T &operator[](size_type pos) const { return data_[pos]; }
// front ////////////////////////////////////////////////////////////////////
T &front() { return data_[0]; } T &front() { return data_[0]; }
const T &front() const { return data_[0]; } const T &front() const { return data_[0]; }
// back /////////////////////////////////////////////////////////////////////
T &back() { return data_[size_ - 1]; } T &back() { return data_[size_ - 1]; }
const T &back() const { return data_[size_ - 1]; } const T &back() const { return data_[size_ - 1]; }
// data /////////////////////////////////////////////////////////////////////
T *data() noexcept { return data_; } T *data() noexcept { return data_; }
const T *data() const 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 /////////////////////////////////////////////////////////////// // Capacity ///////////////////////////////////////////////////////////////
@ -271,6 +321,140 @@ public:
std::swap(data_, other.data_); 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: protected:
}; };