public:

TemplateTemplateParam(){}

TemplateTemplateParam(T t) : t(t) {}

T t;

public:

T t;

V v;

bool equal(){return t == v.t;}

public:

/* the template template enforces that T be used twice,

T t;

V<T> v;

bool equal(){return t == v.t;}

public:

T t;

T ts[N];

TemplateClass(){}

// BAD: what is T = string?

//TemplateClass() t(0.0){}

TemplateClass(T t): t(t){}

void method() {}

void methodDefinedOutside();

T method(T){}

// OK:

template<class C=int>

void methodTemplate() {}

static const int sci = 0;

// BAD: impossible to define?

//static const TemplateClass<T,N>;

class Nested {

public:

T t;

};

int getIPrivate(){return iPrivate;}

private:

int iPrivate;

// Multiplication, or pointer declaration??

// `HAS_I::i` is both qualified (`::`) and dependant on `HAS_I`.

// TODO check.

//HAS_I::i * i;

// Even if here it clearly cannot be a value, only a type,

// we must still help the compiler parse it with `typename`.

//

// ERROR: this could never work, since it does not have the typename specifier

// and therefore always means a value for the compiler.

//std::vector<HAS_I::i> v;

public:

template<int N>

class Nested {

public:

int method() { return N; }

};

template<int N>

static int TemplateMethod() { return N; }

assert(tq.TemplateMethod<1>() == 1);

assert(tq.template TemplateMethod<1>() == 1);

// Template keyword is only needed for arguments with dependent type.

assert(tq.TemplateMethod<1>() == 1);

assert(tq.template TemplateMethod<1>() == 1);

//assert( t.TemplateMethod<1>());

assert(t.template TemplateMethod<1>() == 1);

//assert( tp TemplateMethod<1>() == 1)

assert(tp->template TemplateMethod<1>() == 1);

//assert( T::TemplateMethod<1>() == 1);

assert(T::template TemplateMethod<1>() == 1);

//typename T::Nested<1> n;

typename T::template Nested<1> n;

assert(n.method() == 1);

if (sizeof...(p)) {

t += variadicSum(p...);

}

return(t);

/*

{

assert(templateAdd<int>(1, 1) == 2);

assert(templateAdd<float>(1.0, 1.0) == 2);

}

/*

{

assert((templateSpec<double,double>(1.0, 1.0)) == 3.1);

}

/*

{

/*

{

assert(templateArgDeduct<int> (1) == 1);

assert(templateArgDeduct (1) == 1);

assert(templateArgDeduct<double>(1.0) == 2.0);

assert(templateArgDeduct (1.0) == 2.0);

}

/*

{

assert((templateArgDeductReturn<int>()) == 0);

assert((templateArgDeductLocal<int>()) == 0);

// ERROR.

//assert((templateArgDeductReturn<>()) == 0);

//assert((templateArgDeductLocal<>()) == 0);

}

/*

{

assert((templateArgDeductNotLast<int,int>(1)) == 1);

// ERROR.

//assert((templateArgDeductNotLast<int>(1)) == 1);

}

/*

{

assert(templateArgTemplateArg (TemplateTemplateParam<int>(1)) == 1);

assert(templateArgTemplateArg<int>(TemplateTemplateParam<int>(1)) == 1);

}

/*

{

// WARNING: statement `HasIMember::i` has no effect

//NoTypenameFunc<HasIMember>();

// ERROR: dependant name is parsed as non type

//NoTypenameFunc<HasIType>();

// ERROR: no type named i in HasIMember

//TypenameFunc<HasIMember>();

TypenameFunc<HasIType>();

// ERROR.

//NoTypenameInTemplateFunc<HasIType>();

//ERROR.

//NoTypenameInTemplateFunc<HasIMember>();

// ERROR.

TypenameInTemplateFunc<HasIType>();

// ERROR.

//TypenameInTemplateFunc<HasIMember>();

}

}

/*

{

assert(templateAddInt<1>(1) == 2);

}

// Not a constexpr.

{

//std::cout << templateAddInt<std::time(NULL) >(1) << std::endl;

}

/*

{

// because of this call

// all factorials from

// 1 to 3 will be compiled

assert(factorial<3>() == 6);

// because of this call

// all factorials from

// 4 to 6 will be compiled

assert(factorial<6>() == 720);

}

/*

{

/*

{

//TemplateTemplateIntNotATemplate<int,TemplateTemplateParam>

}

//useless working example

{

TemplateTemplateInt<TemplateTemplateParam> t;

t.t.t = 1;

}

/*

{

/* bad: types don't match */

TemplateTemplateWouldBeBetter<int,TemplateTemplateParam<double>> t;

/* bad: types match, but there is code duplication as `int` must be written twice */

TemplateTemplateWouldBeBetter<int,TemplateTemplateParam<int>> t2;

}

/*

{

TemplateTemplate<int,TemplateTemplateParam> t;

t.v.t = 0;

t.t = 0;

/**/

assert(t.equal());

}

}

/*

{

/*

{

{std::vector<std::vector<int> > vv;}

// ^

// THIS space was required before C++11

#if __cplusplus >= 201103L

{std::vector<std::vector<int>> vv;}

#endif

}

/*

/*

{

}

/*

{

TemplateQualifier tq;

TemplateQualifierTest<TemplateQualifier>(tq, tq, &tq);

}

}

{

/*

{

assert((templateDefault<int,TemplateTemplateParam,1>(1, TemplateTemplateParam<int>(1))) == 3);

// ^ ^

// 1 2

// ERROR: assert macro gets too many arguments, because `<>` does not protect its inner commas.

//assert(templateDefault<int,TemplateTemplateParam,1>(1, TemplateTemplateParam<int>(1)) == 3);

// ^ ^

// 1 2

}

// Reuse a type.

{

assert((TemplateReuseType<int,1>()) == 1);

}

}

{

assert((templateDefault<int,TemplateTemplateParam,1>(1, TemplateTemplateParam<int>(1))) == 3);

assert((templateDefault<int,TemplateTemplateParam >(1, TemplateTemplateParam<int>(1))) == 3);

assert((templateDefault<int >(1, TemplateTemplateParam<int>(1))) == 3);

assert((templateDefault< >(1, TemplateTemplateParam<int>(1))) == 3);

//if there are no parameters left, the `<>` can be ommited:

assert((templateDefault (1, TemplateTemplateParam<int>(1))) == 3);

}

#if __cplusplus >= 201103L

/*

{

assert(variadicSum(1) == 1);

assert(variadicSum(1, 2) == 3);

assert(variadicSum(1, 2, 3) == 6);

assert(fabs(variadicSum(0.1) - 0.1) < 1e-6);

assert(fabs(variadicSum(0.1, 0.2) - 0.3) < 1e-6);

assert(fabs(variadicSum(0.1, 0.2, 0.3) - 0.6) < 1e-6);

assert(variadicSum(1, 1.0) == 2.0);

/*

{

assert( VariadicSizeof<>() == 0 );

assert( VariadicSizeof<int>() == 1 );

assert((VariadicSizeof<int,int>() == 2));

}

}

#endif

/*

/*

{

{

TemplateClass<Empty,int,10> c;

c.ts[9] = 9;

}

{

TemplateClass<Empty,std::string,10> c;

c.ts[9] = "asdf";

}

{

TemplateClass<> c; //default values int 10

// ERROR: canot ommit `<>` for template classes

//TemplateClass c2;

}

// BAD: wont work, unless you defined an assign operator for this case

// which is very unlikelly

//tci10 = TemplateClass<float,20>();

{

TemplateClass<>().methodTemplate<>();

}

{

{

TemplateClass<Empty,int,10> c;

c.methodDefinedOutside();

// 12 class does not contain method().

//TemplateClass<Empty,int,12>().method();

}

{

TemplateClass<Empty,int,11> c;

c.methodDefinedOutside();

//TemplateClass<Empty,int,12>().method();

//12 class does not contain method()

}

{

TemplateClass<Empty,int,12> c;

c.newMethod();

// 12 class does not contain method()

//TemplateClass<Empty,int,12>().method();

}

}

}