ft_containers

{ 1phase / container 의 필수 요소 감잡기 but 이단계에선 내가 뭘 만드는지 모르는게 당연 } // 권장 학습 기간 2~3일 0. 사전 지식 공부 - SFINAE와 enable_if, allocator, is_integral, iterator traits 등 1. // type traits - enable_if, is_integral 들 구현 2. iterator traits 3. algorithm - equal, lexicographical_compare 4. pair { 2phase / 위에서 만든걸 써먹으면서 이해도 높이기 } // 권장 학습 기간 2일 5. random access iterator 6. reverse iterator { 3phase / 위에서 만든걸 사용하면서 컨테이너를 직접 구현 } // 권장 학습 기간 3일 7. vector 구현 8. vector 구현 이후 adaptor container 로 stack 구현 { 4phase / map에 대해 공부하고 tree를 구현할 준비 } // 권장 학습 기간 2일 9. tree node 10. tree iterator { 5phase / map 구현 } // 권장 학습 기간 3일 11. map -> set (인터페이스만 구현) 12. red black tree 이나 avl tree 로직을 사용하여 트리 구현 (내부로직 구현) /* 참고사항 - 대부분 구현해야할 것들은 cppreference.com 이나 cplusplus.com 에서 확인 가능 */

struct T { enum { int_t, float_t } type; template <typename Integer, std::enable_if_t<std::is_integral<Integer>::value, bool> = true > T(Integer) : type(int_t) {} template <typename Floating, std::enable_if_t<std::is_floating_point<Floating>::value, bool> = true > T(Floating) : type(float_t) {} // OK };

#include <iostream> int negate(int i) { std::cout << "int" << std::endl; return -i; } template <typename T> typename T::value_type negate(const T& t) { std::cout << "SFINAE" << std::endl; return -T(t); } int main() { negate('c'); }

#include <iostream> int negate(int i) { std::cout << "int " << std::endl; return -i; } template <typename T> void negate(const T& t) { typename T::value_type n = -t(); } int main() { negate('c'); }

template <bool, typename T = void> struct enable_if {}; template <typename T> struct enable_if<true, T> { typedef T type; };

template <class T> typename std::enable_if<std::is_integral<T>::value, bool>::type is_odd (T i) {return bool(i%2);}

template <class T> struct is_integral;

template <class T, T v> struct integral_constant { static constexpr T value = v; typedef T value_type; typedef integral_constant<T,v> type; constexpr operator T() { return v; } };

template <class T, T v> struct integral_constant { static const T value = v; typedef T value_type; typedef integral_constant<T,v> type; };

typedef integral_constant<bool, true> true_type; typedef integral_constant<bool, false> false_type;

template <> struct is_integral<bool> : public true_type{}; template <> struct is_integral<char> : public true_type {}; template <> struct is_integral<unsigned char> : public true_type {}; . . .

template <class T> struct remove_cv { typedef T type; }; template <class T> struct remove_cv<const T> { typedef T type; }; template <class T> struct remove_cv<volatile T> { typedef T type; }; template <class T> struct remove_cv<const volatile T> { typedef T type; };

template <class T> typename std::enable_if<std::is_integral<T>::value, bool>::type is_odd (T i) {return bool(i%2);}

template <class InputIterator1, class InputIterator2> bool equal (InputIterator1 first1, InputIterator1 last1, InputIterator2 first2);

template <class InputIterator1, class InputIterator2> bool lexicographical_compare (InputIterator1 first1, InputIterator1 last1, InputIterator2 first2, InputIterator2 last2);

// lexicographical_compare example#include <iostream>// std::cout, std::boolalpha#include <algorithm>// std::lexicographical_compare#include <cctype>// std::tolower// a case-insensitive comparison function: bool mycomp (char c1,char c2) {return std::tolower(c1)<std::tolower(c2); } int main () { char foo[]="Apple"; char bar[]="apartment"; std::cout << std::boolalpha; std::cout <<"Comparing foo and bar lexicographically (foo<bar):\n"; std::cout <<"Using default comparison (operator<): "; std::cout << std::lexicographical_compare(foo,foo+5,bar,bar+9); std::cout <<'\n'; std::cout <<"Using mycomp as comparison object: "; std::cout << std::lexicographical_compare(foo,foo+5,bar,bar+9,mycomp); std::cout <<'\n'; return 0; }

pointer _begin; pointer _end; pointer _end_cap; allocator_type _alloc;