Mit sprintf mit std :: string in C++

Question

Ich verwende sprintf Funktion in C++ 11, auf folgende Weise:

std::string toString() 
{ 
    std::string output; 
    uint32_t strSize=512; 
    do 
    { 
     output.reserve(strSize); 
     int ret = sprintf(output.c_str(), "Type=%u Version=%u ContentType=%u contentFormatVersion=%u magic=%04x Seg=%u", 
      INDEX_RECORD_TYPE_SERIALIZATION_HEADER, 
      FORAMT_VERSION, 
      contentType, 
      contentFormatVersion, 
      magic, 
      segmentId); 

     strSize *= 2; 
    } while (ret < 0); 

    return output; 
} 

Gibt es einen besseren Weg, dies zu tun, als jedes Mal zu überprüfen, ob die reservierten Platz war genug? Für die zukünftige Möglichkeit, weitere Dinge hinzuzufügen.

Answer 1

Ihr Konstrukt - Schreiben in den Puffer von c_str() empfing - ist undefiniertes Verhalten, auch wenn Sie die Zeichenfolge Kapazität vorher geprüft. (Der Rückgabewert ist ein Zeiger auf const char, und die Funktion markiert selbst const, aus einem Grund.)

Sie C und C++ nicht mischen, besonders nicht in interne Objektdarstellung zu schreiben. (Das ist sehr grundlegende OOP brechen.) Verwenden Sie C++, für die Typensicherheit und nicht in Conversion Specifier/Parameter Mismatches, wenn für nichts anderes.

std::ostringstream s; 
s << "Type=" << INDEX_RECORD_TYPE_SERIALIZATION_HEADER 
    << " Version=" << FORMAT_VERSION 
    // ...and so on... 
    ; 
std::string output = s.str(); 

Alternative:

std::string output = "Type=" + std::to_string(INDEX_RECORD_TYPE_SERIALIZATION_HEADER) 
        + " Version=" + std::to_string(FORMAT_VERSION) 
        // ...and so on... 
        ; 

Answer 2

Ihr Code ist falsch. reserve reserviert Speicher für die Zeichenfolge, ändert jedoch nicht seine Größe. Das Schreiben in den Puffer, der von c_str zurückgegeben wird, ändert seine Größe ebenfalls nicht. Also glaubt die Zeichenkette immer noch, dass ihre Größe 0 ist, und Sie haben gerade etwas in den ungenutzten Platz im Puffer der Zeichenkette geschrieben. (Wahrscheinlich. Technisch hat der Code Undefined Behavior, weil das Schreiben in c_str undefiniert ist, also könnte alles passieren).

Was Sie wirklich tun möchte, ist vergessen sprintf und ähnliche C-Stil-Funktionen, und verwenden Sie die C++ Art und Weise der String-Formatierung — String-Streams:

std::ostringstream ss; 
ss << "Type=" << INDEX_RECORD_TYPE_SERIALIZATION_HEADER 
    << " Version=" << FORAMT_VERSION 
    << /* ... the rest ... */; 
return ss.str(); 

Answer 3

Ja, es ist!

In C ist die bessere Möglichkeit, eine Datei mit dem null Gerät zuzuordnen und eine Dummy-printf der gewünschten Ausgabe machen, zu erfahren, wie viel Platz wäre es tatsächlich gedruckt nehmen, wenn. Ordnen Sie dann den entsprechenden Puffer und sprintf die gleichen Daten zu.

In C++ können Sie den Ausgabestream auch mit einem Null-Gerät verknüpfen und die Anzahl der mit std::ostream::tellp gedruckten Zeichen testen. Allerdings ist die Verwendung von ostringstream eine bessere Lösung - siehe die Antworten von DevSolar oder Angew.

Answer 4

Die C++ Muster in anderen Antworten gezeigt sind schöner, aber der Vollständigkeit halber, hier ist eine richtige Art und Weise mit sprintf:

auto format = "your %x format %d string %s"; 
auto size = std::snprintf(nullptr, 0, format /* Arguments go here*/); 
std::string output(size + 1, '\0'); 
std::sprintf(&output[0], format, /* Arguments go here*/); 

Achten Sie auf

• Sie Ihre Zeichenfolge resize müssen. reserve ändert nicht die Größe des Puffers. In meinem Beispiel konstruiere ich eine korrekt dimensionierte Zeichenfolge direkt.
• c_str() gibt const char* zurück. Sie dürfen es nicht an sprintf übergeben.
• std::string Puffer war nicht garantiert, um zusammenhängend vor C++ 11 und dies beruht auf dieser Garantie. Wenn Sie exotische C++ 11-konforme Plattformen unterstützen müssen, die die Seilimplementierung für std::string verwenden, ist es wahrscheinlich besser, zuerst sprint in std::vector<char> zu kopieren und dann den Vektor in die Zeichenfolge zu kopieren.
• Dies funktioniert nur, wenn die Argumente nicht zwischen der Größenberechnung und Formatierung geändert werden; Verwenden Sie entweder lokale Kopien von Variablen oder Thread-Synchronisationsgrundelemente für Multithread-Code.

Answer 5

Ein besserer Weg ist die Verwendung von CppFormat. Ex:
std::string message = fmt::sprintf("The answer is %d", 42);
Es macht auch ein schöneres Interface als iostreams und printf, Ex:
std::string message = fmt::format("The answer is {}", 42);
See:
https://github.com/fmtlib/fmt
http://fmtlib.net/latest/api.html#printf-formatting-functions

Answer 6

Wir können Code mischen von hier https://stackoverflow.com/a/36909699/2667451 und hier https://stackoverflow.com/a/7257307 und führt so sein:

template <typename ...Args> 
std::string stringWithFormat(const std::string& format, Args && ...args) 
{ 
    auto size = std::snprintf(nullptr, 0, format.c_str(), std::forward<Args>(args)...); 
    std::string output(size + 1, '\0'); 
    std::sprintf(&output[0], format.c_str(), std::forward<Args>(args)...); 
    return output; 
}