From 4ea9f2ad6d0597cbd57d151ecf01d85dd40370ed Mon Sep 17 00:00:00 2001 From: Dmitriy Date: Wed, 13 Jan 2016 18:51:43 +0300 Subject: [PATCH 1/5] Changed --- include/array.h | 257 ++++++++++++++++++++++++ tests/test_array.cpp | 451 +++++++++++++++++++++++++++++++++++++++++++ 2 files changed, 708 insertions(+) create mode 100644 include/array.h create mode 100644 tests/test_array.cpp diff --git a/include/array.h b/include/array.h new file mode 100644 index 0000000..bf4656c --- /dev/null +++ b/include/array.h @@ -0,0 +1,257 @@ +#ifndef ARRAY_ARRAY_H +#define ARRAY_ARRAY_H + +#include +#include +#include + +template +class Vector { +public: + // Member types + 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*; + + static value_type invar; + + // Member function + Vector(); + + explicit Vector(size_type count); + + Vector(size_type count, const value_type& value); + + Vector(const Vector &other); + + Vector(Vector&& other) noexcept; + + ~Vector(); + + Vector& operator=(const Vector& other); + + Vector& operator=(Vector&& other) noexcept; + + // Element access + reference operator[](size_type pos) noexcept; + + const_reference operator[](size_type pos) const noexcept; + + // at() checks pos and throws std::out_of_range is pos >= size() + reference at(size_type pos); + + const_reference at(size_type pos) const; + + reference front() noexcept; + + const_reference front() const noexcept; + + reference back() noexcept; + + const_reference back() const noexcept; + + pointer data() noexcept; + + const_pointer data() const noexcept; + + // Capacity + bool empty() const noexcept; + + size_type size() const noexcept; + + size_type capacity() const noexcept; + + // Modifiers + void clear(); + + void push_back(const value_type& value); + +private: + //Member + value_type *data_; + size_type size_; + size_type capacity_; + +}; + +template +T Vector::invar = T(); + +template +Vector::Vector() { + data_ = new value_type[1]; + capacity_ = 1; + size_ = 0; +} + +template +Vector::Vector(size_type count) { + data_ = new value_type[2*count]; + capacity_ = 2*count; + size_ = count; +} + +template +Vector::Vector(size_type count, const value_type& value) { + data_ = new value_type[2*count]; + capacity_ = 2*count; + size_ = count; + for(size_type i = 0; i < count; ++i) { + *(data_ + i) = value; + } +} + +template +Vector::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); + } +} + +template +Vector::Vector(Vector&& other) noexcept { + size_ = other.size_; + other.size_ = 0; + capacity_ = other.capacity_; + other.capacity_ = 0; + data_ = other.data_; + other.data_ = &Vector::invar; +} + +template +Vector::~Vector() { + if (data_ != &Vector::invar) { + delete[] data_; + } +} + +template +Vector & 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[2*other.size_]; + capacity_ = 2*other.size_; + for(size_type i = 0; i < other.size_; ++i) { + *(data_ + i) = *(other.data_ + i); + } + } + size_ = other.size_; +} + +template +Vector & Vector::operator=(Vector&& other) noexcept { + size_ = other.size_; + capacity_ = other.capacity_; + delete [] data_; + data_ = other.data_; + other.size_ = 0; + other.capacity_ = 0; + other.data_ = &Vector::invar; +} + +template +T& Vector::operator[](size_type pos) noexcept { /* noexcept? */ + return *(data_ + pos); +} + +template +const T& Vector::operator[](size_type pos) const noexcept { /* noexcept ? */ + return *(data_ + pos); +} + +template +T& Vector::at(size_type pos) { + if (pos >= size_) { /* capacity */ + throw std::out_of_range(""); + } + value_type *pt = data_ + pos; + return *(pt); +} + +template +const T& Vector::at(size_type pos) const { + if (pos >= size_) { /* capacity */ + throw std::out_of_range(""); + } + value_type *pt = data_ + pos; + return *(pt); +} + +template +T& Vector::front() noexcept { + return *data_; +} + +template +const T& Vector::front() const noexcept { + return *data_; +} + +template +T& Vector::back() noexcept { + return *(data_ + size_ - 1); +} + +template +const T& Vector::back() const noexcept { + return *(data_ + size_ - 1); +} + +template +T* Vector::data() noexcept { + return data_; +} + +template +const T* Vector::data() const noexcept { + return data_; +} + +template +bool Vector::empty() const noexcept { + return size_ != 0 ? false : true; +} + +template +std::size_t Vector::size() const noexcept { + return size_; +} + +template +std::size_t Vector::capacity() const noexcept { + return capacity_; +} + +template +void Vector::clear() { + size_ = 0; +} + +template +void Vector::push_back(const value_type& value) { + if ((size_ + 1) <= capacity_) { + *(data_ + size_) = value; + ++size_; + } else { + ++size_; + capacity_ = 2*size_; + value_type *tmp = new value_type[capacity_]; + for(size_type i = 0; i < size_ - 1; ++i) { + *(tmp + i) = *(data_ + i); + } + *(++tmp) = value; + data_ = tmp; + } +} + +#endif //ARRAY_ARRAY_H diff --git a/tests/test_array.cpp b/tests/test_array.cpp new file mode 100644 index 0000000..a097823 --- /dev/null +++ b/tests/test_array.cpp @@ -0,0 +1,451 @@ +#define CATCH_CONFIG_MAIN // This tells Catch to provide a main() - only do this in one cpp file + +#include "array.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); + } + /* SECTION("*char") { + Vector<*char> 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); + } + /* 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); + REQUIRE(*v.data() == Vector::invar); + } + 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); + REQUIRE(*v.data() == Vector::invar); + } + 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); + REQUIRE(*v.data() == Vector::invar); + } +} + +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); + REQUIRE(v.data() == &Vector::invar); + } + 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); + REQUIRE(v.data() == &Vector::invar); + } + 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); + REQUIRE(v.data() == &Vector::invar); + } +} + +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 d0b505cf89bd871c77a8e7b5441f23d22028d3eb Mon Sep 17 00:00:00 2001 From: Dmitriy Date: Wed, 13 Jan 2016 19:13:51 +0300 Subject: [PATCH 2/5] Commit for Travis CI --- .idea/MyArray.iml | 17 +++++++++++++++-- .idea/vcs.xml | 1 + CMakeLists.txt | 1 + 3 files changed, 17 insertions(+), 2 deletions(-) diff --git a/.idea/MyArray.iml b/.idea/MyArray.iml index abb1554..f15ed7e 100644 --- a/.idea/MyArray.iml +++ b/.idea/MyArray.iml @@ -2,13 +2,26 @@ + - - + + + + + + + + + + + + + + diff --git a/.idea/vcs.xml b/.idea/vcs.xml index 94a25f7..f1d963c 100644 --- a/.idea/vcs.xml +++ b/.idea/vcs.xml @@ -2,5 +2,6 @@ + \ No newline at end of file diff --git a/CMakeLists.txt b/CMakeLists.txt index a276e05..6d280ad 100644 --- a/CMakeLists.txt +++ b/CMakeLists.txt @@ -2,6 +2,7 @@ cmake_minimum_required(VERSION 2.8) project(MyArray) + if (MSVC) add_definitions(/W4) else() From 409debf432eb8dd25bd014eb34f437905ae5292a Mon Sep 17 00:00:00 2001 From: Dmitriy Date: Wed, 13 Jan 2016 19:26:51 +0300 Subject: [PATCH 3/5] Travis CI and appveyor has been passed --- .idea/workspace.xml | 105 +++++++++++++++++++++++++++++--------------- README.md | 4 +- 2 files changed, 73 insertions(+), 36 deletions(-) diff --git a/.idea/workspace.xml b/.idea/workspace.xml index a04a52e..a4b8856 100644 --- a/.idea/workspace.xml +++ b/.idea/workspace.xml @@ -12,22 +12,8 @@ - - - - - - - - - - - - - - - - + + @@ -47,17 +33,30 @@ - - + + - - + + + + + + + + + + + + + + + @@ -144,6 +143,11 @@ + + + + + @@ -152,17 +156,17 @@ - + - + - - + + @@ -176,6 +180,13 @@ @@ -184,26 +195,31 @@ - - - + + + + + - - + + + - - - + + - + + + @@ -211,11 +227,30 @@ - - + + + + + + + + + + + + + + + + + + + + + \ No newline at end of file diff --git a/README.md b/README.md index 8e7a0fa..73a4c16 100644 --- a/README.md +++ b/README.md @@ -1 +1,3 @@ -# MyArray \ No newline at end of file +# MyArray +[![Build Status](https://travis-ci.org/Demitriy/MyArray.svg?branch=WorkingBranch)](https://travis-ci.org/Demitriy/MyArray) +[![Build status](https://ci.appveyor.com/api/projects/status/8uqq44fnlwtvorha?svg=true)](https://ci.appveyor.com/project/Demitriy/myarray) From 6d0a462dbf904be5014a15e6996df36655fdf65d Mon Sep 17 00:00:00 2001 From: Dmitriy Date: Thu, 14 Jan 2016 02:21:01 +0300 Subject: [PATCH 4/5] Travis CI and appveyor has been passed #2 --- .idea/workspace.xml | 146 +++++++++++++++++++++++++++++++++++++++----- CMakeLists.txt | 1 - include/array.h | 2 +- 3 files changed, 133 insertions(+), 16 deletions(-) diff --git a/.idea/workspace.xml b/.idea/workspace.xml index a4b8856..900932a 100644 --- a/.idea/workspace.xml +++ b/.idea/workspace.xml @@ -3,6 +3,7 @@ + @@ -11,9 +12,10 @@ - + - + + @@ -44,28 +46,37 @@ - - + + + + + + + + + + + + - - - + @@ -123,12 +134,40 @@ - + @@ -186,20 +225,26 @@ - + - + - + @@ -213,12 +258,22 @@ + + + + - @@ -226,6 +281,14 @@ + + + + + + + + @@ -241,16 +304,71 @@ - + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + \ No newline at end of file diff --git a/CMakeLists.txt b/CMakeLists.txt index 6d280ad..a276e05 100644 --- a/CMakeLists.txt +++ b/CMakeLists.txt @@ -2,7 +2,6 @@ cmake_minimum_required(VERSION 2.8) project(MyArray) - if (MSVC) add_definitions(/W4) else() diff --git a/include/array.h b/include/array.h index bf4656c..a2eb2f2 100644 --- a/include/array.h +++ b/include/array.h @@ -249,7 +249,7 @@ void Vector::push_back(const value_type& value) { for(size_type i = 0; i < size_ - 1; ++i) { *(tmp + i) = *(data_ + i); } - *(++tmp) = value; + *(tmp + size_ - 1) = value; data_ = tmp; } } From 30612e6fd49b592131e64bf5cfd162822d70c444 Mon Sep 17 00:00:00 2001 From: Dmitriy Date: Wed, 10 Feb 2016 16:24:30 +0300 Subject: [PATCH 5/5] Change 10.02.16 #1 --- .idea/workspace.xml | 295 ++++++++++++++++++++++++++++++++++++++++--- include/array.h | 55 +++----- tests/test_array.cpp | 12 +- 3 files changed, 304 insertions(+), 58 deletions(-) diff --git a/.idea/workspace.xml b/.idea/workspace.xml index 900932a..8834ec5 100644 --- a/.idea/workspace.xml +++ b/.idea/workspace.xml @@ -12,10 +12,10 @@ - + - + @@ -49,9 +49,29 @@ - - - + + + + + + + + + + + + + + + + + + + + + + + @@ -60,7 +80,7 @@ - + @@ -76,6 +96,7 @@ @@ -167,9 +188,9 @@ - + - + @@ -195,7 +216,7 @@ - + @@ -231,16 +252,22 @@ - + - + @@ -280,6 +307,138 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + @@ -289,6 +448,34 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + @@ -308,10 +495,66 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + @@ -357,16 +600,36 @@ - + - - - + + + + + + + + + + + + + + + + + + + + + + + diff --git a/include/array.h b/include/array.h index a2eb2f2..97dcd96 100644 --- a/include/array.h +++ b/include/array.h @@ -16,8 +16,6 @@ class Vector { using pointer = value_type*; using const_pointer = const value_type*; - static value_type invar; - // Member function Vector(); @@ -71,6 +69,7 @@ class Vector { private: //Member + static value_type invar; value_type *data_; size_type size_; size_type capacity_; @@ -81,34 +80,20 @@ template T Vector::invar = T(); template -Vector::Vector() { - data_ = new value_type[1]; - capacity_ = 1; - size_ = 0; -} +Vector::Vector() : data_(new value_type[1]), capacity_(1), size_(0) {} template -Vector::Vector(size_type count) { - data_ = new value_type[2*count]; - capacity_ = 2*count; - size_ = count; -} +Vector::Vector(size_type count) : data_(new value_type[2*count]), capacity_(2*count), size_(count) {} template -Vector::Vector(size_type count, const value_type& value) { - data_ = new value_type[2*count]; - capacity_ = 2*count; - size_ = count; +Vector::Vector(size_type count, const value_type& value) : data_(new value_type[2*count]), capacity_(2*count), size_(count) { for(size_type i = 0; i < count; ++i) { *(data_ + i) = value; } } template -Vector::Vector(const Vector &other) { - size_ = other.size_; - capacity_ = other.capacity_; - data_ = new value_type[capacity_]; +Vector::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); } @@ -121,12 +106,12 @@ Vector::Vector(Vector&& other) noexcept { capacity_ = other.capacity_; other.capacity_ = 0; data_ = other.data_; - other.data_ = &Vector::invar; + other.data_ = &invar; } template Vector::~Vector() { - if (data_ != &Vector::invar) { + if (data_ != &invar) { delete[] data_; } } @@ -160,31 +145,29 @@ Vector & Vector::operator=(Vector&& other) noexcept { } template -T& Vector::operator[](size_type pos) noexcept { /* noexcept? */ - return *(data_ + pos); +T& Vector::operator[](size_type pos) noexcept { + return data_[pos]; } template -const T& Vector::operator[](size_type pos) const noexcept { /* noexcept ? */ - return *(data_ + pos); +const T& Vector::operator[](size_type pos) const noexcept { + return data_[pos]; } template T& Vector::at(size_type pos) { - if (pos >= size_) { /* capacity */ - throw std::out_of_range(""); + if (pos >= size_) { + throw std::out_of_range("out_of_range"); } - value_type *pt = data_ + pos; - return *(pt); + return data_[pos]; } template const T& Vector::at(size_type pos) const { - if (pos >= size_) { /* capacity */ - throw std::out_of_range(""); + if (pos >= size_) { + throw std::out_of_range("out_of_rane"); } - value_type *pt = data_ + pos; - return *(pt); + return data_[pos]; } template @@ -199,12 +182,12 @@ const T& Vector::front() const noexcept { template T& Vector::back() noexcept { - return *(data_ + size_ - 1); + return data_[size_ - 1]; } template const T& Vector::back() const noexcept { - return *(data_ + size_ - 1); + return data_[size_ - 1]; } template diff --git a/tests/test_array.cpp b/tests/test_array.cpp index a097823..83b65a5 100644 --- a/tests/test_array.cpp +++ b/tests/test_array.cpp @@ -110,7 +110,7 @@ TEST_CASE("Assigment ctor") { Vector w(std::move(v)); cmp_array(w, expected, 3); REQUIRE(v.size() == 0); - REQUIRE(*v.data() == Vector::invar); + REQUIRE(*v.data() == int()); } SECTION("double") { Vector v{3}; @@ -121,7 +121,7 @@ TEST_CASE("Assigment ctor") { Vector w(std::move(v)); cmp_array(w, expected, 3); REQUIRE(v.size() == 0); - REQUIRE(*v.data() == Vector::invar); + REQUIRE(*v.data() == double()); } SECTION("char") { Vector v{3}; @@ -132,7 +132,7 @@ TEST_CASE("Assigment ctor") { Vector w(std::move(v)); cmp_array(w, expected, 3); REQUIRE(v.size() == 0); - REQUIRE(*v.data() == Vector::invar); + REQUIRE(*v.data() == char()); } } @@ -176,7 +176,7 @@ TEST_CASE("Assigment") { Vector w = std::move(v); cmp_array(w, expected, 3); REQUIRE(v.size() == 0); - REQUIRE(v.data() == &Vector::invar); + REQUIRE(*v.data() == int()); } SECTION("double") { Vector v{3}; @@ -187,7 +187,7 @@ TEST_CASE("Assigment") { Vector w = std::move(v); cmp_array(w, expected, 3); REQUIRE(v.size() == 0); - REQUIRE(v.data() == &Vector::invar); + REQUIRE(*v.data() == double()); } SECTION("char") { Vector v{3}; @@ -198,7 +198,7 @@ TEST_CASE("Assigment") { Vector w = std::move(v); cmp_array(w, expected, 3); REQUIRE(v.size() == 0); - REQUIRE(v.data() == &Vector::invar); + REQUIRE(*v.data() == char()); } }