Замена или временное решение для asprintf в AIX

asprintf — это вариант семейства функций printf, которые выделяют буфер для хранения отформатированной строки и возвращают ее. Это функция с переменным числом аргументов (отсюда и ... в объявлении, что является допустимым кодом C). Описание можно найти здесь.

Его можно относительно легко переопределить, если vsnprintf работает правильно (т. е. возвращает ошибку, если буфер слишком мал для хранения отформатированной строки).

Вот такая реализация:

#include <stdarg.h>

int asprintf(char **ret, const char *format, ...)
{
    va_list ap;

    *ret = NULL;  /* Ensure value can be passed to free() */

    va_start(ap, format);
    int count = vsnprintf(NULL, 0, format, ap);
    va_end(ap);

    if (count >= 0)
    {
        char* buffer = malloc(count + 1);
        if (buffer == NULL)
            return -1;

        va_start(ap, format);
        count = vsnprintf(buffer, count + 1, format, ap);
        va_end(ap);

        if (count < 0)
        {
            free(buffer);
            return count;
        }
        *ret = buffer;
    }

    return count;
}

Опираясь на Sylvain ответ, вот простая реализация как с asprintf(), так и с vasprintf(), потому что там, где вам нужен один, вам обычно нужен и другой. И, учитывая макрос va_copy() из C99, легко реализовать asprintf() в терминах vasprintf(). Действительно, при написании функций с переменным числом аргументов очень часто полезно иметь их парами, одну с многоточием, а другую с аргументом va_list вместо многоточия, и вы тривиально реализуете первое в терминах второго.

Это приводит к коду:

int vasprintf(char **ret, const char *format, va_list args)
{
    va_list copy;
    va_copy(copy, args);

    /* Make sure it is determinate, despite manuals indicating otherwise */
    *ret = NULL;

    int count = vsnprintf(NULL, 0, format, args);
    if (count >= 0)
    {
        char *buffer = malloc(count + 1);
        if (buffer == NULL)
            count = -1;
        else if ((count = vsnprintf(buffer, count + 1, format, copy)) < 0)
            free(buffer);
        else
            *ret = buffer;
    }
    va_end(copy);  // Each va_start() or va_copy() needs a va_end()

    return count;
}

int asprintf(char **ret, const char *format, ...)
{
    va_list args;
    va_start(args, format);
    int count = vasprintf(ret, format, args);
    va_end(args);
    return(count);
}

Сложная часть использования этих функций в системе, где они не предусмотрены, заключается в том, чтобы решить, где должны быть объявлены функции. В идеале они должны быть в <stdio.h>, но тогда вам не нужно будет их записывать. Итак, у вас должен быть какой-то другой заголовок, который включает <stdio.h>, но объявляет эти функции, если они не объявлены в <stdio.h>. И, в идеале, код должен определять это полуавтоматически. Возможно, заголовок "missing.h" и содержит (частично):

#ifdef HAVE_CONFIG_H
#include "config.h"
#endif /* HAVE_CONFIG_H */

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

#ifndef HAVE_ASPRINTF
extern int asprintf(char **ret, const char *format, ...);
extern int vasprintf(char **ret, const char *format, va_list args);
#endif /* HAVE_ASPRINTF */

Также обратите внимание, что на этой справочной странице для asprintf() говорится, что возвращаемое значение в указатель не определен в случае ошибки. Другие справочные страницы, включая ту, на которую есть ссылка в вопросе, указывают, что она явно устанавливается в NULL при ошибке. Документ комитета по стандарту C (n1337.pdf) не определяет поведение ошибки при нехватке памяти.

• При использовании asprintf() не думайте, что указатель инициализируется в случае сбоя функции.
• При реализации asprintf() убедитесь, что указатель установлен в значение null при ошибке, чтобы обеспечить детерминированное поведение.

Я пришел сюда в поисках быстрой реализации для Windows и Linux, которая устанавливает указатель возврата на NULL в случае сбоя.

Ответ Джонатана Леффлера выглядел лучше, но потом я заметил, что он не устанавливает -1, когда malloc терпит неудачу.

Я провел дополнительные поиски и наткнулся на это обсуждение реализации asprintf, который затем просветил меня, что Джонатан и Сильвен тоже неправильно обрабатывали переполнение.

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

Здесь реализация, которая в большинстве случаев не вызывает snprintf() дважды. Я пропустил включения и определения, как показано в других ответах.

Как и должно быть, определите asprintf() как вызов vasprintf()

int asprintf(char **dst, const char * pcFormat, ...)
{
va_list ap;

  va_start(ap, pcFormat);
  int len = vasprintf(dst, pcFormat, ap);
  va_end(ap);
  return len;
}

Мы заранее выделяем буфер до заранее определенного соответствующего размера и только в случае переполнения вызываем vsnprintf() второй раз. Причина в том, что функция s*printf() считается очень тяжелой, а перераспределение памяти допустимо.

int vasprintf(char **dst, const char * pcFormat, va_list ap)
{
  int len = 512;      /* Worked quite well on our project */
  int allocated = 0;
  va_list ap_copy;
  char *buff = NULL;

  while(len >= allocated) {
    free(buff);
    buff = malloc(len+1);
    if(buff) {
      allocated = len+1;
      va_copy(ap_copy, ap);
      len = vsnprintf(buff, len+1, pcFormat, ap_copy);
      va_end(ap_copy);
    }
    else   /* malloc() failed */
      return -1;
  }
  *dst = buff;
  return len;
}

EDIT: я заменил вызов realloc() простым malloc(), так как он дешевле. В случае переполнения пара free()/malloc() стоит меньше, чем realloc() из-за ее внутреннего скрытого memcpy(). Поскольку мы все равно перезаписываем весь буфер с последующим вызовом vsnprintf(), в этой копии нет смысла.