`std::cout` 是如何实现的？

Question

std::cout 是std::ostream 的一个实例。我可以在名为 /usr/include/c++/7/iostream 的文件中看到 std::cout 的声明：

extern ostream cout;      /// Linked to standard output

而std::ostream是由typedef std::basic_ostream<char> std::ostream定义的。

更何况，你好像不能创建std::ostream的实例。请参阅此演示code snippet：

#include<iostream>

int main()
{
    std::ostream os;
    return 0;
}

以下是编译器对上面代码 sn-p 的抱怨：

In file included from /opt/compiler-explorer/gcc-4.9.0/include/c++/4.9.0/iostream:39:0,
                 from <source>:1:
/opt/compiler-explorer/gcc-4.9.0/include/c++/4.9.0/ostream: In function 'int main()':
/opt/compiler-explorer/gcc-4.9.0/include/c++/4.9.0/ostream:384:7: error: 'std::basic_ostream<_CharT, _Traits>::basic_ostream() [with _CharT = char; _Traits = std::char_traits<char>]' is protected
       basic_ostream()
       ^
<source>:5:18: error: within this context
     std::ostream os;
                  ^

问题来了，既然 std::basic_ostream<_CharT, _Traits>::basic_ostream() 被标记为受保护，那么 std::cout 是如何创建的呢？

CppReference 上的这个link 好像意义不大。并没有明确告诉我std::cout是如何实现的，以及std::ostream的构造函数是如何创建std::cout的。据我所知，最相关的信息是：

全局对象 std::cout 和 std::wcout 控制输出到实现定义类型的流缓冲区（派生自 std::streambuf），与标准 C 输出流 stdout 相关联。

仅此而已。

我正在与gcc 4.9一起工作Ubuntu

感谢@NathanPierson。

他告诉我

std::basic_ostream 有一个构造函数，该构造函数接受指向 std::basic_streambuf 对象的指针。std::cout 使用指向 std::basic_streambuf 的某个实现定义的派生类的实例的指针进行初始化。

，这让我离答案更近了。

Answer 1

std::cout 是如何创建的？

首先，来自https://en.cppreference.com/w/cpp/io/ios_base/Init：

std::ios_base::初始化

此类用于确保默认的 C++ 流 (std::cin, std::cout 等）被正确初始化和销毁​​。 [...]

标题 <iostream> 的行为就好像它定义了（直接或 间接地）具有静态存储的 std::ios_base::Init 实例 期间： [...]

嗯，让我们做一个真实的代码示例。我将使用GCC C++ library。来自https://github.com/gcc-mirror/gcc/blob/master/libstdc%2B%2B-v3/include/std/iostream#L73，这是重要的部分：

 // For construction of filebuffers for cout, cin, cerr, clog et. al.
 static ios_base::Init __ioinit;

现在我们跳转到ios_base::Init类的构造函数，在https://github.com/gcc-mirror/gcc/blob/master/libstdc%2B%2B-v3/src/c%2B%2B98/ios_init.cc#L85：

ios_base::Init::Init()
  {
    if (__gnu_cxx::__exchange_and_add_dispatch(&_S_refcount, 1) == 0)
      {
    // Standard streams default to synced with "C" operations.
    _S_synced_with_stdio = true;

    new (&buf_cout_sync) stdio_sync_filebuf<char>(stdout);
    new (&buf_cin_sync) stdio_sync_filebuf<char>(stdin);
    new (&buf_cerr_sync) stdio_sync_filebuf<char>(stderr);

    // The standard streams are constructed once only and never
    // destroyed.
    new (&cout) ostream(&buf_cout_sync);
    new (&cin) istream(&buf_cin_sync);
    new (&cerr) ostream(&buf_cerr_sync);
    new (&clog) ostream(&buf_cerr_sync);
    cin.tie(&cout);
    cerr.setf(ios_base::unitbuf);
    // _GLIBCXX_RESOLVE_LIB_DEFECTS
    // 455. cerr::tie() and wcerr::tie() are overspecified.
    cerr.tie(&cout);

_S_refcount 用于当您从静态类的构造函数手动调用 ios_base::Init::Init(); 时，它可以防止双重初始化。

stdio_sync_filebuf 是istream/ostream 的内部缓冲区，它用于处理cstdio FILE* 操作以获取/放置输入/输出数据，并在此处实现 https://github.com/gcc-mirror/gcc/blob/master/libstdc%2B%2B-v3/include/ext/stdio_sync_filebuf.h#L56 。它继承自std::basic_streambuf。

所以cout是以stdio_sync_filebuf<char>为参数构造的in-place。这是这里提到的第一个构造函数https://en.cppreference.com/w/cpp/io/basic_ostream/basic_ostream。

现在，因为这些东西是就地构建的，您可能想知道内存是如何分配的？来自https://github.com/gcc-mirror/gcc/blob/master/libstdc%2B%2B-v3/src/c%2B%2B98/globals_io.cc#L50：

  // Standard stream objects.
  // NB: Iff <iostream> is included, these definitions become wonky.
  typedef char fake_istream[sizeof(istream)]
  __attribute__ ((aligned(__alignof__(istream))));
  typedef char fake_ostream[sizeof(ostream)]
  __attribute__ ((aligned(__alignof__(ostream))));
  fake_istream cin;
  fake_ostream cout;
  fake_ostream cerr;
  fake_ostream clog;

这些对象只是空的 char 适当大小和适当对齐的缓冲区。

是的，您可以自己构建 ostream，在 GCC 上使用 __gnu_cxx::stdio_sync_filebuf：

#include <fstream>
#include <ext/stdio_sync_filebuf.h>
int main() {
    __gnu_cxx::stdio_sync_filebuf<char> mybuf_cout_sync(stdout);
    std::ostream os(&mybuf_cout_sync);
    os << "Hello world!
";
    return 0;
}

或者，为了便于移植，您可以编写自己的继承自 std::streambuf 的类，并自己从中构造 ostream。网上有很多例子，比如这里的https://stackoverflow.com/a/51250032/9072753。

Answer 2

编译器及其标准库实现可以使用非标准功能进行协作，这些功能仅由程序员无法使用。

在这种情况下这不是必需的，因为有一个非常标准的公共构造函数：

explicit basic_ostream(basic_streambuf<char_type, Traits>* sb);

如果你准备好了streambuf，你可以创建一个ostream类型的对象，标准库也可以。

streambuf 到底是什么是隐藏的实现细节，但在典型的实现中，它可能是从 stdout（C 风格的 <cstdio> 文件指针）构造的自定义类的对象。

Answer 3

我认为当前答案缺少的一部分，以及您的问题的一部分：
std::cout这个名字也很“神奇”。
这意味着标准库知道关于它，并提供特定于操作系统的必要连接到终端；使用相应的（和特定于操作系统的）系统调用进行输出等。