Comment puis-je copier un répertoire à l'aide de Boost système de fichiers

Comment puis-je copier un répertoire à l'aide de Boost système de fichiers?
J'ai essayé de boost::filesystem::copy_directory (), mais qui ne crée que le répertoire cible et de ne pas copier le contenu.

  • boost::filesystem::copie de la copie des répertoires ou des fichiers comme. Vous pouvez écrire un algorithme récursif qui copie les répertoires et fichiers dans l'aide que.
  • Ah. Je vous remercie. Je suis surprise que ce n'est pas une partie de boost::filesystem. Aussi, je ne pouvais pas trouver toute la documentation de la bibliothèque Boost site qui le dit en anglais que la fonction copy_directory la réalité.
InformationsquelleAutor Ant | 2011-12-21
  1. 44
    bool copyDir(
boost::filesystem::path const & source,
boost::filesystem::path const & destination
)
{
namespace fs = boost::filesystem;
try
{
//Check whether the function call is valid
if(
!fs::exists(source) ||
!fs::is_directory(source)
)
{
std::cerr << "Source directory " << source.string()
<< " does not exist or is not a directory." << '\n'
;
return false;
}
if(fs::exists(destination))
{
std::cerr << "Destination directory " << destination.string()
<< " already exists." << '\n'
;
return false;
}
//Create the destination directory
if(!fs::create_directory(destination))
{
std::cerr << "Unable to create destination directory"
<< destination.string() << '\n'
;
return false;
}
}
catch(fs::filesystem_error const & e)
{
std::cerr << e.what() << '\n';
return false;
}
//Iterate through the source directory
for(
fs::directory_iterator file(source);
file != fs::directory_iterator(); ++file
)
{
try
{
fs::path current(file->path());
if(fs::is_directory(current))
{
//Found directory: Recursion
if(
!copyDir(
current,
destination / current.filename()
)
)
{
return false;
}
}
else
{
//Found file: Copy
fs::copy_file(
current,
destination / current.filename()
);
}
}
catch(fs::filesystem_error const & e)
{
std:: cerr << e.what() << '\n';
}
}
return true;
}

    Utilisation:

    copyDir(boost::filesystem::path("/home/nijansen/test"), boost::filesystem::path("/home/nijansen/test_copy")); (Unix)

    copyDir(boost::filesystem::path("C:\\Users\\nijansen\\test"), boost::filesystem::path("C:\\Users\\nijansen\\test2")); (Windows)

    Autant que je le vois, le pire qui peut arriver c'est que rien ne se passe, mais je ne promets rien! Utilisez à vos propres risques.

    Veuillez noter que le répertoire que vous effectuez la copie ne doit pas exister. Si les répertoires dans le répertoire que vous essayez de copie ne peut pas être lu (pensez à la gestion des droits), ils seront ignorés, mais les autres doivent encore être copiés.

    Mise à jour

    Refait la fonction respective pour les commentaires. En outre, la fonction renvoie un résultat réussi. Il sera de retour false si les exigences pour les répertoires ou n'importe quel répertoire dans le répertoire source ne sont pas remplies, mais pas si un seul fichier ne peut pas être copié.

    • Si vous utilisez C++ vous devez utiliser std::cerr au lieu de fprintf et stderr. Et aussi, car c'est coup de pouce.Système de fichiers, vous devez utiliser boost::path au lieu de std::string.
    • Merci pour les suggestions, j'ai amélioré la fonction en conséquence.
    • Notez que vous devez toujours être prudent de ce que vous êtes en copie où. Si vous avez exécuté copyDir(boost::filesystem::path("."), boost::filesystem::path("test")), il se copie lui-même jusqu'à ce qu'il soit résilié en raison de la longueur de chemin d'accès dépasse la limite, ou vous manquez d'espace disque.
    • Merci beaucoup nijansen, qui s'intègre très bien dans ce que je fais. Je suis de la copie d'un très bien définis et connus dossier vers un autre emplacement, donc je n'ai pas besoin de vous préoccuper des cas particuliers. Je suis toujours surpris de voir que copy_directory ne pas copier le contenu ou au moins avoir une option pour copier le contenu.
    • Au lieu de faire dest.chaîne de caractères() + "/" vous devez utiliser l'opérateur/. dest / courant.filename()
    • nice tipp, arsenm. ne savais pas à propos de l'opérateur/, fonctionne même avec une chaîne de caractères comme deuxième argument. le rend beaucoup plus lisible!

    InformationsquelleAutor nijansen
  2. 13

    Depuis C++17 vous n'avez pas besoin de coup de pouce pour cette opération en tant que système de fichiers a été ajouté à la norme.

    Utilisation std::filesystem::copie

    #include <exception>
#include <filesystem>
namespace fs = std::filesystem;
int main()
{
fs::path source = "path/to/source/folder";
fs::path target = "path/to/target/folder";
try {
fs::copy(source, target, fs::copy_options::recursive);
}
catch (std::exception& e) { //Not using fs::filesystem_error since std::bad_alloc can throw too.
//Handle exception or use error code overload of fs::copy.
}
}

    Voir aussi std::filesystem::copy_options.

    • Merci beaucoup Ri. J'espère que les visiteurs de l'avis de votre réponse.
    • Note ce a été ajouté à la norme ISO C++ en C++ 17.
    InformationsquelleAutor Roi Danton
  3. 11

    Je vois cette version comme une version améliorée de @nijansen de réponse. Il prend également en charge la source et/ou destination répertoires relatif.

    namespace fs = boost::filesystem;
void copyDirectoryRecursively(const fs::path& sourceDir, const fs::path& destinationDir)
{
if (!fs::exists(sourceDir) || !fs::is_directory(sourceDir))
{
throw std::runtime_error("Source directory " + sourceDir.string() + " does not exist or is not a directory");
}
if (fs::exists(destinationDir))
{
throw std::runtime_error("Destination directory " + destinationDir.string() + " already exists");
}
if (!fs::create_directory(destinationDir))
{
throw std::runtime_error("Cannot create destination directory " + destinationDir.string());
}
for (const auto& dirEnt : fs::recursive_directory_iterator{sourceDir})
{
const auto& path = dirEnt.path();
auto relativePathStr = path.string();
boost::replace_first(relativePathStr, sourceDir.string(), "");
fs::copy(path, destinationDir / relativePathStr);
}
}

    Les principales différences sont les exceptions à la place des valeurs de retour, l'utilisation de recursive_directory_iterator et boost::replace_first à la bande de la partie courante de l'itérateur chemin, et en s'appuyant sur boost::filesystem::copy() de faire la bonne chose avec différents types de fichiers (en conservant les liens symboliques, par exemple).

    • +1 pour préférant exceptions booléenne valeurs de retour. Aussi, relativePathStr peut être calculée à l'aide de chemin.lexically_relative(sourceDir), qui peut être plus simple à lire que boost::replace_first.
    InformationsquelleAutor Doineann
  4. 0

    C'est un non-Boost version que je suis en utilisant basé sur Doineann du code. Je suis en utilisant std::système de fichiers, mais ne pouvait pas utiliser un simple fs::copy(src, dst, fs::copy_options::recursive); parce que j'ai voulu filtrer les fichiers qui sont copiés par une extension de fichier à l'intérieur de la boucle.

    void CopyRecursive(fs::path src, fs::path dst)
{
//Loop through all the dirs
for (auto dir : fs::recursive_directory_iterator(src))
{
//copy the path's string to store relative path string
std::wstring relstr = dir.path().wstring();
//remove the substring matching the src path
//this leaves only the relative path
relstr.erase(0, std::wstring(src).size());
//combine the destination root path with relative path
fs::path newFullPath = dst / relstr;
//Create dir if it's a dir
if (fs::is_directory(newFullPath))
{
fs::create_directory(newFullPath);
}
//copy the files
fs::copy(dir.path(), newFullPath, fs::copy_options::recursive | fs::copy_options::overwrite_existing);
}
}

    relstr.erase(0, std::wstring(src).size()); est un coup de pouce en moins de remplacement pour le boost::replace_first() appel dans l'autre réponse

    InformationsquelleAutor GuidedHacking