From 4cc2a0b652117008af2d27ac5fd094d197b5db0b Mon Sep 17 00:00:00 2001 From: Waaazzzuuup Date: Thu, 14 Jan 2016 07:30:23 +0300 Subject: [PATCH 1/3] add --- include/vector.h | 216 +++++++++++++++++++++ tests/test_vector.cpp | 428 ++++++++++++++++++++++++++++++++++++++++++ 2 files changed, 644 insertions(+) create mode 100644 include/vector.h create mode 100644 tests/test_vector.cpp diff --git a/include/vector.h b/include/vector.h new file mode 100644 index 0000000..d16d769 --- /dev/null +++ b/include/vector.h @@ -0,0 +1,216 @@ +#ifndef ARRAY_ARRAY_H +#define ARRAY_ARRAY_H + +#include +#include +#include + +template +class Vector +{ +public: + using value_type = T; + using size_type = std::size_t; + using reference = value_type&; + using const_reference = const value_type&; + using pointer = value_type*; + using const_pointer = const value_type*; + + Vector()// + { + data_ = new value_type[1]; + data_[0] = 0; + capacity_ = 1; + size_ = 0; + } + + explicit Vector(size_type count) + { + data_ = new value_type[count]; + capacity_ = count; + size_ = count; + } + + Vector(size_type count, const value_type& value) + { + data_ = new value_type[count]; + capacity_ = count; + size_ = count; + for (size_type i = 0; i < count; i++) + { + *(data_ + i) = value; + } + } + + Vector(const Vector &other) + { + size_ = other.size_; + capacity_ = other.capacity_; + data_ = new value_type[capacity_]; + for (size_type i = 0; i < size_; i++) + { + *(data_ + i) = *(other.data_ + i); + } + } + + Vector(Vector&& other) noexcept + { + size_ = other.size_; + other.size_ = 0; + capacity_ = other.capacity_; + other.capacity_ = 0; + data_ = other.data_; + other.data_ = nullptr; + } + + ~Vector() + { + delete[] data_; + } + + Vector &operator=(const Vector& other) + { + if (capacity_ >= other.size_) + { + for (size_type i = 0; i < other.size_; i++) + { + *(data_ + i) = *(other.data_ + i); + } + } + else + { + delete[] data_; + data_ = new value_type[other.size_]; + capacity_ = other.size_; + for (size_type i = 0; i < other.size_; ++i) + { + *(data_ + i) = *(other.data_ + i); + } + } + size_ = other.size_; + } + + Vector & operator=(Vector&& other) noexcept + { + delete[] data_; + size_ = other.size_; + capacity_ = other.capacity_; + data_ = other.data_; + other.size_ = 0; + other.capacity_ = 0; + other.data_ = nullptr; + return *this; + } + + T& operator[](size_type pos) noexcept + { + return *(data_ + pos); + } + + const T& operator[](size_type pos) const noexcept + { + return *(data_ + pos); + } + + T& at(size_type pos) + { + if (pos >= size_) + { + throw std::out_of_range("positon >= size of vector"); + } + value_type *pt = data_ + pos; + return *(pt); + } + + const T& at(size_type pos) const + { + if (pos >= size_) + { + throw std::out_of_range("positon >= size of vector"); + } + char *temp = data_ + pos;// + return *(temp); + } + + T& front() noexcept + { + return *data_; + } + + const T& front() const noexcept + { + return *data_; + } + + T& back() noexcept + { + return *(data_ + size_ - 1); + } + + const T& back() const noexcept + { + return *(data_ + size_ - 1); + } + + T* data() noexcept + { + return data_; + } + + const T* data() const noexcept + { + return data_; + } + + bool empty() const noexcept + { + if (size_ == 0) + { + return true; + } + return false; + } + + std::size_t size() const noexcept + { + return size_; + } + + std::size_t capacity() const noexcept + { + return capacity_; + } + + void clear() + { + size_ = 0; + } + + void push_back(const value_type& value) + { + if ((size_ + 1) <= capacity_) + { + *(data_ + size_) = value; + size_++; + } + else + { + size_++; + capacity_ = 2 * size_; + value_type *temp = new value_type[capacity_]; + for (size_type i = 0; i < size_ - 1; i++) + { + *(temp + i) = *(data_ + i); + } + *(temp + size_ - 1) = value; + data_ = temp; + } + } + +private: + value_type *data_; + size_type size_; + size_type capacity_; + +}; +#endif //ARRAY_ARRAY_H \ No newline at end of file diff --git a/tests/test_vector.cpp b/tests/test_vector.cpp new file mode 100644 index 0000000..ae3f6be --- /dev/null +++ b/tests/test_vector.cpp @@ -0,0 +1,428 @@ +#define CATCH_CONFIG_MAIN + +#include "vector.h" +#include "catch.hpp" + +template +void cmp_array(const Vector &rhs, const T *expected, const std::size_t N) { + REQUIRE(rhs.size() == N); + for(std::size_t i = 0; i < N; ++i) { + REQUIRE(rhs[i] == expected[i]); + } +} + +TEST_CASE("Vector default ctor") { + SECTION("int") { + Vector v; + REQUIRE(v.size() == 0); + REQUIRE(v.capacity() == 1); + } + SECTION("double") { + Vector v; + REQUIRE(v.size() == 0); + REQUIRE(v.capacity() == 1); + } + SECTION("char") { + Vector v; + REQUIRE(v.size() == 0); + REQUIRE(v.capacity() == 1); + } +} + +TEST_CASE("Vector explicit init ctor") { + SECTION("int") { + REQUIRE(Vector{6}.size() == 6); + } + SECTION("double") { + REQUIRE(Vector{6}.size() == 6); + } + SECTION("char") { + REQUIRE(Vector{6}.size() == 6); + } +} + +TEST_CASE("Vector init ctor") { + SECTION("int") { + Vector v{6, 6}; + int expected[] = {6, 6, 6, 6, 6, 6}; + REQUIRE(v.size() == 6); + cmp_array(v, expected, 6); + } + SECTION("double") { + Vector v{6, 6.1}; + double expected[] = {6.1, 6.1, 6.1, 6.1, 6.1, 6.1}; + REQUIRE(v.size() == 6); + cmp_array(v, expected, 6); + } + SECTION("char") { + Vector v{6, 'h'}; + char expected[] = {'h', 'h', 'h', 'h', 'h', 'h'}; + REQUIRE(v.size() == 6); + cmp_array(v, expected, 6); + } +} + +TEST_CASE("Copy ctor") { + SECTION("int") { + Vector v{3}; + int expected[] = {100, -1, 0}; + v[0] = 100; + v[1] = -1; + v[2] = 0; + Vector w{v}; + cmp_array(w, expected, 3); + } + SECTION("double") { + Vector v{3}; + double expected[] = {100.123, -1.01, 0.0}; + v[0] = 100.123; + v[1] = -1.01; + v[2] = 0.0; + Vector w{v}; + cmp_array(w, expected, 3); + } + SECTION("char") { + Vector v{3}; + char expected[] = {'h', '2', '+'}; + v[0] = 'h'; + v[1] = '2'; + v[2] = '+'; + Vector w{v}; + cmp_array(w, expected, 3); + } +} + +TEST_CASE("Assigment ctor") { + SECTION("int") { + Vector v{3}; + int expected[] = {100, -1, 0}; + v[0] = 100; + v[1] = -1; + v[2] = 0; + Vector w(std::move(v)); + cmp_array(w, expected, 3); + REQUIRE(v.size() == 0); + } + SECTION("double") { + Vector v{3}; + double expected[] = {100.123, -1.01, 0.0}; + v[0] = 100.123; + v[1] = -1.01; + v[2] = 0.0; + Vector w(std::move(v)); + cmp_array(w, expected, 3); + REQUIRE(v.size() == 0); + } + SECTION("char") { + Vector v{3}; + char expected[] = {'h', '2', '+'}; + v[0] = 'h'; + v[1] = '2'; + v[2] = '+'; + Vector w(std::move(v)); + cmp_array(w, expected, 3); + REQUIRE(v.size() == 0); + } +} + +TEST_CASE("Copy assigment") { + SECTION("int") { + Vector v{3}; + int expected[] = {100, -1, 0}; + v[0] = 100; + v[1] = -1; + v[2] = 0; + Vector w = v; + cmp_array(w, expected, 3); + } + SECTION("double") { + Vector v{3}; + double expected[] = {100.123, -1.01, 0.0}; + v[0] = 100.123; + v[1] = -1.01; + v[2] = 0.0; + Vector w = v; + cmp_array(w, expected, 3); + } + SECTION("char") { + Vector v{3}; + char expected[] = {'h', '2', '+'}; + v[0] = 'h'; + v[1] = '2'; + v[2] = '+'; + Vector w = v; + cmp_array(w, expected, 3); + } +} + +TEST_CASE("Assigment") { + SECTION("int") { + Vector v{3}; + int expected[] = {100, -1, 0}; + v[0] = 100; + v[1] = -1; + v[2] = 0; + Vector w = std::move(v); + cmp_array(w, expected, 3); + REQUIRE(v.size() == 0); + } + SECTION("double") { + Vector v{3}; + double expected[] = {100.123, -1.01, 0.0}; + v[0] = 100.123; + v[1] = -1.01; + v[2] = 0.0; + Vector w = std::move(v); + cmp_array(w, expected, 3); + REQUIRE(v.size() == 0); + } + SECTION("char") { + Vector v{3}; + char expected[] = {'h', '2', '+'}; + v[0] = 'h'; + v[1] = '2'; + v[2] = '+'; + Vector w = std::move(v); + cmp_array(w, expected, 3); + REQUIRE(v.size() == 0); + } +} + +TEST_CASE("Indxing operator") { + SECTION("int") { + Vector v{3}; + int expected[] = {100, -1, 0}; + for(std::size_t i = 0; i < 3; ++i) { + v[i] = expected[i]; + } + cmp_array(v, expected, 3); + } + SECTION("double") { + Vector v{3}; + double expected[] = {100.123, -1.01, 0.0}; + for (std::size_t i = 0; i < 3; ++i) { + v[i] = expected[i]; + } + cmp_array(v, expected, 3); + } + SECTION("char") { + Vector v{3}; + char expected[] = {'h', '2', '+'}; + for (std::size_t i = 0; i < 3; ++i) { + v[i] = expected[i]; + } + cmp_array(v, expected, 3); + } +} + +TEST_CASE("Method at") { + SECTION("int") { + Vector v{3}; + int expected[] = {0, -1, 1000}; + for (std::size_t i = 0; i < 3; ++i) { + v[i] = expected[i]; + } + REQUIRE_THROWS(v.at(12)); + REQUIRE(v.at(0) == expected[0]); + } + SECTION("double") { + Vector v{3}; + double expected[] = {100.123, -1.01, 0.0}; + for (std::size_t i = 0; i < 3; ++i) { + v[i] = expected[i]; + } + REQUIRE_THROWS(v.at(12)); + REQUIRE(v.at(0) == expected[0]); + } + SECTION("char") { + Vector v{3}; + char expected[] = {'h', '2', '+'}; + for (std::size_t i = 0; i < 3; ++i) { + v[i] = expected[i]; + } + REQUIRE_THROWS(v.at(12)); + REQUIRE(v.at(0) == expected[0]); + } +} + +TEST_CASE("Method front") { + SECTION("int") { + Vector v{3}; + int expected[] = {100, -1, 0}; + for(std::size_t i = 0; i < 3; ++i) { + v[i] = expected[i]; + } + REQUIRE(v.front() == v[0]); + } + SECTION("double") { + Vector v{3}; + double expected[] = {100.123, -1.01, 0.0}; + for (std::size_t i = 0; i < 3; ++i) { + v[i] = expected[i]; + } + REQUIRE(v.front() == v[0]); + } + SECTION("char") { + Vector v{3}; + char expected[] = {'h', '2', '+'}; + for (std::size_t i = 0; i < 3; ++i) { + v[i] = expected[i]; + } + REQUIRE(v.front() == v[0]); + } +} + +TEST_CASE("Method back") { + SECTION("int") { + Vector v{3}; + int expected[] = {100, -1, 0}; + for(std::size_t i = 0; i < 3; ++i) { + v[i] = expected[i]; + } + REQUIRE(v.back() == v[2]); + } + SECTION("double") { + Vector v{3}; + double expected[] = {100.123, -1.01, 0.0}; + for (std::size_t i = 0; i < 3; ++i) { + v[i] = expected[i]; + } + REQUIRE(v.back() == v[2]); + } + SECTION("char") { + Vector v{3}; + char expected[] = {'h', '2', '+'}; + for (std::size_t i = 0; i < 3; ++i) { + v[i] = expected[i]; + } + REQUIRE(v.back() == v[2]); + } +} + +TEST_CASE("Method pointer") { + SECTION("int") { + Vector v{3}; + int expected[] = {100, -1, 0}; + for(std::size_t i = 0; i < 3; ++i) { + v[i] = expected[i]; + } + REQUIRE(*v.data() == expected[0]); + REQUIRE(v.data() != nullptr); + } + SECTION("double") { + Vector v{3}; + double expected[] = {100.123, -1.01, 0.0}; + for (std::size_t i = 0; i < 3; ++i) { + v[i] = expected[i]; + } + REQUIRE(v.data() != nullptr); + REQUIRE(*v.data() == expected[0]); + } + SECTION("char") { + Vector v{3}; + char expected[] = {'h', '2', '+'}; + for (std::size_t i = 0; i < 3; ++i) { + v[i] = expected[i]; + } + REQUIRE(v.data() != nullptr); + REQUIRE(*v.data() == expected[0]); + } +} + +TEST_CASE("Method empty") { + SECTION("int") { + Vector v{3}; + v.clear(); + REQUIRE(v.empty()); + } + SECTION("double") { + Vector v{3}; + v.clear(); + REQUIRE(v.empty()); + } + SECTION("char") { + Vector v{3}; + v.clear(); + REQUIRE(v.empty()); + } +} + +TEST_CASE("Method size") { + SECTION("int") { + Vector v{3}; + REQUIRE(v.size() == 3); + } + SECTION("double") { + Vector v{105}; + REQUIRE(v.size() == 105); + } + SECTION("char") { + Vector v{1000}; + REQUIRE(v.size() == 1000); + } +} + +TEST_CASE("Method capacity") { + SECTION("int") { + Vector v{3}; + REQUIRE(v.size() <= v.capacity()); + } + SECTION("double") { + Vector v{105}; + REQUIRE(v.size() <= v.capacity()); + } + SECTION("char") { + Vector v{1000}; + REQUIRE(v.size() <= v.capacity()); + } +} + + +TEST_CASE("Method clear") { + SECTION("int") { + Vector v{3}; + v.clear(); + REQUIRE(v.size() == 0); + } + SECTION("double") { + Vector v{3}; + v.clear(); + REQUIRE(v.size() == 0); + } + SECTION("char") { + Vector v{3}; + v.clear(); + REQUIRE(v.size() == 0); + } +} + +TEST_CASE("Method push_back") { + SECTION("int") { + Vector v{3}; + int expected[] = {100, -1, 0, 4}; + for(std::size_t i = 0; i < 3; ++i) { + v[i] = expected[i]; + } + v.push_back(4); + cmp_array(v, expected, 4); + } + SECTION("double") { + Vector v{3}; + double expected[] = {100.123, -1.01, 0.0, -10.088}; + for (std::size_t i = 0; i < 3; ++i) { + v[i] = expected[i]; + } + v.push_back(-10.088); + cmp_array(v, expected, 4); + } + SECTION("char") { + Vector v{3}; + char expected[] = {'h', '2', '+', 'n'}; + for (std::size_t i = 0; i < 3; ++i) { + v[i] = expected[i]; + } + v.push_back('n'); + cmp_array(v, expected, 4); + } + +} From 230b80b89330627ec7a2054c818d75d9692babca Mon Sep 17 00:00:00 2001 From: Waaazzzuuup Date: Thu, 14 Jan 2016 07:41:54 +0300 Subject: [PATCH 2/3] add --- CMakeLists.txt | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/CMakeLists.txt b/CMakeLists.txt index b32f693..6033899 100644 --- a/CMakeLists.txt +++ b/CMakeLists.txt @@ -14,6 +14,6 @@ include_directories(include) enable_testing() -add_executable(test_vector tests/test_vector.cpp ${SOURCES}) +add_executable(test_vector tests/test_vector.cpp ) add_test(NAME ${PROJECT_NAME} COMMAND test_vector) \ No newline at end of file From 555f8f0d6ab8857cd34b8227bec4aca97224288d Mon Sep 17 00:00:00 2001 From: Waaazzzuuup Date: Thu, 14 Jan 2016 07:42:39 +0300 Subject: [PATCH 3/3] Create README.md --- README.md | 4 ++++ 1 file changed, 4 insertions(+) create mode 100644 README.md diff --git a/README.md b/README.md new file mode 100644 index 0000000..58ff702 --- /dev/null +++ b/README.md @@ -0,0 +1,4 @@ +# DynamicArray +Brand new dynamic array +[![Build Status](https://travis-ci.org/Waaazzzuuup/DynamicArray.svg?branch=work_branch)](https://travis-ci.org/Waaazzzuuup/DynamicArray) +[![Build status](https://ci.appveyor.com/api/projects/status/mt7defgixru5j7pe?svg=true)](https://ci.appveyor.com/project/Waaazzzuuup/dynamicarray)