extern int printf(const char *format, ...);

#include <stdarg.h>
#include <stdio.h>

int testparams(int count, ...)
{
 va_list args;
 va_start(args, count);
 for (int i = 0; i < count; ++i)
 {
  int arg = va_arg(args, int);
  printf("arg %d = %d", i, arg);
 }
 va_end(args);
 return 0;
}

int main()
{
 testparams(3, 10, 11, 12);
 return 0;
}

#define _INTSIZEOF(n)   ((sizeof(n) + sizeof(int) - 1) & ~(sizeof(int) - 1))

#define _ADDRESSOF(v) (&const_cast<char&>(reinterpret_cast<const volatile char&>(v)))

#define __crt_va_start_a(ap, v) ((void)(ap = (va_list)_ADDRESSOF(v) + _INTSIZEOF(v)))
#define __crt_va_arg(ap, t)  (*(t*)((ap += _INTSIZEOF(t)) - _INTSIZEOF(t)))
#define __crt_va_end(ap)  ((void)(ap = (va_list)0))

#define __crt_va_start(ap, x) ((void)(__vcrt_va_start_verify_argument_type<decltype(x)>(), __crt_va_start_a(ap, x)))

#define va_start __crt_va_start
#define va_arg __crt_va_arg
#define va_end __crt_va_end

#ifndef UTIL_MEMPOOL_H
#define UTIL_MEMPOOL_H

#include <stdlib.h>

#define MEMPOOL_NEW_SIZE 8

template<typename T, size_t count = 1>
class MemPool
{
private:
 union MemObj {
  char _obj[1];
  MemObj* _freelink;
 };

public:
 static void* Allocate()
 {
  if (!_freelist) {
   refill();
  }
  MemObj* alloc_mem = _freelist;
  _freelist = _freelist->_freelink;
  ++_size;
  return (void*)alloc_mem;
 }

 static void DeAllocate(void* p)
 {
  MemObj* q = (MemObj*)p;
  q->_freelink = _freelist;
  _freelist = q;
  --_size;
 }

 static size_t TotalSize() {
  return _totalsize;
 }

 static size_t Size() {
  return _size;
 }
private:
 static void refill()
 {
  size_t size = sizeof(T) * count;
  char* new_mem = (char*)malloc(size * MEMPOOL_NEW_SIZE);
  for (int i = 0; i < MEMPOOL_NEW_SIZE; ++i) {
   MemObj* free_mem = (MemObj*)(new_mem + i * size);
   free_mem->_freelink = _freelist;
   _freelist = free_mem;
  }
  _totalsize += MEMPOOL_NEW_SIZE;
 }

 static MemObj* _freelist;
 static size_t _totalsize;
 static size_t _size;
};

template<typename T, size_t count>
typename MemPool<T, count>::MemObj* MemPool<T, count>::_freelist = NULL;

template<typename T, size_t count>
size_t MemPool<T, count>::_totalsize = 0;

template<typename T, size_t count>
size_t MemPool<T, count>::_size = 0;
#endif

template<class T>
T *MemNew(size_t count)
{
 T *p = (T*)MemPool<T, count>::Allocate();
 if (p != NULL)
 {
  if (!std::is_pod<T>::value)
  {
   for (size_t i = 0; i < count; ++i)
   {
    new (&p[i]) T();
   }
  }
 }
 return p;
}

template<class T>
T *MemDelete(T *p, size_t count)
{
 if (p != NULL)
 {
  if (!std::is_pod<T>::value)
  {
   for (size_t i = 0; i < count; ++i)
   {
    p[i].~T();
   }
  }
  MemPool<T, count>::DeAllocate(p);
 }
}

template<class T, class... Args>
T *MemNew(size_t count, Args&&... args)
{
 T *p = (T*)MemPool<T, count>::Allocate();
 if (p != NULL)
 {
  if (!std::is_pod<T>::value)
  {
   for (size_t i = 0; i < count; ++i)
   {
    new (&p[i]) T(std::forward<Args>(args)...);
   }
  }
 }
 return p;
}

template<class... T> class Test {};
Test<> test0;
Test<int> test1;
Test<int,int> test2;
Test<int,int,long> test3;

template<class... T> void test(T... args);
test();
test<int>(0);
test<int,int,long>(0,0,0L);

void test()
{
}

template<class T, class... Args> 
void test(T first, Args... args)
{
 std::cout << typeid(T).name() << " " << first << std::endl;
 test(args...);
}

test<int, int, long>(0, 0, 0L);

output:
int 0
int 0
long 0

template<class T>
void print(T arg)
{
 std::cout << typeid(T).name() << " " << arg << std::endl;
}

template<class... Args>
void test(Args... args)
{
 int arr[] = { (print(args), 0)... };
}

test(0, 0, 0L);

output:
int 0
int 0
long 0

template<class T, class... Types>
class Test
{
public:
 enum {
  value = Test<T>::value + Test<Types...>::value,
 };
};

template<class T>
class Test<T>
{
public:
 enum {
  value = sizeof(T),
 };
};

Test<int, int, long> test;
std::cout << test.value;

output: 12

int i =0;//i 左值
int *p = &i;// i 左值
int& foo();
foo() = 42;// foo() 左值
int* p1 = &foo();// foo() 左值

int foo1();
int j = 0;
j = foo1();// foo 右值
int k = j + 1;// j + 1 右值
int *p2 = &foo1(); // 错误，无法取右值的地址
j = 1;// 1 右值

int foo(int param)
{
 printf("%d", param);
 return 0;
}

int res = foo(0);

int foo(const int& param)
{
 printf("%d", param);
 return 0;
}

int result = 0;
int&& foo(int&& param)
{
 printf("%d", param);
 return std::move(result);
}

int&& res = foo(0);
int *pres = &res;

template<class T>
T* Test(T arg)
{
 return new T(arg);
}

template<class T>
T* Test(T& arg)
{
 return new T(arg);
}

template<class T>
T* Test(const T& arg)
{
 return new T(arg);
}

template<class T>
T* Test(T&& arg)
{
 return new T(std::forward<T>(arg));
}

template< class T > struct remove_reference  {typedef T type;};
template< class T > struct remove_reference<T&> {typedef T type;};
template< class T > struct remove_reference<T&&> {typedef T type;};

template< class T > T&& forward( typename std::remove_reference<T>::type& t )
{
 return static_cast<T&&>(t);
}

template<class T>
typename std::remove_reference<T>::type&& move(T&& a) noexcept
{ 
 return static_cast<typename std::remove_reference<T>::type&&>(a);
}

template<class T>
T* Test(T&& arg)
{
 return new T(std::forward<T>(arg));
}

X x;
Test(x);

X& && std::forward(remove_reference<X&>::type& a) noexcept
{
 return static_cast<X& &&>(a);
}

X* Test(X& && arg)
{
 return new X(std::forward<X&>(arg)); 
}

// 塌陷后

X& std::forward(X& a)
{
 return static_cast<X&>(a);
}

X* Test(X& arg)
{
 return new X(std::forward<X&>(arg));
}

X foo();
Test(foo());

X&& std::forward(remove_reference<X>::type& a) noexcept
{
 return static_cast<X&&>(a);
}

X* Test(X&& arg)
{
 return new X(std::forward<X>(arg)); 
}

// 塌陷后

X&& std::forward(X& a)
{
 return static_cast<X&&>(a);
}

X* Test(X&& arg)
{
 return new X(std::forward<X>(arg));
}