C programs under Linux

1. function with variable arguments

void myprintf(const char *format, ...) { va_list arglist; va_start(arglist, format); vprintf(format, arglist); // or some other operation va_end(arglist); }

NAME
       printf, fprintf, sprintf, snprintf, vprintf, vfprintf, vsprintf, vsnprintf - formatted output conversion

SYNOPSIS
       #include <stdio.h>

       int printf(const char *format, ...);
       int fprintf(FILE *stream, const char *format, ...);
       int sprintf(char *str, const char *format, ...);
       int snprintf(char *str, size_t size, const char *format, ...);

       #include <stdarg.h>

       int vprintf(const char *format, va_list ap);
       int vfprintf(FILE *stream, const char *format, va_list ap);
       int vsprintf(char *str, const char *format, va_list ap);
       int vsnprintf(char *str, size_t size, const char *format, va_list ap);

 

void va_print(int num, ...) { int n = num; va_list arglist; va_start(arglist, num); while (n > 0) { printf("%s/n", va_arg(arglist, const char*)); n--; } va_end(arglist); } va_print(2, "hello", "world");

 

输出：

hello

world

 

函数调用规范__cdecl(C语言缺省调用约定)中参数从右至左入栈，first在栈顶，fifth在栈底，根据first的地址即可算出后面参数的地址。函数调用者负责清理堆栈，因此可以定义参数个数可变的函数。(注：以下函数在VC6.0下可以编译运行，gcc下可能会有char类型提升相关的警告。)

 

void va_test(int first, ...) #if 0 void va_test(int first, char second, int third, double fourth, const char* fifth) #endif { va_list arglist; va_start(arglist, first); // arglist points to second param char second = va_arg(arglist, char); // arglist points to third param int third = va_arg(arglist, int); // arglist points to fourth param double fourth = va_arg(arglist, double); // arglist points to fifth param const char *fifth = va_arg(arglist, const char*); // arglist points to next address after fifth param printf("%c %d %f %s/n", second, third, fourth, fifth); va_end(arglist); } va_test(0, 'a', 123456, 123.456, "test");

 

输出：a 123456 123.456000 test

 

 

这里给出的也是VC6.0下的定义： 

#ifndef _VA_LIST_DEFINED #ifdef _M_ALPHA typedef struct { char *a0; /* pointer to first homed integer argument */ int offset; /* byte offset of next parameter */ } va_list; #else typedef char * va_list; #endif #define _VA_LIST_DEFINED #endif // 计算某种类型在调用栈中所占的内存大小，一定是sizeof(int)的整数倍，计算机字长的整数倍？ #define _INTSIZEOF(n) ( (sizeof(n) + sizeof(int) - 1) & ~(sizeof(int) - 1) ) // 根据第一个参数的地址和类型大小计算出第二个参数的地址 #define va_start(ap,v) ( ap = (va_list)&v + _INTSIZEOF(v) ) // 根据当前参数的地址和类型大小计算出下一个参数的地址 // 并返回当前参数的值 #define va_arg(ap,t) ( *(t *)((ap += _INTSIZEOF(t)) - _INTSIZEOF(t)) ) // 将当前指针置0 #define va_end(ap) ( ap = (va_list)0 )

 

2. macro with __VA_ARGS__

#include <stdio.h> #include <stdlib.h> #include <libgen.h> #define DBG1(format, ...) do { / fprintf(stderr, "DBG(%s:%s#%d): "format, basename(__FILE__), __FUNCTION__, __LINE__, ##__VA_ARGS__); / } while (0) #define DBG2(format, arg...) do { / fprintf(stderr, "DBG(%s:%s#%d): "format, __FILE__, __FUNCTION__, __LINE__, ##arg); / } while (0) int main(void) { int test = 100; DBG1("this is debug info, %d/n", test); DBG2("this is debug info, %d/n", test); return 0; }

 

3. print 64 bits integer 

#include <stdio.h> int main(void) { unsigned long long ll = 0x1234567890ULL; printf("sizeof(long long): %d/n", sizeof(long long)); printf("value in dec: %llu/n", ll); printf("value in hex: %llx/n", ll); return 0; }

 

sizeof(long long): 8
value in dec: 78187493520
value in hex: 1234567890

 

4. process id, task id and thread id test

#include <stdio.h> #include <stdlib.h> #include <sys/syscall.h> #include <sys/types.h> #include <unistd.h> #include <pthread.h> #define PRINT_IDs(arg) do { / pthread_mutex_lock(&g_mutex); / if (NULL != arg) / printf("enter thread %d .../n", *(int*)arg); / / printf("pthread_self() : %lu/n", pthread_self()); / printf("getpid() : %d/n", getpid()); / printf("syscall(__NR_gettid): %ld/n", syscall(__NR_gettid)); / / if (NULL != arg) / printf("exit thread %d .../n", *(int*)arg); / pthread_mutex_unlock(&g_mutex); / } while(0) static pthread_mutex_t g_mutex = PTHREAD_MUTEX_INITIALIZER; void *thread_entry(void *arg) { PRINT_IDs(arg); } int ids[2] = {1, 2}; int main(void) { printf("enter main() .../n"); pthread_t pt1, pt2; PRINT_IDs(NULL); if (pthread_create(&pt1, NULL, thread_entry, &ids[0]) != 0) printf("failed to create thread 1/n"); if (pthread_create(&pt2, NULL, thread_entry, &ids[1]) != 0) printf("failed to create thread 2/n"); sleep(1); printf("exit main() .../n"); return 0; }

 

> gcc pidtest.c -o pidtest -lpthread

> ./pidtest

 

enter main() ...
pthread_self()      : 3086104256
getpid()            : 18773
syscall(__NR_gettid): 18773
enter thread 2 ...
pthread_self()      : 3077708688
getpid()            : 18773
syscall(__NR_gettid): 18775
exit thread 2 ...
enter thread 1 ...
pthread_self()      : 3086101392
getpid()            : 18773
syscall(__NR_gettid): 18774
exit thread 1 ...
exit main() ...

 

5. SIGCHLD

#include <stdio.h> #include <stdlib.h> #include <string.h> #include <assert.h> #include <pthread.h> #include <signal.h> #include <sys/types.h> #include <sys/wait.h> #include <unistd.h> int g_count = 0; void sig_handler(int sig) { pid_t pid; int status; assert(SIGCHLD == sig); do { pid = waitpid(-1, &status, WNOHANG); if (0 == pid) { // no more childs break; } if (pid < 0) { break; } printf("SIGCHLD from process %d/n", pid); g_count++; } while(pid); } void launch_process() { pid_t pid = fork(); switch(pid) { case -1: // error { } break; case 0: // this is the child { printf("child process %d created by %d/n", getpid(), getppid()); char *argv[] = {"", "-la", ".", NULL}; execve("/bin/ls", argv, NULL); exit(1); } break; default: // this is the father { } break; } } int main(void) { int rc; int i; struct sigaction action; printf("enter main process %d/n", getpid()); memset(&action, 0, sizeof(action)); action.sa_handler = sig_handler; action.sa_flags = SA_RESTART; rc = sigemptyset(&(action.sa_mask)); rc = sigaddset(&(action.sa_mask), SIGCHLD); rc = sigaction(SIGCHLD, &action, NULL); if (0 != rc) { return -1; } for (i=0; i<2; i++) { launch_process(); } while (g_count != 2) sleep(1); printf("main process %d exited/n", getpid()); return 0; }

enter main process 28041
child process 28042 created by 28041
total 72
drwxr-xr-x  2 user user 4096 Jan 31 20:01 .
drwxr-xr-x 42 user user 4096 Jan 31 20:01 ..
-rwxr-xr-x  1 user user 9572 Jan 31 18:58 pidtest
-rw-r--r--  1 user user 1093 Jan 31 18:56 pidtest.c
-rwxr-xr-x  1 user user 9149 Jan 31 12:43 print64
-rw-r--r--  1 user user  226 Jan 31 12:43 print64.c
-rwxr-xr-x  1 user user 9745 Jan 31 20:01 sigchild
-rw-r--r--  1 user user 1468 Jan 31 20:00 sigchild.c
-rwxr-xr-x  1 user user 9266 Jan 31 12:24 vargs
-rw-r--r--  1 user user  489 Jan 31 12:23 vargs.c
SIGCHLD from process 28042
child process 28043 created by 28041
total 72
drwxr-xr-x  2 user user 4096 Jan 31 20:01 .
drwxr-xr-x 42 user user 4096 Jan 31 20:01 ..
-rwxr-xr-x  1 user user 9572 Jan 31 18:58 pidtest
-rw-r--r--  1 user user 1093 Jan 31 18:56 pidtest.c
-rwxr-xr-x  1 user user 9149 Jan 31 12:43 print64
-rw-r--r--  1 user user  226 Jan 31 12:43 print64.c
-rwxr-xr-x  1 user user 9745 Jan 31 20:01 sigchild
-rw-r--r--  1 user user 1468 Jan 31 20:00 sigchild.c
-rwxr-xr-x  1 user user 9266 Jan 31 12:24 vargs
-rw-r--r--  1 user user  489 Jan 31 12:23 vargs.c
SIGCHLD from process 28043
main process 28041 exited

 

 

6. __attribute__((constructor)) and __attribute__((destructor))

#include <stdio.h> #include <stdlib.h> //extern void ctor1(void) __attribute__((constructor)); //extern void ctor2(void) __attribute__((constructor)); //extern void dtor1(void) __attribute__((destructor)); //extern void dtor2(void) __attribute__((destructor)); void __attribute__((constructor)) ctor1(void) { printf("this is %s().../n", __FUNCTION__); } void __attribute__((constructor)) ctor2(void) { printf("this is %s().../n", __FUNCTION__); } void __attribute__((destructor)) dtor1(void) { printf("this is %s().../n", __FUNCTION__); } void __attribute__((destructor)) dtor2(void) { printf("this is %s().../n", __FUNCTION__); } int main(void) { printf("this is main().../n"); }

this is ctor2()...
this is ctor1()...
this is main()...
this is dtor1()...
this is dtor2()...

7. useful macros

1) compute offset of a field in a struct

#define OFFSET_OF(s,m) (size_t)&(((s*)0)->m)

 

2) compute size of a field in a struct

#define SIZE_OF(s,m) sizeof(((s*)0)->m)

 

3) compute maximum value of a given integer type 

// are there other more efficient ways #define MAX_VALUE(type) / (type)( (type)(~0) > 0 ? (type)(~0) : (type)(~0) & ~(1 << (sizeof(type)*8-1)) )  

eg. MAX_VALUE(short)          = 0x7FFF

    MAX_VALUE(unsigned short) = 0xFFFF

    MAX_VALUE(int)            = 0x7FFFFFFF

    MAX_VALUE(unsigned int)   = 0xFFFFFFFF

 

4) exchange two variables without a third variable

 #define EXCHANGE(a,b) (a) ^= (b) ^= (a) ^= (b)