#include <iostream.h>
#include <stdlib.h>

template<int n> int fact() {
	return n * fact<n - 1>();
}

template<> int fact<1>() {
	return 1;
}

template <class T> class Class {
	public:
		template<class T2> int foo(T2 a);
		//{ return sizeof(T2); }
};

//template <float d> class Class2 {
//};


template<class T> template<class T2> int Class<T>::foo(T2 a)
{ return sizeof(a); }

template<class A, class B, class C> class Class3 {
};

template<class T> class Class3<T, T, T> {
};

namespace {
 int unique_a = 1;
}

class A_E {
public:
	virtual void foo() throw (int);
};

class B_E : public A_E {
	virtual void foo();
};


template<class T> T min(T a, T b)
{ return a < b ? a : b ;}

union A_U {
	A_U();
	~A_U();
};

class B {
public:
	operator int() {
		return 1;
	}
};

struct some_str {
	int a;
	int b;
};


class Base 
{
public:
	virtual const char* foo() const
	{ return "Base"; }
};
class Derived : public Base 
{
public:
	virtual const char* foo() const
	{ return "Derived"; }
};

class Base1 {
public:
	virtual Base* vf4()
	{ return &base; }
private:
	Base base;
};

class Derived1 : public Base1 {
public:
	virtual Derived* vf4()
	{ return &der; }
private:
	Derived der;
};

class A0 {
};

class A : public A0 {
public:
	A()  {a = 0;}
	~A() {a = -1;}
public:
	void mutate() {
		this->~A();
		new (this) A0;
	}
public:
	int a;
};

void main()
{
   void* p  = malloc(sizeof(A));
   A*    pa = new (p) A();
}