std :: форматування рядків, як sprintf

Я маю на формат std::stringз sprintfі відправити його в файловий потік. Як я можу це зробити?

Ви не можете зробити це прямо, тому що у вас немає доступу до основного буферу (до C ++ 11, см Dietrich Еппи коментаря ). Вам доведеться зробити це спочатку в c-string, а потім скопіювати його в std :: string:

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

Але я не впевнений, чому б ви не просто використовували потоковий рядок? Я припускаю, що у вас є конкретні причини не просто робити це:

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

Сучасний C ++ робить це дуже просто.

C ++ 20

C ++ 20 представляє std::format, що дозволяє зробити саме це. Він використовує поля заміни, аналогічні тим, у python :

#include <iostream>
#include <format>

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

Ознайомтеся з повною документацією ! Це величезне покращення якості життя.

C ++ 11

З C ++ 11 с std::snprintfце вже стало досить легким і безпечним завданням.

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

Вищенаведений фрагмент коду ліцензований під CC0 1.0 .

Пояснення за рядком:

Мета: Напишіть у achar*за допомогою, std::snprintfа потім перетворіть його на astd::string.

Спочатку ми визначаємо потрібну довжину масиву char за допомогою спеціальної умови в snprintf. З сайту cppreference.com :

Повернене значення

[...] Якщо результуюча рядок стає усіченою через обмеження buf_size, функція повертає загальну кількість символів (не враховуючи закінчуючий нульовий байт), які були б записані, якби не було встановлено обмеження.

Це означає, що потрібний розмір - це кількість символів плюс один , так що нульовий термінатор буде сидіти після всіх інших символів і його знову може бути відрізаний конструктором рядків. Цю проблему пояснив @ alexk7 у коментарях.

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

snprintfповерне від’ємне число, якщо сталася помилка, тож ми перевіряємо, чи форматування працювало за бажанням. Якщо цього не зробити, це може призвести до мовчазних помилок або виділення величезного буфера, на що в коментарях вказував @ead.

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

Далі ми виділяємо новий масив символів і присвоюємо йому а std::unique_ptr. Це, як правило, рекомендується, оскільки вам не доведеться знову вручну delete.

Зауважте, що це не безпечний спосіб розподілу визначених unique_ptrкористувачем типів, оскільки ви не можете розмістити пам'ять, якщо конструктор кидає виняток!

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

Після цього ми, звичайно, можемо просто використовувати snprintfза призначенням і записати відформатований рядок у char[].

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

Нарешті, ми створюємо та повертаємо нове std::stringз цього, переконуючись опустити нульовий термінатор наприкінці.

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

Приклад дії можна побачити тут .

Якщо ви також хочете використовувати std::stringв списку аргументів, погляньте на цю суть .

Додаткова інформація для користувачів Visual Studio :

Як пояснено у цій відповіді , Microsoft перейменовано std::snprintfна _snprintf(так, без std::). Далі MS встановлює його як застаріле і радить використовувати _snprintf_sзамість цього, однак _snprintf_sне прийме буфер нульовим або меншим, ніж відформатований вихід, і не буде обчислювати довжину виходів, якщо це відбудеться. Отже, щоб позбутися попереджень про депресацію під час компіляції, ви можете вставити наступний рядок у верхній частині файлу, який містить використання _snprintf:

#pragma warning(disable : 4996)

Заключні думки

Дуже багато відповідей на це запитання було написано до часу C ++ 11 і використовували фіксовану довжину буфера або ваги. Якщо ви не зациклюєтесь на старих версіях C ++, я б не рекомендував використовувати ці рішення. В ідеалі йдіть шляхом С ++ 20.

Оскільки рішення C ++ 11 у цій відповіді використовує шаблони, воно може генерувати зовсім небагато коду, якщо воно використовується багато. Однак, якщо ви не розробляєте середовище з дуже обмеженим простором для бінарних файлів, це не буде проблемою, і це все ще неабияке вдосконалення в порівнянні з іншими рішеннями як в ясності, так і в безпеці.

Якщо ефективність простору надзвичайно важлива, ці два рішення з vargs та vsnprintf можуть бути корисними. НЕ ВИКОРИСТОВУЙТЕ будь-які рішення з фіксованою довжиною буфера, це просто задає проблеми.

C ++ 11 рішення, яке використовується vsnprintf()внутрішньо:

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

Більш безпечний і ефективніший (я тестував це, і це швидше) підхід:

#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_strпередається за значенням, щоб відповідати вимогам va_start.

ПРИМІТКА: "Більш безпечна" та "швидша" версія не працює в деяких системах. Отже, обидва досі перераховані. Крім того, "швидше" повністю залежить від правильності кроку попереднього розміщення, інакше це strcpyробить повільніше.

boost::format() надає потрібну вам функціональність:

З конспекту бібліотек формату Boost:

Об'єкт форматування будується з рядка формату, а потім йому надаються аргументи через повторні виклики оператору%. Кожен з цих аргументів потім перетворюється на рядки, які в свою чергу об'єднуються в одну рядок відповідно до рядка формату.

#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 буде включати, std::formatщо нагадує sprintfз точки зору API, але повністю безпечний для типу, працює з визначеними користувачем типами та використовує синтаксис струнних синтаксисів формату Python. Ось як ви зможете відформатувати std::stringта записати його в потік:

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

або

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

Можна також використати бібліотеку {fmt} для форматування рядка та запису до нього stdoutабо потоку файлів за один раз:

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

Як для sprintf або більшості інших відповідей тут, то, на жаль, вони використовують varargs і є по суті небезпечними, якщо ви не використовуєте щось на зразок formatатрибута GCC, який працює лише з рядками прямого формату. На наступному прикладі ви можете зрозуміти, чому ці функції небезпечні:

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

де string_formatреалізація з відповіді Еріка Аронесті. Цей код компілюється, але він, швидше за все, вийде з ладу при спробі його запуску:

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

Відмова : Я автор {fmt} та C ++ 20 std::format.

Якщо ви хочете лише синтаксис, схожий на printf (не викликаючи сам printf), погляньте на формат Boost .

Я написав свій власний, використовуючи vsnprintf, тому він повертає рядок замість того, щоб створювати власний буфер.

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

Таким чином, ви можете використовувати це як

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

Для того, щоб форматувати std::stringв 'sprintf' спосіб, зателефонуйте snprintf(аргументи nullptrта 0), щоб отримати необхідну довжину буфера. Запишіть свою функцію, використовуючи такий варіант C ++ 11:

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

Компілюйте з підтримкою C ++ 11, наприклад в GCC: g++ -std=c++11

Використання:

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

[ред .: 20/05/25] ще краще ...:
У заголовку:

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

Функція PRINTSTRING(r)полягає в обслуговуванні графічного інтерфейсу або терміналу або будь-яких спеціальних вихідних потреб, використовуючи #ifdef _some_flag_за замовчуванням:

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

[редагувати '17 / 8/31] Додавання варіативної шаблонової версії '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;
}

яка фактично обмежена комою (замість) іноді перешкоджаючих <<-операторів, використовуваних так:

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

[редагувати] Адаптовано для використання методики у відповіді Еріка Аронесті (вище):

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

[попередня відповідь]
Дуже пізня відповідь, але для тих, хто, як і я, так подобається "спринт": я написав і використовую такі функції. Якщо вам це подобається, ви можете розширити% -пції, щоб тісніше підходити до sprintf; тих, що там зараз є, достатньо для моїх потреб. Ви використовуєте stringf () і stringfappend () так само, як і sprintf. Просто пам’ятайте, що параметри для ... повинні бути типами 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;
}

Ось як це робить Google: StringPrintf(Ліцензія BSD),
а facebook робить це досить схожим чином: StringPrintf(Ліцензія Apache)
Обидва надають і зручне StringAppendF.

Мої два центи на це дуже популярне питання.

Щоб процитувати статтю printf-подібних функцій :

Після успішного повернення ці функції повертають кількість надрукованих символів (виключаючи нульовий байт, який використовується для завершення виведення у рядки).

Функції snprintf () і vsnprintf () не записують більше, ніж розміри байтів (включаючи кінцевий нульовий байт ('\ 0')). Якщо висновок був урізаний через цю межу, то значенням повернення є кількість символів (за винятком закінчуваного нульового байта), які були б записані в заключний рядок, якби було достатньо місця. Таким чином, повернене значення розміру або більше означає, що вихід був усічений.

Іншими словами, розумною реалізацією C ++ 11 має бути наступне:

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

Це працює досить добре :)

Варіантні шаблони підтримуються лише в C ++ 11. Відповідь від pixelpoint показує аналогічну техніку за допомогою старих стилів програмування.

Дивно, що C ++ такого не має. Нещодавно вони додали to_string(), що, на мій погляд, є чудовим кроком вперед. Мені цікаво, чи додадуть вони .formatоператора в std::stringпідсумку ...

Редагувати

Як вказував alexk7, A +1потрібен для зворотного значення std::snprintf, оскільки нам потрібно мати простір для \0байта. Інтуїтивно зрозуміло, що для більшості архітектур, відсутніх +1волі, requiredціле число буде частково перезаписане символом a 0. Це станеться після оцінки requiredфактичного параметра для std::snprintf, тому ефект не повинен бути видимим.

Однак ця проблема може змінитися, наприклад, при оптимізації компілятора: що робити, якщо компілятор вирішить використовувати регістр requiredзмінної? Це вид помилок, які іноді призводять до проблем із безпекою.

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

Використання C99 snprintf та C ++ 11

Випробувано, відповідь якості виробництва

Ця відповідь обробляє загальний випадок методами, що відповідають стандартам. Такий самий підхід наводиться як приклад на CppReference.com внизу їх сторінки. На відміну від їх прикладу, цей код відповідає вимогам запитання і перевіряється на місцях у робототехніці та супутникових програмах. Це також покращило коментування. Якість дизайну обговорюється далі.

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

Прогнозована лінійна ефективність

Два проходи необхідні для безпечної, надійної та передбачуваної функції багаторазового використання відповідно до специфікацій питання. Припущення щодо розподілу розмірів вагів у функції багаторазового використання є поганим стилем програмування, і цього слід уникати. У цьому випадку довільно великі подання змінної довжини вагів є ключовим фактором вибору алгоритму.

Повторна спроба після переповнення експоненціально неефективна, що є ще однією причиною, яку обговорювали, коли комітет стандартів C ++ 11 обговорював вищевказану пропозицію щодо забезпечення сухого виконання, коли буфер запису недійсний.

У вищезазначеній реалізації, готовій до реалізації, перший запуск - це такий сухий цикл для визначення розміру виділення. Розподіл не відбувається. Розбір директив printf та читання ваг був зроблений надзвичайно ефективно протягом десятиліть. Код для багаторазового використання повинен бути передбачуваним, навіть якщо мала неефективність тривіальних випадків повинна бути принесена в жертву.

Безпека та надійність

Після лекції на заході в Кембриджі Ендрю Кеніг сказав невеликій групі з нас: "Користувацькі функції не повинні покладатися на експлуатацію невдач для невиключної функціональності". Як завжди, з того часу його мудрість виявилася правдою. Виправлені та закриті проблеми з помилками безпеки часто вказують на повторні взломи в описі отвору, який експлуатувався до виправлення.

Про це йдеться в офіційній пропозиції щодо перегляду формальних стандартів для функції нульового буфера в Альтернативі sprintf, Пропозиції щодо редакції C9X, Документу ISO IEC WG14 N645 / X3J11 96-008 . Довільно довгий рядок, вставлений у директиву щодо друку, "% s" в межах обмежень доступності динамічної пам'яті, не є винятком і не повинен використовуватися для створення "Невиключної функціональності".

Розгляньте пропозицію поряд із прикладом коду, наведеним у нижній частині сторінки C ++ Reference.org, посилаючись на перший абзац цієї відповіді.

Крім того, тестування випадків невдач рідко є надійним випадком успіху.

Переносність

Усі основні постачальники ОС надають компілятори, які повністю підтримують std :: vsnprintf як частину стандартів c ++ 11. Господарі запущених продуктів постачальників, які більше не підтримують розповсюдження, повинні бути забезпечені g ++ або clang ++ з багатьох причин.

Використання стека

Використання стека в 1-му дзвінку до std :: vsnprintf буде менше або рівне тому, що у другому, і воно буде звільнене до початку 2-го виклику. Якщо перший виклик перевищує доступність стеку, то і std :: fprintf теж не вдасться.

C ++ 20 std::format

Це прибуло! Ця функція описана за адресою: http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2019/p0645r9.html та використовує подібний до Python.format() синтаксис, .

Я очікую, що використання буде таким:

#include <format>
#include <string>

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

Я спробую, коли підтримка надійде до GCC, GCC 9.1.0 з g++-9 -std=c++2a ще не підтримує її.

API додасть новий std::formatзаголовок:

Пропонований API форматування визначений у новому заголовку <format>і не повинен впливати на існуючий код.

Існуюча fmtбібліотека вимагає її реалізувати, якщо вам потрібна поліфайл: https://github.com/fmtlib/fmt

Впровадження C ++ 20 std::format.

і раніше згадувалося на: std :: string formatting like sprintf

На основі відповіді Еріка Аронесті:

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

Це дозволяє уникнути необхідності відмовлятися constвід результату, .c_str()який був у оригінальній відповіді.

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

рядок не має того, що вам потрібно, але std :: stringstream робить. Створіть рядок, щоб створити рядок, а потім витягніть рядок. Ось вичерпний список речей, які ви можете зробити. Наприклад:

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

дасть вам 10 десяткових знаків точності при друкуванні дублера або поплавця.

Ви можете спробувати це:

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

Якщо ви працюєте в системі, яка має asprintf (3) , ви можете її легко перетворити :

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

Це код, який я використовую для цього у своїй програмі ... Це нічого не фантазії, але це робить трюк ... Зауважте, вам доведеться коригувати свій розмір, як це потрібно. MAX_BUFFER для мене - 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;
}

Ідею взяв з відповіді Дакава та піксельпойнта . Я трохи пограв і отримав таке:

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

Зважаючи на практику нормального програмування, я вважаю, що коду має бути достатньо, проте я все ще відкритий для більш безпечних альтернатив, які все ще досить прості і не потребують C ++ 11.

І ось ще одна версія, яка використовує початковий буфер для запобігання другого виклику, vsnprintf()коли початкового буфера вже достатньо.

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

(Виявляється, що ця версія просто схожа на відповідь Піті Онгмонгколкула , лише те, що вона не використовується newі delete[], а також визначає розмір при створенні std::string.

Ідея тут не використовувати newі delete[]полягає в тому, щоб використовувати стек над купою, оскільки йому не потрібно викликати функції розподілу та розподілу, проте, якщо їх правильно не використовувати, це може бути небезпечним переповненням буфера в деяких (можливо, старих, або можливо, просто вразливі) системи. Якщо це викликає занепокоєння, я настійно пропоную використовувати newі delete[]замість цього. Зауважте, що тут є єдине занепокоєння щодо розподілу, як vsnprintf()це вже називається з обмеженнями, тому визначення ліміту на основі розміру, виділеного на другому буфері, також перешкоджатиме цьому.)

Я зазвичай використовую це:

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

Недолік: не всі системи підтримують вспрінт

Нижче трохи змінена версія відповіді @iFreilicht, оновлена ​​до C ++ 14 (використання make_uniqueфункції замість необробленої декларації) та додана підтримка std::stringаргументів (на основі статті Кенні Керра )

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

Вихід:

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

Не соромтеся при бажанні злити цю відповідь з оригінальною.

Фонд ПокоБібліотека має дуже зручну функцію форматування, яка підтримує std :: string як у рядку формату, так і у значеннях:

• Документ: http://pocoproject.org/docs/Poco.html#7308
• Джерело: https://github.com/pocoproject/poco/blob/develop/Foundation/src/Format.cpp

Ви можете відформатувати вихід C ++ у cout, використовуючи заголовок iomanip. Переконайтеся, що ви включили файл заголовка iomanip перед тим, як використовувати будь-яку з допоміжних функцій, таких як setpoint, setfill тощо.

Ось фрагмент коду, який я раніше використовував для друку середнього часу очікування у векторі, який я "накопичив".

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

Ось короткий опис того, як ми можемо форматувати потоки C ++. http://www.cprogramming.com/tutorial/iomanip.html

Можуть виникнути проблеми, якщо буфер недостатньо великий для друку рядка. Ви повинні визначити довжину відформатованого рядка, перш ніж надрукувати там відформатоване повідомлення. Я роблю власного помічника в цьому (тестується на Windows і Linux GCC ), і ви можете спробувати використовувати його.

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

Дуже-дуже просте рішення.

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

Я усвідомлюю, що на це відповіли багато разів, але це більш стисло:

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

приклад:

#include <iostream>
#include <random>

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

Дивіться також http://rextester.com/NJB14150

ОНОВЛЕННЯ 1 : доданоfmt::format тести

Я взяв власне дослідження щодо впроваджених тут методів і отримав діаметрально протилежні результати порівняно із згаданими тут.

Я використовував 4 функції протягом 4-х методів:

• варіативна функція + vsnprintf+std::unique_ptr
• варіативна функція + vsnprintf+std::string
• функція варіативного шаблону + std::ostringstream+ std::tuple+utility::for_each
• fmt::formatфункція з fmtбібліотеки

Для тестового бекенда googletestвикористано.

#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_eachРеалізація взята звідси: перебрати кортеж

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

}

Тести:

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

}

РЕЗУЛЬТАТИ :

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

Як ви бачите, реалізація через vsnprintf+ std::stringдорівнює fmt::format, але швидше, ніж через vsnprintf+ std::unique_ptr, що швидше, ніж через std::ostringstream.

Тести, складені Visual Studio 2015 Update 3та запущені в Windows 7 x64 / Intel Core i7-4820K CPU @ 3.70GHz / 16GB.