C ++ equivalente de sprintf?

Sé que std::coutes el equivalente en C ++ de printf.

¿Cuál es el equivalente de C ++ sprintf?

std::ostringstream

Ejemplo:

#include <iostream>
#include <sstream> // for ostringstream
#include <string>

int main()
{
  std::string name = "nemo";
  int age = 1000;
  std::ostringstream out;  
  out << "name: " << name << ", age: " << age;
  std::cout << out.str() << '\n';
  return 0;
}

Salida:

name: nemo, age: 1000

Actualización, agosto de 2019:

Parece que C ++ 20 tendrá std::format. La implementación de referencia es {fmt} . Si está buscando una printf()alternativa ahora, este se convertirá en el nuevo enfoque "estándar" y vale la pena considerarlo.

Original:

Utilice Boost.Format . Tiene una printfsintaxis similar, seguridad de tipos, std::stringresultados y muchas otras cosas ingeniosas. No volverás.

sprintf funciona bien en C ++.

Puede utilizar el archivo de encabezado iomanip para formatear el flujo de salida. ¡Mira esto !

Aquí hay una buena función para un sprintf en c ++. Las transmisiones pueden ponerse feas si las usa demasiado.

std::string string_format(const std::string &fmt, ...) {
    int size=100;
    std::string str;
    va_list ap;

    while (1) {
        str.resize(size);
        va_start(ap, fmt);
        int n = vsnprintf(&str[0], size, fmt.c_str(), ap);
        va_end(ap);
   
        if (n > -1 && n < size) {
            str.resize(n); // Make sure there are no trailing zero char
            return str;
        }
        if (n > -1)
            size = n + 1;
        else
            size *= 2;
    }
}

En C ++ 11 y posteriores, se garantiza que std :: string usará un almacenamiento contiguo que termine en '\0', por lo que es legal convertirlo en char *using &str[0].

Se ha señalado que no se supone que los argumentos variados sigan el paso por referencia, y c ++ es bueno para no copiar cadenas si no es necesario. En ese caso, esto lo arregla.

std::string string_format(std::string fmt, ...) {

Utilice un hilo de cadena para lograr el mismo efecto. Además, puede incluir <cstdio>y seguir utilizando snprintf.

Dependiendo de lo que planeas exactamente sprintf(), std::to_string()puede ser útil y más idiomático que otras opciones:

void say(const std::string& message) {
 // ...
}

int main() {
  say(std::to_string(5));
  say("Which is to say " + std::to_string(5) + " words");
}

La principal ventaja de std::to_string(), en mi humilde opinión, es que se puede extender fácilmente para admitir tipos adicionales que sprintf()ni siquiera pueden soñar con encadenar, algo así como el Object.toString()método de Java .