├── 02_basic_template
    ├── 01_template_stack.cpp
    ├── 02_separate_implementation.cpp
    ├── 03_member_template.cpp
    ├── 04_class_and_member_template.cpp
    ├── 05_alias_templates.cpp
    ├── 06_main.cpp
    ├── 06_stack.cpp
    ├── 06_stack.h
    ├── 07_explicit_instantiation_member_function.cpp
    ├── 08_default_template_arg_function.cpp
    ├── 09_default_template_arg_class.cpp
    ├── 10_fixed_capacity_stack.cpp
    ├── 11_array_utility.cpp
    ├── 12_property.cpp
    ├── 13_constructor_template.cpp
    ├── 14_typename_keyword.cpp
    ├── 15_template_keyword.cpp
    ├── 16_specialize_function_template.cpp
    ├── 17_specialize_class_template.cpp
    ├── 18_partial_specialize.cpp
    ├── 19_overload_instead_of_partial_specialize.cpp
    ├── 20_template_template_parameter.cpp
    ├── 21_variadic_print.cpp
    ├── 22_tuple.cpp
    └── 23_initialize.cpp
├── 03_generic_programming
    ├── 01_find.cpp
    ├── 02_copy_01.cpp
    ├── 02_copy_02.cpp
    ├── 03_find_if_01.cpp
    ├── 03_find_if_02.cpp
    ├── 04_selection_sort.cpp
    ├── 05_print_all.cpp
    ├── 06_back_inserter.cpp
    ├── 07_advance.cpp
    ├── 08_decoration_01.cpp
    ├── 08_decoration_02.cpp
    └── 09_print_on.cpp
├── 04_template_meta_programming
    ├── 01_increment.cpp
    ├── 02_factorial.cpp
    ├── 03_square.cpp
    ├── 04_pow.cpp
    ├── 05_identity.cpp
    ├── 06_add_pointer.cpp
    ├── 07_add_lvalue_reference.cpp
    ├── 08_separate_meta_function.cpp
    ├── 09_combine_meta_function.cpp
    ├── 10_remove_const.cpp
    ├── 11_remove_cv.cpp
    ├── 12_if.cpp
    ├── 13_high_order_if.cpp
    ├── 14_cpp11_meta_func_00.cpp
    ├── 15_cpp11_meta_func_01.cpp
    ├── 16_cpp11_meta_func_02.cpp
    ├── 17_cpp11_meta_func_03.cpp
    ├── 18_type_list_00_head_tail.cpp
    ├── 19_type_list_01_any_of.cpp
    ├── 20_type_list_02_any_of_improve.cpp
    └── 21_type_list_03_transform.cpp
├── 05_sfinae
    ├── 01_introduction_sfinae.cpp
    ├── 02_is_void.cpp
    ├── 03_is_pointer.cpp
    ├── 04_has_iterator_function.cpp
    ├── 05_has_iterator_metafunction.cpp
    ├── 06_has_iterator_03_metafunction.cpp
    ├── 07_has_iterator_decltype.cpp
    ├── 08_is_class.cpp
    ├── 09_is_assignable.cpp
    ├── 10_is_addable.cpp
    ├── 11_enable_if.cpp
    ├── 12_has_add_member.cpp
    ├── 13_enable_if_default_template_argument.cpp
    ├── 14_sort.cpp
    ├── 15_optimized_copy.cpp
    └── 16_optimized_dtor.cpp
├── 06_policy
    ├── 01_policy_based_logger.cpp
    ├── 02_default_policy.cpp
    ├── 03_policy_based_smart_ptr.cpp
    ├── 04_inheritance_boost_multi_index.cpp
    ├── 05_named_tmpl_param
    │   ├── 1st_step.cpp
    │   ├── 2nd_step.cpp
    │   ├── find_if.hpp
    │   └── named_tmpl_param.hpp
    └── 06_sorted_vector.cpp
├── 07_concept
    ├── 01_min_requirements.cpp
    ├── 02_basic_distance.cpp
    ├── 03_concept_based_distance.cpp
    ├── 04_add_my_point.cpp
    ├── 05_concept_based_overload.cpp
    └── 06_specialize_template_with_concept.cpp
├── 08_type_erasure
    ├── 01_virtual_function_table.cpp
    ├── 02_non_template_base_and_template_derived.cpp
    ├── 03_shared_ptr_implementation.cpp
    ├── 04_any_implementation.cpp
    ├── 05_1st_step_function_implementation.cpp
    ├── 06_2nd_step_function_implementation.cpp
    └── 07_simple_type_erasure.cpp
├── 09_crtp
    ├── 01_basic_crtp.cpp
    ├── 02_equal_comparable.cpp
    ├── 03_less_than_comparable.cpp
    └── 04_enable_shared_from_this.cpp
├── 10_template_conversion_operator
    ├── 01_operator_bool.cpp
    ├── 02_for_each_macro.cpp
    ├── 03_result_type_overload.cpp
    ├── 04_template_convertion_operator.cpp
    ├── 05_container_holder.cpp
    └── 06_auto_deduction_lexical_cast.cpp
├── 11_expression_template
    ├── 01_plus_expression.cpp
    ├── 02_multiply_expression.cpp
    └── 03_expression_design.cpp
└── README.md


/02_basic_template/01_template_stack.cpp:
--------------------------------------------------------------------------------
 1 | // Copyright (c) 2014
 2 | // Akira Takahashi, Fumiki Fukuda.
 3 | // Released under the CC0 1.0 Universal license.
 4 | 
 5 | template <class T>
 6 | class Stack {
 7 |   T*  data_;
 8 |   int index_;
 9 |   int capacity_;
10 | public:
11 |   explicit Stack(int n) : capacity_(n), index_(0)
12 |     { data_ = new T[capacity_]; }
13 |   ~Stack()
14 |     { delete[] data_; }
15 |   void push(T x)
16 |     { if (index_ < capacity_) data_[index_++] = x; }
17 |   T top() const
18 |     { return data_[index_ - 1]; }
19 |   void pop()
20 |     { if (index_ > 0) --index_; }
21 | };
22 | 
23 | // 3種のStackを使う……
24 | int main()
25 | {
26 |   Stack<int>   istack(5);
27 |   Stack<long>  lstack(8);
28 |   Stack<void*> pstack(10);
29 |   istack.push(1);
30 |   istack.push(2);
31 | //……
32 | }
33 | 


--------------------------------------------------------------------------------
/02_basic_template/02_separate_implementation.cpp:
--------------------------------------------------------------------------------
 1 | // Copyright (c) 2014
 2 | // Akira Takahashi, Fumiki Fukuda.
 3 | // Released under the CC0 1.0 Universal license.
 4 | 
 5 | template <class T>
 6 | class Stack {
 7 |   T*  data_;
 8 |   int index_;
 9 |   int capacity_;
10 | public:
11 |   explicit Stack(int n);
12 |   ~Stack();
13 |   void push(T x);
14 |   T top() const;
15 |   void pop();
16 | };
17 | 
18 | template <class T>
19 | Stack<T>::Stack(int n) : capacity_(n), index_(0)
20 | {
21 |   data_ = new T[capacity_];
22 | }
23 | 
24 | template <class T>
25 | Stack<T>::~Stack()
26 | {
27 |   delete[] data_;
28 | }
29 | 
30 | template <class T>
31 | void Stack<T>::push(T x)
32 | {
33 |   if (index_ < capacity_) data_[index_++] = x;
34 | }
35 | 
36 | template <class T>
37 | T Stack<T>::top() const
38 | {
39 |   return data_[index_ - 1];
40 | }
41 | 
42 | template <class T>
43 | void Stack<T>::pop()
44 | {
45 |   if (index_ > 0)
46 |     --index_;
47 | }
48 | 
49 | // 3種のStackを使う……
50 | int main()
51 | {
52 |   Stack<int>   istack(5);
53 |   Stack<long>  lstack(8);
54 |   Stack<void*> pstack(10);
55 |   istack.push(1);
56 |   istack.push(2);
57 | //……
58 | }
59 | 


--------------------------------------------------------------------------------
/02_basic_template/03_member_template.cpp:
--------------------------------------------------------------------------------
 1 | // Copyright (c) 2014
 2 | // Akira Takahashi, Fumiki Fukuda.
 3 | // Released under the CC0 1.0 Universal license.
 4 | 
 5 | #include <iostream>
 6 | 
 7 | class Foo {
 8 |   int value_;
 9 | public:
10 |   Foo(int v) : value_(v) {}
11 | 
12 |   template <class T>
13 |   void get(T& dst) const
14 |   {
15 |     dst = value_;
16 |   }
17 | 
18 | //……
19 | };
20 | 
21 | 
22 | int main()
23 | {
24 |   Foo f(3);
25 |   long v;
26 |   f.get(v);
27 | 
28 |   std::cout << v << std::endl;
29 | }
30 | 


--------------------------------------------------------------------------------
/02_basic_template/04_class_and_member_template.cpp:
--------------------------------------------------------------------------------
 1 | // Copyright (c) 2014
 2 | // Akira Takahashi, Fumiki Fukuda.
 3 | // Released under the CC0 1.0 Universal license.
 4 | 
 5 | #include <iostream>
 6 | 
 7 | template <class T>
 8 | class Stack {
 9 |   T*  data_;
10 |   int index_;
11 |   int capacity_;
12 | public:
13 |   explicit Stack(int n);
14 |   ~Stack();
15 |   void push(T x);
16 | 
17 |   template <class U>
18 |   void top(U& dst) const;
19 | 
20 |   void pop();
21 | };
22 | 
23 | template <class T>
24 | Stack<T>::Stack(int n) : capacity_(n), index_(0)
25 | {
26 |   data_ = new T[capacity_];
27 | }
28 | 
29 | template <class T>
30 | Stack<T>::~Stack()
31 | {
32 |   delete[] data_;
33 | }
34 | 
35 | template <class T>
36 | void Stack<T>::push(T x)
37 | {
38 |   if (index_ < capacity_) data_[index_++] = x;
39 | }
40 | 
41 | template <class T>
42 | template <class U>
43 | void Stack<T>::top(U& dst) const
44 | {
45 |   dst = data_[index_ - 1];
46 | }
47 | 
48 | template <class T>
49 | void Stack<T>::pop()
50 | {
51 |   if (index_ > 0)
52 |     --index_;
53 | }
54 | 
55 | int main()
56 | {
57 |   const int n = 1;
58 |   Stack<char> s(n);
59 |   s.push('A');
60 | 
61 |   int i;
62 |   long l;
63 | 
64 |   s.top(i);
65 |   s.top(l);
66 | 
67 |   std::cout << static_cast<char>(i) << std::endl;
68 |   std::cout << static_cast<char>(l) << std::endl;
69 | }
70 | 


--------------------------------------------------------------------------------
/02_basic_template/05_alias_templates.cpp:
--------------------------------------------------------------------------------
 1 | // Copyright (c) 2014
 2 | // Akira Takahashi, Fumiki Fukuda.
 3 | // Released under the CC0 1.0 Universal license.
 4 | 
 5 | template <class T, class Allocator>
 6 | class Stack {
 7 |   T*  data_;
 8 |   int index_;
 9 |   int capacity_;
10 | public:
11 |   explicit Stack(int n) : capacity_(n), index_(0)
12 |     {
13 |       Allocator alloc;
14 |       data_ = alloc.allocate(capacity_);
15 |       for (int i = 0; i < capacity_; ++i) {
16 |         alloc.construct(data_ + i);
17 |       }
18 |     }
19 |   ~Stack()
20 |     { delete[] data_; }
21 |   void push(T x)
22 |     { if (index_ < capacity_) data_[index_++] = x; }
23 |   T top() const
24 |     { return data_[index_ - 1]; }
25 |   void pop()
26 |     { if (index_ > 0) --index_; }
27 | };
28 | 
29 | #include <memory>
30 | 
31 | template <class T>
32 | using MyAllocator = std::allocator<T>;
33 | 
34 | // カスタムアロケータを使用するStack型
35 | template <class T>
36 | using MyStack = Stack<T, MyAllocator<T>>;
37 | 
38 | int main()
39 | {
40 |   // 要素型のみ後から指定する
41 |   const int n = 3;
42 |   MyStack<int> s(n);
43 | }
44 | 


--------------------------------------------------------------------------------
/02_basic_template/06_main.cpp:
--------------------------------------------------------------------------------
 1 | // Copyright (c) 2014
 2 | // Akira Takahashi, Fumiki Fukuda.
 3 | // Released under the CC0 1.0 Universal license.
 4 | 
 5 | #include <iostream>
 6 | #include "06_stack.h"
 7 | 
 8 | int main()
 9 | {
10 |   Stack<int> s(10);
11 |   s.push(1);
12 |   s.push(2);
13 |   while (s.size() != 0) {
14 |     std::cout << s.top() << std::endl;
15 |     s.pop();
16 |   }
17 | }
18 | 


--------------------------------------------------------------------------------
/02_basic_template/06_stack.cpp:
--------------------------------------------------------------------------------
 1 | // Copyright (c) 2014
 2 | // Akira Takahashi, Fumiki Fukuda.
 3 | // Released under the CC0 1.0 Universal license.
 4 | 
 5 | #include "06_stack.h"
 6 | 
 7 | template <class T>
 8 | Stack<T>::Stack(int n) : capacity_(n), index_(0)
 9 | {
10 |   data_ = new T[capacity_];
11 | }
12 | 
13 | template <class T>
14 | Stack<T>::~Stack()
15 | {
16 |   delete[] data_;
17 | }
18 | 
19 | template <class T>
20 | void Stack<T>::push(T x)
21 | {
22 |   if (index_ < capacity_) {
23 |     data_[index_++] = x;
24 |   }
25 | }
26 | 
27 | template <class T>
28 | T Stack<T>::top() const
29 | {
30 |   return data_[index_ - 1];
31 | }
32 | 
33 | template <class T>
34 | void Stack<T>::pop()
35 | {
36 |   if (index_ > 0) {
37 |     --index_;
38 |   }
39 | }
40 | 
41 | template <class T>
42 | int Stack<T>::size() const
43 | {
44 |   return index_;
45 | }
46 | 
47 | template class Stack<int>;
48 | 


--------------------------------------------------------------------------------
/02_basic_template/06_stack.h:
--------------------------------------------------------------------------------
 1 | // Copyright (c) 2014
 2 | // Akira Takahashi, Fumiki Fukuda.
 3 | // Released under the CC0 1.0 Universal license.
 4 | 
 5 | #ifndef STACK_H_
 6 | #define STACK_H_
 7 | 
 8 | template <class T>
 9 | class Stack {
10 |   T*  data_;
11 |   int index_;
12 |   int capacity_;
13 | public:
14 |   explicit Stack(int n);
15 |   ~Stack();
16 | 
17 |   void push(T x);
18 |   T top() const;
19 |   void pop();
20 |   int size() const;
21 | };
22 | #endif
23 | 


--------------------------------------------------------------------------------
/02_basic_template/07_explicit_instantiation_member_function.cpp:
--------------------------------------------------------------------------------
 1 | // Copyright (c) 2014
 2 | // Akira Takahashi, Fumiki Fukuda.
 3 | // Released under the CC0 1.0 Universal license.
 4 | 
 5 | #include <iostream>
 6 | #include <string>
 7 | 
 8 | template <class T>
 9 | class Util {
10 |   T value_;
11 | public:
12 |   Util(const T& v);
13 |   void add(const T& v);
14 |   T get() const;
15 |   int size() const;
16 | };
17 | 
18 | template <class T>
19 | Util<T>::Util(const T& v) : value_(v) {}
20 | 
21 | template <class T>
22 | void Util<T>::add(const T& v) { value_ += v; }
23 | 
24 | template <class T>
25 | T Util<T>::get() const { return value_; }
26 | 
27 | template <class T>
28 | int Util<T>::size() const { return value_.size(); }
29 | 
30 | 
31 | // クラス全体を明示的にインスタンス化する
32 | // template class Util<int>; // コンパイルエラー！intはsize()メンバ関数を持っていない
33 | 
34 | // 個々のメンバ関数を明示的にインスタンス化する
35 | // OK
36 | template Util<int>::Util(const int&);
37 | template void Util<int>::add(const int&);
38 | template int Util<int>::get() const;
39 | 
40 | int main()
41 | {
42 |   Util<int> iu(12);
43 |   iu.add(34);
44 |   std::cout << iu.get() << std::endl;
45 |   Util<std::string> su("hello, ");
46 |   su.add("C++");
47 |   std::cout << su.get() << std::endl;
48 | }
49 | 


--------------------------------------------------------------------------------
/02_basic_template/08_default_template_arg_function.cpp:
--------------------------------------------------------------------------------
 1 | // Copyright (c) 2014
 2 | // Akira Takahashi, Fumiki Fukuda.
 3 | // Released under the CC0 1.0 Universal license.
 4 | 
 5 | #include <iostream>
 6 | #include <iomanip>
 7 | 
 8 | template <class T = double> // 省略時はdoubleとみなす
 9 | T pi() { return T(3.1415926536); }
10 | 
11 | int main()
12 | {
13 |   float  x = pi<float>(); // 型の明示
14 |   double y = pi<>();      // 省略時 : pi<double>()
15 |   double z = pi();        // 同上
16 | 
17 |   std::cout << std::setprecision(10) << std::fixed;
18 |   std::cout << x << std::endl;
19 |   std::cout << y << std::endl;
20 |   std::cout << z << std::endl;
21 | }
22 | 


--------------------------------------------------------------------------------
/02_basic_template/09_default_template_arg_class.cpp:
--------------------------------------------------------------------------------
 1 | // Copyright (c) 2014
 2 | // Akira Takahashi, Fumiki Fukuda.
 3 | // Released under the CC0 1.0 Universal license.
 4 | 
 5 | #include <iostream>
 6 | #include <iomanip>
 7 | 
 8 | template <class X = double, class Y = char, class Z = Y>
 9 | struct xyz {
10 |   X x;
11 |   Y y;
12 |   Z z;
13 | };
14 | 
15 | int main()
16 | {
17 |   xyz<> s0; //　→　xyz<double, char, char>
18 |   xyz<int> s1; //　→　xyz<int, char, char>
19 |   xyz<int, long> s2; //　→　xyz<int, long, long>
20 |   xyz<int, long, int> s3; //　→　xyz<int, long, int>
21 | }
22 | 


--------------------------------------------------------------------------------
/02_basic_template/10_fixed_capacity_stack.cpp:
--------------------------------------------------------------------------------
 1 | // Copyright (c) 2014
 2 | // Akira Takahashi, Fumiki Fukuda.
 3 | // Released under the CC0 1.0 Universal license.
 4 | 
 5 | template <class T, int N = 10>
 6 | class Stack {
 7 |   T   data_[N];
 8 |   int index_;
 9 | public:
10 |   Stack() : index_(0) {}
11 |   ~Stack() {}
12 |   void push(T x)
13 |     { if (index_ < N) data_[index_++] = x; }
14 |   T top() const
15 |     { return data_[index_ - 1]; }
16 |   void pop()
17 |     { if (index_ > 0) --index_; }
18 | };
19 | 
20 | // 3種のStackを使う……
21 | int main()
22 | {
23 |   Stack<int, 5>  istack;
24 |   Stack<long, 8> lstack;
25 |   Stack<void*>   pstack; // 省略時は10
26 | //……
27 | }
28 | 
29 | 


--------------------------------------------------------------------------------
/02_basic_template/11_array_utility.cpp:
--------------------------------------------------------------------------------
 1 | // Copyright (c) 2014
 2 | // Akira Takahashi, Fumiki Fukuda.
 3 | // Released under the CC0 1.0 Universal license.
 4 | 
 5 | #include <iostream>
 6 | 	
 7 | template <class T, int N>
 8 | int size(T (&ar)[N])
 9 | {
10 |   return N;
11 | }
12 | 
13 | template <class T, int N>
14 | T last_element(T (&ar)[N])
15 | {
16 |   return ar[N - 1];
17 | }
18 | 
19 | int main()
20 | {
21 |   int data[] = { 1, 3, 5, 7, 9 };
22 |   int n = size(data); // 5を返す
23 |   int last = last_element(data); // data[4]を返す
24 | 
25 |   std::cout << n << std::endl;
26 |   std::cout << last << std::endl;
27 | }
28 | 


--------------------------------------------------------------------------------
/02_basic_template/12_property.cpp:
--------------------------------------------------------------------------------
 1 | // Copyright (c) 2014
 2 | // Akira Takahashi, Fumiki Fukuda.
 3 | // Released under the CC0 1.0 Universal license.
 4 | 
 5 | /*
 6 | N1615: C++ Properties -- a Library Solution
 7 | http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2004/n1615.pdf
 8 | より抜粋
 9 | */
10 | 
11 | template <class T, class Object,       // プロパティの型、オーナーの型
12 |           T (Object::*real_getter)()const,    // get 関数
13 |           T (Object::*real_setter)(const T&)> // set 関数
14 | class RWProperty {
15 |   Object* my_object;
16 | public:
17 |   // プロパティのオーナー（所有者） を設定
18 |   void operator()(Object* obj) { my_object = obj; }
19 |   // 関数呼び出しによるget／set
20 |   T operator()() const
21 |     { return (my_object->*real_getter)(); }
22 |   T operator()(const T& value)
23 |     { return (my_object->*real_setter)(value); }
24 |   // メンバ関数get／set
25 |   T get() const
26 |     { return (my_object->*real_getter)(); }
27 |   T set(const T& value)
28 |     { return (my_object->*real_setter)(value); }
29 |   // '='演算子によるアクセス
30 |   operator T() const
31 |     { return (my_object->*real_getter)(); }
32 |   T operator=(const T& value)
33 |     { return (my_object->*real_setter)(value); }
34 |   typedef T value_type;
35 | };
36 | 
37 | #include <iostream>
38 | #include <string>
39 | 
40 | using namespace std;
41 | 
42 | class Cat {
43 | private:
44 |   int    age_;
45 |   string name_;
46 |   int set_age(const int& age) { return age_ = age; }
47 |   int get_age()const { return age_; }
48 |   string set_name(const string& name) { return name_ = name; }
49 |   string get_name()const { return name_; }
50 | public:
51 |   RWProperty<int, Cat, &Cat::get_age, &Cat::set_age> age;
52 |   RWProperty<string, Cat, &Cat::get_name, &Cat::set_name> name;
53 |   Cat() { age(this); name(this); }
54 | };
55 | 
56 | int main()
57 | {
58 |   Cat aCat;
59 |   aCat.age = 4;
60 |   aCat.name = "tama";
61 |   int age = aCat.age;
62 |   string name = aCat.name;
63 |   cout << name << " is " << age << " years old.\n";
64 | }
65 | 


--------------------------------------------------------------------------------
/02_basic_template/13_constructor_template.cpp:
--------------------------------------------------------------------------------
 1 | // Copyright (c) 2014
 2 | // Akira Takahashi, Fumiki Fukuda.
 3 | // Released under the CC0 1.0 Universal license.
 4 | 
 5 | #include <iostream>
 6 | 
 7 | template <class T>
 8 | class Point {
 9 |   template<class> friend class Point;
10 | private:
11 |   T x_;
12 |   T y_;
13 | public:
14 |   // これがコンストラクタテンプレート
15 |   template <class U>
16 |   Point(const Point<U>& r) : x_(r.x_), y_(r.y_) {}
17 | 
18 |   Point(T x = T(), T y = T()) : x_(x), y_(y) {}
19 |   Point(const Point& pt) : x_(pt.x_), y_(pt.y_) {}
20 |   void print(std::ostream& s) const
21 |     { return s << '(' << x_ << ',' << y_ << ')'; }
22 | };
23 | 
24 | 
25 | int main()
26 | {
27 |   Point<int>  ip(12, 34);
28 |   Point<long> lp(ip);
29 | }
30 | 


--------------------------------------------------------------------------------
/02_basic_template/14_typename_keyword.cpp:
--------------------------------------------------------------------------------
 1 | // Copyright (c) 2014
 2 | // Akira Takahashi, Fumiki Fukuda.
 3 | // Released under the CC0 1.0 Universal license.
 4 | 
 5 | struct X {
 6 |   typedef int result;
 7 |   result f();
 8 | //……
 9 | };
10 | 
11 | struct Y {
12 |   static const int result = 5;
13 | //……
14 | };
15 | 
16 | int p;
17 | 
18 | template <class T>
19 | void g(T arg)
20 | {
21 |   typename T::result* p;
22 | //……
23 | }
24 | 
25 | int main()
26 | {
27 |   g(X()); // OK
28 | //g(Y()); // コンパイルエラー！Yはresult型を持っていない
29 | }
30 | 


--------------------------------------------------------------------------------
/02_basic_template/15_template_keyword.cpp:
--------------------------------------------------------------------------------
 1 | // Copyright (c) 2014
 2 | // Akira Takahashi, Fumiki Fukuda.
 3 | // Released under the CC0 1.0 Universal license.
 4 | 
 5 | #include <iostream>
 6 | 
 7 | class utility {
 8 | public:
 9 |   template <int N>
10 |   int get(int arg)
11 |   {
12 |     return N + arg;
13 |   }
14 | };
15 | 
16 | template <class T>
17 | int foo(T x, int n)
18 | {
19 |   return x.template get<3>(n);
20 | }
21 | 
22 | int main()
23 | {
24 |   std::cout << foo(utility(), 2) << std::endl;
25 | }
26 | 


--------------------------------------------------------------------------------
/02_basic_template/16_specialize_function_template.cpp:
--------------------------------------------------------------------------------
 1 | // Copyright (c) 2014
 2 | // Akira Takahashi, Fumiki Fukuda.
 3 | // Released under the CC0 1.0 Universal license.
 4 | 
 5 | #include <iostream>
 6 | #include <cstring> // strcmp
 7 | 
 8 | template <class T>
 9 | bool equal(T x, T y)
10 | {
11 |   return x == y;
12 | }
13 | 
14 | template <>
15 | bool equal(const char* x, const char* y)
16 | {
17 |   return std::strcmp(x, y) == 0;
18 | }
19 | 
20 | int main()
21 | {
22 |   int n = 3;
23 |   const char* s = "C++";
24 |   std::cout << std::boolalpha;
25 |   std::cout << equal(n, 2) << std::endl;
26 |   std::cout << equal(n, 3) << std::endl;
27 |   std::cout << equal(s, "Java") << std::endl;
28 |   std::cout << equal(s, "C++") << std::endl;
29 | }
30 | 


--------------------------------------------------------------------------------
/02_basic_template/17_specialize_class_template.cpp:
--------------------------------------------------------------------------------
 1 | // Copyright (c) 2014
 2 | // Akira Takahashi, Fumiki Fukuda.
 3 | // Released under the CC0 1.0 Universal license.
 4 | 
 5 | #include <iostream>
 6 | #include <string>
 7 | 
 8 | // プライマリテンプレート
 9 | template <class T>
10 | class printer {
11 | public:
12 |   void out(const T& value) const
13 |   {
14 |     std::cout << value;
15 |   }
16 | };
17 | 
18 | // std::string に対する特殊化
19 | template <>
20 | class printer<std::string> {
21 | public:
22 |   void out(const std::string& value) const
23 |   {
24 |     // 文字列は "" で囲む
25 |     std::cout << '"' << value << '"';
26 |   }
27 | };
28 | 
29 | int main()
30 | {
31 |   printer<int>().out(3);
32 |   std::cout << std::endl;
33 |   printer<std::string>().out("hello");
34 | }
35 | 


--------------------------------------------------------------------------------
/02_basic_template/18_partial_specialize.cpp:
--------------------------------------------------------------------------------
 1 | // Copyright (c) 2014
 2 | // Akira Takahashi, Fumiki Fukuda.
 3 | // Released under the CC0 1.0 Universal license.
 4 | 
 5 | #include <iostream>
 6 | #include <string>
 7 | 
 8 | #include <iostream>
 9 | 
10 | template <class T>
11 | class printer {
12 | public:
13 |   // 標準出力に出力
14 |   void out(T value)
15 |   {
16 |     std::cout << value << std::endl;
17 |   }
18 | };
19 | 
20 | // ポインタに対する部分特殊化
21 | template <class T>
22 | class printer<T*> {
23 | public:
24 |   void out(T* value) const
25 |   {
26 |     std::cout << *value << std::endl;
27 |   }
28 | };
29 | 
30 | int main()
31 | {
32 |   printer<int*> prt; // 部分特殊化版がインスタンス化される
33 |   int n = 123;
34 |   prt.out(&n);       // &nが指す値（123）が出力される
35 | }
36 | 
37 | 


--------------------------------------------------------------------------------
/02_basic_template/19_overload_instead_of_partial_specialize.cpp:
--------------------------------------------------------------------------------
 1 | // Copyright (c) 2014
 2 | // Akira Takahashi, Fumiki Fukuda.
 3 | // Released under the CC0 1.0 Universal license.
 4 | 
 5 | #include <iostream>
 6 | 
 7 | template <class T>
 8 | void print(T value) { std::cout << value << std::endl; }   // ［1］
 9 | 
10 | template <class T>
11 | void print(T* value) { std::cout << *value << std::endl; } // ［2］
12 | 
13 | int main()
14 | {
15 |   int n = 123;
16 |   print(n);  // ［1］が呼ばれる
17 |   print(&n); // ［2］が呼ばれる
18 | }
19 | 


--------------------------------------------------------------------------------
/02_basic_template/20_template_template_parameter.cpp:
--------------------------------------------------------------------------------
 1 | // Copyright (c) 2014
 2 | // Akira Takahashi, Fumiki Fukuda.
 3 | // Released under the CC0 1.0 Universal license.
 4 | 
 5 | #include <vector>
 6 | #include <list>
 7 | #include <string>
 8 | #include <iostream>
 9 | #include <iterator>
10 | #include <algorithm>
11 | 
12 | using namespace std;
13 | 
14 | template <template<class T, class A = allocator<T>>
15 |           class Container>
16 | class Phonebook {
17 |   struct Record {
18 |     string name;
19 |     string phone;
20 |     Record(const string& n, const string& p) : name(n), phone(p) {}
21 |     friend ostream& operator<<(ostream& stream, const Record& r)
22 |     {
23 |       return stream << r.name << ':' << r.phone;
24 |     }
25 |   };
26 |   Container<Record> book;
27 | public:
28 |   void add(const string& name, const string& phone)
29 |   {
30 |     book.emplace_back(name,phone);
31 |   }
32 | 
33 |   void print(ostream& stream) const
34 |   {
35 |     copy(begin(book), end(book),
36 |          ostream_iterator<Record>(stream, "\n"));
37 |   }
38 | };
39 | 
40 | int main()
41 | {
42 |   Phonebook<vector> pb; // list,deque も指定可能
43 |   pb.add("police", "110");
44 |   pb.add("fire", "119");
45 |   pb.add("weather", "177");
46 |   pb.print(std::cout);
47 | }
48 | 


--------------------------------------------------------------------------------
/02_basic_template/21_variadic_print.cpp:
--------------------------------------------------------------------------------
 1 | // Copyright (c) 2014
 2 | // Akira Takahashi, Fumiki Fukuda.
 3 | // Released under the CC0 1.0 Universal license.
 4 | 
 5 | #include <iostream>
 6 | #include <typeinfo>
 7 | 
 8 | using namespace std;
 9 | 
10 | void printType()
11 | {
12 |   cout << endl;
13 | }
14 | 
15 | template <class Thead, class... Tbody>
16 | void printType(Thead head, Tbody... body)
17 | {
18 |   cout << '(' << typeid(Thead).name() << ')' << head;
19 |   if (sizeof...(body) > 0) cout << ',';
20 |   printType(body...);
21 | }
22 | 
23 | int main()
24 | {
25 |   printType('T', 4, "two");
26 | }
27 | 
28 | /* 実行結果
29 | Visual C++:
30 |   (char)T, (int)4,(char const*)two
31 | g++:
32 |   (c)T,(i)4,(PKc)two
33 | */
34 | 


--------------------------------------------------------------------------------
/02_basic_template/22_tuple.cpp:
--------------------------------------------------------------------------------
 1 | // Copyright (c) 2014
 2 | // Akira Takahashi, Fumiki Fukuda.
 3 | // Released under the CC0 1.0 Universal license.
 4 | 
 5 | #include <iostream>
 6 | #include <typeinfo>
 7 | 
 8 | using std::cout;
 9 | using std::endl;
10 | 
11 | void printType()
12 | {
13 |   cout << endl;
14 | }
15 | 
16 | template <class Thead, class... Tbody>
17 | void printType(Thead head, Tbody... body)
18 | {
19 |   cout << '(' << typeid(Thead).name() << ')' << head;
20 |   if (sizeof...(body) > 0) cout << ',';
21 |   printType(body...);
22 | }
23 | 
24 | /*
25 |  * tuple<T0, T1, T2...>
26 |  */
27 | template <int N, class... Ts> 
28 | struct tuple_data;
29 | 
30 | // [1]
31 | template <int N> 
32 | struct tuple_data<N> {};
33 | 
34 | // [2]
35 | template <int N, class Thead, class... Tbody>
36 | struct tuple_data<N, Thead, Tbody...> : public tuple_data<N + 1, Tbody...> {
37 |   Thead value;
38 | };
39 | 
40 | // [3]
41 | template <class... Ts> 
42 | struct tuple : public tuple_data<0, Ts...> {};
43 | 
44 | /*
45 |   struct tuple<○, △, □>
46 |     : tuple_data<0, ○, △, □> {}
47 |       : tuple_data<1, △, □>   { ○ value; }
48 |         : tuple_data<2, □>     { △ value; }
49 |           : tuple_data<3>       { □ value; }
50 | */
51 | 
52 | /* 
53 |  * tuple<...> の N番目要素の参照 : get<N>() 
54 |  */
55 | template <int N, class Thead, class... Tbody>
56 | Thead& get_tuple_data(tuple_data<N, Thead, Tbody...>& t)
57 | {
58 |   return t.value;
59 | }
60 | 
61 | template <int N, class... Ts>
62 | auto get(tuple<Ts...>& t) -> decltype(get_tuple_data<N>(t))
63 | {
64 |   return get_tuple_data<N>(t);
65 | }
66 | 
67 | int main()
68 | {
69 |   tuple<char, int, const char*> t;
70 |   get<0>(t) = 'T';
71 |   get<1>(t) = 4;
72 |   get<2>(t) = "two";
73 |   printType(get<0>(t), get<1>(t), get<2>(t));
74 | }
75 | 


--------------------------------------------------------------------------------
/02_basic_template/23_initialize.cpp:
--------------------------------------------------------------------------------
 1 | // Copyright (c) 2014
 2 | // Akira Takahashi, Fumiki Fukuda.
 3 | // Released under the CC0 1.0 Universal license.
 4 | 
 5 | #include <iostream>
 6 | #include <vector>
 7 | 
 8 | template <int... List>
 9 | std::vector<int> initializer()
10 | {
11 |   std::vector<int> v = { List... };
12 |   return v;
13 | }
14 | 
15 | int main()
16 | {
17 |   std::vector<int> v = initializer<1, 2, 3>();
18 | 
19 |   for (int x : v) {
20 |     std::cout << x << std::endl;
21 |   }
22 | }
23 | 


--------------------------------------------------------------------------------
/03_generic_programming/01_find.cpp:
--------------------------------------------------------------------------------
 1 | // Copyright (c) 2014
 2 | // Akira Takahashi, Fumiki Fukuda.
 3 | // Released under the CC0 1.0 Universal license.
 4 | 
 5 | #include <iostream>
 6 | #include <vector>
 7 | #include <list>
 8 | #include <iterator>
 9 | 
10 | template <class Iterator, class T>
11 | Iterator find(Iterator first, Iterator last, const T& value)
12 | {
13 |   while (first != last) {
14 |     if (*first == value)
15 |       break; // 見つかった！
16 | 
17 |       ++first;
18 |   }
19 |   return first;
20 | }
21 | 
22 | using namespace std;
23 | int main()
24 | {
25 |   char arr[] = "hello";
26 |   vector<int> v = {1, 2, 3};
27 |   list<long> ls = {1L, 2L, 3L};
28 | 
29 |   char* p = ::find(begin(arr), end(arr), 'e');
30 |   if (p != end(arr)) { /* 見つかった */ }
31 | 
32 |   decltype(v)::iterator itv = ::find(begin(v), end(v), 3);
33 |   if (itv != end(v)) { /* 見つかった */ }
34 | 
35 |   decltype(ls)::iterator itls = ::find(begin(ls), end(ls), 3);
36 |   if (itls != end(ls)) { /* 見つかった */ }
37 | }
38 | 


--------------------------------------------------------------------------------
/03_generic_programming/02_copy_01.cpp:
--------------------------------------------------------------------------------
 1 | // Copyright (c) 2014
 2 | // Akira Takahashi, Fumiki Fukuda.
 3 | // Released under the CC0 1.0 Universal license.
 4 | 
 5 | #include <iostream>
 6 | #include <vector>
 7 | #include <iterator>
 8 | 
 9 | template <class InputIterator, class OutputIterator>
10 | OutputIterator
11 | copy(InputIterator first, InputIterator last, OutputIterator out)
12 | {
13 |   while (first != last) {
14 |     *out = *first;
15 |     ++out;
16 |     ++first;
17 |   }
18 |   return out;
19 | }
20 | 
21 | using namespace std;
22 | 
23 | int main()
24 | {
25 |   vector<int> v = {1, 2, 3};
26 | 
27 |   vector<int> result;
28 |   ::copy(begin(v), end(v), back_inserter(result));
29 | 
30 |   for (int x : result) {
31 |     cout << x << endl;
32 |   }
33 | }
34 | 


--------------------------------------------------------------------------------
/03_generic_programming/02_copy_02.cpp:
--------------------------------------------------------------------------------
 1 | // Copyright (c) 2014
 2 | // Akira Takahashi, Fumiki Fukuda.
 3 | // Released under the CC0 1.0 Universal license.
 4 | 
 5 | #include <iostream>
 6 | #include <vector>
 7 | #include <iterator>
 8 | 
 9 | template <class InputIterator, class OutputIterator>
10 | OutputIterator
11 | copy(InputIterator first, InputIterator last, OutputIterator out)
12 | {
13 |   while (first != last) {
14 |     *out = *first;
15 |     ++out;
16 |     ++first;
17 |   }
18 |   return out;
19 | }
20 | 
21 | using namespace std;
22 | 
23 | int main()
24 | {
25 |   vector<int> v = {1, 2, 3};
26 | 
27 |   vector<int> result(v.size()); // 十分な領域を用意しておく
28 |   ::copy(begin(v), end(v), begin(result));
29 | 
30 |   for (int x : result) {
31 |     cout << x << endl;
32 |   }
33 | }
34 | 


--------------------------------------------------------------------------------
/03_generic_programming/03_find_if_01.cpp:
--------------------------------------------------------------------------------
 1 | // Copyright (c) 2014
 2 | // Akira Takahashi, Fumiki Fukuda.
 3 | // Released under the CC0 1.0 Universal license.
 4 | 
 5 | #include <iostream>
 6 | #include <vector>
 7 | #include <iterator>
 8 | 
 9 | template <class Iterator, class Predicate>
10 | Iterator find_if(Iterator first, Iterator last, Predicate pred)
11 | {
12 |   while (first != last) {
13 |     if (pred(*first))
14 |       break; // 見つかった!
15 | 
16 |     ++first;
17 |   }
18 |   return first;
19 | }
20 | 
21 | // 値が偶数か判定する関数オブジェクト
22 | struct is_even {
23 |   bool operator()(int x) const
24 |   { return x % 2 == 0; }
25 | };
26 | 
27 | using namespace std;
28 | 
29 | int main()
30 | {
31 |   vector<int> v = {1, 2, 3};
32 | 
33 |   decltype(v)::iterator it = ::find_if(begin(v), end(v), is_even());
34 |   if (it != end(v)) { // 見つかった
35 |     cout << *it << endl;
36 |   }
37 | }
38 | 


--------------------------------------------------------------------------------
/03_generic_programming/03_find_if_02.cpp:
--------------------------------------------------------------------------------
 1 | // Copyright (c) 2014
 2 | // Akira Takahashi, Fumiki Fukuda.
 3 | // Released under the CC0 1.0 Universal license.
 4 | 
 5 | #include <iostream>
 6 | #include <vector>
 7 | #include <iterator>
 8 | 
 9 | template <class Iterator, class Predicate>
10 | Iterator find_if(Iterator first, Iterator last, Predicate pred)
11 | {
12 |   while (first != last) {
13 |     if (pred(*first))
14 |       break; // 見つかった!
15 | 
16 |     ++first;
17 |   }
18 |   return first;
19 | }
20 | 
21 | using namespace std;
22 | 
23 | int main()
24 | {
25 |   vector<int> v = {1, 2, 3};
26 | 
27 |   decltype(v)::iterator it = ::find_if(begin(v), end(v), [](int x){
28 |                                return x % 2 == 0;
29 |                              });
30 |   if (it != end(v)) { // 見つかった
31 |     cout << *it << endl;
32 |   }
33 | }
34 | 


--------------------------------------------------------------------------------
/03_generic_programming/04_selection_sort.cpp:
--------------------------------------------------------------------------------
 1 | // Copyright (c) 2014
 2 | // Akira Takahashi, Fumiki Fukuda.
 3 | // Released under the CC0 1.0 Universal license.
 4 | 
 5 | template <class Iterator>
 6 | void selection_sort(Iterator first, Iterator last)
 7 | {
 8 |   for (Iterator p = first; p != last; ++p) {
 9 |     Iterator min_position = p;
10 |     for (Iterator q = p; q != last; ++q) {
11 |       if (*min_position > *q) {
12 |         min_position = q;
13 |       }
14 |     }
15 |     auto tmp = *min_position;
16 |     *min_position = *p;
17 |     *p = tmp;
18 |   }
19 | }
20 | 
21 | template <class Iterator, class Compare>
22 | void selection_sort(Iterator first, Iterator last, Compare comp)
23 | {
24 |   for (Iterator p = first; p != last; ++p) {
25 |     Iterator min_position = p;
26 |     for (Iterator q = p; q != last; ++q) {
27 |       if (comp(*q, *min_position)) {
28 |         min_position = q;
29 |       }
30 |     }
31 |     auto tmp = *min_position;
32 |     *min_position = *p;
33 |     *p = tmp;
34 |   }
35 | }
36 | 
37 | #include <iostream>
38 | #include <functional>
39 | #include <iterator>
40 | 
41 | int main()
42 | {
43 |   int data[] = { 9, 7, 5, 3, 1, 8, 6, 4, 2, 0 };
44 | 
45 |   selection_sort(std::begin(data), std::end(data), std::greater<int>());
46 |   for (int x : data) {
47 |     std::cout << x << ' ';
48 |   }
49 |   std::cout << std::endl;
50 | }
51 | 


--------------------------------------------------------------------------------
/03_generic_programming/05_print_all.cpp:
--------------------------------------------------------------------------------
 1 | // Copyright (c) 2014
 2 | // Akira Takahashi, Fumiki Fukuda.
 3 | // Released under the CC0 1.0 Universal license.
 4 | 
 5 | #include <iostream>
 6 | #include <vector>
 7 | #include <iterator>
 8 | #include <utility>
 9 | 
10 | template <class Iterator>
11 | void print_all(std::pair<Iterator, Iterator> iter_pair)
12 | {
13 |   while (iter_pair.first != iter_pair.second) {
14 |     std::cout << *iter_pair.first << ' ';
15 |     ++iter_pair.first;
16 |   }
17 |   std::cout << std::endl;
18 | }
19 | 
20 | int main()
21 | {
22 |   int ar[] = { 1, 2, 4, 8, 16 };
23 |   std::vector<int> v(std::begin(ar), std::end(ar));
24 | 
25 |   print_all(std::make_pair(std::begin(ar), std::end(ar)));
26 |   print_all(std::make_pair(std::begin(v), std::end(v)));
27 | }
28 | 


--------------------------------------------------------------------------------
/03_generic_programming/06_back_inserter.cpp:
--------------------------------------------------------------------------------
 1 | // Copyright (c) 2014
 2 | // Akira Takahashi, Fumiki Fukuda.
 3 | // Released under the CC0 1.0 Universal license.
 4 | 
 5 | #include <vector>
 6 | #include <algorithm>
 7 | #include <iterator>
 8 | 
 9 | int main()
10 | {
11 |   int data[] = { 1, 2, 3 };
12 |   std::vector<int> v;
13 | 
14 |   std::copy(std::begin(data), std::end(data), std::back_inserter(v));
15 | }
16 | 


--------------------------------------------------------------------------------
/03_generic_programming/07_advance.cpp:
--------------------------------------------------------------------------------
 1 | // Copyright (c) 2014
 2 | // Akira Takahashi, Fumiki Fukuda.
 3 | // Released under the CC0 1.0 Universal license.
 4 | 
 5 | #include <vector>
 6 | #include <list>
 7 | #include <algorithm>
 8 | #include <iterator>
 9 | 
10 | using namespace std;
11 | 
12 | // InputIterator版: “ひとつ進む”を繰り返す(あと戻り不可)
13 | template <class InputIterator, class Distance>
14 | void _advance(InputIterator& iter, Distance offset,
15 |               input_iterator_tag)
16 | {
17 |   for (; 0 < offset; --offset)
18 |     ++iter;
19 | }
20 | 
21 | // ForwardIterator版: “ひとつ進む”を繰り返す(あと戻り不可)
22 | template <class ForwardIterator, class Distance>
23 | void _advance(ForwardIterator& iter, Distance offset,
24 |               forward_iterator_tag)
25 | {
26 |   for (; 0 < offset; --offset)
27 |     ++iter;
28 | }
29 | 
30 | // BidirectionalIterator版: “ひとつ進む/ 戻る”を繰り返す
31 | template <class BidirectionalIterator, class Distance>
32 | void _advance(BidirectionalIterator& iter, Distance offset,
33 |               bidirectional_iterator_tag)
34 | {
35 |   if (offset > 0){
36 |     // offsetが正のとき、“ひとつ進む”を繰り返す
37 |     for (; 0 < offset; --offset)
38 |     ++iter;
39 |   }
40 |   else {
41 |     // offsetが負のとき、“ひとつ戻る”を繰り返す
42 |     for (; offset < 0; ++offset)
43 |       --iter;
44 |   }
45 | }
46 | 
47 | // RandomAccessIterator版: operator+=で一気にジャンプ
48 | template <class RandomAccessIterator, class Distance>
49 | void _advance(RandomAccessIterator& iter, Distance offset,
50 |               random_access_iterator_tag)
51 | {
52 |   iter += offset;
53 | }
54 | 
55 | template <class Iterator, class Distance>
56 | void advance(Iterator& iter, Distance offset)
57 | {
58 |   _advance(iter, offset,
59 |     typename iterator_traits<Iterator>::iterator_category());
60 | }
61 | 
62 | int main()
63 | {
64 |   vector<int> vec = {1, 2, 3};
65 |   list<int>   lst = {1, 2, 3};
66 | 
67 |   decltype(vec)::iterator vi = begin(vec);
68 |   ::advance(vi, 2); // viを2進める
69 | 
70 |   decltype(lst)::iterator li = begin(lst);
71 |   ::advance(li, 3); // liを3進める
72 | }
73 | 


--------------------------------------------------------------------------------
/03_generic_programming/08_decoration_01.cpp:
--------------------------------------------------------------------------------
 1 | // Copyright (c) 2014
 2 | // Akira Takahashi, Fumiki Fukuda.
 3 | // Released under the CC0 1.0 Universal license.
 4 | 
 5 | #include <string>
 6 | #include <cassert>
 7 | 
 8 | using namespace std;
 9 | 
10 | class Plain {
11 | public:
12 |   string convert(const string& str) const
13 |     { return str; }
14 | };
15 | 
16 | template <class Base>
17 | class Bold : public Base {
18 | public:
19 |   string convert(const string& str) const
20 |     { return "<b>" + Base::convert(str) + "</b>"; }
21 | };
22 | 
23 | template <class Base>
24 | class Italic: public Base {
25 | public:
26 |   string convert(const string& str) const
27 |     { return "<i>" + Base::convert(str) + "</i>"; }
28 | };
29 | 
30 | int main()
31 | {
32 |   Bold<Plain> b;
33 |   string s1 = b.convert("Hello"); // <b>Hello</b>
34 |   
35 |   Italic<Plain> i;
36 |   string s2 = i.convert("Hello"); // <i>Hello</i>
37 |   
38 |   Italic<Bold<Plain>> ib;
39 |   string s3 = ib.convert("Hello"); // <i><b>Hello</b></i>
40 | 
41 |   assert(s1 == "<b>Hello</b>");
42 |   assert(s2 == "<i>Hello</i>");
43 |   assert(s3 == "<i><b>Hello</b></i>");
44 | }
45 | 


--------------------------------------------------------------------------------
/03_generic_programming/08_decoration_02.cpp:
--------------------------------------------------------------------------------
 1 | // Copyright (c) 2014
 2 | // Akira Takahashi, Fumiki Fukuda.
 3 | // Released under the CC0 1.0 Universal license.
 4 | 
 5 | #include <iostream>
 6 | #include <sstream>
 7 | #include <string>
 8 | 
 9 | using namespace std;
10 | 
11 | class Plain {
12 | public:
13 |   virtual string convert(const string& str) const
14 |     { return str; }
15 | };
16 | 
17 | template <class Base = Plain>
18 | class Bold : public Base {
19 | public:
20 |   using Base::Base; // コンストラクタを継承する(C++11)
21 | 
22 |   virtual string convert(const string& str) const
23 |     { return "<b>" + Base::convert(str) + "</b>"; }
24 | };
25 | 
26 | template <class Base = Plain>
27 | class Italic: public Base {
28 | public:
29 |   using Base::Base;
30 | 
31 |   virtual string convert(const string& str) const
32 |     { return "<i>" + Base::convert(str) + "</i>"; }
33 | };
34 | 
35 | template <class Base = Plain>
36 | class Size : public Base {
37 |   string size_;
38 | public:
39 |   using Base::Base;
40 | 
41 |   Size(int s) { ostringstream strm; strm << s; size_ = strm.str(); }
42 |   virtual string convert(const string& str) const
43 |     { return "<font size='" + size_ + "'>" +
44 |              Base::convert(str) + "</font>"; }
45 | };
46 | 
47 | int main()
48 | {
49 |   Plain p;
50 |   Bold<> b;
51 |   Italic<> i;
52 |   Size<Bold<Italic<>>> sbi(5); // 多重のパラメータ化継承
53 |   Italic<Size<>> si(3);
54 | 
55 |   Plain* converter[5] = { &p, &b, &i, &sbi, &si };
56 | 
57 |   for (Plain* c : converter) {
58 |     cout << c->convert("Hello, C++") << endl;
59 |   }
60 | }
61 | 


--------------------------------------------------------------------------------
/03_generic_programming/09_print_on.cpp:
--------------------------------------------------------------------------------
 1 | // Copyright (c) 2014
 2 | // Akira Takahashi, Fumiki Fukuda.
 3 | // Released under the CC0 1.0 Universal license.
 4 | 
 5 | #include <iostream>
 6 | #include <sstream>
 7 | #include <string>
 8 | 
 9 | using namespace std;
10 | 
11 | class Plain {
12 | public:
13 |   virtual string convert(const string& str) const
14 |     { return str; }
15 | };
16 | 
17 | template <class Base = Plain>
18 | class Bold : public Base {
19 | public:
20 |   using Base::Base; // コンストラクタを継承する(C++11)
21 | 
22 |   virtual string convert(const string& str) const
23 |     { return "<b>" + Base::convert(str) + "</b>"; }
24 | };
25 | 
26 | template <class Base = Plain>
27 | class Italic: public Base {
28 | public:
29 |   using Base::Base;
30 | 
31 |   virtual string convert(const string& str) const
32 |     { return "<i>" + Base::convert(str) + "</i>"; }
33 | };
34 | 
35 | template <class Base = Plain>
36 | class Size : public Base {
37 |   string size_;
38 | public:
39 |   using Base::Base;
40 | 
41 |   Size(int s) { ostringstream strm; strm << s; size_ = strm.str(); }
42 |   virtual string convert(const string& str) const
43 |     { return "<font size='" + size_ + "'>" +
44 |              Base::convert(str) + "</font>"; }
45 | };
46 | 
47 | int main()
48 | {
49 |   Plain p;
50 |   Bold<> b;
51 |   Italic<> i;
52 |   Size<Bold<Italic<>>> sbi(5); // 多重のパラメータ化継承
53 |   Italic<Size<>> si(3);
54 | 
55 |   Plain* converter[5] = { &p, &b, &i, &sbi, &si };
56 | 
57 |   for (Plain* c : converter) {
58 |     cout << c->convert("Hello, C++") << endl;
59 |   }
60 | }
61 | 


--------------------------------------------------------------------------------
/04_template_meta_programming/01_increment.cpp:
--------------------------------------------------------------------------------
 1 | // Copyright (c) 2014
 2 | // Akira Takahashi, Fumiki Fukuda.
 3 | // Released under the CC0 1.0 Universal license.
 4 | 
 5 | template <int N>
 6 | struct increment {
 7 |   static const int value = N + 1;
 8 | };
 9 | 
10 | int main()
11 | {
12 |   const int result = increment<3>::value;
13 |   static_assert(result == 4, "result is 4");
14 | }
15 | 


--------------------------------------------------------------------------------
/04_template_meta_programming/02_factorial.cpp:
--------------------------------------------------------------------------------
 1 | // Copyright (c) 2014
 2 | // Akira Takahashi, Fumiki Fukuda.
 3 | // Released under the CC0 1.0 Universal license.
 4 | 
 5 | template <int N>
 6 | struct factorial {
 7 |   static const int value = N * factorial<N - 1>::value;
 8 | };
 9 | 
10 | template <>
11 | struct factorial<0> {
12 |   static const int value = 1;
13 | };
14 | 
15 | int main()
16 | {
17 |   const int result = factorial<3>::value;
18 |   static_assert(result == 6, "result is 6");
19 | }
20 | 


--------------------------------------------------------------------------------
/04_template_meta_programming/03_square.cpp:
--------------------------------------------------------------------------------
 1 | // Copyright (c) 2014
 2 | // Akira Takahashi, Fumiki Fukuda.
 3 | // Released under the CC0 1.0 Universal license.
 4 | 
 5 | template <int N>
 6 | struct square {
 7 |   static const int value = N * N;
 8 | };
 9 | 
10 | int main()
11 | {
12 |   const int result = square<3>::value;
13 |   static_assert(result == 9, "result is 9");
14 | }
15 | 


--------------------------------------------------------------------------------
/04_template_meta_programming/04_pow.cpp:
--------------------------------------------------------------------------------
 1 | // Copyright (c) 2014
 2 | // Akira Takahashi, Fumiki Fukuda.
 3 | // Released under the CC0 1.0 Universal license.
 4 | 
 5 | template <int X, int N>
 6 | struct pow {
 7 |   static const int value = X * pow<X, N - 1>::value;
 8 | };
 9 | 
10 | template <int X>
11 | struct pow<X, 0> {
12 |   static const int value = 1;
13 | };
14 | 
15 | int main()
16 | {
17 |   const int result = pow<2, 3>::value;
18 |   static_assert(result == 8, "result is 8");
19 | }
20 | 


--------------------------------------------------------------------------------
/04_template_meta_programming/05_identity.cpp:
--------------------------------------------------------------------------------
 1 | // Copyright (c) 2014
 2 | // Akira Takahashi, Fumiki Fukuda.
 3 | // Released under the CC0 1.0 Universal license.
 4 | 
 5 | template <class T> // パラメータで型Tを受け取って
 6 | struct identity {
 7 |   typedef T type;  // 型Tを返す
 8 | };
 9 | 
10 | int main()
11 | {
12 |   identity<int>::type value;
13 | }
14 | 


--------------------------------------------------------------------------------
/04_template_meta_programming/06_add_pointer.cpp:
--------------------------------------------------------------------------------
 1 | // Copyright (c) 2014
 2 | // Akira Takahashi, Fumiki Fukuda.
 3 | // Released under the CC0 1.0 Universal license.
 4 | 
 5 | template <class T>
 6 | struct add_pointer {
 7 |   typedef T* type;
 8 | };
 9 | 
10 | int main()
11 | {
12 |   int value = 3;
13 |   add_pointer<int>::type p = &value;
14 | }
15 | 


--------------------------------------------------------------------------------
/04_template_meta_programming/07_add_lvalue_reference.cpp:
--------------------------------------------------------------------------------
 1 | // Copyright (c) 2014
 2 | // Akira Takahashi, Fumiki Fukuda.
 3 | // Released under the CC0 1.0 Universal license.
 4 | 
 5 | template <class T>
 6 | struct add_const_lvalue_reference {
 7 |   typedef const T& type;
 8 | };
 9 | 
10 | int main()
11 | {
12 |   int value = 3;
13 |   add_const_lvalue_reference<int>::type cr = value;
14 | }
15 | 


--------------------------------------------------------------------------------
/04_template_meta_programming/08_separate_meta_function.cpp:
--------------------------------------------------------------------------------
 1 | // Copyright (c) 2014
 2 | // Akira Takahashi, Fumiki Fukuda.
 3 | // Released under the CC0 1.0 Universal license.
 4 | 
 5 | template <class T>
 6 | struct add_const {
 7 |   typedef const T type;
 8 | };
 9 | 
10 | template <class T>
11 | struct add_lvalue_reference {
12 |   typedef T& type;
13 | };
14 | 
15 | template <class T>
16 | struct add_lvalue_reference<T&> {
17 |   typedef T& type;
18 | };
19 | 
20 | int main()
21 | {
22 |   int value = 3;
23 |   add_const<int>::type            c = value; // c : const int
24 |   add_lvalue_reference<int>::type r = value; // r : int&
25 | }
26 | 


--------------------------------------------------------------------------------
/04_template_meta_programming/09_combine_meta_function.cpp:
--------------------------------------------------------------------------------
 1 | // Copyright (c) 2014
 2 | // Akira Takahashi, Fumiki Fukuda.
 3 | // Released under the CC0 1.0 Universal license.
 4 | 
 5 | template <class T>
 6 | struct add_const {
 7 |   typedef const T type;
 8 | };
 9 | 
10 | template <class T>
11 | struct add_lvalue_reference {
12 |   typedef T& type;
13 | };
14 | 
15 | template <class T>
16 | struct add_lvalue_reference<T&> {
17 |   typedef T& type;
18 | };
19 | 
20 | template <class T>
21 | struct add_const_lvalue_reference {
22 |   typedef
23 |     typename add_const<
24 |       typename add_lvalue_reference<T>::type
25 |     >::type
26 |   type;
27 | };
28 | 
29 | int main()
30 | {
31 |   int value = 3;
32 |   add_const_lvalue_reference<int>::type cr = value; // cr : const int&
33 | }
34 | 


--------------------------------------------------------------------------------
/04_template_meta_programming/10_remove_const.cpp:
--------------------------------------------------------------------------------
 1 | // Copyright (c) 2014
 2 | // Akira Takahashi, Fumiki Fukuda.
 3 | // Released under the CC0 1.0 Universal license.
 4 | 
 5 | template <class T>
 6 | struct remove_const {
 7 |   typedef T type;
 8 | };
 9 | 
10 | template <class T>
11 | struct remove_const<const T> {
12 |   typedef T type;
13 | };
14 | 
15 | int main()
16 | {
17 |   remove_const<const int>::type value = 3;
18 | }
19 | 


--------------------------------------------------------------------------------
/04_template_meta_programming/11_remove_cv.cpp:
--------------------------------------------------------------------------------
 1 | // Copyright (c) 2014
 2 | // Akira Takahashi, Fumiki Fukuda.
 3 | // Released under the CC0 1.0 Universal license.
 4 | 
 5 | template <class T>
 6 | struct remove_const {
 7 |   typedef T type;
 8 | };
 9 | 
10 | template <class T>
11 | struct remove_const<const T> {
12 |   typedef T type;
13 | };
14 | 
15 | template <class T>
16 | struct remove_volatile {
17 |   typedef T type;
18 | };
19 | 
20 | template <class T>
21 | struct remove_volatile<volatile T> {
22 |   typedef T type;
23 | };
24 | 
25 | template <class T>
26 | struct remove_cv {
27 |   typedef typename remove_volatile<
28 |     typename remove_const<T>::type
29 |   >::type type;
30 | };
31 | 
32 | int main()
33 | {
34 |   remove_cv<const volatile int>::type value = 3;
35 | }
36 | 


--------------------------------------------------------------------------------
/04_template_meta_programming/12_if.cpp:
--------------------------------------------------------------------------------
 1 | // Copyright (c) 2014
 2 | // Akira Takahashi, Fumiki Fukuda.
 3 | // Released under the CC0 1.0 Universal license.
 4 | 
 5 | template <bool Cond, class Then, class Else>
 6 | struct if_;
 7 | 
 8 | template <class Then, class Else>
 9 | struct if_<true, Then, Else> {
10 |   typedef Then type;
11 | };
12 | 
13 | template <class Then, class Else>
14 | struct if_<false, Then, Else> {
15 |   typedef Else type;
16 | };
17 | 
18 | int main()
19 | {
20 |   if_<true, int, long>::type value1;
21 |   if_<false, int, long>::type value2;
22 | }
23 | 


--------------------------------------------------------------------------------
/04_template_meta_programming/13_high_order_if.cpp:
--------------------------------------------------------------------------------
 1 | // Copyright (c) 2014
 2 | // Akira Takahashi, Fumiki Fukuda.
 3 | // Released under the CC0 1.0 Universal license.
 4 | 
 5 | template <bool Cond, class Then, class Else>
 6 | struct if_c;
 7 | 
 8 | template <class Then, class Else>
 9 | struct if_c<true, Then, Else> {
10 |   typedef Then type;
11 | };
12 | 
13 | template <class Then, class Else>
14 | struct if_c<false, Then, Else> {
15 |   typedef Else type;
16 | };
17 | 
18 | template <class Cond, class Then, class Else>
19 | struct if_ : public if_c<Cond::value, Then, Else> {};
20 | 
21 | template <int N>
22 | struct is_even {
23 |   static const bool value = N % 2 == 0;
24 | };
25 | 
26 | int main()
27 | {
28 |   if_<is_even<2>, int, long>::type value;
29 |   // 偶数だったらint, 奇数だったらlong型
30 | }
31 | 


--------------------------------------------------------------------------------
/04_template_meta_programming/14_cpp11_meta_func_00.cpp:
--------------------------------------------------------------------------------
 1 | // Copyright (c) 2014
 2 | // Akira Takahashi, Fumiki Fukuda.
 3 | // Released under the CC0 1.0 Universal license.
 4 | 
 5 | #include <type_traits>
 6 | #include <utility>
 7 | 
 8 | template <class T>
 9 | T* add_pointer(T);
10 | 
11 | int main()
12 | {
13 |     typedef decltype(add_pointer(std::declval<int>())) result;
14 |     static_assert(std::is_same<result, int*>::value, "");
15 | }
16 | 
17 | 


--------------------------------------------------------------------------------
/04_template_meta_programming/15_cpp11_meta_func_01.cpp:
--------------------------------------------------------------------------------
 1 | // Copyright (c) 2014
 2 | // Akira Takahashi, Fumiki Fukuda.
 3 | // Released under the CC0 1.0 Universal license.
 4 | 
 5 | #include <type_traits>
 6 | 
 7 | /* メタ関数適用
 8 | template <class T>
 9 | T* add_pointer();
10 | 
11 | int main()
12 | {
13 |     typedef decltype(add_pointer<int>()) result;
14 |     static_assert(std::is_same<result, int*>::value, "");
15 | }
16 | */
17 | 
18 | // 再帰テンプレート
19 | template <class T, int N>
20 | struct add_pointer_t {
21 |     typedef typename add_pointer_t<T*, N - 1>::type type;
22 | };
23 | 
24 | template <class T>
25 | struct add_pointer_t<T, 0> {
26 |     typedef T type;
27 | };
28 | 
29 | template <class T, int N>
30 | typename add_pointer_t<T, N>::type add_pointer();
31 | 
32 | int main()
33 | {
34 |     typedef decltype(add_pointer<int, 3>()) result;
35 |     static_assert(std::is_same<result, int***>::value, "");
36 | }
37 | 


--------------------------------------------------------------------------------
/04_template_meta_programming/16_cpp11_meta_func_02.cpp:
--------------------------------------------------------------------------------
 1 | // Copyright (c) 2014
 2 | // Akira Takahashi, Fumiki Fukuda.
 3 | // Released under the CC0 1.0 Universal license.
 4 | 
 5 | #include <type_traits>
 6 | #include <utility>
 7 | 
 8 | template <int N>
 9 | struct int_ {};
10 | 
11 | template <bool B>
12 | struct bool_ {};
13 | 
14 | struct cont {};
15 | struct end {};
16 | 
17 | template <bool Cond>
18 | auto is_end(bool_<Cond>)
19 |   -> typename std::conditional<Cond, end, cont>::type;
20 | 
21 | // 再帰テンプレート
22 | template <class T, int N>
23 | auto add_pointers_impl(T, int_<N>, cont)
24 |   -> decltype(add_pointers_impl(
25 |                 std::declval<T*>(),
26 |                 int_<N-1>(),
27 |                 std::declval<decltype(
28 |                   is_end(bool_<N - 1 == 0>())
29 |                 )>()
30 |               ));
31 | 
32 | template <class T, int N>
33 | auto add_pointers_impl(T, int_<N>, end)
34 |   -> T;
35 | 
36 | template <class T, int N>
37 | auto add_pointers(T, int_<N>)
38 |   -> decltype(add_pointers_impl(
39 |                 std::declval<T>(),
40 |                 int_<N>(),
41 |                 std::declval<decltype(
42 |                   is_end(bool_<N == 0>())
43 |                 )>()));
44 | 
45 | int main()
46 | {
47 |     typedef decltype(
48 |       add_pointers(std::declval<int>(), int_<3>())
49 |     ) result;
50 |     static_assert(std::is_same<result, int***>::value, "");
51 | }
52 | 
53 | 


--------------------------------------------------------------------------------
/04_template_meta_programming/17_cpp11_meta_func_03.cpp:
--------------------------------------------------------------------------------
 1 | // Copyright (c) 2014
 2 | // Akira Takahashi, Fumiki Fukuda.
 3 | // Released under the CC0 1.0 Universal license.
 4 | 
 5 | #include <type_traits>
 6 | #include <utility>
 7 | 
 8 | template <int N>
 9 | struct int_ {};
10 | 
11 | // 再帰テンプレート
12 | template <class T, int N,
13 |   typename std::enable_if<(N > 0)>::type* = nullptr>
14 | auto add_pointer(T, int_<N>) -> decltype(add_pointer(std::declval<T*>(), int_<N-1>()));
15 | 
16 | template <class T, int N,
17 |   typename std::enable_if<N == 0>::type* = nullptr>
18 | auto add_pointer(T, int_<N>) -> T;
19 | 
20 | int main()
21 | {
22 |   typedef decltype(
23 |     add_pointer(std::declval<int>(), int_<3>())
24 |   ) result;
25 |   static_assert(std::is_same<result, int***>::value, "");
26 | }
27 | 


--------------------------------------------------------------------------------
/04_template_meta_programming/18_type_list_00_head_tail.cpp:
--------------------------------------------------------------------------------
 1 | // Copyright (c) 2014
 2 | // Akira Takahashi, Fumiki Fukuda.
 3 | // Released under the CC0 1.0 Universal license.
 4 | 
 5 | #include <tuple>
 6 | #include <type_traits>
 7 | 
 8 | template <class Head, class... Tail>
 9 | struct g {
10 |   typedef Head head;
11 |   typedef std::tuple<Tail...> tail;
12 | };
13 | 
14 | template <class... List>
15 | struct f {
16 |   typedef typename g<List...>::head head;
17 |   typedef typename g<List...>::tail tail;
18 | };
19 | 
20 | typedef f<int, char, double> list;
21 | 
22 | static_assert(std::is_same<
23 |   list::head,
24 |   int
25 | >::value, "head must be int");
26 | 
27 | static_assert(std::is_same<
28 |   list::tail,
29 |   std::tuple<char, double>
30 | >::value, "tail must be tuple<char, double>");
31 | 
32 | int main() {}
33 | 
34 | 


--------------------------------------------------------------------------------
/04_template_meta_programming/19_type_list_01_any_of.cpp:
--------------------------------------------------------------------------------
 1 | // Copyright (c) 2014
 2 | // Akira Takahashi, Fumiki Fukuda.
 3 | // Released under the CC0 1.0 Universal license.
 4 | 
 5 | #include <iostream>
 6 | 
 7 | template <template <class> class Pred,
 8 |           class Head, class... Tail>
 9 | struct any_of {
10 |   static const bool value = Pred<Head>::value ?
11 |                             true :
12 |                             any_of<Pred, Tail...>::value;
13 | };
14 | 
15 | template <template <class> class Pred,
16 |           class Head>
17 | struct any_of<Pred, Head> {
18 |   static const bool value = Pred<Head>::value;
19 | };
20 | 
21 | 
22 | template <class T>
23 | struct is_int {
24 |   static const bool value = false;
25 | };
26 | 
27 | template <>
28 | struct is_int<int> {
29 |   static const bool value = true;
30 | };
31 | 
32 | int main()
33 | {
34 |   {
35 |     const bool result = any_of<is_int, char, double, int>::value;
36 |     static_assert(result, "include int");
37 |   }
38 |   {
39 |     const bool result = any_of<is_int, char, double, void>::value;
40 |     static_assert(!result, "not include int");
41 |   }
42 | }
43 | 


--------------------------------------------------------------------------------
/04_template_meta_programming/20_type_list_02_any_of_improve.cpp:
--------------------------------------------------------------------------------
 1 | // Copyright (c) 2014
 2 | // Akira Takahashi, Fumiki Fukuda.
 3 | // Released under the CC0 1.0 Universal license.
 4 | 
 5 | #include <iostream>
 6 | #include <tuple>
 7 | 
 8 | template <template <class> class Pred, class List>
 9 | struct any_of_impl;
10 | 
11 | template <template <class> class Pred,
12 |           class Head, class... Tail>
13 | struct any_of_impl<Pred, std::tuple<Head, Tail...>> {
14 |   static const bool value = Pred<Head>::value ?
15 |                             true :
16 |                             any_of_impl<
17 |                               Pred,
18 |                               std::tuple<Tail...>
19 |                             >::value;
20 | };
21 | 
22 | template <template <class> class Pred>
23 | struct any_of_impl<Pred, std::tuple<>> {
24 |   static const bool value = false;
25 | };
26 | 
27 | template <template <class> class Pred,
28 |           class... List>
29 | struct any_of {
30 |   static const bool value =
31 |       any_of_impl<Pred, std::tuple<List...>>::value;
32 | };
33 | 
34 | 
35 | template <class T>
36 | struct is_int {
37 |   static const bool value = false;
38 | };
39 | 
40 | template <>
41 | struct is_int<int> {
42 |   static const bool value = true;
43 | };
44 | 
45 | int main()
46 | {
47 |   {
48 |     const bool result = any_of<is_int, char, double, int>::value;
49 |     static_assert(result, "include int");
50 |   }
51 |   {
52 |     const bool result = any_of<is_int, char, double, void>::value;
53 |     static_assert(!result, "not include int");
54 |   }
55 |   {
56 |     const bool result = any_of<is_int>::value;
57 |     static_assert(!result, "not include int");
58 |   }
59 | }
60 | 


--------------------------------------------------------------------------------
/04_template_meta_programming/21_type_list_03_transform.cpp:
--------------------------------------------------------------------------------
 1 | // Copyright (c) 2014
 2 | // Akira Takahashi, Fumiki Fukuda.
 3 | // Released under the CC0 1.0 Universal license.
 4 | 
 5 | #include <tuple>
 6 | #include <type_traits>
 7 | 
 8 | template <class T>
 9 | struct add_reference {
10 |   typedef T& type;
11 | };
12 | 
13 | template <class T>
14 | struct add_reference<T&> {
15 |   typedef T& type;
16 | };
17 | 
18 | template <template <class> class F, class... List>
19 | struct transform {
20 |   typedef std::tuple<typename F<List>::type...> type;
21 | };
22 | 
23 | int main()
24 | {
25 |   typedef transform<
26 |     add_reference,
27 |     int, char, double
28 |   >::type result;
29 | 
30 |   static_assert(std::is_same<
31 |     result,
32 |     std::tuple<int&, char&, double&>
33 |   >::value, "result's all type must be reference");
34 | }
35 | 


--------------------------------------------------------------------------------
/05_sfinae/01_introduction_sfinae.cpp:
--------------------------------------------------------------------------------
 1 | // Copyright (c) 2014
 2 | // Akira Takahashi, Fumiki Fukuda.
 3 | // Released under the CC0 1.0 Universal license.
 4 | 
 5 | #include <iostream>
 6 | using namespace std;
 7 | struct widget {
 8 |   typedef int value_type;
 9 | };
10 | 
11 | template <class T>
12 | void something(typename T::value_type*)
13 | {
14 |   cout << "value_typeを持っている" << endl;
15 | }
16 | 
17 | template <class T>
18 | void something(...)
19 | {
20 |   cout << "それ以外" << endl;
21 | }
22 | 
23 | int main()
24 | {
25 |   something<widget>(0);
26 |   something<int>(0);
27 | }
28 | 
29 | /*
30 | 出力：
31 | value_typeを持っている
32 | それ以外
33 | */
34 | 


--------------------------------------------------------------------------------
/05_sfinae/02_is_void.cpp:
--------------------------------------------------------------------------------
 1 | // Copyright (c) 2014
 2 | // Akira Takahashi, Fumiki Fukuda.
 3 | // Released under the CC0 1.0 Universal license.
 4 | 
 5 | template <class T>
 6 | struct is_void {
 7 |   static const bool value = false;
 8 | };
 9 | 
10 | template <>
11 | struct is_void<void> {
12 |   static const bool value = true;
13 | };
14 | 
15 | #include <iostream>
16 | using namespace std;
17 | 
18 | int main()
19 | {
20 |   cout << boolalpha;
21 |   cout << ::is_void<void>::value  << endl;
22 |   cout << ::is_void<int>::value   << endl;
23 |   cout << ::is_void<char*>::value << endl;
24 | }
25 | 
26 | /*
27 | 出力：
28 | true
29 | false
30 | false
31 | */
32 | 


--------------------------------------------------------------------------------
/05_sfinae/03_is_pointer.cpp:
--------------------------------------------------------------------------------
 1 | // Copyright (c) 2014
 2 | // Akira Takahashi, Fumiki Fukuda.
 3 | // Released under the CC0 1.0 Universal license.
 4 | 
 5 | template <class T>
 6 | struct is_pointer {
 7 |   static const bool value = false;
 8 | };
 9 | 
10 | template <class T>
11 | struct is_pointer<T*> {
12 |   static const bool value = true;
13 | };
14 | 
15 | #include <iostream>
16 | using namespace std;
17 | 
18 | int main()
19 | {
20 |   cout << ::is_pointer<int>::value  << endl;
21 |   cout << ::is_pointer<int*>::value << endl;
22 | }
23 | 
24 | /*
25 | 出力：
26 | 0
27 | 1
28 | */
29 | 
30 | 


--------------------------------------------------------------------------------
/05_sfinae/04_has_iterator_function.cpp:
--------------------------------------------------------------------------------
 1 | // Copyright (c) 2014
 2 | // Akira Takahashi, Fumiki Fukuda.
 3 | // Released under the CC0 1.0 Universal license.
 4 | 
 5 | template <class T>
 6 | constexpr bool has_iterator_impl(typename T::iterator*)
 7 | {
 8 |   return true;
 9 | }
10 | 
11 | template <class T>
12 | constexpr bool has_iterator_impl(...)
13 | {
14 |   return false;
15 | }
16 | 
17 | template <class T>
18 | constexpr bool has_iterator()
19 | {
20 |   return has_iterator_impl<T>(nullptr);
21 | }
22 | 
23 | #include <vector>
24 | int main()
25 | {
26 |   static_assert(
27 |     has_iterator<std::vector<int>>(),
28 |     "vectorはiterator型を持っている");
29 | 
30 |   static_assert(
31 |     !has_iterator<int>(),
32 |     "intはiterator型を持っていない");
33 | }
34 | 


--------------------------------------------------------------------------------
/05_sfinae/05_has_iterator_metafunction.cpp:
--------------------------------------------------------------------------------
 1 | // Copyright (c) 2014
 2 | // Akira Takahashi, Fumiki Fukuda.
 3 | // Released under the CC0 1.0 Universal license.
 4 | 
 5 | template <class T>
 6 | class has_iterator {
 7 |   template <class U>
 8 |   static constexpr bool check(typename U::iterator*)
 9 |   { return true; }
10 | 
11 |   template <class U>
12 |   static constexpr bool check(...)
13 |   { return false; }
14 | public:
15 |   static const bool value = check<T>(nullptr);
16 | };
17 | 
18 | #include <vector>
19 | int main()
20 | {
21 |   static_assert(
22 |     has_iterator<std::vector<int>>::value,
23 |     "vectorはiterator型を持っている");
24 | 
25 |   static_assert(
26 |     !has_iterator<int>::value,
27 |     "intはiterator型を持っていない");
28 | }
29 | 


--------------------------------------------------------------------------------
/05_sfinae/06_has_iterator_03_metafunction.cpp:
--------------------------------------------------------------------------------
 1 | // Copyright (c) 2014
 2 | // Akira Takahashi, Fumiki Fukuda.
 3 | // Released under the CC0 1.0 Universal license.
 4 | 
 5 | template <class T>
 6 | class has_iterator {
 7 |   typedef char yes;
 8 |   typedef struct { char a[2]; } no;
 9 | 
10 |   template <class U>
11 |   static yes check(typename U::iterator*);
12 | 
13 |   template <class U>
14 |   static no check(...);
15 | 
16 | public:
17 |   static const bool value = sizeof(check<T>(0)) == sizeof(yes);
18 | };
19 | 
20 | #include <vector>
21 | int main()
22 | {
23 |   static_assert(
24 |     has_iterator<std::vector<int>>::value,
25 |     "vectorはiterator型を持っている");
26 | 
27 |   static_assert(
28 |     !has_iterator<int>::value,
29 |     "intはiterator型を持っていない");
30 | }
31 | 


--------------------------------------------------------------------------------
/05_sfinae/07_has_iterator_decltype.cpp:
--------------------------------------------------------------------------------
 1 | // Copyright (c) 2014
 2 | // Akira Takahashi, Fumiki Fukuda.
 3 | // Released under the CC0 1.0 Universal license.
 4 | 
 5 | #include <type_traits>
 6 | 
 7 | struct has_iterator_impl {
 8 |   template <class T>
 9 |   static std::true_type check(typename T::iterator*);
10 | 
11 |   template <class T>
12 |   static std::false_type check(...);
13 | };
14 | 
15 | template <class T>
16 | class has_iterator :
17 |   public decltype(has_iterator_impl::check<T>(nullptr)) {};
18 | 
19 | #include <vector>
20 | int main()
21 | {
22 |   static_assert(
23 |     has_iterator<std::vector<int>>::value,
24 |     "vectorはiterator型を持っている");
25 | 
26 |   static_assert(
27 |     !has_iterator<int>::value,
28 |     "intはiterator型を持っていない");
29 | }
30 | 


--------------------------------------------------------------------------------
/05_sfinae/08_is_class.cpp:
--------------------------------------------------------------------------------
 1 | // Copyright (c) 2014
 2 | // Akira Takahashi, Fumiki Fukuda.
 3 | // Released under the CC0 1.0 Universal license.
 4 | 
 5 | #include <type_traits>
 6 | 
 7 | struct is_class_impl {
 8 |   template <class T>
 9 |   static std::true_type check(int T::*);
10 | 
11 |   template <class T>
12 |   static std::false_type check(...);
13 | };
14 | 
15 | template <class T>
16 | struct is_class :
17 |   public decltype(is_class_impl::check<T>(nullptr)) {};
18 | 
19 | struct X {};
20 | union Y {};
21 | 
22 | int main()
23 | {
24 |   static_assert(
25 |     is_class<X>::value,
26 |     "Xはクラス");
27 | 
28 |   static_assert(
29 |     is_class<Y>::value,
30 |     "Yはクラス");
31 | 
32 |   static_assert(
33 |     !is_class<int>::value,
34 |     "intはクラスではない");
35 | }
36 | 


--------------------------------------------------------------------------------
/05_sfinae/09_is_assignable.cpp:
--------------------------------------------------------------------------------
 1 | // Copyright (c) 2014
 2 | // Akira Takahashi, Fumiki Fukuda.
 3 | // Released under the CC0 1.0 Universal license.
 4 | 
 5 | #include <type_traits>
 6 | #include <utility>
 7 | 
 8 | struct is_assignable_impl {
 9 |   template <class T>
10 |   static auto check(T*) -> decltype(
11 |     std::declval<T&>() = std::declval<const T&>(),
12 |     std::true_type());
13 | 
14 |   template <class T>
15 |   static auto check(...) -> std::false_type;
16 | };
17 | 
18 | template <class T>
19 | struct is_assignable
20 |   : decltype(is_assignable_impl::check<T>(nullptr)) {};
21 | 
22 | struct A {
23 |   A& operator=(const A&) = delete;
24 | };
25 | 
26 | struct B {};
27 | 
28 | int main()
29 | {
30 |   static_assert(!is_assignable<A>::value, "Aは代入不可");
31 |   static_assert( is_assignable<B>::value, "Bは代入可能");
32 | }
33 | 
34 | 


--------------------------------------------------------------------------------
/05_sfinae/10_is_addable.cpp:
--------------------------------------------------------------------------------
 1 | // Copyright (c) 2014
 2 | // Akira Takahashi, Fumiki Fukuda.
 3 | // Released under the CC0 1.0 Universal license.
 4 | 
 5 | #include <iostream>
 6 | #include <utility>
 7 | 
 8 | struct is_addable_impl {
 9 |   template <class T, class U>
10 |   static auto check(T*, U*) -> decltype(
11 |     std::declval<T>() + std::declval<U>(),
12 |     std::true_type());
13 | 
14 |   template <class T, class U>
15 |   static auto check(...) -> std::false_type;
16 | };
17 | 
18 | template <class T, class U>
19 | struct is_addable
20 |   : decltype(is_addable_impl::check<T, U>(
21 |                nullptr, nullptr)) {};
22 | 
23 | struct A {};
24 | 
25 | struct B {};
26 | B operator+(const B&, const B&) { return B(); }
27 | 
28 | int main()
29 | {
30 |   static_assert(!is_addable<A, A>::value, "A must be not addable");
31 |   static_assert( is_addable<B, B>::value, "B must be addable");
32 |   static_assert( is_addable<int, double>::value, "int/double must be addable");
33 | 
34 |   std::cout << std::boolalpha;
35 |   std::cout << is_addable<A, A>::value << std::endl;
36 |   std::cout << is_addable<B, B>::value << std::endl;
37 |   std::cout << is_addable<int, double>::value << std::endl;
38 | }
39 | 
40 | 


--------------------------------------------------------------------------------
/05_sfinae/11_enable_if.cpp:
--------------------------------------------------------------------------------
 1 | // Copyright (c) 2014
 2 | // Akira Takahashi, Fumiki Fukuda.
 3 | // Released under the CC0 1.0 Universal license.
 4 | 
 5 | #include <type_traits>
 6 | 
 7 | struct is_class_impl {
 8 |   template <class T>
 9 |   static std::true_type check(int T::*);
10 | 
11 |   template <class T>
12 |   static std::false_type check(...);
13 | };
14 | 
15 | template <class T>
16 | struct is_class :
17 |   public decltype(is_class_impl::check<T>(nullptr)) {};
18 | 
19 | #include <iostream>
20 | #include <boost/utility.hpp>
21 | 
22 | using namespace boost;
23 | 
24 | template <class T>
25 | void check(T value, typename enable_if<is_class<T>>::type* = 0)
26 | {
27 |   std::cout << "Tはクラス" << std::endl;
28 | }
29 | 
30 | template <class T>
31 | void check(T value, typename disable_if<is_class<T>>::type* = 0)
32 | {
33 |   std::cout << "Tはクラスではない" << std::endl;
34 | }
35 | 
36 | struct X {};
37 | 
38 | int main()
39 | {
40 |   check(X());
41 |   check(3);
42 | }
43 | 


--------------------------------------------------------------------------------
/05_sfinae/12_has_add_member.cpp:
--------------------------------------------------------------------------------
 1 | // Copyright (c) 2014
 2 | // Akira Takahashi, Fumiki Fukuda.
 3 | // Released under the CC0 1.0 Universal license.
 4 | 
 5 | #include <iostream>
 6 | #include <utility>
 7 | #include <boost/utility/enable_if.hpp>
 8 | 
 9 | struct has_add_member_impl {
10 |   template <class T, class U>
11 |   static auto check(T*, U*) -> decltype(
12 |     std::declval<T>().add(std::declval<U>()),
13 |     std::true_type());
14 | 
15 |   template <class T, class U>
16 |   static auto check(...) -> std::false_type;
17 | };
18 | 
19 | template <class T, class U>
20 | struct has_add_member
21 |   : decltype(has_add_member_impl::check<T, U>(
22 | 			    nullptr, nullptr)) {};
23 | 
24 | // 関数テンプレートのoperator+。
25 | // 型Tがadd()メンバ関数を持っている場合のみ呼び出せる。
26 | template <class T, class U>
27 | typename boost::enable_if<has_add_member<T, U>, T>::type
28 |   operator+(const T& a, const U& b)
29 | {
30 |   return a.add(b);
31 | }
32 | 
33 | class X {
34 |   int value;
35 | public:
36 |   X(int value)
37 |     : value(value) {}
38 | 
39 |   X add(const X& x) const
40 |   {
41 |     return X(value + x.value);
42 |   }
43 | 
44 |   int getValue() const { return value; }
45 | };
46 | 
47 | int main()
48 | {
49 |   X a(1);
50 |   X b(2);
51 | 
52 |   X r = a + b;
53 |   std::cout << r.getValue() << std::endl;
54 | }
55 | 


--------------------------------------------------------------------------------
/05_sfinae/13_enable_if_default_template_argument.cpp:
--------------------------------------------------------------------------------
 1 | // Copyright (c) 2014
 2 | // Akira Takahashi, Fumiki Fukuda.
 3 | // Released under the CC0 1.0 Universal license.
 4 | 
 5 | #include <iostream>
 6 | #include <boost/utility.hpp>
 7 | #include <boost/type_traits/is_class.hpp>
 8 | 
 9 | using namespace boost;
10 | 
11 | template <class T,
12 |           typename enable_if<
13 |             is_class<T>
14 |           >::type* = nullptr>
15 | void check(T value)
16 | {
17 |   std::cout << "Tはクラス" << std::endl;
18 | }
19 | 
20 | template <class T,
21 |           typename disable_if<
22 |             is_class<T>
23 |           >::type* = nullptr>
24 | void check(T value)
25 | {
26 |   std::cout << "Tはクラスではない" << std::endl;
27 | }
28 | 
29 | struct X {};
30 | 
31 | int main()
32 | {
33 |   check(X());
34 |   check(3);
35 | }
36 | 


--------------------------------------------------------------------------------
/05_sfinae/14_sort.cpp:
--------------------------------------------------------------------------------
 1 | // Copyright (c) 2014
 2 | // Akira Takahashi, Fumiki Fukuda.
 3 | // Released under the CC0 1.0 Universal license.
 4 | 
 5 | #include <type_traits>
 6 | #include <utility>
 7 | 
 8 | // 型Tがsort()メンバ関数を持っているか判定するメタ関数
 9 | struct has_sort_member_impl {
10 |   template <class T>
11 |   static auto check(T*) -> decltype(
12 |     std::declval<T>().sort(),
13 |     std::true_type());
14 | 
15 |   template <class T>
16 |   static auto check(...) -> std::false_type;
17 | };
18 | 
19 | template <class T>
20 | struct has_sort_member
21 |   : decltype(has_sort_member_impl::check<T>(nullptr)) {};
22 | 
23 | 
24 | #include <iostream>
25 | #include <iterator>
26 | #include <vector>
27 | #include <list>
28 | #include <algorithm>
29 | 
30 | template <class Sortable,
31 |           typename std::enable_if<
32 |             has_sort_member<Sortable>::value
33 |           >::type* = nullptr
34 |          >
35 | void sort(Sortable& x)
36 | {
37 |   x.sort();
38 | }
39 | 
40 | template <class Range,
41 |           typename std::enable_if<
42 |             !has_sort_member<Range>::value
43 |           >::type* = nullptr
44 |          >
45 | void sort(Range& r)
46 | {
47 |   std::sort(std::begin(r), std::end(r));
48 | }
49 | 
50 | int main()
51 | {
52 |   std::vector<int> v  = {3, 1, 4};
53 |   std::list<int>   ls = {3, 1, 4};
54 | 
55 |   sort(v);  // sort(v.begin(), v.end());
56 |   sort(ls); // ls.sort();
57 | 
58 |   for (int x : v) {
59 |     std::cout << x << " ";
60 |   }
61 |   std::cout << std::endl;
62 | 
63 |   for (int x : ls) {
64 |     std::cout << x << " ";
65 |   }
66 | }
67 | 


--------------------------------------------------------------------------------
/05_sfinae/15_optimized_copy.cpp:
--------------------------------------------------------------------------------
 1 | // Copyright (c) 2014
 2 | // Akira Takahashi, Fumiki Fukuda.
 3 | // Released under the CC0 1.0 Universal license.
 4 | 
 5 | #include <iostream>
 6 | #include <cstring> // memmove
 7 | #include <boost/type_traits/has_trivial_assign.hpp>
 8 | #include <boost/type_traits/has_trivial_destructor.hpp>
 9 | 
10 | template <class Iterator,
11 |           typename std::enable_if<
12 |             std::is_pointer<Iterator>::value &&
13 |             boost::has_trivial_assign<
14 |               typename std::iterator_traits<Iterator>::value_type
15 |             >::value &&
16 |             boost::has_trivial_destructor<
17 |               typename std::iterator_traits<Iterator>::value_type
18 |             >::value
19 |            >::type* = nullptr
20 |          >
21 | Iterator copy(Iterator first, Iterator last, Iterator out)
22 | {
23 |   std::cout << "memmove" << std::endl;
24 |   std::memmove(out, first, (last - first) * sizeof(decltype(*first)));
25 |   return out + (last - first);
26 | }
27 | 
28 | template <class InputIterator, class OutputIterator>
29 | OutputIterator copy(InputIterator first, InputIterator last,
30 |                     OutputIterator out)
31 | {
32 |   std::cout << "loop copy" << std::endl;
33 |   for (; first != last; ++out, ++first) {
34 |     *out = *first;
35 |   }
36 |   return out;
37 | }
38 | 
39 | #include <list>
40 | #include <iterator>
41 | 
42 | int main()
43 | {
44 |   int ar1[3] = {3, 1, 4};
45 |   int ar2[3] = {};
46 | 
47 |   ::copy(std::begin(ar1), std::end(ar1), std::begin(ar2));
48 |   for (int x : ar2) { std::cout << x << std::endl; }
49 | 
50 |   std::list<int> ls1 = {3, 1, 4};
51 |   std::list<int> ls2(3);
52 | 
53 |   ::copy(std::begin(ls1), std::end(ls1), std::begin(ls2));
54 |   for (int x : ls2) { std::cout << x << std::endl; }
55 | }
56 | 


--------------------------------------------------------------------------------
/05_sfinae/16_optimized_dtor.cpp:
--------------------------------------------------------------------------------
 1 | // Copyright (c) 2014
 2 | // Akira Takahashi, Fumiki Fukuda.
 3 | // Released under the CC0 1.0 Universal license.
 4 | 
 5 | #include <iostream>
 6 | #include <boost/utility/enable_if.hpp>
 7 | #include <boost/type_traits/has_trivial_destructor.hpp>
 8 | 
 9 | template <class T,
10 |           typename boost::enable_if<
11 |             boost::has_trivial_destructor<T>
12 |           >::type* = nullptr>
13 | void destroy_all(T*, T*)
14 | {
15 |   std::cout << "don't destroy" << std::endl;
16 | }
17 | 
18 | template <class T,
19 |           typename boost::disable_if<
20 |             boost::has_trivial_destructor<T>
21 |           >::type* = nullptr>
22 | void destroy_all(T* first, T* last)
23 | {
24 |   std::cout << "loop destroy" << std::endl;
25 |   while (first != last) {
26 |     first->~T();
27 |     ++first;
28 |   }
29 | }
30 | 
31 | #include <string>
32 | #include <memory>
33 | 
34 | template <class T>
35 | void construct_all(T* first, T* last)
36 | {
37 |   while (first != last) {
38 |     new (first) T();
39 |     ++first;
40 |   }
41 | }
42 | 
43 | template <class T>
44 | void f()
45 | {
46 |   std::allocator<T> alloc;
47 | 
48 |   std::size_t size = 3;
49 |   T* ar = alloc.allocate(size, nullptr);
50 |   construct_all(ar, ar + size);
51 | 
52 |   // 全ての要素に対してデストラクタを呼び出す
53 |   destroy_all(ar, ar + size);
54 | 
55 |   alloc.deallocate(ar, size);
56 | }
57 | 
58 | int main()
59 | {
60 |   f<std::string>();
61 |   f<int>();
62 | }
63 | 


--------------------------------------------------------------------------------
/06_policy/01_policy_based_logger.cpp:
--------------------------------------------------------------------------------
 1 | // Copyright (c) 2014
 2 | // Akira Takahashi, Fumiki Fukuda.
 3 | // Released under the CC0 1.0 Universal license.
 4 | 
 5 | #include <iostream>
 6 | #include <string>
 7 | 
 8 | struct debug_log {
 9 |   static void print(const std::string& value)
10 |   {
11 |     std::cout << value << std::endl;
12 |   }
13 | };
14 | 
15 | struct release_log {
16 |   static void print(const std::string&) {}
17 | };
18 | 
19 | template <class LogPolicy>
20 | struct hoge {
21 |   void foo() const
22 |   {
23 |     LogPolicy::print("Fatal Error!!!");
24 |   }
25 | };
26 | 
27 | int main()
28 | {
29 |   hoge<debug_log>().foo();
30 |   hoge<release_log>().foo();
31 | }
32 | 


--------------------------------------------------------------------------------
/06_policy/02_default_policy.cpp:
--------------------------------------------------------------------------------
 1 | // Copyright (c) 2014
 2 | // Akira Takahashi, Fumiki Fukuda.
 3 | // Released under the CC0 1.0 Universal license.
 4 | 
 5 | #include <iostream>
 6 | #include <string>
 7 | 
 8 | struct debug_log {
 9 |   static void print(const std::string& value)
10 |   {
11 |     std::cout << value << std::endl;
12 |   }
13 | };
14 | 
15 | struct release_log {
16 |   static void print(const std::string&) {}
17 | };
18 | 
19 | template <class LogPolicy = debug_log>
20 | struct hoge {
21 |   void foo() const
22 |   {
23 |     LogPolicy::print("Fatal Error!!!");
24 |   }
25 | };
26 | 
27 | int main()
28 | {
29 |   hoge<debug_log>().foo();
30 |   hoge<release_log>().foo();
31 |   hoge<>().foo();
32 | 
33 |   typedef hoge<debug_log> default_hoge;
34 |   default_hoge().foo();
35 | }
36 | 


--------------------------------------------------------------------------------
/06_policy/03_policy_based_smart_ptr.cpp:
--------------------------------------------------------------------------------
 1 | // Copyright (c) 2014
 2 | // Akira Takahashi, Fumiki Fukuda.
 3 | // Released under the CC0 1.0 Universal license.
 4 | 
 5 | class single_thread_model { /*……*/ }; // シングルスレッド
 6 | class multi_thread_model  { /*……*/ }; // マルチスレッド
 7 | 
 8 | class reference_count { /*……*/ }; // 参照カウント方式
 9 | class deep_copy       { /*……*/ }; // ディープコピー方式
10 | class copy_on_write   { /*……*/ }; // 書き込み時コピー方式
11 | 
12 | // スマートポインタ<所有権管理方式, スレッドモデル>
13 | template <class Ownership, class ThreadModel>
14 | class smart_ptr { /*……*/ };
15 | 
16 | int main()
17 | {
18 |   // シングルスレッドの参照カウント方式のスマートポインタ
19 |   smart_ptr<reference_count, single_thread_model> ptr1;
20 |   
21 |   // マルチスレッドのディープコピー方式のスマートポインタ
22 |   smart_ptr<deep_copy, multi_thread_model> ptr2;
23 |   
24 |   // マルチスレッドの書き込み時コピー方式のスマートポインタ
25 |   smart_ptr<copy_on_write, multi_thread_model> ptr3;
26 | }
27 | 


--------------------------------------------------------------------------------
/06_policy/04_inheritance_boost_multi_index.cpp:
--------------------------------------------------------------------------------
 1 | // Copyright (c) 2014
 2 | // Akira Takahashi, Fumiki Fukuda.
 3 | // Released under the CC0 1.0 Universal license.
 4 | 
 5 | #include <iostream>
 6 | #include <boost/multi_index_container.hpp>
 7 | #include <boost/multi_index/sequenced_index.hpp>
 8 | #include <boost/multi_index/ordered_index.hpp>
 9 | 
10 | using namespace boost::multi_index;
11 | 
12 | template <class T>
13 | using SeqContainer = multi_index_container<
14 |   T,
15 |   indexed_by<sequenced<>>
16 | >;
17 | 
18 | template <class T>
19 | using OrdContainer = multi_index_container<
20 |   T,
21 |   indexed_by<ordered_unique<identity<T>>>
22 | >;
23 | 
24 | int main()
25 | {
26 |   SeqContainer<int> seq;
27 |   seq.push_back(3);
28 | //seq.insert(1); // コンパイルエラー！
29 |                  // insert()メンバ関数はを持っていない
30 | 
31 |   OrdContainer<int> ord;
32 |   ord.insert(3);
33 | //ord.push_back(1); // コンパイルエラー！
34 |                     // push_back()メンバ関数を持っていない
35 | }
36 | 


--------------------------------------------------------------------------------
/06_policy/05_named_tmpl_param/1st_step.cpp:
--------------------------------------------------------------------------------
 1 | // Copyright (c) 2014
 2 | // Akira Takahashi, Fumiki Fukuda.
 3 | // Released under the CC0 1.0 Universal license.
 4 | 
 5 | #include <iostream>
 6 | #include "named_tmpl_param.hpp"
 7 | 
 8 | template <class Strategy>
 9 | struct ownership {
10 |   typedef Strategy type;
11 | };
12 | 
13 | struct reference_count {};
14 | struct deep_copy {};
15 | 
16 | 
17 | template <bool IsMultiThread>
18 | struct multi_thread {
19 |   static const bool value = IsMultiThread;
20 | };
21 | 
22 | 
23 | template <class>
24 | struct is_ownership_policy {
25 |   static const bool value = false;
26 | };
27 | 
28 | template <class Strategy>
29 | struct is_ownership_policy<ownership<Strategy>> {
30 |   static const bool value = true;
31 | };
32 | 
33 | template <class>
34 | struct is_multi_thread_policy {
35 |   static const bool value = false;
36 | };
37 | 
38 | template <bool IsMultiThread>
39 | struct is_multi_thread_policy<multi_thread<IsMultiThread>> {
40 |   static const bool value = true;
41 | };
42 | 
43 | template <class... Args>
44 | struct smart_ptr {
45 |   typedef typename
46 |     get_required_arg<
47 |       is_ownership_policy,
48 |       Args...
49 |     >::type
50 |   ownership_policy;
51 | 
52 |   typedef typename
53 |     get_optional_arg<
54 |       multi_thread<false>,
55 |       is_multi_thread_policy,
56 |       Args...
57 |     >::type
58 |   multi_thread_policy;
59 | };
60 | 
61 | int main()
62 | {
63 |   smart_ptr<multi_thread<true>, ownership<reference_count>> p;
64 | 
65 |   static_assert(
66 |     std::is_same<
67 |       decltype(p)::ownership_policy,
68 |       ownership<reference_count>
69 |     >::value,
70 |     "ownership policy is not reference_count");
71 | 
72 |   static_assert(
73 |     std::is_same<
74 |       decltype(p)::multi_thread_policy,
75 |       multi_thread<true>
76 |     >::value,
77 |     "multi thread policy is not multi_thread<true>");
78 | }
79 | 


--------------------------------------------------------------------------------
/06_policy/05_named_tmpl_param/2nd_step.cpp:
--------------------------------------------------------------------------------
 1 | // Copyright (c) 2014
 2 | // Akira Takahashi, Fumiki Fukuda.
 3 | // Released under the CC0 1.0 Universal license.
 4 | 
 5 | #include <iostream>
 6 | #include "named_tmpl_param.hpp"
 7 | 
 8 | DEFINE_TYPE_NAMED_PARAM(ownership)
 9 | DEFINE_BOOL_NAMED_PARAM(multi_thread)
10 | 
11 | struct reference_count {};
12 | struct deep_copy {};
13 | 
14 | template <class... Args>
15 | struct smart_ptr {
16 |   typedef typename
17 |     get_required_arg<
18 |       is_ownership_policy,
19 |       Args...
20 |     >::type
21 |   ownership_policy;
22 | 
23 |   typedef typename
24 |     get_optional_arg<
25 |       multi_thread<false>,
26 |       is_multi_thread_policy,
27 |       Args...
28 |     >::type
29 |   multi_thread_policy;
30 | };
31 | 
32 | int main()
33 | {
34 |   smart_ptr<multi_thread<true>, ownership<reference_count>> p;
35 | }
36 | 


--------------------------------------------------------------------------------
/06_policy/05_named_tmpl_param/find_if.hpp:
--------------------------------------------------------------------------------
 1 | // Copyright (c) 2014
 2 | // Akira Takahashi, Fumiki Fukuda.
 3 | // Released under the CC0 1.0 Universal license.
 4 | 
 5 | #ifndef TEMPLATE_TECHNIQUES_POLICY_FIND_IF_INCLUDE
 6 | #define TEMPLATE_TECHNIQUES_POLICY_FIND_IF_INCLUDE
 7 | 
 8 | #include <type_traits>
 9 | 
10 | struct not_found {};
11 | 
12 | template <template <class> class Pred,
13 |           class Head, class... Tail>
14 | struct find_if_impl {
15 |   typedef typename
16 |     std::conditional<
17 |       Pred<Head>::value,
18 |       Head,
19 |       typename find_if_impl<Pred, Tail...>::type
20 |     >::type
21 |   type;
22 | };
23 | 
24 | template <template <class> class Pred, class Head>
25 | struct find_if_impl<Pred, Head> {
26 |   typedef typename
27 |     std::conditional<
28 |       Pred<Head>::value,
29 |       Head,
30 |       not_found
31 |     >::type
32 |   type;
33 | };
34 | 
35 | template <template <class> class Pred, class... List>
36 | struct find_if {
37 |   typedef typename find_if_impl<Pred, List...>::type type;
38 | };
39 | 
40 | #endif
41 | 
42 | 
43 | 


--------------------------------------------------------------------------------
/06_policy/05_named_tmpl_param/named_tmpl_param.hpp:
--------------------------------------------------------------------------------
 1 | // Copyright (c) 2014
 2 | // Akira Takahashi, Fumiki Fukuda.
 3 | // Released under the CC0 1.0 Universal license.
 4 | 
 5 | #ifndef TEMPLATE_TECHNIQUES_POLICY_NAMED_TEMPLATE_PARAM_INCLUDE
 6 | #define TEMPLATE_TECHNIQUES_POLICY_NAMED_TEMPLATE_PARAM_INCLUDE
 7 | 
 8 | #include <type_traits>
 9 | #include "./find_if.hpp"
10 | 
11 | template <template <class> class Pred, class... List>
12 | struct get_required_arg {
13 |   typedef typename find_if<Pred, List...>::type type;
14 |   static_assert(!std::is_same<type, not_found>::value,
15 |                 "required policy not found");
16 | };
17 | 
18 | template <class Opt, template <class> class Pred, class... List>
19 | struct get_optional_arg {
20 | private:
21 |   typedef typename find_if<Pred, List...>::type result;
22 | public:
23 |   typedef typename
24 |     std::conditional<
25 |       !std::is_same<result, not_found>::value,
26 |       result,
27 |       Opt
28 |     >::type
29 |   type;
30 | };
31 | 
32 | #define DEFINE_TYPE_NAMED_PARAM(param)       \
33 |   template <class T>                         \
34 |   struct param {                             \
35 |     typedef T type;                          \
36 |   };                                         \
37 |                                              \
38 |   template <class>                           \
39 |   struct is_ ## param ## _policy {           \
40 |     static const bool value = false;         \
41 |   };                                         \
42 |                                              \
43 |   template <class T>                         \
44 |   struct is_ ## param ## _policy<param<T>> { \
45 |     static const bool value = true;          \
46 |   };
47 | 
48 | #define DEFINE_BOOL_NAMED_PARAM(param)       \
49 |   template <bool V>                          \
50 |   struct param {                             \
51 |     static const bool value = V;             \
52 |   };                                         \
53 |                                              \
54 |   template <class>                           \
55 |   struct is_ ## param ## _policy {           \
56 |     static const bool value = false;         \
57 |   };                                         \
58 |                                              \
59 |   template <bool V>                          \
60 |   struct is_ ## param ## _policy<param<V>> { \
61 |     static const bool value = true;          \
62 |   };
63 | 
64 | #endif
65 | 


--------------------------------------------------------------------------------
/06_policy/06_sorted_vector.cpp:
--------------------------------------------------------------------------------
 1 | // Copyright (c) 2014
 2 | // Akira Takahashi, Fumiki Fukuda.
 3 | // Released under the CC0 1.0 Universal license.
 4 | 
 5 | #include <iostream>
 6 | #include <vector>
 7 | #include <algorithm>
 8 | 
 9 | template <class T, template <class> class ComparePolicy>
10 | class sorted_vector {
11 |   std::vector<T> vec_;
12 | public:
13 |   void push_back(const T& value)
14 |   {
15 |     vec_.push_back(value);
16 |     std::sort(std::begin(vec_), std::end(vec_),
17 |               &ComparePolicy<T>::compare);
18 |   }
19 | 
20 |   void print()
21 |   {
22 |     for (const T& x : vec_) {
23 |       std::cout << x << std::endl;
24 |     }
25 |   }
26 | };
27 | 
28 | template <class T>
29 | struct less_policy {
30 |   static bool compare(const T& lhs, const T& rhs)
31 |   {
32 |     return lhs < rhs;
33 |   }
34 | };
35 | 
36 | template <class T>
37 | struct greater_policy {
38 |   static bool compare(const T& lhs, const T& rhs)
39 |   {
40 |     return lhs > rhs;
41 |   }
42 | };
43 | 
44 | int main()
45 | {
46 |   sorted_vector<int, less_policy> v;
47 | 
48 |   v.push_back(3);
49 |   v.push_back(1);
50 |   v.push_back(4);
51 | 
52 |   v.print();
53 | }
54 | 


--------------------------------------------------------------------------------
/07_concept/01_min_requirements.cpp:
--------------------------------------------------------------------------------
 1 | // Copyright (c) 2014
 2 | // Akira Takahashi, Fumiki Fukuda.
 3 | // Released under the CC0 1.0 Universal license.
 4 | 
 5 | #include <utility>
 6 | 
 7 | struct is_less_than_comparable_impl {
 8 |   template <class T, class U>
 9 |   static auto check(T*, U*) -> decltype(
10 |     std::declval<T>() < std::declval<U>(),
11 |     std::true_type());
12 | 
13 |   template <class T, class U>
14 |   static auto check(...) -> std::false_type;
15 | };
16 | 
17 | // 型Tと型Uがoperator<で比較可能か判定するメタ関数
18 | template <class T, class U>
19 | struct is_less_than_comparable
20 |   : decltype(is_less_than_comparable_impl::check<T, U>(
21 |                 nullptr, nullptr
22 |              )) {};
23 | 
24 | template <class T>
25 | const T& min(const T& a, const T& b)
26 | {
27 |   // 型Tに対する要件
28 |   static_assert(is_less_than_comparable<T, T>::value,
29 |                 "T must less than comparable");
30 | 
31 |   return a < b ? a : b;
32 | }
33 | 
34 | class X {};
35 | 
36 | int main()
37 | {
38 |   int n = ::min(1, 2);
39 | //X x = ::min(X(), X()); // コンパイルエラー！
40 |                          // 型Xはoperator<で比較できない
41 | }
42 | 


--------------------------------------------------------------------------------
/07_concept/02_basic_distance.cpp:
--------------------------------------------------------------------------------
 1 | // Copyright (c) 2014
 2 | // Akira Takahashi, Fumiki Fukuda.
 3 | // Released under the CC0 1.0 Universal license.
 4 | 
 5 | #include <iostream>
 6 | #include <cmath>
 7 | 
 8 | class point {
 9 |   double x_ = 0;
10 |   double y_ = 0;
11 | public:
12 |   point() = default;
13 |   point(double x, double y)
14 |     : x_(x), y_(y) {}
15 | 
16 |   // それぞれの座標を取得する
17 |   double x() const { return x_; }
18 |   double y() const { return y_; }
19 | };
20 | 
21 | // pointの減算
22 | point operator-(const point& a, const point& b)
23 |   { return point(a.x() - b.x(), a.y() - b.y()); }
24 | 
25 | template <class Point>
26 | double distance(Point a, Point b)
27 | {
28 |   const Point d = a - b;
29 |   return std::sqrt(d.x() * d.x() + d.y() * d.y());
30 | }
31 | 
32 | int main()
33 | {
34 |   point a(0.0, 0.0);
35 |   point b(3.0, 3.0);
36 | 
37 |   double d = distance(a, b);
38 |   std::cout << d << std::endl;
39 | }
40 | 


--------------------------------------------------------------------------------
/07_concept/03_concept_based_distance.cpp:
--------------------------------------------------------------------------------
 1 | // Copyright (c) 2014
 2 | // Akira Takahashi, Fumiki Fukuda.
 3 | // Released under the CC0 1.0 Universal license.
 4 | 
 5 | #include <iostream>
 6 | #include <cmath>
 7 | 
 8 | class point {
 9 |   double x_ = 0;
10 |   double y_ = 0;
11 | public:
12 |   point() = default;
13 |   point(double x, double y)
14 |     : x_(x), y_(y) {}
15 | 
16 |   // それぞれの座標を取得する
17 |   double x() const { return x_; }
18 |   double y() const { return y_; }
19 | };
20 | 
21 | template <class T>
22 | struct point_traits {
23 |   static double x(const T& p) { return p.x(); }
24 |   static double y(const T& p) { return p.y(); }
25 | 
26 |   static T subtract(const T& a, const T& b)
27 |     { return T(a.x() - b.x(), a.y() - b.y()); }
28 | };
29 | 
30 | template <class Point>
31 | double distance(Point a, Point b)
32 | {
33 |   typedef point_traits<Point> traits;
34 |   const Point d = traits::subtract(a, b);
35 |   return std::sqrt(traits::x(d) * traits::x(d) +
36 |                    traits::y(d) * traits::y(d));
37 | }
38 | 
39 | int main()
40 | {
41 |   point a(0.0, 0.0);
42 |   point b(3.0, 3.0);
43 | 
44 |   double d = distance(a, b);
45 |   std::cout << d << std::endl;
46 | }
47 | 


--------------------------------------------------------------------------------
/07_concept/04_add_my_point.cpp:
--------------------------------------------------------------------------------
 1 | // Copyright (c) 2014
 2 | // Akira Takahashi, Fumiki Fukuda.
 3 | // Released under the CC0 1.0 Universal license.
 4 | 
 5 | #include <iostream>
 6 | #include <cmath>
 7 | 
 8 | class point {
 9 |   double x_ = 0;
10 |   double y_ = 0;
11 | public:
12 |   point() = default;
13 |   point(double x, double y)
14 |     : x_(x), y_(y) {}
15 | 
16 |   // それぞれの座標を取得する
17 |   double x() const { return x_; }
18 |   double y() const { return y_; }
19 | };
20 | 
21 | template <class T>
22 | struct point_traits {
23 |   static double x(const T& p) { return p.x(); }
24 |   static double y(const T& p) { return p.y(); }
25 | 
26 |   static T subtract(const T& a, const T& b)
27 |     { return T(a.x() - b.x(), a.y() - b.y()); }
28 | };
29 | 
30 | template <class Point>
31 | double distance(Point a, Point b)
32 | {
33 |   typedef point_traits<Point> traits;
34 |   const Point d = traits::subtract(a, b);
35 |   return std::sqrt(traits::x(d) * traits::x(d) +
36 |                    traits::y(d) * traits::y(d));
37 | }
38 | 
39 | class MyPoint {
40 |   double x_ = 0;
41 |   double y_ = 0;
42 | public:
43 |   MyPoint() = default;
44 |   MyPoint(double x, double y)
45 |     : x_(x), y_(y) {}
46 | 
47 |   double getX() const { return x_; }
48 |   double getY() const { return y_; }
49 | };
50 | 
51 | template <>
52 | struct point_traits<MyPoint> {
53 |   static double x(const MyPoint& p) { return p.getX(); }
54 |   static double y(const MyPoint& p) { return p.getY(); }
55 | 
56 |   static MyPoint subtract(const MyPoint& a, const MyPoint& b)
57 |     { return MyPoint(a.getX() - b.getX(), a.getY() - b.getY()); }
58 | };
59 | 
60 | int main()
61 | {
62 |   MyPoint a(0.0, 0.0);
63 |   MyPoint b(3.0, 3.0);
64 | 
65 |   double d = distance(a, b);
66 |   std::cout << d << std::endl;
67 | }
68 | 


--------------------------------------------------------------------------------
/07_concept/05_concept_based_overload.cpp:
--------------------------------------------------------------------------------
  1 | // Copyright (c) 2014
  2 | // Akira Takahashi, Fumiki Fukuda.
  3 | // Released under the CC0 1.0 Universal license.
  4 | 
  5 | #include <iostream>
  6 | #include <cmath> // sqrt
  7 | #include <algorithm> // min
  8 | 
  9 | struct point_category {};
 10 | struct line_segment_category {};
 11 | 
 12 | template <class T>
 13 | struct get_geometry_category;
 14 | 
 15 | 
 16 | template <class T>
 17 | struct point_traits {
 18 |   static double x(const T& p) { return p.x(); }
 19 |   static double y(const T& p) { return p.y(); }
 20 | 
 21 |   static T subtract(const T& a, const T& b)
 22 |     { return T(a.x() - b.x(), a.y() - b.y()); }
 23 | };
 24 | 
 25 | template <class T>
 26 | struct line_segment_traits {
 27 |   typedef typename T::point_type point_type;
 28 | 
 29 |   static const point_type&
 30 |     p1(const T& line) { return line.p1(); }
 31 | 
 32 |   static const point_type&
 33 |     p2(const T& line) { return line.p2(); }
 34 | };
 35 | 
 36 | class point {
 37 |   double x_ = 0;
 38 |   double y_ = 0;
 39 | public:
 40 |   point() = default;
 41 |   point(double x, double y)
 42 |     : x_(x), y_(y) {}
 43 | 
 44 |   // それぞれの座標を取得する
 45 |   double x() const { return x_; }
 46 |   double y() const { return y_; }
 47 | };
 48 | 
 49 | template <>
 50 | struct get_geometry_category<point> {
 51 |   typedef point_category type;
 52 | };
 53 | 
 54 | template <class Point>
 55 | class line_segment {
 56 |   Point p1_;
 57 |   Point p2_;
 58 | public:
 59 |   typedef Point point_type;
 60 | 
 61 |   line_segment() = default;
 62 |   line_segment(const Point& p1, const Point& p2)
 63 |     : p1_(p1), p2_(p2) {}
 64 | 
 65 |   const Point& p1() const { return p1_; }
 66 |   const Point& p2() const { return p2_; }
 67 | };
 68 | 
 69 | template <class Point>
 70 | struct get_geometry_category<line_segment<Point>> {
 71 |   typedef line_segment_category type;
 72 | };
 73 | 
 74 | // 点と点
 75 | template <class Point>
 76 | double distance_impl(Point a, Point b,
 77 |                      point_category, point_category)
 78 | {
 79 |   typedef point_traits<Point> traits;
 80 |   const Point d = traits::subtract(a, b);
 81 |   return std::sqrt(traits::x(d) * traits::x(d) +
 82 |                    traits::y(d) * traits::y(d));
 83 | }
 84 | 
 85 | // 点と線分
 86 | template <class Point, class LineSegment>
 87 | double distance_impl(Point a, LineSegment b,
 88 |                      point_category, line_segment_category)
 89 | {
 90 |   typedef line_segment_traits<LineSegment> traits;
 91 |   return std::min(
 92 |            distance(a, traits::p1(b)),
 93 |            distance(a, traits::p2(b))
 94 |          );
 95 | }
 96 | 
 97 | // 線分と点
 98 | template <class LineSegment, class Point>
 99 | double distance_impl(LineSegment a, Point b,
100 |                      line_segment_category, point_category)
101 | {
102 |   return distance(b, a);
103 | }
104 | 
105 | template <class Geometry1, class Geometry2>
106 | double distance(Geometry1 a, Geometry2 b)
107 | {
108 |   return distance_impl(a, b,
109 |            typename get_geometry_category<Geometry1>::type(),
110 |            typename get_geometry_category<Geometry2>::type());
111 | }
112 | 
113 | int main()
114 | {
115 |   point p1(0.0, 0.0);
116 |   point p2(3.0, 3.0);
117 |   line_segment<point> line(point(2.0, 2.0), point(3.0, 3.0));
118 | 
119 |   // 点と点
120 |   double d1 = distance(p1, p2);
121 |   std::cout << d1 << std::endl;
122 | 
123 |   // 点と線分
124 |   double d2 = distance(p1, line);
125 |   std::cout << d2 << std::endl;
126 | }
127 | 


--------------------------------------------------------------------------------
/07_concept/06_specialize_template_with_concept.cpp:
--------------------------------------------------------------------------------
  1 | // Copyright (c) 2014
  2 | // Akira Takahashi, Fumiki Fukuda.
  3 | // Released under the CC0 1.0 Universal license.
  4 | 
  5 | #include <iostream>
  6 | #include <cmath> // sqrt
  7 | #include <algorithm> // min
  8 | #include <utility> // pair
  9 | #include <boost/utility/enable_if.hpp>
 10 | 
 11 | struct point_category {};
 12 | 
 13 | template <class T, class Enable = void>
 14 | struct get_geometry_category;
 15 | 
 16 | template <class T, class Enable = void>
 17 | struct point_traits {
 18 |   static double x(const T& p) { return p.x(); }
 19 |   static double y(const T& p) { return p.y(); }
 20 | 
 21 |   static T subtract(const T& a, const T& b)
 22 |     { return T(a.x() - b.x(), a.y() - b.y()); }
 23 | };
 24 | 
 25 | class point {
 26 |   double x_ = 0;
 27 |   double y_ = 0;
 28 | public:
 29 |   point() = default;
 30 |   point(double x, double y)
 31 |     : x_(x), y_(y) {}
 32 | 
 33 |   // それぞれの座標を取得する
 34 |   double x() const { return x_; }
 35 |   double y() const { return y_; }
 36 | };
 37 | 
 38 | template <>
 39 | struct get_geometry_category<point> {
 40 |   typedef point_category type;
 41 | };
 42 | 
 43 | // 別の計算幾何ライブラリ
 44 | namespace geo {
 45 | 
 46 | template <class T>
 47 | struct is_point_category {
 48 |   static const bool value = false;
 49 | };
 50 | 
 51 | template <class T>
 52 | struct point_traits {
 53 |   static double getX(const T& p) { return p.getX(); }
 54 |   static double getY(const T& p) { return p.getY(); }
 55 | 
 56 |   static T subtract(const T& a, const T& b)
 57 |     { return T(a.getX() - b.getX(), a.getY() - b.getY()); }
 58 | };
 59 | 
 60 | class point {
 61 |   double x_ = 0;
 62 |   double y_ = 0;
 63 | public:
 64 |   point() = default;
 65 |   point(double x, double y)
 66 |     : x_(x), y_(y) {}
 67 | 
 68 |   // それぞれの座標を取得する
 69 |   double getX() const { return x_; }
 70 |   double getY() const { return y_; }
 71 | };
 72 | 
 73 | template <>
 74 | struct is_point_category<point> {
 75 |   static const bool value = true;
 76 | };
 77 | 
 78 | template <>
 79 | struct point_traits<std::pair<double, double>> {
 80 |   typedef std::pair<double, double> point_type;
 81 | 
 82 |   static double getX(const point_type& p)
 83 |     { return p.first; }
 84 | 
 85 |   static double getY(const point_type& p)
 86 |     { return p.second; }
 87 | 
 88 |   static point_type subtract(
 89 |                       const point_type& a,
 90 |                       const point_type& b)
 91 |   {
 92 |     return std::make_pair(
 93 |              a.first - b.first,
 94 |              a.second - b.second);
 95 |   }
 96 | };
 97 | 
 98 | template <>
 99 | struct is_point_category<std::pair<double, double>> {
100 |   static const bool value = true;
101 | };
102 | 
103 | } // namespace geo
104 | 
105 | template <class T>
106 | struct get_geometry_category<
107 |          T,
108 |          typename boost::enable_if<
109 |            geo::is_point_category<T>
110 |          >::type
111 |        > {
112 |   typedef point_category type;
113 | };
114 | 
115 | template <class T>
116 | struct point_traits<
117 |          T,
118 |          typename boost::enable_if<
119 |            geo::is_point_category<T>
120 |          >::type
121 |        > {
122 |   static double x(const T& p) { return geo::point_traits<T>::getX(p); }
123 |   static double y(const T& p) { return geo::point_traits<T>::getY(p); }
124 | 
125 |   static T subtract(const T& a, const T& b)
126 |     { return geo::point_traits<T>::subtract(a, b); }
127 | };
128 | 
129 | // 点と点
130 | template <class Point>
131 | double distance_impl(Point a, Point b,
132 |                      point_category, point_category)
133 | {
134 |   typedef point_traits<Point> traits;
135 |   const Point d = traits::subtract(a, b);
136 |   return std::sqrt(traits::x(d) * traits::x(d) +
137 |                    traits::y(d) * traits::y(d));
138 | }
139 | 
140 | template <class Geometry1, class Geometry2>
141 | double distance(Geometry1 a, Geometry2 b)
142 | {
143 |   return distance_impl(a, b,
144 |            typename get_geometry_category<Geometry1>::type(),
145 |            typename get_geometry_category<Geometry2>::type());
146 | }
147 | 
148 | int main()
149 | {
150 |   {
151 |     point p1(0.0, 0.0);
152 |     point p2(3.0, 3.0);
153 | 
154 |     double d = distance(p1, p2);
155 |     std::cout << d << std::endl;
156 |   }
157 |   {
158 |     geo::point p1(0.0, 0.0);
159 |     geo::point p2(3.0, 3.0);
160 | 
161 |     double d = distance(p1, p2);
162 |     std::cout << d << std::endl;
163 |   }
164 |   {
165 |     std::pair<double, double> p1(0.0, 0.0);
166 |     std::pair<double, double> p2(3.0, 3.0);
167 | 
168 |     double d = distance(p1, p2);
169 |     std::cout << d << std::endl;
170 |   }
171 | }
172 | 


--------------------------------------------------------------------------------
/08_type_erasure/01_virtual_function_table.cpp:
--------------------------------------------------------------------------------
 1 | // Copyright (c) 2014
 2 | // Akira Takahashi, Fumiki Fukuda.
 3 | // Released under the CC0 1.0 Universal license.
 4 | 
 5 | class drawable {
 6 |   struct vtable {
 7 |     void (*draw)(void*);
 8 |   };
 9 | 
10 |   template <class T>
11 |   struct vtable_initializer {
12 |     static vtable vtbl_;
13 | 
14 |     static void draw(void* this_)
15 |     {
16 |       static_cast<T*>(this_)->draw();
17 |     }
18 |   };
19 | 
20 |   void* this_;
21 |   vtable* vptr_;
22 | public:
23 |   template <class T>
24 |   drawable(T& other)
25 |     : this_(&other), vptr_(&vtable_initializer<T>::vtbl_) {}
26 | 
27 |   void draw() const
28 |   {
29 |     vptr_->draw(this_);
30 |   }
31 | };
32 | 
33 | template <class T>
34 | drawable::vtable drawable::vtable_initializer<T>::vtbl_ = {
35 |   &drawable::vtable_initializer<T>::draw
36 | };
37 | 
38 | #include <iostream>
39 | using namespace std;
40 | struct circle { // 注：drawableを継承していない
41 |   void draw() const
42 |   {
43 |     cout << "円を描画する" << endl;
44 |   }
45 | };
46 | 
47 | int main()
48 | {
49 |   circle c;
50 |   drawable a = c;
51 | 
52 |   a.draw(); // OK
53 | }
54 | 


--------------------------------------------------------------------------------
/08_type_erasure/02_non_template_base_and_template_derived.cpp:
--------------------------------------------------------------------------------
 1 | // Copyright (c) 2014
 2 | // Akira Takahashi, Fumiki Fukuda.
 3 | // Released under the CC0 1.0 Universal license.
 4 | 
 5 | class base {
 6 | public:
 7 |   virtual ~base() {}
 8 |   virtual void foo() = 0;
 9 | };
10 | 
11 | template <class T>
12 | class derived : public base {
13 |   T value_;
14 | public:
15 |   derived(const T& value) : value_(value) {}
16 |   virtual ~derived() {}
17 | 
18 |   virtual void foo()
19 |   {
20 |     value_.foo();
21 |   }
22 | };
23 | 
24 | class X {
25 |   base* p_;
26 | public:
27 |   template <class T>
28 |   X(const T& value)
29 |   {
30 |     p_ = new derived<T>(value);
31 |   }
32 | 
33 |   ~X()
34 |   {
35 |     delete p_;
36 |   }
37 | 
38 |   void foo()
39 |   {
40 |     p_->foo();
41 |   }
42 | };
43 | 
44 | #include <iostream>
45 | struct Y {
46 |   void foo()
47 |   {
48 |     std::cout << "foo" << std::endl;
49 |   }
50 | };
51 | 
52 | int main()
53 | {
54 |   Y y;
55 |   X x(y);
56 | 
57 |   x.foo();
58 | }
59 | 


--------------------------------------------------------------------------------
/08_type_erasure/03_shared_ptr_implementation.cpp:
--------------------------------------------------------------------------------
 1 | // Copyright (c) 2014
 2 | // Akira Takahashi, Fumiki Fukuda.
 3 | // Released under the CC0 1.0 Universal license.
 4 | 
 5 | class shared_deleter_base {
 6 | public:
 7 |   shared_deleter_base() {}
 8 |   virtual ~shared_deleter_base() {}
 9 |   virtual void destroy() = 0;
10 | };
11 | 
12 | template <class T, class D>
13 | class shared_deleter : public shared_deleter_base {
14 |   T* object_;
15 |   D deleter_;
16 | public:
17 |   shared_deleter(T* object, D deleter)
18 |   : object_(object), deleter_(deleter) {}
19 | 
20 |   virtual void destroy()
21 |   {
22 |     deleter_(object_);
23 |   }
24 | };
25 | 
26 | template <class T>
27 | class shared_ptr {
28 |   T*                   object_;  // ポインタ
29 |   shared_deleter_base* deleter_; // カスタム削除子
30 | public:
31 |   // カスタム削除子を使用しないコンストラクタ
32 |   explicit shared_ptr(T* object) : object_(object), deleter_(0) {}
33 | 
34 |   // カスタム削除子を使用するコンストラクタ
35 |   template <class D>
36 |   shared_ptr(T* object, D deleter) : object_(object)
37 |   {
38 |     deleter_ = new shared_deleter<T, D>(object_, deleter);
39 |   }
40 | 
41 |   ~shared_ptr()
42 |   {
43 |     // カスタム削除子が指定されていたらそれを実行
44 |     if (deleter_) {
45 |       deleter_->destroy();
46 |       delete deleter_;
47 |     }
48 |     // カスタム削除子が指定されていなかったらdelete
49 |     else {
50 |       delete object_;
51 |     }
52 |   }
53 | 
54 |   T* operator->() const { return object_; }
55 | };
56 | 
57 | #include <iostream>
58 | 
59 | using namespace std;
60 | 
61 | struct hoge {
62 |   hoge() { cout << "コンストラクタ" << endl; }
63 |   ~hoge() { cout << "デストラクタ" << endl; }
64 |   void something() const { cout << "何かする" << endl; }
65 | };
66 | 
67 | void delete_hoge(hoge* p)
68 | {
69 |   delete p;
70 |   cout << "削除子を使用して解放" << endl;
71 | }
72 | 
73 | void foo()
74 | {
75 |   shared_ptr<hoge> p(new hoge(), &delete_hoge);
76 |   p->something();
77 | }
78 | 
79 | int main()
80 | {
81 |   foo();
82 | }
83 | 


--------------------------------------------------------------------------------
/08_type_erasure/04_any_implementation.cpp:
--------------------------------------------------------------------------------
 1 | // Copyright (c) 2014
 2 | // Akira Takahashi, Fumiki Fukuda.
 3 | // Released under the CC0 1.0 Universal license.
 4 | 
 5 | #include <typeinfo>
 6 | 
 7 | class any {
 8 |   struct holder_base {
 9 |     virtual ~holder_base() {}
10 |     virtual holder_base* clone() const = 0;
11 |     virtual const std::type_info& type() const = 0;
12 |   };
13 | 
14 |   template <class T>
15 |   struct holder : public holder_base {
16 |     T value_;
17 | 
18 |     holder(const T& value)
19 |       : value_(value) {}
20 |     
21 |     virtual holder_base* clone() const
22 |     {
23 |       return new holder(value_);
24 |     }
25 | 
26 |     virtual const std::type_info& type() const
27 |     {
28 |       return typeid(T);
29 |     }
30 |   };
31 | 
32 | public:
33 |   template <class T>
34 |   any(const T& value)
35 |     : content_(new holder<T>(value)) {}
36 | 
37 |   any(const any& other)
38 |     : content_(other.content_ ? other.content_->clone() : 0) {}
39 | 
40 |   ~any()
41 |   {
42 |     delete content_;
43 |   }
44 | 
45 |   template <class T>
46 |   any& operator=(const T& value)
47 |   {
48 |     delete content_;
49 |     content_ = new holder<T>(value);
50 |     return *this;
51 |   }
52 | 
53 |   any& operator=(const any& other)
54 |   {
55 |     delete content_;
56 |     content_ = other.content_ ? other.content_->clone() : 0;
57 |     return *this;
58 |   }
59 | 
60 |   const std::type_info& type() const
61 |   {
62 |     return content_ ? content_->type() : typeid(void);
63 |   }
64 | 
65 |   template <class T>
66 |   const T& cast() const
67 |   {
68 |     return dynamic_cast<holder<T>&>(*content_).value_;
69 |   }
70 | 
71 | private:
72 |   holder_base* content_;
73 | };
74 | 
75 | struct hoge {};
76 | 
77 | int main()
78 | {
79 |   any val = 3;
80 |   val = hoge();
81 |   if (val.type() == typeid(int)) {
82 |     int value = val.cast<int>();
83 |   }
84 |   else if (val.type() == typeid(hoge)) {
85 |     hoge h = val.cast<hoge>();
86 |   }
87 | }
88 | 


--------------------------------------------------------------------------------
/08_type_erasure/05_1st_step_function_implementation.cpp:
--------------------------------------------------------------------------------
  1 | // Copyright (c) 2014
  2 | // Akira Takahashi, Fumiki Fukuda.
  3 | // Released under the CC0 1.0 Universal license.
  4 | 
  5 | union any_pointer {
  6 |   void (*func_ptr)(); // 関数ポインタ
  7 |   void* obj_ptr;      // 関数オブジェクト
  8 | };
  9 | 
 10 | template <class Func, class R>
 11 | struct function_ptr_manager {
 12 |   static R invoke(any_pointer function_ptr)
 13 |   {
 14 |     Func func = reinterpret_cast<Func>(function_ptr.func_ptr);
 15 |     return func();
 16 |   }
 17 | 
 18 |   static void destroy(any_pointer) {}
 19 | };
 20 | 
 21 | template <class Func, class R>
 22 | struct function_obj_manager {
 23 |   static R invoke(any_pointer func_obj)
 24 |   {
 25 |     Func* func = reinterpret_cast<Func*>(func_obj.obj_ptr);
 26 |     return (*func)();
 27 |   }
 28 | 
 29 |   static void destroy(any_pointer function_obj_ptr)
 30 |   {
 31 |     Func* func =
 32 |       reinterpret_cast<Func*>(function_obj_ptr.obj_ptr);
 33 |     delete func;
 34 |   }
 35 | };
 36 | 
 37 | template <class Signature>
 38 | class function;
 39 | 
 40 | template <class R>
 41 | class function<R()> {
 42 |   R (*invoke_)(any_pointer);
 43 |   void (*destroy_)(any_pointer);
 44 |   any_pointer functor_;
 45 | public:
 46 |   function()
 47 |     : invoke_(0), destroy_(0) {}
 48 | 
 49 |   ~function()
 50 |   {
 51 |     clear();
 52 |   }
 53 | 
 54 |   template <class Func>
 55 |   void set_function_ptr(Func func_ptr)
 56 |   {
 57 |     clear();
 58 |     invoke_ = &function_ptr_manager<Func, R>::invoke;
 59 |     destroy_ = &function_ptr_manager<Func, R>::destroy;
 60 |     functor_.func_ptr = reinterpret_cast<void(*)()>(func_ptr);
 61 |   }
 62 | 
 63 |   template <class Func>
 64 |   void set_function_obj(Func func_obj)
 65 |   {
 66 |     clear();
 67 |     invoke_ = &function_obj_manager<Func, R>::invoke;
 68 |     destroy_ = &function_obj_manager<Func, R>::destroy;
 69 |     functor_.obj_ptr =
 70 |       reinterpret_cast<void*>(new Func(func_obj));
 71 |   }
 72 | 
 73 |   R operator()()
 74 |   {
 75 |     return invoke_(functor_);
 76 |   }
 77 | 
 78 | private:
 79 |   void clear()
 80 |   {
 81 |     if (destroy_)
 82 |       destroy_(functor_);
 83 |     destroy_ = 0;
 84 |   }
 85 | };
 86 | 
 87 | int func()
 88 | {
 89 |   return 3;
 90 | }
 91 | 
 92 | struct functor {
 93 |   int operator()() const
 94 |   {
 95 |     return 4;
 96 |   }
 97 | };
 98 | 
 99 | int main()
100 | {
101 |   function<int()> f;
102 | 
103 |   // 関数ポインタ
104 |   f.set_function_ptr(&func);
105 |   int func_result    = f(); // 3
106 | 
107 |   // 関数オブジェクト
108 |   f.set_function_obj(functor());
109 |   int functor_result = f(); // 4
110 | }
111 | 


--------------------------------------------------------------------------------
/08_type_erasure/06_2nd_step_function_implementation.cpp:
--------------------------------------------------------------------------------
  1 | // Copyright (c) 2014
  2 | // Akira Takahashi, Fumiki Fukuda.
  3 | // Released under the CC0 1.0 Universal license.
  4 | 
  5 | #include <boost/mpl/if.hpp>
  6 | #include <boost/type_traits/is_pointer.hpp>
  7 | 
  8 | using boost::mpl::if_;
  9 | using boost::is_pointer;
 10 | 
 11 | union any_pointer {
 12 |   void (*func_ptr)(); // 関数ポインタ
 13 |   void* obj_ptr;      // 関数オブジェクト
 14 | };
 15 | 
 16 | template <class Func, class R>
 17 | struct function_ptr_manager {
 18 |   static R invoke(any_pointer function_ptr)
 19 |   {
 20 |     Func func = reinterpret_cast<Func>(function_ptr.func_ptr);
 21 |     return func();
 22 |   }
 23 | 
 24 |   static void destroy(any_pointer) {}
 25 | };
 26 | 
 27 | template <class Func, class R>
 28 | struct function_obj_manager {
 29 |   static R invoke(any_pointer func_obj)
 30 |   {
 31 |     Func* func = reinterpret_cast<Func*>(func_obj.obj_ptr);
 32 |     return (*func)();
 33 |   }
 34 | 
 35 |   static void destroy(any_pointer function_obj_ptr)
 36 |   {
 37 |     Func* func =
 38 |       reinterpret_cast<Func*>(function_obj_ptr.obj_ptr);
 39 |     delete func;
 40 |   }
 41 | };
 42 | 
 43 | struct function_ptr_tag {}; // 関数ポインタ
 44 | struct function_obj_tag {}; // 関数オブジェクト
 45 | 
 46 | template <class Func>
 47 | struct get_function_tag {
 48 |   typedef typename if_<is_pointer<Func>,
 49 |     function_ptr_tag,
 50 |     function_obj_tag>
 51 |   ::type type;
 52 | };
 53 | 
 54 | template <class Signature>
 55 | class function;
 56 | 
 57 | template <class R>
 58 | class function<R()> {
 59 |   R (*invoke_)(any_pointer);
 60 |   void (*destroy_)(any_pointer);
 61 |   any_pointer functor_;
 62 | public:
 63 |   function()
 64 |     : invoke_(0), destroy_(0) {}
 65 | 
 66 |   ~function()
 67 |   {
 68 |     clear();
 69 |   }
 70 | 
 71 |   template <class Func>
 72 |   function& operator=(Func func)
 73 |   {
 74 |     typedef typename get_function_tag<Func>::type func_tag;
 75 |     assign_to(func, func_tag());
 76 |     return *this;
 77 |   }
 78 | 
 79 |   R operator()()
 80 |   {
 81 |     return invoke_(functor_);
 82 |   }
 83 | 
 84 | private:
 85 |   // set_function_ptr()をassign_to()に名前変更して第2パラメータ追加
 86 |   template <class FuncPtr>
 87 |   void assign_to(FuncPtr func_ptr, function_ptr_tag)
 88 |   {
 89 |     clear();
 90 |     invoke_ = &function_ptr_manager<FuncPtr, R>::invoke;
 91 |     destroy_ = &function_ptr_manager<FuncPtr, R>::destroy;
 92 |     functor_.func_ptr = reinterpret_cast<void(*)()>(func_ptr);
 93 |   }
 94 | 
 95 |   // set_function_obj()をassign_to()に名前変更して第2パラメータ追加
 96 |   template <class FuncObj>
 97 |   void assign_to(FuncObj func_obj, function_obj_tag)
 98 |   {
 99 |     clear();
100 |     invoke_ = &function_obj_manager<FuncObj, R>::invoke;
101 |     destroy_ = &function_obj_manager<FuncObj, R>::destroy;
102 |     functor_.obj_ptr =
103 |       reinterpret_cast<void*>(new FuncObj(func_obj));
104 |   }
105 | 
106 |   void clear()
107 |   {
108 |     if (destroy_)
109 |       destroy_(functor_);
110 |     destroy_ = 0;
111 |   }
112 | };
113 | 
114 | int func()
115 | {
116 |   return 3;
117 | }
118 | 
119 | struct functor {
120 |   int operator()() const
121 |   {
122 |     return 4;
123 |   }
124 | };
125 | 
126 | int main()
127 | {
128 |   function<int()> f;
129 | 
130 |   // 関数ポインタ
131 |   f = &func;
132 |   int func_result    = f(); // 3
133 | 
134 |   // 関数オブジェクト
135 |   f = functor();
136 |   int functor_result = f(); // 4
137 | }
138 | 


--------------------------------------------------------------------------------
/08_type_erasure/07_simple_type_erasure.cpp:
--------------------------------------------------------------------------------
 1 | // Copyright (c) 2014
 2 | // Akira Takahashi, Fumiki Fukuda.
 3 | // Released under the CC0 1.0 Universal license.
 4 | 
 5 | #include <iostream>
 6 | #include <boost/function.hpp>
 7 | 
 8 | using std::cout;
 9 | using std::endl;
10 | using boost::function;
11 | 
12 | class drawable {
13 |   function<void()> draw_func_;
14 | public:
15 |   drawable() {}
16 | 
17 |   template <class T>
18 |   drawable(T& obj)
19 |     : draw_func_([&obj] { obj.draw(); }) {}
20 | 
21 |   template <class T>
22 |   drawable& operator=(T& obj)
23 |   {
24 |     draw_func_ = [&obj] { obj.draw(); };
25 |     return *this;
26 |   }
27 | 
28 |   void draw() const
29 |   {
30 |     draw_func_();
31 |   }
32 | };
33 | 
34 | struct circle {
35 |   void draw() const
36 |   {
37 |     cout << "円を描画する" << endl;
38 |   }
39 | };
40 | 
41 | struct square {
42 |   void draw() const
43 |   {
44 |     cout << "四角形を描画する" << endl;
45 |   }
46 | };
47 | 
48 | int main()
49 | {
50 |   drawable a;
51 | 
52 |   circle c;
53 |   a = c;
54 |   a.draw();
55 | 
56 |   square s;
57 |   a = s;
58 |   a.draw();
59 | }
60 | 


--------------------------------------------------------------------------------
/09_crtp/01_basic_crtp.cpp:
--------------------------------------------------------------------------------
 1 | // Copyright (c) 2014
 2 | // Akira Takahashi, Fumiki Fukuda.
 3 | // Released under the CC0 1.0 Universal license.
 4 | 
 5 | #include <iostream>
 6 | 
 7 | template <class Derived>
 8 | struct base {
 9 |   void base_foo() const
10 |   {
11 |     static_cast<const Derived&>(*this).foo();
12 |   }
13 | };
14 | 
15 | struct derived : public base<derived> {
16 |   void foo() const
17 |   {
18 |     std::cout << "foo" << std::endl;
19 |   }
20 | };
21 | 
22 | int main()
23 | {
24 |   derived d;
25 |   d.base_foo(); // foo
26 | }
27 | 


--------------------------------------------------------------------------------
/09_crtp/02_equal_comparable.cpp:
--------------------------------------------------------------------------------
 1 | // Copyright (c) 2014
 2 | // Akira Takahashi, Fumiki Fukuda.
 3 | // Released under the CC0 1.0 Universal license.
 4 | 
 5 | template <class T>
 6 | class equal_comparable {
 7 |   // T クラスのoperator==を使ってoperator!=を定義
 8 |   friend bool operator!=(const T& lhs, const T& rhs)
 9 |     { return !lhs.operator==(rhs); }
10 | };
11 | 
12 | class hoge : private equal_comparable<hoge> {
13 |   int id_;
14 | public:
15 |   explicit hoge(int id) : id_(id) {}
16 | 
17 |   bool operator==(const hoge& rhs) const
18 |     { return id_ == rhs.id_; }
19 | };
20 | 
21 | int main()
22 | {
23 |   hoge h1(1);
24 |   hoge h2(2);
25 |   
26 |   bool is_equal     = h1 == h2;
27 |   bool is_not_equal = h1 != h2;
28 | }
29 | 


--------------------------------------------------------------------------------
/09_crtp/03_less_than_comparable.cpp:
--------------------------------------------------------------------------------
 1 | // Copyright (c) 2014
 2 | // Akira Takahashi, Fumiki Fukuda.
 3 | // Released under the CC0 1.0 Universal license.
 4 | 
 5 | template <class T>
 6 | struct less_than_comparable {
 7 |   friend bool operator>(const T& lhs, const T& rhs)
 8 |   {
 9 |     return rhs.operator<(lhs);
10 |   }
11 | 
12 |   friend bool operator<=(const T& lhs, const T& rhs)
13 |   {
14 |     return !rhs.operator<(lhs);
15 |   }
16 | 
17 |   friend bool operator>=(const T& lhs, const T& rhs)
18 |   {
19 |     return !lhs.operator<(rhs);
20 |   }
21 | };
22 | 
23 | class hoge : private less_than_comparable<hoge> {
24 |   int id_;
25 | public:
26 |   hoge(int id) : id_(id) {}
27 | 
28 |   bool operator<(const hoge& rhs) const
29 |   {
30 |     return id_ < rhs.id_;
31 |   }
32 | };
33 | 
34 | int main()
35 | {
36 |   hoge h1(1);
37 |   hoge h2(2);
38 |   bool is_less             = h1 < h2;
39 |   bool is_greater          = h1 > h2;
40 |   bool is_less_or_equal    = h1 <= h2;
41 |   bool is_greater_or_equal = h1 >= h2;
42 | }
43 | 


--------------------------------------------------------------------------------
/09_crtp/04_enable_shared_from_this.cpp:
--------------------------------------------------------------------------------
 1 | // Copyright (c) 2014
 2 | // Akira Takahashi, Fumiki Fukuda.
 3 | // Released under the CC0 1.0 Universal license.
 4 | 
 5 | #include <iostream>
 6 | #include <boost/shared_ptr.hpp>
 7 | #include <boost/weak_ptr.hpp>
 8 | 
 9 | template <class T>
10 | class my_enable_shared_from_this {
11 |   boost::weak_ptr<T> weak_this_;
12 | public:
13 |   boost::shared_ptr<T> shared_from_this()
14 |   {
15 |     boost::shared_ptr<T> p(weak_this_);
16 |     return p;
17 |   }
18 | 
19 |   void setup_shared_from_this(const boost::shared_ptr<T>& p)
20 |   {
21 |     if (weak_this_.expired()) {
22 |       weak_this_ = p;
23 |     }
24 |   }
25 | };
26 | 
27 | template <class T>
28 | void print_share(boost::shared_ptr<T> p)
29 | {
30 |   p->print();
31 | }
32 | 
33 | class X : public my_enable_shared_from_this<X> {
34 | public:
35 |   void f()
36 |   {
37 |     print_share(shared_from_this());
38 |   }
39 | 
40 |   void print()
41 |   {
42 |     std::cout << "X" << std::endl;
43 |   }
44 | };
45 | 
46 | int main()
47 | {
48 |   boost::shared_ptr<X> p(new X());
49 |   p->setup_shared_from_this(p);
50 | 
51 |   p->f();
52 | }
53 | 


--------------------------------------------------------------------------------
/10_template_conversion_operator/01_operator_bool.cpp:
--------------------------------------------------------------------------------
 1 | // Copyright (c) 2014
 2 | // Akira Takahashi, Fumiki Fukuda.
 3 | // Released under the CC0 1.0 Universal license.
 4 | 
 5 | struct integer {
 6 |   int data_;
 7 | public:
 8 |   integer(int data = 0)
 9 |     : data_(data) {}
10 | 
11 |   operator bool() const
12 |   {
13 |     return false;
14 |   }
15 | };
16 | 
17 | int main()
18 | {
19 |   if      (integer n1 = 1) {}
20 |   else if (integer n2 = 2) {}
21 |   else if (integer n3 = 3) {}
22 |   else {
23 |     n1;
24 |     n2;
25 |     n3;
26 |   }
27 | }
28 | 


--------------------------------------------------------------------------------
/10_template_conversion_operator/02_for_each_macro.cpp:
--------------------------------------------------------------------------------
 1 | // Copyright (c) 2014
 2 | // Akira Takahashi, Fumiki Fukuda.
 3 | // Released under the CC0 1.0 Universal license.
 4 | 
 5 | #include <vector>
 6 | #include <iostream>
 7 | 
 8 | class iterator_holder {
 9 |   typedef std::vector<int>::iterator value_type;
10 |   value_type iter_;
11 | public:
12 |   iterator_holder(value_type iter) : iter_(iter) {}
13 | 
14 |   value_type& get() { return iter_; }
15 | 
16 |   operator bool() const
17 |   {
18 |     return false;
19 |   }
20 | };
21 | 
22 | #define FOR_EACH(Value, Container) \
23 |   if      (iterator_holder begin_ = std::begin(Container)) {} \
24 |   else if (iterator_holder end_   = std::end(Container)) {} \
25 |   else for (bool continue_ = true; \
26 |             begin_.get() != end_.get(); \
27 |             ++begin_.get()) \
28 |     if ((continue_ = false) == true) {} \
29 |     else for (Value = *begin_.get(); \
30 |               continue_ == false; \
31 |               continue_ = true)
32 | 
33 | int main()
34 | {
35 |   std::vector<int> v = {1, 2, 3};
36 | 
37 |   FOR_EACH (int item, v) {
38 |     std::cout << item << std::endl;
39 |   } // 1, 2, 3 が順に出力される
40 | }
41 | 


--------------------------------------------------------------------------------
/10_template_conversion_operator/03_result_type_overload.cpp:
--------------------------------------------------------------------------------
 1 | // Copyright (c) 2014
 2 | // Akira Takahashi, Fumiki Fukuda.
 3 | // Released under the CC0 1.0 Universal license.
 4 | 
 5 | #include <iostream>
 6 | 
 7 | using namespace std;
 8 | 
 9 | struct A {};
10 | struct B {};
11 | 
12 | A foo_a() { cout << "call A" << endl; return A(); }
13 | B foo_b() { cout << "call B" << endl; return B(); }
14 | 
15 | struct X {
16 |   operator A() const { return foo_a(); }
17 |   operator B() const { return foo_b(); }
18 | };
19 | 
20 | int main()
21 | {
22 |   X x;
23 |   static_cast<A>(x); // call A
24 |   static_cast<B>(x); // call B
25 | }
26 | 


--------------------------------------------------------------------------------
/10_template_conversion_operator/04_template_convertion_operator.cpp:
--------------------------------------------------------------------------------
 1 | // Copyright (c) 2014
 2 | // Akira Takahashi, Fumiki Fukuda.
 3 | // Released under the CC0 1.0 Universal license.
 4 | 
 5 | class integer {
 6 |   int data_;
 7 | public:
 8 |   integer(int data)
 9 |     : data_(data) {}
10 | 
11 |   template <class T>
12 |   operator T() const
13 |   {
14 |     return data_;
15 |   }
16 | };
17 | 
18 | int main()
19 | {
20 |   integer value = 3;
21 | 
22 |   int    n = value; // value.operator int()
23 |   double d = value; // value.operator double()
24 |   char   c = value; // value.operator char()
25 | }
26 | 


--------------------------------------------------------------------------------
/10_template_conversion_operator/05_container_holder.cpp:
--------------------------------------------------------------------------------
 1 | // Copyright (c) 2014
 2 | // Akira Takahashi, Fumiki Fukuda.
 3 | // Released under the CC0 1.0 Universal license.
 4 | 
 5 | #include <vector>
 6 | #include <list>
 7 | #include <deque>
 8 | 
 9 | using namespace std;
10 | 
11 | template <class ValueType>
12 | class container_holder {
13 |   std::vector<ValueType> vec_;
14 | public:
15 |   void push_back(const ValueType& value)
16 |   {
17 |     vec_.push_back(value);
18 |   }
19 | 
20 |   template <class T>
21 |   operator T() const
22 |   {
23 |     return T(std::begin(vec_), std::end(vec_));
24 |   }
25 | };
26 | 
27 | int main()
28 | {
29 |   container_holder<int> c;
30 | 
31 |   c.push_back(1);
32 |   c.push_back(2);
33 |   c.push_back(3);
34 | 
35 |   // container_holderから標準コンテナへの変換
36 |   std::vector<int> v  = c; // OK
37 |   std::list<int>   ls = c; // OK
38 |   std::deque<int>  d  = c; // OK
39 | }
40 | 


--------------------------------------------------------------------------------
/10_template_conversion_operator/06_auto_deduction_lexical_cast.cpp:
--------------------------------------------------------------------------------
 1 | // Copyright (c) 2014
 2 | // Akira Takahashi, Fumiki Fukuda.
 3 | // Released under the CC0 1.0 Universal license.
 4 | 
 5 | #include <string>
 6 | #include <sstream>
 7 | 
 8 | template <class To, class From>
 9 | To lexical_cast(From from)
10 | {
11 |   To result;
12 |   std::stringstream ss;
13 | 
14 |   ss << from;
15 |   ss >> result;
16 | 
17 |   return result;
18 | }
19 | 
20 | template <class From>
21 | class lexical_cast_t {
22 |   From from_;
23 | public:
24 |   lexical_cast_t(From from)
25 |     : from_(from) {}
26 | 
27 |   template <class To>
28 |   operator To() const
29 |   {
30 |     return lexical_cast<To>(from_);
31 |   }
32 | };
33 | 
34 | template <class From>
35 | lexical_cast_t<From> lexical(From from)
36 | {
37 |   return lexical_cast_t<From>(from);
38 | }
39 | 
40 | int main()
41 | {
42 |   int         n = lexical("3"); // 文字列型を整数型に変換
43 |   std::string s = lexical(314); // 整数型を文字列型に変換
44 | }
45 | 


--------------------------------------------------------------------------------
/11_expression_template/01_plus_expression.cpp:
--------------------------------------------------------------------------------
 1 | // Copyright (c) 2014
 2 | // Akira Takahashi, Fumiki Fukuda.
 3 | // Released under the CC0 1.0 Universal license.
 4 | 
 5 | #include <cstddef>
 6 | 
 7 | template <class L, class R>
 8 | class plus {
 9 |   const L& l_;
10 |   const R& r_;
11 | public:
12 |   plus(const L& l, const R& r)
13 |     : l_(l), r_(r) {}
14 | 
15 |   float operator[](size_t i) const
16 |   {
17 |     return l_[i] + r_[i];
18 |   }
19 | };
20 | 
21 | namespace math {
22 |   class vector {
23 |   public:
24 |     static const int N = 3; // 次元数
25 | 
26 |     vector()
27 |     {
28 |       for (size_t i = 0; i < N; ++i) {
29 |         values_[i] = 0;
30 |       }
31 |     }
32 | 
33 |     vector(const vector& rhs)
34 |     {
35 |       for (size_t i = 0; i < N; ++i) {
36 |         values_[i] = rhs[i];
37 |       }
38 |     }
39 | 
40 |     template <class E>
41 |     vector& operator=(const E& rhs)
42 |     {
43 |       for (size_t i = 0; i < N; ++i) {
44 |         values_[i] = rhs[i];
45 |       }
46 |       return *this;
47 |     }
48 | 
49 |     float& operator[](size_t i)       { return values_[i]; }
50 |     float  operator[](size_t i) const { return values_[i]; }
51 | 
52 |   private:
53 |     float values_[N];
54 |   };
55 | 
56 |   template <class L, class R>
57 |   plus<L, R> operator+(const L& lhs, const R& rhs)
58 |   {
59 |     return plus<L, R>(lhs, rhs);
60 |   }
61 | } // namespace math
62 | 
63 | int main()
64 | {
65 |   math::vector x, y, z, t;
66 |   t = x + y + z;
67 | }
68 | 


--------------------------------------------------------------------------------
/11_expression_template/02_multiply_expression.cpp:
--------------------------------------------------------------------------------
 1 | // Copyright (c) 2014
 2 | // Akira Takahashi, Fumiki Fukuda.
 3 | // Released under the CC0 1.0 Universal license.
 4 | 
 5 | #include <cstddef>
 6 | 
 7 | template <class L, class R>
 8 | class plus {
 9 |   const L& l_;
10 |   const R& r_;
11 | public:
12 |   plus(const L& l, const R& r)
13 |     : l_(l), r_(r) {}
14 | 
15 |   float operator[](size_t i) const
16 |   {
17 |     return l_[i] + r_[i];
18 |   }
19 | };
20 | 
21 | template <class L, class R>
22 | class multiply {
23 |   const L& l_;
24 |   const R& r_;
25 | public:
26 |   multiply(const L& l, const R& r)
27 |     : l_(l), r_(r) {}
28 | 
29 |   float operator[](size_t i) const
30 |   {
31 |     return l_[i] * r_[i];
32 |   }
33 | };
34 | 
35 | namespace math {
36 |   class vector {
37 |   public:
38 |     static const int N = 3; // 次元数
39 | 
40 |     vector()
41 |     {
42 |       for (size_t i = 0; i < N; ++i) {
43 |         values_[i] = 0;
44 |       }
45 |     }
46 | 
47 |     vector(const vector& rhs)
48 |     {
49 |       for (size_t i = 0; i < N; ++i) {
50 |         values_[i] = rhs[i];
51 |       }
52 |     }
53 | 
54 |     template <class E>
55 |     vector& operator=(const E& rhs)
56 |     {
57 |       for (size_t i = 0; i < N; ++i) {
58 |         values_[i] = rhs[i];
59 |       }
60 |       return *this;
61 |     }
62 | 
63 |     float& operator[](size_t i)       { return values_[i]; }
64 |     float  operator[](size_t i) const { return values_[i]; }
65 | 
66 |   private:
67 |     float values_[N];
68 |   };
69 | 
70 |   template <class L, class R>
71 |   plus<L, R> operator+(const L& lhs, const R& rhs)
72 |   {
73 |     return plus<L, R>(lhs, rhs);
74 |   }
75 | 
76 |   template <class L, class R>
77 |   multiply<L, R> operator*(const L& lhs, const R& rhs)
78 |   {
79 |     return multiply<L, R>(lhs, rhs);
80 |   }
81 | } // namespace math
82 | 
83 | int main()
84 | {
85 |   math::vector x, y, z, t;
86 |   t = x + y * z;
87 | }
88 | 


--------------------------------------------------------------------------------
/11_expression_template/03_expression_design.cpp:
--------------------------------------------------------------------------------
 1 | // Copyright (c) 2014
 2 | // Akira Takahashi, Fumiki Fukuda.
 3 | // Released under the CC0 1.0 Universal license.
 4 | 
 5 | #include <cstddef>
 6 | 
 7 | template <class L, class Op, class R>
 8 | class expression {
 9 |   const L& l_;
10 |   const R& r_;
11 | public:
12 |   expression(const L& l, const R& r)
13 |     : l_(l), r_(r) {}
14 | 
15 |   float operator[](size_t i) const
16 |   {
17 |     return Op::apply(l_[i], r_[i]);
18 |   }
19 | };
20 | 
21 | struct plus {
22 |   static float apply(float l, float r)
23 |   {
24 |     return l + r;
25 |   }
26 | };
27 | 
28 | struct multiply {
29 |   static float apply(float l, float r)
30 |   {
31 |     return l * r;
32 |   }
33 | };
34 | 
35 | namespace math {
36 |   class vector {
37 |   public:
38 |     static const int N = 3; // 次元数
39 | 
40 |     vector()
41 |     {
42 |       for (size_t i = 0; i < N; ++i) {
43 |         values_[i] = 0;
44 |       }
45 |     }
46 | 
47 |     vector(const vector& rhs)
48 |     {
49 |       for (size_t i = 0; i < N; ++i) {
50 |         values_[i] = rhs[i];
51 |       }
52 |     }
53 | 
54 |     template <class E>
55 |     vector& operator=(const E& rhs)
56 |     {
57 |       for (size_t i = 0; i < N; ++i) {
58 |         values_[i] = rhs[i];
59 |       }
60 |       return *this;
61 |     }
62 | 
63 |     float& operator[](size_t i)       { return values_[i]; }
64 |     float  operator[](size_t i) const { return values_[i]; }
65 | 
66 |   private:
67 |     float values_[N];
68 |   };
69 | 
70 |   template <class L, class R>
71 |   expression<L, plus, R> operator+(const L& lhs, const R& rhs)
72 |   {
73 |     return expression<L, plus, R>(lhs, rhs);
74 |   }
75 |   
76 |   template <class L, class R>
77 |   expression<L, multiply, R> operator*(const L& lhs, const R& rhs)
78 |   {
79 |     return expression<L, multiply, R>(lhs, rhs);
80 |   }
81 | } // namespace math
82 | 
83 | int main()
84 | {
85 |   math::vector x, y, z, t;
86 |   t = x + y * z;
87 | }
88 | 


--------------------------------------------------------------------------------
/README.md:
--------------------------------------------------------------------------------
 1 | # C++テンプレートテクニック
 2 | このリポジトリでは、書籍『C++テンプレートテクニック 第2版』に掲載しているサンプルコードを公開しています。
 3 | 
 4 | ## 著者
 5 | 
 6 | - 高橋 晶([faithandbrave](https://github.com/faithandbrave/))
 7 | - επιστημη
 8 | 
 9 | 
10 | ## 書籍情報
11 | 
12 | - [SBクリエイティブ](http://www.sbcr.jp/products/4797376685.html)
13 | - [Amazon.co.jp](http://www.amazon.co.jp/dp/4797376686?tag=faithandbrave-22&camp=243&creative=1615&linkCode=as1&creativeASIN=4797376686&adid=00XFBST2NCRTDZ1DS8X2&&ref-refURL=http%3A%2F%2Ffaithandbrave.hateblo.jp%2F)
14 | 
15 | 
16 | ## ライセンス
17 | 本リポジトリのサンプルコードは、[Creative CommonsのCC0ライセンス](https://creativecommons.org/publicdomain/zero/1.0/deed.ja)の元、提供しています。
18 | 
19 | 


--------------------------------------------------------------------------------