如何計算傳遞給接受可變數量參數的函數的參數數量？

Question

如何計算以下程序中傳遞給函數的參數的數量：

#include<stdio.h>
#include<stdarg.h>
void varfun(int i, ...);
int main(){
        varfun(1, 2, 3, 4, 5, 6);
        return 0;
}
void varfun(int n_args, ...){
        va_list ap;
        int i, t;
        va_start(ap, n_args);
        for(i=0;t = va_arg(ap, int);i++){
               printf("%d", t);
        }
        va_end(ap);
}

該程序在 ubuntu 10.04 下通過我的 gcc 編譯器的輸出：

234561345138032514932134513792

那么如何找到多少沒有。 實際傳遞給函數的參數？

Answer 1

你不能。 您必須設法讓調用者以某種方式指示參數的數量。 你可以：

• 將參數的數量作為第一個變量傳遞
• 要求最后一個變量參數為空、零或其他
• 讓第一個參數描述預期的內容（例如 printf 格式字符串指示應遵循哪些參數）

Answer 2

您可以讓預處理器使用此策略幫助您作弊，從另一個答案中竊取和調整：

#include <stdio.h>
#include <stdarg.h>

#define PP_NARG(...) \
         PP_NARG_(__VA_ARGS__,PP_RSEQ_N())
#define PP_NARG_(...) \
         PP_128TH_ARG(__VA_ARGS__)
#define PP_128TH_ARG( \
          _1, _2, _3, _4, _5, _6, _7, _8, _9,_10, \
         _11,_12,_13,_14,_15,_16,_17,_18,_19,_20, \
         _21,_22,_23,_24,_25,_26,_27,_28,_29,_30, \
         _31,_32,_33,_34,_35,_36,_37,_38,_39,_40, \
         _41,_42,_43,_44,_45,_46,_47,_48,_49,_50, \
         _51,_52,_53,_54,_55,_56,_57,_58,_59,_60, \
         _61,_62,_63,_64,_65,_66,_67,_68,_69,_70, \
         _71,_72,_73,_74,_75,_76,_77,_78,_79,_80, \
         _81,_82,_83,_84,_85,_86,_87,_88,_89,_90, \
         _91,_92,_93,_94,_95,_96,_97,_98,_99,_100, \
         _101,_102,_103,_104,_105,_106,_107,_108,_109,_110, \
         _111,_112,_113,_114,_115,_116,_117,_118,_119,_120, \
         _121,_122,_123,_124,_125,_126,_127,N,...) N
#define PP_RSEQ_N() \
         127,126,125,124,123,122,121,120, \
         119,118,117,116,115,114,113,112,111,110, \
         109,108,107,106,105,104,103,102,101,100, \
         99,98,97,96,95,94,93,92,91,90, \
         89,88,87,86,85,84,83,82,81,80, \
         79,78,77,76,75,74,73,72,71,70, \
         69,68,67,66,65,64,63,62,61,60, \
         59,58,57,56,55,54,53,52,51,50, \
         49,48,47,46,45,44,43,42,41,40, \
         39,38,37,36,35,34,33,32,31,30, \
         29,28,27,26,25,24,23,22,21,20, \
         19,18,17,16,15,14,13,12,11,10, \
         9,8,7,6,5,4,3,2,1,0

void _variad(size_t argc, ...);
#define variad(...) _variad(PP_NARG(__VA_ARGS__), __VA_ARGS__)

void _variad(size_t argc, ...) {
    va_list ap;
    va_start(ap, argc);
    for (int i = 0; i < argc; i++) {
        printf("%d ", va_arg(ap, int));
    }
    printf("\n");
    va_end(ap);
}

int main(int argc, char* argv[]) {
    variad(2, 4, 6, 8, 10);
    return 0;
}

這里有一些巧妙的技巧。

1) 不是直接調用可變參數函數，而是調用一個宏來計算參數並將參數計數作為第一個參數傳遞給函數。 main 上預處理器的最終結果如下所示：

_variad(5, 2, 4, 6, 8, 10);

2) PP_NARG是一個聰明的宏來計算參數。

這里的主力是PP_128TH_ARG 。 它返回第128說法，通過忽略所述第一參數127（任意命名_1 _2 _3等），命名第128參數N ，並限定宏的結果為N 。

PP_NARG調用PP_128TH_ARG ， __VA_ARGS__ PP_128TH_ARG與__VA_ARGS__連接， PP_RSEQ_N是一個從 127 向下計數到 0 的PP_RSEQ_N數字序列。

如果您不提供任何參數，則PP_RSEQ_N的第 128 個值是 0。如果您將一個參數傳遞給PP_NARG ，則該參數將作為_1傳遞給PP_128TH_ARG ； _2將是 127，而PP_128TH_ARG的第 128 個參數將是 1。因此， __VA_ARGS__ PP_RSEQ_N每個參數__VA_ARGS__ PP_RSEQ_N一個，將正確答案留在第 128 個位置。

（顯然127 個參數是 C 允許的最大值。）

Answer 3

如果你有一個 C99 兼容的編譯器（包括預處理器），你可以通過聲明一個為你計算參數數量的宏來規避這個問題。 自己做這個有點棘手，你可以使用P99 宏包中的P99_VA_ARGS來實現這一點。

Answer 4

你不能。 還有一些東西要告訴你（例如對於 printf，它由格式字符串中 % 格式描述符的數量暗示）

Answer 5

你不能。 varargs 並非旨在使這成為可能。 您需要實現一些其他機制來告訴函數有多少個參數。 一種常見的選擇是在參數列表的末尾傳遞一個哨兵參數，例如：

varfun(1, 2, 3, 4, 5, 6, -1);

另一種是在開始時通過計數：

varfun(6, 1, 2, 3, 4, 5, 6);

這更干凈，但不那么安全，因為比在最后記住和維護哨兵更容易弄錯計數或忘記更新它。

這取決於你如何做（考慮 printf 的模型，其中格式字符串決定了有多少和什么類型的參數）。

Answer 6

最安全的方法如上所述。 但是如果你真的需要知道參數的數量而不添加提到的額外參數，那么你可以這樣做（但請注意，它非常依賴機器、操作系統，甚至在極少數情況下依賴於編譯器）。 我在 64 位 DELL E6440 上使用 Visual Studio 2013 運行此代碼。

另一點，在我除以 sizeof(int) 的那一點，那是因為我的所有參數都是 int 的。 如果您有不同的大小參數，我需要在那里進行一些調整。

這依賴於調用程序使用標准的 C 調用約定。 （varfun() 從“add esp,xxx”中獲取參數的數量，add 有兩種形式，(1) 短形式和 (2) 長形式。在第二個測試中，我通過了一個結構體，因為我想模擬大量參數以強制使用長格式）。

打印的答案將是 6 和 501。

    varfun(1, 2, 3, 4, 5, 6);
00A03CC8 6A 06                push        6  
00A03CCA 6A 05                push        5  
00A03CCC 6A 04                push        4  
00A03CCE 6A 03                push        3  
00A03CD0 6A 02                push        2  
00A03CD2 6A 01                push        1  
00A03CD4 E8 E5 D3 FF FF       call        _varfun (0A010BEh)  
00A03CD9 83 C4 18             add         esp,18h  
    varfun(1, x);
00A03CDC 81 EC D0 07 00 00    sub         esp,7D0h  
00A03CE2 B9 F4 01 00 00       mov         ecx,1F4h  
00A03CE7 8D B5 28 F8 FF FF    lea         esi,[x]  
00A03CED 8B FC                mov         edi,esp  
00A03CEF F3 A5                rep movs    dword ptr es:[edi],dword ptr [esi]  
00A03CF1 6A 01                push        1  
00A03CF3 E8 C6 D3 FF FF       call        _varfun (0A010BEh)  
00A03CF8 81 C4 D4 07 00 00    add         esp,7D4h 



#include<stdio.h>
#include<stdarg.h>
void varfun(int i, ...);
int main()
{
    struct eddy
    {
        int x[500];
    } x = { 0 };
    varfun(1, 2, 3, 4, 5, 6);
    varfun(1, x);
    return 0;
}

void varfun(int n_args, ...)
{
    va_list ap;
    unsigned long *p;
    unsigned char *p1;
    unsigned int nargs;
    va_start(ap, n_args);
    p = (long *)(ap - _INTSIZEOF(int) - _INTSIZEOF(&varfun));
    p1 = (char *)*p;
    if (*p1 == 0x83)     // short add sp,x
    {
        nargs = p1[2] / sizeof(int);
    }
    else
    {
        nargs = *(unsigned long *)(p1+2) / sizeof(int);
    }
    printf("%d\n", nargs);
    va_end(ap);
}

Answer 7

您還可以使用一個有意義的值來指示參數的結尾。 就像 0 或 -1。 或者ushort的最大類型大小，如 0xFFFF 。

否則，您需要預先提及計數或使其可從另一個參數中扣除（ printf()類的函數format ） 。

Answer 8

在這段代碼中，當您只傳遞指針時是可能的

# include <unistd.h>
# include <stdarg.h>
# include <string.h>
# include <errno.h>

size_t __print__(char * str1, ...);
# define print(...) __print__(NULL, __VA_ARGS__, NULL)
# define ENDL "\n"

int main() {

  print("1", ENDL, "2", ENDL, "3", ENDL);

  return 0;
}

size_t __print__(char * str1, ...) {
    va_list args;
    va_start(args, str1);
    size_t out_char = 0;
    char * tmp_str;
    while((tmp_str = va_arg(args, char *)) != NULL)
        out_char = out_char + write(1, tmp_str,strlen(tmp_str));
    va_end(args);
    return out_char;
}

Answer 9

您可能需要在包中添加模板和名稱，但在這種情況下會打印 3。

lista.insertar(0, 4, 'W', 4.7);

template<typename... data>
int Lista::insertar(int pos, data... datos) {
    std::cout<< sizeof...(datos)<<std::endl;
}

Answer 10

而不是va_list ，在數組上使用__VA_ARGS__可以讓你達到預期的結果：

#include<stdio.h>

#define count(...)                              \
{                                               \
    int parameters[] = {__VA_ARGS__};           \
    int count = sizeof(parameters)/sizeof(int); \
                                                \
    for (int i = 0; i < count; i++)             \
        printf("%d", parameters[i]);            \
}

int main()
{
    count(1, 2, 3, 4, 5, 6);
    count(7);
    count(8, 9, 10);
}
//12345678910

ps使用typeof() （這是 gcc/clang 擴展；現在是 C23 標准）而不是int以獲得更通用的用法。

Answer 11

從 EBP 讀取指向指針的指針。

#define getReturnAddresses() void ** puEBP = NULL; __asm { mov puEBP, ebp };

用法

getReturnAddresses();
int argumentCount = *((unsigned char*)puEBP[1] + 2) / sizeof(void*) ;
printf("CalledFrom: 0x%08X Argument Count: %i\n", puEBP[1], argumentCount);

不可移植，但我在 __cdecl 方法的 x86 C++ 繞道中使用了它，該方法采用可變數量的參數取得了一些成功。

您可能需要根據堆棧/參數調整 -1 部分。

我沒有想出這個方法。 懷疑我可能在某個時候在 UC 論壇上找到了它。

我不建議在 propper 代碼中使用它，但是如果你在 x86 exe 上有一個 hacky 繞道， __cdecl 調用約定和 1 個參數，然后其余的是 ... 可變參數它可能會工作。 (Win32)

繞行方法的調用約定示例。

void __cdecl hook_ofSomeKind_va_list(void* self, unsigned char first, ...)

證明：屏幕截圖顯示了目標進程上 x32dbg 旁邊的控制台輸出，並應用了繞路

Answer 12

最后追加或 NULL 使我可以擁有任意數量的參數而不必擔心它會出棧

#include <cstdarg>
template<typename _Ty>
inline void variadic_fun1(_Ty param1,...)
{
    va_list arg1;
    //TO_DO

    va_end(arg1);
}
template<typename _Ty> 
void variadic_fun2(_Ty param1,...)
{
    va_list arg1;
    va_start(arg1, param1);
    variadic_fun1(param1, arg1, 0);
    va_end(arg1);
}

Answer 13

更簡單，我認為更優雅的方法是使用 std::initializer_list。 你可以用一個簡單的宏去掉多余的括號，看這個例子：

void doList(const std::initializer_list<std::string>& elts) {
    int count = 0;
    for (std::string s : elts) {
        cout << "(" << count++ << ") " << s << endl;
    }
    cout << "total: " << count << " also as: " << elts.size() <<endl;
}
// and to get rid of extra brackets:
#define DOLIST(...) doList({ __VA_ARGS__ })

使用：

doList({ "this", "is", "a", "initializer_list", "example" } );
DOLIST("and", "a", "variant", "without", "brackets");