Boost filessystem...

CMakeList.txt:

 cmake_minimum_required(VERSION 3.8)

 project(Demo)

 set(CMAKE_CXX_STANDARD )

 set(SOURCE_FILES main.cpp)

 //需要添加filesystem组件

 find_package(Boost REQUIRED COMPONENTS system filesystem)

 if (Boost_FOUND)

     INCLUDE_DIRECTORIES(${Boost_INCLUDE_DIRS})

     add_executable(Demo ${SOURCE_FILES})

     target_link_libraries(Demo ${Boost_LIBRARIES})

 endif ()

 find_package(Boost REQUIRED COMPONENTS system)

boost::filesystem

boost::filesystem库的核心类是path类,他屏蔽了不同文件系统的差异,使用了可移植的POSIX语法提供了通用的目录和路径表示,并且支持POSIX的符号链接

boost::filesystem::path

path的构造函数可接受char*类型和string类型的参数构造，也可以是一个字符串迭代范围,路径的分割符由constexpr preferred_separator定义,UNIX是正斜杠(/),WINDOWS是反斜杠(\),C++中需要转义;

path使用的是POSIX语法标准,使用正斜杠(/)来分割目录,(./)代表当前路径,(..)代表当前目录上层;

path类中基本实现了大部分文件属性操作，具体查看官方文档,以下只做了少部分测试

基本方法:

 #include <iostream>

 #include <boost/filesystem.hpp>

 int

 main(int argc, char **argv)

 {

     //因为文件属于程序外的不可控资源，随时抛出异常,try{}catch处理

     try

     {

         //unix

         boost::filesystem::path path1("./Demo/Demo.txt");

         //windows

         boost::filesystem::path path2("C:\\Boost\\Demo\\include\\");

         //空路径,可用empty()判断

         boost::filesystem::path path3;

         assert(path3.empty());

         //path构造时不会检查路径的合法性(可使用函数判断)

         boost::filesystem::path path4("asdwqdqdasd");

         boost::filesystem::path path5("/usr/local/include/");

         auto path6 = path5 / "boost/filesystem/";                    //path重载了operator/()方法可追加路径

         std::cout << path6 << std::endl;                             //path重载operator<<方法输出

         std::cout << path6.string() << std::endl;                    //返回string的方法,可用于C++中的fstream

         std::cout << path6.parent_path() << std::endl; //父路径

         std::cout << path6.filename() << std::endl; //文件

         std::cout << path6.stem() << std::endl; //不带扩展名的文件名

         std::cout << path6.extension() << std::endl; //扩展名

         //唯一两个可修改路径函数

         path6.replace_extension("ini");     //修改文件后缀名

         std::cout << path6 << std::endl;                    //"/usr/local/include/boost/filesystem/.ini"

         path6.remove_filename();            //移除文件名

         std::cout << path6 << std::endl;                    //"/usr/local/include/boost/filesystem"

         //path中有begin 和 end 迭代器，可以循环得出目录名

         for (auto &iter:path6)

         {

             std::cout << "[" << iter << "]" << std::endl;

         }

         /*["/"]

           ["usr"]

           ["local"]

           ["include"]

           ["boost"]

           ["filesystem"]*/

         ////                                     file_type                                        //

 ////--------------------------------------------------------------------------------------//

 //

 //        enum file_type

 //        {

 //            status_error,

 //#   ifndef BOOST_FILESYSTEM_NO_DEPRECATED

 //            status_unknown = status_error,

 //#   endif

 //            file_not_found,

 //            regular_file,

 //            directory_file,

 //            // the following may not apply to some operating systems or file systems

 //                    symlink_file,

 //            block_file,

 //            character_file,

 //            fifo_file,

 //            socket_file,

 //            reparse_file,  // Windows: FILE_ATTRIBUTE_REPARSE_POINT that is not a symlink

 //            type_unknown,  // file does exist, but isn't one of the above types or

 //            // we don't have strong enough permission to find its type

 //

 //            _detail_directory_symlink  // internal use only; never exposed to users

 //        };

         std::cout << boost::filesystem::status(path6).type() << std::endl;              //文件类型

         std::cout << boost::filesystem::symlink_status(path6).type() << std::endl;

         std::cout << boost::filesystem::directory_file << std::endl;

         std::cout << boost::filesystem::status(path6).permissions() << std::endl;      //文件的权限等级

     }

     catch (boost::filesystem::filesystem_error &e)

     {

         std::cout << e.path1() << std::endl;

         std::cout << e.path2() << std::endl;

         std::cout << e.what() << std::endl;

     }

     return ;

 }

查看磁盘和当前路径,修改文件时间(linux::touch)

 #include <iostream>

 #include <boost/filesystem.hpp>

 #include <boost/ratio.hpp>

 int

 main()

 {

     //因为文件属于程序外的不可控资源，随时抛出异常,try{}catch处理

     try

     {

         boost::filesystem::path path("/Users/xuaidong/Desktop/test.txt");

         boost::filesystem::path path1("/Users/xuaidong");

         //进入(程序启动时)main函数时的路径

         std::cout << boost::filesystem::initial_path() << std::endl;

         //返回当前路径，和initial_path()都是返回绝对路径(完整路径)

         std::cout << boost::filesystem::current_path() << std::endl;

         assert(boost::filesystem::is_regular_file(path));

         //返回文件最后一次修改时间

         std::cout << boost::filesystem::last_write_time(path) << std::endl;

         //更改文件修改时间(linux touch)

         boost::filesystem::last_write_time(path, time());

         std::cout << boost::filesystem::last_write_time(path) << std::endl;

         //查看磁盘空间

         boost::filesystem::space_info sp = boost::filesystem::space(path);

         std::cout << "磁盘空间: " << sp.capacity / boost::giga::num << std::endl;

         std::cout << "磁盘可用空间: " << sp.free / boost::giga::num << std::endl;

         std::cout << "磁盘可用空间: " << sp.available / boost::giga::num << std::endl;

         std::cout << boost::filesystem::file_size(path) << std::endl;

     }

     catch (boost::filesystem::filesystem_error &e)

     {

         std::cout << e.path1() << std::endl;

         std::cout << e.path2() << std::endl;

         std::cout << e.what() << std::endl;

     }

     return ;

 }

 #include <iostream>

 #include <boost/filesystem.hpp>

 #include <boost/ratio.hpp>

 int

 main(int argc, char **argv)

 {

     //因为文件属于程序外的不可控资源，随时抛出异常,try{}catch处理

     try

     {

         boost::filesystem::path path("/Users/xuaidong/Desktop/ABABAB");

         //assert(boost::filesystem::is_regular_file(path));

         assert(boost::filesystem::is_directory(path));

         //删除空目录/文件

         //boost::filesystem::remove(path);

         //递归删除多个目录或者文件

         boost::filesystem::remove_all(path);

         //根据path创建一个目录

         boost::filesystem::create_directories(path);

         assert(boost::filesystem::exists(path));

         //拷贝文件到这个目录下

         boost::filesystem::copy_file("/Users/xuaidong/Desktop/Some.txt", path / "Some2.txt");

         //重命名

         boost::filesystem::rename(path/"Some2.txt",path/"Demo.txt");

         //创建多及目录

         boost::filesystem::create_directories(path/"Director1"/"Director2"/"Director3");

     }

     catch (boost::filesystem::filesystem_error &e)

     {

         std::cout << e.path1() << std::endl;

         std::cout << e.path2() << std::endl;

         std::cout << e.what() << std::endl;

     }

     return ;

 }

使用boost::filesystem::director_iterator迭代当前目录下文件(不向下层目录迭代),但是也可实现目录下层目录循环递归,其实boost也提供了boost::filesystem::recursive_directory_iterator向下递归而且遍历目录是可控制的(深度/浅度),且速度比递归的director_itertaor快

 #include <iostream>

 #include <boost/filesystem.hpp>

 #include <boost/ratio.hpp>

 void resource_direction(const boost::filesystem::path& path)

 {

     //递归文件目录下的所有文件路径

     boost::filesystem::directory_iterator end;

     for(boost::filesystem::directory_iterator begin(path);begin!=end;begin++)

     {

         //如果是目录继续向下解析

         if (boost::filesystem::is_directory(*begin))

             resource_direction(*begin);

         else

             std::cout<<*begin<<std::endl;

     }

 }

 int

 main(int argc, char **argv)

 {

     //因为文件属于程序外的不可控资源，随时抛出异常,try{}catch处理

     try

     {

         boost::filesystem::path path("/Users/xuaidong/Desktop/");

         resource_direction(path);

     }

     catch (boost::filesystem::filesystem_error &e)

     {

         std::cout << e.path1() << std::endl;

         std::cout << e.path2() << std::endl;

         std::cout << e.what() << std::endl;

     }

     return ;

 }

 //系统提供的文件目录遍历

 #include <iostream>

 #include <boost/filesystem.hpp>

 #include <boost/ratio.hpp>

 #include <map>

 #include <vector>

 #include <string>

 #include <memory>

 int

 main(int argc, char **argv)

 {

     //因为文件属于程序外的不可控资源，随时抛出异常,try{}catch处理

     try

     {

         std::map<int64_t, std::shared_ptr<std::vector<std::string>>> dir_map;

         //boost深度遍历目录和浅度遍历

         //默认构造是尾迭代器

         boost::filesystem::recursive_directory_iterator end;

         for (boost::filesystem::recursive_directory_iterator iter("/Users/xuaidong/Desktop"); iter != end; iter++)

         {

             //std::cout << "directory_level: " << iter.level() << "file path: " << *iter << std::endl;

             if (boost::filesystem::is_directory(*iter))

             {

                 iter.no_push();

             }             //不深度便利

             //iter.pop() 退出当前目录的遍历

             auto &ptr = dir_map[iter.level()];

             if (!ptr)

                 ptr.reset(new std::vector<std::string>);

             ptr->push_back(iter->path().string());

         }

         for (auto &iter1:dir_map)

         {

             for (auto &iter2:*(iter1.second))

             {

                 std::cout << "directory_level: " << iter1.first << "， file path: " << iter2 << std::endl;

             }

         }

     }

     catch (boost::filesystem::filesystem_error &e)

     {

         std::cout << e.path1() << std::endl;

         std::cout << e.path2() << std::endl;

         std::cout << e.what() << std::endl;

     }

     return ;

 }

实例1:实现简单文件查找

 #include <iostream>

 #include <boost/filesystem.hpp>

 #include <boost/ratio.hpp>

 #include <boost/optional.hpp>

 //boost filesystem realize find file

 boost::optional<boost::filesystem::path> find_file(const boost::filesystem::path& path,const std::string& file)

 {

     typedef boost::optional<boost::filesystem::path> result_value;

     if (!boost::filesystem::exists(path)&&!boost::filesystem::is_directory(path))

         return result_value();

     //递归目录查找

     boost::filesystem::recursive_directory_iterator end;

     for(boost::filesystem::recursive_directory_iterator iter(path);iter!=end;++iter)

     {

         if (!boost::filesystem::is_directory(*iter)&&iter->path().filename()==file)

             return result_value(iter->path());

     }

     return result_value();

 }

 int

 main(int argc, char **argv)

 {

     //因为文件属于程序外的不可控资源，随时抛出异常,try{}catch处理

     try

     {

         auto path=find_file("/Users/xuaidong/Desktop/","application.cpp");

         if (path)

         {

             std::cout<<"CMakeLists.txt is here: "<<*path<<std::endl;

         }else

         {

             std::cout<<"CMakeLists.txt not to find"<<std::endl;

         }

     }

     catch (boost::filesystem::filesystem_error &e)

     {

         std::cout << e.path1() << std::endl;

         std::cout << e.path2() << std::endl;

         std::cout << e.what() << std::endl;

     }

     return ;

 }

实例2:利用boost::xpressive正则匹配实现模糊查找(只实现"*"匹配)

 #include <iostream>

 #include <string>

 #include <boost/filesystem.hpp>

 #include <boost/xpressive/xpressive.hpp>

 #include <boost/algorithm/string.hpp>

 //boost filesystem realize obscure find file

 std::vector<boost::filesystem::path>

 find_file(const boost::filesystem::path &path, const std::string &file)

 {

     //之后查找使用- -

     static boost::xpressive::sregex_compiler rc;         //正则表达式工厂

     if (!rc[file].regex_id())

     {

         std::string str = boost::replace_all_copy(boost::replace_all_copy(file, ".", "\\."), "*", ".*");

         rc[file] = rc.compile(str);

     }

     typedef std::vector<boost::filesystem::path> result_value;

     result_value v;

     if (!boost::filesystem::exists(path) && !boost::filesystem::is_directory(path))

     {

         return v;

     }

     //递归目录查找

     boost::filesystem::recursive_directory_iterator end;

     for (boost::filesystem::recursive_directory_iterator iter(path); iter != end; ++iter)

     {

         if (!boost::filesystem::is_directory(*iter) &&

             boost::xpressive::regex_match(iter->path().filename().string(), rc[file]))

         {

             v.push_back(iter->path());

         }

     }

     return v;

 }

 int

 main(int argc, char **argv)

 {

     //因为文件属于程序外的不可控资源，随时抛出异常,try{}catch处理

     try

     {

         auto path = find_file("/Users/xuaidong/Desktop/", "*.txt");

         for (auto &iter:path)

         {

             std::cout << "file match: " << iter << std::endl;

         }

     }

     catch (boost::filesystem::filesystem_error &e)

     {

         std::cout << e.path1() << std::endl;

         std::cout << e.path2() << std::endl;

         std::cout << e.what() << std::endl;

     }

     return ;

 }

 #include <iostream>

 #include <string>

 #include <boost/filesystem.hpp>

 #include <boost/xpressive/xpressive.hpp>

 #include <boost/algorithm/string.hpp>

 #include <boost/progress.hpp>

 std::vector<boost::filesystem::path>

 find_file(const boost::filesystem::path &path, const std::string &file)

 {

     //之后查找使用- -

     static boost::xpressive::sregex_compiler rc;         //正则表达式工厂

     if (!rc[file].regex_id())

     {

         std::string str = boost::replace_all_copy(boost::replace_all_copy(file, ".", "\\."), "*", ".*");

         rc[file] = rc.compile(str);

     }

     typedef std::vector<boost::filesystem::path> result_value;

     result_value v;

     if (!boost::filesystem::exists(path) && !boost::filesystem::is_directory(path))

     {

         return v;

     }

     //递归目录查找

     boost::filesystem::recursive_directory_iterator end;

     for (boost::filesystem::recursive_directory_iterator iter(path); iter != end; ++iter)

     {

         if (boost::xpressive::regex_match(iter->path().filename().string(), rc[file]))

         {

             v.push_back(iter->path());

         }

     }

     return v;

 }

 std::size_t

 copy_files(

         const boost::filesystem::path &from_dir,

         const boost::filesystem::path &to_dir,

         const std::string &filename = "*"

 )

 {

     if (!boost::filesystem::exists(from_dir))

     {

         std::cout << "file not find" << std::endl;

         return -;

     }

     std::cout << "prepare copy please wait....." << std::endl;

     auto vcontain = find_file(from_dir, filename);

     if (vcontain.empty())

     {

         std::cout << "file is empty" << std::endl;

         return -;

     }

     boost::filesystem::path temp;

     boost::progress_display display(vcontain.size());

     for (auto &iter:vcontain)

     {

         temp = to_dir / iter.string().substr(from_dir.string().length());

         std::cout << "file: " << temp << std::endl;

         if (!boost::filesystem::exists(temp.parent_path()))

         {

             boost::filesystem::create_directories(temp.parent_path());

         }

         if(boost::filesystem::is_directory(iter))

         {

             boost::filesystem::create_directories(temp);

         }

         else{

             boost::filesystem::copy_file(iter, temp, boost::filesystem::copy_option::overwrite_if_exists);

         }

         ++display;

     }

     std::cout << vcontain.size() << " filed copyed" << std::endl;

     return vcontain.size();

 }

 int

 main(int argc, char **argv)

 {

     //因为文件属于程序外的不可控资源，随时抛出异常,try{}catch处理

     try

     {

         copy_files("/Users/xuaidong/Desktop/Boost", "/Users/xuaidong/Desktop/Test");

     }

     catch (boost::filesystem::filesystem_error &e)

     {

         std::cout << e.path1() << std::endl;

         std::cout << e.path2() << std::endl;

         std::cout << e.what() << std::endl;

     }

 }