fork download 
  1. #include <iostream>
  2. #include <utility>
  3.  
  4. template<class T>
  5. class MyVector
  6. {
  7. private:
  8.     int size_;
  9.     int capacity_;
  10.     T* data;
  11.  
  12. 	void grow();
  13.  
  14. public:
  15.     typedef T* it;
  16.  
  17. 	MyVector();
  18. 	MyVector(const MyVector &src);
  19. 	MyVector(MyVector &&src);
  20. 	~MyVector();
  21.  
  22. 	MyVector& operator=(MyVector rhs);
  23.  
  24.     it begin();
  25.     it end();
  26. 	int size();
  27.  
  28.     void push_back(const T& value);
  29.     void insert(it pos, const T& value);
  30. };
  31.  
  32. template<class T>
  33. MyVector<T>::MyVector()
  34.     : size_(0), capacity_(0), data(nullptr)
  35. {
  36. }
  37.  
  38. template<class T>
  39. MyVector<T>::MyVector(const MyVector &src)
  40.     : size_(src.size_), capacity_(src.capacity_), data(new T[src.size_])
  41. {
  42.     for (int i = 0; i < size_; ++i)
  43.     	data[i] = src.data[i];
  44. }
  45.  
  46. template<class T>
  47. MyVector<T>::MyVector(MyVector &&src)
  48.     : size_(src.size_), capacity_(src.capacity_), data(src.data)
  49. {
  50.     src.size_ = 0;
  51.     src.capacity_ = 0;
  52.     src.data = nullptr;
  53. }
  54.  
  55. template<class T>
  56. MyVector<T>::~MyVector()
  57. {
  58. 	delete[] data;	
  59. }
  60.  
  61. template<class T>
  62. MyVector<T>& MyVector<T>::operator=(MyVector rhs)
  63. {
  64. 	std::swap(size_, rhs.size_);
  65.     std::swap(capacity_, rhs.capacity_);
  66.     std::swap(data, rhs.data);
  67.     return *this;
  68. }
  69.  
  70. template<class T>
  71. typename MyVector<T>::it MyVector<T>::begin()
  72. {
  73. 	return data;
  74. }
  75.  
  76. template<class T>
  77. typename MyVector<T>::it MyVector<T>::end()
  78. {
  79. 	return data + size_;	
  80. }
  81.  
  82. template<class T>
  83. int MyVector<T>::size()
  84. {
  85. 	return size_;
  86. }
  87.  
  88. template<class T>
  89. void MyVector<T>::grow()
  90. {
  91. 	static const int delta = 5; // <-- use whatever value makes sense for your use case...
  92. 	int new_cap = capacity_ + delta;
  93.     T* new_data = new T[new_cap];
  94.     for(int i = 0; i < size_; ++i) {
  95.         new_data[i] = std::move(data[i]);
  96.     }
  97.     delete[] data;
  98.     data = new_data;
  99.     capacity_ = new_cap;
  100. }
  101.  
  102. template<class T>
  103. void MyVector<T>::push_back(const T & v)
  104. {
  105.     if (size_ == capacity_)
  106.         grow();
  107.  
  108.     data[size_] = v;
  109.     ++size_;
  110. }
  111.  
  112. template<class T>
  113. void MyVector<T>::insert(typename MyVector<T>::it pos, const T & v)
  114. {
  115.     int index = pos - data;
  116.     if (index < 0 || index > size_)
  117.         return; // or throw...
  118.  
  119.     if (size_ == capacity_)
  120.         grow();
  121.  
  122.     for(int i = size_ - 1; i >= index; --i)
  123.         data[i+1] = data[i];
  124.  
  125.     data[index] = v;
  126.     ++size_;
  127. }
  128.  
  129. int main()
  130. {
  131. 	MyVector<int> vec;
  132.  
  133. 	auto printVec = [&](){
  134. 		if (vec.size() == 0) {
  135. 			std::cout << "(empty)";
  136. 		}
  137. 		else {
  138. 			for(auto &value : vec)
  139. 				std::cout << value << ' ';
  140. 		}
  141. 		std::cout << std::endl;
  142. 	};
  143.  
  144. 	std::cout << "Before: "; printVec();
  145.  
  146.     vec.push_back(1);
  147.     vec.push_back(3);
  148.     vec.push_back(5);
  149.  
  150. 	std::cout << "After push_back: "; printVec();
  151.  
  152.     vec.insert(vec.begin()+1, 2);
  153.     vec.insert(vec.end()-1, 4);
  154.  
  155. 	std::cout << "After insert: "; printVec();
  156.  
  157. 	return 0;
  158. }
Success #stdin #stdout 0s 4380KB
comments (?)
stdin 
Standard input is empty
stdout 
Before: (empty)
After push_back: 1 3 5 
After insert: 1 2 3 4 5
https://ideone.com/GhO5M6
language:
C++ (gcc 8.3)
created:
5 years ago
visibility:
public

Share or Embed source code

Discover > Sphere Engine API

The brand new service which powers Ideone!

Discover > IDE Widget

Widget for compiling and running the source code in a web browser!