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
partition(int *a, int n) //~ seperate a[], using a[0] as pivot
{
    int l = 0, r = n;
    int pivot = a[l];
    while(l < r)
    {
        while( l < r && a[--r] > pivot) ;
        a[l] = a[r];
        while(l < r && a[++l] < pivot) ;
        a[r] = a[l];
    }
    a[l] = pivot;
    return l; //~ return the final index of pivot
}
void
qsort_recur(int *a, int n)
{
    if(n <= 1)
        return;
    int m = partition(a, n);
    if(m <= n / 2)
    {
        qsort_recur(a, m);
        qsort_recur(a + m + 1, n - m - 1);
    }
    else
    {
        qsort_recur(a + m + 1, n - m - 1);
        qsort_recur(a, m);
    }
}

void
qsort_iter(int *a, int n) //~ qsort of 'iterative version
{
    if(n <= 1)
        return ;
    stack<int> ranges; //~ stack of ranges to be sorted
    int l = 0;
    int r = n;
    ranges.push(l); //~ initial range
    ranges.push(r);
    while(!ranges.empty())
    {
        int tr = r = ranges.top(); ranges.pop();
        int tl = l = ranges.top(); ranges.pop();
        if(r - l <= 1) //~ range sorted
            continue;
        //~ partition begins
        int pivot = a[tl];
        while(tr > tl)
        {
            while(tr > tl && a[--tr] > pivot);
            a[tl] = a[tr];
            while(tr > tl && a[++tl] < pivot);
            a[tr] = a[tl];
        }
        a[tl] = pivot;
        //~ partition ends
 
        //~ ranges pushed, with order counting for little
        ranges.push(l); ranges.push(tl);
        ranges.push(tl+1); ranges.push(r);
    }
}

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>
#include <stdlib.h>
#include <unistd.h>
#include <memory.h>
#include <time.h>
#include <sys/time.h> //~ gettimeofday()
 
typedef void (*SORTFUN)(int *a, int n);
 
#define ASIZE 24*1024 //~ array size
#define SCOUNT 6 //~ number of sort method
enum {BUBBLE, INSERT, QSORT, HEAP, MERGE, SHELL};
char *fname[SCOUNT] =
    {
        "Bubble", "Insert", "Qsort",
        "Heap", "Merge", "Shell"
    };
 
SORTFUN fpointer[SCOUNT]; //~ pointers to sort functions
 
int array[SCOUNT][ASIZE]; //~ array(s) under sort.
 
long timeused[SCOUNT]; //~ time taken by every sort function
 
/*******************Generate random data*********************/
void
gen_data(void)
{
    srand(time(NULL)); //~ rand seeding
    for(int i = 0; i < ASIZE; ++i) //~ generate random array[0]
    {
        array[0][i] = rand() % ASIZE;
    }
    for(int i = 1; i < SCOUNT; ++i) //~ copy array[0] to the rest
    {
        for(int j = 0; j < ASIZE; ++j)
        {
            array[i][j] = array[i-1][j];
        }
    }
    //NOTE: using TWO loops to maximize caching
}
 
/***********************Time the time**********************/
long
timer(void) //~ Current Time by millisecond
{
    struct timeval tv;
    gettimeofday(&tv, NULL);
    return (tv.tv_sec * 1000 + tv.tv_usec / 1000);
}
int
main(int AC, char **AV) //~ Both of AC and AV are fascinating ^_^
{
    gen_data();
 
    //NOTE: to disable a function, just comment it out below.
    fpointer[BUBBLE] = bubble_sort;
    fpointer[INSERT] = insert_sort;
    fpointer[QSORT] = quick_sort;
    fpointer[HEAP] = heap_sort;
    fpointer[MERGE] = merge_sort;
    fpointer[SHELL] = shell_sort;
 
    for(int i = 0; i < SCOUNT; ++i)
    {
        long starttime = timer();
        SORTFUN fp = fpointer[i];
        if(fp)
            fp(array[i], ASIZE);
        timeused[i] = timer() - starttime;
    }
 
    //~ Header
    printf("%%Method\t\t%%Time\t\t%%Elements\n");
    printf("-----------------------------------------\n");
    //~ result
    for(int i = 0; i < SCOUNT; ++i)
    {
        printf("%s\t\t%ld\t\t%d\n", fname[i], timeused[i], ASIZE);
    }
    printf("\n");
    return 0;
}

/************************Bubble Sort**************************/
void
bubble_sort(int *a, int n)
{
    for(int i = n - 1; i > 0; --i)
    {
        int issorted = 0; //~ flag, for some optimition
        for(int j = 0; j < i; ++j)
        {
            if(a[j] > a[j+1])
            {
                issorted = 1;
                int tmp = a[j];
                a[j] = a[j+1];
                a[j+1] = tmp;
            }
        }
        if(!issorted)
            break;
    }
}
 
/************************Insert Sort**************************/
void
insert_sort(int *a, int n)
{
    for(int i = 0; i < n - 1; ++i)
    {
        int j = i + 1;
        int tmp = a[j];
        while(j > 0 && tmp < a[j-1])
        {
            a[j] = a[j-1];
            --j;
        }
        a[j] = tmp;
    }
}
 
/************************Quick Sort**************************/
int
partition(int *a, int n) //~ seperate a[], using a[0] as pivot
{
    int l = 0, r = n;
    int pivot = a[l];
    while(l < r)
    {
        while( l < r && a[--r] > pivot) ;
        a[l] = a[r];
        while(l < r && a[++l] < pivot) ;
        a[r] = a[l];
    }
    a[l] = pivot;
    return l; //~ return the final index of pivot
}
void
quick_sort(int *a, int n)
{
    if(n <= 1)
        return;
    int m = partition(a, n);
    if(m <= n / 2)
    {
        quick_sort(a, m);
        quick_sort(a + m + 1, n - m - 1);
    }
    else
    {
        quick_sort(a + m + 1, n - m - 1);
        quick_sort(a, m);
    }
}
 
/************************Quik Sort**************************/
void
sift(int *a, int i, int n) //~ sift to rebuild the heap rooted by a[i]
{
    int tmp = a[i];
    while(2*i + 1 < n)
    {
        int j = 2*i + 1;
        if(j + 1 < n && a[j+1] > a[j])
            ++j;
        if(a[j] > tmp)
        {
            a[i] = a[j];
            i = j;
        }
        else
            break;
    }
    a[i] = tmp;
}
void
heap_sort(int *a, int n)
{
    for(int i = (n-2) / 2; i >= 0; --i) //~ build heap
    {
        sift(a, i, n);
    }
    for(int i = 1; i < n; ++i) //~ rebuild the decreasing heap over and over
    {
        int tmp = a[0];
        a[0] = a[n-i];
        a[n-i] = tmp;
        sift(a, 0, n - i);
    }
}
 
/***********************Merge Sort**********************/
void
merge_sort(int *a, int n)
{
    if(n == 1)
        return;
    int *ext = (int*)malloc(sizeof(int) * n / 2);
    merge_sort(a, n / 2);
    merge_sort(a + n / 2, (n + 1) / 2);
 
    memcpy(ext, a, n / 2 * sizeof(int));
    int i = 0, j = n / 2, k = 0;
    while(i < n / 2 && j < n)
    {
        if(a[j] < ext[i])
            a[k++] = a[j++];
        else
            a[k++] = ext[i++];
    }
    while(i < n / 2)
        a[k++] = ext[i++];
    while(j < n)
        a[k++] = a[j++];
    free(ext);
}
 
/***********************Shell Sort**********************/
void
shell_sort(int * a, int n)
{
    int step = n / 2;
    while(step > 0)
    {
        for(int i = step; i < n; ++i)
        {
            int tmp = *(a + i);
            int j = i - step;
            while(j >= 0 && tmp < *(a + j))
            {
                *(a + j + step) = *(a + j);
                j -= step;
            }
            *(a + j + step) = tmp;
        }
        if(step == 2)
            step = 1;
        else
            step = step * 11 / 5; //~ integer is better
    }
}

#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
lockfile(int fd) //~ try to lock the file, affecting errno when it fails.
{
    struct flock fk;
    fk.l_type = F_WRLCK;
    fk.l_start = 0;
    fk.l_whence = SEEK_SET;
    fk.l_len = 0;
    return (fcntl(fd, F_SETLK, &fk));
}
 
int
already_running(const char* fname) //~ return 1, if another daemon is running
{
    int fd;
    fd = open(fname, O_RDWR|O_CREAT, S_IRUSR|S_IWUSR|S_IRGRP|S_IROTH);
    if( fd < 0 )
    {
        //~ in daemon process, you should use syslog, instead of stdout, for logging
        //~ syslog(LOG_ERR, "cannot open %s: %s", fname, strerror(errno));
        fprintf(stdout, "cannot open %s: %s", fname, strerror(errno));
        fflush(stdout);
        exit(1);
    }
    if( lockfile(fd) < 0 )
    {
        if( errno == EACCES || errno == EAGAIN )
        {
            //~ syslog(LOG_ERR, "cannot lock %s: %s", fname, strerror(errno));
            fprintf(stdout, "cannot lock %s: %s", fname, strerror(errno));
            close(fd);
            return 1;
        }
        //~ syslog(LOG_ERR, "cannot lock %s: %s", fname, strerror(errno));
        fprintf(stdout, "cannot lock %s: %s", fname, strerror(errno));
        fflush(stdout);
        exit(1);
    }
    ftruncate(fd, 0);
    char buf[16];
    sprintf(buf, "%ld", (long)getpid());
    write(fd, buf, strlen(buf) + 1);
    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;
}

#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <sys/types.h>
#include <fcntl.h> //~ O_RDWR, S_IRWXU etc.
#include <pthread.h>
#include <time.h>
#include <limits.h>
#include <signal.h>
 
void daemonize();
 
//~ thread functions
void *listen_ms(void *);
void *listen_kb(void *);
 
//~ time stamp, keeping the time
//~ when the last KB or Mouse event happened.
volatile time_t stamp;
 
//~ mutex keeping stamp consistent.
pthread_mutex_t stamp_mutex;
 
int
main()
{
    daemonize();
    //~ initialize the mutex, stamp
    pthread_mutex_init(&stamp_mutex, NULL);
    //time(&stamp);
    stamp = time(NULL);
 
    //~ create two threads monitoring the Mouse and Keyboard.
    pthread_t ms_tid, kb_tid;
    if(pthread_create(&ms_tid, NULL, listen_ms, NULL) != 0)
    {
        perror("pthread_create");
        exit(1);
    }
    if(pthread_create(&kb_tid, NULL, listen_kb, NULL) != 0)
    {
        perror("pthread_create");
        exit(1);
    }
 
    unsigned int interval = 60 * 30;
    while(1)
    {
        sleep(1);
        pthread_mutex_lock(&stamp_mutex);
        if( time(NULL) - stamp > interval )
        {
            /*printf("shutdown\n");*/
            /*fflush(stdin);*/
            system("init 0");
        }
        pthread_mutex_unlock(&stamp_mutex);
    }
    //~ join the threads, though it'll never be excuted.
    pthread_join(ms_tid, NULL);
    pthread_join(kb_tid, NULL);
 
    return 0;
}
 
void *
listen_ms(void * arg)
{
    int fd = open("/dev/input/mice", O_RDONLY);
    if(fd < 0)
    {
        perror("open mice");
        exit(1);
    }
    char buf[256];
    while( read(fd, buf, sizeof(buf)) > 0 )
    {
        /*printf("Moused Moved.\n");*/
        pthread_mutex_lock(&stamp_mutex);
        //time(&stamp);
        stamp = time(NULL);
        pthread_mutex_unlock(&stamp_mutex);
    }
    close(fd);
}
 
void *
listen_kb(void * arg)
{
    int fd = open("/dev/input/event3", O_RDONLY);
    if(fd < 0)
    {
        perror("open event3");
        exit(1);
    }
    char buf[256];
    while( read(fd, buf, sizeof(buf)) > 0 )
    {
        /*printf("Key Hit.\n");*/
        pthread_mutex_lock(&stamp_mutex);
        //time(&stamp);
        stamp = time(NULL);
        pthread_mutex_unlock(&stamp_mutex);
    }
    close(fd);
}
 
void
daemonize()
{
    if( fork() > 0)
        exit(0);
    setsid();
    close(0);
    close(1);
    close(2);
    int fd = open("/dev/null", O_RDWR);
    //int fd = open("log.txt", O_RDWR);
    dup2(fd, 1);
    dup2(fd, 2);
    chdir("/");
    umask(0);
    signal(SIGCHLD, SIG_IGN);
}

if( fork() > 0)
    exit(0);

int close_all_fd(void)
{
        struct rlimit lim;
        unsigned int i;
 
        if (getrlimit(RLIMIT_NOFILE, &lim) < 0)
                return -1;
        if (lim.rlim_cur == RLIM_INFINITY)
                lim.rlim_cur = 1024;
        for (i = 0; i < lim.rlim_cur; i ++) {
#ifdef MYPERF
                if (i == 1)
                        continue;
#endif
                if (close(i) < 0 && errno != EBADF)
                        return -1;
        }
        return 0;
}

void daemonize();
int
main()
{
    daemonize();
    //~ other operations here.
    return 0;
}
void
daemonize()
{
    if( fork() > 0)
        exit(0);
    setsid();
    close(0); //~ im so lazy a guy.
    close(1);
    close(2);
    //~ you can use I/O functions, but to/from the black hole...
    int fd = open("/dev/null", O_RDWR);
    dup2(fd, 1);
    dup2(fd, 2);
    chdir("/");
    umask(0);
    signal(SIGCHLD, SIG_IGN);
}

int n = 0;
int
main()
{
    while(!n)
        ;
    return 0;
}

int n = 0;
void *foo(void*);
int
main()
{
    pthread_t pth_id;
    pthread_create(&pth_id, NULL, foo, NULL);
    while(!n)
        ;
    pthread_join(pth_id, NULL);
    return 0;
}
 
void *foo(void* arg)
{
    printf("n: %d\n", n);
    sleep(5);
    ++n;
    printf("++n: %d\n", n);
    return NULL;
}

main:
    movl    n(%rip), %eax #从内存中取n值至寄存器eax
.L3:
    testl   %eax, %eax # 与测试eax
    je  .L3 # eax为0时跳转至标号L3处
    movl    $0, %eax
    ret

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

#include "plus.h"
int
plus(int a, int b)
{
    return a + b;
}

#include "sub.h"
int
sub(int a, int b)
{
    return a - b;
}

#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include "plus.h"
int
main(int argc, char **argv)
{
    int a = plus(1, 2);
    printf("%d\n", a);
    return 0;
}

$ cc -c plus.c sub.c
$ ar rc libmath.a plus.o sub.o
$ ranlib libmath.a

$ cc main.c -L. -lmath -o main
$ ./main
3

$ cc -c -fpic plus.c sub.c
$ cc -shared -o libmath.so *.o

$ cc main.c -L. -lmath -o main

$ LD_LIBRARY_PATH=$LD_LIBRARY_PATH:. # 添加当前目录
$ export LD_LIBRARY_PATH # 将环境变量导出，使其在子shell中可用
$ ./main
3

#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <dlfcn.h>
#include "plus.h"
int
main(int argc, char **argv)
{
    void * lib_handle = dlopen("./libmath.so", RTLD_LAZY);
    if(lib_handle)
    {
        int (*plus_ptr)(int, int) = dlsym(lib_handle, "plus");
        if(plus_ptr)
        {
            int a = plus_ptr(1, 2);
            printf("%d\n", a);
        }
        dlclose(lib_handle);
    }
    return 0;
}

$ cc main.c -ldl -o main
$ ./main
3

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