Como faço para copiar arquivos e pastas usando o impulso e Visual Studio 2005?

Question

Eu estou tentando usar boost :: filesystem para copiar arquivos e pastas (apenas como um padrão de copiar uma pasta e colá-lo no Windows Explorer).

Embora eu fui para o impulso: : sistema de arquivos de documentação , eu ainda realmente não sei como ir sobre fazer isto.

Você tem que ir de forma recursiva que cada diretório (criá-la) e encontrar cada arquivo copiá-lo?

Além disso, como é que você copie o arquivo em C ++ / impulso?

P.S. Estou usando impulso 1.40.0

Atualizar Eu acho que pode ter acabou criando uma resposta a esta, a única preocupação é que eu não faço quaisquer erros try-catch para verificar arquivos e pastas bloqueadas.

O código a seguir faz uma cópia de um diretório no caminho relativo "../example/ecomm" e duplica-lo para um caminho não existente "../ example / dup_ecomm":

#include <boost/test/unit_test.hpp>
#include <boost/algorithm/string.hpp>
#include <boost/filesystem/operations.hpp>
#include <boost/regex.hpp>
#include <iostream>
#include <fstream>
#include<string>

bool copy_dir( const boost::filesystem::path & ext_dir_path,         // the existing directory
               const boost::filesystem::path & duplicate_dir_path    // the duplicate directory
             )
{
  std::cout << "BEGIN: copy_dir " << endl;
  std::cout << "- ext_dir_path: " << ext_dir_path << endl;
  std::cout << "- duplicate_dir_path: " << duplicate_dir_path << endl;

  // 1. Ensure that the directory we are trying to copy exists.
  if (!boost::filesystem::exists( ext_dir_path ) ) return false;

  bool createdDir = boost::filesystem::create_directory( duplicate_dir_path );

  // cout << "createdDir: " << createdDir << endl;


  copy_dir(ext_dir_path,         // the existing directory
           duplicate_dir_path,   // the duplicate directory,
           ext_dir_path,    // the base path for the existing directory
           duplicate_dir_path,
           true);

  std::cout << "END: copy_dir " << endl;
}


bool copy_dir( const boost::filesystem::path & ext_dir_path,         // the existing directory
               const boost::filesystem::path & duplicate_dir_path,   // the duplicate directory,
               const boost::filesystem::path & base_ext_dir_path,    // the base path for the existing directory
               const boost::filesystem::path & base_duplicate_dir_path, // the base path for the duplicate of the exisiting directory
               bool isRootPath)
{
  // Debug input arguments
  std::cout << "BEGIN: copy_dir " << endl;
  std::cout << "- ext_dir_path: " << ext_dir_path << endl;
  std::cout << "- duplicate_dir_path: " << duplicate_dir_path << endl;
  std::cout << "- base_ext_dir_path: " << base_ext_dir_path << endl;
  std::cout << "- base_duplicate_dir_path: " << base_duplicate_dir_path << endl;
  std::cout << "- isRootPath: " << isRootPath << endl;

  boost::filesystem::directory_iterator end_itr; // default construction yields past-the-end

  cout << "--Beginning itr loop" << endl;
  for ( boost::filesystem::directory_iterator itr( ext_dir_path );
        itr != end_itr;
        ++itr )
  {

    if ( boost::filesystem::is_directory(itr->status()) )
    {
     cout << "---itr->path(): " << itr->path() << endl;


     boost::filesystem::path newExtDir(itr->path());

     string dup_path = itr->path().string();
     boost::algorithm::replace_first(dup_path, base_ext_dir_path.string(), base_duplicate_dir_path.string());
     cout << "dup_path: " << dup_path << endl;

     boost::filesystem::path new_dup_dir(dup_path);

     bool createdDir = boost::filesystem::create_directory( new_dup_dir );

     cout << "creating directory " << dup_path << " created: " << createdDir << endl;

     boost::filesystem::path newDuplicateDir(duplicate_dir_path);

     copy_dir(newExtDir,         // the existing directory
          newDuplicateDir,   // the duplicate directory,
          base_ext_dir_path,
          base_duplicate_dir_path,
          false);
    }
    else 
    {
            cout << "---isLeaf: " << itr->path() << endl;

        string dup_path = itr->path().string();

        boost::algorithm::replace_first(dup_path, base_ext_dir_path.string(), base_duplicate_dir_path.string());

        string src_path = itr->path().string();

        cout << "src_path: " << src_path << endl;
        cout << "dup_path: " << dup_path << endl;

        boost::filesystem::path s_path(src_path);
        boost::filesystem::path d_path(dup_path);

        boost::filesystem::copy_file(s_path, d_path);
    }

  }
  std::cout << "--Ending itr loop" << endl;


  std::cout << "END: copy_dir " << endl;

  return false;
}

test_suite*
init_unit_test_suite( int, char* [] ) {

    boost::filesystem::path ext_dir("..\\example\\ecomm");
    boost::filesystem::path dir_dup("..\\example\\dup_ecomm");

    copy_dir(ext_dir,
             dir_dup);   // the duplicate directory,

        // ... unit tests...etc...
}

A minha pergunta agora é o que eu sou eu esquecer de fazer em relação a arquivos bloqueados e diretórios?

Answer 1

boost :: filesystem :: recursive_directory_iterator