#include #include // std::unique_ptr #include // std::copy, std::swap #include // std::ostream_iterator /** * It's a first attempt to create my own dynamic (std::vector like) container in c++. * I left some comments but not so many so if something * seems like hard to undersand do not hesitate to ask! * Any suggestions? Leave a comment! * * If you liked it leave a like! * * Made by Jakub Stasiak - Do not copy pls */ template class MyArray { public: using Iter = Type*; // I'm just too lazy for my own iterator implementation will do it later using ConstIter = const Type*; // same as above using size_type = std::size_t; //It's just a standard in containers implementations, don't mind it MyArray() : m_size (0) , m_capacity (16) // default , m_tab (new Type[sizeof(Type) * m_capacity]) { } MyArray(const MyArray& rhs) : m_size (rhs.m_size) , m_capacity (rhs.m_capacity) , m_tab (new Type[sizeof(Type) * m_capacity]) { // deep copy required Type * rhsTmp = rhs.m_tab.get(); for (size_type i = 0; i < m_size; ++i) { m_tab.get()[i] = rhsTmp[i]; } } MyArray(MyArray&& rhs) : m_size (std::move(rhs.m_size)) , m_capacity (std::move(rhs.m_capacity)) , m_tab (std::move(rhs.m_tab)) { } explicit MyArray(const size_type & size) : m_size (size) , m_capacity (size + 2) //safe padding , m_tab (new Type[sizeof(Type) * m_capacity]) { } MyArray(const std::initializer_list & initList) : m_size (initList.size()) , m_capacity (initList.size() + 2) //safety padding , m_tab (new Type[sizeof(Type) * m_capacity]) { for(size_type i = 0; i < m_size; i++) { m_tab.get()[i] = *(initList.begin() + i); } } ~MyArray() { for(Iter it = m_tab.get(); it != &m_tab.get()[m_size]; ++it) { (*it).~Type(); } } MyArray& operator=(MyArray rhs) noexcept { swap(*this, rhs); return *this; } Type& operator[](size_type index) { return m_tab.get()[index]; } const Type& operator[](size_type index) const { return m_tab.get()[index]; } friend void swap(MyArray& lhs, MyArray& rhs) noexcept { // Enabling ADL using std::swap; swap(lhs.m_size, rhs.m_size); swap(lhs.m_capacity, rhs.m_capacity); swap(lhs.m_tab, rhs.m_tab); } void setCapacity(size_type elements) { Type* oldData = m_tab.release(); for(Iter it = &m_tab.get()[m_size]; it != &m_tab.get()[0]; --it) { (*it).~Type(); } m_tab = std::unique_ptr(new Type[sizeof(Type) * elements]); m_capacity = elements; std::copy(&oldData[0], &oldData[m_size], &m_tab.get()[0]); oldData = nullptr; } void fitToSize() { setCapacity(m_size); } void pushBack(Type val) { ++m_size; if(m_size >= m_capacity) { setCapacity(m_capacity + 16); } m_tab.get()[m_size-1] = val; } size_type size() const noexcept { return m_size; } size_type capacity() const noexcept { return m_capacity; } bool empty() const noexcept { return m_size == 0; } Iter begin() const noexcept { return &m_tab.get()[0]; } Iter end() const noexcept { return &m_tab.get()[0] + m_size; } ConstIter cbegin() const noexcept { return m_tab.get(); } ConstIter cend() const noexcept { return &m_tab.get()[m_size]; } private: size_type m_size; size_type m_capacity; std::unique_ptr m_tab; }; // So you can use std::cout << arr; template std::ostream& operator <<(std::ostream& out,const MyArray &arr) { std::copy(&arr[0], &arr[arr.size()], std::ostream_iterator(out, " ")); return out; } int main() { MyArray arr = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17}; arr.pushBack(18); arr.pushBack(98); arr.pushBack(21); MyArray arr2 = arr; std::cout << arr << std::endl; std::cout << arr2 << std::endl; std::cout << "Capacity before: " << arr.capacity() << std::endl; arr.setCapacity(arr.capacity() + 10); std::cout << "Capacity after: " << arr.capacity() << std::endl; arr.fitToSize(); std::cout << "Capacity after fitToSize: " << arr.capacity() << std::endl; return 0; }

[C++] Custom dynamic container