library/Array.h at master · beerlincur/library · GitHub

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
#include <algorithm>
#include <initializer_list>
#include <iostream>
#include "Book.h"


using std::initializer_list;
using std::fill;
using std::copy;
using std::swap;

template <typename T>
class Array
{
public:
	Array() : data_(nullptr), size_(0) {};
	Array(const initializer_list<T>&);
	Array(const size_t size);
	Array(const Array&);

	Array& operator=(const Array&);
	T* begin() const;
	T* end() const;
	T& operator [](const size_t);
	const T& operator [](const size_t) const;
	size_t size() const;
	friend class Book;
	~Array();

private:
	void swap(Array&, Array&);
	T* data_;
	size_t size_;
};

template <typename T>
Array<T>::Array(const size_t size) :
	data_(new T[size]),
	size_(size)
{
	// âûçûâàåì êîíñòðóêòîðû äëÿ êàæäîãî ýëåìåíòà
	fill(data_, data_ + size_, T());
}

template<typename T>
Array<T>::Array(const initializer_list<T>& il) :
	data_(new T[il.size()]),
	size_(il.size())
{
	copy(il.begin(), il.end(), data_);
}

template <typename T>
Array<T>::Array(const Array& arr)
{
	size_ = arr.size_;
	if (arr.data_)
	{
		data_ = new T[size_];
		// êîïèðóåì ýëåìåíòû â íîâûé êîíòåéíåð
		copy(arr.data_, arr.data_ + size_, data_);
	}
	else
		data_ = nullptr;
}

template <typename T>
Array<T>& Array<T>::operator=(const Array& arr)
{
	// èñêëþ÷àåì ðàáîòó ïðè ïðèñâàèâàíèè ñàìîìó ñåáå
	if (this != &arr)
		Array(arr).swap(*this);
	return *this;
}


template <typename T>
T* Array<T>::begin() const { return data_; }

template <typename T>
T* Array<T>::end() const { return data_ + size_; }

template <typename T>
T& Array<T>::operator [](const size_t index) { return data_[index]; }

template <typename T>
const T& Array<T>::operator [](const size_t index) const { return data_[index]; }

template <typename T>
size_t Array<T>::size() const { return size_; }

template <typename T>
void Array<T>::swap(Array& first, Array& second)
{
	swap(first.data_, second.data_);
	swap(first.size_, second.size_);
}

template <typename T>
Array<T>::~Array() { delete[] data_; }