我通常使用cout和cerr向控制台输出文本。然而，有时我发现使用老式的printf语句更容易。当我需要格式化输出时，我就会使用它。
以下是我使用这种方法的一个例子：
// Lets assume that I'm printing coordinates...
printf("(%d,%d)\n", x, y);
// To do the same thing as above using cout....
cout << "(" << x << "," << y << ")" << endl;
我知道可以使用cout格式化输出，但我已经知道如何使用printf。有什么理由不能使用printf语句吗？
我的学生们先学习cin和cout，然后再学习printf，但是他们大多数都更喜欢使用printf（通常是fprintf）。我本人觉得printf模型足够易读，所以我把它移植到其他编程语言中。Olivier Danvy也这么做了，他甚至让它变成了类型安全的。
只要你有一个能够检查printf调用类型的编译器，我认为在C++中使用fprintf等函数是没有问题的。
免责声明：我是个糟糕的C++程序员。
String.format。在C++中，我经常使用Boost.Format，它既友好于iostreams，又有点类似于printf。 - C. K. Youngprintf()的“类型安全问题”。那么，printf()的类型安全问题具体是什么？ - Lazerprintf()，从未遇到过问题。 - Lazer如果你希望国际化你的程序，请远离iostreams。问题在于，如果句子由多个片段组成，就像iostream所做的那样，正确本地化字符串可能是不可能的。
除了消息片段的问题，你还面临着排序问题。考虑一个打印学生姓名和平均绩点的报告：
std::cout << name << " has a GPA of " << gpa << std::endl;
如果你需要将文本翻译成其他语言，那么该语言的语法可能要求你在名字之前显示GPA。 据我所知，iostreams无法重新排列插入值。
如果你想兼顾类型安全性和国际化能力，请使用Boost.Format。
boost::format可以提供类型安全等好处。printf则会出现问题。 - jalf任何尝试对非平凡数据类型进行 printf 的操作都会导致未定义的行为：
struct Foo {
virtual ~Foo() {}
operator float() const { return 0.f; }
};
printf ("%f", Foo());
std::string foo;
printf ("%s", foo);
std::cout << Foo();
std::string foo;
std::cout << foo;
请自行判断。
struct Person {
string first_name;
string second_name;
};
std::ostream& operator<< (std::ostream &os, Person const& p) {
return os << p.first_name << ", " << p.second_name;
}
cout << p;
cout << p;
some_file << p;
C:
// inline everywhere
printf ("%s, %s", p.first_name, p.second_name);
printf ("%s, %s", p.first_name, p.second_name);
fprintf (some_file, "%s, %s", p.first_name, p.second_name);
或者：
// re-usable (not common in my experience)
int person_fprint(FILE *f, const Person *p) {
return fprintf(f, "%s, %s", p->first_name, p->second_name);
}
int person_print(const Person *p) {
return person_fprint(stdout, p);
}
Person p;
....
person_print(&p);
person_fprint(stderr, ...，person_fprint(myfile, ...），而在C ++中，“FILE”参数会自动从表达式“派生”出来。更精确等效于此推导的示例实际上更像是这样的：FILE *fout = stdout;
...
fprintf(fout, "Hello World!\n");
person_fprint(fout, ...);
fprintf(fout, "\n");
我们重用了我们的Person定义：
cout << boost::format("Hello %1%") % p;
cout << boost::format("Na %1%, sei gegrüßt!") % p;
printf ("Hello %1$s, %2$s", p.first_name.c_str(), p.second_name.c_str());
printf ("Na %1$s, %2$s, sei gegrüßt!",
p.first_name.c_str(), p.second_name.c_str());
请自行判断。
我认为这个问题在今天（2017年）已经不那么重要了。也许只是一种直觉，但是I18N并不是普通的C或C++程序员每天都会做的事情。此外，它仍然是一件麻烦的事情。
如果您始终使用iostreams，则可以
std::ios::sync_with_stdio(false);
使用好的编译器，可以获得相等的运行时间：
#include <cstdio>
#include <iostream>
#include <ctime>
#include <fstream>
void ios_test (int n) {
for (int i=0; i<n; ++i) {
std::cout << "foobarfrob" << i;
}
}
void c_test (int n) {
for (int i=0; i<n; ++i) {
printf ("foobarfrob%d", i);
}
}
int main () {
const clock_t a_start = clock();
ios_test (10024*1024);
const double a = (clock() - a_start) / double(CLOCKS_PER_SEC);
const clock_t p_start = clock();
c_test (10024*1024);
const double p = (clock() - p_start) / double(CLOCKS_PER_SEC);
std::ios::sync_with_stdio(false);
const clock_t b_start = clock();
ios_test (10024*1024);
const double b = (clock() - b_start) / double(CLOCKS_PER_SEC);
std::ofstream res ("RESULTS");
res << "C ..............: " << p << " sec\n"
<< "C++, sync with C: " << a << " sec\n"
<< "C++, non-sync ..: " << b << " sec\n";
}
结果 (g++ -O3 synced-unsynced-printf.cc, ./a.out > /dev/null, cat RESULTS):
C ..............: 1.1 sec
C++, sync with C: 1.76 sec
C++, non-sync ..: 1.01 sec
请自行判断...
在C++11中，由于可变参数模板，您可以拥有一个类型安全、I18N友好的printf。并且通过使用用户定义的字面量，您将能够使它们非常高效，即可以编写完全静态的实现。
我有一个概念证明。当时对C++11的支持还不如现在成熟，但您可以得到一个想法。
// foo.h
...
struct Frob {
unsigned int x;
};
...
// alpha.cpp
... printf ("%u", frob.x); ...
// bravo.cpp
... printf ("%u", frob.x); ...
// charlie.cpp
... printf ("%u", frob.x); ...
// delta.cpp
... printf ("%u", frob.x); ...
// foo.h
...
unsigned long long x;
...
这是一个有趣的练习，要保持它没有漏洞。特别是当其他非耦合项目使用foo.h时。
漏洞潜在性：使用printf时有很多出错空间，特别是当您将用户输入的字符串混合在一起时（考虑I18N团队）。您必须小心地正确转义每个格式字符串，确保传递正确的参数等。
IO-Streams会使我的二进制文件变大：如果这比可维护性、代码质量、可重用性更重要，那么（在验证问题后！）请使用printf。
我使用printf，因为我讨厌丑陋的<<cout<<语法。
使用boost::format。你将获得类型安全性，std::string支持，类似printf的接口，能够使用cout以及许多其他好东西。你不会再回去了。
没有任何理由。我认为只是一些奇怪的意识形态驱使人们仅使用C++库，尽管好用的老式C库仍然有效。我是一个C ++ 程序员，并且经常使用C函数，从来没有遇到过任何问题。
printf更好的是节省字节）。而且虽然你可能知道如何正确使用它，但许多人不知道（我记得像光栅化器中出现闪烁的三角形之类的不感激的调试会话，偶然发现一个误用的printf是问题所在，在完全远离的地方，甚至不在同一个应用程序代码中）。 - Sebastian Machprintf 而不是 cout（虽然其他人可能会 - 在这个问题的另一个答案中有链接），我同意有些情况下 cout 明显更适合。然而，我坚信仅仅因为“这是 C++ 的方式”而使用 cout 而不是 printf 不过是一种宗教迷信罢了。 - mingos总的来说，我同意（尤其是如果你需要复杂格式，讨厌 << 语法）
但我应该指出安全方面的问题。
printf("%x",2.0f)
printf("%x %x",2)
printf("%x",2,2)
这可能不会被编译器注意到，但可能会导致你的应用崩溃。
fmt::print("The answer is {}.", 42);
这个库支持类Python和printf格式字符串语法。
声明：我是这个库的作者。
流是官方推荐的方法。尝试使用 printf 使这段代码工作：
template <typename T>
void output(const T& pX)
{
std::cout << pX << std::endl;
}
祝你好运。
我的意思是，你可以创建操作符使你的类型能够输出到 ostream 中，而且使用起来就像任何其他类型一样轻松。 printf 不适用于 C++ 的通用性，或者更具体地说是模板。
还有更多的可用性。还有一致性。在我所有的项目中，我都将 cout（和 cerr 和 clog）连接到一个文件中进行输出。如果你使用 printf，你就会跳过所有这些。另外，一致性本身就是一件好事；混合使用 cout 和 printf，虽然完全有效，但很丑陋。
如果你有一个对象，并且想让它能够输出，最干净的方法是为该类重载 operator<<。那么你要如何使用 printf 呢？你最终会得到一堆混合了 cout 和 printf 的代码。
如果你真的想要格式化，可以使用 Boost.Format 来保持流接口。一致性和格式化。
printf不能做到这一点，因为它不是设计成这样的。这就像说：“哦，我打赌你不能在C语言中创建一个类”。这个观点也是正确的，因为该语言并没有设计用于此。 - Bob Dylanprintf。为了保持一致性，不要使用。流永远都能用，但 printf 并非总是能用。不一致的代码很丑陋。如果我将 cout 与一个日志文件同时输出会怎样呢？（是的，我所有的项目都这样做！）现在你仅仅是绕过了这些。有比节省打字更需要考虑的事情。 - GManNickGprintf(stdout, "Hello "); person.print(stdout); printf("! I see you've subscribed to the "); tags.print(stdout); printf("tags, nice!");比cout << "Hello " << person << "! I see you've subscribed to the " << tags << ", nice!";更加优美，更不疯狂？ - Sebastian MachpX 有一个 << 操作符方法。如果我假设 pX 有一个 (char *) 类型方法，我可以使用带有 (char *) 强制转换的 printf() 方法。这样就没有使用 cout 的优势了。个人而言，我非常不喜欢 << 操作符的重载含义，所以我倾向于使用 printf() 或其他解决方案。 - Bill Weinman
endl也会刷新流，就像您编写了printf("(%d,%d)\n", x, y); fflush(stdout);一样。如果在循环中重复执行此操作，可能会导致大量的性能损耗。要在C ++中获得类似于printf语句的真正等效语句，您应该编写cout << "(" << x << "," << y << ")\n";。 - Didier Trosset