worked some more on vectors
This commit is contained in:
Phuntsok Drak-pa
parent
2edac15430
commit
7bb0ab619c
1532
src/list.hh
1532
src/list.hh
File diff suppressed because it is too large
Load Diff
14
src/test.cc
14
src/test.cc
|
|
@ -10,27 +10,19 @@ 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'};
|
||||
|
||||
for (auto c : test)
|
||||
cout << c << " ";
|
||||
cout << c << " ";
|
||||
|
||||
cout << "\n";
|
||||
|
||||
|
|
|
|||
248
src/vector.hh
248
src/vector.hh
|
|
@ -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:
|
||||
};
|
||||
|
||||
|
|
|
|||
Loading…
Reference in New Issue