我应该在C ++代码中使用printf吗？

我通常使用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模型具有足够的可读性，因此已将其移植到其他编程语言中。所以有奥利维尔·丹维，谁已经连上了类型安全。

如果您有一个能够对调用进行类型检查的编译器printf，我认为没有理由不使用fprintfC ++和朋友。

免责声明：我是一位糟糕的C ++程序员。

如果您希望使用i18n程序，请远离iostream。问题是，如果句子由多个片段组成（如iostream），则可能无法正确定位字符串。

除了消息片段的问题之外，您还遇到了排序问题。考虑一个打印学生姓名及其平均成绩的报告：

std::cout << name << " has a GPA of " << gpa << std::endl;

将其翻译为另一种语言时，另一种语言的语法可能需要您在名称之前显示GPA。AFAIK，iostreams无法重新排序插值。

如果您希望两全其美（输入安全性并能够使用i18n），请使用Boost.Format。

适应性

对printf非POD的任何尝试都会导致不确定的行为：

struct Foo { 
    virtual ~Foo() {}
    operator float() const { return 0.f; }
};

printf ("%f", Foo());

std::string foo;
printf ("%s", foo);

上面的printf-calls产生不确定的行为。您的编译器可能确实会警告您，但是这些警告不是标准所必需的，并且对于仅在运行时才知道的格式字符串是不可能的。

IO流：

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);

注意，你怎么也得拿使用正确的调用参数/用C签名（例如保健person_fprint(stderr, ...，person_fprint(myfile, ...），其中在C ++中，“ FILE-argument”自动从表达“衍生”。这种推导的更精确的等效实际上是这样的：

FILE *fout = stdout;
...
fprintf(fout, "Hello World!\n");
person_fprint(fout, ...);
fprintf(fout, "\n");

I18N

我们重复使用我们的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 ++程序员每天都会做的事情。另外，无论如何，这都是解剖学上的痛苦。

性能

1. 您是否衡量了printf性能的实际意义？您的瓶颈应用程序是否真的如此懒惰，以至于计算结果的输出就是瓶颈？您确定您完全需要C ++吗？
2. 可怕的性能损失是要满足那些想同时使用printf和cout的用户。这是功能，不是错误！

如果您始终使用iostream，则可以

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：

template <typename T>
void output(const T& pX)
{
    std::cout << pX << std::endl;
}

祝好运。

我的意思是，您可以让运算符将您的类型输出到ostream，而不必像其他任何类型一样麻烦地使用它。printf不适合C ++或更一般的模板。

不仅仅是可用性。也有一致性。在我所有的项目中，我都将cout（和cerr和clog）也输出到文件中。如果使用printf，则跳过所有这些。另外，一致性本身是一件好事。混合cout和printf，尽管完全有效，却很难看。

如果您有一个对象，并且想要使其成为可输出的，则最干净的方法是operator<<对该类进行重载。那你打算怎么用printf呢？您将最终得到混杂有couts和printfs的代码。

如果您确实要格式化，请在维持流接口的同时使用Boost.Format。一致性和格式。

使用printf。不要使用C ++流。printf为您提供更好的控制（例如浮点精度等）。该代码通常也更短，更易读。

Google C ++样式指南同意。

除非记录接口要求，否则不要使用流。请改用类似printf的例程。

使用流有多种利弊，但在这种情况下，就像在许多其他情况下一样，一致性胜过争论。不要在代码中使用流。

总的来说，我同意（讨厌<<语法，尤其是在需要复杂格式的情况下）

但我要指出安全方面。

printf("%x",2.0f)
printf("%x %x",2)
printf("%x",2,2)

编译器可能不会注意到它，但可能会使您的应用程序崩溃。

使用适合您需求和偏好的任何东西。如果您对printf感到满意，则一定要使用它。如果您对iostream更加满意，请坚持使用它们。混合搭配以最适合您的要求。毕竟，这是软件-有更好的方法和更糟糕的方法，但是很少只有一种方法。

分享并享受。

我不喜欢printf。它缺乏类型安全性，因此使用起来很危险，再加上需要记住格式说明符的麻烦。巧妙地做正确的事的模板化运算符要好得多。所以我总是在C ++中使用C ++流。

当然，由于其他原因，许多人更喜欢printf，在其他地方已列举。

我经常“退回”使用printf()，但更多时候snprintf()来格式化输出。当用C ++编程时，我使用这个包装器，我写了一段时间，就像这样（使用上面的示例）：cout << format("(%d,%d)\n", x, y);

这是标题（stdiomm.h）：

#pragma once

#include <cstdarg>
#include <string>

template <typename T>
std::basic_string<T> format(T const *format, ...);

template <typename T>
std::basic_string<T> vformat(T const *format, va_list args);

以及来源（stdiomm.cpp）：

#include "stdiomm.h"
#include <boost/scoped_array.hpp>
#include <cstdio>

template <>
std::wstring vformat(wchar_t const *format, va_list arguments)
{
#if defined(_WIN32)
    int required(_vscwprintf(format, arguments));
    assert(required >= 0);
    boost::scoped_array<wchar_t> buffer(new wchar_t[required + 1]);
    int written(vswprintf(buffer.get(), required + 1, format, arguments));
    assert(written == required);
    return std::wstring(buffer.get(), written);
#else
#   error "No implementation yet"
#endif
}

template <>
std::string vformat(char const *format, va_list arguments)
{
#if defined(_WIN32)
    int required(_vscprintf(format, arguments));
    assert(required >= 0);
    boost::scoped_array<char> buffer(new char[required + 1]);
    int written(vsnprintf(buffer.get(), required + 1, format, arguments));
    assert(written == required);
    return std::string(buffer.get(), written);
#else
    char *buffer;
    int printed = vasprintf(&buffer, format, arguments);
    assert(printed != -1);
    std::string retval(buffer, printed);
    free(buffer);
    return retval;      
#endif
}

template <typename T>
std::basic_string<T> format(T const *format, ...)
{
    va_list ap;
    va_start(ap, format);
    std::basic_string<T> retval(vformat(format, ap));
    va_end(ap);
    return retval;
}

template std::wstring format(wchar_t const *format, ...);
template std::string format(char const *format, ...);

更新资料

在阅读了其他一些答案之后，我可能不得不转向boost::format()自己！

您可以使用fmt库获得两全其美的功能，该库将iostream的安全性和可扩展性与易用性和性能相结合(s)printf。例：

std::string = fmt::format("The answer is {}", 42);

该库支持类似Python和printf格式的字符串语法。

免责声明：我是fmt库的作者。

即使这个问题比较老，我还是要加两分钱。

使用printf（）打印用户创建的对象

考虑一下，这相当简单-您可以将类型字符串化并将字符串发送给printf：

std::string to_string(const MyClass &x)
{
     return to_string(x.first)+" "+to_string(x.second);
}

//...

printf("%s is awesome", to_string(my_object).c_str()); //more or less

没有可耻的是（没有C ++ 11 to_string（））标准化的C ++接口来对对象进行字符串化...

printf（）陷阱

单个标志-％n

唯一的一个是输出参数-它期望指向int的指针。它将成功写入的字符数写入此指针指向的位置。熟练使用它可能会触发溢出，这是安全漏洞（请参阅printf（）格式字符串攻击）。

（请参见fmt库主页）

在C ++ 20中，格式化部分的fmt库是标准化的：

std::format("({},{})\n", x, y) // returns a std::string

您可以使用format_to以下方法避免动态分配开销：

std::format_to(/* output iterator */, "({},{})\n", x, y);

应该将其视为规范的格式化方式，因为它结合了流的优点：

• 安全：磁带库是完全类型安全的。自动内存管理可防止缓冲区溢出。使用异常或在编译时报告格式字符串中的错误。

• 可扩展性：重载operator<<很容易，而扩展printf则不是那么容易。

以及printf：

• 易于使用：%支持语法，而不是冗长的操纵符。该{}语法也被引入，以消除符。

• 性能：测量表明，fmt库是迄今为止C ++中最快的输出方法。比printf和更快。

我几乎总是将printf用于临时调试语句。对于更永久的代码，我更喜欢'c'流，因为它们是C ++ Way。尽管boost :: format看起来很有希望，并且可能会代替我的流用法（尤其是对于格式复杂的输出），但是很长一段时间内，可能没有什么可以代替printf。

C ++流被高估了，毕竟它们实际上只是带有重载运算符的类<<。
我已经读过很多次了，流是C ++方式，而printf是C方式，但是它们都是C ++中可用的库功能，因此您应该使用最适合的方式。
我最喜欢printf，但我也使用了流，它提供了更简洁的代码，并避免了将％占位符与参数匹配的情况。

这取决于实际情况。没有什么是完美的。我都用。流适用于自定义类型，因为您可以在ostream中重载>>运算符。但是，当涉及到间距等时，最好使用printf（）。stringstream和like优于C风格的strcat（）。因此，请使用适合该情况的一种。

我读过警告说cout和cerr对多线程不安全。如果为true，则是避免使用它们的一个很好的理由。注意：我将GNU g ++与openMP一起使用。

在cpp中，流是首选的，因为它们遵循cpp的面向对象范例，而且类型安全。

另一方面，printf更像是一种功能方法。

我能想到的在cpp代码中不使用printf的唯一原因不是面向对象的。

它更多是个人选择。