linux可變參數
Ⅰ 為什麼linux下面的open函數有2種原型這樣做有什麼好處呢求正解。。。
那叫：可變參數。
當其第二個參數含有O_CREAT 時，第三個參數才有效。表示的是當使用open系統調用創建一個文件時，其文件的訪問許可權是多少，第三個參數可以指定為0755，0644等，也可以用系統提供的宏：S_IRWXU、S_IRUSR等代替，一個作用。
兩個都是posix標准，事實上兩個函數是一個。
Ⅱ linux設置環境變數path
變數是計算機系統用於保存可變值的數據類型。在Linux系統中，變數名稱一般都是大寫的，這是一種約定俗成的規范。我們可以直接通過變數名稱來提取到對應的變數值。
Linux系統中的環境變數是用來定義系統運行環境的一些參數，比如每個用戶不同的家目錄、郵件存放位置等。《Linux就該這么學》一起來學習更多linux知識。
PASH環境變數的設置方法：
方法一：用戶主目錄下的.profile或.bashrc文件（推薦）
登錄到你的用戶（非root），在終端輸入：
$ sudo gedit ~/.profile(or .bashrc)
可以在此文件末尾加入PATH的設置如下：
export PATH=」$PATH:your path1:your path2 ...」
保存文件，注銷再登錄，變數生效。
該方式添加的變數只對當前用戶有效。
方法二：系統目錄下的profile文件（謹慎）
在系統的etc目錄下，有一個profile文件，編輯該文件：
$ sudo gedit /etc/profile
在最後加入PATH的設置如下：
export PATH=」$PATH:your path1:your path2 ...」
該文件編輯保存後，重啟系統，變數生效。
該方式添加的變數對所有的用戶都有效。
方法三：系統目錄下的 environment 文件（謹慎）
在系統的etc目錄下，有一個environment文件，編輯該文件：
$ sudo gedit /etc/environment
找到以下的 PATH 變數：
PATH="<......>"
修改該 PATH 變數，在其中加入自己的path即可，例如：
PATH="<......>:your path1:your path2 …"
各個path之間用冒號分割。該文件也是重啟生效，影響所有用戶。
注意這里不是添加export PATH=… 。
方法四：直接在終端下輸入
$ sudo export PATH="$PATH:your path1:your path2 …"
這種方式變數立即生效，但用戶注銷或系統重啟後設置變成無效，適合臨時變數的設置。
Ⅲ printf這樣參數可變的函數如何封裝
C中的可變參數研究
一． 何謂可變參數
int printf( const char* format, ...);
這是使用過C語言的人所再熟悉不過的printf函數原型，它的參數中就有固定參數format和可變參數（用」…」表示）. 而我們又可以用各種方式來調用printf,如:
printf("%d",value);
printf("%s",str);
printf("the number is %d ,string is:%s", value, str);
二.實現原理
C語言用宏來處理這些可變參數。這些宏看起來很復雜，其實原理挺簡單，就是根據參數入棧的特點從最靠近第一個可變參數的固定參數開始，依次獲取每個可變參數的地址。下面我們來分析這些宏。在VC中的stdarg.h頭文件中，針對不同平台有不同的宏定義，我們選取X86平台下的宏定義：
typedef char *va_list;
/*把va_list被定義成char*，這是因為在我們目前所用的PC機上，字元指針類型可以用來存儲內存單元地址。而在有的機器上va_list是被定義成void*的*/
#define _INTSIZEOF(n) ( (sizeof(n) + sizeof(int) - 1) & ~(sizeof(int) - 1) )
/*_INTSIZEOF(n)宏是為了考慮那些內存地址需要對齊的系統，從宏的名字來應該是跟sizeof(int)對齊。一般的sizeof(int)=4，也就是參數在內存中的地址都為4的倍數。比如，如果sizeof(n)在1－4之間，那麼_INTSIZEOF(n)＝4；如果sizeof(n)在5－8之間，那麼_INTSIZEOF(n)=8。*/
#define va_start(ap,v)( ap = (va_list)&v + _INTSIZEOF(v) )
/*va_start的定義為 &v+_INTSIZEOF(v) ,這里&v是最後一個固定參數的起始地址，再加上其實際佔用大小後，就得到了第一個可變參數的起始內存地址。所以我們運行va_start(ap, v)以後,ap指向第一個可變參數在的內存地址*/
#define va_arg(ap,t) ( *(t *)((ap += _INTSIZEOF(t)) - _INTSIZEOF(t)) )
/*這個宏做了兩個事情，
①用用戶輸入的類型名對參數地址進行強制類型轉換，得到用戶所需要的值
②計算出本參數的實際大小，將指針調到本參數的結尾，也就是下一個參數的首地址，以便後續處理。*/
#define va_end(ap) ( ap = (va_list)0 )
/*x86平台定義為ap=(char*)0;使ap不再 指向堆棧,而是跟NULL一樣.有些直接定義為((void*)0),這樣編譯器不會為va_end產生代碼,例如gcc在linux的x86平台就是這樣定義的. 在這里大家要注意一個問題:由於參數的地址用於va_start宏,所以參數不能聲明為寄存器變數或作為函數或數組類型. */
以下再用圖來表示:
在VC等絕大多數C編譯器中，默認情況下，參數進棧的順序是由右向左的，因此，參數進棧以後的內存模型如下圖所示：最後一個固定參數的地址位於第一個可變參數之下，並且是連續存儲的。
|——————————————————————————|
|最後一個可變參數 | ->高內存地址處
|——————————————————————————|
...................
|——————————————————————————|
|第N個可變參數 | ->va_arg(arg_ptr,int)後arg_ptr所指的地方,
| | 即第N個可變參數的地址。
|——————————————— |
………………………….
|——————————————————————————|
|第一個可變參數 | ->va_start(arg_ptr,start)後arg_ptr所指的地方
| | 即第一個可變參數的地址
|——————————————— |
|———————————————————————— ——|
| |
|最後一個固定參數 | -> start的起始地址
|—————————————— —| .................
|—————————————————————————— |
| |
|——————————————— |-> 低內存地址處
三.printf研究
下面是一個簡單的printf函數的實現，參考了中的156頁的例子，讀者可以結合書上的代碼與本文參照。
#include "stdio.h"
#include "stdlib.h"
void myprintf(char* fmt, ...) //一個簡單的類似於printf的實現，//參數必須都是int 類型
{
char* pArg=NULL; //等價於原來的va_list
char c;
pArg = (char*) &fmt; //注意不要寫成p = fmt !!因為這里要對//參數取址，而不是取值
pArg += sizeof(fmt); //等價於原來的va_start
do
{
c =*fmt;
if (c != '%')
{
putchar(c); //照原樣輸出字元
}
else
{
//按格式字元輸出數據
switch(*++fmt)
{
case 'd':
printf("%d",*((int*)pArg));
break;
case 'x':
printf("%#x",*((int*)pArg));
break;
default:
break;
}
pArg += sizeof(int); //等價於原來的va_arg
}
++fmt;
}while (*fmt != '\0');
pArg = NULL; //等價於va_end
return;
}
int main(int argc, char* argv[])
{
int i = 1234;
int j = 5678;
myprintf("the first test:i=%d",i,j);
myprintf("the secend test:i=%d; %x;j=%d;",i,0xabcd,j);
system("pause");
return 0;
}
在intel+win2k+vc6的機器執行結果如下：
the first test:i=1234
the secend test:i=1234; 0xabcd;j=5678;
四.應用
求最大值:
#include //不定數目參數需要的宏
int max(int n,int num,...)
{
va_list x;//說明變數x
va_start(x,num);//x被初始化為指向num後的第一個參數
int m=num;
for(int i=1;i {
//將變數x所指向的int類型的值賦給y,同時使x指向下一個參數
int y=va_arg(x,int);
if(y>m)m=y;
}
va_end(x);//清除變數x
return m;
}
main()
{
printf("%d,%d",max(3,5,56),max(6,0,4,32,45,533));
}
Ⅳ 在LINUX下C語言編程調用這個函數int open(argv[1],O_CREAT|O_RDWR,0755) 執行時參數是怎樣給定的
你好，O_CREAT表示在argv[1]中的文件存在時，第三個參數沒用，並且以讀寫將其打開；argv[1]中的文件不存在時，則創建這個文件，並設置文件的許可權為755，就是用chmod更改的文件許可權，755表示對所有者可讀可寫可執行，對所屬組可讀可執行不可寫，對其他用戶可讀可執行不可寫。
Ⅳ 在Linux9.0中Shell提供變數來設置環境參數和保存shell信息。變數根據不同的作用可以分為哪四種變數設
1）、四種變數分別為：本地變數、環境變數、位置參數變數和預定義變數。
2）、變數=${參數變數:=woed}表示如果設置了參數變數，則用參數變數的值置換變數的值，否則把變數設置成word，然後再用word替換參數的值。如B=${C:=word}中，如果設置了C=good, word=bad時，則B=good; 如果C沒有設置，word=bad,則B=bad,同時把B也設成bad。
3）、$# 表示傳遞到腳本的參數的數量
$! 表示後台運行的最後一個進程號
$0 表示當前執行的進程名
還有不會的請參考《linux就該這么學》，針對各種linux疑難雜症，幫助linux學習者。
Ⅵ Linux編程問題，execl("/bin/ls", "ls", "-al", "/etc/passwd", (char *) 0);
execl,l代表list，參數表的意思，
(char *) 0，代表空指針，說明參數表結束。
這個函數的原型是可變參數，空指針給庫解析參數的時候防止程序錯誤。execl是個庫函數，真正的系統調用是execve。
Ⅶ linux中支不支持可變參數宏
支持的：
本節主要分析宏定義的特殊用法。
一、#與##
1.#
#符號用作一個預處理運算符，它可以把語言符號轉換成字元串。
eg：x是一個宏參數，那麼#x可以把參數名轉換成相應的字元串，這個過程叫字元串化。
test1.c
[cpp] view plain
#include <stdio.h>
#define PSQR(x) printf("the square of" #x "is %d.\n",(x)*(x))
int main(void)
{
int y =4;
PSQR(y);
PSQR(2+4);
return 0;
}
/*result:
the square ofyis 16.
the square of2+4is 36.
*/
gcc test1.c -o test1
./test1
[plain] view plain
the square ofyis 16.
the square of2+4is 36.
2.##
該運算符把兩個語言符號組合成單個語言符號。
test2.c
[cpp] view plain
#include <stdio.h>
#define XNAME(n) x##n
#define PXN(n) printf("x"#n" = %d\n",x##n)
int main(void)
{
int XNAME(1)=12;//int x1=12;
PXN(1);//printf("x1 = %d\n", x1);
return 0;
}
/*result:
x1 = 12
*/
gcc test2.c -o test2
./test2
[plain] view plain
x1 = 12
二、可變參數宏與__VA_ARGS__
__VA_ARGS__是一個可變參數宏，是新的C99規范中新增的，目前只有gcc支持（VC6.0的編譯器不支持）。
宏定義中參數列表的最後一個參數為省略號（也就是三個點）。這樣預定義宏_ _VA_ARGS_ _就可以被用在替換部分中，替換省略號所代表的字元串。
簡單例子：
test3.c
[cpp] view plain
#include <stdio.h>
#define PR(...) printf(__VA_ARGS__)
int main()
{
int wt=1,sp=2;
PR("hello\n");
PR("weight = %d, shipping = %d\n",wt,sp);
return 0;
}
/*result:
hello
weight = 1, shipping = 2
*/
gcc test3.c -o test3
./test3
[plain] view plain
hello
weight = 1, shipping = 2
三、在Linux內核系統調用中的應用
公共介面：
common.h（相當與內核中的systemcalls.h）
[cpp] view plain
#define __SC_DECL1(t1, a1) t1 a1
#define __SC_DECL2(t2, a2, ...) t2 a2, __SC_DECL1(__VA_ARGS__)
#define __SC_DECL3(t3, a3, ...) t3 a3, __SC_DECL2(__VA_ARGS__)
#define __SC_DECL4(t4, a4, ...) t4 a4, __SC_DECL3(__VA_ARGS__)
#define __SC_DECL5(t5, a5, ...) t5 a5, __SC_DECL4(__VA_ARGS__)
#define __SYSCALL_DEFINEx(x, name, ...) \
long sys##name(__SC_DECL##x(__VA_ARGS__))
#define SYSCALL_DEFINEx(x, sname, ...) \
__SYSCALL_DEFINEx(x, sname, __VA_ARGS__)
#define SYSCALL_DEFINE0(name) long sys_##name(void)
#define SYSCALL_DEFINE1(name, ...) SYSCALL_DEFINEx(1, _##name, __VA_ARGS__)
#define SYSCALL_DEFINE5(name, ...) SYSCALL_DEFINEx(5, _##name, __VA_ARGS__)
1.無參數
test4.c
[cpp] view plain
#include <stdio.h>
#include "common.h"
long sys_tank(void);
long sys_tankai(void);
SYSCALL_DEFINE0(tank)
{
printf("TK--------_>>>>>>tank call ok!!!\n");
}
SYSCALL_DEFINE0(tankai)
{
printf("TK--------_>>>>>>tankai call ok!!!\n");
}
int main(){
sys_tank();
sys_tankai();
return 0;
}
/*result:
TK----->>>lianjie(a,b) is 20
TK----->>>lianjie(4,5) is 45
TK--------_>>>>>>tank call ok!!!
TK--------_>>>>>>tankai call ok!!
*/
gcc test4.c -o test4
./test4
[plain] view plain
TK----->>>lianjie(a,b) is 20
TK----->>>lianjie(4,5) is 45
TK--------_>>>>>>tank call ok!!!
TK--------_>>>>>>tankai call ok!!
2.一個參數
test5.c
[cpp] view plain
#include <stdio.h>
#include "common.h"
long sys_tank(int fd);
SYSCALL_DEFINE1(tank, int, fd)
{
printf("TK--------_>>>>>>call ok!!!>>fd is %d\n",fd);
return 0;
}
int main(){
sys_tank(3);
return 0;
}
/*
SYSCALL_DEFINE1(tank,int,fd) = SYSCALL_DEFINEx(1, _tank, int, fd)
SYSCALL_DEFINEx(1, _tank, int, fd) = __SYSCALL_DEFINEx(1, _tank, int, fd)
__SYSCALL_DEFINEx(1, _tank, int, fd) = long sys_tank(__SC_DECL1(int,fd))
long sys_tank(__SC_DECL1(int,fd))
//__SC_DECL1(int,fd) = int fd
//#define __SC_DECL1(t1, a1) t1 a1
//#define __SC_DECL2(t2, a2, ...) t2 a2, __SC_DECL1(__VA_ARGS__)
//#define __SC_DECL3(t3, a3, ...) t3 a3, __SC_DECL2(__VA_ARGS__)
long sys_tank(__SC_DECL1(int,fd)) = long sys_tank(int fd);
*/
/*result:
TK--------_>>>>>>call ok!!!>>fd is 3
*/
gcc test5.c -o test5
./test5
[plain] view plain
TK--------_>>>>>>call ok!!!>>fd is 3
3.五個參數情況，其他不再羅列
test6.c
[cpp] view plain
#include <stdio.h>
#include "common.h"
long sys_mount(char *dev_name, char *dir_name, char *type, unsigned long flags, void *data);
SYSCALL_DEFINE5(mount, char *, dev_name, char *, dir_name, char *, type, unsigned long, flags, void *, data)
{
printf("TK--------_>>>>>>call ok!!!>>>dev_name is %s,dir_name is %s,flags is %d\n",dev_name,dir_name,flags);
return 0;
}
int main(){
sys_mount(".", "/", NULL, 0, NULL);
return 0;
}
/*
SYSCALL_DEFINE5(mount,char *, dev_name, char *, dir_name, char *, type, unsigned long, flags, void *, data) = SYSCALL_DEFINEx(5, _mount, char *, dev_name, char *, dir_name, char *, type, unsigned long, flags, void *, data)
SYSCALL_DEFINEx(5, _mount, char *, dev_name, char *, dir_name, char *, type, unsigned long, flags, void *, data) = __SYSCALL_DEFINEx(5, _mount, char *, dev_name, char *, dir_name, char *, type, unsigned long, flags, void *, data)
__SYSCALL_DEFINEx(5, _mount, char *, dev_name, char *, dir_name, char *, type, unsigned long, flags, void *, data) = long sys_tank(__SC_DECL5(char *, dev_name, char *, dir_name, char *, type, unsigned long, flags, void *, data))
long sys_tank(__SC_DECL1(int,fd))
//__SC_DECL5(char *, dev_name, char *, dir_name, char *, type, unsigned long, flags, void *, data) = char * dev_name, __SC_DECL4(char *, dir_name, char *, type, unsigned long, flags, void *, data)
//......
//__SC_DECL5(char *, dev_name, char *, dir_name, char *, type, unsigned long, flags, void *, data) = char *dev_name, char *dir_name, char *type, unsigned long flags, void *data
//#define __SC_DECL1(t1, a1) t1 a1
//#define __SC_DECL2(t2, a2, ...) t2 a2, __SC_DECL1(__VA_ARGS__)
//#define __SC_DECL3(t3, a3, ...) t3 a3, __SC_DECL2(__VA_ARGS__)
//#define __SC_DECL4(t4, a4, ...) t4 a4, __SC_DECL3(__VA_ARGS__)
//#define __SC_DECL5(t5, a5, ...) t5 a5, __SC_DECL4(__VA_ARGS__)
long sys_mount(__SC_DECL5(int,fd)) = long sys_mount(char *dev_name, char *dir_name, char *type, unsigned long flags, void *data);
*/
/*result:
//TK--------_>>>>>>call ok!!!>>>dev_name is .,dir_name is /,flags is 0
*/
gcc test6.c -o test6
./test6
[plain] view plain
TK--------_>>>>>>call ok!!!>>>dev_name is .,dir_name is /,flags is 0
Ⅷ linux c變參函數參數類型不同怎麼辦
寫一個簡單的可變參數的C函數
下面我們來探討如何寫一個簡單的可變參數的C函數.寫可變參數的
C函數要在程序中用到以下這些宏:
void va_start( va_list arg_ptr, prev_param );
type va_arg( va_list arg_ptr, type );
void va_end( va_list arg_ptr );
va在這里是variable-argument(可變參數)的意思.
這些宏定義在stdarg.h中,所以用到可變參數的程序應該包含這個
頭文件.下面我們寫一個簡單的可變參數的函數,改函數至少有一個整數
參數,第二個參數也是整數,是可選的.函數只是列印這兩個參數的值.
void simple_va_fun(int i, ...)
{
va_list arg_ptr;
int j=0;
va_start(arg_ptr, i);
j=va_arg(arg_ptr, int);
va_end(arg_ptr);
printf("%d %d\n", i, j);
return;
}
我們可以在我們的頭文件中這樣聲明我們的函數:
extern void simple_va_fun(int i, ...);
我們在程序中可以這樣調用:
simple_va_fun(100);
simple_va_fun(100,200);
從這個函數的實現可以看到,我們使用可變參數應該有以下步驟:
1)首先在函數里定義一個va_list型的變數,這里是arg_ptr,這個變
量是指向參數的指針.
2)然後用va_start宏初始化變數arg_ptr,這個宏的第二個參數是第
一個可變參數的前一個參數,是一個固定的參數.
3)然後用va_arg返回可變的參數,並賦值給整數j. va_arg的第二個
參數是你要返回的參數的類型,這里是int型.
4)最後用va_end宏結束可變參數的獲取.然後你就可以在函數里使
用第二個參數了.如果函數有多個可變參數的,依次調用va_arg獲
取各個參數.
如果我們用下面三種方法調用的話,都是合法的,但結果卻不一樣:
1)simple_va_fun(100);
結果是:100 -123456789(會變的值)
2)simple_va_fun(100,200);
結果是:100 200
3)simple_va_fun(100,200,300);
結果是:100 200
我們看到第一種調用有錯誤,第二種調用正確,第三種調用盡管結果
正確,但和我們函數最初的設計有沖突.下面一節我們探討出現這些結果
的原因和可變參數在編譯器中是如何處理的.
(二)可變參數在編譯器中的處理
我們知道va_start,va_arg,va_end是在stdarg.h中被定義成宏的,
由於1)硬體平台的不同 2)編譯器的不同,所以定義的宏也有所不同,下
面以VC++中stdarg.h里x86平台的宏定義摘錄如下(』\』號表示折行):
typedef char * va_list;
#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)) )
#define va_end(ap) ( ap = (va_list)0 )
定義_INTSIZEOF(n)主要是為了某些需要內存的對齊的系統.C語言的函
數是從右向左壓入堆棧的,圖(1)是函數的參數在堆棧中的分布位置.我
們看到va_list被定義成char*,有一些平台或操作系統定義為void*.再
看va_start的定義,定義為&v+_INTSIZEOF(v),而&v是固定參數在堆棧的
地址,所以我們運行va_start(ap, v)以後,ap指向第一個可變參數在堆
棧的地址,如圖:
高地址|-----------------------------|
|函數返回地址 |
|-----------------------------|
|....... |
|-----------------------------|
|第n個參數(第一個可變參數) |
|-----------------------------|<--va_start後ap指向
|第n-1個參數(最後一個固定參數)|
低地址|-----------------------------|<-- &v
圖( 1 )
然後,我們用va_arg()取得類型t的可變參數值,以上例為int型為例,我
們看一下va_arg取int型的返回值:
j= ( *(int*)((ap += _INTSIZEOF(int))-_INTSIZEOF(int)) );
首先ap+=sizeof(int),已經指向下一個參數的地址了.然後返回
ap-sizeof(int)的int*指針,這正是第一個可變參數在堆棧里的地址
(圖2).然後用*取得這個地址的內容(參數值)賦給j.
高地址|-----------------------------|
|函數返回地址 |
|-----------------------------|
|....... |
|-----------------------------|<--va_arg後ap指向
|第n個參數(第一個可變參數) |
|-----------------------------|<--va_start後ap指向
|第n-1個參數(最後一個固定參數)|
低地址|-----------------------------|<-- &v
圖( 2 )
最後要說的是va_end宏的意思,x86平台定義為ap=(char*)0;使ap不再
指向堆棧,而是跟NULL一樣.有些直接定義為((void*)0),這樣編譯器不
會為va_end產生代碼,例如gcc在linux的x86平台就是這樣定義的.
在這里大家要注意一個問題:由於參數的地址用於va_start宏,所
以參數不能聲明為寄存器變數或作為函數或數組類型.
關於va_start, va_arg, va_end的描述就是這些了,我們要注意的
是不同的操作系統和硬體平台的定義有些不同,但原理卻是相似的.
(三)可變參數在編程中要注意的問題
因為va_start, va_arg, va_end等定義成宏,所以它顯得很愚蠢,
可變參數的類型和個數完全在該函數中由程序代碼控制,它並不能智能
地識別不同參數的個數和類型.
有人會問:那麼printf中不是實現了智能識別參數嗎?那是因為函數
printf是從固定參數format字元串來分析出參數的類型,再調用va_arg
的來獲取可變參數的.也就是說,你想實現智能識別可變參數的話是要通
過在自己的程序里作判斷來實現的.
另外有一個問題,因為編譯器對可變參數的函數的原型檢查不夠嚴
格,對編程查錯不利.如果simple_va_fun()改為:
void simple_va_fun(int i, ...)
{
va_list arg_ptr;
char *s=NULL;
va_start(arg_ptr, i);
s=va_arg(arg_ptr, char*);
va_end(arg_ptr);
printf("%d %s\n", i, s);
return;
}
可變參數為char*型,當我們忘記用兩個參數來調用該函數時,就會出現
core mp(Unix) 或者頁面非法的錯誤(window平台).但也有可能不出
錯,但錯誤卻是難以發現,不利於我們寫出高質量的程序.
以下提一下va系列宏的兼容性.
System V Unix把va_start定義為只有一個參數的宏:
va_start(va_list arg_ptr);
而ANSI C則定義為:
va_start(va_list arg_ptr, prev_param);
如果我們要用system V的定義,應該用vararg.h頭文件中所定義的
宏,ANSI C的宏跟system V的宏是不兼容的,我們一般都用ANSI C,所以
用ANSI C的定義就夠了,也便於程序的移植.
Ⅸ linux如何設置變數來拿到不確定個數的參數值
一般在文件的開頭是直接變成你那文件裡面的內容，執行的時候就會替換這個變數名，還有一種就是在這個用戶一個環境用戶變數裡面設置，那麼就會在這個用戶咨詢下的所有文件，所有信息有使用到變數的都會替換。還有一種是設置成系統變數，在系統級別上整個伺服器所有的任何用戶執行任何文件，都可以替換對應的變數。
Ⅹ Linux C開發中的「va_arg, va_start, va_end，va_list」分別表示什麼意思
這是用於實現可變參數的幾個宏，比如printf()這個函數的可變參數就是用這幾個宏實現的。
參考這個，講的很清楚：
http://www.cppblog.com/qiujian5628/archive/2008/01/21/41562.html