printf()和coutC ++ 和有什么不一样？

令我惊讶的std::cout是printf，即使这个问题只是要求有所不同，这个问题中的每个人都认为它比更好。现在，有一个区别std::cout-C ++和printfC（不过，您可以在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.（假定错误号），并且其描述为占位符，则代码应如下所示。这两个示例的工作方式相同（嗯，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构造。当然，printfgettext$它不是C标准，但它是如此普遍，以至于我认为可以安全使用。

不必记住/查找特定的整数类型语法

C有很多整数类型，C ++也有。std::cout为您处理所有类型，同时printf根据整数类型需要特定的语法（存在非整数类型，但实际上您将在其中使用的唯一非整数类型printf是const char *（C字符串，可以使用的to_c方法获得std::string））。例如，要打印size_t，您需要使用%zd，而int64_t需要使用%"PRId64"。可以在http://en.cppreference.com/w/cpp/io/c/fprintf和http://en.cppreference.com/w/cpp/types/integer上找到这些表。

您无法打印NUL字节， \0

因为printf使用C字符串而不是C ++字符串，所以没有特定技巧就无法打印NUL字节。在某些情况下，可以将%cwith '\0'用作参数，尽管这显然是黑客。

没人关心的差异

性能

更新：事实证明，它iostream是如此之慢，以至于通常比硬盘驱动器慢（如果将程序重定向到文件）。stdio如果需要输出大量数据，则禁用与的同步可能会有所帮助。如果性能是真正的问题（与向STDOUT写几行相对），请使用printf。

每个人都认为他们关心性能，但是没有人去评估它。我的回答是，无论您使用printf还是，I / O都是瓶颈iostream。我认为，printf 可以从快速查看组件（使用铿锵编译更快-O3编译器选项）。假设我的错误示​​例，printfexample的调用方式少于该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（number）被作为printf参数推入。就是这样 没有别的了。为了进行比较，将其iostream编译为汇编。不，没有内联；每个单个operator <<调用都意味着另一个带有另一组参数的调用。

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:

但是，说实话，这没有任何意义，因为I / O仍然是瓶颈。我只是想表明这样iostream做并不快，因为它是“类型安全的”。大多数C实现printf使用计算后的goto 实现格式，因此printf即使没有编译器意识到，其速度也要尽可能快printf（不是，它们不是-有些编译器可以printf在某些情况下进行优化-以结尾的常量字符串\n通常会被优化为puts） 。

遗产

我不知道您为什么要继承ostream，但是我不在乎。也有可能FILE。

class MyFile : public FILE {}

类型安全

诚然，可变长度参数列表没有安全性，但这无关紧要，因为流行的C编译器可以printf在启用警告的情况下检测格式字符串问题。实际上，Clang可以做到这一点而无需启用警告。

$ cat safety.c

#include <stdio.h>

int main(void) {
    printf("String: %s\n", 42);
    return 0;
}

$ clang safety.c

safety.c:4:28: warning: format specifies type 'char *' but the argument has type 'int' [-Wformat]
    printf("String: %s\n", 42);
                    ~~     ^~
                    %d
1 warning generated.
$ gcc -Wall safety.c
safety.c: In function ‘main’:
safety.c:4:5: warning: format ‘%s’ expects argument of type ‘char *’, but argument 2 has type ‘int’ [-Wformat=]
     printf("String: %s\n", 42);
     ^

从C ++常见问题解答：

[15.1]为什么我应该使用它<iostream> 而不是传统方法<cstdio>？

增加类型安全性，减少错误，允许扩展，并提供继承性。

printf()可以说它没有被破坏，scanf()尽管容易出错，但也许可以生存，但是两者在C ++ I / O可以做什么方面都受到限制。C ++ I / O（使用<<和>>）相对于C（使用printf()和scanf()）：

• 类型安全性更高：使用<iostream>，编译器将静态知道要进行I / O操作的对象的类型。相反，<cstdio>使用“％”字段可以动态找出类型。
• 更少的错误倾向：使用<iostream>，没有多余的“％”令牌必须与要进行I / O的实际对象一致。消除冗余消除了一类错误。
• 可扩展：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 /）

人们经常声称这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速度几乎一样快，甚至更快。可以在我的博客上找到更多详细信息。

明确地说，我并不是要说iostreams总是比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);
    }
}

我引用：

从高级的角度来讲，主要区别在于类型安全性（cstdio没有），性能（大多数iostream实现比cstdio慢）和可扩展性（iostream允许自定义输出目标和用户定义类型的无缝输出）。

一种是打印到标准输出的功能。另一个是一个对象，它提供一些成员函数以及operator<<该打印输出到stdout的重载。我可以列举更多的区别，但是我不确定您追求的是什么。

对我来说，使我喜欢“ cout”而不是“ printf”的真正区别是：

1）<<操作符可以在我的课程中重载。

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更加容易。

我发现这里没有另外提及的两点很重要：

1）cout如果您尚未使用STL，则会带来很多负担。它为您的目标文件添加了两倍多的代码printf。对于string，也是如此，这是我倾向于使用自己的字符串库的主要原因。

2）cout使用重载<<运算符，我觉得很不幸。如果您还将<<操作符用于其预期目的（向左移动），这可能会增加混乱。我个人不希望过载运算符以达到与其预期用途相关的目的。

底线：如果已经在使用STL，我将使用cout（和string）。否则，我倾向于避免这种情况。

对于基元，使用哪一个基本无关紧要。我说它有用的地方是当您要输出复杂的对象时。

例如，如果您有一堂课，

#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”，则不必担心输出。

当然，可以编写一些更好的东西来保持维护：

#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;
}

如果有人想进行更多测试（Visual Studio 2008，可执行文件的发行版），则对cout vs. printf进行了扩展测试，添加了“ double”测试：

#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

我想指出的是，如果您想使用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

玩得开心！

cout<< "Hello";
printf("%s", "Hello"); 

两者都用于打印值。它们具有完全不同的语法。C ++兼有，C只有printf。

我想说缺乏可扩展性printf并不是完全正确的：
在C语言中，它是正确的。但是在C语言中，没有真正的类。
在C ++中，可以重载强制转换运算符，因此，可以重载char*运算符并printf像这样使用：

Foo bar;
...;
printf("%s",bar);

如果Foo重载了好的运算符，则可能是可行的。或者，如果您做了一个好方法。简而言之，对我来说printf可扩展cout。

我可以从C ++流中看到的技术论点（通常……不仅是cout。）是：

• 类型安全。（顺便说一句，如果我想打印一张，我会'\n'使用putchar('\n')...我不会使用核弹来杀死昆虫。）

• 简单易学。（无需学习“复杂”参数，只需使用<<和>>操作即可）

• 本机工作std::string（因为printf有std::string::c_str()，但有scanf？）

对于printf我来说：

• 更简单或更复杂的格式（至少在书写字符方面）。对我而言，可读性要高得多（我猜是口味的问题）。

• 更好地控制函数的功能（返回写入的字符数和%n格式化程序：“什么都没有打印。参数必须是一个指向带符号的int的指针，该指针存储了到目前为止写入的字符数。”（摘自printf -C ++参考）

• 更好的调试可能性。出于与上一个参数相同的原因。

我个人偏爱使用printf（和scanf）函数，这主要是因为我喜欢短行，并且因为我认为打印文字方面的类型问题真的很难避免。我不赞成使用C样式的功能，这std::string是唯一不受支持的功能。我们必须char*先将其交给printf（std::string::c_str()如果要阅读，但要如何书写，请加上）。

更多区别：“ printf”返回一个整数值（等于打印的字符数），“ cout”不返回任何值

和。

cout << "y = " << 7; 不是原子的。

printf("%s = %d", "y", 7); 是原子的。

cout执行类型检查，printf不执行。

没有iostream等效于 "% d"

TL; DR：在信任在线随机注释（包括此注释）之前，请始终对生成的机器代码大小，性能，可读性和编码时间进行自己的研究。

我不是专家。我只是偶然听到两个同事谈论由于性能问题应如何避免在嵌入式系统中使用C ++。好吧，很有趣，我根据实际项目任务做了一个基准测试。

在上述任务中，我们必须将一些配置写入RAM。就像是：

咖啡=热
糖=无
牛奶=母乳
= 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();

在将它们都循环十万次之前，我已尽力抛光它们。结果如下：

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。

我不是程序员，但我曾是人为因素工程师。我认为编程语言应该易于学习，理解和使用，这要求它具有简单且一致的语言结构。尽管所有语言都是象征性的，因此从本质上讲是任意的，但仍有约定俗成，遵循这些约定可使该语言更易于学习和使用。

C ++和其他语言中有大量的函数编写为function（parameter），这是一种在计算机前时代最初用于数学函数关系的语法。printf()遵循此语法，如果C ++的编写者想要创建任何在逻辑上不同的方法来读写文件，则可以使用相似的语法简单地创建一个不同的函数。

在Python中，我们当然可以使用也相当标准的object.method语法进行打印，即variablename.print，因为变量是对象，但在C ++中则不是。

我不喜欢cout语法，因为<<操作符不遵循任何规则。它是一个方法或函数，即它接受一个参数并对它执行某些操作。但是，它被编写为好像是一个数学比较运算符。从人为因素的角度来看，这是一种糟糕的方法。

printf是一个函数，cout而是一个变量。