std string formatting like sprintf

Question

I have to format std  string with sprintf and send it into file stream  How can I do this

User · Answer

You could try this   string str  str resize   MAX PATH     sprintf   amp str 0     s  s    hello    world        optionals    sprintf s   amp str 0   str length      s  s    hello    world        Microsoft     include  lt stdio h gt     snprintf   amp str 0   str length      s  s    hello    world        c  11  str resize  strlen  str data       1

User · Answer

You can format C   output in cout using iomanip header file  Make sure that you include iomanip header file before you use any of the helper functions like setprecision  setfill etc   Here is a code snippet I have used in the past to print the average waiting time in the vector  which I have  accumulated     include lt iomanip gt   include lt iostream gt   include lt vector gt   include lt numeric gt        cout lt  lt   Average waiting times for tasks is    lt  lt  setprecision 4   lt  lt  accumulate all waitingTimes   0  double waitingTimes size      cout  lt  lt    and    lt  lt  Q size    lt  lt    tasks remaining   lt  lt  endl    Here is a brief description of how we can format C   streams  http   www cprogramming com tutorial iomanip html

User · Answer

One solution I ve favoured is to do this with sprintf directly into the std  string buffer  after making said buffer big enough    include  lt string gt   include  lt iostream gt   using namespace std   string l output  l output resize 100    for  int i   0  i  lt  1000    i               memset   amp l output 0   0  100       sprintf   amp l output 0     r i 0   i        cout  lt  lt  l output      cout flush        So  create the std  string  resize it  access its buffer directly

User · Answer

return desc    boost  format  fail to detect  cv result    d     st result  str

User · Answer

Here my  simple solution    std  string Format const char  lpszFormat                Warning    vsnprintf  crashes with an access violation        exception if lpszFormat is not a  const char    for example  const string amp        size t  nSize       1024      char     lpBuffer    char  malloc nSize        va list lpParams       while  true                va start lpParams  lpszFormat            int nResult   vsnprintf              lpBuffer              nSize              lpszFormat              lpParams                     va end lpParams            if   nResult  gt   0   amp  amp   nResult  lt   int nSize                             Success              lpBuffer nResult      0               std  string sResult lpBuffer                free  lpBuffer                return sResult                    else                          Increase buffer              nSize                      nResult  lt  0                    nSize    2                    nResult   1                             lpBuffer    char   realloc lpBuffer  nSize

User · Answer

I will now write version for Visual Studio  hopefully someday someone will make it portable   Suspect need to replace  vsnwprintf with vsnwprintf and something like this    You need to disable deprecate warnings by using define  CRT SECURE NO WARNINGS from project configuration   I m using  vsnwprintf with first parameter as a nullptr to be able to estimate buffer size  reserve wstring buffer  and then formatting string directly into buffer   Not sure why you need to disable deprecated warning  as safe versions of same method call   vsnwprintf s  cannot use nullptr as an input  Suspect needs to be reported to Microsoft C   team   This version should be working with both - string or wstring classes   If you find any bug or inconsistency  please ask again  I ll try to fix it   stringHelpers h    pragma once  include  lt string gt          Formats string wstring according to format  if formatting fails  e g  invalid  s pointer - returns empty string     template  lt typename T gt  std  basic string lt T gt  sFormat const T  format             va list args      va start args  format       int size       if constexpr  std  is same v lt T  char gt           size   vsnprintf nullptr  0  format  args       else         size    vsnwprintf nullptr  0  format  args        size       Zero termination     std  basic string lt T gt  s      s resize size        if constexpr  std  is same v lt T  char gt           vsnprintf  amp s 0   size  format  args       else          vsnwprintf  amp s 0   size  format  args        va end args       return s      Above is sample of code  which can be copied as such  I will maintain working version in my own repository in github   https   github com tapika cppscriptcore blob master SolutionProjectModel helpers h L12

User · Answer

Poco Foundation library has a very convenient format function  which supports std  string in both the format string and the values    Doc  http   pocoproject org docs Poco html 7308 Source  https   github com pocoproject poco blob develop Foundation src Format cpp

User · Answer

inline void format string amp  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

User · Answer

In order to format std  string in a  sprintf  manner  call snprintf  arguments nullptr and 0  to get length of buffer needed  Write your function using C  11 variadic template like this    include  lt cstdio gt   include  lt string gt   include  lt cassert gt   template lt  typename    Args  gt  std  string string sprintf  const char  format  Args    args       int length   std  snprintf  nullptr  0  format  args         assert  length  gt   0       char  buf   new char length   1     std  snprintf  buf  length   1  format  args          std  string str  buf      delete   buf    return str      Compile with C  11 support  for example in GCC  g   -std c  11  Usage     std  cout  lt  lt  string sprintf   g   g n   1 23  0 001

User · Answer

edit  20 05 25  better still     In header       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  lt br  gt   void PRINTSTRING const std  string  amp s     cater for GUI  terminal  whatever   template lt typename   P gt  void say P   p    std  string r    std  stringstream ss       ss lt  lt     lt  lt p   r ss str    PRINTSTRING r     template lt typename   P gt  std  string says P   p    std  string r    std  stringstream ss       ss lt  lt     lt  lt p   r ss str    return r    template lt typename   P gt  void sayss std  string  amp s  P   p    std  string r    std  stringstream ss       ss lt  lt     lt  lt p   r ss str     s  r      APPENDS  to s  template lt typename   P gt  bool sayerr P   p    std  string r    std  stringstream ss  ERROR       ss lt  lt     lt  lt p   r ss str    PRINTSTRING r   return false      The PRINTSTRING r -function is to cater for GUI or terminal or any special output needs using  ifdef  some flag   the default is   void PRINTSTRING const std  string  amp s    std  cout  lt  lt  s  lt  lt  std  flush         edit  17 8 31  Adding a variadic templated version  vtspf        template lt typename T gt  const std  string type to string const T  amp v        std  ostringstream ss      ss  lt  lt  v      return ss str        template lt typename T gt  const T string to type const std  string  amp str        std  istringstream ss str       T ret      ss  gt  gt  ret      return ret      template lt typename   P gt  void vtspf priv std  string  amp s      template lt typename H  typename   P gt  void vtspf priv std  string  amp s  H h  P   p        s  type to string h       vtspf priv s  p         template lt typename   P gt  std  string temp vtspf P   p        std  string s          vtspf priv s  p          return s      which is effectively a comma-delimited version  instead  of the sometimes hindering  lt  lt -operators  used like this   char chSpace      double pi 3 1415  std  string sWorld  World   str var  str var   vtspf  Hello        chSpace  sWorld     pi    pi        edit  Adapted to make use of the technique in Erik Aronesty s answer  above     include  lt string gt   include  lt cstdarg gt   include  lt cstdio gt                                                                                   void spf std  string  amp 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 gt 0   amp  amp    b  n lt size    true   s resize n   else size  2                                                                                           void spfa std  string  amp 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 gt 0   amp  amp    b  n lt size    true   ss resize n   else size  2            s    ss       previous answer  A very late answer  but for those who  like me  do like the  sprintf -way  I ve written and are using the following functions  If you like it  you can expand the  -options to more closely fit the sprintf ones  the ones in there currently are sufficient for my needs  You use stringf   and stringfappend   same as you would sprintf  Just remember that the parameters for     must be POD types                                                                                   void DoFormatting std  string amp  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 lt m                ch   sf at i           if  ch                               i                if  i lt m                                ch   sf at i                   switch ch                                        case  s     s   va arg marker  char     ss  lt  lt  s            break                      case  c     n   va arg marker  int      ss  lt  lt   char n      break                      case  d     n   va arg marker  int      ss  lt  lt   int n       break                      case  l     l   va arg marker  long     ss  lt  lt   long l      break                      case  f     d   va arg marker  double   ss  lt  lt   float d     break                      case  e     d   va arg marker  double   ss  lt  lt   double d    break                      case  X                       case  x                                                         if    i lt m                                                                ss  lt  lt  std  hex  lt  lt  std  setiosflags  std  ios base  showbase                                   if  ch     X   ss  lt  lt  std  setiosflags  std  ios base  uppercase                                   char ch2   sf at i                                   if  ch2     c     n   va arg marker  int    ss  lt  lt  std  hex  lt  lt   char n                                    else if  ch2     d     n   va arg marker  int   ss  lt  lt  std  hex  lt  lt   int n                                    else if  ch2     l     l   va arg marker  long      ss  lt  lt  std  hex  lt  lt   long l                                    else ss  lt  lt       lt  lt  ch  lt  lt  ch2                                  ss  lt  lt  std  resetiosflags  std  ios base  showbase   std  ios base  uppercase   lt  lt  std  dec                                                          break                      case        ss  lt  lt         break                      default                                                ss  lt  lt       lt  lt  ch                            i   m    get out of loop                                                                         else ss  lt  lt  ch          i              va end marker       sF   ss str                                                                                       void stringf string amp  stgt const char  sformat              va list marker      va start marker  sformat       DoFormatting stgt  sformat  marker                                                                                      void stringfappend string amp  stgt const char  sformat              string sF           va list marker      va start marker  sformat       DoFormatting sF  sformat  marker       stgt    sF

User · Answer

template lt typename    Args gt  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  amp buf 0   size   1  fmt  args          return buf      Using C99 snprintf and C  11

User · Answer

I wrote my own using vsnprintf so it returns string instead of having to create my own buffer    include  lt string gt   include  lt cstdarg gt     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 lt  nsize     fail delete buffer and try again         delete   buffer          buffer   0          buffer   new char nsize 1      1 for  0         nsize   vsnprintf buffer  size  fmt  vl             std  string ret buffer       va end vl       delete   buffer      return ret      So you can use it like  std  string mystr   format   s  d  10 5f    omg   1  10 5

User · Answer

this can be tried out  simple  really does not use nuances of the string class though    include  lt stdarg h gt   include  lt stdio h gt   include  lt stdlib h gt   include  lt assert h gt    include  lt string gt   include  lt exception gt  using namespace std     ---------------------------------------------------------------------  class StringFormatter   public      static string format const char  format            string StringFormatter  format const char  format             va list  argptr       va start argptr  format            char    ptr          size t  size          FILE    fp mem   open memstream  amp ptr   amp size           assert fp mem            vfprintf  fp mem  format  argptr           fclose  fp mem        va end argptr        string ret   ptr      free ptr        return ret       ---------------------------------------------------------------------  int main void        string temp   StringFormatter  format  my age is  d   100       printf   s n   temp c str          return 0

User · Answer

This is how google does it  StringPrintf  BSD License  and facebook does it in a quite similar fashion  StringPrintf  Apache License  Both provide with a convenient StringAppendF too

User · Answer

If you are on a system that has asprintf 3   you can easily wrap it    include  lt iostream gt   include  lt cstdarg gt   include  lt cstdio gt   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  amp 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  lt  lt  format  Hello  s   d   username c str    123   lt  lt  std  endl      return 0

User · Answer

UPDATE 1  added fmt  format tests  I ve took my own investigation around methods has introduced here and gain diametrically opposite results versus mentioned here   I have used 4 functions over 4 methods    variadic function   vsnprintf   std  unique ptr variadic function   vsnprintf   std  string variadic template function   std  ostringstream   std  tuple   utility  for each fmt  format function from fmt library   For the test backend the googletest has used    include  lt string gt   include  lt cstdarg gt   include  lt cstdlib gt   include  lt memory gt   include  lt algorithm gt    include  lt fmt format h gt   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 lt char   gt  formatted       va list ap      va start ap  fmt str        while  true            formatted reset new char str len             const int final n   vsnprintf  amp formatted 0   str len  fmt str c str    ap            if  final n  lt  0    final n  gt   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 lt char   gt  str data     str len  fmt str c str    ap            if  final n  lt  0    final n  gt   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  lt typename    Args gt  inline std  string string format3 size t string reserve  Args    args        std  ostringstream ss      if  string reserve            ss rdbuf  - gt str   reserve string reserve             std  tuple lt Args    gt  t  args           utility  for each t    amp ss  auto  amp  v                ss  lt  lt  v              return ss str        The for each implementation is taken from here  iterate over tuple   include  lt type traits gt   include  lt tuple gt   namespace utility        template  lt std  size t I   0  typename FuncT  typename    Tp gt      inline typename std  enable if lt I    sizeof    Tp   void gt   type         for each std  tuple lt Tp    gt   amp   const FuncT  amp                    template lt std  size t I   0  typename FuncT  typename    Tp gt      inline typename std  enable if lt I  lt  sizeof    Tp   void gt   type         for each std  tuple lt Tp    gt   amp  t  const FuncT  amp  f                f std  get lt I gt  t            for each lt I   1  FuncT  Tp    gt  t  f              The tests   TEST ExternalFuncs  test string format on unique ptr 0        for  size t i   0  i  lt  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  lt  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  lt  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  lt  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  lt  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  lt  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  lt  1000000  i              std  ostringstream ss          ss  lt  lt   test test test   lt  lt       lt  lt  12345  lt  lt    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  lt  1000000  i              std  ostringstream ss          ss rdbuf  - gt str   reserve 256           ss  lt  lt   test test test   lt  lt       lt  lt  12345  lt  lt    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  lt  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  lt  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  amp 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             RESULTS     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    As you can see implementation through the vsnprintf std  string is equal to fmt  format  but faster than through the vsnprintf std  unique ptr  which is faster than through the std  ostringstream   The tests compiled in Visual Studio 2015 Update 3 and run at Windows 7 x64   Intel Core i7-4820K CPU   3 70GHz   16GB

User · Answer

This is the code I use to do this in my program    It s nothing fancy  but it does the trick    Note  you will have to adjust your size as applicable  MAX BUFFER for me is 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

User · Answer

C  20 std  format It has arrived  The feature is described at  http   www open-std org jtc1 sc22 wg21 docs papers 2019 p0645r9 html and uses a Python-like  format   syntax  I expect that the usage will be like   include  lt format gt   include  lt string gt   int main         std  string message   std  format  quot The answer is     quot   42      I ll give it a try when support arrives to GCC  GCC 9 1 0 with g  -9 -std c  2a still doesn t support it  The API will add a new std  format header   The proposed formatting API is defined in the new header  lt format gt  and should have no impact on existing code   The existing fmt library claims to implement it if you need the polyfill  https   github com fmtlib fmt  Implementation of C  20 std  format   and was previously mentioned at  std  string formatting like sprintf Hexadecimal format   x  C   cout hex values  Leading zeroes   03  Print leading zeros with C   output operator  Alignment left    lt    right    gt    center      C   alignment when printing cout  lt  lt  Floating point precision    2   How do I print a double value with full precision using cout  Set back default floating point print precision in C    Show sign on positive numbers      How to print positive numbers with a prefix   in C   Show booleans as true and false      Converting bool to text in C

User · Answer

I usually use this   std  string myformat const char  const fmt                 char  buffer   NULL          va list ap           va start ap  fmt            void vasprintf  amp buffer  fmt  ap           va end ap            std  string result   buffer          free buffer            return result      Disadvantage  not all systems support vasprint

User · Answer

C  20 will include std  format which resembles sprintf in terms of API but is fully type-safe  works with user-defined types  and uses Python-like format string syntax  Here s how you will be able to format std  string and write it to a stream  std  string s    quot foo quot   std  cout  lt  lt  std  format  quot Look  a string     quot   s    Alternatively  you could use the  fmt  library to format a string and write it to stdout or a file stream in one go  fmt  print  quot Look  a string     quot   s     As for sprintf or most of the other answers here  unfortunately they use varargs and are inherently unsafe unless you use something like GCC s format attribute which only works with literal format strings  You can see why these functions are unsafe on the following example  std  string format str    quot  s quot   string format format str  format str 0     where string format is an implementation from the Erik Aronesty s answer  This code compiles  but it will most likely crash when you try to run it    g   -Wall -Wextra -pedantic test cc      a out  Segmentation fault  11  Disclaimer  I m the author of  fmt  and C  20 std  format

User · Answer

C  11 solution that uses vsnprintf   internally    include  lt stdarg h gt      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  gt  -1  amp  amp  n  lt  size        Everything worked             str resize n               return str                    if  n  gt  -1      Needed size returned             size   n   1       For null char         else             size    2          Guess at a larger size  OS specific            return str      A safer and more efficient  I tested it  and it is faster  approach    include  lt stdarg h gt      For va start  etc   include  lt memory gt        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 lt char   gt  formatted      va list ap      while 1            formatted reset new char n       Wrap the plain char array into the unique ptr            strcpy  amp formatted 0   fmt str c str             va start ap  fmt str           final n   vsnprintf  amp formatted 0   n  fmt str c str    ap           va end ap           if  final n  lt  0    final n  gt   n              n    abs final n - n   1           else             break            return std  string formatted get         The fmt str is passed by value to conform with the requirements of va start   NOTE  The  safer  and  faster  version doesn t work on some systems  Hence both are still listed  Also   faster  depends entirely on the preallocation step being correct  otherwise the strcpy renders it slower

User · Answer

I gave it a try  with regular expressions  I implemented it for ints and const strings as an example  but you can add whatever other types  POD types but with pointers you can print anything     include  lt assert h gt   include  lt cstdarg gt    include  lt string gt   include  lt sstream gt   include  lt regex gt   static std  string formatArg std  string argDescr  va list args        std  stringstream ss      if  argDescr     i             int val   va arg args  int           ss  lt  lt  val          return ss str              if  argDescr     s             const char  val   va arg args  const char            ss  lt  lt  val          return ss str              assert 0     Not implemented    std  string format std  string fmt             std  string result fmt       va list args      va start args  fmt       std  regex e                            std  smatch m      while  std  regex search fmt  m  e             std  string formattedArg   formatArg m 1  str    args           fmt replace m position    m length    formattedArg             va end args       return fmt      Here is an example of use of it   std  string formatted   format  I am  s  and I have  i  cats    bob   3   std  cout  lt  lt  formatted  lt  lt  std  endl    Output      I am bob and I have 3 cats

User · Answer

For Visual C   std  wstring stringFormat const wchar t  fmt             if   fmt            return L               std  vector lt wchar t gt  buff      size t size   wcslen fmt    2      buff resize size       va list ap      va start ap  fmt       while  true            int ret    vsnwprintf s buff data    size   TRUNCATE  fmt  ap           if  ret    -1              break          else               size    2              buff resize size                       va end ap       return std  wstring buff data

User · Answer

Windows and Visual Studio have a mighty attractive solution  CString   CString str  str Format  Hello  s n    World    str    ABC   str     DEF

User · Answer

boost  format   provides the functionality you want   As from the Boost format libraries synopsis      A format object is constructed from a format-string  and is then given arguments through repeated calls to operator     Each of those arguments are then converted to strings  who are in turn combined into one string  according to the format-string     include  lt boost format hpp gt   cout  lt  lt  boost  format  writing  1    x  2     3 -th try      toto    40 23   50      prints  writing toto   x 40 230   50-th try

User · Answer

There can be problems  if the buffer is not large enough to print the string  You must determine the length of the formatted string before printing a formatted message in there  I make own helper to this  tested on Windows and Linux GCC   and you can try use it   String cpp  http   pastebin com DnfvzyKP String h  http   pastebin com 7U6iCUMa  String cpp    include  lt cstdio gt   include  lt cstdarg gt   include  lt cstring gt   include  lt string gt   using   std  string    pragma warning disable   4996    ifndef va copy  ifdef  MSC VER  define va copy dst  src  dst src  elif     cplusplus  gt   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  amp 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  gt  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  amp 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  lt cstdarg gt   include  lt string gt   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  amp 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  amp 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

User · Answer

This is a Windows specific solution designed to avoid compiler warnings in Visual Studio without silencing them  The warnings in question are for using an std  string with va start  which produces a warning erroneously  and for using deprecated printf variants    template lt typename     va gt  std  string Format  const std  string amp  format  va     args         std  string s      s resize   scprintf  format c str    args         1        s resize   snprintf s  s data    s capacity     TRUNCATE  format c str    args              return s     template lt typename     va gt  std  wstring Format  const std  wstring amp  format  va     args         std  wstring s      s resize   scwprintf  format c str    args         1        s resize   snwprintf s  s data    s capacity     TRUNCATE  format c str    args              return s     std  string s   Format    hs  d    abc   123    std  wstring ws   Format  L  hs  d    abc   123

User · Answer

All the answers so far here seems to have one or more of these problems   1  it may not work on VC    2  it requires additional dependencies like boost or fmt  3  its too complicated custom implementation and probably not tested well   Below code addresses all of above issues    include  lt string gt   include  lt cstdarg gt   include  lt memory gt   std  string stringf const char  format             va list args      va start args  format        ifndef  MSC VER            GCC generates warning for valid use of snprintf to get           size of result string  We suppress warning with below macro           ifdef   GNUC            pragma GCC diagnostic push          pragma GCC diagnostic ignored  -Wformat-nonliteral           endif          size t size   std  snprintf nullptr  0  format  args    1     Extra space for   0            ifdef   GNUC             pragma GCC diagnostic pop          endif          std  unique ptr lt char   gt  buf new char  size               std  vsnprintf buf get    size  format  args           return std  string buf get    buf get     size - 1       We don t want the   0  inside      else         int size    vscprintf format  args           std  string result   size  0           vsnprintf s  char  result data    size   TRUNCATE  format  args           return result       endif     va end args          int main         float f   3 f      int i   5      std  string s    hello        auto rs   stringf  i  d  f  f  s  s   i  f  s c str         printf   s   rs c str         return 0      Notes    Separate VC   code branch is necessary because VC   has decided to deprecate snprintf which will generate compiler warnings for other highly voted answers above  As I always run in  warnings as errors  mode  its no go for me  The function accepts char   instead of std  string  This because most of the time this function would be called with literal string which is indeed char    not std  string  In case you do have std  string as format parameter  then just call  c str    Name of the function is stringf instead of things like string format to keepup with printf  scanf etc  It doesn t address safety issue  i e  bad parameters can potentially cause seg fault instead of exception   If you need this then you are better off with boost or fmt libraries  My preference here would be fmt because it is just one header and source file to drop in the project while having less weird formatting syntax than boost  However both are non-compatible with printf format strings so below is still useful in that case   The stringf code passes through GCC strict mode compilation  This requires extra  pragma macros to suppress false positives in GCC warnings    Above code was tested on    GCC 4 9 2 C  11 C  14 VC   compiler ver 19 0 Clang 3 7 0

User · Answer

Tested  Production Quality Answer  This answer handles the general case with standards compliant techniques   The same approach is given as an example on CppReference com near the bottom of their page  Unlike their example  this code fits the question s requirements and is field tested in robotics and satellite applications  It also has improved commenting  Design quality is discussed further below    include  lt string gt   include  lt cstdarg gt   include  lt vector gt      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 lt char gt  zc iLen   1       std  vsnprintf zc data    zc size    zcFormat  vaArgs       va end vaArgs       return std  string zc data    iLen       include  lt ctime gt   include  lt iostream gt   include  lt iomanip gt      demonstration of use int main          std  time t t   std  time nullptr       std  cerr          lt  lt  std  put time std  localtime  amp  t     D  T            lt  lt     debug              lt  lt  vformat  Int 1 is  d  Int 2 is  d  Int 3 is  d   11  22  33           lt  lt  std  endl      return 0      Predictable Linear Efficiency  Two passes are necessities for a secure  reliable  and predictable reusable function per the question specifications  Presumptions about the distribution of sizes of vargs in a reusable function is bad programming style and should be avoided  In this case  arbitrarily large variable length representations of vargs is a key factor in choice of algorithm   Retrying upon overflow is exponentially inefficient  which is another reason discussed when the C  11 standards committee discussed the above proposal to provide a dry run when the write buffer is null   In the above production ready implementation  the first run is such a dry run to determine allocation size  No allocation occurs  Parsing of printf directives and the reading of vargs has been made extremely efficient over decades  Reusable code should be predictable  even if a small inefficiency for trivial cases must be sacrificed   Security and Reliability  Andrew Koenig said to a small group of us after his lecture at a Cambridge event   User functions shouldn t rely on the exploitation of a failure for unexceptional functionality   As usual  his wisdom has been shown true in the record since  Fixed and closed security bug issues often indicate retry hacks in the description of the hole exploited prior to the fix   This is mentioned in the formal standards revision proposal for the null buffer feature in Alternative to sprintf  C9X Revision Proposal  ISO IEC Document WG14 N645 X3J11 96-008  An arbitrarily long string inserted per print directive    s   within the constraints of dynamic memory availability  is not an exception  and should not be exploited to produce   Unexceptional functionality    Consider the proposal along side the example code given at the bottom of the C  Reference org page linked to in the first paragraph of this answer   Also  the testing of failure cases is rarely as robust of success cases   Portability  All major O S  vendors provide compilers that fully support std  vsnprintf as part of the c  11 standards  Hosts running products of vendors that no longer maintain distributions should be furnished with g   or clang   for many reasons   Stack Use  Stack use in the 1st call to std  vsnprintf will be less than or equal to that of the 2nd  and and it will be freed before the 2nd call begins  If the first call exceeds stack availability  then std  fprintf would fail too

User · Answer

You can t do it directly  because you don t have write access to the underlying buffer  until C  11  see Dietrich Epp s comment   You ll have to do it first in a c-string  then copy it into a std  string     char buff 100     snprintf buff  sizeof buff     s    Hello      std  string buffAsStdStr   buff    But I m not sure why you wouldn t just use a string stream  I m assuming you have specific reasons to not just do this     std  ostringstream stringStream    stringStream  lt  lt   Hello     std  string copyOfStr   stringStream str

User · Answer

Update of some answer around  difference is - function will properly accept std  string for  s  namespace format helper        template  lt class Src gt      inline Src cast Src v                return v             inline const char  cast const std  string amp  v                return v c str              template  lt typename    Ts gt  inline std  string stringfmt  const std  string  amp fmt  Ts amp  amp     vs        using namespace format helper      char b      size t required   std  snprintf  amp b  0  fmt c str    cast std  forward lt Ts gt  vs         not counting the terminating null character      std  string result        because we use string as container  it adds extra 0 automatically     result resize required   0         and snprintf will use n-1 bytes supplied     std  snprintf const cast lt char  gt  result data     required   1  fmt c str    cast std  forward lt Ts gt  vs             return result      Live  http   cpp sh 5ajsv

User · Answer

Based on the answer provided by Erik Aronesty   std  string string format const std  string  amp fmt             std  vector lt char gt  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  gt  -1   amp  amp   size t n   lt  str size                   return str data                      if  n  gt  -1              str resize  n   1            else             str resize  str size     2             return str data        This avoids the need to cast away const from the result of  c str   which was in the original answer

User · Answer

Modern C   makes this super simple  C  20 C  20 introduces std  format  which allows you to do exactly that  It uses replacement fields similar to those in python   include  lt iostream gt   include  lt format gt    int main         std  cout  lt  lt  std  format  quot Hello     n quot    quot world quot       Code from cppreference com  CC  BY-SA and GFDL Check out the compiler support page to see if it s available in your standard library implementation  As of 2020-11-06  it s not supported by any  so you ll have to resort to the C  11 solution below   C  11 With C  11s std  snprintf  this already became a pretty easy and safe task   include  lt memory gt   include  lt string gt   include  lt stdexcept gt   template lt typename     Args gt  std  string string format  const std  string amp  format  Args     args         int size   snprintf  nullptr  0  format c str    args         1     Extra space for   0      if  size  lt   0    throw std  runtime error   quot Error during formatting  quot           std  unique ptr lt char   gt  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    The code snippet above is licensed under CC0 1 0  Line by line explanation  Aim  Write to a char  by using  std  snprintf and then convert that to a std  string  First  we determine the desired length of the char array using a special condition in snprintf  From cppreference com   Return value       If the resulting string gets truncated due to buf size limit  function returns the total number of characters  not including the terminating null-byte  which would have been written  if the limit was not imposed   This means that the desired size is the number of characters plus one  so that the null-terminator will sit after all other characters and that it can be cut off by the string constructor again  This issue was explained by  alexk7 in the comments  int size   snprintf  nullptr  0  format c str    args         1   snprintf will return a negative number if an error occurred  so we then check whether the formatting worked as desired  Not doing this could lead to silent errors or the allocation of a huge buffer  as pointed out by  ead in the comments  if  size  lt   0    throw std  runtime error   quot Error during formatting  quot        Next  we allocate a new character array and assign it to a std  unique ptr  This is generally advised  as you won t have to manually delete it again  Note that this is not a safe way to allocate a unique ptr with user-defined types as you can not deallocate the memory if the constructor throws an exception  std  unique ptr lt char   gt  buf  new char  size       After that  we can of course just use snprintf for its intended use and write the formatted string to the char    snprintf  buf get    size  format c str    args         Finally  we create and return a new std  string from that  making sure to omit the null-terminator at the end  return std  string  buf get    buf get     size - 1      You can see an example in action here   If you also want to use std  string in the argument list  take a look at this gist   Additional information for Visual Studio users  As explained in this answer  Microsoft renamed std  snprintf to  snprintf  yes  without std     MS further set it as deprecated and advises to use  snprintf s instead  however  snprintf s won t accept the buffer to be zero or smaller than the formatted output and will not calculate the outputs length if that occurs  So in order to get rid of the deprecation warnings during compilation  you can insert the following line at the top of the file which contains the use of  snprintf   pragma warning disable   4996    Final thoughts A lot of answers to this question were written before the time of C  11 and use fixed buffer lengths or vargs  Unless you re stuck with old versions of C    I wouldn t recommend using those solutions  Ideally  go the C  20 way  Because the C  11 solution in this answer uses templates  it can generate quite a bit of code if it is used a lot  However  unless you re developing for an environment with very limited space for binaries  this won t be a problem and is still a vast improvement over the other solutions in both clarity and security  If space efficiency is super important  these two solution with vargs and vsnprintf can be useful  DO NOT USE any solutions with fixed buffer lengths  that is just asking for trouble

User · Answer

I realize this has been answered many times  but this is more concise   std  string format const std  string fmt str             va list ap      char  fp   NULL      va start ap  fmt str       vasprintf  amp fp  fmt str c str    ap       va end ap       std  unique ptr lt char   gt  formatted fp       return std  string formatted get         example    include  lt iostream gt   include  lt random gt   int main         std  random device r      std  cout  lt  lt  format  Hello  d  n   r         See also http   rextester com NJB14150

User · Answer

My two cents on this very popular question   To quote the manpage of printf-like functions      Upon successful return  these functions return the number of characters printed  excluding the null byte used to end output to strings        The  functions  snprintf    and vsnprintf   do not write more than size bytes  including the terminating null byte    0      If the output  was truncated  due  to  this  limit  then the return value is the number of characters  excluding the terminating null byte  which would have  been written  to the final string if enough space had been available   Thus  a return value of size or more means that  the  output  was  truncated    In other words  a sane C  11 implementation should be the following    include  lt string gt   include  lt cstdio gt   template  lt typename    Ts gt  std  string fmt  const std  string  amp fmt  Ts    vs        char b      size t required   std  snprintf  amp 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       It works quite well     Variadic templates are supported only in C  11  The answer from pixelpoint show a similar technique using older programming styles   It s weird that C   does not have such a thing out of the box  They recently added to string    which in my opinion is a great step forward  I m wondering if they will add a  format operator to the std  string eventually     Edit  As alexk7 pointed out  A  1 is needed on the return value of std  snprintf  since we need to have space for the  0 byte  Intuitively  on most architectures missing the  1 will cause the required integer to be partially overwritten with a 0  This will happen after the evaluation of required as actual parameter for std  snprintf  so the effect should not be visible   This problem could however change  for instance with compiler optimization  what if the compiler decides to use a register for the required variable  This is the kind of errors which sometimes result in security issues

User · Answer

Below slightly modified version of  iFreilicht answer  updated to C  14  usage of make unique function instead of raw declaration  and added support for std  string arguments  based on Kenny Kerr article    include  lt iostream gt   include  lt memory gt   include  lt string gt   include  lt cstdio gt   template  lt typename T gt  T process arg T value  noexcept       return value     template  lt typename T gt  T const   process arg std  basic string lt T gt  const  amp  value  noexcept       return value c str       template lt typename     Args gt  std  string string format const std  string amp  format  Args const  amp      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 lt char   gt  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  lt  lt  string format  i  d  f  f  s  s  s   i  f  s0  s1   lt  lt    n       Output   i   3  f   5 000000  s   hello world   Feel free to merge this answer with the original one if desired

User · Answer

Very-very simple solution   std  string strBuf  strBuf resize 256   int iCharsPrinted   sprintf s  char   strPath c str    strPath size          strBuf resize iCharsPrinted

User · Answer

Took the idea from Dacav and pixelpoint s answer   I played around a bit and got this    include  lt cstdarg gt   include  lt cstdio gt   include  lt string gt   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       With sane programming practice I believe the code should be enough  however I m still open to more secure alternatives that are still simple enough and would not require C  11     And here s another version that makes use of an initial buffer to prevent second call to vsnprintf   when initial buffer is already enough   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  lt  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        It turns out that this version is just similar to Piti Ongmongkolkul s answer  only that it doesn t use new and delete    and also specifies a size when creating std  string     The idea here of not using new and delete   is to imply usage of the stack over the heap since it doesn t need to call allocation and deallocation functions  however if not properly used  it could be dangerous to buffer overflows in some  perhaps old  or perhaps just vulnerable  systems   If this is a concern  I highly suggest using new and delete   instead   Note that the only concern here is about the allocations as vsnprintf   is already called with limits  so specifying a limit based on the size allocated on the second buffer would also prevent those

User · Answer

If you only want a printf-like syntax  without calling printf yourself   have a look at Boost Format

User · Answer

string doesn t have what you need  but std  stringstream does  Use a stringstream to create the string and then extract the string  Here is a comprehensive list on the things you can do  For example   cout setprecision 10     stringstream is a stream like cout   will give you 10 decimal places of precision when printing a double or float

[c++] std::string formatting like sprintf

Examples related to c++

Examples related to string

Examples related to formatting

Examples related to stdstring

Examples related to c++-standard-library