| #include <list> |
| #include <map> |
| #include <vector> |
| |
| #define MACRO(T) f < T > () |
| |
| class MyClass |
| { |
| public: |
| std::map < int, bool > someData; |
| std::map < int, std::list < bool > > otherData; |
| }; |
| |
| void foo() |
| { |
| List < byte > bob = new List < byte > (); |
| |
| } |
| |
| A < B > foo; |
| A < B,C > bar; |
| A < B* > baz; |
| A < B < C > > bay; |
| |
| void asd(void) |
| { |
| A < B > foo; |
| A < B,C > bar; |
| A < B* > baz; |
| A < B < C > > bay; |
| if (a<b && b>c) |
| { |
| a = b<c>0; |
| } |
| if (a < bar() > c) |
| { |
| } |
| a<up_lim() ? do_hi() : do_low; |
| a[ a<b>c] = d; |
| } |
| |
| template< typename T > class MyClass |
| { |
| |
| } |
| |
| template< typename T > |
| class MyClass |
| { |
| } |
| |
| template< typename A, typename B, typename C > class MyClass : myvar(0), |
| myvar2(0) |
| { |
| |
| } |
| |
| template< typename A, typename B, typename C > class MyClass |
| : myvar(0), |
| myvar2(0) |
| { |
| |
| } |
| |
| |
| static int max_value() |
| { |
| return (std :: numeric_limits < int >:: max )(); |
| } |
| |
| template< class Config_ > |
| priority_queue < Config_ > :: ~priority_queue () { |
| |
| } |
| |
| template< class T > |
| T test(T a) { |
| return a; |
| } |
| |
| int main() { |
| int k,j; |
| h g < int >; |
| k=test < int > (j); |
| return 0; |
| } |
| |
| template< typename T, template< typename, unsigned int, unsigned int > class ConcreteStorageClass > |
| class RotationMatrix |
| : public StaticBaseMatrix < T, 3, 3, ConcreteStorageClass > |
| { |
| |
| public: |
| |
| RotationMatrix() |
| : StaticBaseMatrix < T, 3, 3, ConcreteStorageClass > () |
| { |
| // do some initialization |
| } |
| |
| void assign(const OtherClass < T, 3, 3 >& other) |
| { |
| // do something |
| } |
| |
| }; |
| |
| int main() |
| { |
| MyClass < double, 3, 3, MyStorage > foo; |
| } |
| |
| template< typename CharT, int N, typename Traits > |
| inline std::basic_ostream < CharT,Traits >& FWStreamOut(std::basic_ostream < CharT,Traits >& os, |
| const W::S < CharT,N,Traits >& s) |
| { |
| return operator << < CharT, N, Traits, char, std::char_traits < char > > ( os, s ); |
| } |
| |
| struct foo { |
| type1 < int& > bar; |
| }; |
| struct foo { |
| type1 < int const > bar; |
| }; |
| |
| |
| template< int i > void f(); |
| template< int i > void g() { |
| f < i - 1 > (); |
| f < i > (); |
| f < i + 1 > (); |
| f < bar() > (); |
| } |
| void h() { |
| g < 42 > (); |
| } |
| |
| #include <vector> |
| std::vector < int > A(2); |
| std::vector < int > B; |
| std::vector < int > C(2); |
| std::vector < int > D; |
| |
| template< class T > struct X { template< class U > void operator ()(U); }; |
| |
| template< class T > class Y { template< class V > void f(V); }; |
| |
| void (* foobar)(void) = NULL; |
| std::vector < void (*)(void) > functions; |
| |
| #define MACRO( a ) a |
| template< typename = int > class X; |
| MACRO ( void f( X < >& x ) ); |
| void g( X < >& x ); |
| |
| #include <vector> |
| typedef std::vector < std::vector < int > > Table; // OK |
| typedef std::vector < std::vector < bool > > Flags; // Error |
| |
| void func(List < B > = default_val1); |
| void func(List < List < B > > = default_val2); |
| |
| BLAH < (3.14>=42) > blah; |
| bool X = j < 3 > >1; |
| |
| void foo() |
| { |
| A < (X>Y) > a; |
| a = static_cast < List < B > > (ld); |
| } |
| |
| template< int i > class X { /* ... */ }; |
| X<1>2>x1; // Syntax error. |
| X < (1>2) > x2; // Okay. |
| |
| template< class T > class Y { /* ... */ }; |
| Y < X < 1 > > x3; // Okay, same as "Y<X<1> > x3;". |
| Y < X < (6 >> 1) > > x4; |
| |
| |
| template< typename T > |
| int |
| myFunc1(typename T::Subtype val); |
| |
| int |
| myFunc2(T::Subtype val); |