42/42_INT_11_ft_containers
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

add namespace, make stl, and template allocator

Browse Source
This commit is contained in:
hugogogo
2022-06-03 14:49:22 +02:00
parent 6362a50ffa
commit aecd2caa1c
6 changed files with 262 additions and 197 deletions
Download Patch File Download Diff File Expand all files Collapse all files

54
Makefile
View File

@@ -1,3 +1,29 @@
# - - - - - - - #
# #
# COLORS #
# #
# - - - - - - - #
GRAY = "\e[0;30m"
RED = "\e[0;31m"
GREEN = "\e[0;32m"
YELLOW = "\e[0;33m"
BLUE = "\e[0;34m"
PURPLE = "\e[0;35m"
CYAN = "\e[0;36m"
WHITE = "\e[0;37m"
B_GRAY = "\e[1;30m"
B_RED = "\e[1;31m"
B_GREEN = "\e[1;32m"
B_YELLOW = "\e[1;33m"
B_BLUE = "\e[1;34m"
B_PURPLE = "\e[1;35m"
B_CYAN = "\e[1;36m"
B_WHITE = "\e[1;37m"
RESET = "\e[0m"
# - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - # # - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - #
# . name = value \ . += append to a variable # # . name = value \ . += append to a variable #
# VARIABLES . value . != set result of command # # VARIABLES . value . != set result of command #
@@ -17,16 +43,22 @@ VPATH = $(D_SRCS)
LIBS = LIBS =
INCLUDES = -I$(D_HEADERS) F_INCLUDES = $(HEADERS:%=$(D_HEADERS)/%) \
$(TEMPLATES:%=$(D_TEMPLATES)/%)
INCLUDES = -I$(D_HEADERS) \
-I$(D_TEMPLATES)
D_SRCS = srcs D_SRCS = ./tests
SRCS = main.cpp \ SRCS = main.cpp
ftvector.cpp #SRCS = main42.cpp
D_HEADERS = headers D_HEADERS = ./headers
HEADERS = colors.h \ HEADERS = colors.h \
tests.h \ tests.hpp \
ftvector.hpp vector.hpp
D_TEMPLATES = ./templates
TEMPLATES = vector.tpp
D_OBJS = builds D_OBJS = builds
OBJS = $(SRCS:%.$(EXT)=$(D_OBJS)/%.o) OBJS = $(SRCS:%.$(EXT)=$(D_OBJS)/%.o)
@@ -46,15 +78,21 @@ endif
all: $(NAME) all: $(NAME)
stl: CFLAGS += -D STL
stl: all
ft: all
$(D_OBJS)/%.o: %.$(EXT) | $(D_OBJS) $(D_OBJS)/%.o: %.$(EXT) | $(D_OBJS)
@echo $(CYAN)"compilation (objects.o) :"$(RESET)
$(CC) $(CFLAGS) -c $< -o $@ $(CC) $(CFLAGS) -c $< -o $@
$(D_OBJS): $(D_OBJS):
mkdir $@ mkdir $@
$(OBJS): $(HEADERS:%=$(D_HEADERS)/%) $(OBJS): $(F_INCLUDES)
$(NAME): $(OBJS) $(NAME): $(OBJS)
@echo $(CYAN)"linkage (link objects.o) :"$(RESET)
$(CC) $(OBJS) -o $@ $(LIBS) $(CC) $(OBJS) -o $@ $(LIBS)
leaks: $(NAME) leaks: $(NAME)

0
headers/tests.h → headers/tests.hpp
View File

50
headers/ftvector.hpp → headers/vector.hpp
View File

@@ -1,26 +1,48 @@
#ifndef FTVECTOR_HPP #ifndef VECTOR_HPP
# define FTVECTOR_HPP # define VECTOR_HPP
# include "colors.h" # include "colors.h"
# include <iostream> # include <iostream>
# include <string> # include <string>
# include <memory> // std::allocator # include <memory> // std::allocator
# include <algorithm> // std::min
class ftvector { namespace ft {
template <
class T,
class Allocator = std::allocator<T>
> class vector {
public: public:
typedef int value_type; typedef T value_type;
typedef std::allocator<int> allocator_type; typedef Allocator allocator_type;
typedef std::size_t size_type; typedef std::size_t size_type;
typedef int * iterator; typedef T * iterator;
ftvector(); typedef typename allocator_type::reference reference;
ftvector( ftvector const & src );
~ftvector();
ftvector & operator=( ftvector const & rhs ); /************
* copliens :
************/
// constructor -------------------------------
// explicit vector (const allocator_type& alloc = allocator_type());
// explicit vector (size_type n, const value_type& val = value_type(), const allocator_type& alloc = allocator_type());
// template <class InputIterator>
// vector (InputIterator first, InputIterator last, const allocator_type& alloc = allocator_type());
// vector (const vector& x);
// TMP
vector();
vector( vector const & src );
// TMP END
// destructor --------------------------------
~vector();
// operator= ---------------------------------
vector & operator=( vector const & rhs );
/************* /*************
@@ -59,7 +81,7 @@ public:
* element access : * element access :
******************/ ******************/
// operator[] -------------------------------- // operator[] --------------------------------
//reference operator[](size_type n); reference operator[](size_type n);
//const_reference operator[](size_type n) const; //const_reference operator[](size_type n) const;
// at ---------------------------------------- // at ----------------------------------------
//reference at(size_type n); //reference at(size_type n);
@@ -107,7 +129,11 @@ private:
}; };
//std::ostream & operator<<(std::ostream & o, ftvector const & rhs); //std::ostream & operator<<(std::ostream & o, vector const & rhs);
}
# include "vector.tpp"
#endif #endif

56
srcs/ftvector.cpp → templates/vector.tpp
View File

@@ -1,24 +1,28 @@
#include "ftvector.hpp" //#include "vector.hpp"
#define COPLIEN_COLOR B_CYAN #define COPLIEN_COLOR B_CYAN
namespace ft {
/********************************************* /*********************************************
* CONSTRUCTORS * CONSTRUCTORS
*********************************************/ *********************************************/
ftvector::ftvector() template <class T, class Allocator>
vector<T, Allocator>::vector()
: _size(0) : _size(0)
, _capacity(0) , _capacity(0)
, _mem_ptr(NULL) , _mem_ptr(NULL)
{ {
// std::cout << COPLIEN_COLOR "ftvector constructor" RESET "\n"; // std::cout << COPLIEN_COLOR "vector constructor" RESET "\n";
_allocator = allocator_type(); _allocator = allocator_type();
return; return;
} }
ftvector::ftvector( ftvector const & src ) { template <class T, class Allocator>
// std::cout << COPLIEN_COLOR "ftvector copy constructor" RESET "\n"; vector<T, Allocator>::vector( vector const & src ) {
// std::cout << COPLIEN_COLOR "vector copy constructor" RESET "\n";
*this = src; *this = src;
return; return;
} }
@@ -27,8 +31,9 @@ ftvector::ftvector( ftvector const & src ) {
* DESTRUCTORS * DESTRUCTORS
*********************************************/ *********************************************/
ftvector::~ftvector() { template <class T, class Allocator>
// std::cout << COPLIEN_COLOR "ftvector destructor" RESET "\n"; vector<T, Allocator>::~vector() {
// std::cout << COPLIEN_COLOR "vector destructor" RESET "\n";
return; return;
} }
@@ -36,7 +41,8 @@ ftvector::~ftvector() {
* OPERATORS * OPERATORS
*********************************************/ *********************************************/
ftvector & ftvector::operator=( ftvector const & rhs ) { template <class T, class Allocator>
vector<T, Allocator> & vector<T, Allocator>::operator=( vector const & rhs ) {
// Base::operator=(rhs); // Base::operator=(rhs);
if ( this != &rhs ) if ( this != &rhs )
{ {
@@ -45,7 +51,7 @@ ftvector & ftvector::operator=( ftvector const & rhs ) {
return *this; return *this;
} }
//std::ostream & operator<<(std::ostream & o, ftvector const & rhs) //std::ostream & operator<<(std::ostream & o, vector const & rhs)
//{ //{
// o << rhs.getFoo(); // o << rhs.getFoo();
// return (o); // return (o);
@@ -60,9 +66,11 @@ ftvector & ftvector::operator=( ftvector const & rhs ) {
* iterators : * iterators :
*************/ *************/
// begin ------------------------------------- // begin -------------------------------------
ftvector::iterator ftvector::begin() {return _mem_ptr;} template <class T, class Allocator>
typename vector<T, Allocator>::iterator vector<T, Allocator>::begin() {return _mem_ptr;}
// end --------------------------------------- // end ---------------------------------------
ftvector::iterator ftvector::end() {return &_mem_ptr[_size];} template <class T, class Allocator>
typename vector<T, Allocator>::iterator vector<T, Allocator>::end() {return &_mem_ptr[_size];}
// rbegin ------------------------------------ // rbegin ------------------------------------
// rend -------------------------------------- // rend --------------------------------------
@@ -70,13 +78,15 @@ ftvector::iterator ftvector::end() {return &_mem_ptr[_size];}
* capacity : * capacity :
************/ ************/
// size -------------------------------------- // size --------------------------------------
ftvector::size_type ftvector::size() const {return _size;} template <class T, class Allocator>
typename vector<T, Allocator>::size_type vector<T, Allocator>::size() const {return _size;}
// max_size ---------------------------------- // max_size ----------------------------------
// resize ------------------------------------ // resize ------------------------------------
// capacity ---------------------------------- // capacity ----------------------------------
// empty ------------------------------------- // empty -------------------------------------
// reserve ----------------------------------- // reserve -----------------------------------
void ftvector::reserve(size_type new_cap) { template <class T, class Allocator>
void vector<T, Allocator>::reserve(size_type new_cap) {
value_type * tmp_ptr; value_type * tmp_ptr;
iterator first = begin(); iterator first = begin();
iterator last = end(); iterator last = end();
@@ -107,6 +117,8 @@ void ftvector::reserve(size_type new_cap) {
* element access : * element access :
******************/ ******************/
// operator[] -------------------------------- // operator[] --------------------------------
template <class T, class Allocator>
typename vector<T, Allocator>::reference vector<T, Allocator>::operator[](size_type n) {return _mem_ptr[n];}
// at ---------------------------------------- // at ----------------------------------------
// front ------------------------------------- // front -------------------------------------
// back -------------------------------------- // back --------------------------------------
@@ -116,17 +128,12 @@ void ftvector::reserve(size_type new_cap) {
*************/ *************/
// assign ------------------------------------ // assign ------------------------------------
// push_back --------------------------------- // push_back ---------------------------------
void ftvector::push_back(const value_type & element) { template <class T, class Allocator>
void vector<T, Allocator>::push_back(const value_type & element) {
if (_size >= _capacity) if (_size >= _capacity)
reserve(std::min(_size + 1, _allocator.max_size() / 2) * 2); reserve(std::min(_size + 1, _allocator.max_size() / 2) * 2);
_allocator.construct(&_mem_ptr[_size], element); _allocator.construct(&_mem_ptr[_size], element);
_size++; _size++;
// TMP
for (size_type i = 0; i < _size; i++)
std::cout << _mem_ptr[i] << "\n";
std::cout << "\n";
// TMP END
} }
// pop_back ---------------------------------- // pop_back ----------------------------------
// insert ------------------------------------ // insert ------------------------------------
@@ -141,7 +148,8 @@ void ftvector::push_back(const value_type & element) {
* PRIVATE MEMBER FUNCTIONS * PRIVATE MEMBER FUNCTIONS
*********************************************/ *********************************************/
void ftvector::_destroy(iterator first, iterator last) { template <class T, class Allocator>
void vector<T, Allocator>::_destroy(iterator first, iterator last) {
while (first != last) while (first != last)
{ {
_allocator.destroy(first); _allocator.destroy(first);
@@ -153,12 +161,12 @@ void ftvector::_destroy(iterator first, iterator last) {
* NESTED CLASS * NESTED CLASS
*********************************************/ *********************************************/
//void ftvector::Class::function() {} //void vector::Class::function() {}
/********************************************* /*********************************************
* STATICS * STATICS
*********************************************/ *********************************************/
//std::string const ftvector::_bar = "bar"; //std::string const vector::_bar = "bar";
}

151
main.cpp → tests/main.cpp
View File

@@ -1,23 +1,31 @@
#include <iostream> #include <iostream>
#include <string> #include <string>
#include "colors.h" #include "colors.h"
#include "tests.h" #include "tests.hpp"
#include <iomanip> // std::setw()
#include <vector> #include <vector>
#include "ftvector.hpp" #ifdef STL
namespace ft = std;
#else
#include "vector.hpp"
#endif
int main() { int main() {
TEST(vector::vector (constructor)) TEST(vector::vector (constructor))
{ {
ftvector myvector; ft::vector<int> myvector;
int myint[] = {12434, -2432, 12, 5345, 23, 0, -4, 387, 8432, -934723, 1}; int myint[] = {12434, -2432, 12, 5345, 23, 0, -4, 387, 8432, -934723, 1};
int size = sizeof(myint) / sizeof(myint[0]); int size = sizeof(myint) / sizeof(myint[0]);
for (int i = 0; i < size; i++) for (int i = 0; i < size; i++)
myvector.push_back (myint[i]); myvector.push_back(myint[i]);
std::cout << "myvector stores " << int(myvector.size()) << " numbers.\n"; for (int i = 0; i < size; i++)
std::cout << "[" << std::setw(2) << i << "] " << myvector[i] << "\n";
std::cout << " -> myvector stores " << int(myvector.size()) << " numbers.\n";
} }
TESTEND TESTEND
@@ -477,136 +485,3 @@ int main() {
return 0; return 0;
} }
//////////////////////////////////////////////////////////////////////////////
//
// original main
//
// #include <iostream>
// #include <string>
// #include <deque>
// #if 1 //CREATE A REAL STL EXAMPLE
// #include <map>
// #include <stack>
// #include <vector>
// namespace ft = std;
// #else
// #include <map.hpp>
// #include <stack.hpp>
// #include <vector.hpp>
// #endif
//
// #include <stdlib.h>
//
// #define MAX_RAM 4294967296
// #define BUFFER_SIZE 4096
// struct Buffer
// {
// int idx;
// char buff[BUFFER_SIZE];
// };
//
//
// #define COUNT (MAX_RAM / (int)sizeof(Buffer))
//
// template<typename T>
// class MutantStack : public ft::stack<T>
// {
// public:
// MutantStack() {}
// MutantStack(const MutantStack<T>& src) { *this = src; }
// MutantStack<T>& operator=(const MutantStack<T>& rhs)
// {
// this->c = rhs.c;
// return *this;
// }
// ~MutantStack() {}
//
// typedef typename ft::stack<T>::container_type::iterator iterator;
//
// iterator begin() { return this->c.begin(); }
// iterator end() { return this->c.end(); }
// };
//
// int main(int argc, char** argv) {
// if (argc != 2)
// {
// std::cerr << "Usage: ./test seed" << std::endl;
// std::cerr << "Provide a seed please" << std::endl;
// std::cerr << "Count value:" << COUNT << std::endl;
// return 1;
// }
// const int seed = atoi(argv[1]);
// srand(seed);
//
// ft::vector<std::string> vector_str;
// ft::vector<int> vector_int;
// ft::stack<int> stack_int;
// ft::vector<Buffer> vector_buffer;
// ft::stack<Buffer, std::deque<Buffer> > stack_deq_buffer;
// ft::map<int, int> map_int;
//
// for (int i = 0; i < COUNT; i++)
// {
// vector_buffer.push_back(Buffer());
// }
//
// for (int i = 0; i < COUNT; i++)
// {
// const int idx = rand() % COUNT;
// vector_buffer[idx].idx = 5;
// }
// ft::vector<Buffer>().swap(vector_buffer);
//
// try
// {
// for (int i = 0; i < COUNT; i++)
// {
// const int idx = rand() % COUNT;
// vector_buffer.at(idx);
// std::cerr << "Error: THIS VECTOR SHOULD BE EMPTY!!" <<std::endl;
// }
// }
// catch(const std::exception& e)
// {
// //NORMAL ! :P
// }
//
// for (int i = 0; i < COUNT; ++i)
// {
// map_int.insert(ft::make_pair(rand(), rand()));
// }
//
// int sum = 0;
// for (int i = 0; i < 10000; i++)
// {
// int access = rand();
// sum += map_int[access];
// }
// std::cout << "should be constant with the same seed: " << sum << std::endl;
//
// {
// ft::map<int, int> copy = map_int;
// }
// MutantStack<char> iterable_stack;
// for (char letter = 'a'; letter <= 'z'; letter++)
// iterable_stack.push(letter);
// for (MutantStack<char>::iterator it = iterable_stack.begin(); it != iterable_stack.end(); it++)
// {
// std::cout << *it;
// }
// std::cout << std::endl;
// return (0);
// }
//
//////////////////////////////////////////////////////////////////////////////

118
tests/main42.cpp Normal file
View File

@@ -0,0 +1,118 @@
#include <iostream>
#include <string>
#include <deque>
#if 1 //CREATE A REAL STL EXAMPLE
#include <map>
#include <stack>
#include <vector>
namespace ft = std;
#else
#include <map.hpp>
#include <stack.hpp>
#include <vector.hpp>
#endif
#include <stdlib.h>
#define MAX_RAM 4294967296
#define BUFFER_SIZE 4096
struct Buffer
{
int idx;
char buff[BUFFER_SIZE];
};
#define COUNT (MAX_RAM / (int)sizeof(Buffer))
template<typename T>
class MutantStack : public ft::stack<T>
{
public:
MutantStack() {}
MutantStack(const MutantStack<T>& src) { *this = src; }
MutantStack<T>& operator=(const MutantStack<T>& rhs)
{
this->c = rhs.c;
return *this;
}
~MutantStack() {}
typedef typename ft::stack<T>::container_type::iterator iterator;
iterator begin() { return this->c.begin(); }
iterator end() { return this->c.end(); }
};
int main(int argc, char** argv) {
if (argc != 2)
{
std::cerr << "Usage: ./test seed" << std::endl;
std::cerr << "Provide a seed please" << std::endl;
std::cerr << "Count value:" << COUNT << std::endl;
return 1;
}
const int seed = atoi(argv[1]);
srand(seed);
ft::vector<std::string> vector_str;
ft::vector<int> vector_int;
ft::stack<int> stack_int;
ft::vector<Buffer> vector_buffer;
ft::stack<Buffer, std::deque<Buffer> > stack_deq_buffer;
ft::map<int, int> map_int;
for (int i = 0; i < COUNT; i++)
{
vector_buffer.push_back(Buffer());
}
for (int i = 0; i < COUNT; i++)
{
const int idx = rand() % COUNT;
vector_buffer[idx].idx = 5;
}
ft::vector<Buffer>().swap(vector_buffer);
try
{
for (int i = 0; i < COUNT; i++)
{
const int idx = rand() % COUNT;
vector_buffer.at(idx);
std::cerr << "Error: THIS VECTOR SHOULD BE EMPTY!!" <<std::endl;
}
}
catch(const std::exception& e)
{
//NORMAL ! :P
}
for (int i = 0; i < COUNT; ++i)
{
map_int.insert(ft::make_pair(rand(), rand()));
}
int sum = 0;
for (int i = 0; i < 10000; i++)
{
int access = rand();
sum += map_int[access];
}
std::cout << "should be constant with the same seed: " << sum << std::endl;
{
ft::map<int, int> copy = map_int;
}
MutantStack<char> iterable_stack;
for (char letter = 'a'; letter <= 'z'; letter++)
iterable_stack.push(letter);
for (MutantStack<char>::iterator it = iterable_stack.begin(); it != iterable_stack.end(); it++)
{
std::cout << *it;
}
std::cout << std::endl;
return (0);
}