CppTemplateTutorial/CppTemplateTutorial.cpp at master · bigvaliant/CppTemplateTutorial

760 lines (628 loc) · 12.4 KB
#include "stdafx.h"
#include <vector>
#define WRONG_CODE_ENABLED 1
// 0. Basic Form
namespace _0
	template <typename T> // Old fasion: template <class T>
	class ClassA
		void foo2(T const&);
	template <int Sz>
	class ClassB
		int arr[Sz];
	size_t a = sizeof(ClassB<3>);
	size_t b = sizeof(ClassB<7>);
	template <typename T> void FunctionA(T const& param)
	template <typename T> T FunctionB()
		return T();
// 1.1 Nested in Class
namespace _1_1
	template <typename T> // Old fasion: template <class T>
	class ClassA
		template <typename U> void foo2(T const&, U const&);
// 1.2 Instanciating 1
namespace _1_2
	_1_1::ClassA<int>				a;
	#if WRONG_CODE_ENABLED
	_1_1::ClassA<WhatTheFuck>		b;	// Wrong
	_1_1::ClassA					c;	// Wrong
namespace _1_2_2
	template <typename T> T Add(T a, T b)
		return a + b;
	template <typename SrcT, typename DstT> DstT c_style_cast(SrcT v)
		return (DstT)(v);
#if WRONG_CODE_ENABLED
	void foo()
		int  a = 0;
		int  b = 0;
		char c = 0;
		Add(b, c);
	void foo2()
		int v = 0;
		float i = c_style_cast<float>(v);
// 1.3 Instanciating 2
namespace _1_3
	template <typename T>
	class ClassB
	template <typename T>
	class ClassC
	struct StructA; // Declared but not be defined
	ClassB<StructA> d;	// Right
#if WRONG_CODE_ENABLED
	ClassC<StructA> e;	// Wrong
// 1.4 Specialization, Partial Specialization, Full Specialization
namespace _1_4
	// Prototype of Templates I: Single Parameter
	template <typename T> class ClassD
	// Specialization: Write a pattern for matching
	template <> class ClassD<int>			// 1. template <>			2. ClassD<int>
	template <> class ClassD<float>
	// Partial-Specialization: A partial pattern for matching
	template <typename T> class ClassD<T*>	// 1. template <typename T>	2. ClassD<T*>
	template <> class ClassD<int*>			// 1. template <>			2. ClassD<T*>
	// Question:
	// ClassD<int>::?
	// ClassD<float>::?
	// ClassD<double>::?
	// ClassD<double*>::?
	// ClassD<int*>::?
	// ClassD<int const*>::?
	// Prototype of Templates II: Multiple Parameter
	template <typename T, typename U> class ClassE
	template <typename T, typename U> class ClassE<T, U*>
	template <typename T> class ClassE<T, int>
	template <typename T> class ClassE<T, int*>
	template <typename U> class ClassE<int, U>
	template <> class ClassE<int, int>
	// Question:
	// ClassE<float, double>::?
	// ClassE<float, int>::?
	// ClassE<int, float>::?
	// ClassE<int, int*>::?
	// ClassE<int, int>::?
	// Member function specialization
	template <typename T>
	class ClassF
		void foo();
	template <typename T>
	void ClassF<T>::foo()
	template <> 
	void ClassF<int>::foo()
	void foo()
		ClassF<int>().foo();
		ClassF<float>().foo();
// 2.1 Function Specialization
namespace _2_1
	// Overload is enabled but no partial-specialization
	template <typename T> void foo(T const& x) {}
	template <typename T> void foo(T& y) {}
	void foo(int&) {}
	void foo(int) {}
	// Specialization or Overloading
	template <> void foo<bool>(bool const& x) {}
	// Overloading
	template <typename T> void foo(T const*) {}
	template <typename T, typename U> void foo2(T const&, U const&);
#if WRONG_CODE_ENABLED
	template <typename U> void foo2<int, U>(int const&, U const&);
	template <typename T, typename U> void foo2<T, U>(int const&, U const&);
	// Overloading - Looks like partial specification
	template <typename U> void foo2(int const&, U const&);
	template <typename T, typename U> void foo2(T const*, U const&);
	// Don't forgot
	// T foo(...);
	// Specialize types which cannot be inferred by parameter
	template <typename UninferableT, typename InferableT>
	UninferableT foo3(InferableT const&) { return UninferableT(); }
	void test()
		int x = 5;
		float y = 10.0f;
		int const z = 5;
		foo(true);
		foo3<int>(0.0f);	// Specialize types which is uninferable.
#if WRONG_CODE_ENABLED
		foo(3);	// Ambigous
		foo(x); // Ambigous
// 2.2 Example: Derived from template.
namespace _2_2
	template <typename T>
	class ClassA
	template <typename T>
	class ClassB
	template <typename T>
	class ClassC: public ClassB<T>
	ClassC<int> a;
#if WRONG_CODE_ENABLED
	class ClassC: public ClassA<ClassC>
	class ClassD: public ClassB<ClassD>
	// ClassC =??= ClassD
// 3.1 Meta Switch-Case/If-Then-Else via Specialization
namespace _3_1
	bool equal(int a, int b)
		return a == b;
	// meta functions:
	// bool equal0(TypeA, TypeB)
	//		return false;
	// bool equal1(TypeA, TypeA)
	//		return true;
	// equal(A, A) == equal1(A, A) == true
	// euqla(A, B) == equal0(A, B) == false
	template <typename T, typename U>
	class Equal
		static bool const value = false;
	template <typename T>
	class Equal<T, T>
		static bool const value = true;
	bool x = Equal<int, float>::value;
	bool y = Equal<int, int>::value;
// 3.2 SFINAE: Substitution Failure Is Not An Error.
namespace _3_2
	class ClassA
	template <int Sz> struct Mark
		char _[Sz];
#if	WRONG_CODE_ENABLED
	template <typename T>
	Mark<1> TestIncrementAdd(T const& v)
		T tmp = v;
		return Mark<1>();
	template <typename T>
	Mark<2> TestIncrementAdd(T const& v)
		return Mark<2>();
	bool a = TestIncrementAdd( ClassA() ) ) == sizeof(Mark<1>);
	// Right case: From Wiki
	class ClassB
		typedef int Marker;
	template <typename T> void test(typename T::Marker) { }
	template <typename T> void test(T) { }
	void DoTest()
		test<ClassB>(10);	// Call #1.
		test<int>(10);		// Call #2. SFINAE for test(T::Marker).
// 3.3 Application: Type Traits
namespace _3_3
	template <typename T, typename U> class is_same;
	template <typename B, typename D> class is_base_of;
	// is_base_of
	// 1. B is class, D is also class.
	// 2. D* could be convert to B*
	// 3. B != D
	// Fundamentals
	typedef char Accepted;
	typedef int  Rejected;
	class D: public B
	class D2: public D
	// Type is a class
	template <typename T>
	class is_class
		// SFINAE
		template <typename U> static Accepted test( int U::* );
		template <typename U> static Rejected test(...);
		static const bool value = sizeof( test<T>(0) ) == sizeof(Accepted);
	bool a = is_class<int>::value;
	bool b = is_class<B>::value;
	// B* could be convert to D*
	template <typename Source, typename Dest>
	class Convertible
		// Not SFINAE
		static Accepted test(Dest*);
		static Rejected test(...);
		static const bool value = sizeof( test(static_cast<Source*>(NULL)) ) == sizeof(Accepted);
	bool c = Convertible<B, D>::value;
	bool d = Convertible<D, B>::value;
	bool e = Convertible<B, int>::value;
	using _3_1::Equal;
	template <typename Base, typename Derived>
	class is_base_of
		static bool const value = 
			is_class<Base>::value &&
			is_class<Derived>::value &&
			Convertible<Base, Derived>::value &&
			!Equal<Base, Derived>::value;
	bool f = is_base_of<B, D2>::value;
	bool g = is_base_of<D2, D>::value;
	bool h = is_base_of<B, int>::value;
	bool i = is_base_of<float, int>::value;
	// Questions:
	// remove_reference
	// remove_pointer
	// remove all qualifiers
// 3.4 Application: "Recursive" and Meta-Programming
namespace _3_4
	// sum a, a+1, ..., b-1, b
	int basic_algo(int a, int b)
		int result = 0;
		for (int i = a; i <= b; ++i)
			result += i;
		return result;
	// Template could not support variable
	// sum [a, b] without variable
	int recursive_algo(int a, int b)
		if (a == b)
			return b;
		return a + recursive_algo(a+1, b);
	// Translate to meta-programming
	template <int a, int b>
	class MetaSum
		static int const value = MetaSum<a+1, b>::value + a;
	template <int a>
	class MetaSum<a, a>
		static int const value = a;
	int a = MetaSum<1, 10>::value;
// 3.5 Application: Meta-Fibonacci
namespace _3_5
	template <int Index>
	class Fibonacci
		static int const value = Fibonacci<Index - 1>::value + Fibonacci<Index - 2>::value;
	template <>
	class Fibonacci<0>
		static int const value = 0;
	template <>
	class Fibonacci<1>
		static int const value = 1;
	int a = Fibonacci<8>::value;
// 4   Directive word: typename and template
namespace _4
	// typename T::type x;
	// ??? typename ???
	// typename T::template U<type> x;
	// ??? template ???
	class ClassA
		typedef int NestedType;
	class ClassB
		typedef ClassA::NestedType NestedType;
	template <typename T>
	class ClassC
#if WRONG_CODE_ENABLED
		typedef T::NestedType NestedType;
		typedef typename T::NestedType NestedType;
		typedef typename std::vector<T>::iterator iterator;
	class ClassD
		template <typename U, typename V> class NestedType;
	template <typename T>
	class ClassE
		template <typename U> class NestedType;
	template <typename T, typename U>
	class ClassF
#if WRONG_CODE_ENABLED
		typedef typename T::NestedType<U> NestedType;
		typedef typename T::template NestedType<U, int> NestedType;
		typedef typename ClassE<T>::template NestedType<U> NestedType2;
	ClassC<ClassB> a;
	ClassF<ClassD, float> b;
// 5.1 How to Construct Meta Operators
namespace _5_1
	// Expression = Value/Data Structure + Operator/Operations
	// Value in Templates:
	//	 Integral Constant (bool, char, unsigned, ...)
	//	 Type (typename)
	// 1. Trick: Constant <--> Type
	template <int i>
	class int_
		static int const value = i;
	int a = int_<5>::value;
	// This trick could work with overloading
	template <typename T>
	void Do(T* obj, int_<2>)
	template <typename T>
	void Do(T* obj, int_<1>)
	void foo()
		Do( static_cast<int*>(nullptr), int_<1>() );
	template <typename T, int i> void DoAnotherWay(T* obj)
	// Boolean is more useful than integral in general.
	template <bool v>
	class bool_
		static bool const value = v;
	typedef bool_<true>		true_;
	typedef bool_<false>	false_;
#if WRONG_CODE_ENABLED
	// Aha, function cannot support partial specialization.
	template <typename T> void DoAnotherWay<T, 1>(T* obj) {}
	template <typename T> void DoAnotherWay<T, 2>(T* obj) {}
	// 2. Operators:
	template <typename T, typename U>
	class add_
		typedef int_<T::value + U::value> type;
		static int const value = type::value;
#if WRONG_CODE_ENABLED
	// conflict
	template <int x, int y>
	class add_
		typedef int_<x+y> type;
		static int const value = type::value;
	template <int x, int y>
	class add_c
		typedef int_<x+y> type;
		static int const value = type::value;
	typedef add_< int_<2>, int_<3> >::type sum;
	int b = sum::value;
	typedef add_< int_<2>, int_<3> >::type sum_c;
	int c = sum_c::value;
	// another solution
	template <typename T, typename U>
	class add2_: public int_<T::value+U::value>
	int d = add2_< int_<2>, int_<3> >::value;
	// Other operators: sub, not, or, and ...
// 5.2 Example of Meta Programming: Meta-Vector
namespace _5_2
	// Array: elem[count]
	// Meta Array ?
	// Recursively Definition
	// 'Null' terminated
	template <typename HeadT, typename TailT>
	class pair_
		typedef HeadT head;
		typedef TailT tail;
	class Nil;
	// Try Use It to Definition
	typedef pair_< int, pair_<float, pair_<double, Nil> > > vector_3;
	template <typename T0, typename T1 = Nil, typename T2 = Nil, typename T3 = Nil>
	class make_vector_
		typedef pair_< T0, make_vector_<T1, T2, T3> > type;
	template <>
	class make_vector_<Nil, Nil, Nil, Nil>
		typedef Nil type;
	template <typename T0, typename T1 = Nil, typename T2 = Nil, typename T3 = Nil>
	class vector_: public make_vector_<T0, T1, T2, T3>::type
	typedef vector_<double, float, int> vector3;
	// Let's meta-program further
	// push_back	?	tip: push_back<Vector, Element>::type
	// pop			?
	// find			?
	// size			?
// 6.1 Template-Template Class
// 6.2 High order function, closure and STL allocator rebind
int _tmain(int argc, _TCHAR* argv[])
Provide feedback

Saved searches

Use saved searches to filter your results more quickly

FilesExpand file tree

CppTemplateTutorial.cpp

Latest commit

History

CppTemplateTutorial.cpp

File metadata and controls
