int printf(const char *fmt, ...);

void mockprintf(const char *fmt, ...)
{
    va_list ap;
    va_start(ap, fmt);
    for (const char *s = fmt; *s; ++s)
    {
        switch(*s)
        {
            case 'd':
                printf("meet d\n");
                int d = va_arg(ap, int);
                printf("%d\n", d);
                break;
            case 's':
                printf("meet s\n");
                const char *str = va_arg(ap, char*);
                printf("%s\n", str);
                break;
            case 'c':
                printf("meet c\n");
                char c = va_arg(ap, int);
                printf("%c\n", c);
                break;
            default:
                printf("unknown format specifier\n");
        }
    }
    va_end(ap);
}
int
main()
{
    mockprintf("cdfs", 'A', 0x45, "string");
    return 0;
}

#include <stdio.h>
int printf(const char *fmt, ...);
int fprintf(FILE *stream, const char *fmt, ...);
int sprintf(char *str, const char *fmt, ...);
int snprintf(char *str, size_t size, const char *fmt, ...);
 
#include <stdarg.h>
int vprintf(const char *fmt, va_list ap);
int vfprintf(FILE *stream, const char *fmt, va_list ap);
int vsprintf(char *str, const char *fmt, va_list ap);
int vsnprintf(char *str, size_t size, const char *fmt, va_list ap);

enum LogLevel { ERROR, WARN, INFO, DEBUG }
void log(LogLevel level, const char *fmt, ...)
{
    va_list ap;
    va_start(ap, fmt);
    vsnprintf(buf, sizeof(buf), fmt, ap);
    va_end(ap);
    //~ write buf to file, or do something else.
}

#define log_warn(fmt, ...) log(WARN, fmt, __VA_ARGS__)

#define log_warn(fmt, args...) log(WARN, fmt, args)

#define log_warn(...) log(WARN, __VA_ARGS__)

//~ foo.c
float 
foo(float f)
{
    return f * f;
}
//~ main.c
int
main()
{
    double d = foo(3.1415926);
    return 0;
}

$ cc foo.c main.c -c
$ cc foo.o main.o -omain
$ ./main

#include <stdio.h>
 
int
main(int AC, char **AV)
{
    FILE *fd = fopen("data", "w+");
    fprintf(fd, "%x%c", 0x41, '1');
    fseek(fd, 0, SEEK_SET);
    int n;
    fscanf(fd, "%d", &n);
    fseek(fd, 0, SEEK_SET);
    char s[4];
    int c = fread(s, 1, sizeof(s), fd);
    s[c] = '\0';
    printf("%d, %s\n", n, s);
    fclose(fd);
    return 0;
}

#include <stdio.h>
typedef struct node
{
      int i;
      struct node *next;
}node;
node getnode(int a)
{
      struct node n;
      n.i=a;
      n.next=NULL;
      return n;
}
 
main()
{
     int i;
     node newtemp,root,temp;
     scanf("%d",&i);
     root=getnode(i);
     temp=root;
 
     while(i--)
     {
         newtemp=getnode(i);
         temp.next=&newtemp;
         if(root.next==NULL)
         {
            root=temp;
         }
        temp=*(temp.next);
     }
     temp=root;
 
     while( temp.next != NULL )
     {
         printf(" %d ",temp.i);
         temp=*(temp.next);
     }
}

int
main()
{
    int n = 0;
    int m = (++n) + (++n) + (++n) + (++n);
    printf("%d, %d\n", m, n);
    return 0;
}

int
main()
{
    int m = 1, n = 0;
    printf("%d, %d\n", m, n);
    m ^= n ^= m ^= n;
    printf("%d, %d\n", m, n);
    return 0;
}

const int N = 4;
char *str[N] = { "xyz", "cdef", "abcd", "caaa"};
 
int cmp(const void *l, const void *r)
{
    const char *a = *((char**)l);
    const char *b = *((char**)r);
    return strcmp(a, b);
}
int
main(int argc, char **argv)
{
    qsort( (void*)str, N, sizeof(int*), cmp );
    for(int i = 0; i < N; ++i)
    {
        printf("%s\n", str[i]);
    }
    return 0;
}

const int N = 4;
char str[N][10] = { "xyz", "cdef", "abcd", "caaa"};
 
int
main(int argc, char **argv)
{
    qsort( (void*)str, N,
            sizeof(char)*10,
            ( int(*)(const void*, const void*) )strcmp );
    for(int i = 0; i < N; ++i)
    {
        printf("%s\n", str[i]);
    }
    return 0;
}

struct structName {
    int n;
};
//~ typedef struct structName structName;
int
main()
{
    struct structName n;
    return 0;
}

struct structName {
    int n;
};
void structName() {
    ;
}
int
main()
{
    structName n;
    return 0;
}

#include <stdio.h>
inline int add(int a, int b) { return a + b; }
int main()
{
	int n = add(1,2);
	return 0;
}

$ g++ -otest test.cpp
$ objdump ./test -d

08048494 <main>:
 8048494:	55                   	push   %ebp
 8048495:	89 e5                	mov    %esp,%ebp
 8048497:	83 e4 f0             	and    $0xfffffff0,%esp
 804849a:	83 ec 20             	sub    $0x20,%esp
 804849d:	c7 44 24 04 02 00 00 	movl   $0x2,0x4(%esp)
 80484a4:	00 
 80484a5:	c7 04 24 01 00 00 00 	movl   $0x1,(%esp)
 80484ac:	e8 0b 00 00 00       	call   80484bc <_Z3addii>
 80484b1:	89 44 24 1c          	mov    %eax,0x1c(%esp)
 80484b5:	b8 00 00 00 00       	mov    $0x0,%eax
 80484ba:	c9                   	leave  
 80484bb:	c3                   	ret    
 
080484bc <_Z3addii>:
 80484bc:	55                   	push   %ebp
 80484bd:	89 e5                	mov    %esp,%ebp
 80484bf:	8b 45 0c             	mov    0xc(%ebp),%eax
 80484c2:	8b 55 08             	mov    0x8(%ebp),%edx
 80484c5:	8d 04 02             	lea    (%edx,%eax,1),%eax
 80484c8:	5d                   	pop    %ebp
 80484c9:	c3                   	ret    
 80484ca:	90                   	nop
 80484cb:	90                   	nop

int
main()
{
	unsigned a = 1;
	int b = 1;
	while(a + b >= 0) --b;
	return 0;
}

	movl	$1, -4(%ebp)
	movl	$1, -8(%ebp)
.L2:
	subl	$1, -8(%ebp)
	jmp	.L2

//...
	while(a + b > 0) --b;
//...

	movl	$1, -4(%ebp)
	movl	$1, -8(%ebp)
	jmp	.L2
.L3:
	subl	$1, -8(%ebp)
.L2:
	movl	-8(%ebp), %eax
	addl	-4(%ebp), %eax
	testl	%eax, %eax
	setne	%al
	testb	%al, %al
	jne	.L3

//...
	while(a + b > -2) --b;
//...

	movl	$1, -4(%ebp)
	movl	$1, -8(%ebp)
	jmp	.L2
.L3:
	subl	$1, -8(%ebp)
.L2:
	movl	-8(%ebp), %eax
	addl	-4(%ebp), %eax
	cmpl	$-1, %eax
	sete	%al
	testb	%al, %al
	jne	.L3

//...
	while(a + b >= -2) --b;
//...

	movl	$1, -4(%ebp)
	movl	$1, -8(%ebp)
	jmp	.L2
.L3:
	subl	$1, -8(%ebp)
.L2:
	movl	-8(%ebp), %eax
	addl	-4(%ebp), %eax
	cmpl	$-3, %eax
	seta	%al
	testb	%al, %al
	jne	.L3

//...
	while(a + b >= 1) --b;
//...

	movl	$1, -4(%ebp)
	movl	$1, -8(%ebp)
	jmp	.L2
.L3:
	subl	$1, -8(%ebp)
.L2:
	movl	-8(%ebp), %eax
	addl	-4(%ebp), %eax
	testl	%eax, %eax
	setne	%al
	testb	%al, %al
	jne	.L3

#include <iostream>
#include <pthread.h>
class CThreadQueue
{
public:
    CThreadQueue (int queueSize = 1024):
  sizeQueue (queueSize), lput (0), lget (0), nFullThread (0),
      nEmptyThread (0), nData (0)
  {
      pthread_mutex_init (&mux, 0);
      pthread_cond_init (&condGet, 0);
      pthread_cond_init (&condPut, 0);
      buffer = new void *[sizeQueue];
  }
  virtual ~ CThreadQueue ()
  {
      pthread_mutex_destroy (&mux);
      pthread_cond_destroy (&condGet);
      pthread_cond_destroy (&condPut);
      delete[]buffer;
  }
  void *getq ()
  {
      void *data;
      pthread_mutex_lock (&mux);
      /*
       * 此处循环判断的原因如下：假设2个线程在getq阻塞，然后两者都被激活，
       * 而其中一个线程运行比较块，快速消耗了2个数据，
       * 另一个线程醒来的时候已经没有新数据可以消耗了。
       * 另一点，man pthread_cond_wait可以看到，
       * 该函数可以被信号中断返回，此时返回EINTR。
       * 为避免以上任何一点，都必须醒来后再次判断睡眠条件。
       * 更正：pthread_cond_wait是信号安全的系统调用，不会被信号中断。
       */
      while (lget == lput && nData == 0)
      {
        nEmptyThread++;
        pthread_cond_wait (&condGet, &mux);
        nEmptyThread--;
      }
 
      data = buffer[lget++];
      nData--;
      if (lget == sizeQueue)
      {
        lget = 0;
      }
      if (nFullThread)                  //必要时才进行signal操作，勿总是signal
      {
        pthread_cond_signal (&condPut);
      }
      pthread_mutex_unlock (&mux);
      return data;
  }
  void putq (void *data)
  {
      pthread_mutex_lock (&mux);
      while (lput == lget && nData)
      {
        nFullThread++;
        pthread_cond_wait (&condPut, &mux);
        nFullThread--;
      }
      buffer[lput++] = data;
      nData++;
      if (lput == sizeQueue)
      {
        lput = 0;
      }
      if (nEmptyThread)
      {
        pthread_cond_signal (&condGet);
      }
      pthread_mutex_unlock (&mux);
  }
private:
  pthread_mutex_t mux;
  pthread_cond_t condGet;
  pthread_cond_t condPut;
 
  void **buffer;                        //循环消息队列
  int sizeQueue;                        //队列大小
  int lput;                                    //location put  放数据的指针偏移
  int lget;                                    //location get  取数据的指针偏移
  int nFullThread;                        //队列满，阻塞在putq处的线程数
  int nEmptyThread;                        //队列空，阻塞在getq处的线程数
  int nData;                              //队列中的消息个数，主要用来判断队列空还是满
};
 
//使用的时候给出稍大的CThreadQueue初始化参数，可以减少进入内核态的操作。
CThreadQueue queue;
void *
produce (void *arg)
{
  int i = 0;
  pthread_detach (pthread_self ());
  while (i++ < 100)
  {
      queue.putq ((void *) i);
  }
}
 
void *
consume (void *arg)
{
  int data;
  while (1)
  {
      data = (int) (queue.getq ());
      printf ("data=%d\n", data);
  }
}
 
int
main ()
{
  pthread_t pid;
  int i = 0;
 
  while (i++ < 3)
      pthread_create (&pid, 0, produce, 0);
  i = 0;
  while (i++ < 3)
      pthread_create (&pid, 0, consume, 0);
  sleep (30);
  return 0;
}

#include <iostream>
#include <pthread.h>
using namespace std;
 
class M
{
    public:
        M(){}
        ~M()
        {
            cout<<"M destructed..."<<endl;
        }
    private:
        int i;
};
class B
{
    public:
        B(){}
        //! virtual ~B(){}
        ~B(){}
};
class D: public B
{
    public:
        D(){}
        ~D(){}
    private:
        M m;
};
 
int
main()
{
    B * pb = new D;
    delete pb;
    return 0;
}

//~ demo.cpp
#include <iostream>
#include <fstream>
#include <string>
#include <streambuf>
using namespace std;
//~ 测试代码 :)
int main()
{
	ifstream in("demo.cpp");
	char buffer[4096]="original content in this buffer";
	cout<<buffer<<endl;
	streambuf * ptrbuff = in.rdbuf(); //~ 将streambuf与文件句柄关联
	ptrbuf->pubsetbuf(bufer, 4096); //~ 设置缓冲区，即设置in的缓冲区
	cout<<buffer<<endl; //~ 此时bufer里面的内容还是original content in this buffer
	string str;
	in>>str; //~ 真正要输入时bufer才被填充为in的内容
	cout<<str<<endl;
	cout<<buffer<<endl;
	return 0;
}

template 
class Queue
{
public:
	Queue(int size = 30);
	~Queue();
	void EnQueue(T value);
	T DeQueue();
	T GetFirst();
	bool IsEmpty();
	bool IsFull();
	void ClearQueue();
private:
	T *queue;
	int front;
	int rare;
	int MaxSize;
	int CurLen;
};
 
template 
Queue::Queue(int size = 30)
{
	queue = new T[size];
	front = 0;
	rare = 0;
	CurLen = 0;
	MaxSize =size;
}
 
template 
Queue::~Queue()
{
	delete queue;
}
 
template
void Queue::EnQueue(T value)
{
	queue[rare] = value;
	rare = (rare + 1)%MaxSize;
	CurLen++;
}
 
template
T Queue::DeQueue()
{
	T value;
	if(IsEmpty())
	{
		cout<<"Empty When Dequeue"<
T Queue::GetFirst()
{
	T value;
	if(IsEmpty())
	{
		cout<<"Empty When GetFirst!"<
bool Queue::IsEmpty()
{
	return (front==rare&&CurLen==0)?true:false;
}
 
template
bool Queue::IsFull()
{
	return (front==rare&&CurLen==MaxSize)?true:false;
}
 
template
void Queue::ClearQueue()
{
	front = 0;
	rare = 0;
	CurLen = 0;
}

template <class T>   
 
class Stack   
{   
public:   
	Stack(int stack_size = 30);   
	~Stack();   
	void Push(T value);   
	T Pop();   
	T Top();   
	bool IsEmpty();   
	bool IsFull();   
	void ClearStack();   
private:   
	int top;   
	T* stack;   
	int size;   
};   
template<class T>   
Stack<T>::Stack(int stack_size)   
{   
	size = stack_size;   
	Stack::stack = new T[size];   
	Stack::top = -1;   
}   
 
template<class T>   
Stack<T>::~Stack()   
{   
	delete []stack;   
}   
 
template<class T>   
void Stack<T>::Push(T value)   
{   
	stack[++top] = value;   
}   
 
template<class T>   
T Stack<T>::Pop()   
{   
	return stack[top--];   
}   
 
template<class T>   
T Stack<T>::Top()   
{   
	return Stack[top];   
}   
 
template<class T>   
bool Stack<T>::IsEmpty()   
{   
	return(top==-1?true:false);   
}   
 
template<class T>   
bool Stack<T>::IsFull()   
{   
	return(top==(size-1)?true:false);   
}   
 
template<class T>   
void Stack<T>::ClearStack()   
{   
	top = -1;   
}

#include <iostream>
#include <string>
#include <sstream>
#include <vector>
#include "Stack.h"
 
using namespace std;
 
class Calculate
{
public:
	Calculate();
	~Calculate();
	int Cal(string express);
private:
	string ParseString(string express);
	vector<string> MidToBehind(string express);
	int Compute(int a,int b,char operater);
	Stack<int> stack_int;
	Stack<char> stack_char;
};

Calculate::Calculate()
{
 
}
 
Calculate::~Calculate()
{
 
}
 
vector<string> Calculate::MidToBehind(string express)
{
	stringstream strstrm(express);
	char temp_char;
	string temp_str;
	vector<string> result_vec;
	while (strstrm>>temp_char)
	{
		if (temp_char!='('&&temp_char!=')'&&temp_char!='+'&&temp_char!='-'&&temp_char!='*'&&temp_char!='/'&&temp_char!='=')
		{
			strstrm.putback(temp_char);
			strstrm>>temp_str;
			result_vec.push_back(temp_str);
		}
		else if(temp_char == '(')
		{
			stack_char.Push(temp_char);
		}
		else if(temp_char == ')')
		{
			if(stack_char.IsEmpty())
			{
				cout<<"stack is empty when push ')'"<<endl;
				stack_char.ClearStack();
			}
			else
			{
				while (temp_char = stack_char.Pop(),temp_char != '(')
				{
					result_vec.push_back(string(1,temp_char));
					if (stack_char.IsEmpty())
					{
						cout<<"stack is empty when pop,not found the '('"<<endl;
						stack_char.ClearStack();
					}
				}
			}
		}
		else if(temp_char == '+'||temp_char == '-'||temp_char == '*'||temp_char == '/')
		{
			switch (temp_char)
			{
				char temp_char_2;
			case '+':
				while (!stack_char.IsEmpty())
				{
					temp_char_2 = stack_char.Pop();
					if (temp_char_2 == '(')
					{
						stack_char.Push(temp_char_2);
						break;
					}
					else
						result_vec.push_back(string(1,temp_char_2));
				}
				stack_char.Push(temp_char);
				break;
			case '-':
				while (!stack_char.IsEmpty())
				{
					temp_char_2 = stack_char.Pop();
					if (temp_char_2 == '(')
					{
						stack_char.Push(temp_char_2);
						break;
					}
					else
						result_vec.push_back(string(1,temp_char_2));
				}
				stack_char.Push(temp_char);
				break;
			case '*':
				while (!stack_char.IsEmpty())
				{
					temp_char_2 = stack_char.Pop();
					if (temp_char_2 == '('||temp_char_2 == '+'||temp_char_2 == '-')
					{
						stack_char.Push(temp_char_2);
						break;
					}
					else
						result_vec.push_back(string(1,temp_char_2));
				}
				stack_char.Push(temp_char);
				break;
			case '/':
				while (!stack_char.IsEmpty())
				{
					temp_char_2 = stack_char.Pop();
					if (temp_char_2 == '('||temp_char_2 == '+'||temp_char_2 == '-')
					{
						stack_char.Push(temp_char_2);
						break;
					}
					else
						result_vec.push_back(string(1,temp_char_2));
				}
				stack_char.Push(temp_char);
				break;
			default:
				break;
			}
		}
		else if (temp_char == '=')
		{
			while (!stack_char.IsEmpty())
			{
				result_vec.push_back(string(1,stack_char.Pop()));
			}
		}
		else
			cout<<"wrong express"<<endl;
	}
	return result_vec;
}
 
int Calculate::Compute(int a,int b,char operater)
{
	switch(operater)
	{
	case '+':
		return a + b;
	case '-':
		return a - b;
	case '*':
		return a * b;
	case '/':
		if(b == 0)
		{
			cout<<"divided by 0!wrong!"<<endl;
			return -1;
		}
		else
			return a / b;
	default:
		break;
	}
	cout<<"Not return"<<endl;
	return -1;
}
 
int Calculate::Cal(string express)
{
	string new_exp = ParseString(express);
	string str_temp;
	vector<string> vec_exp = MidToBehind(new_exp);
	for (vector<string>::iterator it = vec_exp.begin();it != vec_exp.end();it++)
	{
		str_temp = *it;
		if (str_temp!="+"&&str_temp!="-"&&str_temp!="*"&&str_temp!="/")
		{
			int int_temp = 0;
			int time = 1;
			for (string::iterator itr = str_temp.begin();itr != str_temp.end();itr++)
			{
				int_temp = int_temp*10 + (*itr - '0');
			}
			stack_int.Push(int_temp);
		} 
		else
		{
			int a,b;
			b = stack_int.Pop();
			a = stack_int.Pop();
			char ch = str_temp[0];
			int c = Compute(a,b,ch);
			stack_int.Push(c);
		}
	}
	return stack_int.Pop();
}
 
string Calculate::ParseString(string express)
{
	string new_exp;
	bool flag = false;
	for (string::iterator it = express.begin();it != express.end();it++)
	{
		if (*it>='0'&&*it<='9')
		{
			if(flag)
				new_exp.push_back(' ');
			flag = false;
			new_exp.push_back(*it);
		}
		else
		{
			flag = true;
			if(it != express.begin())
				new_exp.push_back(' ');
			new_exp.push_back(*it);
		}
	}
	return new_exp;
}

#include <stdio.h>
int
main()
{
    int* pi = (int*)malloc(sizeof(int));
    free((char*)pi);
    return 0;
}

#include <iostream>
using namespace std;
int
main()
{
    int* pi = new int;
    delete (char*) pi;
    return 0;
}

#include <iostream>
using namespace std;
class demo
{
    public:
        //~ 此处省略代码数行……
        ~demo()
        {
             delete [] pi;
        }
    private:
        int * pi;
};
int
main()
{
    demo * pd = new demo;
    delete (char*)pd;
    return 0;
}

#include <iostream>
using namespace std;
class demo
{
    public:
        //~ 此处省略代码数行……
        ~demo()
        {
             delete [] pi;
        }
    private:
        int * pi;
};
 
class foo
{
public:
    ~foo(){cout<<"foo's collapsing..."<<endl;
};
int
main()
{
    demo * pd = new demo;
    delete (foo*)pd;
    return 0;
}

template <class T>
T Min(T x, T y)
{
	return x < y ? x : y;
}
 
int main()
{
	unsigned ui = 0;
	int a = Min(ui, 1);
	return 0;
}

/**
 * strstr - Find the first substring in a %NUL terminated string
 * @s1: The string to be searched
 * @s2: The string to search for
 */
char *strstr(const char *s1, const char *s2)
{
	int l1, l2;
 
	l2 = strlen(s2);
	if (!l2)
		return (char *)s1;
	l1 = strlen(s1);
	while (l1 >= l2) {
		l1--;
		if (!memcmp(s1, s2, l2))
			return (char *)s1;
		s1++;
	}
	return NULL;
}

/**
 * memmove - Copy one area of memory to another
 * @dest: Where to copy to
 * @src: Where to copy from
 * @count: The size of the area.
 *
 * Unlike memcpy(), memmove() copes with overlapping areas.
 */
void *memmove(void *dest, const void *src, size_t count)
{
	char *tmp;
	const char *s;
 
	if (dest <= src) {
		tmp = dest;
		s = src;
		while (count--)
			*tmp++ = *s++;
	} 
	else {
		tmp = dest;
		tmp += count;
		s = src;
		s += count;
		while (count--)
			*--tmp = *--s;
	}
	return dest;
}

/**
 * strncmp - Compare two length-limited strings
 * @cs: One string
 * @ct: Another string
 * @count: The maximum number of bytes to compare
 */
int strncmp(const char *cs, const char *ct, size_t count)
{
	signed char __res = 0;
 
	while (count) {
		if ((__res = *cs - *ct++) != 0 || !*cs++)
			break;
		count--;
	}
	return __res;
}

//! 需要包含de头文件
#include <sys/types.h>
#include <sys/stat.h>
 
int stat(const char *filename, struct stat *buf); //! prototype,原型
 
struct stat
{
    dev_t       st_dev;     /* ID of device containing file -文件所在设备的ID*/
    ino_t       st_ino;     /* inode number -inode节点号*/
    mode_t      st_mode;    /* protection -保护模式?*/
    nlink_t     st_nlink;   /* number of hard links -链向此文件的连接数(硬连接)*/
    uid_t       st_uid;     /* user ID of owner -user id*/
    gid_t       st_gid;     /* group ID of owner - group id*/
    dev_t       st_rdev;    /* device ID (if special file) -设备号，针对设备文件*/
    off_t       st_size;    /* total size, in bytes -文件大小，字节为单位*/
    blksize_t   st_blksize; /* blocksize for filesystem I/O -系统块的大小*/
    blkcnt_t    st_blocks;  /* number of blocks allocated -文件所占块数*/
    time_t      st_atime;   /* time of last access -最近存取时间*/
    time_t      st_mtime;   /* time of last modification -最近修改时间*/
    time_t      st_ctime;   /* time of last status change - */
};

#include <iostream>
#include <ctime>
#include <sys/types.h>
#include <sys/stat.h>
 
using namespace std;
 
int
main ()
{
    struct stat buf;
    int result;
    result = stat ("./Makefile", &buf);
    if (result != 0)
      {
	  perror ("Failed ^_^");
      }
    else
      {
	  //! 文件的大小，字节为单位
	  cout << "size of the file in bytes: " << buf.st_size << endl;
	  //! 文件创建的时间
	  cout << "time of creation of the file: " << ctime (&buf.st_ctime) <<
	      endl;
	  //! 最近一次修改的时间
	  cout << "time of last modification of the file: " <<
	      ctime (&buf.st_mtime) << endl;
	  //! 最近一次访问的时间
	  cout << "time of last access of the file: " << ctime (&buf.st_atime)
	      << endl;
      }
    return 0;
}