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

resolve template specialization with inline keyword

Browse Source
This commit is contained in:
hugogogo
2022-06-18 17:58:14 +02:00
parent 72762a79cb
commit 94745ca8a9
11 changed files with 222 additions and 327 deletions
Download Patch File Download Diff File Expand all files Collapse all files

22
Makefile
View File

@@ -32,7 +32,7 @@ RESET = "\e[0m"
NAME = containers NAME = containers
CC = clang++ CC = g++
EXT = cpp EXT = cpp
CFLAGS = -Wall -Wextra -Werror $(INCLUDES) CFLAGS = -Wall -Wextra -Werror $(INCLUDES)
@@ -44,22 +44,22 @@ VPATH = $(D_SRCS)
LIBS = LIBS =
F_INCLUDES = $(HEADERS:%=$(D_HEADERS)/%) \ F_INCLUDES = $(HEADERS:%=$(D_HEADERS)/%) \
$(TEMPLATES:%=$(D_TEMPLATES)/%) $(TEMPLATES:%=$(D_TEMPLATES)/%) \
$(TESTS:%=$(D_TESTS)/%)
INCLUDES = -I$(D_HEADERS) \ INCLUDES = -I$(D_HEADERS) \
-I$(D_TEMPLATES) -I$(D_TEMPLATES) \
-I$(D_TESTS)
D_SRCS = ./tests D_SRCS = ./tests
#SRCS = main42.cpp #SRCS = main42.cpp
SRCS = main.cpp \ SRCS = main.cpp \
tests_vector.cpp tests_definitions.cpp \
\
# tests_map.cpp tests_vector.cpp \
tests_map.cpp
D_HEADERS = ./headers D_HEADERS = ./headers
HEADERS = colors.h \ HEADERS = colors.h \
tests_utils.hpp \
tests_proto.hpp \
A_test.hpp \
\ \
enable_if.hpp \ enable_if.hpp \
iterator_traits.hpp \ iterator_traits.hpp \
@@ -72,6 +72,10 @@ HEADERS = colors.h \
D_TEMPLATES = ./templates D_TEMPLATES = ./templates
TEMPLATES = vector.tpp TEMPLATES = vector.tpp
D_TESTS = ./tests/includes
TESTS = main.hpp \
tests_utils.hpp
D_OBJS = builds D_OBJS = builds
OBJS = $(SRCS:%.$(EXT)=$(D_OBJS)/%.o) OBJS = $(SRCS:%.$(EXT)=$(D_OBJS)/%.o)

132
headers/tests.hpp
View File

@@ -1,132 +0,0 @@
#ifndef TESTS_HPP
# define TESTS_HPP
#include "colors.h"
#include <iostream>
#include <string>
#include <iomanip> // std::setw()
#include <iterator> // std::reverse_iterator
#include <utility> // std::make_pair
#include <sstream> // std::stringstream
// toogle between test ft and stl
// *************************
#include <vector>
#include <map>
#ifdef STL
namespace ft = std;
#else
#include "vector.hpp"
#include "reverse_iterator.hpp"
#endif
// global variables
// ***************************************
std::vector< std::vector<A_test*> > test_list;
std::vector<mystruct*> mem_list;
// global functions
// ***************************************
void add_to_list(std::string s, A_test* s1, A_test* s2, A_test* s3, A_test* s4);
// struct for tests
// ***************************************
struct mystruct {
public:
mystruct(int data = 0);
~mystruct();
int * get_data() const;
private:
int * _val;
};
std::ostream & operator<<(std::ostream & o, mystruct const * rhs);
// adding each test to the list
// ***************************
#define TEST(f_name) \
template <class T> struct s_ ## f_name : public A_test\
{ void func(); };\
void f_name ()\
{ add_to_list(\
#f_name,\
new(s_ ## f_name <int>),\
new(s_ ## f_name <char>),\
new(s_ ## f_name <std::string>),\
new(s_ ## f_name <mystruct*>)\
);}\
template <class T>\
void s_ ## f_name <T>::func()
// defines
// ****************************************
# define TITLE(s) std::cout << "\n" B_PURPLE #s RESET "\n\n";
# define VAL(n) val<T>(n)
# define TOI(n) toi<T>(n)
# define PRINT(n) print_vector<T>(n);
# define DELETE delete_structs();
// prototypes
// *********************************************
// vectors
void tests_vector_constructor();
void tests_vector_operator_assignation();
void tests_vector_begin();
void tests_vector_end();
void tests_vector_rbegin();
void tests_vector_rend();
void tests_vector_size();
void tests_vector_max_size();
void tests_vector_resize();
void tests_vector_capacity();
void tests_vector_empty();
void tests_vector_reserve();
void tests_vector_operator_access();
void tests_vector_at();
void tests_vector_front();
void tests_vector_back();
void tests_vector_assign();
void tests_vector_push_back();
void tests_vector_pop_back();
void tests_vector_insert();
void tests_vector_erase();
void tests_vector_swap();
void tests_vector_clear();
void tests_vector_get_allocator();
void tests_vector_relational_operators();
void tests_vector_swap_non_member();
void tests_vector_reverse_iterators();
// map
void tests_map_simple();
//void tests_map_constructor();
//void tests_map_operator_assignation();
//void tests_map_begin();
//void tests_map_end();
//void tests_map_rbegin();
//void tests_map_rend();
//void tests_map_empty();
//void tests_map_size();
//void tests_map_max_size();
//void tests_map_operator_access();
//void tests_map_insert();
//void tests_map_erase();
//void tests_map_swap();
//void tests_map_clear();
//void tests_map_key_comp();
//void tests_map_value_comp();
//void tests_map_find();
//void tests_map_count();
//void tests_map_lower_bound();
//void tests_map_upper_bound();
//void tests_map_equal_range();
//void tests_map_get_allocator();
#endif

48
headers/tests_proto.hpp → tests/includes/main.hpp
View File

@@ -1,34 +1,23 @@
#ifndef TESTS_PROTO_HPP #ifndef MAIN_HPP
# define TESTS_PROTO_HPP # define MAIN_HPP
#include "colors.h"
#include <iostream>
#include <string>
#include <iomanip> // std::setw()
#include <vector> #include <vector>
#include "A_test.hpp" #include "tests_utils.hpp"
// ************************************
// global declarations
std::vector< std::vector<A_test*> > test_list;
void add_to_list(std::string s, A_test* s1, A_test* s2, A_test* s3, A_test* s4) {
std::vector<A_test*> test_sub_list;
s1->title = s;
s2->title = s;
s3->title = s;
s4->title = s;
s1->type = "int";
s2->type = "char";
s3->type = "std::string";
s4->type = "mystruct";
test_sub_list.push_back(s1);
test_sub_list.push_back(s2);
test_sub_list.push_back(s3);
test_sub_list.push_back(s4);
test_list.push_back(test_sub_list);
}
// ************************************** // global variables
// prototypes vector // ***************************************
std::vector< std::vector<A_test*> > test_list;
std::vector< mystruct* > mem_list;
// prototypes
// *********************************************
// vectors
void tests_vector_constructor(); void tests_vector_constructor();
void tests_vector_operator_assignation(); void tests_vector_operator_assignation();
void tests_vector_begin(); void tests_vector_begin();
@@ -56,10 +45,7 @@ void tests_vector_get_allocator();
void tests_vector_relational_operators(); void tests_vector_relational_operators();
void tests_vector_swap_non_member(); void tests_vector_swap_non_member();
void tests_vector_reverse_iterators(); void tests_vector_reverse_iterators();
// map
// *****************************************
// prototypes map
void tests_map_simple(); void tests_map_simple();
//void tests_map_constructor(); //void tests_map_constructor();
//void tests_map_operator_assignation(); //void tests_map_operator_assignation();

4
headers/A_test.hpp → tests/includes/tests_A.hpp
View File

@@ -1,5 +1,5 @@
#ifndef A_TEST_HPP #ifndef TESTS_A_HPP
# define A_TEST_HPP # define TESTS_A_HPP
#include <string> #include <string>

21
tests/includes/tests_mystruct.hpp Normal file
View File

@@ -0,0 +1,21 @@
#ifndef TESTS_MYSTRUCT_HPP
# define TESTS_MYSTRUCT_HPP
#include <iostream>
struct mystruct {
public:
mystruct(int data = 0);
~mystruct();
int * get_data() const;
private:
int * _val;
};
std::ostream & operator<<(std::ostream & o, mystruct const * rhs);
#endif

47
tests/tests_utils.cpp → tests/includes/tests_templates.tpp
View File

@@ -1,35 +1,8 @@
#include "tests.hpp" #include "tests_utils.hpp"
void add_to_list(std::string s, A_test* s1, A_test* s2, A_test* s3, A_test* s4) {
std::vector<A_test*> test_sub_list;
s1->title = s;
s2->title = s;
s3->title = s;
s4->title = s;
s1->type = "int";
s2->type = "char";
s3->type = "std::string";
s4->type = "mystruct";
test_sub_list.push_back(s1);
test_sub_list.push_back(s2);
test_sub_list.push_back(s3);
test_sub_list.push_back(s4);
test_list.push_back(test_sub_list);
}
void delete_structs() {
std::vector<mystruct*>::iterator it;
std::vector<mystruct*>::iterator it_end = mem_list.end();
for (it = mem_list.begin(); it != it_end; ++it)
delete *it;
mem_list.clear();
}
// print vector
// ********************************************
template <class T> template <class T>
void print_vector(ft::vector<T> vec) { void print_vector(ft::vector<T> vec) {
@@ -42,20 +15,6 @@ template <class T>
std::cout << "\nsize:" << vec.size() << " capacty:" << vec.capacity() << "\n"; std::cout << "\nsize:" << vec.size() << " capacty:" << vec.capacity() << "\n";
} }
// mystruct
// *********************************************
mystruct::mystruct(int data) {_val = new int[2]; _val[0] = data; _val[1] = data;}
mystruct::~mystruct() {delete[] _val;}
int * mystruct::get_data() const {return _val;}
std::ostream & operator<<(std::ostream & o, mystruct const * rhs) {
if (rhs != NULL)
o << (*rhs).get_data()[0] << "," << (*rhs).get_data()[1];
else
o << "NULL";
return (o);
}
// get a value // get a value
// ********************************************* // *********************************************
template <class T> template <class T>

192
headers/tests_utils.hpp → tests/includes/tests_utils.hpp
View File

@@ -1,22 +1,21 @@
#ifndef TESTS_UTILS_HPP #ifndef TESTS_UTILS_HPP
# define TESTS_UTILS_HPP # define TESTS_UTILS_HPP
#include "colors.h" #include "colors.h"
#include "A_test.hpp"
#include <iostream> #include <iostream>
#include <string> #include <string>
#include <iomanip> // std::setw() #include <iomanip> // std::setw()
#include <iterator> // std::reverse_iterator #include <iterator> // std::reverse_iterator
#include <utility> // std::make_pair #include <utility> // std::make_pair
#include <map> // std::map
#include <sstream> // std::stringstream #include <sstream> // std::stringstream
#include <vector>
#include <map>
// toogle between test ft and stl // toogle between test ft and stl
// ************************* // *************************
#include <vector>
#include <map>
#ifdef STL #ifdef STL
namespace ft = std; namespace ft = std;
#else #else
@@ -25,31 +24,41 @@
#endif #endif
// struct for tests // defines
// *************************************** // ****************************************
# define TITLE(s) std::cout << "\n" B_PURPLE #s RESET "\n\n";
# define VAL(n) val<T>(n)
# define TOI(n) toi<T>(n)
# define PRINT(n) print_vector<T>(n);
# define DELETE delete_structs();
// prototypes
// *********************************************
struct A_test
{
virtual ~A_test(){};
std::string title;
std::string type;
virtual void func() = 0;
};
struct mystruct { struct mystruct {
public: public:
mystruct(int data = 0) {_val = new int[2]; _val[0] = data; _val[1] = data;} mystruct(int data = 0);
~mystruct() {delete[] _val;} ~mystruct();
int * get_data() const {return _val;} int * get_data() const;
private: private:
int * _val; int * _val;
}; };
//extern std::ostream & operator<<(std::ostream & o, mystruct const & rhs); std::ostream & operator<<(std::ostream & o, mystruct const * rhs);
std::ostream & operator<<(std::ostream & o, mystruct const * rhs) { void add_to_list(std::string s, A_test* s1, A_test* s2, A_test* s3, A_test* s4);
if (rhs != NULL) void delete_structs();
o << (*rhs).get_data()[0] << "," << (*rhs).get_data()[1];
else
o << "NULL";
return (o);
}
// global declarations // global variables
// ************************************ // ***************************************
extern std::vector<A_test*> test_list; extern std::vector< std::vector<A_test*> > test_list;
extern void add_to_list(std::string s, A_test* s1, A_test* s2, A_test* s3, A_test* s4); extern std::vector< mystruct* > mem_list;
std::vector<mystruct*> mem_list;
// adding each test to the list // adding each test to the list
@@ -69,77 +78,8 @@ std::vector<mystruct*> mem_list;
void s_ ## f_name <T>::func() void s_ ## f_name <T>::func()
// defines // templates print
// ****************************************
# define TITLE(s) std::cout << "\n" B_PURPLE #s RESET "\n\n";
# define VAL(n) val<T>(n)
# define TOI(n) toi<T>(n)
# define PRINT(n) print_vector<T>(n);
# define DELETE delete_structs();
// get a value
// *********************************************
template <class T>
T val(int n) {(void)n; return (T());
}
template <>
int val(int n) {return (n);
}
template <>
char val(int n) {return (n % 94 + 33);
}
template <>
std::string val(int n) {
std::string str;
std::stringstream stream;
stream << n;
stream >> str;
stream.clear();
return (str);
}
template <>
mystruct* val(int n) {
mystruct *s = new mystruct(n);
mem_list.push_back(s);
return ( s );
}
// convert a value
// ***************************************** // *****************************************
template <class T>
int toi(T t) {(void)t; return (0);
}
template <>
int toi(int i) {return (i);
}
template <>
int toi(char c) {return (c);
}
template <>
int toi(std::string str) {
int i;
std::stringstream stream;
stream << str;
stream >> i;
stream.clear();
return (i);
}
template <>
int toi(mystruct* s) {
return ( s->get_data()[0] );
}
// get a value
// *********************************************
template <class T> template <class T>
void print_vector(ft::vector<T> vec) { void print_vector(ft::vector<T> vec) {
@@ -152,17 +92,65 @@ template <class T>
std::cout << "\nsize:" << vec.size() << " capacty:" << vec.capacity() << "\n"; std::cout << "\nsize:" << vec.size() << " capacty:" << vec.capacity() << "\n";
} }
// templates get value
// *************************************
// specialization in header, make it inline :
// https://stackoverflow.com/questions/63529059/c-specialized-method-templates-produce-multiple-definition-errors
template <class T>
T val(int n) {(void)n; return (T());
}
template <>
inline int val(int n) {return (n);
}
template <>
inline char val(int n) {return (n % 94 + 33);
}
template <>
inline std::string val(int n) {
// delete vector elements std::string str;
// ********************************** std::stringstream stream;
void delete_structs() {
std::vector<mystruct*>::iterator it;
std::vector<mystruct*>::iterator it_end = mem_list.end();
for (it = mem_list.begin(); it != it_end; ++it) stream << n;
delete *it; stream >> str;
mem_list.clear(); stream.clear();
return (str);
}
template <>
inline mystruct* val(int n) {
mystruct *s = new mystruct(n);
mem_list.push_back(s);
return ( s );
}
// templates to value
// **************************************
template <class T>
int toi(T t) {(void)t; return (0);
}
template <>
inline int toi(int i) {return (i);
}
template <>
inline int toi(char c) {return (c);
}
template <>
inline int toi(std::string str) {
int i;
std::stringstream stream;
stream << str;
stream >> i;
stream.clear();
return (i);
}
template <>
inline int toi(mystruct* s) {
return ( s->get_data()[0] );
} }

8
tests/main.cpp
View File

@@ -1,9 +1,5 @@
#include <iostream>
#include <string> #include "main.hpp"
#include <iomanip> // std::setw()
#include "colors.h"
#include "A_test.hpp"
//#include "tests_proto.hpp"
int main() { int main() {

54
tests/tests_definitions.cpp Normal file
View File

@@ -0,0 +1,54 @@
#include "tests_utils.hpp"
// functions
// **********************************************
void add_to_list(std::string s, A_test* s1, A_test* s2, A_test* s3, A_test* s4) {
std::vector<A_test*> test_sub_list;
s1->title = s;
s2->title = s;
s3->title = s;
s4->title = s;
s1->type = "int";
s2->type = "char";
s3->type = "std::string";
s4->type = "mystruct";
test_sub_list.push_back(s1);
test_sub_list.push_back(s2);
test_sub_list.push_back(s3);
test_sub_list.push_back(s4);
test_list.push_back(test_sub_list);
}
void delete_structs() {
std::vector<mystruct*>::iterator it;
std::vector<mystruct*>::iterator it_end = mem_list.end();
for (it = mem_list.begin(); it != it_end; ++it)
delete *it;
mem_list.clear();
}
// mystruct
// ***********************************************
mystruct::mystruct(int data)
{_val = new int[2]; _val[0] = data; _val[1] = data;}
mystruct::~mystruct()
{delete[] _val;}
int * mystruct::get_data() const
{return _val;}
std::ostream & operator<<(std::ostream & o, mystruct const * rhs) {
if (rhs != NULL)
o << (*rhs).get_data()[0] << "," << (*rhs).get_data()[1];
else
o << "NULL";
return (o);
}

19
tests/tests_mystruct.cpp Normal file
View File

@@ -0,0 +1,19 @@
#include "tests_mystruct.hpp"
mystruct::mystruct(int data)
{_val = new int[2]; _val[0] = data; _val[1] = data;}
mystruct::~mystruct()
{delete[] _val;}
int * mystruct::get_data() const
{return _val;}
std::ostream & operator<<(std::ostream & o, mystruct const * rhs) {
if (rhs != NULL)
o << (*rhs).get_data()[0] << "," << (*rhs).get_data()[1];
else
o << "NULL";
return (o);
}

2
tests/tests_vector.cpp
View File

@@ -11,7 +11,7 @@ TEST(tests_vector_constructor)
// constructors used in the same order as described above: // constructors used in the same order as described above:
ft::vector<T> first; // empty vector of ints ft::vector<T> first; // empty vector of ints
ft::vector<T> second (4,VAL(100)); // four ints with value 100 ft::vector<T> second (4,VAL(100)); // four ints with value 100
ft::vector<T> third (second.begin(),second.end()); // iterating through second ft::vector<T> third (second.begin(),second.end()); // iterating through second
ft::vector<T> fourth (third); // a copy of third ft::vector<T> fourth (third); // a copy of third