6

For convenient usage I want to write formatting function similar to sprintf just returning std::string, like this:

std::string format_string(const char* format, ...)

I can use vsnprintf there but have problem - I don't know in advance how long temp buffer should be. On Microsoft have function _vscprintf that can do it but I think it not portable?

One option is have temp buffer start some known size then increase it if see it's not enough with vsnprintf. Are there better approach? Thanks

P.S. Please give answer without Boost. I know about Boost, but I'm curious how implement it without.

Improve this question
3
  • For convenient usage, consider using something like Boost.Format. Variadic functions are not type safe and can't be used with non-POD types. Boost.Format is pretty easy to use, is type safe, and can safely be used with any type. Commented Nov 15, 2010 at 6:56
  • @James, thanks but I'm looking for answer without boost Commented Nov 15, 2010 at 7:10
  • Have you looked at the source of Boost.Format? It may give you some hints (but may also take some time to understand). Commented Nov 15, 2010 at 7:43

4 Answers 4

Reset to default
5

One option is have temp buffer start some known size then increase it if see it's not enough with vsnprintf. Are there better approach? Thanks

You can use vasprintf(), but that does an unnecessary heap allocation - it's unlikely to be faster on average. Using alloca you can avoid the heap. Or, you can write directly into the string that's returned: NRVO should avoid a copy, and as of C++11 move semantics would limit the cost sans-NRVO to a few pointer swaps.

#include <cstdio>
#include <cstdarg>
#include <alloca.h>

#include <string>
#include <iostream>

std::string stringf(const char* format, ...)
{
    va_list arg_list;                                                           
    va_start(arg_list, format);                                                 

    // SUSv2 version doesn't work for buf NULL/size 0, so try printing
    // into a small buffer that avoids the double-rendering and alloca path too...
    char short_buf[256];                                                        
    const size_t needed = vsnprintf(short_buf, sizeof short_buf,
                                    format, arg_list) + 1;
    if (needed <= sizeof short_buf)
        return short_buf;

    // need more space...

    // OPTION 1
    std::string result(needed, ' ');
    vsnprintf(result.data(), needed, format, arg_list);
    return result;  // RVO ensures this is cheap
 OR
    // OPTION 2
    char* p = static_cast<char*>(alloca(needed)); // on stack
    vsnprintf(p, needed, format, arg_list);
    return p;  // text copied into returned string
}

int main()                                                                      
{                                                                               
    std::string s = stringf("test '%s', n %8.2f\n", "hello world", 3.14);       
    std::cout << s;                                                             
}

An simpler and initially faster option would be:

    std::string result(255, ' ');  // 255 spaces + NUL
    const size_t needed = vsnprintf(result.data(), result.size() + 1,
                                    format, arg_list);
    result.resize(needed); // may truncate, leave or extend...
    if (needed > 255) // needed doesn't count NUL
        vsnprintf(result.data(), needed + 1, format, arg_list);
    return result;

The potential problem is that you're allocating at least 256 characters however short the actual text stored: that could add up and cost you in memory/cache related performance. You might be able to work around the issue using [shrink_to_fit]http://en.cppreference.com/w/cpp/string/basic_string/shrink_to_fit), but the Standard doesn't require it to actually do anything (the requirements are "non binding"). If you end up having to copy to a new exactly-sized string, you might as well have used the local char array.

Improve this answer
Sign up to request clarification or add additional context in comments.

5 Comments

i guess can also instead of alloca use new? alloca is portable to windows?
@zaharpopov: yes, you can use new if you want - it's more portable and on some systems more secure if handling arbitrary volumes of user-supplied input (see man alloca BUGS on Linux), though it's also slower (and you need to do the delete yourself). But if you're considering new/delete, you might as well use vasprintf() as it combines memory allocation with printing, and just might have some useful optimisation (e.g. realloc on exhaustion) - you need to use free() to deallocate that memory though. alloca is available in windows... a quick check in VS2005 picked it up via #include <cstdlib>.
The vsnprintf() documentation says that a value of -1 is returned if a formatting error occurred. There really should be a check to make sure that this is not the case.
@TonyD I noticed you returned the char* p as is, I think this can cause memory leak?
@Nap: I can see how it might look like that, but the return p statement has to be reconciled (by the compiler) with the return type of std::string, so it calls the std::string::string(const char*) constructor which makes a copy of the provided ASCIIZ string, after which the function's free to reclaim the memory from alloca as it returns.
3

C99 introduced snprintf and possibly vsnprintf as well. There are several portable open source implementations of (v)snprintf such as this one. The latter also implements vasprintf which dynamically allocates storage.

Also consider the C++ Format library which provides a safe printf implementation similar to Boost Format, but much faster.

Improve this answer

4 Comments

I mentioned vsnprintf in my answer - problem is I don't know how big to make temporary buffer
+1, but only for boost::format, snprintf has nothing to to with stl types like std::string
@zaharpopov: Your approach of starting with some predefined size and then increasing if it doesn't fit is OK when using vsnprintf.
@vitaut: thanks, this is kind of answer I look for - Boost I know, but curious how to manage without
0

If you don't care using non-standard functions (ie: using a different function for any platform, like I got you're doing from your question), and want a fast job, you will find asprintf and vasprintf amongst GNU extension (that's it: nor C nor POSIX, but supported by GCC and glibc).

They works like printf and vsprintf, but take care of allocating buffer memory easing your work.

int asprintf( char **strp, const char *fmt, ... );
int vasprintf( char **strp, const char *fmt, va_list ap );

You'll probably found similar functions on any system. For the others you could just write some code to allocate some buffer and pass it to snprintf.

Improve this answer

1 Comment

tx, but I looking for portable solution
0

The robust way to do this is by writing the entire function yourself. That is to say, don't forward to other printf-like function, but parse and print all arguments yourself. Scan the whole format string, and check the arguments to determine the necessary buffer size. Subsequently, print to that buffer

This is not an all-or-nothing suggestion; you can still use sprintf for selected types. E.g. it may be easier to use sprintf(buf, "%6.4f", dbltemp); when your input format string contains a %6.4f argument, but %s is better handled yourself (simple memcpy).

Improve this answer

Comments

Your Answer

By clicking “Post Your Answer”, you agree to our terms of service and acknowledge you have read our privacy policy.

Start asking to get answers

Find the answer to your question by asking.

Ask question

Explore related questions

See similar questions with these tags.