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

80
Makefile
View File

@@ -1,40 +1,72 @@
# - - - - - - - #
# #
# 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 #
# VARIABLES . value . != set result of command #
# . name is case sensitive . ?= set if not already set #
# - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - #
NAME = containers
NAME = containers
CC = c++
EXT = cpp
CC = c++
EXT = cpp
CFLAGS = -Wall -Wextra -Werror $(INCLUDES)
CFLAGS += -std=c++98
CFLAGS += -g3
CFLAGS = -Wall -Wextra -Werror $(INCLUDES)
CFLAGS += -std=c++98
CFLAGS += -g3
VPATH = $(D_SRCS)
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
SRCS = main.cpp \
ftvector.cpp
D_SRCS = ./tests
SRCS = main.cpp
#SRCS = main42.cpp
D_HEADERS = headers
HEADERS = colors.h \
tests.h \
ftvector.hpp
D_HEADERS = ./headers
HEADERS = colors.h \
tests.hpp \
vector.hpp
D_OBJS = builds
OBJS = $(SRCS:%.$(EXT)=$(D_OBJS)/%.o)
D_TEMPLATES = ./templates
TEMPLATES = vector.tpp
D_OBJS = builds
OBJS = $(SRCS:%.$(EXT)=$(D_OBJS)/%.o)
ifeq "$(D_OBJS)" "."
RM_OBJS = rm -f $(OBJS)
RM_OBJS = rm -f $(OBJS)
else
RM_OBJS = rm -rf $(D_OBJS)
RM_OBJS = rm -rf $(D_OBJS)
endif
@@ -46,15 +78,21 @@ endif
all: $(NAME)
stl: CFLAGS += -D STL
stl: all
ft: all
$(D_OBJS)/%.o: %.$(EXT) | $(D_OBJS)
@echo $(CYAN)"compilation (objects.o) :"$(RESET)
$(CC) $(CFLAGS) -c $< -o $@
$(D_OBJS):
mkdir $@
$(OBJS): $(HEADERS:%=$(D_HEADERS)/%)
$(OBJS): $(F_INCLUDES)
$(NAME): $(OBJS)
@echo $(CYAN)"linkage (link objects.o) :"$(RESET)
$(CC) $(OBJS) -o $@ $(LIBS)
leaks: $(NAME)

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

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

@@ -1,26 +1,48 @@
#ifndef FTVECTOR_HPP
# define FTVECTOR_HPP
#ifndef VECTOR_HPP
# define VECTOR_HPP
# include "colors.h"
# include <iostream>
# 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:
typedef int value_type;
typedef std::allocator<int> allocator_type;
typedef std::size_t size_type;
typedef T value_type;
typedef Allocator allocator_type;
typedef std::size_t size_type;
typedef int * iterator;
typedef T * iterator;
ftvector();
ftvector( ftvector const & src );
~ftvector();
ftvector & operator=( ftvector const & rhs );
typedef typename allocator_type::reference reference;
/************
* 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 :
******************/
// operator[] --------------------------------
//reference operator[](size_type n);
reference operator[](size_type n);
//const_reference operator[](size_type n) const;
// at ----------------------------------------
//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

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

@@ -1,24 +1,28 @@
#include "ftvector.hpp"
//#include "vector.hpp"
#define COPLIEN_COLOR B_CYAN
namespace ft {
/*********************************************
* CONSTRUCTORS
*********************************************/
ftvector::ftvector()
template <class T, class Allocator>
vector<T, Allocator>::vector()
: _size(0)
, _capacity(0)
, _mem_ptr(NULL)
{
// std::cout << COPLIEN_COLOR "ftvector constructor" RESET "\n";
// std::cout << COPLIEN_COLOR "vector constructor" RESET "\n";
_allocator = allocator_type();
return;
}
ftvector::ftvector( ftvector const & src ) {
// std::cout << COPLIEN_COLOR "ftvector copy constructor" RESET "\n";
template <class T, class Allocator>
vector<T, Allocator>::vector( vector const & src ) {
// std::cout << COPLIEN_COLOR "vector copy constructor" RESET "\n";
*this = src;
return;
}
@@ -27,8 +31,9 @@ ftvector::ftvector( ftvector const & src ) {
* DESTRUCTORS
*********************************************/
ftvector::~ftvector() {
// std::cout << COPLIEN_COLOR "ftvector destructor" RESET "\n";
template <class T, class Allocator>
vector<T, Allocator>::~vector() {
// std::cout << COPLIEN_COLOR "vector destructor" RESET "\n";
return;
}
@@ -36,7 +41,8 @@ ftvector::~ftvector() {
* 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);
if ( this != &rhs )
{
@@ -45,7 +51,7 @@ ftvector & ftvector::operator=( ftvector const & rhs ) {
return *this;
}
//std::ostream & operator<<(std::ostream & o, ftvector const & rhs)
//std::ostream & operator<<(std::ostream & o, vector const & rhs)
//{
// o << rhs.getFoo();
// return (o);
@@ -60,9 +66,11 @@ ftvector & ftvector::operator=( ftvector const & rhs ) {
* iterators :
*************/
// 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 ---------------------------------------
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 ------------------------------------
// rend --------------------------------------
@@ -70,13 +78,15 @@ ftvector::iterator ftvector::end() {return &_mem_ptr[_size];}
* capacity :
************/
// 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 ----------------------------------
// resize ------------------------------------
// capacity ----------------------------------
// empty -------------------------------------
// 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;
iterator first = begin();
iterator last = end();
@@ -107,6 +117,8 @@ void ftvector::reserve(size_type new_cap) {
* element access :
******************/
// operator[] --------------------------------
template <class T, class Allocator>
typename vector<T, Allocator>::reference vector<T, Allocator>::operator[](size_type n) {return _mem_ptr[n];}
// at ----------------------------------------
// front -------------------------------------
// back --------------------------------------
@@ -116,17 +128,12 @@ void ftvector::reserve(size_type new_cap) {
*************/
// assign ------------------------------------
// 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)
reserve(std::min(_size + 1, _allocator.max_size() / 2) * 2);
_allocator.construct(&_mem_ptr[_size], element);
_size++;
// TMP
for (size_type i = 0; i < _size; i++)
std::cout << _mem_ptr[i] << "\n";
std::cout << "\n";
// TMP END
}
// pop_back ----------------------------------
// insert ------------------------------------
@@ -141,7 +148,8 @@ void ftvector::push_back(const value_type & element) {
* 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)
{
_allocator.destroy(first);
@@ -153,12 +161,12 @@ void ftvector::_destroy(iterator first, iterator last) {
* NESTED CLASS
*********************************************/
//void ftvector::Class::function() {}
//void vector::Class::function() {}
/*********************************************
* 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 <string>
#include "colors.h"
#include "tests.h"
#include "tests.hpp"
#include <iomanip> // std::setw()
#include <vector>
#include "ftvector.hpp"
#ifdef STL
namespace ft = std;
#else
#include "vector.hpp"
#endif
int main() {
TEST(vector::vector (constructor))
{
ftvector myvector;
ft::vector<int> myvector;
int myint[] = {12434, -2432, 12, 5345, 23, 0, -4, 387, 8432, -934723, 1};
int size = sizeof(myint) / sizeof(myint[0]);
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
@@ -477,136 +485,3 @@ int main() {
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);
}