答案 0 :(得分：259)
我很惊讶这个问题中的每个人都声称std::cout比printf更好，即使问题只是要求差异。现在，存在差异 - std::cout是C ++，printf是C（但是，您可以在C ++中使用它，就像几乎 C中的任何其他内容一样）。现在，我在这里说实话; printf和std::cout都有其优势。
std::cout是可扩展的。我知道人们会说printf也是可扩展的，但C标准中没有提到这种扩展（所以你必须使用非标准功能 - 但是甚至不存在常见的非标准功能），以及这样的扩展名是一个字母（所以它很容易与已经存在的格式冲突）。
与printf不同，std::cout完全取决于运算符重载，因此自定义格式没有问题 - 您所做的就是定义一个子程序，将std::ostream作为第一个参数和您的类型作为第二。因此，没有命名空间问题 - 只要你有一个类（不限于一个字符），你可以为它进行std::ostream重载。
但是，我怀疑很多人会想延长ostream（说实话，我很少看到这样的扩展，即使它们很容易制作）。但是，如果你需要它就在这里。
由于可以很容易地注意到，printf和std::cout都使用不同的语法。 printf使用模式字符串和可变长度参数列表使用标准函数语法。实际上，printf是C拥有它们的原因 - printf格式过于复杂，没有它们就无法使用。但是，std::cout使用不同的API - 返回自身的operator << API。
一般来说，这意味着C版本会更短，但在大多数情况下它都不重要。打印多个参数时，差异很明显。如果您必须编写类似Error 2: File not found.的内容，假设错误编号，并且其描述是占位符，则代码将如下所示。两个示例work identically（好吧，std::endl实际上都刷新了缓冲区。）
printf("Error %d: %s.\n", id, errors[id]);
std::cout << "Error " << id << ": " << errors[id] << "." << std::endl;
虽然这看起来并不太疯狂（它只会长两倍），但实际设置参数格式时，事情会变得更加疯狂，而不仅仅是打印它们。例如，打印像0x0424这样的东西真是太疯狂了。这是由std::cout混合状态和实际值引起的。我从未见过类似std::setfill之类的语言（当然不是C ++）。 printf清楚地区分了参数和实际类型。我真的更喜欢保持它的printf版本（即使它看起来有点神秘）与iostream版本相比（因为它包含太多噪音）。
printf("0x%04x\n", 0x424);
std::cout << "0x" << std::hex << std::setfill('0') << std::setw(4) << 0x424 << std::endl;
这是printf的真正优势所在。 printf格式字符串很好......一个字符串。与operator <<滥用iostream相比，这使得翻译变得非常容易。假设gettext()函数转换，并且您想要显示Error 2: File not found.，那么用于转换先前显示的格式字符串的代码将如下所示：
printf(gettext("Error %d: %s.\n"), id, errors[id]);
现在，让我们假设我们翻译为Fictionish，其中错误编号在描述之后。翻译后的字符串看起来像%2$s oru %1$d.\n。现在，如何在C ++中完成它？好吧，我不知道。我想你可以伪造iostream构建printf，你可以传递给gettext或其他东西，以便进行翻译。当然，$不是C标准，但它很常见，在我看来它是安全的。
C有很多整数类型，C ++也是如此。 std::cout为您处理所有类型，而printf需要特定语法，具体取决于整数类型（有非整数类型，但是您将在实践中使用的唯一非整数类型{{1} }是printf（C字符串，可以使用const char *的{{1}}方法获得）。例如，要打印to_c，您需要使用std::string，而size_t则需要使用%zd。这些表格位于http://en.cppreference.com/w/cpp/io/c/fprintf和http://en.cppreference.com/w/cpp/types/integer。
int64_t 因为%"PRId64"使用C字符串而不是C ++字符串，所以如果没有特定的技巧，它就无法打印NUL字节。在某些情况下，可以使用\0 printf作为参数，尽管这显然是一个黑客攻击。
更新：事实证明%c速度太慢，以至于它通常比您的硬盘驱动器慢（如果您将程序重定向到文件）。如果您需要输出大量数据，禁用与'\0'的同步可能会有所帮助。如果性能是一个真正的问题（而不是向STDOUT写几行），只需使用iostream。
每个人都认为他们关心表现，但没有人愿意测量它。我的回答是，无论你使用stdio还是printf，I / O都是瓶颈。我认为printf 可以通过快速查看汇编（使用iostream编译器选项使用clang编译）来加快速度。假设我的错误示例，printf示例的调用次数少于-O3示例。这是printf cout：
int main您可以很容易地注意到两个字符串和printf（数字）被推送为main: @ @main
@ BB#0:
push {lr}
ldr r0, .LCPI0_0
ldr r2, .LCPI0_1
mov r1, #2
bl printf
mov r0, #0
pop {lr}
mov pc, lr
.align 2
@ BB#1:
个参数。这是关于它的;没有别的。为了比较，这是2编译为程序集。不，没有内联;每一个printf调用都意味着另一个调用另一组参数。
iostream然而，说实话，这意味着什么，因为I / O无论如何都是瓶颈。我只是想表明operator <<并不快，因为它类型安全＆＃34;。大多数C实现使用计算的goto实现main: @ @main
@ BB#0:
push {r4, r5, lr}
ldr r4, .LCPI0_0
ldr r1, .LCPI0_1
mov r2, #6
mov r3, #0
mov r0, r4
bl _ZSt16__ostream_insertIcSt11char_traitsIcEERSt13basic_ostreamIT_T0_ES6_PKS3_l
mov r0, r4
mov r1, #2
bl _ZNSolsEi
ldr r1, .LCPI0_2
mov r2, #2
mov r3, #0
mov r4, r0
bl _ZSt16__ostream_insertIcSt11char_traitsIcEERSt13basic_ostreamIT_T0_ES6_PKS3_l
ldr r1, .LCPI0_3
mov r0, r4
mov r2, #14
mov r3, #0
bl _ZSt16__ostream_insertIcSt11char_traitsIcEERSt13basic_ostreamIT_T0_ES6_PKS3_l
ldr r1, .LCPI0_4
mov r0, r4
mov r2, #1
mov r3, #0
bl _ZSt16__ostream_insertIcSt11char_traitsIcEERSt13basic_ostreamIT_T0_ES6_PKS3_l
ldr r0, [r4]
sub r0, r0, #24
ldr r0, [r0]
add r0, r0, r4
ldr r5, [r0, #240]
cmp r5, #0
beq .LBB0_5
@ BB#1: @ %_ZSt13__check_facetISt5ctypeIcEERKT_PS3_.exit
ldrb r0, [r5, #28]
cmp r0, #0
beq .LBB0_3
@ BB#2:
ldrb r0, [r5, #39]
b .LBB0_4
.LBB0_3:
mov r0, r5
bl _ZNKSt5ctypeIcE13_M_widen_initEv
ldr r0, [r5]
mov r1, #10
ldr r2, [r0, #24]
mov r0, r5
mov lr, pc
mov pc, r2
.LBB0_4: @ %_ZNKSt5ctypeIcE5widenEc.exit
lsl r0, r0, #24
asr r1, r0, #24
mov r0, r4
bl _ZNSo3putEc
bl _ZNSo5flushEv
mov r0, #0
pop {r4, r5, lr}
mov pc, lr
.LBB0_5:
bl _ZSt16__throw_bad_castv
.align 2
@ BB#6:
格式，因此iostream尽可能快，即使没有编译器知道printf（不是他们不是......）某些编译器在某些情况下可以优化printf - 以printf结尾的常量字符串通常会优化为printf。）
我不知道你为什么要继承\n，但我不在乎。它也可能puts。
ostream确实，可变长度参数列表没有安全性，但这并不重要，因为如果启用警告，流行的C编译器可以检测FILE格式字符串的问题。事实上，Clang可以在不启用警告的情况下做到这一点。
class MyFile : public FILE {}
答案 1 :(得分：193)
来自C++ FAQ：
[15.1]为什么我应该使用
<iostream>而不是传统的<cstdio>？提高类型安全性，减少错误，允许可扩展性并提供可继承性。
printf()可以说是没有被破坏，scanf()尽管容易出错，但可能是适合居住的，但两者在C ++ I / O方面都有限。相对于C（使用<<和>>），C ++ I / O（使用printf()和scanf()）是：
- 更多类型安全：使用
<iostream>，I / O的对象类型是 由编译器静态知道。在 对比度，<cstdio>使用“％”字段 动态计算出类型。- 不易出错：使用
<iostream>，没有多余的 必须保持一致的“％”代币 实际对象是I / O'd。 删除冗余会删除一个类 错误。- 可扩展：C ++
<iostream>机制允许新的用户定义 类型是I / O而不会破坏 现有代码。想象一下混乱 每个人都在同时添加 新的不兼容的“％”字段printf()和scanf()？！- 可继承：C ++
<iostream>机制是从真实类构建的 例如std::ostream和std::istream。与<cstdio>不同FILE*，这些是真正的类和 因此可以继承。这意味着你可以 有其他用户定义的东西 看起来和行为像溪流，但那 做任何奇怪和奇妙的事情 你想要的东西。你自动了 得到使用数以万计的 您没有使用的用户编写的I / O代码 即使知道，他们也不需要 知道你的“扩展流” 类。
另一方面，printf明显更快，在非常特定和有限的情况下，可能优先使用cout。始终首先介绍。 （例如，参见http://programming-designs.com/2009/02/c-speed-test-part-2-printf-vs-cout /）
答案 2 :(得分：38)
人们经常声称printf要快得多。这在很大程度上是一个神话。我刚测试了它，结果如下：
cout with only endl 1461.310252 ms
cout with only '\n' 343.080217 ms
printf with only '\n' 90.295948 ms
cout with string constant and endl 1892.975381 ms
cout with string constant and '\n' 416.123446 ms
printf with string constant and '\n' 472.073070 ms
cout with some stuff and endl 3496.489748 ms
cout with some stuff and '\n' 2638.272046 ms
printf with some stuff and '\n' 2520.318314 ms
结论：如果您只想换行，请使用printf;否则，cout几乎一样快，甚至更快。有关详细信息，请参阅my blog。
要明确，我并不是说iostream总是比printf更好;我只是想说你应该根据实际数据做出明智的决定，而不是基于一些常见的误导性假设的疯狂猜测。
更新：这是我用于测试的完整代码。使用g++进行编译，没有任何其他选项（时间除了-lrt之外）。
#include <stdio.h>
#include <iostream>
#include <ctime>
class TimedSection {
char const *d_name;
timespec d_start;
public:
TimedSection(char const *name) :
d_name(name)
{
clock_gettime(CLOCK_REALTIME, &d_start);
}
~TimedSection() {
timespec end;
clock_gettime(CLOCK_REALTIME, &end);
double duration = 1e3 * (end.tv_sec - d_start.tv_sec) +
1e-6 * (end.tv_nsec - d_start.tv_nsec);
std::cerr << d_name << '\t' << std::fixed << duration << " ms\n";
}
};
int main() {
const int iters = 10000000;
char const *text = "01234567890123456789";
{
TimedSection s("cout with only endl");
for (int i = 0; i < iters; ++i)
std::cout << std::endl;
}
{
TimedSection s("cout with only '\\n'");
for (int i = 0; i < iters; ++i)
std::cout << '\n';
}
{
TimedSection s("printf with only '\\n'");
for (int i = 0; i < iters; ++i)
printf("\n");
}
{
TimedSection s("cout with string constant and endl");
for (int i = 0; i < iters; ++i)
std::cout << "01234567890123456789" << std::endl;
}
{
TimedSection s("cout with string constant and '\\n'");
for (int i = 0; i < iters; ++i)
std::cout << "01234567890123456789\n";
}
{
TimedSection s("printf with string constant and '\\n'");
for (int i = 0; i < iters; ++i)
printf("01234567890123456789\n");
}
{
TimedSection s("cout with some stuff and endl");
for (int i = 0; i < iters; ++i)
std::cout << text << "01234567890123456789" << i << std::endl;
}
{
TimedSection s("cout with some stuff and '\\n'");
for (int i = 0; i < iters; ++i)
std::cout << text << "01234567890123456789" << i << '\n';
}
{
TimedSection s("printf with some stuff and '\\n'");
for (int i = 0; i < iters; ++i)
printf("%s01234567890123456789%i\n", text, i);
}
}
答案 3 :(得分：37)
我quote：
从高层来看，主要区别在于类型安全（cstdio 没有它，性能（大多数iostream实现 慢于cstdio）和可扩展性（iostreams允许 自定义输出目标和用户定义类型的无缝输出。
答案 4 :(得分：29)
一个是打印到stdout的函数。另一个是提供打印到stdout的operator<<的几个成员函数和重载的对象。我可以列举更多的差异，但我不确定你在追求什么。
答案 5 :(得分：11)
对我来说，真正的差异会让我选择'cout'而不是'printf'：
1）＆lt;＆lt; 运算符可以为我的类重载。
2）cout的输出流可以很容易地更改为文件： （：复制粘贴：）
#include <iostream>
#include <fstream>
using namespace std;
int main ()
{
cout << "This is sent to prompt" << endl;
ofstream file;
file.open ("test.txt");
streambuf* sbuf = cout.rdbuf();
cout.rdbuf(file.rdbuf());
cout << "This is sent to file" << endl;
cout.rdbuf(sbuf);
cout << "This is also sent to prompt" << endl;
return 0;
}
3）我发现cout更具可读性，特别是当我们有很多参数时。
cout的一个问题是格式选项。在printf中格式化数据（精确度，对齐度等）更容易。
答案 6 :(得分：5)
这里没有另外提到的两点我觉得很重要：
1）如果您尚未使用STL，cout会带来很多行李。它为您的目标文件添加了两倍于printf的代码。 string也是如此，这是我倾向于使用自己的字符串库的主要原因。
2）cout使用重载的<<运算符，我觉得这很不幸。如果您还将<<运算符用于其预期目的（向左移动），则会增加混淆。我个人不喜欢为了与其预期用途相关的目的而使操作员超载。
结论：如果我已经在使用STL，我会使用cout（以及string）。否则，我倾向于避免它。
答案 7 :(得分：4)
对于原语，你使用哪一个并不重要。我说当你想要输出复杂的对象时，它变得有用了。
例如，如果你有一个班级，
#include <iostream>
#include <cstdlib>
using namespace std;
class Something
{
public:
Something(int x, int y, int z) : a(x), b(y), c(z) { }
int a;
int b;
int c;
friend ostream& operator<<(ostream&, const Something&);
};
ostream& operator<<(ostream& o, const Something& s)
{
o << s.a << ", " << s.b << ", " << s.c;
return o;
}
int main(void)
{
Something s(3, 2, 1);
// output with printf
printf("%i, %i, %i\n", s.a, s.b, s.c);
// output with cout
cout << s << endl;
return 0;
}
现在上面看起来似乎并不那么好，但我们假设您必须在代码中的多个位置输出它。不仅如此，我们假设您添加了一个字段“int d”。有了cout，你只需要在一个地方改变它。但是，使用printf，你必须在很多地方改变它，不仅如此，你必须提醒自己输出哪些。
有了这个说法，使用cout，你可以减少维护代码所花费的大量时间，而不仅仅是如果你在新应用程序中重新使用“Something”对象，你真的不必担心关于输出。
答案 8 :(得分：2)
当然，你可以更好地写一些东西来保持维护：
#include <iostream>
#include <cstdlib>
using namespace std;
class Something
{
public:
Something(int x, int y, int z) : a(x), b(y), c(z) { }
int a;
int b;
int c;
friend ostream& operator<<(ostream&, const Something&);
void print() const { printf("%i, %i, %i\n", a, b, c); }
};
ostream& operator<<(ostream& o, const Something& s)
{
o << s.a << ", " << s.b << ", " << s.c;
return o;
}
int main(void)
{
Something s(3, 2, 1);
// Output with printf
s.print(); // Simple as well, isn't it?
// Output with cout
cout << s << endl;
return 0;
}
对cout与printf进行了一些扩展测试，添加了一个'double'测试，如果有人想做更多测试（Visual Studio 2008，可执行文件的发布版本）：
#include <stdio.h>
#include <iostream>
#include <ctime>
class TimedSection {
char const *d_name;
//timespec d_start;
clock_t d_start;
public:
TimedSection(char const *name) :
d_name(name)
{
//clock_gettime(CLOCK_REALTIME, &d_start);
d_start = clock();
}
~TimedSection() {
clock_t end;
//clock_gettime(CLOCK_REALTIME, &end);
end = clock();
double duration = /*1e3 * (end.tv_sec - d_start.tv_sec) +
1e-6 * (end.tv_nsec - d_start.tv_nsec);
*/
(double) (end - d_start) / CLOCKS_PER_SEC;
std::cerr << d_name << '\t' << std::fixed << duration * 1000.0 << " ms\n";
}
};
int main() {
const int iters = 1000000;
char const *text = "01234567890123456789";
{
TimedSection s("cout with only endl");
for (int i = 0; i < iters; ++i)
std::cout << std::endl;
}
{
TimedSection s("cout with only '\\n'");
for (int i = 0; i < iters; ++i)
std::cout << '\n';
}
{
TimedSection s("printf with only '\\n'");
for (int i = 0; i < iters; ++i)
printf("\n");
}
{
TimedSection s("cout with string constant and endl");
for (int i = 0; i < iters; ++i)
std::cout << "01234567890123456789" << std::endl;
}
{
TimedSection s("cout with string constant and '\\n'");
for (int i = 0; i < iters; ++i)
std::cout << "01234567890123456789\n";
}
{
TimedSection s("printf with string constant and '\\n'");
for (int i = 0; i < iters; ++i)
printf("01234567890123456789\n");
}
{
TimedSection s("cout with some stuff and endl");
for (int i = 0; i < iters; ++i)
std::cout << text << "01234567890123456789" << i << std::endl;
}
{
TimedSection s("cout with some stuff and '\\n'");
for (int i = 0; i < iters; ++i)
std::cout << text << "01234567890123456789" << i << '\n';
}
{
TimedSection s("printf with some stuff and '\\n'");
for (int i = 0; i < iters; ++i)
printf("%s01234567890123456789%i\n", text, i);
}
{
TimedSection s("cout with formatted double (width & precision once)");
std::cout << std::fixed << std::scientific << std::right << std::showpoint;
std::cout.width(8);
for (int i = 0; i < iters; ++i)
std::cout << text << 8.315 << i << '\n';
}
{
TimedSection s("cout with formatted double (width & precision on each call)");
std::cout << std::fixed << std::scientific << std::right << std::showpoint;
for (int i = 0; i < iters; ++i)
{ std::cout.width(8);
std::cout.precision(3);
std::cout << text << 8.315 << i << '\n';
}
}
{
TimedSection s("printf with formatted double");
for (int i = 0; i < iters; ++i)
printf("%8.3f%i\n", 8.315, i);
}
}
结果是：
cout with only endl 6453.000000 ms
cout with only '\n' 125.000000 ms
printf with only '\n' 156.000000 ms
cout with string constant and endl 6937.000000 ms
cout with string constant and '\n' 1391.000000 ms
printf with string constant and '\n' 3391.000000 ms
cout with some stuff and endl 9672.000000 ms
cout with some stuff and '\n' 7296.000000 ms
printf with some stuff and '\n' 12235.000000 ms
cout with formatted double (width & precision once) 7906.000000 ms
cout with formatted double (width & precision on each call) 9141.000000 ms
printf with formatted double 3312.000000 ms
答案 9 :(得分：2)
我想指出，如果你想在C ++中使用线程，如果使用cout，你可以得到一些有趣的结果。
考虑以下代码：
#include <string>
#include <iostream>
#include <thread>
using namespace std;
void task(int taskNum, string msg) {
for (int i = 0; i < 5; ++i) {
cout << "#" << taskNum << ": " << msg << endl;
}
}
int main() {
thread t1(task, 1, "AAA");
thread t2(task, 2, "BBB");
t1.join();
t2.join();
return 0;
}
// g++ ./thread.cpp -o thread.out -ansi -pedantic -pthread -std=c++0x
现在，输出全部改组了。它也会产生不同的结果，尝试多次执行：
##12:: ABABAB
##12:: ABABAB
##12:: ABABAB
##12:: ABABAB
##12:: ABABAB
您可以使用printf来做到正确，也可以使用mutex。
#1: AAA
#2: BBB
#1: AAA
#2: BBB
#1: AAA
#2: BBB
#1: AAA
#2: BBB
#1: AAA
#2: BBB
玩得开心！
答案 10 :(得分：1)
我想说printf的可扩展性缺乏并不完全正确：
在C中，这是事实。但在C语言中，没有真正的课程
在C ++中，可以重载强制转换运算符，因此，重载char*运算符并使用printf这样：
Foo bar;
...;
printf("%s",bar);
。或者如果你做了一个好方法。简而言之，对于我来说，printf与cout一样可扩展。
我可以看到C ++流的技术论据（通常......不仅仅是cout。）是：
类型安全。 （顺便说一句，如果我想要打印一个'\n'我使用putchar('\n') ......我不会用核弹来杀死昆虫。）
更容易学习。 （不需要学习“复杂”参数，只需使用<<和>>运算符）
与std::string本地合作（对于printf有std::string::c_str()，但对于scanf？）
对于printf，我看到了：
更容易，或者至少更短（在写字符方面）复杂的格式。更可读，对我来说（我猜的味道问题）。
更好地控制函数的作用（返回写入的字符数和%n格式化程序：“没有打印。参数必须是指向有符号int的指针，其中的数字为目前已写入的字符已存储。“（来自printf - C++ Reference）
更好的调试可能性。出于与上一个论点相同的原因。
我的个人偏好转到printf（和scanf）功能，主要是因为我喜欢短线，因为我不认为印刷文字的类型问题真的很难避免。
我唯一对C风格函数感到遗憾的是std::string不受支持。我们必须经过char*才能将printf传递给std::string::c_str()（如果我们想要阅读{{1}}，那么该如何写？）
答案 11 :(得分：1)
更多差异： “printf”返回一个整数值（等于打印的字符数），“cout”不返回任何内容
和
cout << "y = " << 7;不是原子的。
printf("%s = %d", "y", 7);是原子的。
cout执行类型检查，printf没有。
没有相当于"% d"
答案 12 :(得分：1)
我不是程序员，但我一直是人工因素工程师。我觉得编程语言应该易于学习，理解和使用，这要求它具有简单一致的语言结构。虽然所有语言都是象征性的，因此，其核心是任意的，有一些约定，并且遵循它们使语言更容易学习和使用。
C ++和其他语言中有大量函数被编写为函数（参数），这种语法最初用于计算机时代的数学函数关系。 printf()遵循这种语法，如果C ++的编写者想要创建任何逻辑上不同的读写文件的方法，他们可以使用类似的语法创建一个不同的函数。
在Python中，我们当然可以使用相当标准的object.method语法进行打印，即variablename.print，因为变量是对象，但在C ++中它们不是。
我不喜欢cout语法因为＆lt;＆lt;运营商不遵守任何规则。它是一种方法或功能，即它需要一个参数并对其做一些事情。然而，它被写成好像是一个数学比较运算符。从人为因素的角度来看，这是一种糟糕的方法。
答案 13 :(得分：1)
TL; DR：关于生成的机器代码大小，性能，可读性和编码，始终做自己的研究在信任在线随机评论之前，包括这个评论。
我没有专家。我碰巧听到两位同事在谈论我们应该如何避免因为性能问题而在嵌入式系统中使用C ++。好吧，有趣的是，我根据一个真实的项目任务做了一个基准测试。
在上述任务中，我们必须将一些配置写入RAM。类似的东西：
咖啡=热
糖=无
牛奶=乳房
MAC = AA：BB：CC：DD：EE：FF
这是我的基准程序（是的，我知道OP询问了printf（），而不是fprintf（）。尝试捕捉精华，顺便说一句，OP的链接指向fprintf（）无论如何。）
C程序：
char coffee[10], sugar[10], milk[10];
unsigned char mac[6];
/* Initialize those things here. */
FILE * f = fopen("a.txt", "wt");
fprintf(f, "coffee=%s\nsugar=%s\nmilk=%s\nmac=%02X:%02X:%02X:%02X:%02X:%02X\n", coffee, sugar, milk, mac[0], mac[1],mac[2],mac[3],mac[4],mac[5]);
fclose(f);
C ++程序：
//Everything else is identical except:
std::ofstream f("a.txt", std::ios::out);
f << "coffee=" << coffee << "\n";
f << "sugar=" << sugar << "\n";
f << "milk=" << milk << "\n";
f << "mac=" << (int)mac[0] << ":"
<< (int)mac[1] << ":"
<< (int)mac[2] << ":"
<< (int)mac[3] << ":"
<< (int)mac[4] << ":"
<< (int)mac[5] << endl;
f.close();
在我将它们环绕100,000次之前，我尽力擦亮它们。结果如下：
C程序：
real 0m 8.01s
user 0m 2.37s
sys 0m 5.58s
C ++程序：
real 0m 6.07s
user 0m 3.18s
sys 0m 2.84s
目标文件大小：
C - 2,092 bytes
C++ - 3,272 bytes
结论：在我非常具体的平台上，使用非常具体的处理器，运行非常具体的 Linux内核版本来运行使用非常具体的 GCC 版本编译的程序，为了完成一个非常具体的任务，我想说C ++方法更合适，因为它运行得更快，提供更好的可读性。另一方面，在我看来，C占地面积小，几乎没有任何意义，因为程序规模不是我们关注的问题。
记住，YMMV。
答案 14 :(得分：0)
cout<< "Hello";
printf("%s", "Hello");
两者都用于打印值。它们的语法完全不同。 C ++有两个，C 只有printf。
答案 15 :(得分：-4)
printf是一个函数，而cout是一个变量。