使用链表而不是 stdarg 实现可变参数函数
Qidi 2023.10.15
0. 需要使用可变参数函数的场景
常见的场景是类似于 printf(char *fmt, ...) 函数，输入的参数个数和类型都是未知的，此时除了需要 ... 表示可变参数列表，还需要用 fmt 参数说明参数的个数和类型。
还有另一种场景，假设我们要实现一个音频控制功能的程序。在初始设计中，需要实现以下 3 个函数：
int init(char *amplifierType);
int connect(long long audioSource, int speakerMask, float sourceGain);
int setVolume(long long audioSource, int volumeStep);
为了 便于编写测试工具 或 便于用有限状态机管理程序状态，我们需要将函数/接口形式统一，这时也要用到可变参数函数。
本文主要讨论第二种场景。
1. stdarg 的局限
va_start()必须知道可变参数列表的前一个参数，用作查询可变参数列表的起始地址；va_arg()等宏的实现位于编译器内部，不便于阅读研究、了解代码细节。
2. stdarg 的工作原理
程序运行时，函数参数或存于寄存器、或存于栈。因为寄存器是已知的，且栈上的参数位于连续内存地址上，所以 stdarg 可以通过 读取寄存器 和通过 栈上起始地址 获得所有参数。
关于 stdarg 原理的更多介绍，推荐阅读 《AArch64中va_list/va_start/va_arg/...的实现》。
3. 使用链表实现可变参数列表
为了摆脱 va_start() 对参数列表起始地址的依赖，我们可以把函数参数按照从左往右的顺序，依次存储于一个动态创建的链表中。
3.1 链表设计
链表节点要设计得足够通用，可以容纳常用数据类型。比如：
typedef union {
long long m_ll;
char *m_s;
int m_i;
float m_f;
} FuncArgItem;
struct FuncArgChainItem {
FuncArgItem mArgVal;
struct FuncArgChainItem *mpNext;
};
typedef struct FuncArgChainItem FuncArgChainItem_t;
3.2 可变参数函数声明
采用 stdarg 实现可变参数函数时，函数声明的形式类似下方这样：
int init(char *fmt, ...);
int connect(char *fmt, ...);
int setVolume(char *fmt, ...);
或者
int init(char *fmt, va_list ap);
int connect(char *fmt, va_list ap);
int setVolume(char *fmt, va_list ap);
在本文开头，我们其实就已经清楚了 init()、connect()、setVolume() 函数各自能接收的参数个数和类型，所以使用 stdarg 方式传递可变参数时，就算没有 fmt 参数，我们也能在各个函数的函数体里依次取出参数。这里之所以要写出 fmt 参数，完全是因为 stdarg 的相关语法导致。在我们讨论的场景中，fmt 完全是个冗余参数。
采用链表来传递可变参数，就可以规避冗余参数的问题。基于 3.1 节的链表设计，可变参数函数声明应该改为：
int init(FuncArgChainItem_t *argChainHead); // "char *amplifierName"
int connect(FuncArgChainItem_t *argChainHead); // "long long audioSource int speakerMask, float sourceGain"
int setVolume(FuncArgChainItem_t *argChainHead); // "long long audioSource, int volumeStep"
其中 argChainHead 参数是链表头。链表中存储任意多个任意类型的参数。不同函数的参数个数和参数类型可以不同。
此时我们发现，采用可变参数链表替换掉原先的参数后，函数形式变得统一。每个函数都可以用以下函数指针进行表示：
typedef int(*AudioFuncPtr)(FuncArgChainItem_t *);
3.3 函数读取可变参数的方式
函数读取传入的可变参数的方式非常简单。
因为我们早已清楚每个函数需要接收的参数个数和类型，所以在函数体中可以直接从链表里读取各个参数。比如：
int init(FuncArgChainItem_t *argChainHead) // "char *amplifierName"
{
char *amplifierType = argChainHead->mArgVal.m_s;
printf("%s got args: amplifierType(%s)\n", __func__, amplifierType);
return RET_OK;
}
int connect(FuncArgChainItem_t *argChainHead) // "long long audioSource int speakerMask, float sourceGain"
{
long long audioSource = argChainHead->mArgVal.m_ll;
int channelMask = argChainHead->mpNext->mArgVal.m_i;
float sourceGain = argChainHead->mpNext->mpNext->mArgVal.m_f;
printf("%s got args: audioSource(%lld), channelMask(%d), sourceGain(%f)\n", __func__, audioSource, channelMask, sourceGain);
return RET_OK;
}
int setVolume(FuncArgChainItem_t *argChainHead) // "long long audioSource, int volumeStep"
{
long long audioSource = argChainHead->mArgVal.m_ll;
int volumeStep = argChainHead->mpNext->mArgVal.m_i;
printf("%s got args: audioSource(%lld), volumeStep(%d)\n", __func__, audioSource, volumeStep);
return RET_OK;
}
3.4 如何向函数写入可变参数
写入可变参数的方式稍微复杂一点点。
向各个函数写入的可变参数通过链表存储。各个函数所接收的参数个数和类型不同，因此我们需要动态构造拥有不同长度和节点类型的链表。
为了便于动态构造链表，以及让代码更加通用，我们将每个函数和它所需的真实参数信息记录在一张表里。如下（称之为表，实际是个数组）：
typedef enum {
CASE_INIT,
CASE_CONNECT,
CASE_SETVOLUME
} AudioFuncCase;
typedef struct {
int mFuncCase; // AudioFuncCase enumerations
char *mFuncStr;
AudioFuncPtr mFuncPtr;
char *mFuncArg;
char *mFuncArgDesc;
} AudioFuncTableItem;
const AudioFuncTableItem gAudioFuncTable[] = {
// CAUTION: argument descriptions must be extra '\0' terminated, else program may crash!!!
{CASE_INIT, "init", init, "s", "amplifierType\0"},
{CASE_CONNECT, "connect", connect, "ll,i,f", "audioSource\0channelMask\0sourceGain\0"},
{CASE_SETVOLUME, "setVolume", setVolume, "ll,i", "audioSource\0volumeStep\0"}
};
const int gAudioFuncTableSize = sizeof(gAudioFuncTable)/sizeof(AudioFuncTableItem);
其中 mFuncArg 表示各函数真实需要的参数个数和类型。s 表示 char *，ll 表示 long long，i 表示 int，f 表示 `float``。
然后再编写一段代码，根据表里信息为每个函数自动生成可变参数链表，并传入参数。
可变参数列表中，每个参数的值可以从其它地方读取/赋值，也可以是来自手工输入。以手工输入参数值为例，这段代码类似下方：
#define NEW_ARG_ITEM(argVal, argShortType, argChainHead, argChainCurrent) \
\
FuncArgChainItem_t *argChainItem_##argShortType = (FuncArgChainItem_t *)malloc(sizeof(FuncArgChainItem_t)); \
memset(argChainItem_##argShortType, 0, sizeof(FuncArgChainItem_t)); \
argChainItem_##argShortType->mArgVal.m_##argShortType = argVal; \
\
if (argChainHead == NULL) { \
argChainHead = argChainItem_##argShortType; \
} else { \
argChainCurrent->mpNext = argChainItem_##argShortType; \
} \
argChainCurrent = argChainItem_##argShortType;
int callAudioFunc()
{
int ret = RET_ERROR;
FuncArgChainItem_t *argChainHead = NULL, *argChainCurrent = NULL;
char *origArgList = gAudioFuncTable[testCaseChoice].mFuncPtrArg;
int origArgListSize = strlen(origArgList) + 1;
char *copiedArgList = (char *)malloc(origArgListSize);
memcpy(copiedArgList, origArgList, origArgListSize);
char *nextArgDesc = gAudioFuncTable[testCaseChoice].mFuncArgDesc;
char *subArgType, *subArgType_saved;
subArgType = strtok_r(copiedArgList, ",", &subArgType_saved);
while (subArgType != NULL) {
if (strcmp(subArgType, "ll") == 0) {
long long input_ll;
scanf("%lld", &input_ll);
NEW_ARG_ITEM(input_ll, ll, argChainHead, argChainCurrent);
} else if (strcmp(subArgType, "i") == 0) {
int input_i;
scanf("%d", &input_i);
NEW_ARG_ITEM(input_i, i, argChainHead, argChainCurrent);
} else if (strcmp(subArgType, "f") == 0) {
float input_f;
scanf("%f", &input_f);
NEW_ARG_ITEM(input_f, f, argChainHead, argChainCurrent);
} else if (strcmp(subArgType, "s") == 0) {
char input_s[MAX_KVPAIR_SIZE] = {0};
LIMITED_STR_SCANF(MAX_KVPAIR_SIZE-1, input_s);
NEW_ARG_ITEM(input_s, s, argChainHead, argChainCurrent);
} else {
printf("illegal argument type \'%s\'\n", subArgType);
return RET_ERROR;
}
subArgType = strtok_r(NULL, ",", &subArgType_saved);
}
free(copiedArgList);
ret = gAudioFuncTable[testCaseChoice].mFuncPtr(argChainHead);
return ret;
}
至此，我们不使用 stdarg，而是使用链表实现的可变参数函数就可以工作了。
