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

这是可以尝试的。简单。虽然没有使用字符串类的细微差别。

#include <stdarg.h>
#include <stdio.h>
#include <stdlib.h>
#include <assert.h>

#include <string>
#include <exception>
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(&ptr, &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;
}

我喜欢的一个解决方案是，在使缓冲区足够大之后，用sprintf直接在std::string缓冲区中执行此操作:

#include <string>
#include <iostream>

using namespace std;

string l_output;
l_output.resize(100);

for (int i = 0; i < 1000; ++i)
{       
    memset (&l_output[0], 0, 100);
    sprintf (&l_output[0], "\r%i\0", i);

    cout << l_output;
    cout.flush();
}

因此，创建std::string，调整它的大小，直接访问它的缓冲区…

String没有你需要的东西，但是std::stringstream有。使用stringstream创建字符串，然后提取字符串。这里有一个关于你可以做的事情的全面列表。例如:

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

将在打印双精度或浮点数时提供10位小数点后的精度。

我试了一下，用正则表达式。我为int和const字符串实现了它作为一个例子，但你可以添加任何其他类型(POD类型，但有指针，你可以打印任何东西)。

#include <assert.h>
#include <cstdarg>

#include <string>
#include <sstream>
#include <regex>

static std::string
formatArg(std::string argDescr, va_list args) {
    std::stringstream ss;
    if (argDescr == "i") {
        int val = va_arg(args, int);
        ss << val;
        return ss.str();
    }
    if (argDescr == "s") {
        const char *val = va_arg(args, const char*);
        ss << 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;
}

下面是一个使用它的例子:

std::string formatted = format("I am {s} and I have {i} cats", "bob", 3);
std::cout << formatted << std::endl;

输出:

我是鲍勃，我有三只猫

现代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的解决方案可能会很有用。 不要使用任何具有固定缓冲长度的解决方案，那只是在自找麻烦。