ผ่านจำนวนตัวแปรของการขัดแย้งรอบ ๆ

สมมติว่าฉันมีฟังก์ชั่น C ซึ่งรับอาร์กิวเมนต์จำนวนตัวแปร: ฉันจะเรียกฟังก์ชั่นอื่นซึ่งคาดว่าจะมีจำนวนตัวแปรที่ขัดแย้งกันจากภายในได้อย่างไรโดยผ่านอาร์กิวเมนต์ทั้งหมดที่มีในฟังก์ชันแรก

ตัวอย่าง:

void format_string(char *fmt, ...);

void debug_print(int dbg_lvl, char *fmt, ...) {
    format_string(fmt, /* how do I pass all the arguments from '...'? */);
    fprintf(stdout, fmt);
 }

ในการส่งผ่านจุดไข่ปลาคุณต้องแปลงเป็น va_list และใช้ va_list นั้นในฟังก์ชันที่สองของคุณ โดยเฉพาะ;

void format_string(char *fmt,va_list argptr, char *formatted_string);


void debug_print(int dbg_lvl, char *fmt, ...) 
{    
 char formatted_string[MAX_FMT_SIZE];

 va_list argptr;
 va_start(argptr,fmt);
 format_string(fmt, argptr, formatted_string);
 va_end(argptr);
 fprintf(stdout, "%s",formatted_string);
}

ไม่มีวิธีใดในการโทร (เช่น) printf โดยไม่ทราบว่าคุณมีข้อโต้แย้งกี่ข้อที่คุณส่งผ่านเว้นแต่ว่าคุณต้องการใช้กลอุบายที่ซุกซนและไม่พกพาได้

วิธีการแก้ปัญหาที่ใช้โดยทั่วไปคือการมักจะให้รูปแบบอื่นของการทำงาน vararg เพื่อให้printfมีvprintfซึ่งจะใช้เวลาในสถานที่ของva_list รุ่นนี้เป็นเพียงห่อรอบรุ่น......va_list

ฟังก์ชั่น Variadicอาจเป็นอันตรายได้ นี่คือเคล็ดลับที่ปลอดภัยยิ่งขึ้น:

   void func(type* values) {
        while(*values) {
            x = *values++;
            /* do whatever with x */
        }
    }

func((type[]){val1,val2,val3,val4,0});

ใน C ++ 0x ที่งดงามคุณสามารถใช้เทมเพลตแบบแปรผันได้:

template <typename ... Ts>
void format_string(char *fmt, Ts ... ts) {}

template <typename ... Ts>
void debug_print(int dbg_lvl, char *fmt, Ts ... ts)
{
  format_string(fmt, ts...);
}

คุณสามารถใช้ชุดประกอบแบบอินไลน์สำหรับการเรียกใช้ฟังก์ชัน (ในรหัสนี้ฉันถือว่าอาร์กิวเมนต์เป็นตัวอักษร)

void format_string(char *fmt, ...);
void debug_print(int dbg_level, int numOfArgs, char *fmt, ...)
    {
        va_list argumentsToPass;
        va_start(argumentsToPass, fmt);
        char *list = new char[numOfArgs];
        for(int n = 0; n < numOfArgs; n++)
            list[n] = va_arg(argumentsToPass, char);
        va_end(argumentsToPass);
        for(int n = numOfArgs - 1; n >= 0; n--)
        {
            char next;
            next = list[n];
            __asm push next;
        }
        __asm push fmt;
        __asm call format_string;
        fprintf(stdout, fmt);
    }

คุณสามารถลองใช้มาโครได้เช่นกัน

#define NONE    0x00
#define DBG     0x1F
#define INFO    0x0F
#define ERR     0x07
#define EMR     0x03
#define CRIT    0x01

#define DEBUG_LEVEL ERR

#define WHERESTR "[FILE : %s, FUNC : %s, LINE : %d]: "
#define WHEREARG __FILE__,__func__,__LINE__
#define DEBUG(...)  fprintf(stderr, __VA_ARGS__)
#define DEBUG_PRINT(X, _fmt, ...)  if((DEBUG_LEVEL & X) == X) \
                                      DEBUG(WHERESTR _fmt, WHEREARG,__VA_ARGS__)

int main()
{
    int x=10;
    DEBUG_PRINT(DBG, "i am x %d\n", x);
    return 0;
}

แม้ว่าคุณจะสามารถแก้ปัญหาการส่งผ่านฟอร์แมตเตอร์ได้โดยการจัดเก็บไว้ในบัฟเฟอร์ในเครื่องก่อน แต่ก็ต้องใช้สแต็กและบางครั้งก็อาจมีปัญหาในการจัดการ ฉันลองทำตามและดูเหมือนว่าจะทำงานได้ดี

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

void print(char const* fmt, ...)
{
    va_list arg;
    va_start(arg, fmt);
    vprintf(fmt, arg);
    va_end(arg);
}

void printFormatted(char const* fmt, va_list arg)
{
    vprintf(fmt, arg);
}

void showLog(int mdl, char const* type, ...)
{
    print("\nMDL: %d, TYPE: %s", mdl, type);

    va_list arg;
    va_start(arg, type);
    char const* fmt = va_arg(arg, char const*);
    printFormatted(fmt, arg);
    va_end(arg);
}

int main() 
{
    int x = 3, y = 6;
    showLog(1, "INF, ", "Value = %d, %d Looks Good! %s", x, y, "Infact Awesome!!");
    showLog(1, "ERR");
}

หวังว่านี่จะช่วยได้

น้ำยาของ Ross ทำความสะอาดนิดหน่อย ใช้งานได้หาก args ทั้งหมดเป็นตัวชี้เท่านั้น การใช้ภาษาจะต้องสนับสนุนการลบเครื่องหมายจุลภาคก่อนหน้าถ้า__VA_ARGS__ว่างเปล่า (ทั้ง Visual Studio C ++ และ GCC ทำ)

// pass number of arguments version
 #define callVardicMethodSafely(...) {value_t *args[] = {NULL, __VA_ARGS__}; _actualFunction(args+1,sizeof(args) / sizeof(*args) - 1);}


// NULL terminated array version
 #define callVardicMethodSafely(...) {value_t *args[] = {NULL, __VA_ARGS__, NULL}; _actualFunction(args+1);}

สมมติว่าคุณมีฟังก์ชัน Variadic ทั่วไปที่คุณเขียน เนื่องจากต้องมีอาร์กิวเมนต์อย่างน้อยหนึ่งตัวก่อนที่จะมีอาร์กิวเมนต์แบบแปรผัน...คุณจะต้องเขียนอาร์กิวเมนต์เพิ่มเติมในการใช้งานเสมอ

หรือคุณ

หากคุณหุ้มฟังก์ชั่น Variadic ของคุณในแมโครคุณไม่จำเป็นต้องมี arg ก่อนหน้า ลองพิจารณาตัวอย่างนี้:

#define LOGI(...)
    ((void)__android_log_print(ANDROID_LOG_INFO, LOG_TAG, __VA_ARGS__))

เห็นได้ชัดว่าสะดวกกว่าเนื่องจากคุณไม่จำเป็นต้องระบุอาร์กิวเมนต์เริ่มต้นทุกครั้ง

ฉันไม่แน่ใจว่าจะใช้งานได้กับคอมไพเลอร์ทั้งหมดหรือไม่ แต่มันได้ผลสำหรับฉันแล้ว

void inner_func(int &i)
{
  va_list vars;
  va_start(vars, i);
  int j = va_arg(vars);
  va_end(vars); // Generally useless, but should be included.
}

void func(int i, ...)
{
  inner_func(i);
}

คุณสามารถเพิ่ม ... ลงใน inner_func () ได้ถ้าต้องการ แต่ไม่ต้องการ มันทำงานได้เพราะ va_start ใช้ที่อยู่ของตัวแปรที่กำหนดเป็นจุดเริ่มต้น ในกรณีนี้เราจะให้การอ้างอิงกับตัวแปรใน func () ดังนั้นจึงใช้ที่อยู่นั้นและอ่านตัวแปรหลังจากนั้นบนสแต็ก ฟังก์ชัน inner_func () กำลังอ่านจากที่อยู่สแต็คของ func () ดังนั้นจะใช้งานได้ถ้าทั้งสองฟังก์ชั่นใช้กลุ่มสแต็กเดียวกัน

โดยทั่วไปแล้วแมโคร va_start และ va_arg จะใช้งานได้หากคุณให้ var ใด ๆ เป็นจุดเริ่มต้น ดังนั้นหากคุณต้องการคุณสามารถส่งต่อพอยน์เตอร์ไปยังฟังก์ชั่นอื่น ๆ และใช้มันได้ คุณสามารถสร้างมาโครของคุณเองได้อย่างง่ายดาย แมโครทั้งหมดทำคือที่อยู่หน่วยความจำ typecast อย่างไรก็ตามการทำให้มันใช้งานได้สำหรับคอมไพเลอร์ทั้งหมดและการเรียกประชุมก็น่ารำคาญ ดังนั้นโดยทั่วไปแล้วการใช้สิ่งที่มาพร้อมกับคอมไพเลอร์ง่ายกว่า