| #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); |