Получение ФАЙЛА* из std::fstream
Вопрос
Есть ли (кросс-платформенный) способ получить дескриптор C FILE* из C++ std::fstream?
Причина, по которой я спрашиваю, заключается в том, что моя библиотека C++ принимает fstreams, и в одной конкретной функции я хотел бы использовать библиотеку C, которая принимает FILE*.
Решение
Короткий ответ - нет.
Причина в том, что 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
объект, у которого фактически открыт файл.
Другие советы
Не существует стандартизированного способа.Я предполагаю, что это связано с тем, что группа стандартизации C++ не хотела предполагать, что дескриптор файла может быть представлен как fd.
Большинство платформ, похоже, предоставляют какой-то нестандартный способ сделать это.
http://www.ginac.de/~kreckel/fileno/ обеспечивает хорошее описание ситуации и предоставляет код, который скрывает всю грубость, специфичную для платформы, по крайней мере, для GCC.Учитывая, насколько это отвратительно только для GCC, я думаю, что, если возможно, я бы избегал делать все это вместе.
ОБНОВЛЯТЬ:Посмотрите @Jettatura, я считаю, что это лучший ответ. https://stackoverflow.com/a/33612982/225186 (Только Linux?).
ОРИГИНАЛ:
(Вероятно, не кроссплатформенный, но простой)
Упрощение взлома http://www.ginac.de/~kreckel/fileno/ (ответ Дворжака) и глядя на это расширение gcc http://gcc.gnu.org/onlinedocs/gcc-4.6.2/libstdc++/api/a00069.html#a59f78806603c619eafcd4537c920f859, У меня есть это решение, которое работает на 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";
}
Ограничения: (комментарии приветствуются)
Я считаю, что важно
fflush
послеfprintf
печать наstd::ofstream
, иначе в приведенном выше примере «sample2» появится перед «sample1».Я не знаю, есть ли лучший обходной путь, чем использованиеfflush
.Примечательноofs << flush
не помогает.Невозможно извлечь ФАЙЛ* из
std::stringstream
, я даже не знаю, возможно ли это.(обновление см. ниже).Я до сих пор не знаю, как извлечь C
stderr
отstd::cerr
и т. д., например, для использования в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
от istream
с использованием fmemopen
, но это требует большого учета и обновления входной позиции потока после каждого чтения, если кто-то хочет объединить чтения C и C++.Я не смог преобразовать это в cfile
функционируйте, как указано выше.(Может быть, cfile
сорт который продолжает обновляться после каждого чтения, это правильный путь).
// 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;
}
Ну, вы можете получить дескриптор файла — я забыл, какой метод — fd() или getfd(). Реализации, которые я использовал, предоставляют такие методы, но я считаю, что стандарт языка не требует их - стандарт не должен заботиться о том, использует ли ваша платформа fd для файлов.
После этого вы можете использовать fdopen(fd, mode) для получения ФАЙЛА*.
Однако я думаю, что механизмы, которые стандарт требует для синхронизации STDIN/cin, STDOUT/cout и STDERR/cerr, не обязательно должны быть вам видны.Поэтому, если вы используете и fstream, и FILE*, буферизация может вас запутать.
Кроме того, если закрывается fstream ИЛИ ФАЙЛ, они, вероятно, закроют базовый fd, поэтому вам нужно убедиться, что вы очистили ОБА перед закрытием ЛИБО.
В однопоточном приложении 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
Этот метод дает сбой в многопоточном приложении, если этот код конкурирует с другими потоками, открывающими дескрипторы файлов.
еще один способ сделать это в 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;
}
Есть способ получить дескриптор файла из 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.Если вы хотите использовать его в своем производственном коде, я предлагаю вам создать отдельный .cpp
и .h
с одной функцией int getFdFromFstream(std::basic_ios<char>& fstr);
.Заголовочный файл не должен включать fstream.