src test dir, makefile, Added subject

3 files changed, 341 insertions, 0 deletions

diff --git a/src/List.hpp b/src/List.hpp
new file mode 100644
index 0000000..aca8f06
--- /dev/null
+++ b/src/List.hpp
@@ -0,0 +1,184 @@
+/* ************************************************************************** */
+/*                                                                            */
+/*                                                        :::      ::::::::   */
+/*   List.hpp                                           :+:      :+:    :+:   */
+/*                                                    +:+ +:+         +:+     */
+/*   By: cacharle <marvin@42.fr>                    +#+  +:+       +#+        */
+/*                                                +#+#+#+#+#+   +#+           */
+/*   Created: 2020/02/01 09:31:07 by cacharle          #+#    #+#             */
+/*   Updated: 2020/02/01 09:38:20 by cacharle         ###   ########.fr       */
+/*                                                                            */
+/* ************************************************************************** */
+
+#ifndef LIST_HPP
+# define LIST_HPP
+
+namespace ft
+{
+	template < typename T, typename Alloc = allocator<T> > 
+	class List
+	{
+
+		typedef T value_type;
+		typedef Alloc allocator_type;
+		typedef allocator_type::reference reference;
+		typedef allocator_type::const_reference const_reference;
+		typedef allocator_type::pointer pointer;
+		typedef allocator_type::const_pointer const_pointer;
+
+
+	
+	public:
+		List(const allocator_type& alloc = allocator_type());
+		{
+			front = nullptr;
+			back = nullptr;
+			size = 0;
+		}
+		// List(size_type n, const value_type& val = value_type(), const allocator_type& alloc = allocator_type());
+		// template <class InputIterator>
+	  	// List(InputIterator first, InputIterator last, const allocator_type& alloc = allocator_type());
+		// List(const list& x);
+		~List()
+		{
+			while (size > 0)
+				pop_front();
+		}
+		// List& operator = (const List& x);
+
+		// iterators
+		// iterator begin();
+		// const_iterator begin() const;
+		// iterator end();
+		// const_iterator end() const;
+		// reverse_iterator rbegin();
+		// const_reverse_iterator rbegin() const;
+		// reverse_iterator rend();
+		// const_reverse_iterator rend() const;
+
+		// capacity
+		bool empty() const
+		{
+			return front == nullptr;
+		}
+		size_type size() const
+		{
+			return size;
+		}
+
+		size_type max_size() const;
+
+		// element access
+		reference front()
+		{
+			return *front;
+		}
+
+		reference back()
+		{
+			return *back;
+		}
+		const_reference front() const;
+		const_reference back();
+
+		// modifiers
+		// template <class InputIterator>
+		// void assign (InputIterator first, InputIterator last);
+		// void assign (size_type n, const value_type& val);
+		void push_front (const value_type& val)
+		{
+			PrivateList *nfront = new PrivateList(val);
+			nfront->next = front;
+			front = nfront;
+			if (back == nullptr)
+				back = front;
+			size++;
+		}
+		void pop_front()
+		{
+			t_llist *nfront = front->next;
+			if (size == 1)
+				back = nullptr;
+			delete front;
+			front = nfront;
+			size--;
+		}
+		void push_back (const value_type& val)
+		{
+			PrivateList *nback = new PrivateList(val);
+			if (empty())
+			{
+				back = nback;
+				front = back;
+				return;
+			}
+			back->next = nback;
+			back = nback;
+			size++;
+		}
+		void pop_back()
+		{
+			t_llist *tmp = front;
+
+			while (tmp->next != back)
+				tmp = tmp->next;
+			delete back;
+			back = tmp;	
+		}
+		// iterator insert (iterator position, const value_type& val);
+		// void insert (iterator position, size_type n, const value_type& val);
+		// template <class InputIterator>
+		// void insert (iterator position, InputIterator first, InputIterator last);
+		// iterator erase (iterator position);
+		// iterator erase (iterator first, iterator last);
+		// void swap (list& x);
+		// void resize (size_type n, value_type val = value_type());
+		// void clear();
+
+		// operations
+		// void splice (iterator position, list& x);
+		// void splice (iterator position, list& x, iterator i);
+		// void splice (iterator position, list& x, iterator first, iterator last);
+		// void remove (const value_type& val);
+		// template <class Predicate>
+		// void remove_if (Predicate pred);
+		// void unique();
+		// template <class BinaryPredicate>
+		// void unique (BinaryPredicate binary_pred);
+        //
+		// void merge (list& x);
+		// template <class Compare>
+		// void merge (list& x, Compare comp);
+		// void sort();
+		// template <class Compare>
+		// void sort (Compare comp);
+		// void reverse();
+
+		// observers
+		// allocator_type get_allocator() const;
+
+	private:
+		class PrivateList
+		{
+		public:
+			PrivateList(const value_type& val)
+			{
+				next = nullptr;
+				val = val;
+			}
+					
+			~PrivateList()
+			{
+				delete val;
+			}
+
+			PrivateList *next;
+			T val;
+		}
+		PrivateList *front;
+		PrivateList *back;
+		size_type size;
+	};
+}
+
+#endif
diff --git a/src/Stack.hpp b/src/Stack.hpp
new file mode 100644
index 0000000..64bfc66
--- /dev/null
+++ b/src/Stack.hpp
@@ -0,0 +1,29 @@
+#ifndef STACK_HPP
+# define STACK_HPP
+
+# include "vector.hpp"
+
+namespace ft
+{
+	template <class T, class Container = deque<T> >
+	class stack : public vector
+	{
+	public:
+		explicit stack (const container_type& ctnr = container_type());
+		value_type& top()
+		{
+			return back();
+		}
+		void push (const value_type& val)
+		{
+			push_back(val);
+		}
+		void pop()
+		{
+			pop_back();
+		}
+	};
+}
+
+#endif
+
diff --git a/src/Vector.hpp b/src/Vector.hpp
new file mode 100644
index 0000000..0f21995
--- /dev/null
+++ b/src/Vector.hpp
@@ -0,0 +1,128 @@
+#ifndef VECTOR_HPP
+# define VECTOR_HPP
+
+# include <stddef.h>
+
+# define GROWTH_FACTOR 1.5
+
+typedef size_t size_type;
+
+
+namespace ft
+{
+	template < class T, class Alloc = allocator<T> >
+	class vector
+	{
+		typedef T value_type;
+		typedef T& reference;
+
+	public:
+		// capacity
+		size_type size() const;
+		{
+			return size;
+		}
+		void resize (size_type n, value_type val = value_type())
+		{
+			if (n < size)
+			{
+				for (int i = n; i < size; i++)
+					~T(under[i]);
+				size = n;
+				return;
+			}
+			if (n > capacity)
+				grow();
+			size_type prev_n;
+			for (prev_n = n; prev_n < size; prev_n++)
+				under[n] = val;
+			size = n;
+		}
+		size_type capacity() const
+		{
+			return capacity;
+		}
+		bool empty() const
+		{
+			return size == 0;
+		}
+		void reserve (size_type n)
+		{
+			if (n > capacity)
+				grow_to(n);
+		}
+
+		// element access
+		reference operator[] (size_type n)
+		{
+			return under[n];
+		}
+		reference at (size_type n)
+		{
+			if (n >= size)
+				raise std::out_of_range;
+			return under[n];
+		}
+		reference front()
+		{
+			return under[0];
+		}
+		reference back()
+		{
+			return under[size - 1];
+		}
+
+		// modifiers
+		template <class InputIterator>
+		void assign (InputIterator first, InputIterator last);
+		void assign (size_type n, const value_type& val);
+		void push_back (const value_type& val)
+		{
+			if (size >= capacity)
+				grow();
+			under[size] = val;
+			size++;
+		}
+		void pop_back()
+		{
+			~T(back());
+			size--;
+		}
+		iterator insert (iterator position, const value_type& val)
+		{
+			
+		}
+		void insert (iterator position, size_type n, const value_type& val);
+		template <class InputIterator>
+		void insert (iterator position, InputIterator first, InputIterator last);
+
+		
+
+
+	private:
+		T *under;
+		size_type size;
+		size_type capacity;
+
+		void grow()
+		{
+			capacity *= GROWTH_FACTOR;
+			grow_to(capacity);
+		}
+
+		void grow_to(size_type new_capacity)
+		{
+			T *under_copy = new T[capacity];
+			for (int i = 0; i < capacity; i++)
+				under_copy[i] = under[i];
+			delete [] under;
+			capacity = new_capacity;
+			under = new T[capacity];
+			for (int i = 0; i < capacity; i++)
+				under[i] = under_copy[i];
+			delete [] under_copy;
+		}
+	};
+}
+
+#endif