Есть ли способ определить, сколько символов будет записано sprintf?

Страница руководства для snprintf говорит:

   Return value
       Upon  successful  return,  these  functions return the number of
       characters printed (not including the trailing '\0' used to  end
       output to strings).  The functions snprintf and vsnprintf do not
       write more than size bytes (including the  trailing  '\0').   If
       the output was truncated due to this limit then the return value
       is the number of characters (not including  the  trailing  '\0')
       which  would  have  been  written  to the final string if enough
       space had been available. Thus, a return value of size  or  more
       means  that  the  output  was  truncated.  (See also below under
       NOTES.)  If an output error is encountered, a negative value  is
       returned.

Это означает, что вы можете вызвать snprintf с размером 0. Ничего не будет записано, а возвращаемое значение сообщит вам, сколько места вам нужно выделить для вашей строки:

int how_much_space = snprintf(NULL, 0, fmt_string, param0, param1, ...);

Как уже упоминалось, snprintf() вернет количество символов, необходимое в буфере, чтобы предотвратить усечение вывода. Вы можете просто вызвать его с параметром длины буфера 0, чтобы получить требуемый размер, а затем использовать буфер соответствующего размера.

Для небольшого повышения эффективности вы можете вызвать его с буфером, достаточно большим для нормального случая, и сделать второй вызов snprintf() только в том случае, если вывод усекается. Чтобы убедиться, что в этом случае буферы правильно освобождены, я часто использую объект auto_buffer<>, который обрабатывает динамическую память для меня (и имеет буфер по умолчанию в стеке, чтобы избежать выделения кучи в обычном случае). ).

Если вы используете компилятор Microsoft, у MS есть нестандартный _snprintf(), который имеет серьезные ограничения: не всегда нуль завершает буфер и не указывает, насколько большим должен быть буфер.

Чтобы обойти отказ от поддержки Microsoft, я использую почти общедоступный домен snprintf() от Holger Weiss.

Конечно, если в вашем компиляторе C или C++, отличном от MS, отсутствует snprintf(), код из приведенной выше ссылки должен работать так же хорошо.

Я бы использовал двухэтапный подход. Как правило, большой процент выходных строк будет ниже определенного порога, и только некоторые из них будут больше.

Этап 1. Используйте статический буфер разумного размера, например 4K. Поскольку snprintf() может ограничивать количество записываемых символов, вы не получите переполнения буфера. Что вы получите от snprintf(), так это количество символов, которое он записал бы, если бы ваш буфер был достаточно большим.

Если ваш вызов snprintf() возвращает меньше 4 КБ, используйте буфер и выйдите. Как уже говорилось, подавляющее большинство вызовов должны делать именно это.

Некоторые не будут, и именно тогда вы перейдете к этапу 2. Если вызов snprintf() не помещается в буфер 4K, вы, по крайней мере, теперь знаете, насколько большой буфер вам нужен.

Выделите с помощью malloc() буфер, достаточно большой для его хранения, затем снова snprintf() в этот новый буфер. Когда вы закончите с буфером, освободите его.

Мы работали над системой за несколько дней до snprintf() и добились того же результата, подключив дескриптор файла к /dev/null и используя с ним fprintf(). /dev/null всегда гарантированно принимает столько данных, сколько вы ему даете, поэтому мы фактически получаем размер из этого, а затем при необходимости выделяем буфер.

Имейте в виду, что не во всех системах есть snprintf() (например, я понимаю, что это _snprintf() в Microsoft C), поэтому вам, возможно, придется найти функцию, которая выполняет ту же работу, или вернуться к решению fprintf /dev/null.

Также будьте осторожны, если данные могут быть изменены между проверкой размера snprintf() и фактическим snprintf() в буфере (т.е. следите за потоками). Если размеры увеличиваются, вы получите повреждение переполнения буфера.

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

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

Вы можете использовать его так:

#define _GNU_SOURCE
#include <stdio.h>

int main(int argc, char const *argv[])
{
    char *hi = "hello"; // these could be really long
    char *everyone = "world";
    char *message;
    asprintf(&message, "%s %s", hi, everyone);
    puts(message);
    free(message);
    return 0;
}

Надеюсь, это поможет кому-то!

Взгляните на CodeProject: CString-clone Using Standard C++. Он использует предложенное вами решение с увеличением размера буфера.

// -------------------------------------------------------------------------
    // FUNCTION:  FormatV
    //      void FormatV(PCSTR szFormat, va_list, argList);
    //

    // DESCRIPTION:
    //      This function formats the string with sprintf style format-specs. 
    //      It makes a general guess at required buffer size and then tries
    //      successively larger buffers until it finds one big enough or a
    //      threshold (MAX_FMT_TRIES) is exceeded.
    //
    // PARAMETERS: 
    //      szFormat - a PCSTR holding the format of the output
    //      argList - a Microsoft specific va_list for variable argument lists
    //
    // RETURN VALUE: 
    // -------------------------------------------------------------------------


void FormatV(const CT* szFormat, va_list argList)
{
#ifdef SS_ANSI

    int nLen    = sslen(szFormat) + STD_BUF_SIZE;
    ssvsprintf(GetBuffer(nLen), nLen-1, szFormat, argList);
    ReleaseBuffer();
#else
    CT* pBuf            = NULL;
    int nChars          = 1;
    int nUsed           = 0;
    size_type nActual   = 0;
    int nTry            = 0;

    do  
    {
        // Grow more than linearly (e.g. 512, 1536, 3072, etc)

        nChars          += ((nTry+1) * FMT_BLOCK_SIZE);
        pBuf            = reinterpret_cast<CT*>(_alloca(sizeof(CT)*nChars));
        nUsed           = ssnprintf(pBuf, nChars-1, szFormat, argList);

        // Ensure proper NULL termination.
        nActual         = nUsed == -1 ? nChars-1 : SSMIN(nUsed, nChars-1);
        pBuf[nActual+1]= '\0';


    } while ( nUsed < 0 && nTry++ < MAX_FMT_TRIES );

    // assign whatever we managed to format

    this->assign(pBuf, nActual);
#endif
}

Я искал ту же функциональность, о которой вы говорите, но, насколько я знаю, что-то настолько простое, как метод C99, недоступно в C++, потому что C++ в настоящее время не включает функции, добавленные в C99 (например, snprintf) .

Лучше всего, вероятно, использовать объект stringstream. Это немного более громоздко, чем четко написанный вызов sprintf, но он будет работать.

Поскольку вы используете C++, нет необходимости использовать какую-либо версию sprintf. Проще всего использовать std::ostringstream.

std::ostringstream oss;
oss << a << " " << b << std::endl;

oss.str() возвращает std::string с содержимым того, что вы написали в oss. Используйте oss.str().c_str(), чтобы получить const char *. В долгосрочной перспективе с этим будет намного проще справляться, и он устранит утечки памяти или переполнение буфера. Как правило, если вас беспокоят такие проблемы с памятью, как в C++, вы не используете весь потенциал языка, и вам следует переосмыслить свой дизайн.