sprintf() mit automatischer Speicherzuweisung?

Ich suche ein sprintf()-ähnliche Implementierung einer Funktion, die automatisch den erforderlichen Speicher zuweist. Also möchte ich sagen

char *my_str = dynamic_sprintf("Hello %s, this is a %.*s nice %05d string", a, b, c, d);

und my_str erhält die Adresse eines zugewiesenen Speicherblocks, der das Ergebnis davon enthält sprintf().

In einem anderen Forum habe ich gelesen, dass man das so lösen kann:

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

int main()
{
    char    *ret;
    char    *a = "Hello";
    char    *b = "World";
    int     c = 123;

    int     numbytes;

    numbytes = sprintf((char *)NULL, "%s %d %s!", a, c, b);
    printf("numbytes = %d", numbytes);

    ret = (char *)malloc((numbytes + 1) * sizeof(char));
    sprintf(ret, "%s %d %s!", a, c, b);

    printf("ret = >%s<\n", ret);
    free(ret);

    return 0;
}

Dies führt jedoch sofort zu einem Segfault, wenn die sprintf() mit dem Nullzeiger aufgerufen wird.

Also irgendwelche Ideen, Lösungen oder Tipps? Eine kleine Implementierung von a sprintf()-ähnlicher Parser, der in die Public Domain gestellt wird, würde schon ausreichen, dann könnte ich es selbst erledigen.

Danke vielmals!

Hier ist die ursprüngliche Antwort von Stack Overflow. Wie andere bereits erwähnt haben, müssen Sie snprintf nicht sprintf. Stellen Sie sicher, dass das zweite Argument zu snprintf ist zero. Das wird verhindern snprintf vom Schreiben bis zum NULL Zeichenfolge, die das erste Argument ist.

Das zweite Argument wird benötigt, weil es sagt snprintf dass nicht genügend Platz vorhanden ist, um in den Ausgabepuffer zu schreiben. Wenn nicht genügend Platz vorhanden ist snprintf gibt die Anzahl der Bytes zurück, die es geschrieben hätte, wenn genügend Speicherplatz vorhanden gewesen wäre.

Den Code von diesem Link hier reproduzieren …

char* get_error_message(char const *msg) {
    size_t needed = snprintf(NULL, 0, "%s: %s (%d)", msg, strerror(errno), errno) + 1;
    char  *buffer = malloc(needed);
    sprintf(buffer, "%s: %s (%d)", msg, strerror(errno), errno);
    return buffer;
}

GNU und BSD haben asprintf und vasprintf die dafür entwickelt wurden, genau das für Sie zu tun. Es wird herausfinden, wie der Speicher für Sie zugewiesen wird, und bei jedem Speicherzuweisungsfehler null zurückgeben.

asprintf macht das Richtige in Bezug auf die Zuweisung von Zeichenfolgen – es misst zuerst die Größe und versucht dann mit der Zuweisung malloc. Andernfalls wird null zurückgegeben. Es sei denn, Sie haben ein eigenes Speicherzuweisungssystem, das die Verwendung von ausschließt malloc, asprintf ist das beste Werkzeug für den Job.

Der Code würde wie folgt aussehen:

#define _GNU_SOURCE
#include <stdlib.h>
#include <stdio.h>
#include <string.h>

int main()
{
    char*   ret;
    char*   a = "Hello";
    char*   b = "World";
    int     c = 123;

    int err = asprintf(&ret, "%s %d %s!", a, c, b );
    if (err == -1) {
        fprintf(stderr, "Error in asprintf\n");
        return 1;
    }

    printf("ret = >%s<\n", ret);
    free(ret);

    return 0;
}

Wenn Sie mit GNU/BSD-Erweiterungen leben können, ist die Frage bereits beantwortet. Sie können verwenden asprintf() (und vasprintf() zum Erstellen von Wrapper-Funktionen) und fertig.

Aber snprintf() und vsnprintf() werden laut der Manpage von POSIX vorgeschrieben, und letztere kann verwendet werden, um Ihre eigene einfache Version von zu erstellen asprintf() und vasprintf().

int
vasprintf(char **strp, const char *fmt, va_list ap)
{
    va_list ap1;
    int len;
    char *buffer;
    int res;

    va_copy(ap1, ap);
    len = vsnprintf(NULL, 0, fmt, ap1);

    if (len < 0)
        return len;

    va_end(ap1);
    buffer = malloc(len + 1);

    if (!buffer)
        return -1;

    res = vsnprintf(buffer, len + 1, fmt, ap);

    if (res < 0)
        free(buffer);
    else
        *strp = buffer;

    return res;
}

int
asprintf(char **strp, const char *fmt, ...)
{
    int error;
    va_list ap;

    va_start(ap, fmt);
    error = vasprintf(strp, fmt, ap);
    va_end(ap);

    return error;
}

Sie können etwas Präprozessor-Magie anwenden und Ihre Versionen von Funktionen nur auf Systemen verwenden, die sie nicht unterstützen.

1. Wenn möglich verwenden snprintf — Es bietet eine einfache Möglichkeit, die Größe der erzeugten Daten zu messen, damit Sie Speicherplatz zuweisen können.
2. Wenn du Ja wirklich kann das nicht, eine andere Möglichkeit ist das Drucken in eine temporäre Datei mit fprintf Um die Größe zu erhalten, weisen Sie den Speicher zu und verwenden Sie dann sprintf. snprintf ist bestimmt jedoch die bevorzugte Methode.

Das GLib Bibliothek bietet a g_strdup_printf Funktion, die genau das tut, was Sie wollen, wenn das Verlinken gegen GLib eine Option ist. Aus der Dokumentation:

Ähnlich wie beim Standard-C sprintf()
Funktion, aber sicherer, da sie den maximal erforderlichen Speicherplatz berechnet und Speicher zuweist, um das Ergebnis zu halten. Die zurückgegebene Zeichenfolge sollte mit freigegeben werden g_free() wenn nicht mehr benötigt.

POSIX.1 (alias IEEE 1003.1-2008) bietet open_memstream:

char *ptr;
size_t size;
FILE *f = open_memstream(&ptr, &size);
fprintf(f, "lots of stuff here\n");
fclose(f);
write(1, ptr, size); /* for example */
free(ptr);

open_memstream(3) ist zumindest unter Linux und macOS verfügbar und das schon seit einigen Jahren. Das Gegenteil von open_memstream(3) ist fmemopen(3), das den Inhalt eines Puffers zum Lesen verfügbar macht.

Wenn Sie nur einen einzigen sprintf(3) wollen, dann könnte das weit verbreitete, aber nicht standardmäßige asprintf(3) das sein, was Sie wollen.

/*  casprintf print to allocated or reallocated string

char *aux = NULL;
casprintf(&aux,"first line\n");
casprintf(&aux,"seconde line\n");
printf(aux);
free(aux);
*/
int vcasprintf(char **strp,const char *fmt,va_list ap)
{
  int ret;
  char *strp1;
  char *result;
  if (*strp==NULL)
     return vasprintf(strp,fmt,ap);

  ret=vasprintf(&strp1,fmt,ap); // ret = strlen(strp1) or -1
  if (ret == -1 ) return ret;
  if (ret==0) {free(strp1);return strlen(*strp);}

  size_t len = strlen(*strp);
  *strp=realloc(*strp,len + ret +1);
  memcpy((*strp)+len,strp1,ret+1);
  free(strp1);
  return(len+ret);
}

int casprintf(char **strp, const char *fmt, ...)
{
 int ret;
 va_list ap;
 va_start(ap,fmt);
 ret =vcasprintf(strp,fmt,ap);
 va_end(ap);
 return(ret);
}