std :: formattazione di stringhe come sprintf

Devo formato std::stringcon sprintfe inviare in flusso di file. Come posso fare questo?

Non puoi farlo direttamente, perché non hai accesso in scrittura al buffer sottostante (fino a C ++ 11; vedi il commento di Dietrich Epp ). Dovrai prima farlo in una stringa c, quindi copiarlo in una stringa std :: string:

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

Ma non sono sicuro del perché non dovresti usare solo un flusso di stringhe? Suppongo che tu abbia motivi specifici per non solo fare questo:

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

Il moderno C ++ lo rende super semplice.

C ++ 20

C ++ 20 introduce std::format, che ti permette di fare esattamente questo. Utilizza campi di sostituzione simili a quelli in Python :

#include <iostream>
#include <format>

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

Controlla la documentazione completa ! È un enorme miglioramento della qualità della vita.

C ++ 11

Con C ++ 11 s std::snprintf, questo è già diventato un compito abbastanza facile e sicuro.

#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
}

Lo snippet di codice sopra riportato è concesso in licenza in CC0 1.0 .

Spiegazione riga per riga:

Obiettivo: scrivere in achar*utilizzando std::snprintfe quindi convertirlo in astd::string.

Innanzitutto, determiniamo la lunghezza desiderata dell'array char usando una condizione speciale in snprintf. Da cppreference.com :

Valore di ritorno

[...] Se la stringa risultante viene troncata a causa del limite buf_size, la funzione restituisce il numero totale di caratteri (escluso il byte null terminante) che sarebbero stati scritti se il limite non fosse stato imposto.

Ciò significa che la dimensione desiderata è il numero di caratteri più uno , in modo che il terminatore null siederà dopo tutti gli altri caratteri e che possa essere nuovamente tagliato dal costruttore di stringhe. Questo problema è stato spiegato da @ alexk7 nei commenti.

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

snprintfrestituirà un numero negativo se si è verificato un errore, quindi controlliamo se la formattazione ha funzionato come desiderato. Non farlo potrebbe portare a errori silenziosi o all'allocazione di un enorme buffer, come sottolineato da @ead nei commenti.

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

Successivamente, assegniamo un nuovo array di caratteri e lo assegniamo a std::unique_ptr. Questo è generalmente consigliato, in quanto non sarà necessario manualmente di deletenuovo.

Si noti che questo non è un modo sicuro per allocare un unique_ptrcon tipi definiti dall'utente in quanto non è possibile deallocare la memoria se il costruttore genera un'eccezione!

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

Dopodiché, possiamo ovviamente usare solo snprintfper l'uso previsto e scrivere la stringa formattata su char[].

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

Infine, ne creiamo e ne restituiamo uno nuovo std::string, assicurandoci di omettere il null-terminator alla fine.

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

Puoi vedere un esempio in azione qui .

Se vuoi usare anche std::stringnella lista degli argomenti, dai un'occhiata a questo riassunto .

Ulteriori informazioni per gli utenti di Visual Studio :

Come spiegato in questa risposta , Microsoft è stata rinominata std::snprintfin _snprintf(sì, senza std::). MS lo imposta ulteriormente come obsoleto e consiglia di utilizzare _snprintf_sinvece, tuttavia _snprintf_snon accetterà che il buffer sia zero o più piccolo dell'output formattato e non calcolerà la lunghezza degli output se ciò si verifica. Quindi, al fine di eliminare gli avvisi di deprecazione durante la compilazione, è possibile inserire la seguente riga nella parte superiore del file che contiene l'uso di _snprintf:

#pragma warning(disable : 4996)

Pensieri finali

Molte risposte a questa domanda sono state scritte prima del tempo di C ++ 11 e usano lunghezze di buffer fisse o Varg. A meno che tu non sia bloccato con le vecchie versioni di C ++, non consiglierei di usare quelle soluzioni. Idealmente, vai in C ++ 20.

Poiché la soluzione C ++ 11 in questa risposta utilizza modelli, può generare un bel po 'di codice se viene usata molto. Tuttavia, a meno che non si stia sviluppando per un ambiente con uno spazio molto limitato per i file binari, questo non sarà un problema ed è comunque un grande miglioramento rispetto alle altre soluzioni in termini di chiarezza e sicurezza.

Se l'efficienza dello spazio è estremamente importante, queste due soluzioni con vargs e vsnprintf possono essere utili. NON UTILIZZARE alcuna soluzione con buffer fissi, che richiede solo problemi.

Soluzione C ++ 11 che utilizza vsnprintf()internamente:

#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;
}

Un approccio più sicuro ed efficiente (l'ho testato ed è più veloce):

#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());
}

Il fmt_strvalore viene passato per valore per essere conforme ai requisiti di va_start.

NOTA: la versione "più sicura" e "più veloce" non funziona su alcuni sistemi. Quindi entrambi sono ancora elencati. Inoltre, "più veloce" dipende interamente dalla corretta fase di preallocazione, altrimenti la strcpyrende più lenta.

boost::format() fornisce le funzionalità desiderate:

A partire dalla sinossi delle librerie di formato Boost:

Un oggetto formato è costruito da una stringa di formato e viene quindi fornito argomenti tramite ripetute chiamate all'operatore%. Ciascuno di questi argomenti viene quindi convertito in stringhe, che vengono a loro volta combinate in una stringa, in base alla stringa di formato.

#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 includerà std::formatche assomiglia sprintfin termini di API ma è completamente sicuro per i tipi, funziona con tipi definiti dall'utente e utilizza una sintassi di stringhe di formato simile a Python. Ecco come sarai in grado di formattarlo std::stringe scriverlo su uno stream:

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

o

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

In alternativa, è possibile utilizzare la libreria {fmt} per formattare una stringa e scriverla in stdoutun flusso di file in una volta sola:

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

Per quanto riguarda sprintfo la maggior parte delle altre risposte qui, sfortunatamente usano varargs e sono intrinsecamente non sicuri a meno che tu non usi qualcosa come l' formatattributo GCC che funziona solo con stringhe di formato letterale. Puoi vedere perché queste funzioni non sono sicure nell'esempio seguente:

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

dov'è string_formatun'implementazione dalla risposta di Erik Aronesty. Questo codice viene compilato, ma molto probabilmente si arresterà in modo anomalo quando si tenta di eseguirlo:

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

Disclaimer : sono l'autore di {fmt} e C ++ 20 std::format.

Se desideri solo una sintassi simile a printf (senza chiamare tu stesso printf), dai un'occhiata a Boost Format .

Ho scritto il mio usando vsnprintf in modo che ritorni stringa invece di dover creare il mio buffer.

#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;
}

Quindi puoi usarlo come

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

Per formattare std::stringin modo "sprintf", chiamare snprintf(argomenti nullptre 0) per ottenere la lunghezza del buffer necessaria. Scrivi la tua funzione usando il modello variadic C ++ 11 in questo modo:

#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;
}

Compilare con il supporto C ++ 11, ad esempio in GCC: g++ -std=c++11

Uso:

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

[modifica: 20/05/25] meglio ancora ...:
nell'intestazione:

// `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; }

La funzione PRINTSTRING(r)è quella di soddisfare la GUI o il terminale o qualsiasi uscita speciale che necessita utilizzando #ifdef _some_flag_, il valore predefinito è:

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

[modifica '17 / 8/31] Aggiunta di una versione variadica del modello '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;
}

che è effettivamente una versione delimitata da virgole (invece) degli <<operatori a volte ostacolanti , utilizzata in questo modo:

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

[modifica] Adattato per utilizzare la tecnica nella risposta di Erik Aronesty (sopra):

#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;
}

[risposta precedente]
Una risposta molto tardiva, ma per coloro a cui, come me, piace il modo 'sprintf': ho scritto e sto usando le seguenti funzioni. Se ti piace, puoi espandere le% -opzioni per adattarle più da vicino a quelle dello sprintf; quelli presenti al momento sono sufficienti per le mie esigenze. Usa stringf () e stringfappend () come faresti con sprintf. Ricorda solo che i parametri per ... devono essere tipi POD.

//=============================================================================
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;
}

Ecco come fa Google: StringPrintf(Licenza BSD)
e Facebook lo fa in modo abbastanza simile: StringPrintf(Licenza Apache)
Entrambi forniscono anche un comodo StringAppendF.

I miei due centesimi su questa domanda molto popolare.

Per citare la manpage di printffunzioni simili :

In caso di restituzione corretta, queste funzioni restituiscono il numero di caratteri stampati (escluso il byte null utilizzato per terminare l'output in stringhe).

Le funzioni snprintf () e vsnprintf () non scrivono più di byte di dimensione (incluso il byte null di terminazione ('\ 0')). Se l'output è stato troncato a causa di questo limite, il valore restituito è il numero di caratteri (escluso il byte null terminante) che sarebbero stati scritti nella stringa finale se fosse stato disponibile spazio sufficiente. Pertanto, un valore di ritorno di dimensione o superiore indica che l'output è stato troncato.

In altre parole, un'implementazione sana di C ++ 11 dovrebbe essere la seguente:

#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);
}

Funziona abbastanza bene :)

I modelli variabili sono supportati solo in C ++ 11. La risposta di pixelpoint mostra una tecnica simile usando stili di programmazione più vecchi.

È strano che C ++ non abbia una cosa del genere. Di recente hanno aggiunto to_string(), che secondo me è un grande passo avanti. Mi chiedo se aggiungeranno un .formatoperatore alla std::stringfine ...

modificare

Come ha sottolineato alexk7, A +1è necessario sul valore restituito di std::snprintf, poiché è necessario disporre di spazio per il \0byte. Intuitivamente, sulla maggior parte delle architetture mancanti +1, il requirednumero intero verrà sovrascritto parzialmente con a 0. Ciò accadrà dopo la valutazione requiredcome parametro effettivo per std::snprintf, quindi l'effetto non dovrebbe essere visibile.

Questo problema potrebbe tuttavia cambiare, ad esempio con l'ottimizzazione del compilatore: cosa succede se il compilatore decide di utilizzare un registro per la requiredvariabile? Questo è il tipo di errori che a volte causano problemi di sicurezza.

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;
}

Utilizzo di C99 snprintf e C ++ 11

Testato, risposta alla qualità della produzione

Questa risposta tratta il caso generale con tecniche conformi agli standard. Lo stesso approccio è fornito come esempio su CppReference.com nella parte inferiore della loro pagina. A differenza del loro esempio, questo codice soddisfa i requisiti della domanda ed è testato sul campo in applicazioni robotiche e satellitari. Ha anche migliorato i commenti. La qualità del design è discussa più avanti.

#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; }

Efficienza lineare prevedibile

Due passaggi sono necessari per una funzione riutilizzabile sicura, affidabile e prevedibile secondo le specifiche della domanda. Le presunzioni sulla distribuzione delle dimensioni dei Varg in una funzione riutilizzabile sono cattivi stili di programmazione e dovrebbero essere evitate. In questo caso, rappresentazioni di lunghezza variabile arbitrariamente grandi di Varg sono un fattore chiave nella scelta dell'algoritmo.

Riprovare in caso di overflow è esponenzialmente inefficiente, che è un altro motivo discusso quando il comitato per gli standard C ++ 11 ha discusso la proposta di cui sopra per fornire un ciclo a vuoto quando il buffer di scrittura è nullo.

Nell'implementazione pronta per la produzione di cui sopra, la prima serie è una serie così secca per determinare la dimensione di allocazione. Non si verifica alcuna allocazione. L'analisi delle direttive printf e la lettura dei Varg sono state rese estremamente efficienti nel corso di decenni. Il codice riutilizzabile dovrebbe essere prevedibile, anche se una piccola inefficienza per casi insignificanti deve essere sacrificata.

Sicurezza e affidabilità

Andrew Koenig ha detto a un piccolo gruppo di noi dopo la sua conferenza a un evento di Cambridge: "Le funzioni dell'utente non dovrebbero fare affidamento sullo sfruttamento di un fallimento per funzionalità non eccezionale". Come al solito, la sua saggezza è stata dimostrata vera nel disco da allora. Problemi di bug di sicurezza fissi e chiusi spesso indicano riprovare hack nella descrizione del buco sfruttato prima della correzione.

Questo è menzionato nella proposta di revisione degli standard formali per la funzione null buffer in Alternativa a sprintf, Proposta di revisione C9X , Documento ISO IEC WG14 N645 / X3J11 96-008 . Una stringa arbitrariamente lunga inserita per direttiva di stampa, "% s", nei limiti della disponibilità della memoria dinamica, non fa eccezione e non deve essere sfruttata per produrre "Funzionalità non eccezionale".

Considera la proposta a fianco del codice di esempio fornito nella parte inferiore della pagina C ++ Reference.org collegata al primo paragrafo di questa risposta.

Inoltre, il test dei casi di fallimento raramente è altrettanto solido dei casi di successo.

portabilità

Tutti i principali fornitori di sistemi operativi forniscono compilatori che supportano completamente std :: vsnprintf come parte degli standard c ++ 11. Gli host che eseguono prodotti di fornitori che non mantengono più le distribuzioni dovrebbero essere forniti con g ++ o clang ++ per molte ragioni.

Stack Stack

L'uso dello stack nella prima chiamata a std :: vsnprintf sarà inferiore o uguale a quello della seconda e verrà liberato prima dell'inizio della seconda chiamata. Se la prima chiamata supera la disponibilità dello stack, anche std :: fprintf fallirebbe.

C ++ 20 std::format

È arrivato! La funzione è descritta su: http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2019/p0645r9.html e utilizza una .format()sintassi simile a Python .

Mi aspetto che l'utilizzo sarà simile a:

#include <format>
#include <string>

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

Ci proverò quando il supporto arriva a GCC, GCC 9.1.0 con g++-9 -std=c++2aancora non lo supporta.

L'API aggiungerà una nuova std::formatintestazione:

L'API di formattazione proposta è definita nella nuova intestazione <format>e non dovrebbe avere alcun impatto sul codice esistente.

La fmtlibreria esistente afferma di implementarla se è necessario il polyfill: https://github.com/fmtlib/fmt

Implementazione di C ++ 20 std::format.

ed è stato precedentemente menzionato in: std :: string formatting come sprintf

Sulla base della risposta fornita da 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();
}

Questo evita la necessità di abbandonare constil risultato di .c_str()cui era nella risposta originale.

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);
}

stringa non ha ciò di cui hai bisogno, ma std :: stringstream ha. Utilizzare uno stringstream per creare la stringa e quindi estrarre la stringa. Ecco un elenco completo delle cose che puoi fare. Per esempio:

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

ti darà 10 decimali di precisione quando stampi un doppio o un float.

Puoi provare questo:

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 );

Se utilizzi un sistema con asprintf (3) , puoi facilmente avvolgerlo:

#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;
}

Questo è il codice che uso per fare questo nel mio programma ... Non è niente di speciale, ma fa il trucco ... Nota, dovrai adattare le tue dimensioni come applicabile. MAX_BUFFER per me è 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;
}

Prese l'idea dalla risposta di Dacav e pixelpoint . Ho giocato un po 'e ho ottenuto questo:

#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);
}

Con una pratica di programmazione sana credo che il codice dovrebbe essere sufficiente, tuttavia sono ancora aperto a alternative più sicure che sono ancora abbastanza semplici e non richiederebbero C ++ 11.

Ed ecco un'altra versione che utilizza un buffer iniziale per impedire la seconda chiamata a vsnprintf()quando il buffer iniziale è già sufficiente.

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);
}

(Si scopre che questa versione è proprio simile alla risposta di Piti Ongmongkolkul , solo che non usa newe delete[], e specifica anche una dimensione durante la creazione std::string.

L'idea qui di non usare newed delete[]è implicare l'uso dello stack sull'heap poiché non ha bisogno di chiamare le funzioni di allocazione e deallocazione, tuttavia se non usato correttamente, potrebbe essere pericoloso bufferizzare gli overflow in alcuni (forse vecchi, o forse solo vulnerabili) sistemi. Se questo è un problema, consiglio vivamente di usare newe delete[]invece. Si noti che l'unica preoccupazione qui riguarda le allocazioni come vsnprintf()è già stato chiamato con limiti, quindi specificare un limite in base alla dimensione allocata sul secondo buffer impedirebbe anche quelle.)

Di solito lo uso:

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;
}

Svantaggio: non tutti i sistemi supportano vasprint

Sotto versione leggermente modificata di @iFreilicht risposta, aggiornato per C ++ 14 (utilizzo della make_uniquefunzione invece della dichiarazione crudo) e aggiunto il supporto per std::stringargomenti (sulla base di Kenny Kerr articolo )

#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";
}

Produzione:

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

Sentiti libero di unire questa risposta con quella originale, se lo desideri.

La libreria Poco Foundation ha una funzione di formato molto conveniente, che supporta std :: string sia nella stringa di formato che nei valori:

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

È possibile formattare l'output C ++ in cout utilizzando il file di intestazione iomanip. Assicurati di includere il file di intestazione iomanip prima di utilizzare una qualsiasi delle funzioni di supporto come setprecision, setfill ecc.

Ecco uno snippet di codice che ho usato in passato per stampare il tempo medio di attesa nel vettore, che ho "accumulato".

#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;

Ecco una breve descrizione di come possiamo formattare i flussi C ++. http://www.cprogramming.com/tutorial/iomanip.html

Possono esserci problemi, se il buffer non è abbastanza grande per stampare la stringa. È necessario determinare la lunghezza della stringa formattata prima di stampare un messaggio formattato al suo interno. Faccio il mio aiuto per questo (testato su Windows e Linux GCC ), e puoi provare ad usarlo.

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();

Soluzione molto molto semplice.

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

Mi rendo conto che è stato risposto più volte, ma è più conciso:

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());
}

esempio:

#include <iostream>
#include <random>

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

Vedi anche http://rextester.com/NJB14150

AGGIORNAMENTO 1 : aggiunti fmt::formattest

Ho preso la mia indagine sui metodi introdotti qui e ottengo risultati diametralmente opposti rispetto a quelli qui menzionati.

Ho usato 4 funzioni su 4 metodi:

• funzione variadica + vsnprintf+std::unique_ptr
• funzione variadica + vsnprintf+std::string
• funzione del modello variadico + std::ostringstream+ std::tuple+utility::for_each
• fmt::formatfunzione dalla fmtlibreria

Per il backend di test googletestè stato utilizzato.

#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();
}

L' for_eachimplementazione è presa da qui: iterare sulla tupla

#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);
    }

}

I test:

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);
    }
}

Il 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;
    }

}

RISULTATI :

[ 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)

Come puoi vedere, l'implementazione attraverso vsnprintf+ std::stringè uguale a fmt::format, ma più veloce rispetto a vsnprintf+ std::unique_ptr, che è più veloce di attraverso std::ostringstream.

I test sono stati compilati Visual Studio 2015 Update 3ed eseguiti a Windows 7 x64 / Intel Core i7-4820K CPU @ 3.70GHz / 16GB.