我可以用口罩与升压目录遍历文件？(Can I use a mask to iterate files

我想所有的文件遍历目录中的匹配类似somefiles*.txt 。

是否boost::filesystem有一些内置的做到这一点，或者我需要一个正则表达式或一些针对每个leaf()

Answer 1:

编辑 ：正如评论指出，下面的代码是有效的版本boost::filesystem之前V3。 对于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().string(), what, my_filter ) ) continue;

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

（如果你正在寻找一个内置的目录过滤准备使用的类，看看Qt的QDir 。）

Answer 2:

有一个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 3:

我的解决办法是基本相同朱利安-L，但封装在包含文件是更好的使用。 使用boost ::文件系统V3实现。 我想，这样的事情是不包含在了boost ::文件系统直接，因为它会引入依赖于刺激::正则表达式。

#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 4:

我相信directory_iterators将只提供目录中的所有文件。 它由你根据需要进行过滤。

Answer 5:

接受的答案没有编译我，甚至当我使用i->path().extension()代替leaf() 做什么工作对我来说是从一个例子这个网站 。 下面的代码，修改，应用过滤器：

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。

为什么我们不都只是使用glob()和一些正则表达式是超越我。

Answer 6:

截至年底提到朱利安-L的后QDir正是你想要的。
https://qt-project.org/doc/qt-5.0/qtcore/qdir.html#QDir-3

Answer 7:

我一直在寻找解决这个早些时候，我想我的解决方案是最简单的

#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";});

文章来源: Can I use a mask to iterate files in a directory with Boost?