Comment créer un répertoire temporaire en C++?

La Version 3 de Stimuler le système de fichier de la Bibliothèque fournit la fonction unique_path() pour générer un nom de chemin d'accès approprié pour la création d'un fichier temporaire ou d'un répertoire.

using namespace boost::filesystem;

path ph = unique_path();
create_directories(ph);

C++17 std::filesystem::temp_directory_path + de génération de nombre aléatoire

Ici est un pur C++17 qui pourrait être fiable: pas de Boost ou d'autres bibliothèques externes et pas de mkdtemp qui est POSIX.

Nous venons de passer en boucle des nombres aléatoires jusqu'à ce que nous sommes en mesure de créer un répertoire qui n'existaient pas avant à l'intérieur de std::filesystem::temp_directory_path (/tmp dans Ubuntu 18.04).

On peut alors supprimer explicitement le répertoire créé avec std::filesystem::remove_all fois que nous avons fini avec elle.

Je ne suis pas sûr que la norme C++ ne le garantit, mais est extrêmement probable que std::filesystem::temp_directory_path appels mkdir, qui atomiquement essaie de créer le répertoire et si il ne peut pas ne parvient pas à EEXIST, donc je ne pense pas qu'il peut y avoir des conditions de course à travers parallèle appelants.

main.cpp

#include <exception>
#include <fstream>
#include <iostream>
#include <random>
#include <sstream>

#include <filesystem>

std::filesystem::path create_temporary_directory(
      unsigned long long max_tries = 1000) {
    auto tmp_dir = std::filesystem::temp_directory_path();
    unsigned long long i = 0;
    std::random_device dev;
    std::mt19937 prng(dev());
    std::uniform_int_distribution<uint64_t> rand(0);
    std::filesystem::path path;
    while (true) {
        std::stringstream ss;
        ss << std::hex << rand(prng);
        path = tmp_dir / ss.str();
        //true if the directory was created.
        if (std::filesystem::create_directory(path)) {
            break;
        }
        if (i == max_tries) {
            throw std::runtime_error("could not find non-existing directory");
        }
        i++;
    }
    return path;
}

int main() {
    auto tmpdir = create_temporary_directory();
    std::cout << "create_temporary_directory() = "
              << tmpdir
              << std::endl;

    //Use our temporary directory: create a file
    //in it and write to it.
    std::ofstream ofs(tmpdir / "myfile");
    ofs << "asdf\nqwer\n";
    ofs.close();

    //Remove the directory and its contents.
    std::filesystem::remove_all(tmpdir);
}

GitHub en amont.

Compiler et exécuter:

g++-8 -std=c++17 -Wall -Wextra -pedantic -o main.out main.cpp -lstdc++fs
./main.out 

Exemple de sortie:

_directory.out
temp_directory_path() = "/tmp"
create_temporary_directory() = "/tmp/106adc08ff89874c"

Pour les fichiers, voir: Comment créer un fichier texte temporaire en C++? les Fichiers sont un peu différent parce que open dans Linux a la O_TMPFILE, qui crée un anonyme inode qui disparaît automatiquement sur fermer ainsi consacré fichier temporaire Api peuvent être plus efficaces grâce à l'aide que. Il n'y a pas d'analogue drapeau pour mkdir cependant, cette solution pourrait être optimale.

Testé sur Ubuntu, 18.04.

Il n'y a pas de fonction standard pour ce faire, vous aurez besoin de compiler les différentes implémentations pour chaque plate-forme cible.

Sur Windows, par exemple, vous devez utiliser le répertoire temp, qui peut être obtenu par un appel à GetTempPath().