std :: string Formatierung wie sprintf

Ich muss Format std::stringmit sprintfund in Datei - Stream senden. Wie kann ich das machen?

Sie können dies nicht direkt tun, da Sie keinen Schreibzugriff auf den zugrunde liegenden Puffer haben (bis C ++ 11; siehe Dietrich Epps Kommentar ). Sie müssen es zuerst in einem C-String tun und dann in einen std :: string kopieren:

  char buff[100];
  snprintf(buff, sizeof(buff), "%s", "Hello");
  std::string buffAsStdStr = buff;

Aber ich bin mir nicht sicher, warum Sie nicht einfach einen String-Stream verwenden würden? Ich gehe davon aus, dass Sie bestimmte Gründe haben, dies nicht einfach zu tun:

  std::ostringstream stringStream;
  stringStream << "Hello";
  std::string copyOfStr = stringStream.str();

Modernes C ++ macht dies super einfach.

C ++ 20

C ++ 20 wird eingeführt std::format, mit dem Sie genau das tun können. Es werden Ersatzfelder verwendet, die denen in Python ähneln :

#include <iostream>
#include <format>

int main() {
    std::cout << std::format("Hello {}!\n", "world");
}

Lesen Sie die vollständige Dokumentation ! Es ist eine enorme Verbesserung der Lebensqualität.

C ++ 11

Mit C ++ 11 s std::snprintf, wurde dies bereits eine ziemlich einfache und sichere Aufgabe.

#include <memory>
#include <string>
#include <stdexcept>

template<typename ... Args>
std::string string_format( const std::string& format, Args ... args )
{
    size_t size = snprintf( nullptr, 0, format.c_str(), args ... ) + 1; // Extra space for '\0'
    if( size <= 0 ){ throw std::runtime_error( "Error during formatting." ); }
    std::unique_ptr<char[]> buf( new char[ size ] ); 
    snprintf( buf.get(), size, format.c_str(), args ... );
    return std::string( buf.get(), buf.get() + size - 1 ); // We don't want the '\0' inside
}

Das obige Code-Snippet ist unter CC0 1.0 lizenziert .

Zeile für Zeile Erklärung:

Ziel: Schreibe einechar*durchVerwendung std::snprintfund dann konvertierendas zu einstd::string.

Zuerst bestimmen wir die gewünschte Länge des char-Arrays unter Verwendung einer speziellen Bedingung in snprintf. Von cppreference.com :

Rückgabewert

[...] Wenn die resultierende Zeichenfolge aufgrund des Grenzwerts für buf_size abgeschnitten wird, gibt die Funktion die Gesamtzahl der Zeichen (ohne das abschließende Nullbyte) zurück, die geschrieben worden wären, wenn der Grenzwert nicht festgelegt worden wäre.

Dies bedeutet, dass die gewünschte Größe die Anzahl der Zeichen plus eins ist , sodass der Nullterminator hinter allen anderen Zeichen steht und vom Zeichenfolgenkonstruktor wieder abgeschnitten werden kann. Dieses Problem wurde von @ alexk7 in den Kommentaren erklärt.

size_t size = snprintf( nullptr, 0, format.c_str(), args ... ) + 1;

snprintfgibt eine negative Zahl zurück, wenn ein Fehler aufgetreten ist. Daher prüfen wir, ob die Formatierung wie gewünscht funktioniert hat. Wenn Sie dies nicht tun, kann dies zu stillen Fehlern oder zur Zuweisung eines großen Puffers führen, wie @ead in den Kommentaren hervorhebt.

if( size <= 0 ){ throw std::runtime_error( "Error during formatting." ); }

Als nächstes weisen wir ein neues Zeichenarray zu und weisen es einem zu std::unique_ptr. Dies wird im Allgemeinen empfohlen, da Sie es nicht deleteerneut manuell ausführen müssen.

Beachten Sie, dass dies keine sichere Methode zum Zuweisen eines unique_ptrmit benutzerdefinierten Typen ist, da Sie den Speicher nicht freigeben können, wenn der Konstruktor eine Ausnahme auslöst!

std::unique_ptr<char[]> buf( new char[ size ] );

Danach können wir natürlich nur snprintffür den vorgesehenen Verwendungszweck verwenden und den formatierten String in das schreiben char[].

snprintf( buf.get(), size, format.c_str(), args ... );

Schließlich erstellen wir ein neues und geben es zurück, wobei wir std::stringsicherstellen, dass der Null-Terminator am Ende weggelassen wird.

return std::string( buf.get(), buf.get() + size - 1 );

Sie können ein Beispiel in Aktion sehen hier .

Wenn Sie auch std::stringin der Argumentliste verwenden möchten, werfen Sie einen Blick auf diesen Kern .

Zusätzliche Informationen für Visual Studio- Benutzer:

Wie in erklärt diese Antwort , umbenannt Microsoft std::snprintfauf _snprintf(ja, ohne std::). MS setzt es weiter als veraltet und empfiehlt, es _snprintf_sstattdessen zu verwenden , _snprintf_sakzeptiert jedoch nicht, dass der Puffer Null oder kleiner als die formatierte Ausgabe ist, und berechnet in diesem Fall nicht die Ausgabelänge. Um die Verfallswarnungen während der Kompilierung zu entfernen, können Sie die folgende Zeile oben in die Datei einfügen, die Folgendes enthält _snprintf:

#pragma warning(disable : 4996)

Abschließende Gedanken

Viele Antworten auf diese Frage wurden vor C ++ 11 geschrieben und verwenden feste Pufferlängen oder Variablen. Wenn Sie nicht mit alten Versionen von C ++ feststecken, würde ich die Verwendung dieser Lösungen nicht empfehlen. Im Idealfall gehen Sie den C ++ 20-Weg.

Da die C ++ 11-Lösung in dieser Antwort Vorlagen verwendet, kann sie viel Code generieren, wenn sie häufig verwendet wird. Sofern Sie nicht für eine Umgebung mit sehr begrenztem Speicherplatz für Binärdateien entwickeln, ist dies kein Problem und stellt in Bezug auf Klarheit und Sicherheit immer noch eine enorme Verbesserung gegenüber den anderen Lösungen dar.

Wenn die Raumeffizienz sehr wichtig ist, können diese beiden Lösungen mit vargs und vsnprintf nützlich sein. Verwenden Sie keine Lösungen mit festen Pufferlängen, da dies nur zu Problemen führt.

C ++ 11-Lösung, die vsnprintf()intern verwendet:

#include <stdarg.h>  // For va_start, etc.

std::string string_format(const std::string fmt, ...) {
    int size = ((int)fmt.size()) * 2 + 50;   // Use a rubric appropriate for your code
    std::string str;
    va_list ap;
    while (1) {     // Maximum two passes on a POSIX system...
        str.resize(size);
        va_start(ap, fmt);
        int n = vsnprintf((char *)str.data(), size, fmt.c_str(), ap);
        va_end(ap);
        if (n > -1 && n < size) {  // Everything worked
            str.resize(n);
            return str;
        }
        if (n > -1)  // Needed size returned
            size = n + 1;   // For null char
        else
            size *= 2;      // Guess at a larger size (OS specific)
    }
    return str;
}

Ein sicherer und effizienter Ansatz (ich habe ihn getestet und er ist schneller):

#include <stdarg.h>  // For va_start, etc.
#include <memory>    // For std::unique_ptr

std::string string_format(const std::string fmt_str, ...) {
    int final_n, n = ((int)fmt_str.size()) * 2; /* Reserve two times as much as the length of the fmt_str */
    std::unique_ptr<char[]> formatted;
    va_list ap;
    while(1) {
        formatted.reset(new char[n]); /* Wrap the plain char array into the unique_ptr */
        strcpy(&formatted[0], fmt_str.c_str());
        va_start(ap, fmt_str);
        final_n = vsnprintf(&formatted[0], n, fmt_str.c_str(), ap);
        va_end(ap);
        if (final_n < 0 || final_n >= n)
            n += abs(final_n - n + 1);
        else
            break;
    }
    return std::string(formatted.get());
}

Der fmt_strWert wird übergeben, um den Anforderungen von zu entsprechen va_start.

HINWEIS: Die "sicherere" und "schnellere" Version funktioniert auf einigen Systemen nicht. Daher sind beide noch aufgeführt. Außerdem hängt "schneller" vollständig davon ab, ob der Vorbelegungsschritt korrekt ist, andernfalls wird strcpyer langsamer.

boost::format() bietet die gewünschte Funktionalität:

Ab der Übersicht über die Boost-Formatbibliotheken:

Ein Formatobjekt wird aus einer Formatzeichenfolge erstellt und erhält dann durch wiederholte Aufrufe des Operators% Argumente. Jedes dieser Argumente wird dann in Zeichenfolgen konvertiert, die wiederum entsprechend der Formatzeichenfolge zu einer Zeichenfolge kombiniert werden.

#include <boost/format.hpp>

cout << boost::format("writing %1%,  x=%2% : %3%-th try") % "toto" % 40.23 % 50; 
// prints "writing toto,  x=40.230 : 50-th try"

C ++ 20 wird Folgendes enthalten, std::formatdas sprintfin Bezug auf die API ähnelt, jedoch vollständig typsicher ist, mit benutzerdefinierten Typen arbeitet und eine Python-ähnliche Format-String-Syntax verwendet. So können Sie es formatieren std::stringund in einen Stream schreiben:

std::string s = "foo";
std::cout << std::format("Look, a string: {}", s);

oder

std::string s = "foo";
puts(std::format("Look, a string: {}", s).c_str());

Alternativ können Sie die {fmt} -Bibliothek verwenden, um eine Zeichenfolge zu formatieren und in stdouteinen Dateistream auf einmal zu schreiben :

fmt::print(f, "Look, a string: {}", s); // where f is a file stream

Die sprintfmeisten anderen Antworten hier verwenden leider varargs und sind von Natur aus unsicher, es sei denn, Sie verwenden so etwas wie das formatAttribut von GCC , das nur mit Zeichenfolgen im Literalformat funktioniert. Im folgenden Beispiel können Sie sehen, warum diese Funktionen unsicher sind:

std::string format_str = "%s";
string_format(format_str, format_str[0]);

Wo string_formatist eine Implementierung aus der Antwort von Erik Aronesty. Dieser Code wird kompiliert, stürzt jedoch höchstwahrscheinlich ab, wenn Sie versuchen, ihn auszuführen:

$ g++ -Wall -Wextra -pedantic test.cc 
$ ./a.out 
Segmentation fault: 11

Haftungsausschluss : Ich bin der Autor von {fmt} und C ++ 20 std::format.

Wenn Sie nur eine printf-ähnliche Syntax wünschen (ohne printf selbst aufzurufen), schauen Sie sich das Boost-Format an .

Ich habe mein eigenes mit vsnprintf geschrieben, damit es einen String zurückgibt, anstatt meinen eigenen Puffer erstellen zu müssen.

#include <string>
#include <cstdarg>

//missing string printf
//this is safe and convenient but not exactly efficient
inline std::string format(const char* fmt, ...){
    int size = 512;
    char* buffer = 0;
    buffer = new char[size];
    va_list vl;
    va_start(vl, fmt);
    int nsize = vsnprintf(buffer, size, fmt, vl);
    if(size<=nsize){ //fail delete buffer and try again
        delete[] buffer;
        buffer = 0;
        buffer = new char[nsize+1]; //+1 for /0
        nsize = vsnprintf(buffer, size, fmt, vl);
    }
    std::string ret(buffer);
    va_end(vl);
    delete[] buffer;
    return ret;
}

So können Sie es wie verwenden

std::string mystr = format("%s %d %10.5f", "omg", 1, 10.5);

Um std::stringim Sprintf- Format zu formatieren , rufen Sie snprintf(Argumente nullptrund 0) auf, um die benötigte Pufferlänge zu erhalten. Schreiben Sie Ihre Funktion mit einer variablen C ++ 11-Vorlage wie folgt:

#include <cstdio>
#include <string>
#include <cassert>

template< typename... Args >
std::string string_sprintf( const char* format, Args... args ) {
  int length = std::snprintf( nullptr, 0, format, args... );
  assert( length >= 0 );

  char* buf = new char[length + 1];
  std::snprintf( buf, length + 1, format, args... );

  std::string str( buf );
  delete[] buf;
  return str;
}

Kompilieren Sie mit C ++ 11-Unterstützung, zum Beispiel in GCC: g++ -std=c++11

Verwendungszweck:

  std::cout << string_sprintf("%g, %g\n", 1.23, 0.001);

[edit: 20/05/25] noch besser ...:
In der Kopfzeile:

// `say` prints the values
// `says` returns a string instead of printing
// `sayss` appends the values to it's first argument instead of printing
// `sayerr` prints the values and returns `false` (useful for return statement fail-report)<br/>

void PRINTSTRING(const std::string &s); //cater for GUI, terminal, whatever..
template<typename...P> void say(P...p) { std::string r{}; std::stringstream ss(""); (ss<<...<<p); r=ss.str(); PRINTSTRING(r); }
template<typename...P> std::string says(P...p) { std::string r{}; std::stringstream ss(""); (ss<<...<<p); r=ss.str(); return r; }
template<typename...P> void sayss(std::string &s, P...p) { std::string r{}; std::stringstream ss(""); (ss<<...<<p); r=ss.str();  s+=r; } //APPENDS! to s!
template<typename...P> bool sayerr(P...p) { std::string r{}; std::stringstream ss("ERROR: "); (ss<<...<<p); r=ss.str(); PRINTSTRING(r); return false; }

Die Funktion PRINTSTRING(r)besteht darin, die Benutzeroberfläche oder das Terminal oder spezielle Ausgabeanforderungen zu berücksichtigen #ifdef _some_flag_. Die Standardeinstellung lautet:

void PRINTSTRING(const std::string &s) { std::cout << s << std::flush; }

[edit '17 / 8/31] Hinzufügen einer variadic templated version 'vtspf (..)':

template<typename T> const std::string type_to_string(const T &v)
{
    std::ostringstream ss;
    ss << v;
    return ss.str();
};

template<typename T> const T string_to_type(const std::string &str)
{
    std::istringstream ss(str);
    T ret;
    ss >> ret;
    return ret;
};

template<typename...P> void vtspf_priv(std::string &s) {}

template<typename H, typename...P> void vtspf_priv(std::string &s, H h, P...p)
{
    s+=type_to_string(h);
    vtspf_priv(s, p...);
}

template<typename...P> std::string temp_vtspf(P...p)
{
    std::string s("");
    vtspf_priv(s, p...);
    return s;
}

<<Dies ist effektiv eine durch Kommas getrennte Version (anstelle) der manchmal behindernden Operatoren, die wie folgt verwendet werden:

char chSpace=' ';
double pi=3.1415;
std::string sWorld="World", str_var;
str_var = vtspf("Hello", ',', chSpace, sWorld, ", pi=", pi);

[Bearbeiten] Angepasst, um die Technik in Erik Aronestys Antwort (oben) zu nutzen:

#include <string>
#include <cstdarg>
#include <cstdio>

//=============================================================================
void spf(std::string &s, const std::string fmt, ...)
{
    int n, size=100;
    bool b=false;
    va_list marker;

    while (!b)
    {
        s.resize(size);
        va_start(marker, fmt);
        n = vsnprintf((char*)s.c_str(), size, fmt.c_str(), marker);
        va_end(marker);
        if ((n>0) && ((b=(n<size))==true)) s.resize(n); else size*=2;
    }
}

//=============================================================================
void spfa(std::string &s, const std::string fmt, ...)
{
    std::string ss;
    int n, size=100;
    bool b=false;
    va_list marker;

    while (!b)
    {
        ss.resize(size);
        va_start(marker, fmt);
        n = vsnprintf((char*)ss.c_str(), size, fmt.c_str(), marker);
        va_end(marker);
        if ((n>0) && ((b=(n<size))==true)) ss.resize(n); else size*=2;
    }
    s += ss;
}

[vorherige Antwort]
Eine sehr späte Antwort, aber für diejenigen, die wie ich den 'Sprintf'-Weg mögen: Ich habe geschrieben und benutze die folgenden Funktionen. Wenn es Ihnen gefällt, können Sie die% -Optionen erweitern, um sie besser an die Sprint-Optionen anzupassen. Die dort sind derzeit für meine Bedürfnisse ausreichend. Sie verwenden stringf () und stringfappend () wie sprintf. Denken Sie daran, dass die Parameter für ... POD-Typen sein müssen.

//=============================================================================
void DoFormatting(std::string& sF, const char* sformat, va_list marker)
{
    char *s, ch=0;
    int n, i=0, m;
    long l;
    double d;
    std::string sf = sformat;
    std::stringstream ss;

    m = sf.length();
    while (i<m)
    {
        ch = sf.at(i);
        if (ch == '%')
        {
            i++;
            if (i<m)
            {
                ch = sf.at(i);
                switch(ch)
                {
                    case 's': { s = va_arg(marker, char*);  ss << s;         } break;
                    case 'c': { n = va_arg(marker, int);    ss << (char)n;   } break;
                    case 'd': { n = va_arg(marker, int);    ss << (int)n;    } break;
                    case 'l': { l = va_arg(marker, long);   ss << (long)l;   } break;
                    case 'f': { d = va_arg(marker, double); ss << (float)d;  } break;
                    case 'e': { d = va_arg(marker, double); ss << (double)d; } break;
                    case 'X':
                    case 'x':
                        {
                            if (++i<m)
                            {
                                ss << std::hex << std::setiosflags (std::ios_base::showbase);
                                if (ch == 'X') ss << std::setiosflags (std::ios_base::uppercase);
                                char ch2 = sf.at(i);
                                if (ch2 == 'c') { n = va_arg(marker, int);  ss << std::hex << (char)n; }
                                else if (ch2 == 'd') { n = va_arg(marker, int); ss << std::hex << (int)n; }
                                else if (ch2 == 'l') { l = va_arg(marker, long);    ss << std::hex << (long)l; }
                                else ss << '%' << ch << ch2;
                                ss << std::resetiosflags (std::ios_base::showbase | std::ios_base::uppercase) << std::dec;
                            }
                        } break;
                    case '%': { ss << '%'; } break;
                    default:
                    {
                        ss << "%" << ch;
                        //i = m; //get out of loop
                    }
                }
            }
        }
        else ss << ch;
        i++;
    }
    va_end(marker);
    sF = ss.str();
}

//=============================================================================
void stringf(string& stgt,const char *sformat, ... )
{
    va_list marker;
    va_start(marker, sformat);
    DoFormatting(stgt, sformat, marker);
}

//=============================================================================
void stringfappend(string& stgt,const char *sformat, ... )
{
    string sF = "";
    va_list marker;
    va_start(marker, sformat);
    DoFormatting(sF, sformat, marker);
    stgt += sF;
}

So macht es Google: StringPrintf(BSD-Lizenz)
und Facebook machen es auf ganz ähnliche Weise: StringPrintf(Apache-Lizenz)
Beide bieten auch eine bequeme StringAppendF.

Meine zwei Cent zu dieser sehr beliebten Frage.

Um die Manpage printfähnlicher Funktionen zu zitieren :

Bei erfolgreicher Rückgabe geben diese Funktionen die Anzahl der gedruckten Zeichen zurück (mit Ausnahme des Nullbytes, mit dem die Ausgabe an Zeichenfolgen beendet wird).

Die Funktionen snprintf () und vsnprintf () schreiben nicht mehr als Größenbytes (einschließlich des abschließenden Nullbytes ('\ 0')). Wenn die Ausgabe aufgrund dieser Begrenzung abgeschnitten wurde, ist der Rückgabewert die Anzahl der Zeichen (ohne das abschließende Nullbyte), die in die endgültige Zeichenfolge geschrieben worden wären, wenn genügend Speicherplatz verfügbar gewesen wäre. Ein Rückgabewert von Größe oder mehr bedeutet also, dass die Ausgabe abgeschnitten wurde.

Mit anderen Worten, eine vernünftige C ++ 11-Implementierung sollte wie folgt aussehen:

#include <string>
#include <cstdio>

template <typename... Ts>
std::string fmt (const std::string &fmt, Ts... vs)
{
    char b;
    size_t required = std::snprintf(&b, 0, fmt.c_str(), vs...) + 1;
        // See comments: the +1 is necessary, while the first parameter
        //               can also be set to nullptr

    char bytes[required];
    std::snprintf(bytes, required, fmt.c_str(), vs...);

    return std::string(bytes);
}

Es funktioniert ganz gut :)

Variadische Vorlagen werden nur in C ++ 11 unterstützt. Die Antwort von Pixelpoint zeigt eine ähnliche Technik unter Verwendung älterer Programmierstile.

Es ist seltsam, dass C ++ so etwas nicht sofort einsatzbereit hat. Sie haben kürzlich hinzugefügt to_string(), was meiner Meinung nach ein großer Schritt nach vorne ist. Ich frage mich, ob sie irgendwann einen .formatOperator zum std::string...

Bearbeiten

Wie alexk7 hervorhob, wird A +1für den Rückgabewert von benötigt std::snprintf, da wir Platz für das \0Byte benötigen . Intuitiv führt bei den meisten fehlenden Architekturen +1dazu, dass die requiredGanzzahl teilweise mit a überschrieben wird 0. Dies geschieht nach der Auswertung requiredals Istparameter für std::snprintf, daher sollte der Effekt nicht sichtbar sein.

Dieses Problem könnte sich jedoch beispielsweise bei der Compileroptimierung ändern: Was passiert, wenn der Compiler beschließt, ein Register für die requiredVariable zu verwenden? Dies ist die Art von Fehlern, die manchmal zu Sicherheitsproblemen führen.

template<typename... Args>
std::string string_format(const char* fmt, Args... args)
{
    size_t size = snprintf(nullptr, 0, fmt, args...);
    std::string buf;
    buf.reserve(size + 1);
    buf.resize(size);
    snprintf(&buf[0], size + 1, fmt, args...);
    return buf;
}

Verwenden von C99 snprintf und C ++ 11

Getestet, Antwort auf die Produktionsqualität

Diese Antwort behandelt den allgemeinen Fall mit standardkonformen Techniken. Der gleiche Ansatz wird als Beispiel auf CppReference.com am Ende ihrer Seite angegeben. Im Gegensatz zu ihrem Beispiel entspricht dieser Code den Anforderungen der Frage und wird in Robotik- und Satellitenanwendungen vor Ort getestet. Es hat auch das Kommentieren verbessert. Die Designqualität wird weiter unten erläutert.

#include <string>
#include <cstdarg>
#include <vector>

// requires at least C++11
const std::string vformat(const char * const zcFormat, ...) {

    // initialize use of the variable argument array
    va_list vaArgs;
    va_start(vaArgs, zcFormat);

    // reliably acquire the size
    // from a copy of the variable argument array
    // and a functionally reliable call to mock the formatting
    va_list vaArgsCopy;
    va_copy(vaArgsCopy, vaArgs);
    const int iLen = std::vsnprintf(NULL, 0, zcFormat, vaArgsCopy);
    va_end(vaArgsCopy);

    // return a formatted string without risking memory mismanagement
    // and without assuming any compiler or platform specific behavior
    std::vector<char> zc(iLen + 1);
    std::vsnprintf(zc.data(), zc.size(), zcFormat, vaArgs);
    va_end(vaArgs);
    return std::string(zc.data(), iLen); }

#include <ctime>
#include <iostream>
#include <iomanip>

// demonstration of use
int main() {

    std::time_t t = std::time(nullptr);
    std::cerr
        << std::put_time(std::localtime(& t), "%D %T")
        << " [debug]: "
        << vformat("Int 1 is %d, Int 2 is %d, Int 3 is %d", 11, 22, 33)
        << std::endl;
    return 0; }

Vorhersagbare lineare Effizienz

Zwei Durchgänge sind für eine sichere, zuverlässige und vorhersehbare wiederverwendbare Funktion gemäß den Fragenspezifikationen erforderlich. Vermutungen über die Verteilung der Größe von Variablen in einer wiederverwendbaren Funktion sind ein schlechter Programmierstil und sollten vermieden werden. In diesem Fall sind beliebig große Darstellungen variabler Länge von Variablen ein Schlüsselfaktor bei der Wahl des Algorithmus.

Ein erneuter Versuch beim Überlauf ist exponentiell ineffizient. Dies ist ein weiterer Grund, der erörtert wurde, als das C ++ 11-Standardkomitee den obigen Vorschlag erörterte, einen Probelauf bereitzustellen, wenn der Schreibpuffer Null ist.

In der obigen produktionsfertigen Implementierung ist der erste Lauf ein solcher Trockenlauf, um die Zuordnungsgröße zu bestimmen. Es erfolgt keine Zuordnung. Das Parsen von printf-Anweisungen und das Lesen von vargs wurde über Jahrzehnte äußerst effizient gemacht. Wiederverwendbarer Code sollte vorhersehbar sein, auch wenn eine kleine Ineffizienz für triviale Fälle geopfert werden muss.

Sicherheit und Zuverlässigkeit

Andrew Koenig sagte nach seinem Vortrag auf einer Veranstaltung in Cambridge zu einer kleinen Gruppe von uns: "Benutzerfunktionen sollten sich nicht darauf verlassen, dass ein Fehler für außergewöhnliche Funktionen ausgenutzt wird." Wie üblich hat sich seine Weisheit seitdem in der Aufzeichnung als wahr erwiesen. Behobene und geschlossene Sicherheitslücken weisen häufig auf Wiederholungshacks in der Beschreibung des vor dem Fix ausgenutzten Lochs hin.

Dies wird im Überarbeitungsvorschlag für formale Standards für die Nullpufferfunktion in Alternative zu Sprintf, C9X-Überarbeitungsvorschlag , ISO IEC-Dokument WG14 N645 / X3J11 96-008 erwähnt . Eine willkürlich lange Zeichenfolge, die gemäß der Druckanweisung "% s" im Rahmen der dynamischen Speicherverfügbarkeit eingefügt wird, ist keine Ausnahme und sollte nicht zur Erzeugung von "nicht außergewöhnlichen Funktionen" verwendet werden.

Betrachten Sie den Vorschlag neben dem Beispielcode, der unten auf der Seite C ++ Reference.org angegeben ist, auf die im ersten Absatz dieser Antwort verwiesen wird.

Auch das Testen von Fehlerfällen ist selten so robust wie Erfolgsfälle.

Portabilität

Alle großen Betriebssystemanbieter bieten Compiler an, die std :: vsnprintf als Teil der c ++ 11-Standards vollständig unterstützen. Hosts, auf denen Produkte von Anbietern ausgeführt werden, die keine Distributionen mehr verwalten, sollten aus vielen Gründen mit g ++ oder clang ++ ausgestattet sein.

Stapelverwendung

Die Stapelverwendung im ersten Aufruf von std :: vsnprintf ist kleiner oder gleich der des zweiten Aufrufs und wird freigegeben, bevor der zweite Aufruf beginnt. Wenn der erste Aufruf die Stapelverfügbarkeit überschreitet, schlägt auch std :: fprintf fehl.

C ++ 20 std::format

Es ist angekommen! Die Funktion wird unter folgender Adresse beschrieben: http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2019/p0645r9.html und verwendet eine Python-ähnliche .format()Syntax.

Ich erwarte, dass die Verwendung wie folgt sein wird:

#include <format>
#include <string>

int main() {
    std::string message = std::format("The answer is {}.", 42);
}

Ich werde es versuchen, wenn der Support bei GCC eintrifft. GCC 9.1.0 g++-9 -std=c++2aunterstützt ihn immer noch nicht.

Die API fügt einen neuen std::formatHeader hinzu:

Die vorgeschlagene Formatierungs-API wird im neuen Header definiert <format>und sollte keine Auswirkungen auf vorhandenen Code haben.

Die vorhandene fmtBibliothek behauptet, sie zu implementieren, wenn Sie die Polyfüllung benötigen: https://github.com/fmtlib/fmt

Implementierung von C ++ 20 std::format.

und wurde bereits erwähnt unter: std :: string Formatierung wie sprintf

Basierend auf der Antwort von Erik Aronesty:

std::string string_format(const std::string &fmt, ...) {
    std::vector<char> str(100,'\0');
    va_list ap;
    while (1) {
        va_start(ap, fmt);
        auto n = vsnprintf(str.data(), str.size(), fmt.c_str(), ap);
        va_end(ap);
        if ((n > -1) && (size_t(n) < str.size())) {
            return str.data();
        }
        if (n > -1)
            str.resize( n + 1 );
        else
            str.resize( str.size() * 2);
    }
    return str.data();
}

Dies vermeidet die Notwendigkeit, constvon dem Ergebnis, .c_str()das in der ursprünglichen Antwort enthalten war, abzuwerfen.

inline void format(string& a_string, const char* fmt, ...)
{
    va_list vl;
    va_start(vl, fmt);
    int size = _vscprintf( fmt, vl );
    a_string.resize( ++size );
    vsnprintf_s((char*)a_string.data(), size, _TRUNCATE, fmt, vl);
    va_end(vl);
}

string hat nicht das, was du brauchst, aber std :: stringstream. Verwenden Sie einen Stringstream, um den String zu erstellen und den String dann zu extrahieren. Hier ist eine umfassende Liste der Dinge, die Sie tun können. Zum Beispiel:

cout.setprecision(10); //stringstream is a stream like cout

Sie erhalten 10 Dezimalstellen Genauigkeit, wenn Sie ein Double oder Float drucken.

Sie könnten dies versuchen:

string str;
str.resize( _MAX_PATH );

sprintf( &str[0], "%s %s", "hello", "world" );
// optionals
// sprintf_s( &str[0], str.length(), "%s %s", "hello", "world" ); // Microsoft
// #include <stdio.h>
// snprintf( &str[0], str.length(), "%s %s", "hello", "world" ); // c++11

str.resize( strlen( str.data() ) + 1 );

Wenn Sie sich auf einem System mit asprintf (3) befinden , können Sie es einfach umbrechen :

#include <iostream>
#include <cstdarg>
#include <cstdio>

std::string format(const char *fmt, ...) __attribute__ ((format (printf, 1, 2)));

std::string format(const char *fmt, ...)
{
    std::string result;

    va_list ap;
    va_start(ap, fmt);

    char *tmp = 0;
    int res = vasprintf(&tmp, fmt, ap);
    va_end(ap);

    if (res != -1) {
        result = tmp;
        free(tmp);
    } else {
        // The vasprintf call failed, either do nothing and
        // fall through (will return empty string) or
        // throw an exception, if your code uses those
    }

    return result;
}

int main(int argc, char *argv[]) {
    std::string username = "you";
    std::cout << format("Hello %s! %d", username.c_str(), 123) << std::endl;
    return 0;
}

Dies ist der Code, den ich dazu in meinem Programm verwende ... Es ist nichts Besonderes, aber es macht den Trick ... Beachten Sie, dass Sie Ihre Größe gegebenenfalls anpassen müssen. MAX_BUFFER ist für mich 1024.

std::string Format ( const char *fmt, ... )
{
    char textString[MAX_BUFFER*5] = {'\0'};

    // -- Empty the buffer properly to ensure no leaks.
    memset(textString, '\0', sizeof(textString));

    va_list args;
    va_start ( args, fmt );
    vsnprintf ( textString, MAX_BUFFER*5, fmt, args );
    va_end ( args );
    std::string retStr = textString;
    return retStr;
}

Übernahm die Idee aus der Antwort von Dacav und Pixelpoint . Ich habe ein bisschen rumgespielt und das bekommen:

#include <cstdarg>
#include <cstdio>
#include <string>

std::string format(const char* fmt, ...)
{
    va_list vl;

    va_start(vl, fmt);
    int size = vsnprintf(0, 0, fmt, vl) + sizeof('\0');
    va_end(vl);

    char buffer[size];

    va_start(vl, fmt);
    size = vsnprintf(buffer, size, fmt, vl);
    va_end(vl);

    return std::string(buffer, size);
}

Mit vernünftiger Programmierpraxis glaube ich, dass der Code ausreichen sollte, aber ich bin immer noch offen für sicherere Alternativen, die immer noch einfach genug sind und kein C ++ 11 erfordern würden.

Und hier ist eine andere Version, die einen Anfangspuffer verwendet, um einen zweiten Aufruf zu verhindern, vsnprintf()wenn der Anfangspuffer bereits ausreicht.

std::string format(const char* fmt, ...)
{

    va_list vl;
    int size;

    enum { INITIAL_BUFFER_SIZE = 512 };

    {
        char buffer[INITIAL_BUFFER_SIZE];

        va_start(vl, fmt);
        size = vsnprintf(buffer, INITIAL_BUFFER_SIZE, fmt, vl);
        va_end(vl);

        if (size < INITIAL_BUFFER_SIZE)
            return std::string(buffer, size);
    }

    size += sizeof('\0');

    char buffer[size];

    va_start(vl, fmt);
    size = vsnprintf(buffer, size, fmt, vl);
    va_end(vl);

    return std::string(buffer, size);
}

(Es stellt sich heraus, dass diese Version der Antwort von Piti Ongmongkolkul ähnlich ist , nur dass sie nicht verwendet newund delete[]beim Erstellen auch eine Größe angibt std::string.

Die Idee hier ist, den Stack nicht über den Heap zu verwenden newund delete[]zu implizieren, da er keine Zuordnungs- und Freigabefunktionen aufrufen muss. Wenn er jedoch nicht ordnungsgemäß verwendet wird, kann es gefährlich sein, Überläufe in einigen (möglicherweise alten oder alten) zu puffern vielleicht nur anfällige) Systeme. Wenn dies ein Problem ist, empfehle ich dringend, stattdessen newund zu delete[]verwenden. Beachten Sie, dass das einzige Problem hier die Zuweisungen ist, wie sie vsnprintf()bereits mit Limits aufgerufen werden. Wenn Sie also ein Limit basierend auf der im zweiten Puffer zugewiesenen Größe angeben, werden diese ebenfalls verhindert.)

Ich benutze normalerweise Folgendes:

std::string myformat(const char *const fmt, ...)
{
        char *buffer = NULL;
        va_list ap;

        va_start(ap, fmt);
        (void)vasprintf(&buffer, fmt, ap);
        va_end(ap);

        std::string result = buffer;
        free(buffer);

        return result;
}

Nachteil: Nicht alle Systeme unterstützen Vasprint

Unten leicht modifizierte Version der @ iFreilicht-Antwort, aktualisiert auf C ++ 14 (Verwendung der make_uniqueFunktion anstelle der Rohdeklaration ) und Unterstützung für std::stringArgumente hinzugefügt (basierend auf dem Artikel von Kenny Kerr )

#include <iostream>
#include <memory>
#include <string>
#include <cstdio>

template <typename T>
T process_arg(T value) noexcept
{
    return value;
}

template <typename T>
T const * process_arg(std::basic_string<T> const & value) noexcept
{
    return value.c_str();
}

template<typename ... Args>
std::string string_format(const std::string& format, Args const & ... args)
{
    const auto fmt = format.c_str();
    const size_t size = std::snprintf(nullptr, 0, fmt, process_arg(args) ...) + 1;
    auto buf = std::make_unique<char[]>(size);
    std::snprintf(buf.get(), size, fmt, process_arg(args) ...);
    auto res = std::string(buf.get(), buf.get() + size - 1);
    return res;
}

int main()
{
    int i = 3;
    float f = 5.f;
    char* s0 = "hello";
    std::string s1 = "world";
    std::cout << string_format("i=%d, f=%f, s=%s %s", i, f, s0, s1) << "\n";
}

Ausgabe:

i = 3, f = 5.000000, s = hello world

Wenn Sie möchten, können Sie diese Antwort auch mit der Originalantwort zusammenführen.

Die Poco Foundation- Bibliothek verfügt über eine sehr praktische Formatierungsfunktion, die std :: string sowohl in der Formatzeichenfolge als auch in den Werten unterstützt:

• Doc: http://pocoproject.org/docs/Poco.html#7308
• Quelle: https://github.com/pocoproject/poco/blob/develop/Foundation/src/Format.cpp

Sie können die C ++ - Ausgabe in cout mithilfe der iomanip-Headerdatei formatieren. Stellen Sie sicher, dass Sie eine iomanip-Headerdatei einschließen, bevor Sie Hilfsfunktionen wie setprecision, setfill usw. verwenden.

Hier ist ein Codefragment, das ich in der Vergangenheit verwendet habe, um die durchschnittliche Wartezeit in dem Vektor zu drucken, den ich "akkumuliert" habe.

#include<iomanip>
#include<iostream>
#include<vector>
#include<numeric>

...

cout<< "Average waiting times for tasks is " << setprecision(4) << accumulate(all(waitingTimes), 0)/double(waitingTimes.size()) ;
cout << " and " << Q.size() << " tasks remaining" << endl;

Hier finden Sie eine kurze Beschreibung, wie wir C ++ - Streams formatieren können. http://www.cprogramming.com/tutorial/iomanip.html

Es kann Probleme geben, wenn der Puffer nicht groß genug ist, um die Zeichenfolge zu drucken. Sie müssen die Länge der formatierten Zeichenfolge bestimmen, bevor Sie dort eine formatierte Nachricht drucken. Ich mache einen eigenen Helfer dafür (getestet unter Windows und Linux GCC ), und Sie können versuchen, es zu verwenden.

String.cpp: http://pastebin.com/DnfvzyKP
String.h: http://pastebin.com/7U6iCUMa

String.cpp:

#include <cstdio>
#include <cstdarg>
#include <cstring>
#include <string>

using ::std::string;

#pragma warning(disable : 4996)

#ifndef va_copy
#ifdef _MSC_VER
#define va_copy(dst, src) dst=src
#elif !(__cplusplus >= 201103L || defined(__GXX_EXPERIMENTAL_CXX0X__))
#define va_copy(dst, src) memcpy((void*)dst, (void*)src, sizeof(*src))
#endif
#endif

///
/// \breif Format message
/// \param dst String to store formatted message
/// \param format Format of message
/// \param ap Variable argument list
///
void toString(string &dst, const char *format, va_list ap) throw() {
  int length;
  va_list apStrLen;
  va_copy(apStrLen, ap);
  length = vsnprintf(NULL, 0, format, apStrLen);
  va_end(apStrLen);
  if (length > 0) {
    dst.resize(length);
    vsnprintf((char *)dst.data(), dst.size() + 1, format, ap);
  } else {
    dst = "Format error! format: ";
    dst.append(format);
  }
}

///
/// \breif Format message
/// \param dst String to store formatted message
/// \param format Format of message
/// \param ... Variable argument list
///
void toString(string &dst, const char *format, ...) throw() {
  va_list ap;
  va_start(ap, format);
  toString(dst, format, ap);
  va_end(ap);
}

///
/// \breif Format message
/// \param format Format of message
/// \param ... Variable argument list
///
string toString(const char *format, ...) throw() {
  string dst;
  va_list ap;
  va_start(ap, format);
  toString(dst, format, ap);
  va_end(ap);
  return dst;
}

///
/// \breif Format message
/// \param format Format of message
/// \param ap Variable argument list
///
string toString(const char *format, va_list ap) throw() {
  string dst;
  toString(dst, format, ap);
  return dst;
}


int main() {
  int a = 32;
  const char * str = "This works!";

  string test(toString("\nSome testing: a = %d, %s\n", a, str));
  printf(test.c_str());

  a = 0x7fffffff;
  test = toString("\nMore testing: a = %d, %s\n", a, "This works too..");
  printf(test.c_str());

  a = 0x80000000;
  toString(test, "\nMore testing: a = %d, %s\n", a, "This way is cheaper");
  printf(test.c_str());

  return 0;
}

String.h:

#pragma once
#include <cstdarg>
#include <string>

using ::std::string;

///
/// \breif Format message
/// \param dst String to store formatted message
/// \param format Format of message
/// \param ap Variable argument list
///
void toString(string &dst, const char *format, va_list ap) throw();
///
/// \breif Format message
/// \param dst String to store formatted message
/// \param format Format of message
/// \param ... Variable argument list
///
void toString(string &dst, const char *format, ...) throw();
///
/// \breif Format message
/// \param format Format of message
/// \param ... Variable argument list
///
string toString(const char *format, ...) throw();

///
/// \breif Format message
/// \param format Format of message
/// \param ap Variable argument list
///
string toString(const char *format, va_list ap) throw();

_return.desc = (boost::format("fail to detect. cv_result = %d") % st_result).str();

Sehr sehr einfache Lösung.

std::string strBuf;
strBuf.resize(256);
int iCharsPrinted = sprintf_s((char *)strPath.c_str(), strPath.size(), ...);
strBuf.resize(iCharsPrinted);

Mir ist klar, dass dies schon oft beantwortet wurde, aber das ist prägnanter:

std::string format(const std::string fmt_str, ...)
{
    va_list ap;
    char *fp = NULL;
    va_start(ap, fmt_str);
    vasprintf(&fp, fmt_str.c_str(), ap);
    va_end(ap);
    std::unique_ptr<char[]> formatted(fp);
    return std::string(formatted.get());
}

Beispiel:

#include <iostream>
#include <random>

int main()
{
    std::random_device r;
    std::cout << format("Hello %d!\n", r());
}

Siehe auch http://rextester.com/NJB14150

UPDATE 1 : fmt::formatTests hinzugefügt

Ich habe meine eigenen Untersuchungen zu den hier eingeführten Methoden durchgeführt und dabei diametral entgegengesetzte Ergebnisse erzielt als hier erwähnt.

Ich habe 4 Funktionen über 4 Methoden verwendet:

• Variadische Funktion + vsnprintf+std::unique_ptr
• Variadische Funktion + vsnprintf+std::string
• Variadic Template Funktion + std::ostringstream+ std::tuple+utility::for_each
• fmt::formatFunktion aus der fmtBibliothek

Für das Test-Backend googletesthat das verwendet.

#include <string>
#include <cstdarg>
#include <cstdlib>
#include <memory>
#include <algorithm>

#include <fmt/format.h>

inline std::string string_format(size_t string_reserve, const std::string fmt_str, ...)
{
    size_t str_len = (std::max)(fmt_str.size(), string_reserve);

    // plain buffer is a bit faster here than std::string::reserve
    std::unique_ptr<char[]> formatted;

    va_list ap;
    va_start(ap, fmt_str);

    while (true) {
        formatted.reset(new char[str_len]);

        const int final_n = vsnprintf(&formatted[0], str_len, fmt_str.c_str(), ap);

        if (final_n < 0 || final_n >= int(str_len))
            str_len += (std::abs)(final_n - int(str_len) + 1);
        else
            break;
    }

    va_end(ap);

    return std::string(formatted.get());
}

inline std::string string_format2(size_t string_reserve, const std::string fmt_str, ...)
{
    size_t str_len = (std::max)(fmt_str.size(), string_reserve);
    std::string str;

    va_list ap;
    va_start(ap, fmt_str);

    while (true) {
        str.resize(str_len);

        const int final_n = vsnprintf(const_cast<char *>(str.data()), str_len, fmt_str.c_str(), ap);

        if (final_n < 0 || final_n >= int(str_len))
            str_len += (std::abs)(final_n - int(str_len) + 1);
        else {
            str.resize(final_n); // do not forget to shrink the size!
            break;
        }
    }

    va_end(ap);

    return str;
}

template <typename... Args>
inline std::string string_format3(size_t string_reserve, Args... args)
{
    std::ostringstream ss;
    if (string_reserve) {
        ss.rdbuf()->str().reserve(string_reserve);
    }
    std::tuple<Args...> t{ args... };
    utility::for_each(t, [&ss](auto & v)
    {
        ss << v;
    });
    return ss.str();
}

Die for_eachImplementierung erfolgt von hier aus: Über Tupel iterieren

#include <type_traits>
#include <tuple>

namespace utility {

    template <std::size_t I = 0, typename FuncT, typename... Tp>
    inline typename std::enable_if<I == sizeof...(Tp), void>::type
        for_each(std::tuple<Tp...> &, const FuncT &)
    {
    }

    template<std::size_t I = 0, typename FuncT, typename... Tp>
    inline typename std::enable_if<I < sizeof...(Tp), void>::type
        for_each(std::tuple<Tp...> & t, const FuncT & f)
    {
        f(std::get<I>(t));
        for_each<I + 1, FuncT, Tp...>(t, f);
    }

}

Die Tests:

TEST(ExternalFuncs, test_string_format_on_unique_ptr_0)
{
    for (size_t i = 0; i < 1000000; i++) {
        const std::string v = string_format(0, "%s+%u\n", "test test test", 12345);
        UTILITY_SUPPRESS_OPTIMIZATION_ON_VAR(v);
    }
}

TEST(ExternalFuncs, test_string_format_on_unique_ptr_256)
{
    for (size_t i = 0; i < 1000000; i++) {
        const std::string v = string_format(256, "%s+%u\n", "test test test", 12345);
        UTILITY_SUPPRESS_OPTIMIZATION_ON_VAR(v);
    }
}

TEST(ExternalFuncs, test_string_format_on_std_string_0)
{
    for (size_t i = 0; i < 1000000; i++) {
        const std::string v = string_format2(0, "%s+%u\n", "test test test", 12345);
        UTILITY_SUPPRESS_OPTIMIZATION_ON_VAR(v);
    }
}

TEST(ExternalFuncs, test_string_format_on_std_string_256)
{
    for (size_t i = 0; i < 1000000; i++) {
        const std::string v = string_format2(256, "%s+%u\n", "test test test", 12345);
        UTILITY_SUPPRESS_OPTIMIZATION_ON_VAR(v);
    }
}

TEST(ExternalFuncs, test_string_format_on_string_stream_on_variadic_tuple_0)
{
    for (size_t i = 0; i < 1000000; i++) {
        const std::string v = string_format3(0, "test test test", "+", 12345, "\n");
        UTILITY_SUPPRESS_OPTIMIZATION_ON_VAR(v);
    }
}

TEST(ExternalFuncs, test_string_format_on_string_stream_on_variadic_tuple_256)
{
    for (size_t i = 0; i < 1000000; i++) {
        const std::string v = string_format3(256, "test test test", "+", 12345, "\n");
        UTILITY_SUPPRESS_OPTIMIZATION_ON_VAR(v);
    }
}

TEST(ExternalFuncs, test_string_format_on_string_stream_inline_0)
{
    for (size_t i = 0; i < 1000000; i++) {
        std::ostringstream ss;
        ss << "test test test" << "+" << 12345 << "\n";
        const std::string v = ss.str();
        UTILITY_SUPPRESS_OPTIMIZATION_ON_VAR(v);
    }
}

TEST(ExternalFuncs, test_string_format_on_string_stream_inline_256)
{
    for (size_t i = 0; i < 1000000; i++) {
        std::ostringstream ss;
        ss.rdbuf()->str().reserve(256);
        ss << "test test test" << "+" << 12345 << "\n";
        const std::string v = ss.str();
        UTILITY_SUPPRESS_OPTIMIZATION_ON_VAR(v);
    }
}

TEST(ExternalFuncs, test_fmt_format_positional)
{
    for (size_t i = 0; i < 1000000; i++) {
        const std::string v = fmt::format("{0:s}+{1:d}\n", "test test test", 12345);
        UTILITY_SUPPRESS_OPTIMIZATION_ON_VAR(v);
    }
}

TEST(ExternalFuncs, test_fmt_format_named)
{
    for (size_t i = 0; i < 1000000; i++) {
        const std::string v = fmt::format("{first:s}+{second:d}\n", fmt::arg("first", "test test test"), fmt::arg("second", 12345));
        UTILITY_SUPPRESS_OPTIMIZATION_ON_VAR(v);
    }
}

Die UTILITY_SUPPRESS_OPTIMIZATION_ON_VAR.

unsued.hpp :

#define UTILITY_SUPPRESS_OPTIMIZATION_ON_VAR(var)   ::utility::unused_param(&var)

namespace utility {

    extern const volatile void * volatile g_unused_param_storage_ptr;

    extern void
#ifdef __GNUC__
    __attribute__((optimize("O0")))
#endif
        unused_param(const volatile void * p);

}

unused.cpp :

namespace utility {

    const volatile void * volatile g_unused_param_storage_ptr = nullptr;

    void
#ifdef __GNUC__
    __attribute__((optimize("O0")))
#endif
        unused_param(const volatile void * p)
    {
        g_unused_param_storage_ptr = p;
    }

}

Ergebnisse :

[ RUN      ] ExternalFuncs.test_string_format_on_unique_ptr_0
[       OK ] ExternalFuncs.test_string_format_on_unique_ptr_0 (556 ms)
[ RUN      ] ExternalFuncs.test_string_format_on_unique_ptr_256
[       OK ] ExternalFuncs.test_string_format_on_unique_ptr_256 (331 ms)
[ RUN      ] ExternalFuncs.test_string_format_on_std_string_0
[       OK ] ExternalFuncs.test_string_format_on_std_string_0 (457 ms)
[ RUN      ] ExternalFuncs.test_string_format_on_std_string_256
[       OK ] ExternalFuncs.test_string_format_on_std_string_256 (279 ms)
[ RUN      ] ExternalFuncs.test_string_format_on_string_stream_on_variadic_tuple_0
[       OK ] ExternalFuncs.test_string_format_on_string_stream_on_variadic_tuple_0 (1214 ms)
[ RUN      ] ExternalFuncs.test_string_format_on_string_stream_on_variadic_tuple_256
[       OK ] ExternalFuncs.test_string_format_on_string_stream_on_variadic_tuple_256 (1325 ms)
[ RUN      ] ExternalFuncs.test_string_format_on_string_stream_inline_0
[       OK ] ExternalFuncs.test_string_format_on_string_stream_inline_0 (1208 ms)
[ RUN      ] ExternalFuncs.test_string_format_on_string_stream_inline_256
[       OK ] ExternalFuncs.test_string_format_on_string_stream_inline_256 (1302 ms)
[ RUN      ] ExternalFuncs.test_fmt_format_positional
[       OK ] ExternalFuncs.test_fmt_format_positional (288 ms)
[ RUN      ] ExternalFuncs.test_fmt_format_named
[       OK ] ExternalFuncs.test_fmt_format_named (392 ms)

Wie Sie sehen können, ist die Implementierung durch das vsnprintf+ std::stringgleich fmt::format, aber schneller als durch das vsnprintf+ std::unique_ptr, was schneller ist als durch das std::ostringstream.

Die Tests wurden in kompiliert Visual Studio 2015 Update 3und laufen auf Windows 7 x64 / Intel Core i7-4820K CPU @ 3.70GHz / 16GB.