Wie berechnet man die Länge der Ausgabe, die sprintf generiert?

Tor: Daten in JSON serialisieren.

Ausgabe: Ich kann vorher nicht wissen, wie viele Zeichen lang die ganze Zahl ist.

Ich dachte, ein guter Weg, dies zu tun, ist die Verwendung von sprintf()

size_t length = sprintf(no_buff, "{data:%d}",12312);
char *buff = malloc(length);
snprintf(buff, length, "{data:%d}",12312);
//buff is passed on ...

Natürlich kann ich eine Stapelvariable wie verwenden char a[256] Anstatt von no_buff.

Frage: Aber gibt es in C ein Dienstprogramm für Wegwerf-Schreibvorgänge wie Unix /dev/null? Etwas so:

#define FORGET_ABOUT_THIS ...
size_t length = sprintf(FORGET_ABOUT_THIS, "{data:%d}",12312);

ps Ich weiß, dass ich die Länge der Ganzzahl auch über das Protokoll erhalten kann, aber auf diese Weise scheint es schöner zu sein.

Da C eine einfache Sprache ist, gibt es keine “wegwerfbaren Puffer” – die gesamte Speicherverwaltung liegt auf den Schultern des Programmierers (es gibt GNU C-Compiler-Erweiterungen dafür, aber sie sind kein Standard).

kann vorher nicht wissen, wie viele Zeichen lang die Ganzzahl ist.

Es gibt viel einfachere Lösung für Ihr Problem. snprintf weiß!

Auf C99-kompatiblen Plattformen rufen Sie snprintf mit NULL als erstem Argument auf:

ssize_t bufsz = snprintf(NULL, 0, "{data:%d}",12312);
char* buf = malloc(bufsz + 1);
snprintf(buf, bufsz + 1, "{data:%d}",12312);

...

free(buf);

Verwenden Sie in älteren Visual Studio-Versionen (mit nicht C99-kompatibler CRT). _scprintf Anstatt von snprintf(NULL, ...) Anruf.

Du kannst anrufen int len = snprintf(NULL, 0, "{data:%d}", 12312) um zu testen, wie viel Platz Sie benötigen.

snprintf wird höchstens gedruckt size Zeichen, wo size ist das zweite Argument und gibt zurück, wie viele Zeichen nötig gewesen wären, um das Ganze zu drucken, ohne das Ende zu zählen '\0'. Da Sie 0 übergeben, wird tatsächlich nichts ausgeschrieben (und somit jede Nullzeiger-Ausnahme vermieden, die beim Versuch einer Dereferenzierung auftreten würde NULL), aber es wird immer noch die Länge zurückgegeben, die für die gesamte Ausgabe erforderlich ist, die Sie zum Zuweisen Ihres Puffers verwenden können.

An diesem Punkt können Sie Ihren Puffer zuweisen und drucken, wobei Sie daran denken, einen weiteren für den Nachlauf einzufügen '\0':

char *buf = malloc(len + 1);
snprintf(buf, len + 1, "{data:%d}", 12312);

Um nur die Länge zu erhalten, können Sie schreiben:

int length = snprintf(NULL, 0, "{data:%d}", 12312);

Beachten Sie, dass der Rückgabetyp ist int. Es kann zurückkehren -1 im Falle eines Fehlers. Stellen Sie sicher, dass Ihre Eingabedaten keine langen Zeichenfolgen enthalten, die dazu führen könnten, dass die Gesamtlänge überschritten wird INT_MAX !

Wenn Sie die Leistung überprüfen, wird die Ausführung von snprintf ohne Ausgabepuffer ungefähr so ​​lange dauern wie ein vollständiger Aufruf.

Daher empfehle ich Ihnen, für alle Fälle einen kleineren Puffer zu verwenden und ihn nur ein zweites Mal aufzurufen, wenn die zurückgegebene Größe die Puffergröße überschreitet.

Dies verwendet C++ std::string aber ich denke, du kannst es an deine Bedürfnisse anpassen.

std::string format(const char* format, ...) {
    va_list args;
    va_start(args, format);
    char smallBuffer[1024];
    int size = vsnprintf(smallBuffer, sizeof smallBuffer, format, args);
    va_end(args);

    if (size < sizeof smallBuffer) 
        return std::string(smallBuffer);

    char buffer[size  + 1]; /* maybe malloc if it's too big */

    va_start(args, format);
    vsnprintf(buffer, sizeof buffer, format, args);
    va_end(args);
    return std::string(buffer);
}

Dieser Code läuft 2x schneller für Strings unter 1k im Vergleich zu den längeren.

Der Aufruf von snprintf(nullptr, 0, …) gibt zwar die Größe zurück, hat aber Leistungseinbußen, da IO_str_overflow aufgerufen wird und das langsam ist.

Wenn Ihnen die Leistung wichtig ist, können Sie einen Dummy-Puffer vorab zuweisen und seinen Zeiger und seine Größe an ::snprintf übergeben. es wird um ein Vielfaches schneller sein als die nullptr-Version.

template<typename ...Args>
size_t get_len(const char* format, Args ...args) {
  static char dummy[4096]; // you can change the default size
  return ::snprintf(dummy, 4096, format, args...) + 1; // +1 for \0
}

Printf unterstützt den %n-Formatparameter, was bedeutet „Position von %n in der Ausgabezeichenfolge in den int-Wert schreiben, auf den der x-Parameter zeigt), also:

int x;snprintf(NULL, 0, "Message: %s%n", "Error!",&x);

Sollte funktionieren!

Dies ist nicht unbedingt eine Antwort auf Ihre Frage, aber Sie können es dennoch hilfreich finden. Es ist nicht portabel, aber wenn Sie es auf glibc ausführen, können Sie es einfach verwenden asprintf() stattdessen, was die Speicherzuweisung für Sie übernimmt.