TD3 Joker : Added Deque Inheritance.

td/td3/include/deque.h

@@ -0,0 +1,104 @@
+#ifndef HEADER_DEQUE
+#define HEADER_DEQUE
+
+#include "vector.h"
+#include <algorithm>
+#include <iostream>
+
+template <class T>
+class Deque : public Vector<T> {
+public:
+    Deque() : Vector<T>(), _frontIndex(-1) {};
+    Deque(size_t capacity): Vector<T>(capacity), _frontIndex(-1) {};
+    Deque(size_t capacity, T value): Vector<T>(capacity,value), _frontIndex(-1) {};
+    Deque(const Vector<T>& other) : Vector<T>(other), _frontIndex(-1) {};
+    void PushFront(T value);
+    Deque<T> GetFront(void);
+    Deque<T> GetBack(void);
+    void RemoveFront(void);
+    void RemoveBack(void);
+    void ShrinkToFit(void);
+private:
+    size_t _frontIndex;
+};
+
+template <class T>
+void Deque<T>::PushFront(T value)
+{
+    // if the next size will overload the heap
+    // We create a new allocation, and shift each data
+    if (this->_capacity < this->_size + 1) {
+        auto oldPtr = this->_values;
+        this->_values = new T[this->_size * 2];
+        this->_capacity *= 2;
+        for (size_t i = 0; i < this->_size; i++)
+            this->_values[i+1] = oldPtr[i];
+        delete[] oldPtr;
+    }
+    // Else we only shift the data
+    else{
+        // _values[0] will be overwritten, so it serves as a temporary value
+        // To store the overwritten index
+        auto tempActual(this->_values[0]);
+        for(size_t i=0; i< this->_size ; i++)
+        {
+            this->_values[0] = this->_values[i+1];
+            this->_values[i+1] = tempActual;
+            tempActual = this->_values[0];
+        }
+    }
+    this->_values[0] = value;
+    this->_size++;
+    _frontIndex++;
+}
+
+template <class T>
+Deque<T> Deque<T>::GetFront(void)
+{
+    if(this->_frontIndex == -1)
+        throw "This Deque doesn't have front elements";
+    Deque<T> returnDeque(this->_frontIndex+1);
+    returnDeque._size = this->_frontIndex+1;
+    for(size_t i=0; i< this->_frontIndex+1 ; i++)
+        returnDeque._values[i] = this->_values[i];
+    return returnDeque;
+}
+
+template <class T>
+Deque<T> Deque<T>::GetBack(void)
+{
+    Deque<T> returnDeque(this->_size-(this->_frontIndex+1));
+    returnDeque._size = this->_size-(this->_frontIndex+1);
+    for(size_t i = this->_frontIndex+1, j=0 ; i<this->_size ; i++, j++)
+        returnDeque._values[j] = this->_values[i];
+    return returnDeque;
+}
+
+template <class T>
+void Deque<T>::RemoveFront(void)
+{
+    for(size_t i = this->_frontIndex+1, j=0 ; i<this->_size ; i++, j++)
+        this->_values[j] = this->_values[i];
+    this->_size -= (this->_frontIndex+1);
+    this->_frontIndex = -1;
+}
+
+// The Capacity is not shrunk during this process.
+template <class T>
+void Deque<T>::RemoveBack(void)
+{
+    this->_size = this->_frontIndex+1;
+}
+
+template <class T>
+void Deque<T>::ShrinkToFit(void)
+{
+    auto oldPtr = this->_values;
+    this->_values = new T[this->_size];
+    for(size_t i=0; i<this->_size; i++)
+        this->_values[i] = oldPtr[i];
+    delete[] oldPtr;
+    this->_capacity = this->_size;
+}
+
+#endif //HEADER_DEQUE

td/td3/src/main.cpp

@@ -1,5 +1,8 @@
 #include "../include/vector.h"
 #include "../include/smart_vector.h"
+#include "../include/deque.h"
+// Joker : slice.h
+// Joker : vector_iteraor.h
 #include <iostream>
 
 int main(void)
@@ -20,5 +23,28 @@ int main(void)
     little = Smart_Vector<int>(5,1);
     big += little;
     std::cout << big << std::endl;
+
+    // Deque test
+    Deque<int> dequeInt;
+    for(int i=0; i<6; i++)
+        dequeInt.PushBack(i);
+    std::cout << "Deque push back: " << dequeInt << std::endl;
+    for(int i=1; i<=6; i++)
+        dequeInt.PushFront(i*10);
+    std::cout << "Deque push front: " << dequeInt << std::endl;
+    std::cout << "End capacity: " << dequeInt.Capacity() << std::endl;
+
+    std::cout << "Deque Front Elements: " << dequeInt.GetFront() << std::endl;
+    std::cout << "Deque Back Elements: " << dequeInt.GetBack() << std::endl;
+    dequeInt.RemoveBack();
+    std::cout << "After Removing Back: " << dequeInt << std::endl;
+    dequeInt.PushBack(56);
+    std::cout << "Pushing Back again: " << dequeInt << std::endl;
+    dequeInt.RemoveFront();
+    std::cout << "After Removing Front: " << dequeInt << std::endl;
+    dequeInt.PushFront(10);
+    std::cout << "Front: " << dequeInt.GetFront() << "\tBack: " << dequeInt.GetBack() << "\tFull Deque: " << dequeInt << "\tWith Capacity: " << dequeInt.Capacity() << std::endl;
+    dequeInt.ShrinkToFit();
+    std::cout << "After ShrinkToFit: " << dequeInt.Capacity() << "\tWith: " << dequeInt << std::endl;
     return 0;
 }