formatowanie std :: string jak sprintf

Mam do formatu std::stringz sprintfi wysłać go do strumienia pliku. W jaki sposób mogę to zrobić?

Nie możesz tego zrobić bezpośrednio, ponieważ nie masz dostępu do zapisu do bufora bazowego (do C ++ 11; patrz komentarz Dietricha Eppa ). Najpierw musisz to zrobić ciągiem c, a następnie skopiować go do std :: string:

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

Ale nie jestem pewien, dlaczego po prostu nie używałbyś strumienia ciągów? Zakładam, że masz konkretne powody, aby nie tylko to zrobić:

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

Nowoczesne C ++ sprawia, że ​​jest to bardzo proste.

C ++ 20

C ++ 20 wprowadza std::format, co pozwala dokładnie to zrobić. Używa zastępczych pól podobnych do tych w Pythonie :

#include <iostream>
#include <format>

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

Sprawdź pełną dokumentację ! To ogromna poprawa jakości życia.

C ++ 11

Z c ++ 11 s std::snprintf, to już stało się bardzo łatwe i bezpieczne zadanie.

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

Powyższy fragment kodu jest licencjonowany na podstawie CC0 1.0 .

Objaśnienie linia po linii:

Cel: Napisz dochar*używając, std::snprintfa następnie przekonwertuj to nastd::string.

Najpierw określamy pożądaną długość tablicy znaków przy użyciu specjalnego warunku w snprintf. Od cppreference.com :

Zwracana wartość

[...] Jeśli wynikowy łańcuch zostanie obcięty z powodu limitu buf_size, funkcja zwraca całkowitą liczbę znaków (nie wliczając kończącego znaku zerowego), które zostałyby zapisane, gdyby limit nie został narzucony.

Oznacza to, że pożądany rozmiar to liczba znaków plus jeden , tak więc terminator zerowy usiądzie za wszystkimi innymi znakami i może zostać ponownie odcięty przez konstruktor łańcucha. Ten problem został wyjaśniony przez @ alexk7 w komentarzach.

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

snprintfzwróci liczbę ujemną, jeśli wystąpi błąd, więc sprawdzamy, czy formatowanie działało zgodnie z oczekiwaniami. Nieprzestrzeganie tego może prowadzić do cichych błędów lub przydzielenia ogromnego bufora, jak wskazał @ead w komentarzach.

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

Następnie przydzielamy nową tablicę znaków i przypisujemy ją do std::unique_ptr. Jest to ogólnie zalecane, ponieważ nie trzeba ręczniedelete ponownie tego .

Pamiętaj, że nie jest to bezpieczny sposób przydzielania unique_ptrtypów zdefiniowanych przez użytkownika, ponieważ nie można cofnąć przydziału pamięci, jeśli konstruktor zgłasza wyjątek!

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

Następnie możemy oczywiście po prostu użyć snprintfzgodnie z przeznaczeniem i zapisać sformatowany ciąg do char[].

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

Na koniec tworzymy i zwracamy nowe std::string, upewniając się, że na końcu pominięto terminator zerowy.

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

Można zobaczyć przykład w akcji tutaj .

Jeśli chcesz także użyć std::stringna liście argumentów, spójrz na tę treść .

Dodatkowe informacje o Visual Studio użytkowników :

Jak wyjaśniono w tej odpowiedzi , Microsoft zmienił nazwę std::snprintfna _snprintf(tak, bez std::). MS dodatkowo ustawiło to jako przestarzałe i zaleca użycie _snprintf_szamiast tego, jednak _snprintf_snie zaakceptuje bufora jako zera lub mniejszego niż sformatowane wyjście i nie obliczy długości wyjść, jeśli to nastąpi. Aby więc pozbyć się ostrzeżeń o wycofaniu podczas kompilacji, możesz wstawić następujący wiersz na górze pliku, który zawiera użycie _snprintf:

#pragma warning(disable : 4996)

Końcowe przemyślenia

Wiele odpowiedzi na to pytanie zostało napisanych przed C ++ 11 i używa stałych długości buforów lub vargs. Jeśli nie utkniesz ze starymi wersjami C ++, nie poleciłbym używania tych rozwiązań. Idealnie jest przejść na C ++ 20.

Ponieważ rozwiązanie C ++ 11 w tej odpowiedzi używa szablonów, może generować sporo kodu, jeśli jest często używane. Jednak jeśli nie tworzysz środowiska z bardzo ograniczoną przestrzenią na pliki binarne, nie będzie to stanowić problemu i nadal stanowi znaczną poprawę w stosunku do innych rozwiązań, zarówno pod względem przejrzystości, jak i bezpieczeństwa.

Jeśli wydajność przestrzeni jest bardzo ważna, te dwa rozwiązania z vargs i vsnprintf mogą być przydatne. NIE UŻYWAJ żadnych rozwiązań o ustalonych długościach buforów, które wymagają jedynie problemów.

Rozwiązanie C ++ 11, które wykorzystuje vsnprintf()wewnętrznie:

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

Bezpieczniejsze i bardziej wydajne (przetestowałem to i jest szybsze) podejście:

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

fmt_strJest przekazywane przez wartość za zgodne z wymaganiamiva_start .

UWAGA: „Bezpieczniejsza” i „szybsza” wersja nie działa na niektórych systemach. Dlatego oba są nadal wymienione. Również „szybsze” zależy całkowicie od poprawności kroku wstępnego przydziału, w przeciwnym razie strcpyrenderowanie będzie wolniejsze.

boost::format() zapewnia pożądaną funkcjonalność:

Począwszy od streszczenia bibliotek formatu Boost:

Obiekt formatu jest konstruowany z ciągu formatu, a następnie otrzymuje argumenty poprzez powtarzane wywołania operatora%. Każdy z tych argumentów jest następnie konwertowany na ciągi, które z kolei są łączone w jeden ciąg, zgodnie z ciągiem formatującym.

#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 obejmie, std::formatktóry przypomina sprintfAPI, ale jest w pełni bezpieczny dla typów, działa z typami zdefiniowanymi przez użytkownika i używa składni łańcuchowej formatu podobnego do Pythona. Oto, w jaki sposób będziesz mógł sformatować std::stringi zapisać go w strumieniu:

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

lub

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

Alternatywnie możesz użyć biblioteki {fmt}, aby sformatować ciąg i zapisać go stdoutlub strumień plików za jednym razem:

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

Podobnie jak w przypadku sprintfwiększości innych odpowiedzi tutaj, niestety używają one varargs i są z natury niebezpieczne, chyba że użyjesz czegoś takiego jak formatatrybut GCC, który działa tylko z literałymi ciągami formatu. Możesz zobaczyć, dlaczego te funkcje są niebezpieczne na następującym przykładzie:

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

gdzie string_format jest wdrożenie z odpowiedzi Erika Aronesty. Ten kod się kompiluje, ale najprawdopodobniej ulegnie awarii podczas próby uruchomienia:

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

Zastrzeżenie : Jestem autorem {fmt} i C ++ 20 std::format.

Jeśli chcesz tylko składnię podobną do printf (bez samodzielnego wywoływania printf), spójrz na Format Boost .

Napisałem własny przy użyciu vsnprintf, więc zwraca ciąg zamiast konieczności tworzenia własnego bufora.

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

Możesz więc używać go jak

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

Aby sformatować std::stringw sposób „sprintf”, wywołaj snprintf(argumenty nullptri 0), aby uzyskać potrzebną długość bufora. Napisz swoją funkcję przy użyciu szablonu variadic C ++ 11 w następujący sposób:

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

Kompiluj z obsługą C ++ 11, na przykład w GCC: g++ -std=c++11

Stosowanie:

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

[edycja: 20/05/25] lepiej jeszcze ...:
W nagłówku:

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

Funkcja PRINTSTRING(r)służy do obsługi interfejsu graficznego lub terminala lub innych specjalnych potrzeb wyjściowych #ifdef _some_flag_, domyślnie:

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

[edytuj '17 / 8/31] Dodanie variadic wersji szablonów „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;
}

która jest w rzeczywistości wersją rozdzielaną przecinkami (zamiast) niekiedy przeszkadzających <<operatorów, używanych w ten sposób:

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

[edytuj] Dostosowany do wykorzystania techniki zawartej w odpowiedzi Erika Aronesty (powyżej):

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

[poprzednia odpowiedź]
Bardzo późna odpowiedź, ale dla tych, którzy, podobnie jak ja, lubią „sprintf”: napisałem i używam następujących funkcji. Jeśli Ci się spodoba, możesz rozwinąć opcje%, aby ściślej pasowały do ​​sprintfów; te tam obecnie są wystarczające na moje potrzeby. Używasz stringf () i stringfappend () tak samo jak sprintf. Pamiętaj tylko, że parametry ... muszą być typami 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;
}

Oto jak robi to Google: StringPrintf(licencja BSD)
i Facebook robi to w dość podobny sposób: StringPrintf(licencja Apache)
Oba zapewniają również wygodę StringAppendF.

Moje dwa centy za to bardzo popularne pytanie.

Cytując manpage z printf-Jak funkcji :

Po pomyślnym zwróceniu funkcje te zwracają liczbę drukowanych znaków (z wyłączeniem bajtu zerowego używanego do zakończenia wyjścia w łańcuchach).

Funkcje snprintf () i vsnprintf () nie zapisują więcej niż wielkości bajtów (w tym kończącego bajtu zerowego ('\ 0')). Jeśli wynik został obcięty z powodu tego limitu, zwracaną wartością jest liczba znaków (z wyłączeniem kończącego bajtu zerowego), które zostałyby zapisane w końcowym ciągu, gdyby było wystarczająco dużo miejsca. Dlatego zwracana wartość rozmiaru lub większa oznacza, że ​​dane wyjściowe zostały obcięte.

Innymi słowy, rozsądna implementacja C ++ 11 powinna wyglądać następująco:

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

Działa całkiem dobrze :)

Szablony Variadic są obsługiwane tylko w C ++ 11. Odpowiedź z pixelpoint pokazuje podobną technikę przy użyciu starszych stylów programowania.

To dziwne, że C ++ nie ma czegoś takiego po wyjęciu z pudełka. Ostatnio dodali to_string(), co moim zdaniem jest wielkim krokiem naprzód. Zastanawiam się, czy dodadzą one .formatoperatora dostd::string ostatecznie ...

Edytować

Jak wskazał alexk7, A +1jest potrzebne na wartości zwracanej std::snprintf, ponieważ musimy mieć miejsce na \0bajt. Intuicyjnie, w przypadku większości architektur brakujące +1spowoduje requiredczęściowe zastąpienie liczby całkowitej przez 0. Stanie się tak po oszacowaniu requiredrzeczywistego parametru dlastd::snprintf , więc efekt nie powinien być widoczny.

Problem ten może się jednak zmienić, na przykład przy optymalizacji kompilatora: co, jeśli kompilator zdecyduje się użyć rejestru dla requiredzmiennej? Jest to rodzaj błędów, które czasami powodują problemy z bezpieczeństwem.

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

Korzystanie z C99 snprintf i C ++ 11

Testowane, odpowiedź na pytanie o jakość produkcji

Ta odpowiedź dotyczy ogólnego przypadku przy użyciu technik zgodnych ze standardami. To samo podejście podano jako przykład na stronie CppReference.com u dołu strony. W przeciwieństwie do ich przykładów, ten kod spełnia wymagania pytania i jest testowany w terenie w robotyce i aplikacjach satelitarnych. Poprawiono także komentowanie. Jakość projektu omówiono poniżej.

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

Przewidywalna wydajność liniowa

Dwa przejścia są niezbędne dla bezpiecznej, niezawodnej i przewidywalnej funkcji wielokrotnego użytku zgodnie ze specyfikacją pytania. Domniemania dotyczące rozkładu wielkości vargów w funkcji wielokrotnego użytku są złym stylem programowania i należy ich unikać. W tym przypadku arbitralnie duże reprezentacje zmiennej długości vargs są kluczowym czynnikiem przy wyborze algorytmu.

Ponowna próba przepełnienia jest wykładniczo nieefektywna, co jest kolejnym powodem omawianym, gdy komitet normalizacyjny C ++ 11 omówił powyższą propozycję zapewnienia suchego przebiegu, gdy bufor zapisu jest zerowy.

W powyższej implementacji gotowej do produkcji, pierwszy przebieg jest takim suchym przebiegiem w celu ustalenia wielkości alokacji. Alokacja nie występuje. Przetwarzanie dyrektyw printf i czytanie vargów stało się niezwykle skuteczne przez dziesięciolecia. Kod wielokrotnego użytku powinien być przewidywalny, nawet jeśli trzeba poświęcić niewielką nieefektywność dla trywialnych przypadków.

Bezpieczeństwo i niezawodność

Andrew Koenig powiedział niewielkiej grupie z nas po swoim wykładzie na wydarzeniu w Cambridge: „Funkcje użytkownika nie powinny polegać na wykorzystaniu niepowodzenia wyjątkowej funkcjonalności”. Od tego czasu jego mądrość okazała się prawdziwa. Naprawione i zamknięte błędy bezpieczeństwa często wskazują na powtórne włamania w opisie otworu wykorzystanego przed naprawą.

Jest to wspomniane w formalnej propozycji zmiany standardów dla funkcji bufora zerowego w Alternative to sprintf, C9X Revision Wniosek , Dokument ISO IEC WG14 N645 / X3J11 96-008 . Dowolnie długi ciąg wstawiany według dyrektywy drukowania „% s” w ramach ograniczeń dynamicznej dostępności pamięci nie jest wyjątkiem i nie powinien być wykorzystywany do tworzenia „wyjątkowej funkcjonalności”.

Rozważ propozycję obok przykładowego kodu podanego na dole strony C ++ Reference.org, do której link znajduje się w pierwszym akapicie tej odpowiedzi.

Ponadto testowanie przypadków awarii rzadko jest tak wiarygodne jak przypadki sukcesu.

Ruchliwość

Wszyscy główni dostawcy systemów operacyjnych udostępniają kompilatory w pełni obsługujące std :: vsnprintf jako część standardów c ++ 11. Hosty z produktami dostawców, które nie utrzymują już dystrybucji, powinny być wyposażone w g ++ lub clang ++ z wielu powodów.

Wykorzystanie w stosie

Wykorzystanie stosu w pierwszym wywołaniu do std :: vsnprintf będzie mniejsze lub równe zużyciu drugiego i zostanie zwolnione przed rozpoczęciem drugiego wywołania. Jeśli pierwsze wywołanie przekroczy dostępność stosu, std :: fprintf również się nie powiedzie.

C ++ 20 std::format

Przybył! Funkcja jest opisana na stronie : http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2019/p0645r9.html i używa .format()składni podobnej do Pythona .

Oczekuję, że użycie będzie wyglądało tak:

#include <format>
#include <string>

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

Spróbuję, kiedy wsparcie dotrze do GCC, GCC 9.1.0 g++-9 -std=c++2anadal go nie obsługuje.

Interfejs API doda nowy std::formatnagłówek:

Proponowany interfejs API formatowania jest zdefiniowany w nowym nagłówku <format>i nie powinien mieć wpływu na istniejący kod.

Istniejąca fmtbiblioteka twierdzi, że zaimplementuje ją, jeśli potrzebujesz wypełnienia: https://github.com/fmtlib/fmt

Implementacja C ++ 20 std::format.

i był wcześniej wspomniany w: formatowanie std :: string jak sprintf

Na podstawie odpowiedzi udzielonej przez Erika 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();
}

Pozwala to uniknąć konieczności odrzucania, constktórego wynik .c_str()był w pierwotnej odpowiedzi.

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 nie ma tego, czego potrzebujesz, ale ma std :: stringstream. Użyj ciągu znaków, aby utworzyć ciąg, a następnie wyodrębnij ciąg. Oto pełna lista rzeczy, które możesz zrobić. Na przykład:

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

da Ci 10 miejsc po przecinku z precyzją podczas drukowania podwójnego lub zmiennoprzecinkowego.

Możesz spróbować:

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

Jeśli korzystasz z systemu, który ma asprintf (3) , możesz łatwo go owinąć:

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

To jest kod, którego używam do zrobienia tego w moim programie ... To nic nadzwyczajnego, ale robi to sztuczkę ... Uwaga, będziesz musiał dostosować swój rozmiar odpowiednio do potrzeb. MAX_BUFFER to dla mnie 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;
}

Wziął pomysł z Dacav i odpowiedź pixelpoint . Grałem trochę i dostałem to:

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

Z rozsądną praktyką programowania uważam, że kod powinien wystarczyć, jednak wciąż jestem otwarty na bezpieczniejsze alternatywy, które są wciąż wystarczająco proste i nie wymagałyby C ++ 11.

A oto kolejna wersja, która wykorzystuje bufor początkowy, aby zapobiec ponownemu wywołaniu, vsnprintf()gdy bufor początkowy jest już wystarczający.

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

(Okazuje się, że ta wersja jest po prostu podobna do odpowiedzi Piti Ongmongkolkul , tyle że nie używa newi delete[]określa rozmiar podczas tworzenia std::string.

Chodzi o to, aby nie używać newi delete[]sugerować użycie stosu nad stertą, ponieważ nie musi on wywoływać funkcji alokacji i dezalokacji, jednak jeśli nie zostanie właściwie użyty, buforowanie przepełnień w niektórych (być może starych lub być może po prostu słabe) systemy. Jeśli jest to problem, zdecydowanie sugeruję użycie newi delete[]zamiast tego. Zauważ, że jedyny problem dotyczy alokacji, jak vsnprintf()to się już nazywa z limitami, więc określenie limitu na podstawie wielkości przydzielonej w drugim buforze również by je zapobiegło.)

Zwykle używam tego:

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

Wada: nie wszystkie systemy obsługują vasprint

Poniżej nieznacznie zmodyfikowana wersja odpowiedzi @iFreilicht, zaktualizowana do C ++ 14 (użycie make_uniquefunkcji zamiast surowej deklaracji) i dodano obsługę std::stringargumentów (na podstawie artykułu Kenny'ego Kerra )

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

Wynik:

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

W razie potrzeby możesz połączyć tę odpowiedź z oryginalną.

Biblioteka Poco Foundation ma bardzo wygodną funkcję formatowania, która obsługuje std :: string zarówno w formacie formatującym, jak i wartościach:

• Dokument: http://pocoproject.org/docs/Poco.html#7308
• Źródło: https://github.com/pocoproject/poco/blob/develop/Foundation/src/Format.cpp

Możesz sformatować dane wyjściowe C ++ w cout przy użyciu pliku nagłówka iomanip. Upewnij się, że dołączasz plik nagłówka iomanip, zanim użyjesz funkcji pomocniczych, takich jak setprecision, setfill itp.

Oto fragment kodu, którego użyłem w przeszłości, aby wydrukować średni czas oczekiwania w wektorze, który „skumulowałem”.

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

Oto krótki opis tego, jak możemy sformatować strumienie C ++. http://www.cprogramming.com/tutorial/iomanip.html

Mogą wystąpić problemy, jeśli bufor nie jest wystarczająco duży, aby wydrukować ciąg. Musisz określić długość sformatowanego ciągu przed wydrukowaniem tam sformatowanej wiadomości. Robię do tego własnego pomocnika (testowane na Windows i Linux GCC ) i możesz go użyć.

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

Bardzo, bardzo proste rozwiązanie.

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

Zdaję sobie sprawę, że na to pytanie udzielono odpowiedzi wiele razy, ale jest to bardziej zwięzłe:

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

przykład:

#include <iostream>
#include <random>

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

Zobacz także http://rextester.com/NJB14150

AKTUALIZACJA 1 : dodanofmt::format testy

Przeprowadziłem własne badanie wokół metod, które tu wprowadziłem i uzyskałem diametralnie przeciwne wyniki w porównaniu z wymienionymi tutaj.

Użyłem 4 funkcji w 4 metodach:

• funkcja wariadyczna + vsnprintf+std::unique_ptr
• funkcja wariadyczna + vsnprintf+std::string
• funkcja szablonu variadic + std::ostringstream+ std::tuple+utility::for_each
• fmt::formatfunkcja z fmtbiblioteki

Do testowania zaplecza googletestużył.

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

for_eachRealizacja pochodzi stąd: iteracyjne nad krotki

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

}

Testy:

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

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

}

WYNIKI :

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

Jak widać implementacja przez vsnprintf+ std::stringjest równa fmt::format, ale szybsza niż przez vsnprintf+std::unique_ptr , co jest szybsze niż przez std::ostringstream.

Testy zostały skompilowane Visual Studio 2015 Update 3i uruchomione w Windows 7 x64 / Intel Core i7-4820K CPU @ 3.70GHz / 16GB.