Kinou/ft_containers
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

tester almost done

Browse Source
This commit is contained in:
kinou-p 2022-11-29 14:48:02 +01:00
parent 93907d3154
commit 560e1e985c
12 changed files with 533 additions and 2169 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

10
Makefile
View File

@ -6,14 +6,16 @@
# By: apommier <apommier@student.42.fr> +#+ +:+ +#+ # # By: apommier <apommier@student.42.fr> +#+ +:+ +#+ #
# +#+#+#+#+#+ +#+ # # +#+#+#+#+#+ +#+ #
# Created: 2022/10/12 19:45:18 by apommier #+# #+# # # Created: 2022/10/12 19:45:18 by apommier #+# #+# #
# Updated: 2022/11/19 01:32:23 by apommier ### ########.fr # # Updated: 2022/11/29 13:23:22 by apommier ### ########.fr #
# # # #
# **************************************************************************** # # **************************************************************************** #
NAME = a.out NAME = a.out
SRCS = tests/main.cpp SRCS = tests/map_tester.cpp\
tests/vector_tester.cpp\
tests/stack_tester.cpp\
tests/main.cpp
INCLUDE = ./containers
OBJS = ${SRCS:.cpp=.o} OBJS = ${SRCS:.cpp=.o}
CC = c++ CC = c++
CFLAGS = -g -Wall -Wextra -Werror -std=c++98 CFLAGS = -g -Wall -Wextra -Werror -std=c++98
@ -23,7 +25,7 @@ RM = rm -rf
$(CC) ${CFLAGS} -c $< -o $(<:.cpp=.o) $(CC) ${CFLAGS} -c $< -o $(<:.cpp=.o)
${NAME}: ${OBJS} ${NAME}: ${OBJS}
${CC} ${LIB} ${OBJS} ${INCLUDE} -o ${NAME} ${CC} ${LIB} ${OBJS} -o ${NAME}
all: ${NAME} all: ${NAME}

10
containers/map.hpp
View File

@ -33,12 +33,15 @@ template<
class map class map
{ {
protected :
struct node;
public : public :
//----------------------------- //-----------------------------
//---------MEMBER TYPE--------- //---------MEMBER TYPE---------
//----------------------------- //-----------------------------
struct node;
typedef Key key_type; typedef Key key_type;
typedef node Node; typedef node Node;
@ -74,9 +77,6 @@ class map
NodePtr _end; NodePtr _end;
size_type _size; size_type _size;
public :
struct node{ struct node{
value_type data; value_type data;
NodePtr parent; NodePtr parent;
@ -91,6 +91,8 @@ class map
{} {}
}; };
public :
//--------------------------------------- //---------------------------------------
//---------COPLIEN FORM FUNCTION--------- //---------COPLIEN FORM FUNCTION---------
//--------------------------------------- //---------------------------------------

1274
containers/map2.hpp
View File

File diff suppressed because it is too large Load Diff

776
containers/set.hpp
View File

@ -1,776 +0,0 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* set.hpp :+: :+: :+: */
/* +:+ +:+ +:+ */
/* By: apommier <apommier@student.42.fr> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2022/11/26 15:23:32 by apommier #+# #+# */
/* Updated: 2022/11/26 17:32:44 by apommier ### ########.fr */
/* */
/* ************************************************************************** */
#pragma once
#include "./iterators/bidirectionnal_iterator.hpp"
#include "./iterators/pair.hpp"
#include "./iterators/make_pair.hpp"
#define RED 1
#define BLACK 0
#define _end 0
//typedef typename Alloc::template rebind<s_node<T> >::other
namespace ft
{
template<
class Key,
class Compare = std::less<Key>,
class Allocator = std::allocator<Key> >
class set
{
public :
//-----------------------------
//---------MEMBER TYPE---------
//-----------------------------
struct node;
typedef Key key_type;
typedef Key value_type;
typedef std::size_t size_type;
typedef std::ptrdiff_t difference_type;
typedef Compare key_compare;
typedef Allocator allocator_type;
typedef typename Allocator::template rebind<node>::other node_allocator_type;
typedef value_type& reference;
typedef const value_type& const_reference;
typedef typename Allocator::pointer pointer;
typedef typename Allocator::const_pointer const_pointer;
typedef ft::bidirectionnal_iterator<value_type, node> iterator;
typedef ft::bidirectionnal_iterator<value_type const, node const> const_iterator;
typedef std::reverse_iterator<iterator> reverse_iterator;
typedef std::reverse_iterator<const_iterator> const_reverse_iterator;
class value_compare;
protected :
key_compare _comp;
allocator_type _alloc;
node_allocator_type _node_alloc;
node *_root;
size_type _size;
public :
struct node{
value_type data;
node *parent;
node *right;
node *left;
bool color;
//node() : parent(0), right(set::_end), left(set::_end), color(0) {}
node(key_type const &key)
: data(key), parent(0), right(_end), left(_end), color(0)
{}
//std::cout << "end in construct= " << _end << std::endl;
};
//-----------------------------
//-----PRIVATE MEMBER TYPE-----
//-----------------------------
public :
//---------------------------------------
//---------COPLIEN FORM FUNCTION---------
//---------------------------------------
explicit set( const Compare& comp = Compare(), const Allocator& alloc = Allocator() ) : _comp(comp), _alloc(alloc), _root(_end)
{
//_end = _node_alloc.allocate(1);
//_node_alloc.construct(_end, node());
_size = 0;
}
template< class InputIt >
set( InputIt first, InputIt last, const Compare& comp = Compare(), const Allocator& alloc = Allocator() ) : _comp(comp), _alloc(alloc), _root(_end)
{
_size = 0;
//_end = _node_alloc.allocate(1);
//_node_alloc.construct(_end, node());
this->insert(first, last);
}
set( const set& x)
{
*this = x;
}
~set()
{
}
set& operator=(const set& x)
{
_comp = x._comp;
_alloc = x._alloc;
_node_alloc = x._node_alloc;
_root = x._root;
//_end = x._end;
_size = x._size;
return (*this);
}
//----------------------------------
//---------MEMBER FUNCTION----------
//----------------------------------
//-------------------------
//--------Iterators--------
//-------------------------
iterator begin()
{
return iterator(_root, _root);
}
const_iterator begin() const
{
return const_iterator(_root, _root);
}
iterator end()
{
return iterator(_root, _end);
}
const_iterator end() const
{
return const_iterator(_root, _end);
}
reverse_iterator rbegin()
{
return reverse_iterator(this->end());
}
const_reverse_iterator rbegin() const
{
return const_reverse_iterator(this->end());
}
reverse_iterator rend()
{
return reverse_iterator(this->begin());
}
const_reverse_iterator rend() const
{
return const_reverse_iterator(this->begin());
}
//------------------------
//--------Capacity--------
//------------------------
bool empty() const
{
if (!_size)
return (1);
return(0);
}
size_type size() const
{
return (_size);
}
size_type max_size() const
{
return (_alloc.max_size());
}
//-------------------------
//--------Modifiers--------
//-------------------------
ft::pair<iterator, bool> insert (const value_type& val)
{
// if (this->insert_node(val.first, val.second))
// _size++;
node *pt = new_node(val);
_root = insert_node(_root, pt);
fixViolation(_root, pt);
}
iterator insert (iterator position, const value_type& val)
{
(void)position;
// if (this->insert_node(val.first, val.second))
// _size++;
node *pt = new_node(val);
_root = insert_node(_root, pt);
fixViolation(_root, pt);
}
template <class InputIterator>
void insert (InputIterator first, InputIterator last)
{
while (first != last)
{
// std::cout << "i === " << i++ << std::endl;
// if (this->insert_node(_root, new_node((*first).first, (*first).second)))
// _size++;
// first++;
node *pt = new_node(*first);
_root = insert_node(_root, pt);
fixViolation(_root, pt);
first++;
}
}
void erase (iterator position)
{
delete_node(position.base());
}
size_type erase (const key_type& k)
{
delete_node(find(k).base());
return(1);
}
void erase (iterator first, iterator last)
{
while (first != last)
{
delete_node(first.base());
first++;
}
}
void swap (set& x)
{
set tmp;
tmp->_comp = _comp;
tmp->_alloc = _alloc;
tmp->_node_alloc = _node_alloc;
tmp->_root = _root;
//tmp->_end = _end;
tmp->_size = _size;
_comp = x->_comp;
_alloc = x->_alloc;
_node_alloc = x->_node_alloc;
_root = x->_root;
//_end = x->_end;
_size = x->_size;
x->_comp = tmp-> _comp;
x->_alloc = tmp->_alloc;
x->_node_alloc = tmp->_node_alloc;
x->_root = tmp->_root;
//x->_end = tmp->_end;
x->_size = tmp->_size;
}
void clear()
{
}
//-------------------------
//--------Observers--------
//-------------------------
key_compare key_comp() const
{
return (_comp);
}
value_compare value_comp() const
{
return (value_compare(_comp));
}
//-------------------------
//-------Operations--------
//-------------------------
iterator find (const key_type& k)
{
node *x = _root;
int i = 0;
while (x != _end && x->data.first != k)
{
std::cout << "i === " << i << std::endl;
if (k > x->data.first)
x = x->left;
else
x = x->right;
i++;
}
return (iterator(_root, _end, x));
}
const_iterator find (const key_type& k) const
{
node *x = _root;
while (x != _end && x->data.first != k)
{
if (k > x->data.first)
x = x->left;
else
x = x->right;
}
return (iterator(_root, _end, x));
}
size_type count (const key_type& k) const
{
if (find(k)->m == _end)
return (0);
return (1);
}
iterator lower_bound (const key_type& k)
{
iterator it = begin(), ite = end();
while (it != ite && !(_comp((*it), k)))
it++;
return (it);
}
const_iterator lower_bound (const key_type& k) const
{
const_iterator it = begin(), ite = end();
while (it != ite && !(_comp((*it), k)))
it++;
return (it);
}
iterator upper_bound (const key_type& k)
{
iterator it = begin(), ite = end();
while (it != ite && !(_comp((*it), k)))
it++;
return (it);
}
const_iterator upper_bound (const key_type& k) const
{
const_iterator it = begin(), ite = end();
while (it != ite && _comp((*it), k))
it++;
return (it);
}
ft::pair<const_iterator,const_iterator> equal_range (const key_type& k) const
{
return (ft::make_pair(lower_bound(k), upper_bound(k)));
}
ft::pair<iterator,iterator> equal_range (const key_type& k)
{
return (ft::make_pair(lower_bound(k), upper_bound(k)));
}
/* ************************************************************************** */
/* ************************************************************************** */
/* ************************************************************************** */
/* ******************************TREE FUNCTIONS****************************** */
/* ************************************************************************** */
/* ************************************************************************** */
/* ************************************************************************** */
private :
void rotateLeft(node *&root, node *&pt)
{
node *pt_right = pt->right;
pt->right = pt_right->left;
if (pt->right != NULL)
pt->right->parent = pt;
pt_right->parent = pt->parent;
if (pt->parent == NULL)
root = pt_right;
else if (pt == pt->parent->left)
pt->parent->left = pt_right;
else
pt->parent->right = pt_right;
pt_right->left = pt;
pt->parent = pt_right;
}
void rotateRight(node *&root, node *&pt)
{
node *pt_left = pt->left;
pt->left = pt_left->right;
if (pt->left != NULL)
pt->left->parent = pt;
pt_left->parent = pt->parent;
if (pt->parent == NULL)
root = pt_left;
else if (pt == pt->parent->left)
pt->parent->left = pt_left;
else
pt->parent->right = pt_left;
pt_left->right = pt;
pt->parent = pt_left;
}
node* insert_node(node* root, node *pt)
{
/* If the tree is empty, return a new node */
if (root == NULL)
return pt;
/* Otherwise, recur down the tree */
if (pt->data < root->data)
{
root->left = insert_node(root->left, pt);
root->left->parent = root;
}
else if (pt->data > root->data)
{
root->right = insert_node(root->right, pt);
root->right->parent = root;
}
/* return the (unchanged) node pointer */
return root;
}
void fixViolation(node *&root, node *&pt)
{
node *parent_pt = NULL;
node *grand_parent_pt = NULL;
while ((pt != root) && (pt->color != BLACK) && (pt->parent->color == RED))
{
parent_pt = pt->parent;
grand_parent_pt = pt->parent->parent;
/* Case : A Parent of pt is left child of Grand-parent of pt */
if (parent_pt == grand_parent_pt->left)
{
node *uncle_pt = grand_parent_pt->right;
/* Case : 1 The uncle of pt is also red Only Recoloring required */
if (uncle_pt != NULL && uncle_pt->color == RED)
{
grand_parent_pt->color = RED;
parent_pt->color = BLACK;
uncle_pt->color = BLACK;
pt = grand_parent_pt;
}
else
{
/* Case : 2 pt is right child of its parent Left-rotation required */
if (pt == parent_pt->right)
{
rotateLeft(root, parent_pt);
pt = parent_pt;
parent_pt = pt->parent;
}
/* Case : 3 pt is left child of its parent Right-rotation required */
rotateRight(root, grand_parent_pt);
swapColors(parent_pt, grand_parent_pt);
pt = parent_pt;
}
}
/* Case : B Parent of pt is right child of Grand-parent of pt */
else
{
node *uncle_pt = grand_parent_pt->left;
/* Case : 1 The uncle of pt is also red Only Recoloring required */
if ((uncle_pt != NULL) && (uncle_pt->color == RED))
{
grand_parent_pt->color = RED;
parent_pt->color = BLACK;
uncle_pt->color = BLACK;
pt = grand_parent_pt;
}
else
{
/* Case : 2 | pt is left child of its parent | Right-rotation required */
if (pt == parent_pt->left)
{
rotateRight(root, parent_pt);
pt = parent_pt;
parent_pt = pt->parent;
}
/* Case : 3 pt is right child of its parent Left-rotation required */
rotateLeft(root, grand_parent_pt);
swapColors(parent_pt, grand_parent_pt);
pt = parent_pt;
}
}
}
root->color = BLACK;
}
/* ************************************************************************** */
/* **********************************DELETE********************************** */
/* ************************************************************************** */
node *uncle(node *x)
{
if (x->parent == NULL or x->parent->parent == NULL)
return NULL;
if (x->parent->isOnLeft())
return x->parent->parent->right;
else
return x->parent->parent->left;
}
bool isOnLeft(node *x) { return this == x->parent->left; }
// returns pointer to sibling
node *sibling(node *x)
{
// sibling null if no parent
if (x->parent == NULL)
return NULL;
if (isOnLeft())
return x->parent->right;
return x->parent->left;
}
// moves node down and moves given node in its place
void moveDown(node *nParent, node *x)
{
if (x->parent != NULL)
{
if (isOnLeft())
x->parent->left = nParent;
else
x->parent->right = nParent;
}
nParent->parent = x->parent;
x->parent = nParent;
}
bool hasRedChild(node *x)
{
return (x->left != NULL and x->left->color == RED) or (x->right != NULL and x->right->color == RED);
}
void swapColors(node *x1, node *x2)
{
bool temp;
temp = x1->color;
x1->color = x2->color;
x2->color = temp;
}
void swapValues(node *u, node *v)
{
int temp;
temp = u->val;
u->val = v->val;
v->val = temp;
}
void fixRedRed(node *x)
{
// if x is root color it black and return
if (x == _root)
{
x->color = BLACK;
return;
}
// initialize parent, grandparent, uncle
node *parent = x->parent, *grandparent = parent->parent,
*uncle = x->uncle();
if (parent->color != BLACK)
{
if (uncle != NULL && uncle->color == RED)
{
// uncle red, perform recoloring and recurse
parent->color = BLACK;
uncle->color = BLACK;
grandparent->color = RED;
fixRedRed(grandparent);
}
else
{
// Else perform LR, LL, RL, RR
if (parent->isOnLeft())
{
if (x->isOnLeft())
{
// for left right
swapColors(parent, grandparent);
}
else
{
leftRotate(parent);
swapColors(x, grandparent);
}
// for left left and left right
rightRotate(grandparent);
}
else
{
if (x->isOnLeft())
{
// for right left
rightRotate(parent);
swapColors(x, grandparent);
}
else
swapColors(parent, grandparent);
// for right right and right left
leftRotate(grandparent);
}
}
}
}
// find node that do not have a left child
// in the subtree of the given node
node *successor(node *x)
{
node *temp = x;
while (temp->left != NULL)
temp = temp->left;
return temp;
}
// find node that replaces a deleted node in BST
node *replace_node(node *x)
{
// when node have 2 children
if (x->left != NULL and x->right != NULL)
return successor(x->right);
// when leaf
if (x->left == NULL and x->right == NULL)
return NULL;
// when single child
if (x->left != NULL)
return x->left;
else
return x->right;
}
// deletes the given node
void deleteNode(node *v)
{
node *u = replace_node(v);
// True when u and v are both black
bool uvBlack = ((u == NULL or u->color == BLACK) and (v->color == BLACK));
node *parent = v->parent;
if (u == NULL)
{
// u is NULL therefore v is leaf
if (v == _root)
_root = NULL;// v is root, making root null
else
{
if (uvBlack)
{
// u and v both black
// v is leaf, fix double black at v
fixDoubleBlack(v);
}
else
{
// u or v is red
if (v->sibling() != NULL)
// sibling is not null, make it red"
v->sibling()->color = RED;
}
// delete v from the tree
if (v->isOnLeft())
parent->left = NULL;
else
parent->right = NULL;
}
delete v;
return;
}
if (v->left == NULL or v->right == NULL)
{
// v has 1 child
if (v == _root)
{
// v is root, assign the value of u to v, and delete u
v->val = u->val;
v->left = v->right = NULL;
delete u;
}
else
{
// Detach v from tree and move u up
if (v->isOnLeft())
parent->left = u;
else
parent->right = u;
delete v;
u->parent = parent;
if (uvBlack)
fixDoubleBlack(u);// u and v both black, fix double black at u
else
u->color = BLACK;// u or v red, color u black
}
return;
}
// v has 2 children, swap values with successor and recurse
swapValues(u, v);
deleteNode(u);
}
//template<typename T_node>
node *new_node(key_type key)
{
node *ret;
ret = _node_alloc.allocate(1);
_node_alloc.construct(ret, node(key));
//ret = _node_alloc::allocate(1);
//_node_alloc::construct(ret, node(key));
return (ret);
}
}; //end of set class
//----------------------------------
//----------COMPARE CLASS-----------
//----------------------------------
template <class Key, class Compare, class Alloc>
class set<Key,Compare,Alloc>::value_compare //man set::value_compare
{ // in C++98, it is required to inherit binary_function<value_type,value_type,bool>
friend class set;
protected:
Compare comp;
value_compare(Compare c) : comp(c) {} // constructed with set's comparison object
public:
typedef bool result_type;
typedef value_type first_argument_type;
typedef value_type second_argument_type;
bool operator() (const value_type& x, const value_type& y) const
{
return comp(x, y);
}
};
}

11
containers/stack.hpp
View File

@ -6,19 +6,19 @@
/* By: apommier <apommier@student.42.fr> +#+ +:+ +#+ */ /* By: apommier <apommier@student.42.fr> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */ /* +#+#+#+#+#+ +#+ */
/* Created: 2022/10/12 19:46:30 by apommier #+# #+# */ /* Created: 2022/10/12 19:46:30 by apommier #+# #+# */
/* Updated: 2022/11/28 15:56:04 by apommier ### ########.fr */ /* Updated: 2022/11/29 13:15:44 by apommier ### ########.fr */
/* */ /* */
/* ************************************************************************** */ /* ************************************************************************** */
#ifndef STACK_HPP #ifndef STACK_HPP
# define STACK_HPP # define STACK_HPP
# include <vector> # include "vector.hpp"
namespace ft namespace ft
{ {
template <class T, class Container = std::vector<T> > template <class T, class Container = ft::vector<T> >
class stack class stack
{ {
public: public:
@ -30,7 +30,7 @@ class stack
typedef T value_type; typedef T value_type;
typedef Container container_type; typedef Container container_type;
private: protected:
container_type c; container_type c;
public: public:
@ -39,11 +39,14 @@ class stack
//---------COPLIEN FORM FUNCTION--------- //---------COPLIEN FORM FUNCTION---------
//--------------------------------------- //---------------------------------------
explicit stack (const container_type& ctnr = container_type()) : c(ctnr){}//default constructor explicit stack (const container_type& ctnr = container_type()) : c(ctnr){}//default constructor
stack<T, Container>(const stack &other )//copy constructor stack<T, Container>(const stack &other )//copy constructor
{ {
*this = other; *this = other;
} }
~stack<T, Container>(void) {}//destructor ~stack<T, Container>(void) {}//destructor
stack &operator=( const stack &other )//assigment operator stack &operator=( const stack &other )//assigment operator
{ {
if (this != &other) if (this != &other)

54
containers/vector.hpp
View File

@ -6,7 +6,7 @@
/* By: apommier <apommier@student.42.fr> +#+ +:+ +#+ */ /* By: apommier <apommier@student.42.fr> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */ /* +#+#+#+#+#+ +#+ */
/* Created: 2022/10/12 19:46:32 by apommier #+# #+# */ /* Created: 2022/10/12 19:46:32 by apommier #+# #+# */
/* Updated: 2022/11/29 02:18:37 by apommier ### ########.fr */ /* Updated: 2022/11/29 14:05:18 by apommier ### ########.fr */
/* */ /* */
/* ************************************************************************** */ /* ************************************************************************** */
@ -214,11 +214,6 @@ class vector
} }
else if (n > _size) else if (n > _size)
{ {
// while (n > _capacity)
// this->reserve(_capacity);
//if (n < _capacity * 2 && _size == _capacity)
// else
if (n > _capacity) if (n > _capacity)
{ {
if (n == _capacity + 1 || n > _capacity * 2) if (n == _capacity + 1 || n > _capacity * 2)
@ -226,10 +221,6 @@ class vector
else else
this->reserve(_capacity * 2); this->reserve(_capacity * 2);
} }
// else if (n < _capacity * 2)
// this->reserve(_size * 2);
// else
//this->reserve(n);
while (n > _size) while (n > _size)
{ {
_alloc.construct(_tab + _size, val); _alloc.construct(_tab + _size, val);
@ -269,19 +260,6 @@ class vector
_tab = tmp; _tab = tmp;
_capacity = n; _capacity = n;
} }
// if (n > this->max_size())
// throw (std::length_error("vector::reserve"));
// else if (n > _capacity)
// {
// value_type *prev_ptr = _tab;
// std::size_t prev_size = _size;
// std::size_t prev_capacity = _capacity;
// _tab = _alloc.allocate(n);
// _capacity = n;
// for(std::size_t i = 0; i < prev_size; i++)
// _alloc.construct(_tab + i, *(prev_ptr + i));
// _alloc.deallocate(prev_ptr, prev_capacity);
// }
} }
//------------------------------ //------------------------------
@ -455,32 +433,6 @@ class vector
temp++; temp++;
} }
return (first); return (first);
// pointer p_first = &(*first);
// for (; &(*first) != &(*last); first++)
// _alloc.destroy(&(*first));
// for (int i = 0; i < this->end() - &(*last); i++)
// {
// _alloc.construct(p_first + i, *(&(*last) + i));
// _alloc.destroy(&(*last) + i);
// }
// //_end -= (&(*last) - p_first);
// return (iterator(p_first));
// difference_type lenght = last - first;
// int i;
// //if (first == this->begin() && last == this->end())
// // this->clear();
// for (i = 0; lenght - i - 1; i++)
// _alloc.destroy(&(*(first + i)));
// for (i = 0; _size - i - 1; i++)
// {
// _alloc.construct(&(*(first + i)), *(&(*last) + i));
// _alloc.destroy(*(&(*last) + i));
// }
// _size -= lenght;
// return (first);
} }
void swap (vector& x) void swap (vector& x)
@ -555,10 +507,6 @@ class vector
{ {
if (lhs._size != rhs._size) if (lhs._size != rhs._size)
return (false); return (false);
// int i = 0;
// while (lhs._size - i - 1 && lhs._tab[i] == rhs._tab[i])
// i++;
// return (lhs._tab[i] == rhs._tab[i]);
return (ft::equal(lhs.begin(), lhs.end(), rhs.begin())); return (ft::equal(lhs.begin(), lhs.end(), rhs.begin()));
} }

19
ft_containers.hpp
View File

@ -6,22 +6,25 @@
/* By: apommier <apommier@student.42.fr> +#+ +:+ +#+ */ /* By: apommier <apommier@student.42.fr> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */ /* +#+#+#+#+#+ +#+ */
/* Created: 2022/10/12 19:46:33 by apommier #+# #+# */ /* Created: 2022/10/12 19:46:33 by apommier #+# #+# */
/* Updated: 2022/11/16 19:07:06 by apommier ### ########.fr */ /* Updated: 2022/11/29 13:22:18 by apommier ### ########.fr */
/* */ /* */
/* ************************************************************************** */ /* ************************************************************************** */
#ifndef FT_CONTAINERS_HPP #pragma once
# define FT_CONTAINERS_HPP
# include <iostream> # include <iostream>
//namespace ft {
# include "./containers/map.hpp" # include "./containers/map.hpp"
# include "./containers/set.hpp"
# include "./containers/stack.hpp" # include "./containers/stack.hpp"
# include "./containers/vector.hpp" # include "./containers/vector.hpp"
//}
# include <iterator> # include <map>
# include <stack>
# include <vector>
#endif void stack_tester();
void real_stack_tester();
void vector_tester();
void real_vector_tester();
void map_tester();
void real_map_tester();

8
main.cpp
View File

@ -6,7 +6,7 @@
/* By: apommier <apommier@student.42.fr> +#+ +:+ +#+ */ /* By: apommier <apommier@student.42.fr> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */ /* +#+#+#+#+#+ +#+ */
/* Created: 2022/10/12 19:46:35 by apommier #+# #+# */ /* Created: 2022/10/12 19:46:35 by apommier #+# #+# */
/* Updated: 2022/10/19 18:35:21 by apommier ### ########.fr */ /* Updated: 2022/11/29 12:38:05 by apommier ### ########.fr */
/* */ /* */
/* ************************************************************************** */ /* ************************************************************************** */
@ -19,9 +19,9 @@
#include <vector> #include <vector>
namespace ft = std; namespace ft = std;
#else #else
#include <map.hpp> #include "./containers/map.hpp"
#include <stack.hpp> #include "./containers/stack.hpp"
#include <vector.hpp> #include "./containers/vector.hpp"
#endif #endif
#include <stdlib.h> #include <stdlib.h>

130
tests/main.cpp
View File

@ -6,7 +6,7 @@
/* By: apommier <apommier@student.42.fr> +#+ +:+ +#+ */ /* By: apommier <apommier@student.42.fr> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */ /* +#+#+#+#+#+ +#+ */
/* Created: 2022/10/19 14:04:37 by apommier #+# #+# */ /* Created: 2022/10/19 14:04:37 by apommier #+# #+# */
/* Updated: 2022/11/16 22:18:48 by apommier ### ########.fr */ /* Updated: 2022/11/29 13:25:14 by apommier ### ########.fr */
/* */ /* */
/* ************************************************************************** */ /* ************************************************************************** */
@ -20,54 +20,100 @@ long get_time(void)
gettimeofday(&time, NULL); gettimeofday(&time, NULL);
return (time.tv_sec * 1000 + time.tv_usec / 1000); return (time.tv_sec * 1000 + time.tv_usec / 1000);
} }
// void print_vector(ft::vector<int> x)
// {
// std::cout << "-----print vector----\n";
// for (size_t i = 0; i < x.size(); i++)
// std::cout << x[i] << std::endl;
// }
void stack_tester() // void stack_tester()
{ // {
ft::stack<int> first; // ft::stack<int> first;
std::cout << "------empty------\n"; // std::cout << "------empty------\n";
std::cout << first.empty() << std::endl; // std::cout << first.empty() << std::endl;
std::cout << "------size------\n"; // std::cout << "------size------\n";
std::cout << first.size() << std::endl; // std::cout << first.size() << std::endl;
} // }
void print_vector(ft::vector<int> x) // void vector_tester()
{ // {
std::cout << "-----print vector----\n"; // ft::vector<int> first(5, 3);
for (size_t i = 0; i < x.size(); i++) // ft::vector<int> second;
std::cout << x[i] << std::endl; // ft::vector<int>::iterator it = first.begin();
} // std::cout << "------empty------\n";
// std::cout << first.empty() << std::endl;
void vector_tester() // std::cout << second.empty() << std::endl;
{ // std::cout << "------size------\n";
ft::vector<int> first(5, 3); // std::cout << first.size() << std::endl;
ft::vector<int> second; // std::cout << "------pushback then size------\n";
ft::vector<int>::iterator it = first.begin(); // first.push_back(5);
std::cout << "------empty------\n"; // std::cout << first.size() << std::endl;
std::cout << first.empty() << std::endl; // std::cout << "------for------\n";
std::cout << second.empty() << std::endl; // print_vector(first);
std::cout << "------size------\n"; // std::cout << "-------0-----\n";
std::cout << first.size() << std::endl; // std::cout << first.at(5) << std::endl;
std::cout << "------pushback then size------\n";
first.push_back(5);
std::cout << first.size() << std::endl;
std::cout << "------for------\n";
print_vector(first);
std::cout << "-------0-----\n";
std::cout << first.at(5) << std::endl;
} // }
int main() int main()
{ {
std::cout << "------TESTER START-------\n"; long real_time;
std::cout << "------STACK-------\n"; long my_time;
std::cout << "/* ************************************************************************** */\n";
std::cout << "/* ************************************************************************** */\n";
std::cout << "/* ************************************************************************** */\n";
std::cout << "/* *****************************FT_CONTAINERS TESTER************************* */\n";
std::cout << "/* ************************************************************************** */\n";
std::cout << "/* ************************************************************************** */\n";
std::cout << "/* ************************************************************************** */\n";
std::cout << " ------------------------------------------------------------\n";
std::cout << " ---------------------------STACK----------------------------\n";
std::cout << " ------------------------------------------------------------\n";
my_time = get_time();
stack_tester(); stack_tester();
std::cout << "------VECTOR-------\n"; my_time = get_time() - my_time;
std::cout << " --------------------------REAL STACK------------------------\n";
real_time = get_time();
real_stack_tester();
real_time = get_time() - real_time;
std::cout << " --------------------------TIME DIFF-------------------------\n";
std::cout << " homemade ft containers = " << my_time << "ms\n";
std::cout << " real std containers = " << real_time << "ms\n";
std::cout << " ------------------------------------------------------------\n";
std::cout << " ---------------------------VECTOR---------------------------\n";
std::cout << " ------------------------------------------------------------\n";
my_time = get_time();
vector_tester(); vector_tester();
// std::cout << "------MAP-------\n"; my_time = get_time() - my_time;
// map_tester(); std::cout << " --------------------------REAL VECTOR------------------------\n";
// std::cout << "------SET-------\n"; real_time = get_time();
// set_tester(); real_vector_tester();
std::cout << "------End-------\n"; real_time = get_time() - real_time;
std::cout << " --------------------------TIME DIFF-------------------------\n";
std::cout << " homemade ft containers = " << my_time << "ms\n";
std::cout << " real std containers = " << real_time << "ms\n";
std::cout << " ------------------------------------------------------------\n";
std::cout << " -----------------------------MAP----------------------------\n";
std::cout << " ------------------------------------------------------------\n";
my_time = get_time();
map_tester();
my_time = get_time() - my_time;
std::cout << " ---------------------------REAL MAP-------------------------\n";
real_time = get_time();
real_map_tester();
real_time = get_time() - real_time;
std::cout << " --------------------------TIME DIFF-------------------------\n";
std::cout << " homemade ft containers = " << my_time << "ms\n";
std::cout << " real std containers = " << real_time << "ms\n";
std::cout << "/* ************************************************************************** */\n";
std::cout << "/* ******************************END OF TESTER******************************* */\n";
std::cout << "/* ************************************************************************** */\n";
return (0); return (0);
} }

23
tests/map_tester.cpp Normal file
View File

@ -0,0 +1,23 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* map_tester.cpp :+: :+: :+: */
/* +:+ +:+ +:+ */
/* By: apommier <apommier@student.42.fr> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2022/11/29 12:55:17 by apommier #+# #+# */
/* Updated: 2022/11/29 13:23:51 by apommier ### ########.fr */
/* */
/* ************************************************************************** */
#include "../ft_containers.hpp"
void map_tester()
{
}
void real_map_tester()
{
}

154
tests/stack_tester.cpp Normal file
View File

@ -0,0 +1,154 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* stack_tester.cpp :+: :+: :+: */
/* +:+ +:+ +:+ */
/* By: apommier <apommier@student.42.fr> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2022/11/29 12:55:21 by apommier #+# #+# */
/* Updated: 2022/11/29 13:50:26 by apommier ### ########.fr */
/* */
/* ************************************************************************** */
#include "../ft_containers.hpp"
template <typename T_STACK>
void printSize(T_STACK &cntr)
{
std::cout << "empty: " << cntr.empty() << std::endl;
std::cout << "size: " << cntr.size() << std::endl;
std::cout << std::endl << "Content :" << std::endl;
while (cntr.size() != 0) {
std::cout << cntr.top() << std::endl;
cntr.pop();
}
}
template <class T_STACK>
void cmp(const T_STACK &lhs, const T_STACK &rhs)
{
std::cout << "== : " << (lhs == rhs) << " | != : " << (lhs != rhs) << std::endl;
std::cout << "< : " << (lhs < rhs) << " | <= : " << (lhs <= rhs) << std::endl;
std::cout << "> : " << (lhs > rhs) << " | >= : " << (lhs >= rhs) << std::endl;
}
void stack_tester()
{
ft::vector<int> ctnr;
ctnr.push_back(21);
ctnr.push_back(42);
ctnr.push_back(1337);
ctnr.push_back(19);
ctnr.push_back(0);
ctnr.push_back(183792);
std::cout << "----container copy constructor----\n";
ft::stack<int> stack_ctnr(ctnr);
stack_ctnr.push(1);
stack_ctnr.push(2);
stack_ctnr.push(3);
stack_ctnr.push(4);
stack_ctnr.push(5);
stack_ctnr.push(6);
printSize(stack_ctnr);
std::cout << "----default constructor----\n";
ft::stack<int> stack_ctnr2;
stack_ctnr2.push(11);
stack_ctnr2.push(21);
stack_ctnr2.push(31);
stack_ctnr2.push(41);
stack_ctnr2.push(51);
stack_ctnr2.push(61);
printSize(stack_ctnr2);
std::cout << "----stack copy constructor----\n";
stack_ctnr2.push(11);
stack_ctnr2.push(21);
stack_ctnr2.push(31);
stack_ctnr2.push(41);
stack_ctnr2.push(51);
stack_ctnr2.push(61);
ft::stack<int> stack_ctnr3(stack_ctnr2);
printSize(stack_ctnr3);
std::cout << "----relationnal ope----\n";
stack_ctnr3 = stack_ctnr2;
cmp(stack_ctnr2, stack_ctnr2);
}
void real_stack_tester()
{
std::deque<int> ctnr2;
ctnr2.push_back(21);
ctnr2.push_back(42);
ctnr2.push_back(1337);
ctnr2.push_back(19);
ctnr2.push_back(0);
ctnr2.push_back(183792);
std::cout << "----container copy constructor----\n";
std::stack<int> stack_ctnr(ctnr2);
stack_ctnr.push(1);
stack_ctnr.push(2);
stack_ctnr.push(3);
stack_ctnr.push(4);
stack_ctnr.push(5);
stack_ctnr.push(6);
printSize(stack_ctnr);
std::cout << "----default constructor----\n";
std::stack<int> stack_ctnr2;
stack_ctnr2.push(11);
stack_ctnr2.push(21);
stack_ctnr2.push(31);
stack_ctnr2.push(41);
stack_ctnr2.push(51);
stack_ctnr2.push(61);
printSize(stack_ctnr2);
std::cout << "----stack copy constructor----\n";
stack_ctnr2.push(11);
stack_ctnr2.push(21);
stack_ctnr2.push(31);
stack_ctnr2.push(41);
stack_ctnr2.push(51);
stack_ctnr2.push(61);
std::stack<int> stack_ctnr3(stack_ctnr2);
printSize(stack_ctnr3);
std::cout << "----relationnal ope----\n";
stack_ctnr3 = stack_ctnr2;
cmp(stack_ctnr2, stack_ctnr2);
}

233
tests/vector_tester.cpp Normal file
View File

@ -0,0 +1,233 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* vector_tester.cpp :+: :+: :+: */
/* +:+ +:+ +:+ */
/* By: apommier <apommier@student.42.fr> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2022/11/29 12:55:23 by apommier #+# #+# */
/* Updated: 2022/11/29 14:45:23 by apommier ### ########.fr */
/* */
/* ************************************************************************** */
#include "../ft_containers.hpp"
template <class T_STACK>
void cmp(const T_STACK &lhs, const T_STACK &rhs)
{
std::cout << "== : " << (lhs == rhs) << " | != : " << (lhs != rhs) << std::endl;
std::cout << "< : " << (lhs < rhs) << " | <= : " << (lhs <= rhs) << std::endl;
std::cout << "> : " << (lhs > rhs) << " | >= : " << (lhs >= rhs) << std::endl;
}
void printSize(ft::vector<int> const &vct)
{
std::cout << "size: " << vct.size() << std::endl;
std::cout << "capacity: " << vct.capacity() << std::endl;
std::cout << "max_size: " << vct.max_size() << std::endl;
ft::vector<int>::const_iterator it = vct.begin();
ft::vector<int>::const_iterator ite = vct.end();
std::cout << std::endl << "Content is:" << std::endl;
for (; it != ite; ++it)
std::cout << "- " << *it << std::endl;
}
void printSize_real(std::vector<int> const &vct)
{
std::cout << "size: " << vct.size() << std::endl;
std::cout << "capacity: " << vct.capacity() << std::endl;
std::cout << "max_size: " << vct.max_size() << std::endl;
std::vector<int>::const_iterator it = vct.begin();
std::vector<int>::const_iterator ite = vct.end();
std::cout << std::endl << "Content is:" << std::endl;
for (; it != ite; ++it)
std::cout << "- " << *it << std::endl;
}
void vector_tester()
{
std::cout << "----default constructor----" << std::endl;
ft::vector<int> ctnr;
printSize(ctnr);
std::cout << "----assign val----" << std::endl;
ctnr.assign(10, 1);
printSize(ctnr);
std::cout << "----range constructor----" << std::endl;
ft::vector<int> ctnr2(ctnr.begin(), ctnr.end());
printSize(ctnr2);
std::cout << "----range assign----" << std::endl;
ft::vector<int> ctnr3;
ctnr3.assign(ctnr.begin(), ctnr.end());
printSize(ctnr3);
////////////////////////////////////
std::cout << "----insert at position + assign constrcutor----" << std::endl;
ft::vector<int> ctnr4(5, 5);
printSize(ctnr4);
std::cout << "----insert----\n";
ctnr4.insert(ctnr4.begin() + 3, 100);
printSize(ctnr4);
std::cout << "----insert fill----\n";
ctnr4.insert(ctnr4.begin() + 3, 5, 100);
printSize(ctnr4);
std::cout << "----operator equal----\n";
ft::vector<int> ctnr5;
ctnr5 = ctnr4;
printSize(ctnr5);
std::cout << "----insert range----\n";
ctnr5.insert(ctnr5.begin() + 2, ctnr.begin()++, ctnr.end()--);
printSize(ctnr5);
std::cout << "----erase----\n";
ctnr5.erase(ctnr5.end() - 5);
printSize(ctnr5);
std::cout << "----erase range----\n";
ctnr5.erase(ctnr5.begin(), ctnr5.end() - 5);
printSize(ctnr5);
std::cout << "----swap----\n";
ctnr5.swap(ctnr);
std::cout << "----ctnr----\n";
printSize(ctnr);
std::cout << "----ctnr5----\n";
printSize(ctnr5);
std::cout << "----clear----\n";
ctnr.clear();
printSize(ctnr);
///////////////
std::cout << "----iterator----\n";
ft::vector<int>::iterator it = ctnr4.begin();
ft::vector<int>::iterator ite = ctnr4.end();
for (int i = 1; it != ite; ++i)
*it++ = i;
printSize(ctnr4);
it = ctnr4.begin();
ite = ctnr4.begin();
std::cout << *(++ite) << std::endl;
std::cout << *(ite++) << std::endl;
std::cout << *ite++ << std::endl;
std::cout << *++ite << std::endl;
std::cout << *(++it) << std::endl;
std::cout << *(it++) << std::endl;
std::cout << *it++ << std::endl;
std::cout << *++it << std::endl;
std::cout << *(--ite) << std::endl;
std::cout << *(ite--) << std::endl;
std::cout << *--ite << std::endl;
std::cout << *ite-- << std::endl;
std::cout << *(--it) << std::endl;
std::cout << *(it--) << std::endl;
std::cout << *it-- << std::endl;
std::cout << *--it << std::endl;
std::cout << "----relationnal ope----\n";
cmp(ctnr, ctnr4);
}
void real_vector_tester()
{
std::cout << "----default constructor----" << std::endl;
std::vector<int> ctnr;
printSize_real(ctnr);
std::cout << "----assign val----" << std::endl;
ctnr.assign(10, 1);
printSize_real(ctnr);
std::cout << "----range constructor----" << std::endl;
std::vector<int> ctnr2(ctnr.begin(), ctnr.end());
printSize_real(ctnr2);
std::cout << "----range assign----" << std::endl;
std::vector<int> ctnr3;
ctnr3.assign(ctnr.begin(), ctnr.end());
printSize_real(ctnr3);
////////////
std::cout << "----insert at position + assign constrcutor----" << std::endl;
std::vector<int> ctnr4(5, 5);
printSize_real(ctnr4);
std::cout << "----insert----\n";
ctnr4.insert(ctnr4.begin() + 3, 100);
printSize_real(ctnr4);
std::cout << "----insert fill----\n";
ctnr4.insert(ctnr4.begin() + 3, 5, 100);
printSize_real(ctnr4);
std::cout << "----operator equal----\n";
std::vector<int> ctnr5;
ctnr5 = ctnr4;
printSize_real(ctnr5);
std::cout << "----insert range----\n";
ctnr5.insert(ctnr5.begin() + 2, ctnr.begin()++, ctnr.end()--);
printSize_real(ctnr5);
std::cout << "----erase----\n";
ctnr5.erase((ctnr5.end()) - 5);
printSize_real(ctnr5);
std::cout << "----erase range----\n";
ctnr5.erase(ctnr5.begin(), ctnr5.end() - 5);
printSize_real(ctnr5);
std::cout << "----swap----\n";
ctnr5.swap(ctnr);
std::cout << "----ctnr----\n";
printSize_real(ctnr);
std::cout << "----ctnr5----\n";
printSize_real(ctnr5);
std::cout << "----clear----\n";
ctnr.clear();
printSize_real(ctnr);
std::cout << "----iterator----\n";
std::vector<int>::iterator it = ctnr4.begin();
std::vector<int>::iterator ite = ctnr4.end();
for (int i = 1; it != ite; ++i)
*it++ = i;
printSize_real(ctnr4);
it = ctnr4.begin();
ite = ctnr4.begin();
std::cout << *(++ite) << std::endl;
std::cout << *(ite++) << std::endl;
std::cout << *ite++ << std::endl;
std::cout << *++ite << std::endl;
std::cout << *(++it) << std::endl;
std::cout << *(it++) << std::endl;
std::cout << *it++ << std::endl;
std::cout << *++it << std::endl;
std::cout << *(--ite) << std::endl;
std::cout << *(ite--) << std::endl;
std::cout << *--ite << std::endl;
std::cout << *ite-- << std::endl;
std::cout << *(--it) << std::endl;
std::cout << *(it--) << std::endl;
std::cout << *it-- << std::endl;
std::cout << *--it << std::endl;
std::cout << "----relationnal ope----\n";
cmp(ctnr, ctnr4);
}