I m trying to use boost::filesystem to copy files and folders (just like a standard copy a folder and paste it in windows explorer).

Although I ve been to the boost::filesystem documentation, I still don t really know how to go about doing this.

Do you have to recursively go though each directory (creating it) and find each file copying it?

Additionally, how do you copy the file in C++/Boost?

P.S. I m using Boost 1.40.0

Update I think I may have ended up creating an answer to this one, only concern being that I don t do any try-catch errors to check for locked files and folders.

The following code makes a copy of a directory in the relative path "../example/ecomm" and duplicates it to a non-existing path "../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...
}

My question now is what I m I forgetting to do in regards to locked files and directories?