void* worker(void *args)
{
    //~ thread execution.
    return NULL;
}
pthread_t tid;
//~ pthread_create(pthread_t*, pthread_attr_t*, void*(*)(void*), void*);
pthread_create(&tid, NULL, worker, NULL);

class Thread
{
public:
    void* worker(void* args) {
        //~ thread execution.
    }
private:
    //~ here some data member.
};
pthread_t tid;
pthread_create(&tid, NULL, &Thread::worker, NULL);

class Thread
{
public:
    static void* worker(void* args) {
        //~ thread execution.
    }
private:
    //~ here some data member.
};
pthread_t tid;
pthread_create(&tid, NULL, &Thread::worker, NULL);

class Thread
{
public:
    virtual ~Thread() {}
    pthread_t start() {
        pthread_t tid;
        pthread_create(&tid, NULL, hook, this);
        return tid;
    }
private:
    void* hook(void* args) {
        reinterpret_cast<Thread*>(args)->worker();
        return NULL;
    }
protected:
    virtual void worker() = 0;
};

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__)

class B
{
public:
    B(){}
    B(const B& b) {
        memcpy(this, &b, sizeof b);
    }
    virtual void foo() const {
        cout<<"B::foo()"<<endl;
    }
};
 
class D: public B
{
    virtual void foo() const {
        cout<<"D::foo()"<<endl;
    }
};
void bar(const B& b)
{
    b.foo();
}

int
main()
{
    D d;
    B b = d;
    B &r = b;
    r.foo();
    return 0;
}

void bar(const B& b)
{
    b.foo();
}
int
main()
{
    D d;
    B b = d; //~ 调用B::B(const B& b)
    bar(b);
    return 0;
}

int
main()
{
    sleep(3);
    std::cout<<"stage 1..."<<std::endl;
    char *p = new char[1U<<30 * 2]; //~ 2GB
 
    sleep(3);
    std::cout<<"stage 2..."<<std::endl;
 
    for(unsigned i = 0; i < (1U<<30*2); ++i) //~ access
    {
        p[i] = 0;
        usleep(1000); //~ per millisecond
    }
    return 0;
}

int
main()
{
    vector<int> v(1U<<29);
    cout<<"step into stage one..."<<endl;
    sleep(30);
    v.clear();
    cout<<"step into stage two..."<<endl;
    sleep(30);
    return 0;
}

int
main()
{
    vector<int> v(1U<<29);
    cout<<"step into stage one..."<<endl;
    sleep(30);
    vector<int>().swap(v);
    cout<<"step into stage two..."<<endl;
    sleep(30);
    return 0;
}

int
main()
{
    deque<int> dq(1U<<29);
    cout<<"step into stage one..."<<endl;
    sleep(30);
    dq.clear();
    cout<<"step into stage two..."<<endl;
    sleep(30);
    return 0;
}

//~ 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);
     }
}

//~ add.h
int add(int, int);
//~ add.c
int add(int a, int b)
{
    return a + b;
}

//~ main.cpp
#include <add.h>
int main()
{
    int a = add(0, 1);
    return 0;
}

$ gcc -c add.c
$ g++ -c main.cpp
$ g++ main.o add.o -o main
main.o: In function `main':
main.cpp:(.text+0x13): undefined reference to `add(int, int)'
collect2: ld returned 1 exit status

    movl    $1, %esi # 参数入栈
    movl    $0, %edi # 参数入栈
    call    _Z3addii # 调用add, 注意符号
    movl    %eax, -4(%rbp) # 返回值赋给int a

//~ add.h
#ifdef __cplusplus
extern "C" {
#endif
int add(int, int);
#ifdef __cplusplus
}
#endif

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;
}

int
main()
{
    int x = -1,
        y = -1,
        z = 0;
    printf("%d\n", ++x || ++y && ++z);
    printf("%d, %d, %d\n", x, y, z);
    return 0;
}

int
main()
{
    int x = -1,
        y = -1,
        z = 0,
        s = 0;
    printf("%d\n", ++x && ++y || ++z && ++s);
    printf("%d, %d, %d, %d\n", x, y, z, s);
    return 0;
}

int
main(int argc, char **argv)
{
    const int N = 10;
    int a[N] = { 1, 2, 3 };
    return 0;
}

int
main(int argc, char **argv)
{
    const int N = 10;
    int a[N];
    return 0;
}

 
	.file	"main.c"
	.text
.globl main
	.type	main, @function
main:
	leal	4(%esp), %ecx
	andl	$-16, %esp
	pushl	-4(%ecx)
	pushl	%ebp
	movl	%esp, %ebp
	pushl	%esi
	pushl	%ebx
	pushl	%ecx
	subl	$60, %esp
	movl	%ecx, %eax
	movl	4(%eax), %eax
	movl	%eax, -44(%ebp)
	movl	%gs:20, %eax
	movl	%eax, -28(%ebp)
[ ... ] # 此处略去n行
	movl	%ecx, %esp
	movl	-28(%ebp), %edx
	xorl	%gs:20, %edx
	je	.L3
	call	__stack_chk_fail
.L3:
	leal	-12(%ebp), %esp
	addl	$0, %esp
	popl	%ecx
	popl	%ebx
	popl	%esi
	popl	%ebp
	leal	-4(%ecx), %esp
	ret

	.file	"main.c"
	.text
.globl main
	.type	main, @function
main:
.LFB0:
	.cfi_startproc
	.cfi_personality 0x0,__gxx_personality_v0
	pushl	%ebp
	.cfi_def_cfa_offset 8
	movl	%esp, %ebp
	.cfi_offset 5, -8
	.cfi_def_cfa_register 5
	subl	$48, %esp
	movl	$10, -4(%ebp)
	movl	$0, %eax
	leave
	ret
	.cfi_endproc
.LFE0:
	.size	main, .-main
	.ident	"GCC: (Ubuntu 4.4.3-4ubuntu5) 4.4.3"
	.section	.note.GNU-stack,"",@progbits

#include <stdio.h>
 
int foo(void)
{
    int i = 0;
    while(i++ < 20);
    return i;
}
int
main(int argc, char **argv)
{
    int i = foo();
    int j = i;
    int k = i;
    printf("%d, %d, %d\n", i, j, k);
    return 0;
}

$ gcc -S -O1 main.c # 优化等级1

[ ... ]
.LC0:
	.string	"%d, %d, %d\n"
[ ... ]
main:
[ ... ]
	call	foo # 调用函数foo，返回值保存至寄存器eax
	movl	%eax, 16(%esp) # 参数k入栈
	movl	%eax, 12(%esp) # 参数j入栈
	movl	%eax, 8(%esp) # 参数i入栈
	movl	$.LC0, 4(%esp) # 格式字符串地址入栈
	movl	$1, (%esp)
	call	__printf_chk
	movl	$0, %eax
	leave
	ret
[ ... ]

[ ... ]
main:
[ ... ]
	call	foo # 调用函数foo，返回值保存至寄存器eax
	movl	%eax, 44(%esp) # 为i赋值
	movl	44(%esp), %edx # 读取i值
	movl	44(%esp), %ecx # 读取i值
	movl	44(%esp), %eax # 读取i值
	movl	%ecx, 16(%esp) # 参数k入栈，使用i值
	movl	%edx, 12(%esp) # 参数j入栈，使用i值
	movl	%eax, 8(%esp) # 参数i入栈
	movl	$.LC0, 4(%esp) # 格式字符串地址入栈
	call	__printf_chk
	movl	$0, %eax
	leave
	ret
[ ... ]

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;
}

std::vector<int> ivec;
//~ or
using std::vector;
vector<int> ivec;
//~ or
using namespace std;
vector<int> ivec;

#include <iostream>
#include <string>
using namespace std;
bool operator<(const string& l, const string& r)
{
    return l > r; //~ 逆天而行了 :-)
}
int
main(int argc, char **argv)
{
    cout<<string("dutor")<string("ivan")<<endl;
    return 0;
}

#include <iostream>
#include <string>
#include <set>
using namespace std;
bool operator<(const string& l, const string& r)
{
    return l > r;
}
int
main(int argc, char **argv)
{
    set<string> Set;
    Set.insert("ivan");
    Set.insert("dutor");
    for(set<string>::iterator it = Set.begin();
            it != Set.end(); ++it)
    {
        cout<<*it<<endl;
    }
    return 0;
}

namespace std{
    bool operator<(const string& l, const string& r)
    {
        return l > r;
    }
}

#include <iostream>
#include <set>
#include <algorithm>
using namespace std;
class cmp
{
public:
	bool operator()(long long l, long long r)
	{
		//~ 此间内容可略去不看。
		//~ 如果l和r含有的digits完全相同则返回false,
		//~ 如125 vs. 512
		char tmp1[1024], tmp2[1024];
		sprintf(tmp1,"%ld",l);
		sprintf(tmp2,"%ld",r);
		sort(tmp1, tmp1+strlen(tmp1));
		sort(tmp2, tmp2+strlen(tmp2));
		if (!strcmp(tmp1, tmp2))
		{
			return false;
		}
		return true;
	}
};
int main(int argc, char* argv[])
{
	set<long long,cmp > Set;
	int a[15];
	Set.insert(1);
	Set.insert(2); //~ 此处疯狂
	return 0;
}

template<class _Pr, class _Ty1, class _Ty2> inline
    bool __CLRCALL_OR_CDECL _Debug_lt_pred(_Pr _Pred, _Ty1& _Left, _Ty2& _Right,
        const wchar_t *_Where, unsigned int _Line)
    {    // test if _Pred(_Left, _Right)  and _Pred is strict weak ordering
    if (!_Pred (_Left, _Right))
        return (false);
    else if (_Pred(_Right, _Left))
        _DEBUG_ERROR2("invalid operator<", _Where, _Line);
    return (true);
    }

class cmp
{
public:
	bool operator()(long long l, long long r)
	{
		//~ ……
		if (!strcmp(tmp1, tmp2))
		{
			return false;
		}
                else
		        return l < r;
	}
};

#include <stdio.h>
int
main()
{
    int a[] = {1, 2, 3, 4, 5};
    int *ptr1 = (int*) (&a + 1) - 1;
    int *ptr2 = (int*) ((int)a + 1);
    printf("%x, %x\n", *ptr1, *ptr2);
    return 0;
}

#include <iostream>
using namespace std;
class Base
{
public:
    static void foo() { cout<<"Base"<<endl; }
    virtual void bar() { foo(); }
};
class Derived: public Base
{
public:
    static void foo() { cout<<"Derived"<<endl; }
    virtual void bar() { foo(); }
};
int main
{
    Base * p = new Derived;
    p->bar();
    delete p;
    return 0;
}

#include <iostream>
class Test
{
public:
    void print() const
    {
        std::cout<<_int<<std::endl;
    }
private:
    static int _int;
};
int Test::_int = 0;
int
main(int argc, char **argv)
{
    Test TArray[10];
    TArray[100].print();
    return 0;
}

.LC0:
	.string	"Hello, Piggy!"
	.text
.globl main
	.type	main, @function
main:
	andl	$-16, %esp
	subl	$32, %esp
	movl	$32, (%esp)
	call	_Znaj
	movl	%eax, 28(%esp)
	movl	$.LC0, 28(%esp) ;把str给覆盖了