You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
197 lines
3.1 KiB
197 lines
3.1 KiB
#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);
|