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会使其变慢。

_return.desc = (boost::format("fail to detect. cv_result = %d") % st_result).str();

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

c++ 17解决方案(这将工作于std::string和std::wstring):

分配一个缓冲区，格式化它，然后复制到另一个字符串是不高效的。可以创建格式化字符串大小的std::string，并直接格式化到字符串缓冲区中:

#include <string>
#include <stdexcept>
#include <cwchar>
#include <cstdio>
#include <type_traits>

template<typename T, typename ... Args>
std::basic_string<T> string_format(T const* const format, Args ... args)
{
    int size_signed{ 0 };

    // 1) Determine size with error handling:    
    if constexpr (std::is_same_v<T, char>) { // C++17
        size_signed = std::snprintf(nullptr, 0, format, args ...);
    }
    else {
        size_signed = std::swprintf(nullptr, 0, format, args ...);
    }  
    if (size_signed <= 0) {
        throw std::runtime_error("error during formatting.");
    }
    const auto size = static_cast<size_t>(size_signed);

    // 2) Prepare formatted string:
    std::basic_string<T> formatted(size, T{});
    if constexpr (std::is_same_v<T, char>) { // C++17
        std::snprintf(formatted.data(), size + 1, format, args ...); // +1 for the '\0' (it will not be part of formatted).
    }
    else {
        std::swprintf(formatted.data(), size + 1, format, args ...); // +1 for the '\0' (it will not be part of formatted).
    }

    return formatted; // Named Return Value Optimization (NRVO), avoids an unnecessary copy. 
}

此外:通常，format参数是char[] / wchar_t[] &创建std::string对象效率不高。传递char*或wchar_t* &如果你已经有一个std::string对象，你仍然可以使用它作为your_string.c_str()。例子:

int main()
{
    int i{ 0 };

    // The format parameter is a char[] / wchar_t[]:

    const std::string title1 = string_format("story[%d].", ++i); // => "story[1]"

    const std::wstring title2 = string_format(L"story[%d].", ++i); // => L"story[2]"

    // If you already have a std::string object:

    const std::string format1{ "story[%d]." };
    const std::string title3 = string_format(format1.c_str(), ++i); // => "story[3]"

    const std::wstring format2{ L"story[%d]." };
    const std::wstring title4 = string_format(format2.c_str(), ++i); // => L"story[4]"  
}

下面是@iFreilicht答案的稍微修改版本，更新到c++ 14(使用make_unique函数而不是原始声明)，并增加了对std::string参数的支持(基于Kenny Kerr的文章)

#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

如果需要，可以随意将这个答案与原始答案合并。

现代c++使得这非常简单。

C + + 20

c++ 20引入了std::format，它允许你这样做。它使用的替换字段类似于python中的替换字段:

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

代码来自cppreference.com, CC BY-SA和GFDL

查看编译器支持页面，看看它是否在您的标准库实现中可用。截至2021年11月28日，Visual Studio 2019 16.10(于2021年05月25日发布)和Clang 14(可在此处跟踪)提供了部分支持。在所有其他情况下，您可以求助于下面的c++ 11解决方案，或使用{fmt}库，它具有与std::format相同的语义。

---

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 )
{
    int size_s = std::snprintf( nullptr, 0, format.c_str(), args ... ) + 1; // Extra space for '\0'
    if( size_s <= 0 ){ throw std::runtime_error( "Error during formatting." ); }
    auto size = static_cast<size_t>( size_s );
    std::unique_ptr<char[]> buf( new char[ size ] );
    std::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许可的。

逐行解释:

目的:写入一个char*使用std::snprintf，然后将其转换为std::string。

首先，使用snprintf中的一个特殊条件确定所需的char数组长度。从cppreference.com:

返回值 […如果结果字符串由于buf_size限制而被截断， 函数返回字符总数(不包括 终止空字节)，如果限制为 没有实施。

这意味着所需的大小是字符数加1，因此空结束符将位于所有其他字符之后，并且可以再次被字符串构造函数截断。@alexk7在评论中解释了这个问题。

int size_s = std::snprintf( nullptr, 0, format.c_str(), args ... ) + 1;

如果发生错误，Snprintf将返回负数，因此我们随后检查格式是否按预期工作。不这样做可能会导致无声错误或分配一个巨大的缓冲区，正如@ead在评论中指出的那样。

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

因为我们知道size_s不能为负，所以我们使用静态强制转换将size_t从有符号整型转换为无符号size_t。这样，即使是最迂腐的编译器也不会抱怨下一行可能发生的转换。

size_t size = static_cast<size_t>( size_s );

接下来，我们分配一个新的字符数组，并将其分配给std::unique_ptr。通常建议这样做，因为您不必再次手动删除它。

注意，这不是一种使用用户定义类型分配unique_ptr的安全方法，因为如果构造函数抛出异常，您就不能释放内存!

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

在c++ 14中，您可以使用make_unique，这对于用户定义的类型是安全的。

auto buf = std::make_unique<char[]>( size );

在此之后，我们当然可以将snprintf用于其预期用途，并将格式化的字符串写入char[]。

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

最后，我们创建并返回一个新的std::string，确保省略结尾的空结束符。

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

---

您可以在这里看到一个实际的例子。

---

如果你也想在参数列表中使用std::string，看看这个要点。

---

针对Visual Studio用户的其他信息:

正如回答中所解释的，微软将std::snprintf重命名为_snprintf(是的，没有std::)。MS进一步将其设置为弃用，并建议使用_snprintf_s代替，但是_snprintf_s不会接受缓冲区为零或小于格式化输出，如果发生这种情况，将不会计算输出长度。 因此，为了消除编译过程中的弃用警告，您可以在文件顶部插入以下一行，其中包含了_snprintf的使用:

#pragma warning(disable : 4996)

---

最终的想法

这个问题的很多答案都是在c++ 11之前编写的，并且使用固定的缓冲区长度或vargs。除非你一直使用旧版本的c++，否则我不建议你使用这些解决方案。理想情况下，走c++ 20的路。

因为这个答案中的c++ 11解决方案使用模板，如果它被大量使用，它可以生成相当多的代码。但是，除非您正在为一个二进制文件空间非常有限的环境进行开发，否则这不会成为问题，并且在清晰度和安全性方面仍然比其他解决方案有很大的改进。

如果空间效率非常重要，这两个带有vargs和vsnprintf的解决方案可能会很有用。 不要使用任何具有固定缓冲长度的解决方案，那只是在自找麻烦。