我可以使用掩碼來迭代Boost中目錄中的文件嗎？

Question

我想遍歷與「somefiles * .txt」類似的目錄中的所有文件。 boost :: filesystem是否有內置的東西來做到這一點，或者我需要一個正則表達式或什麼對每個葉（）？

Answer 1

編輯：如評論中所述，以下代碼適用於v3之前版本boost::filesystem。對於v3，請參閱評論中的建議。

---

boost::filesystem沒有通配符搜索，你必須自己篩選文件。

這是一個代碼樣本中提取的目錄與boost::filesystem的directory_iterator的內容，並與boost::regex對其進行篩選：

const std::string target_path("/my/directory/"); 
const boost::regex my_filter("somefiles.*\.txt"); 

std::vector<std::string> all_matching_files; 

boost::filesystem::directory_iterator end_itr; // Default ctor yields past-the-end 
for(boost::filesystem::directory_iterator i(target_path); i != end_itr; ++i) 
{ 
    // Skip if not a file 
    if(!boost::filesystem::is_regular_file(i->status())) continue; 

    boost::smatch what; 

    // Skip if no match for V2: 
    if(!boost::regex_match(i->leaf(), what, my_filter)) continue; 
    // For V3: 
    //if(!boost::regex_match(i->path().filename(), what, my_filter)) continue; 

    // File matches, store it 
    all_matching_files.push_back(i->leaf()); 
} 

（如果你正在尋找一個現成的使用類型與內建目錄過濾，看看Qt的QDir。）

Answer 2

我相信directory_iterators只會提供目錄中的所有文件。由您根據需要過濾它們。

Answer 3

正如在Julien-L的末尾所提到的QDir正是你想要的。
https://qt-project.org/doc/qt-5.0/qtcore/qdir.html#QDir-3

Answer 4

我的解決辦法是基本相同朱利安-L，但封裝在包含文件是更好的使用。使用boost :: filesystem v3實現。我猜這樣的東西沒有直接包含在boost :: filesystem中，因爲它會引入對boost :: regex的依賴。

#include "FilteredDirectoryIterator.h" 
std::vector<std::string> all_matching_files; 
std::for_each(
     FilteredDirectoryIterator("/my/directory","somefiles.*\.txt"), 
     FilteredDirectoryIterator(), 
     [&all_matching_files](const FilteredDirectoryIterator::value_type &dirEntry){ 
       all_matching_files.push_back(dirEntry.path()); 
      } 
     ); 

選擇使用FilteredRecursiveDirectoryIterator遞歸子目錄搜索：

#include "FilteredDirectoryIterator.h" 
std::vector<std::string> all_matching_files; 
std::for_each(
     FilteredRecursiveDirectoryIterator("/my/directory","somefiles.*\.txt"), 
     FilteredRecursiveDirectoryIterator(), 
     [&all_matching_files](const FilteredRecursiveDirectoryIterator::value_type &dirEntry){ 
       all_matching_files.push_back(dirEntry.path()); 
      } 
     ); 

FilteredDirectoryIterator.h

#ifndef TOOLS_BOOST_FILESYSTEM_FILTEREDDIRECTORYITERATOR_H_ 
#define TOOLS_BOOST_FILESYSTEM_FILTEREDDIRECTORYITERATOR_H_ 

#include "boost/filesystem.hpp" 
#include "boost/regex.hpp" 
#include <functional> 

template <class NonFilteredIterator = boost::filesystem::directory_iterator> 
class FilteredDirectoryIteratorTmpl 
: public std::iterator< 
    std::input_iterator_tag, typename NonFilteredIterator::value_type 
    > 
{ 
private: 
    typedef std::string string; 
    typedef boost::filesystem::path path; 
    typedef 
     std::function< 
      bool(const typename NonFilteredIterator::value_type &dirEntry) 
      > 
     FilterFunction; 

    NonFilteredIterator it; 

    NonFilteredIterator end; 

    const FilterFunction filter; 

public: 

    FilteredDirectoryIteratorTmpl(); 

    FilteredDirectoryIteratorTmpl(
     const path &iteratedDir, const string &regexMask 
     ); 

    FilteredDirectoryIteratorTmpl(
     const path &iteratedDir, const boost::regex &mask 
     ); 

    FilteredDirectoryIteratorTmpl(
     const path &iteratedDir, 
     const FilterFunction &filter 
     ); 

    //preincrement 
    FilteredDirectoryIteratorTmpl<NonFilteredIterator>& operator++() { 
     for(++it;it!=end && !filter(*it);++it); 
     return *this; 
    }; 

    //postincrement 
    FilteredDirectoryIteratorTmpl<NonFilteredIterator> operator++(int) { 
     for(++it;it!=end && !filter(*it);++it); 
     return FilteredDirectoryIteratorTmpl<NonFilteredIterator>(it,filter); 
    }; 
    const boost::filesystem::directory_entry &operator*() {return *it;}; 
    bool operator!=(const FilteredDirectoryIteratorTmpl<NonFilteredIterator>& other) 
    { 
     return it!=other.it; 
    }; 
    bool operator==(const FilteredDirectoryIteratorTmpl<NonFilteredIterator>& other) 
    { 
     return it==other.it; 
    }; 
}; 

typedef 
    FilteredDirectoryIteratorTmpl<boost::filesystem::directory_iterator> 
    FilteredDirectoryIterator; 

typedef 
    FilteredDirectoryIteratorTmpl<boost::filesystem::recursive_directory_iterator> 
    FilteredRecursiveDirectoryIterator; 

template <class NonFilteredIterator> 
FilteredDirectoryIteratorTmpl<NonFilteredIterator>::FilteredDirectoryIteratorTmpl() 
: it(), 
    filter(
     [](const boost::filesystem::directory_entry& /*dirEntry*/){return true;} 
     ) 
{ 

} 

template <class NonFilteredIterator> 
FilteredDirectoryIteratorTmpl<NonFilteredIterator>::FilteredDirectoryIteratorTmpl(
    const path &iteratedDir,const string &regexMask 
    ) 
: FilteredDirectoryIteratorTmpl(iteratedDir, boost::regex(regexMask)) 
{ 
} 

template <class NonFilteredIterator> 
FilteredDirectoryIteratorTmpl<NonFilteredIterator>::FilteredDirectoryIteratorTmpl(
    const path &iteratedDir,const boost::regex &regexMask 
    ) 
: it(NonFilteredIterator(iteratedDir)), 
    filter(
     [regexMask](const boost::filesystem::directory_entry& dirEntry){ 
      using std::endl; 
      // return false to skip dirEntry if no match 
      const string filename = dirEntry.path().filename().native(); 
      return boost::regex_match(filename, regexMask); 
     } 
     ) 
{ 
    if (it!=end && !filter(*it)) ++(*this); 
} 

template <class NonFilteredIterator> 
FilteredDirectoryIteratorTmpl<NonFilteredIterator>::FilteredDirectoryIteratorTmpl(
    const path &iteratedDir, const FilterFunction &filter 
    ) 
: it(NonFilteredIterator(iteratedDir)), 
    filter(filter) 
{ 
    if (it!=end && !filter(*it)) ++(*this); 
} 

#endif 

Answer 5

有一個Boost Range Adaptors方式：

#define BOOST_RANGE_ENABLE_CONCEPT_ASSERT 0 
#include <boost/filesystem.hpp> 
#include <boost/range/adaptors.hpp> 

namespace bfs = boost::filesystem; 
namespace ba = boost::adaptors; 

const std::string target_path("/my/directory/"); 
const boost::regex my_filter("somefiles.*\.txt"); 
boost::smatch what; 

for (auto &entry: boost::make_iterator_range(bfs::directory_iterator(target_path), {}) 
| ba::filtered(static_cast<bool (*)(const bfs::path &)>(&bfs::is_regular_file)) 
| ba::filtered([&](const bfs::path &path){ return boost::regex_match(path.filename().string(), what, my_filter); }) 
) 
{ 
    // There are only files matching defined pattern "somefiles*.txt". 
    std::cout << entry.path().filename() << std::endl; 
} 

Answer 6

我一直在尋找解決這個早些時候，我想我的解決方案是最簡單的

#include <boost/filesystem.hpp> 
#include <boost/regex.hpp> 
#include <boost/iterator/iterator_facade.hpp> 
#include <boost/exception/all.hpp> 

struct dir_filter_iter 
     : public boost::iterator_facade< 
       dir_filter_iter, 
       boost::filesystem::path, 
       boost::forward_traversal_tag, 
       boost::filesystem::path 
     > 
{ 
     using path = boost::filesystem::path; 
     using impl_type = boost::filesystem::directory_iterator; 

     dir_filter_iter():impl_(){} 
     dir_filter_iter(path p, boost::regex rgx):impl_(std::move(p)),rgx_(std::move(rgx)){ 
       namespace bf = boost::filesystem; 
       if(! bf::is_directory(p)){ 
         BOOST_THROW_EXCEPTION(
           boost::enable_error_info(std::domain_error("not a dir")) 
           << boost::errinfo_file_name(p.string())); 
       } 
     } 
     private: 
     friend class boost::iterator_core_access; 
     bool equal(const dir_filter_iter& that)const{ 
       return this->impl_ == that.impl_; 
     } 
     void increment(){ 
       assert(impl_ != impl_type()); 
       for(;;){ 
         ++impl_; 
         if(impl_ == impl_type()) 
           break; 
         std::string s(impl_->path().string()); 
         if(boost::regex_match(s, rgx_)){ 
           break; 
         } 
       } 
     } 
     path dereference()const{ 
       assert(impl_ != impl_type()); 
       return *impl_; 
     } 
     impl_type impl_; 
     boost::regex rgx_; 
}; 
struct dir_filter_iter_maker{ 
     using value_type = dir_filter_iter; 

     explicit dir_filter_iter_maker(boost::regex rgx):rgx_(rgx){} 

     value_type make()const{ 
       return value_type(); 
     } 
     value_type make(boost::filesystem::path p)const{ 
       return value_type(std::move(p),rgx_); 
     } 
     template<typename... Args> 
     auto operator()(Args&&... args)->decltype(make(args...)){ 
       return this->make(std::forward<Args>(args)...); 
     } 
     private: 
     boost::regex rgx_; 
}; 

然後，你可以做

dir_filter_iter_maker di_maker(boost::regex(R"_(.*\.hpp)_")); 
    std::for_each(di_maker(p), di_maker(), [](const bf::path& p){std::cout << p.string() << "\n";}); 

Answer 7

接受的答案沒有編譯我，即使我用i->path().extension()代替的leaf()。對我有用的是this website的一個例子。下面的代碼，修改，應用過濾器：

vector<string> results; 
filesystem::path filepath(fullpath_to_file); 
filesystem::directory_iterator it(filepath); 
filesystem::directory_iterator end; 
const boost::regex filter("myfilter(capturing group)"); 
BOOST_FOREACH(filesystem::path const &p, make_pair(it, end)) 
{ 
    if(is_regular_File(p)) 
    { 
      match_results<string::const_iterator> what; 
      if (regex_search(it->path().filename().string(), what, pidFileFilter, match_default)) 
      { 
       string res = what[1]; 
       results.push_back(res); 
      } 
    } 
} 

我使用Boost版本：1.53.0。

爲什麼我們不只是使用​​3210而有些正則表達式超出了我的想象。