Лучший способ сохранить va_list для последующего использования в C/C++

Хранение самого va_list — не лучшая идея; стандарт требует только, чтобы аргумент va_list работал с va_start(), va_arg() и va_end(). Насколько я могу судить, va_list не гарантируется возможность создания копии.

Но вам не нужно хранить файл va_list. Скопируйте предоставленные аргументы в другую структуру данных, такую ​​как вектор (вероятно, типа void*), и извлеките их позже обычным способом. Вы должны быть осторожны с типами, но это всегда имеет место для функций в стиле printf в C++.

Этот вопрос меня очень заинтересовал. Кроме того, я столкнусь с аналогичной проблемой в своей работе, поэтому решение, разработанное здесь, может помочь и мне.

Короче говоря, я написал код для проверки концепции, который кэширует переменные аргументы для последующего использования — вы можете найти его ниже.

Мне удалось заставить приведенный ниже код правильно работать как в Windows, так и в Linux на базе Intel. Я скомпилировал с помощью gcc в Linux и MSVC в Windows. Существует дважды повторяющееся предупреждение о злоупотреблении va_start() из gcc — это предупреждение вы можете отключить в своем make-файле.

Я хотел бы знать, работает ли этот код на компиляторе Mac. Может потребоваться небольшая настройка, чтобы заставить его скомпилироваться.

Я понимаю, что этот код:

• Экстремально злоупотребляет va_start(), как это определено стандартом ANSI C.
• Олдскульный байт-ориентированный C.
• Теоретически не переносим при использовании переменной va_list в качестве указателя.

Я использовал malloc() и free() очень обдуманно, поскольку макросы va_list взяты из стандарта C и не являются функциями C++. Я понимаю, что в заголовке вашего вопроса упоминается C++, но я попытался создать полностью C-совместимое решение, кроме использования некоторых комментариев в стиле C++.

Этот код также, без сомнения, имеет некоторые ошибки или непереносимость в обработке строки формата. Я предоставляю это как доказательство концепции, которую я собрал за два часа, а не готовый пример кода, готовый для профессионального использования.

В заявлении об отказе от ответственности говорилось: «Надеюсь, вы найдете результат таким же восхитительным, как и я!» Это был прекрасный вопрос, над которым можно было поразмыслить. Болезненный и извращенный характер результата вызывает у меня глубокий смех. ;)

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

#define VERBOSE 0

#ifdef WINDOWS
#define strdup _strdup
#endif

/*
 * struct cached_printf_args
 *
 * This is used as the pointer type of the dynamically allocated
 * memory which holds a copy of variable arguments.  The struct
 * begins with a const char * which recieves a copy of the printf()
 * format string.
 *
 * The purpose of ending a struct with a zero-length array is to
 * allow the array name to be a symbol to the data which follows
 * that struct.  In this case, additional memory will always be
 * allocted to actually contain the variable args, and cached_printf_args->args
 * will name the start address of that additional buffer space.
 *
 */
struct cached_printf_args
{
    const char * fmt;
    char  args[0];
};


/*
 * copy_va_args -- Accepts a printf() format string and va_list
 *                 arguments.
 *
 *                 Advances the va_list pointer in *p_arg_src in
 *                 accord with the specification in the format string.
 *
 *                 If arg_dest provided is not NULL, each argument
 *                 is copied from *p_arg_src to arg_dest according
 *                 to the format string.
 *
 */
int copy_va_args(const char * fmt, va_list * p_arg_src, va_list arg_dest)
{
    const char * pch = fmt;

    int processing_format = 0;

    while (*pch)
    {
        if (processing_format)
        {
            switch (*pch)
            {
            //case '!': Could be legal in some implementations such as FormatMessage()
            case '0':
            case '1':
            case '2':
            case '3':
            case '4':
            case '5':
            case '6':
            case '7':
            case '8':
            case '9':
            case '.':
            case '-':

                // All the above characters are legal between the % and the type-specifier.
                // As the have no effect for caching the arguments, here they are simply
                // ignored.
                break;

            case 'l':
            case 'I':
            case 'h':
                printf("Size prefixes not supported yet.\n");
                exit(1);

            case 'c':
            case 'C':
                // the char was promoted to int when passed through '...'
            case 'x':
            case 'X':
            case 'd':
            case 'i':
            case 'o':
            case 'u':
                if (arg_dest)
                {
                     *((int *)arg_dest) = va_arg(*p_arg_src, int);
                     va_arg(arg_dest, int);
                }
                else
                    va_arg(*p_arg_src, int);
#if VERBOSE
                printf("va_arg(int), ap = %08X, &fmt = %08X\n", *p_arg_src, &fmt);
#endif
                processing_format = 0;
                break;

            case 's':
            case 'S':
            case 'n':
            case 'p':
                if (arg_dest)
                {
                    *((char **)arg_dest) = va_arg(*p_arg_src, char *);
                    va_arg(arg_dest, char *);
                }
                else
                    va_arg(*p_arg_src, char *);
#if VERBOSE
                printf("va_arg(char *), ap = %08X, &fmt = %08X\n", *p_arg_src, &fmt);
#endif
                processing_format = 0;
                break;

            case 'e':
            case 'E':
            case 'f':
            case 'F':
            case 'g':
            case 'G':
            case 'a':
            case 'A':
                if (arg_dest)
                {
                    *((double *)arg_dest) = va_arg(*p_arg_src, double);
                    va_arg(arg_dest, double);
                }
                else
                    va_arg(*p_arg_src, double);
#if VERBOSE
                printf("va_arg(double), ap = %08X, &fmt = %08X\n", *p_arg_src, &fmt);
#endif
                processing_format = 0;
                break;
            }
        }
        else if ('%' == *pch)
        {
            if (*(pch+1) == '%')
                pch ++;
            else
                processing_format = 1;
        }
        pch ++;
    }

    return 0;
}

/*
 * printf_later -- Accepts a printf() format string and variable
 *                 arguments.
 *
 *                 Returns NULL or a pointer to a struct which can
 *                 later be used with va_XXX() macros to retrieve
 *                 the cached arguments.
 *
 *                 Caller must free() the returned struct as well as
 *                 the fmt member within it.
 *
 */
struct cached_printf_args * printf_later(const char *fmt, ...)
{
    struct cached_printf_args * cache;
    va_list ap;
    va_list ap_dest;
    char * buf_begin, *buf_end;
    int buf_len;

    va_start(ap, fmt);
#if VERBOSE 
    printf("va_start, ap = %08X, &fmt = %08X\n", ap, &fmt);
#endif

    buf_begin = (char *)ap;

    // Make the 'copy' call with NULL destination.  This advances
    // the source point and allows us to calculate the required
    // cache buffer size.
    copy_va_args(fmt, &ap, NULL);

    buf_end = (char *)ap;

    va_end(ap);

    // Calculate the bytes required just for the arguments:
    buf_len = buf_end - buf_begin;

    if (buf_len)
    {
        // Add in the "header" bytes which will be used to fake
        // up the last non-variable argument.  A pointer to a
        // copy of the format string is needed anyway because
        // unpacking the arguments later requires that we remember
        // what type they are.
        buf_len += sizeof(struct cached_printf_args);

        cache = malloc(buf_len);
        if (cache)
        {
            memset(cache, 0, buf_len);
            va_start(ap, fmt);
            va_start(ap_dest, cache->fmt);

            // Actually copy the arguments from our stack to the buffer
            copy_va_args(fmt, &ap, ap_dest);

            va_end(ap);
            va_end(ap_dest);

            // Allocate a copy of the format string
            cache->fmt = strdup(fmt);

            // If failed to allocate the string, reverse allocations and
            // pointers
            if (!cache->fmt)
            {
                free(cache);
                cache = NULL;
            }
        }
    }

    return cache;
}

/*
 * free_printf_cache - frees the cache and any dynamic members
 *
 */
void free_printf_cache(struct cached_printf_args * cache)
{
    if (cache)
        free((char *)cache->fmt);
    free(cache);
}

/*
 * print_from_cache -- calls vprintf() with arguments stored in the
 *                     allocated argument cache
 *
 *
 * In order to compile on gcc, this function must be declared to
 * accept variable arguments.  Otherwise, use of the va_start()
 * macro is not allowed.  If additional arguments are passed to
 * this function, they will not be read.
 */
int print_from_cache(struct cached_printf_args * cache, ...)
{
    va_list arg;

    va_start(arg, cache->fmt);
    vprintf(cache->fmt, arg);
    va_end(arg);
}

int main(int argc, char *argv)
{
    struct cached_printf_args * cache;

    // Allocates a cache of the variable arguments and copy of the format string.
    cache = printf_later("All %d of these arguments will be %s fo%c later use, perhaps in %g seconds.", 10, "stored", 'r', 2.2);

    // Demonstrate the time-line with some commentary to the output.
    printf("This statement intervenes between creation of the cache and its journey to the display.\n"

    // THIS is the call which actually displays the output from the cached printf.
    print_from_cache(cache);

    // Don't forget to return dynamic memory to the free store
    free_printf_cache(cache);

    return 0;

}

Вы можете использовать va_copy(), вот пример:

va_list ap;
va_list tmp;
va_copy(tmp, ap);
//do something with tmp
va_end(tmp);

То, что вы описываете о «удержании номеров, указанных в va_list», - это способ приблизиться к этому.

va_list поддерживает указатели на временную память в стеке (так называемое «автоматическое хранение» в стандарте C). После того, как функция с переменными аргументами вернулась, это автоматическое хранилище исчезло, и его содержимое больше нельзя использовать. Из-за этого вы не можете просто сохранить копию самого va_list — память, на которую он ссылается, будет содержать непредсказуемое содержимое.

В приведенном вами примере вам нужно будет сохранить два целых числа, которые повторно используются при повторном создании этого сообщения. В зависимости от того, сколько различных строк формата вам приходится иметь дело, ваш подход может различаться.

Для совершенно общего типа подхода вам потребуется:

• Напишите функцию "cache_arguments()", которая создает буфер динамической памяти из значений, найденных в переменных аргументах.
• Этот cache_arguments() будет использовать строку формата в стиле printf() вместе с макросами va_start, va_arg, va_end. Вам нужно будет получить типы в соответствии со спецификаторами типов printf(), поскольку sizeof(double) != sizeof(int).
• Сохраните аргументы в кеше памяти с тем же выравниванием и заполнением, что и va_arg() на вашей платформе. (Прочитайте свой файл varargs.h.)
• Сделайте так, чтобы ваши вызовы vsnprintf() работали с этим кэшированным буфером памяти вместо указателя, созданного va_start().

Все перечисленные выше элементы возможны на большинстве платформ, включая Linux и Windows.

Вопрос, который вы, возможно, захотите рассмотреть при переводе, касается порядка слов. Что по-английски пишется как:

Игрок Сэм набрал 20 очков.

На некоторых (человеческих) языках может быть бегло написано только с порядком слов, аналогичным:

Игрок Сэм набрал 20 очков.

По этой причине Win32 FormatMessage() API использует строку формата, подобную printf(), с той функциональной разницей, что параметры нумеруются, например:

Игрок %1 набрал %2!d! баллы.
%2!d! очков набрал игрок %1.

(Тип строки предполагается для каждого аргумента, поэтому %1 эквивалентно %1!s!)

Конечно, вы можете не использовать Win32 API, но функциональность изменения порядка слов форматированных аргументов — это то, что я пытаюсь представить в качестве концепции. Вы также можете реализовать это в своем программном обеспечении.

В C это можно сделать, вместо этого отправив в функцию структуру аргументов. Вы должны передать структуру по ссылке, а затем скопировать (memcpy) структуру в общее место, что позволит вам повторно использовать ее позже. Вы распутываете структуру в месте назначения так же, как вы ее отправили. Вы сохраняете шаблон структуры для «установки и получения».