从 std::fstream 获取 FILE*

Question

有没有一种（跨平台）方法从 C++ std::fstream 获取 C FILE* 句柄？

我问的原因是因为我的 C++ 库接受 fstream，并且在一个特定函数中我想使用接受 FILE* 的 C 库。

Answer 1

简短的回答是否定的。

原因是，std::fstream 不需要使用 FILE* 作为其实现的一部分。因此，即使您设法从 std::fstream 对象中提取文件描述符并手动构建 FILE 对象，您也会遇到其他问题，因为现在有两个缓冲对象写入同一个文件描述符。

真正的问题是为什么要将 std::fstream 对象转换为 FILE* ？

虽然我不推荐，但您可以尝试查找 funopen()。
不幸的是，这不是一个 POSIX API（它是一个 BSD 扩展），因此它的可移植性是有问题的。这也可能是为什么我找不到任何人用这样的对象包装 std::stream 的原因。

FILE *funopen(
              const void *cookie,
              int    (*readfn )(void *, char *, int),
              int    (*writefn)(void *, const char *, int),
              fpos_t (*seekfn) (void *, fpos_t, int),
              int    (*closefn)(void *)
             );

这允许您构建一个 FILE 对象并指定一些将用于完成实际工作的函数。如果您编写适当的函数，您可以让它们从实际打开文件的 std::fstream 对象中读取。

Answer 2

没有一个标准化的方法。我认为这是因为 C++ 标准化小组不想假设文件句柄可以表示为 fd。

大多数平台似乎确实提供了一些非标准的方法来做到这一点。

http://www.ginac.de/~kreckel/fileno/ 提供了很好的文章情况并提供隐藏所有平台特定严重性的代码，至少对于 GCC 来说是这样。考虑到这在海湾合作委员会上是多么恶心，我想如果可能的话我会避免一起做这一切。

Answer 3

更新：请参阅@Jettatura，我认为这是最好的答案https://stackoverflow.com/a/33612982/225186< /a>（仅限 Linux？）。

原文：（

可能不是跨平台，但很简单）

简化 http://www.ginac 中的黑客攻击.de/~kreckel/fileno/ （dvorak 答案），并查看这个 gcc 扩展 http://gcc.gnu.org/onlinedocs/gcc-4.6.2/libstdc++/api/a00069.html#a59f78806603c619eafcd4537c920f859,
我有一个适用于 C++11 之前的 GCC （至少 4.8）和 clang （至少 3.3）的解决方案：

#include<fstream>
#include<ext/stdio_filebuf.h>

typedef std::basic_ofstream<char>::__filebuf_type buffer_t;
typedef __gnu_cxx::stdio_filebuf<char>            io_buffer_t; 
FILE* cfile_impl(buffer_t* const fb){
    return (static_cast<io_buffer_t* const>(fb))->file(); //type std::__c_file
}

FILE* cfile(std::ofstream const& ofs){return cfile_impl(ofs.rdbuf());}
FILE* cfile(std::ifstream const& ifs){return cfile_impl(ifs.rdbuf());}

并且可以使用这个，

int main(){
    std::ofstream ofs("file.txt");
    fprintf(cfile(ofs), "sample1");
    fflush(cfile(ofs)); // ofs << std::flush; doesn't help 
    ofs << "sample2\n";
}

注意： stdio_filebuf 未在较新版本的库中使用。 static_cast<>() 也有些危险。如果您得到的 nullptr 不是正确的类，请使用 dynamic_cast<>() 而不是。您可以尝试使用 stdio_sync_filebuf 来代替。该类的问题是 file() 根本不再可用。

限制：（欢迎评论）

1. 我发现在 fprintf 打印到 std::ofstream 后进行 fflush 很重要，否则上例中“sample2”将出现在“sample1”之前。我不知道是否有比使用 fflush 更好的解决方法。值得注意的是 ofs <<冲洗没有帮助。

2. 无法从std::stringstream中提取FILE*，我什至不知道是否可能。 （请参阅下面的更新）。

3. 我仍然不知道如何从 std::cerr 等中提取 C 的 stderr ，例如在 fprintf(stderr, "sample ")，在这样的假设代码中 fprintf(cfile(std::cerr), "sample")。

关于最后一个限制，我发现的唯一解决方法是添加这些重载：

FILE* cfile(std::ostream const& os){
    if(std::ofstream const* ofsP = dynamic_cast<std::ofstream const*>(&os)) return cfile(*ofsP);
    if(&os == &std::cerr) return stderr;
    if(&os == &std::cout) return stdout;
    if(&os == &std::clog) return stderr;
    if(dynamic_cast<std::ostringstream const*>(&os) != 0){
       throw std::runtime_error("don't know cannot extract FILE pointer from std::ostringstream");
    }
    return 0; // stream not recognized
}
FILE* cfile(std::istream const& is){
    if(std::ifstream const* ifsP = dynamic_cast<std::ifstream const*>(&is)) return cfile(*ifsP);
    if(&is == &std::cin) return stdin;
    if(dynamic_cast<std::ostringstream const*>(&is) != 0){
        throw std::runtime_error("don't know how to extract FILE pointer from std::istringstream");
    }
    return 0; // stream not recognized
}

尝试处理 iostringstream

可以使用 fscanf 从 < code>istream 使用 fmemopen，但是如果想将 C 读取和 C++ 读取结合起来，则需要在每次读取后进行大量簿记和更新流的输入位置。我无法将其转换为上面那样的 cfile 函数。 （也许在每次读取后不断更新的 cfile class 是可行的方法）。

// hack to access the protected member of istreambuf that know the current position
char* access_gptr(std::basic_streambuf<char, std::char_traits<char>>& bs){
    struct access_class : std::basic_streambuf<char, std::char_traits<char>>{
        char* access_gptr() const{return this->gptr();}
    };
    return ((access_class*)(&bs))->access_gptr();
}

int main(){
    std::istringstream iss("11 22 33");
    // read the C++ way
    int j1; iss >> j1;
    std::cout << j1 << std::endl;

    // read the C way
    float j2;
   
    char* buf = access_gptr(*iss.rdbuf()); // get current position
    size_t buf_size = iss.rdbuf()->in_avail(); // get remaining characters
    FILE* file = fmemopen(buf, buf_size, "r"); // open buffer memory as FILE*
    fscanf(file, "%f", &j2); // finally!
    iss.rdbuf()->pubseekoff(ftell(file), iss.cur, iss.in); // update input stream position from current FILE position.

    std::cout << "j2 = " << j2 << std::endl;

    // read again the C++ way
    int j3; iss >> j3;
    std::cout << "j3 = " << j3 << std::endl;
}

Answer 4

好吧，你可以获取文件描述符 - 我忘记了该方法是 fd() 还是 getfd()。 我使用的实现提供了这样的方法，但我相信语言标准不需要它们 - 标准不应该关心您的平台是否使用文件描述符。

从中，您可以使用fdopen(fd, mode) 获取 FILE*。

但是，我认为标准所需的同步 STDIN/cin、STDOUT/cout 和 STDERR/cerr 的机制不必对您可见。因此，如果您同时使用 fstream 和 FILE*，缓冲可能会让您陷入困境。

另外，如果 fstream 或 FILE 关闭，它们可能会关闭底层 fd，因此您需要确保在关闭之前刷新两者。

Answer 5

在 Linux 中执行此操作的另一种方法：

#include <stdio.h>
#include <cassert>

template<class STREAM>
struct STDIOAdapter
{
    static FILE* yield(STREAM* stream)
    {
        assert(stream != NULL);

        static cookie_io_functions_t Cookies =
        {
            .read  = NULL,
            .write = cookieWrite,
            .seek  = NULL,
            .close = cookieClose
        };

        return fopencookie(stream, "w", Cookies);
    }

    ssize_t static cookieWrite(void* cookie,
        const char* buf,
        size_t size)
    {
        if(cookie == NULL)
            return -1;

        STREAM* writer = static_cast <STREAM*>(cookie);

        writer->write(buf, size);

        return size;
    }

    int static cookieClose(void* cookie)
    {
         return EOF;
    }
}; // STDIOAdapter

用法，例如：

#include <boost/iostreams/filtering_stream.hpp>
#include <boost/iostreams/filter/bzip2.hpp>
#include <boost/iostreams/device/file.hpp>

using namespace boost::iostreams;

int main()
{   
    filtering_ostream out;
    out.push(boost::iostreams::bzip2_compressor());
    out.push(file_sink("my_file.txt"));

    FILE* fp = STDIOAdapter<filtering_ostream>::yield(&out);
    assert(fp > 0);

    fputs("Was up, Man", fp);

    fflush (fp);

    fclose(fp);

    return 1;
}

Answer 6

在单线程 POSIX 应用程序中，您可以轻松地以可移植的方式获取 fd 编号：

int fd = dup(0);
close(fd);
// POSIX requires the next opened file descriptor to be fd.
std::fstream file(...);
// now fd has been opened again and is owned by file

如果此代码与打开文件描述符的其他线程竞争，则此方法会在多线程应用程序中中断。

Answer 7

有一种方法可以从fstream获取文件描述符，然后将其转换为FILE*（通过fdopen）。就我个人而言，我认为 FILE* 没有任何必要，但是使用文件描述符，您可以做许多有趣的事情，例如重定向（dup2）。

解决方案：

#define private public
#define protected public
#include <fstream>
#undef private
#undef protected

std::ifstream file("some file");
auto fno = file._M_filebuf._M_file.fd();

最后一个字符串适用于 libstdc++。如果您使用其他库，则需要对其进行一些逆向工程。

这个技巧很肮脏，会暴露 fstream 的所有私有和公共成员。如果您想在生产代码中使用它，我建议您使用单个函数 int getFdFromFstream(std::basic_ios<字符>&fstr);。头文件不得包含 fstream。

Answer 8

当我遇到仅处理文件描述符的 istty() 时，我遇到了这个问题。

在较新版本的 C++ 标准库中（至少自 C++11 以来），alfC 提出的解决方案不再有效，因为一个类已更改为新类。

如果您使用非常旧版本的编译器，旧方法仍然有效。在较新的版本中，您需要使用std::basic_filebuf<>()。但这不适用于标准 I/O，例如 std::cout。对于这些，您需要使用 __gnu_cxx::stdio_sync_filebuf<>()。

我在 isatty()< 的实现中有一个功能示例/code>用于此处的 C++ 流。您应该能够删除该文件并在您自己的项目中重复使用它。不过，就您而言，您需要 FILE* 指针，因此只需返回该指针，而不是返回 ::isatty(fileno())。

这是模板函数的副本：

template<typename _CharT
       , typename _Traits = std::char_traits<_CharT>>
bool isatty(std::basic_ios<_CharT, _Traits> const & s)
{
    { // cin, cout, cerr, and clog
        typedef __gnu_cxx::stdio_sync_filebuf<_CharT, _Traits> io_sync_buffer_t;
        io_sync_buffer_t * buffer(dynamic_cast<io_sync_buffer_t *>(s.rdbuf()));
        if(buffer != nullptr)
        {
            return ::isatty(fileno(buffer->file()));
        }
    }

    { // modern versions
        typedef std::basic_filebuf<_CharT, _Traits> file_buffer_t;
        file_buffer_t * file_buffer(dynamic_cast<file_buffer_t *>(s.rdbuf()));
        if(file_buffer != nullptr)
        {
            typedef detail::our_basic_filebuf<_CharT, _Traits> hack_buffer_t;
            hack_buffer_t * buffer(static_cast<hack_buffer_t *>(file_buffer));
            if(buffer != nullptr)
            {
                return ::isatty(fileno(buffer->file()));
            }
        }
    }

    { // older versions
        typedef __gnu_cxx::stdio_filebuf<_CharT, _Traits> io_buffer_t;
        io_buffer_t * buffer(dynamic_cast<io_buffer_t *>(s.rdbuf()));
        if(buffer != nullptr)
        {
            return ::isatty(fileno(buffer->file()));
        }
    }

    return false;
}

现在，您应该问：但是那个详细信息类 our_basic_filebuf 是什么？！？

这是一个好问题。事实上，_M_file 指针受到保护，并且 std 中没有 file()（或 fd()）： :basic_filebuf。因此，我创建了一个 shell 类，它可以访问受保护的字段，这样我就可以返回 FILE* 指针。

template<typename _CharT
       , typename _Traits = std::char_traits<_CharT>>
class our_basic_filebuf
    : public std::basic_filebuf<_CharT, _Traits>
{
public:
    std::__c_file * file() throw()
    {
        return this->_M_file.file();
    }
};

这有点丑陋，但我能想到的最干净的方法是访问 _M_file 字段。

Answer 9

对 Alexis Wilke 想法的修改
它适用于我在 MSVC 2022 和 MSYS2 下

namespace detail {

#ifdef _WIN32
using handle_type = HANDLE;
#else
#define INVALID_HANDLE_VALUE (-1)
using handle_type = int;
#endif

template <
    typename _Elem,
    typename _Traits = std::char_traits<_Elem>
>
class basic_filebuf_hack :
#ifdef _MSC_VER
public std::basic_streambuf<_Elem, _Traits> {
public:
    using _Cvt  = std::codecvt<_Elem, char, typename _Traits::state_type>;

    const _Cvt * _Pcvt;
    _Elem        _Mychar;
    bool         _Wrotesome;
    typename _Traits::state_type _State;
    bool         _Closef;
    FILE       * _Myfile;
    _Elem      * _Set_eback;
    _Elem      * _Set_egptr;
    
    __forceinline
    auto file() throw() {
        return this->_Myfile;
    }
#else
public std::basic_filebuf<_Elem, _Traits> {
    auto file() throw() {
        return this->_M_file.file();
    }
#endif
};
static_assert(sizeof(std::basic_filebuf<char>) == sizeof(basic_filebuf_hack<char>), "sizes not same");

} // namespace detail

template <
    typename _CharT,
    typename _Traits = std::char_traits<_CharT>
>
detail::handle_type ios_fileno(const std::basic_ios<_CharT, _Traits> & s) {
    using file_buffer_t = std::basic_filebuf<_CharT, _Traits>;
    auto file_buffer = dynamic_cast<file_buffer_t *>(s.rdbuf());

    if (file_buffer != nullptr) {
        using hack_buffer_t = detail::basic_filebuf_hack<_CharT, _Traits>;
        auto buffer = reinterpret_cast<hack_buffer_t *>(file_buffer);

        if (buffer != nullptr) {
            auto file = buffer->file();

            if (file != nullptr) {
#ifdef _WIN32
                return detail::handle_type(_get_osfhandle(_fileno(file)));
#else
                return fileno(file);
#endif
            }
        }
    }

    return INVALID_HANDLE_VALUE;
}