Je recherche essentiellement une version C ++ de fdopen (). J'ai fait un peu de recherche à ce sujet et c'est une de ces choses qui semble devoir être facile, mais qui s'avère très compliquée. Est-ce que je manque quelque chose dans cette croyance (c'est-à-dire que c'est vraiment facile)? Sinon, y a-t-il une bonne bibliothèque quelque part pour gérer cela?

EDIT: J'ai déplacé mon exemple de solution vers une réponse distincte.

D'après la réponse d'Éric Malenfant:

AFAIK, il n'y a aucun moyen de le faire en C ++ standard. Selon votre plate-forme, votre implémentation de la bibliothèque standard peut offrir (en tant qu'extension non standard) un constructeur fstream prenant un descripteur de fichier en entrée. (C'est le cas de libstdc ++, IIRC) ou d'un FILE *.

Sur la base des observations ci-dessus et de mes recherches ci-dessous, il existe un code de travail en deux variantes; un pour libstdc ++ et un autre pour Microsoft Visual C ++.

libstdc ++

Il existe un __gnu_cxx::stdio_filebufmodèle de classe non standard qui hérite std::basic_streambufet 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 tampon de flux de fichiers à un descripteur de fichier POSIX ouvert.

Nous le créons en passant le handle POSIX (ligne 1) puis nous le passons au constructeur d'istream en tant que 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 y avait une version non standard du constructeur d'ifstream prenant le descripteur de fichier POSIX, mais il manque à la fois dans la documentation actuelle et dans le code. Il existe une autre version non standard du constructeur d'ifstream prenant FILE *

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

et ce n'est pas documenté (je n'ai même pas pu trouver de documentation ancienne où il serait présent). Nous l'appelons (ligne 1) avec le paramètre résultant de l'appel de _fdopen pour obtenir le flux C FILE * à partir du descripteur de fichier POSIX.

#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;
}

AFAIK, il n'y a aucun moyen de le faire en C ++ standard. En fonction de votre plateforme, votre implémentation de la bibliothèque standard peut proposer (en tant qu'extension non standard) un constructeur fstream prenant un descripteur de fichier (c'est le cas pour libstdc ++, IIRC) ou a FILE*en entrée.

Une autre alternative serait d'utiliser un périphérique boost :: iostreams :: file_descriptor , que vous pouvez envelopper dans un boost :: iostreams :: stream si vous voulez avoir une interface std :: stream.

Il y a de fortes chances que votre compilateur propose un constructeur fstream basé sur FILE, même s'il n'est pas standard. Par exemple:

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

Mais pour autant que je sache, il n'y a pas de moyen portable de le faire.

Une partie de la motivation originale (non déclarée) de cette question est d'avoir la possibilité de transmettre des données soit entre programmes, soit entre deux parties d'un programme de test en utilisant un fichier temporaire créé en toute sécurité, mais tmpnam () jette un avertissement dans gcc, donc je voulais pour utiliser mkstemp () à la place. Voici un programme de test que j'ai écrit sur la base de la réponse donnée par Éric Malenfant mais en utilisant mkstemp () au lieu de fdopen (); cela fonctionne sur mon système Ubuntu avec les bibliothèques Boost installées:

#include <stdlib.h>
#include <string.h>
#include <assert.h>
#include <string>
#include <iostream>
#include <boost/filesystem.hpp>
#include <boost/iostreams/device/file_descriptor.hpp>
#include <boost/iostreams/stream.hpp>

using boost::iostreams::stream;
using boost::iostreams::file_descriptor_sink;
using boost::filesystem::path;
using boost::filesystem::exists;
using boost::filesystem::status;
using boost::filesystem::remove;

int main(int argc, const char *argv[]) {
  char tmpTemplate[13];
  strncpy(tmpTemplate, "/tmp/XXXXXX", 13);
  stream<file_descriptor_sink> tmp(mkstemp(tmpTemplate));
  assert(tmp.is_open());
  tmp << "Hello mkstemp!" << std::endl;
  tmp.close();
  path tmpPath(tmpTemplate);
  if (exists(status(tmpPath))) {
    std::cout << "Output is in " << tmpPath.file_string() << std::endl;
    std::string cmd("cat ");
    cmd += tmpPath.file_string();
    system(cmd.c_str());
    std::cout << "Removing " << tmpPath.file_string() << std::endl;
    remove(tmpPath);
  }
}

C'est en fait assez simple. Nicolai M. Josuttis a publié fdstreamen conjonction avec son livre The C ++ Standard Library - A Tutorial and Reference . Vous pouvez trouver l'implémentation de 184 lignes ici .

J'ai essayé la solution proposée ci-dessus pour libstdc ++ par Piotr Dobrogost, et j'ai trouvé qu'elle avait un défaut douloureux: en raison de l'absence d'un constructeur de mouvement approprié pour istream, il est très difficile d'extraire l'objet istream nouvellement construit de la fonction de création . Un autre problème avec celui-ci est qu'il fuit un objet FILE (même si ce n'est pas le descripteur de fichier posix sous-jacent). Voici une solution alternative qui évite 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 une utilisation potentielle. Notez également que l'exemple utilise static_assert et utilise qui sont C ++ 11, à part cela, il devrait très bien se construire en mode C ++ 03.

Je crois comprendre qu'il n'y a aucune association avec des pointeurs FILE ou des descripteurs de fichier dans le modèle d'objet C ++ iostream afin de garder le code portable.

Cela dit, j'ai vu plusieurs endroits faire référence aux mds-utils ou boost pour aider à combler cet écart.