Comment construire une c++ fstream à partir d'une POSIX descripteur de fichier?

À partir de la réponse donnée par Éric Malenfant:

Autant que je sache, il n'y a aucun moyen de le faire dans
standard C++. En fonction de votre
plate-forme, votre mise en œuvre de la
la bibliothèque standard peut vous offrir (comme un
non standard extension) un fstream
constructeur prenant un descripteur de fichier
comme entrée. (C'est le cas pour
libstdc++, IIRC) ou un FICHIER*.

Basée sur des observations ci-dessus et ma recherche ci-dessous il y a du code qui fonctionne dans les deux variantes, l'une pour libstdc++ et Microsoft Visual C++.

---

libstdc++

Il y a non-standard __gnu_cxx::stdio_filebuf modèle de classe qui hérite de std::basic_streambuf et a le constructeur suivant

stdio_filebuf (int __fd, std::ios_base::openmode __mode, size_t __size=static_cast< size_t >(BUFSIZ)) 

avec description Ce constructeur associe un fichier de la mémoire tampon avec un POSIX descripteur de fichier.

Nous créons en passant POSIX poignée (ligne 1) et ensuite on passe à istream du constructeur comme basic_streambuf (ligne 2):

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

using namespace std;

int main()
{
    ofstream ofs("test.txt");
    ofs << "Writing to a basic_ofstream object..." << endl;
    ofs.close();

    int posix_handle = fileno(::fopen("test.txt", "r"));

    __gnu_cxx::stdio_filebuf<char> filebuf(posix_handle, std::ios::in); //1
    istream is(&filebuf); //2

    string line;
    getline(is, line);
    cout << "line: " << line << std::endl;
    return 0;
}

---

Microsoft Visual C++

Il utilisé pour être non-standard version de ifstream du constructeur prenant POSIX descripteur de fichier, mais il manque à la fois de actuel docs et de code. Il y a un autre non-standard de la version de ifstream du constructeur prenant FICHIER*

explicit basic_ifstream(_Filet *_File)
    : _Mybase(&_Filebuffer),
        _Filebuffer(_File)
    {   //construct with specified C stream
    }

et il n'est pas documenté (je ne pouvais même pas trouver tout les vieux de la documentation où il serait présent). Nous appelons (ligne 1) avec le paramètre étant le résultat de l'appel d' _fdopen pour obtenir C FICHIER de flux* de POSIX descripteur de fichier.

#include <cstdio>
#include <iostream>
#include <fstream>
#include <string>

using namespace std;

int main()
{
    ofstream ofs("test.txt");
    ofs << "Writing to a basic_ofstream object..." << endl;
    ofs.close();

    int posix_handle = ::_fileno(::fopen("test.txt", "r"));

    ifstream ifs(::_fdopen(posix_handle, "r")); //1

    string line;
    getline(ifs, line);
    ifs.close();
    cout << "line: " << line << endl;
    return 0;
}

Il ya une bonne chance que votre compilateur propose un FICHIER de la base de fstream constructeur, même si c'est non standard. Par exemple:

FILE* f = fdopen(my_fd, "a");
std::fstream fstr(f);
fstr << "Greetings\n";

Mais autant que je sache, il n'y a pas de portable façon de le faire.

J'ai essayé la solution proposée ci-dessus pour libstdc++ par Piotr Dobrogost, et a trouvé qu'elle avait une faille douloureuse: en Raison de l'absence d'un bon constructeur de déplacement pour istream, il est très difficile d'obtenir le nouvellement construit istream objet de la création de la fonction. Un autre problème avec lui c'est qu'il fuit un FICHIER objet (même pensé ne pas le sous-jacent posix descripteur de fichier). Voici une autre solution qui permet d'éviter ces problèmes:

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

bool OpenFileForSequentialInput(ifstream& ifs, const string& fname)
{
    ifs.open(fname.c_str(), ios::in);
    if (! ifs.is_open()) {
        return false;
    }

    using FilebufType = __gnu_cxx::stdio_filebuf<std::ifstream::char_type>;
    static_assert(  std::is_base_of<ifstream::__filebuf_type, FilebufType>::value &&
                    (sizeof(FilebufType) == sizeof(ifstream::__filebuf_type)),
            "The filebuf type appears to have extra data members, the cast might be unsafe");

    const int fd = static_cast<FilebufType*>(ifs.rdbuf())->fd();
    assert(fd >= 0);
    if (0 != posix_fadvise(fd, 0, 0, POSIX_FADV_SEQUENTIAL)) {
        ifs.close();
        return false;
    }

    return true;
}

L'appel à posix_fadvise() démontre un potentiel d'utilisation. Notez également que l'exemple utilise static_assert et à l'aide de qui sont C++ 11, autre que celui qu'il doit construire l'amende juste en C++ 03 mode.

Ma compréhension est qu'il n'y a pas d'association avec les pointeurs de FICHIERS ou des descripteurs de fichiers en C++ iostream modèle d'objet afin de garder le code portable.

Cela dit, j'ai vu plusieurs endroits, reportez-vous à la mds-utils ou coup de pouce pour aider à combler cette lacune.