C语言中可变参数的原理是什么

C语言中可变参数的原理是什么，相信很多没有经验的人对此束手无策，为此本文总结了问题出现的原因和解决方法，通过这篇文章希望你能解决这个问题。

var_list可变参数介绍

VA_LIST 是在C语言中解决变参问题的一组宏，原型：

typedef char* va_list;

其实就是个char*类型变量

除了var_list ，我们还需要几个宏来实现可变参数

「va_start、va_arg、va_end」

#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 )                  // 将指针置为无效

简单使用可变参数

#include <stdio.h> #include <stdarg.h> int AveInt(int, ...); void main() {     printf("%d\t", AveInt(2, 2, 3));     printf("%d\t", AveInt(4, 2, 4, 6, 8));     return; }  int AveInt(int v, ...) {     int ReturnValue = 0;     int i = v;     va_list ap;     va_start(ap, v);     while (i > 0)     {         ReturnValue += va_arg(ap, int);         i--;     }     va_end(ap);     return ReturnValue /= v; }

啊这..

可变参数原理

在进程中,堆栈地址是从高到低分配的.当执行一个函数的时候,将参数列表入栈,压入堆栈的高地址部分,然后入栈函数的返回地址,接着入栈函数的执行代码,这个入栈过程,堆栈地址不断递减,

「黑客就是在堆栈中修改函数返回地址,执行自己的代码来达到执行自己插入的代码段的目的」.

函数在堆栈中的分布情况是:地址从高到低,依次是:函数参数列表,函数返回地址,函数执行代码段.

说这么多直接上代码演示吧..

#include <stdio.h> #include <stdarg.h> int AveInt(int, ...); void main() {     printf("AveInt(2, 2, 4): %d\n", AveInt(2, 2, 4));     return; }  int AveInt(int arGC, ...) {     int ReturnValue = 0;     int next = 0;     va_list arg_ptr;      va_start(arg_ptr, argc);     printf("&argc = %p\n", &argc);            //打印参数i在堆栈中的地址     printf("arg_ptr = %p\n", arg_ptr);  //打印va_start之后arg_ptr地址,比参数i的地址高sizeof(int)个字节           next = *((int*)arg_ptr);     ReturnValue += next;      next = va_arg(arg_ptr, int);     printf("arg_ptr = %p\n", arg_ptr);  //打印va_arg后arg_ptr的地址,比调用va_arg前高sizeof(int)个字节      next = *((int*)arg_ptr);     ReturnValue += next;          va_end(arg_ptr);     return ReturnValue/argc; }

输出：

&argc = 0088FDD4 arg_ptr = 0088FDD8 arg_ptr = 0088FDDC AveInt(2, 2, 4): 3

「这个是为了介绍简单化，所以举的例子」

这样有点不大方便只能获取两个参数的，用可变参数改变一下

#include <stdio.h> #include <stdarg.h> int Arg_ave(int argc, ...); void main() {     printf("Arg_ave(2, 2, 4): %d\n", Arg_ave(2, 2, 4));     return; } int Arg_ave(int argc, ...) {     int value = 0;     int ReturnValue = 0;      va_list arg_ptr;     va_start(arg_ptr, argc);     for (int i = 0; i < argc; i++)     {         value = va_arg(arg_ptr, int);         printf("value[%d]=%d\n", i + 1, value);         ReturnValue += value;     }     return ReturnValue/argc; }

输出

value[1]=2 value[2]=4 Arg_ave(2, 2, 4): 3

当你理解之后你就会说就这?这么简单，指定第一个参数是后面参数的总数就可以了，这还不随随便玩

别着急，精彩的来了，「可变参数的应用」

可变参数应用：实现log打印

#include <stdarg.h> #include <stdio.h> #include <stdlib.h>  typedef void (*libvlcFORMattedLogCallback)(void* data, int level, const void* ctx, const char* message); enum libvlc_log_level {      LIBVLC_DEBUG = 0,       //调试     LIBVLC_NOTICE = 2,      //普通     LIBVLC_WARNING = 3,     //警告     LIBVLC_ERROR = 4 }      //错误 ;  typedef struct CallbackData {     void* managedData;     libvlcFormattedLogCallback managedCallback;     int minLogLevel;        //log 级别 } CallbackData;   void* makeCallbackData(libvlcFormattedLogCallback callback, void* data, int minLevel) {     CallbackData* result = (CallbackData *)malloc(sizeof(CallbackData));     result->managedCallback = callback;     result->managedData = data;     result->minLogLevel = minLevel;     return result; }   void formattedLogCallback(void* data, int level, const void* ctx, const char* message) {     printf("level:%d", level);     if (level == LIBVLC_ERROR)     {         printf("LIBVLC_ERROR:%s", message);         return;     }     if (level >= LIBVLC_WARNING) {         printf("LIBVLC_WARNING:%s", message);         return;     }     if (level >= LIBVLC_NOTICE)     {         printf("LIBVLC_ERROR:%s", message);         return;     }     if (level >= LIBVLC_DEBUG) {         printf("LIBVLC_WARNING:%s", message);         return;     }           }   void InteropCallback(void* data, int level, const void* ctx, const char* fmt, va_list args) {     CallbackData* callbackData = (CallbackData*)data;     if (level >= callbackData->minLogLevel)     {         va_list argsCopy;         int length = 0;          va_copy(argsCopy, args);         length = vsnprintf(NULL, 0, fmt, argsCopy);         va_end(argsCopy);          char* str = malloc(length + 1);         if (str != NULL)         {             va_copy(argsCopy, args);             vsprintf(str, fmt, argsCopy);             va_end(argsCopy);         }         else         {             // Failed to allocate log message, drop it.             return;         }         callbackData->managedCallback(callbackData->managedData, level, ctx, str);         free(str);     } } void sendLog(void* data, int level, const void* ctx, const char* fmt, ...) {     va_list va;     va_start(va, fmt);     InteropCallback(data, level, ctx, fmt, va);     va_end(va); } int main(int argc, char** argv) {          void* callbackData = makeCallbackData(formattedLogCallback, "context", LIBVLC_WARNING);          sendLog(callbackData, LIBVLC_DEBUG, NULL, "This should not be displayed : %s\n","debug");     sendLog(callbackData, LIBVLC_NOTICE, NULL, "This should not be displayed : %s\n", "notick");     sendLog(callbackData, LIBVLC_WARNING, NULL, "This message level is : %s\n", "warning");     sendLog(callbackData, LIBVLC_ERROR, NULL, "Hello, %s ! You should see %ld message here : %s\n", "World", 1, "warning message");      free(callbackData);     return 0; }

输出                                                                                                                                                                                                               

level:3LIBVLC_WARNING:This message level is : warning level:4LIBVLC_ERROR:Hello, World ! You should see 1 message here : warning message

这个使用示例精妙之处在于注册一个指定level的回调函数makeCallbackData(formattedLogCallback, "context",  LIBVLC_WARNING);

看完上述内容，你们掌握C语言中可变参数的原理是什么的方法了吗？如果还想学到更多技能或想了解更多相关内容，欢迎关注编程网其他教程频道，感谢各位的阅读！