使用boost中的filesystem类库遍历某个目录所有的文件

filesystem库用法文件系统库（filesystem library）是C++17新增的标准库之一，用于简化和统一文件和目录的操作。

使用filesystem库的一般步骤如下：1. 包含头文件：`#include <filesystem>`2. 命名空间：`using namespace std::filesystem;`3. 使用库中的功能，例如：- 创建目录：`create_directory(path);`- 删除目录或文件：`remove(path);`- 拷贝或移动目录或文件：`copy(path1, path2);` 或`rename(path1, path2);`- 获取文件大小：`file_size(path);`- 判断路径是否存在：`exists(path);`- 判断是否为目录：`is_directory(path);`- 遍历目录中的文件和子目录：使用迭代器或递归函数等。

以下是一个简单的示例代码，演示了filesystem库的基本用法：```cpp#include <iostream>#include <filesystem>using namespace std::filesystem;int main() {path filePath = "path/to/file.txt";if (exists(filePath)) {if (is_directory(filePath)) {std::cout << "Path is a directory." << std::endl;} else {std::cout << "Path is a file." << std::endl;std::cout << "Size: " << file_size(filePath) << " bytes." << std::endl;}} else {std::cout << "Path does not exist." << std::endl;}return 0;}```上述代码会判断给定的路径是否存在，并输出路径类型（文件还是目录）和文件大小（如果是文件的话）。

C++使⽤BOOST操作⽂件、⽬录开始使⽤在BOOST库出现之前，C++对于⽂件和⽬录的操作，⼤都借助于UNIX提供的底层⽂件和⽬录接⼝，从使⽤⾓度来看，这些底层的操作不够友好。

BOOST中filesystem库是⼀种可移植的⽂件系统操作库，可以跨平台的操作⽬录、⽂件等，在不失性能的情况下，提供了友好的操作⽅法。

本⽂主要介绍在UNIX环境中，boost::filesystem的常⽤操作⽅法。

假设你已经安装好了boost库，使⽤boost::filesystem需要加上头⽂件#include <boost/filesystem.hpp>编译时，需要链接-lboost_filesystem当安装路径不是UNIX环境变量中设置的标准路径的话，编译时还需加上boost库头⽂件和动态路路径，即：-I $(BOOST)/include/-L $(BOOST)/lib/变量$(BOOST)是BOOST库实际安装路径。

filesystem介绍filesystem库是⼀个可移植的⽂件系统操作库，它在底层做了⼤量的⼯作，使⽤POSIX标准表⽰⽂件系统的路径，使C++具有了类似脚本语⾔的功能，可以跨平台操作⽬录、⽂件，写出通⽤的脚本程序。

1.path的构造函数可以接受C字符串和string，也可以是⼀个指定⾸末迭代器字符串序列区间。

2.filesystem提供了⼀系列的⽂件名（或⽬录）检查函数。

3.有丰富的函数⽤于获取⽂件名、⽬录名、判断⽂件属性等等。

4.filesystem库使⽤异常来处理⽂件操作时发⽣的错误。

5.filesystem库提供⼀个⽂件状态类file_status及⼀组相关函数，⽤于检查⽂件的各种属性，如是否存在、是否是⽬录、是否是符号链接等。

6.filesystem提供了少量的⽂件属性操作，如windows下的只读、归档等，Linux下的读写权限等。

7.⽂件操作，如创建⽬录、⽂件改名、⽂件删除、⽂件拷贝等等。

boost：：filesystem文件操作utilFile.h#ifndef RGM_FILEUTILITY_HPP_#define RGM_FILEUTILITY_HPP_#include <boost/filesystem.hpp>namespace RGM{namespace fs = boost::filesystem;/// Utility functions for file managementclass FileUtil{public:/// File separator#if (defined(WIN32) || defined(_WIN32) || defined(WIN64) || defined(_WIN64))static const char FILESEP = '\\';#elsestatic const char FILESEP = '/';#endif/// check if a file or dir existsstatic bool exists(const std::string & input);/// Create dir from input ("D:\a\b\c.ext" or "D:\a\b\", i.e."D:\a\b")static void CreateDir( const std::string& input );/// Get (dir, filebasename, extname) from a full file namestatic std::vector<std::string> FileParts(const std::string& fileName);static std::string GetParentDir(const std::string& filePath);static std::string GetFileExtension(const std::string& filePath);static std::string GetFileBaseName(const std::string& filePath);/// Check if a file already existedstatic bool CheckFileExists(const std::string &fileName);/// Check if a dir existed, if not, create itstatic bool VerifyDirectoryExists(const std::string& directoryName, bool create=true);/// Delete all files under a dirstatic void ClearDirectory(const std::string& directoryName);/// Get all files under a dirstatic void GetFileList(std::vector<std::string>& files,const std::string& path,const std::string& ext, bool useRootDir=false);/// Get current work directorystatic std::string GetCurrentWorkDirectory();/// Add the file separator to filePath if necessarystatic void VerifyTheLastFileSep(std::string&filePath);}; // class FileUtil} // namespace RGM#endif // RGM_FILEUTILITY_HPP_utilFile.cpp#include <boost/foreach.hpp>#include "UtilFile.hpp"namespace RGM{bool FileUtil::exists(const std::string & input){return fs::exists(fs::path(input));}void FileUtil::CreateDir( const std::string& input ) {fs::path p(input.c_str());if (!fs::is_directory(p)) {fs::path pp = p.parent_path();fs::create_directories(pp);}}std::vector<std::string> FileUtil::FileParts(const std::string& fileName)//分离文件名{fs::path p( fileName.c_str() );std::vector<std::string> vstr(3);vstr[0] = p.parent_path().string();vstr[1] = p.stem().string();vstr[2] = p.extension().string();return vstr;}std::string FileUtil::GetParentDir(const std::string& filePath) {return fs::path(filePath.c_str()).parent_path().string();}std::string FileUtil::GetFileExtension(const std::string& filePath){return fs::path(filePath.c_str()).extension().string();}std::string FileUtil::GetFileBaseName(const std::string& filePath){return fs::path(filePath.c_str()).stem().string();}bool FileUtil::CheckFileExists(const std::string& fileName){return fs::exists(fs::path(fileName.c_str()));}bool FileUtil::VerifyDirectoryExists(const std::string& directoryName, bool create){fs::path p(directoryName.c_str());bool exist = fs::exists(p);if (!exist && create) {fs::create_directories(p);}return exist;}void FileUtil::ClearDirectory(const std::string& directoryName){fs::path p(directoryName.c_str());fs::remove_all( p );fs::create_directory( p );}//获取指定目录下所有文件void FileUtil::GetFileList(std::vector<std::string>& files, const std::string& path, const std::string& ext, bool useRootDir) {fs::path targetDir(path.c_str());fs::directory_iterator it(targetDir), eod;bool getAllFiles = (pare("*")==0);BOOST_FOREACH(fs::path const &p, std::make_pair(it, eod)) { if (fs::is_regular_file(p)) {if ( getAllFiles ) {useRootDir ? files.push_back( p.string() ) : files.push_back(p.filename().string());} else {if (pare(p.extension().string())==0) {useRootDir ? files.push_back( p.string() ) : files.push_back(p.filename().string());}}}}}//获取工作目录std::string FileUtil::GetCurrentWorkDirectory(){fs::path p = fs::initial_path();return p.string();}//在文件的结尾加上\\void FileUtil::VerifyTheLastFileSep(std::string &filePath) {if ( filePath.find_last_of("/\\") != (filePath.length() - 1) ) { filePath = filePath + FILESEP;}}} // namespace RGM。

boost：：filesystem总结boost::filesystem是Boost C++ Libraries中的⼀个模块，主要作⽤是处理⽂件（Files）和⽬录(Directories)。

该模块提供的类boost::filesystem::path专门⽤来处理路径。

⽽且，该模块中还有很多独⽴的函数能够⽤来执⾏创建⽬录、检查⽂件是否存在等任务。

⼀、创建Paths定义路径时需要包含头⽂件boost/filesystem.hpp，并且使⽤命名空间boost::filesystem；路径的创建很简单，仅仅需要向类boost::filesystem::path()的构造器传递⼀个string；构造器的输⼊可以是⼀个没有意义的字符串，因为构造器不会去检测该路径是否是合法路径及是否存在；path对象是⼀个跨平台的路径对象。

path对象的属性有下列这些：1) path.string() 输出字符串形式的路径2) path.stem() ⽂件名，不带扩展名3) path.extension() 返回⽂件扩展名更详细的内容见。

⼆、⽂件和⽬录该部分包括下列函数：boost::filesystem::status(path) 查询⽂件或⽬录的状态，返回的是boost::filesystem::file_status类型的对象boost::filesystem::is_directory() 根据获取的状态判断是否是⽬录，返回boolboost::filesystem::is_empty() 判断是否为空boost::filesystem::is_regular_file() 根据获取的状态判断是否是普通⽂件，返回boolboost::filesystem::is_symlink() 判断符号连接（在windows系统中，后缀为lnk的⽂件为连接⽂件）boost::filesystem::exists() 判断是否存在boost::filesystem::file_size() 返回⽂件的size，按bytes计算boost::filesystem::last_write_time() 返回⽂件最后⼀次修改的时间boost::filesystem::space() 返回磁盘的总空间和剩余空间，boost::filesystem::create_directory() 创建⽬录boost::filesystem::create_directories() 递归创建整个⽬录结构boost::filesystem::remove() 删除⽬录boost::filesystem::remove_all() 递归删除整个⽬录结构boost::filesystem::rename() 重命名⽬录boost::filesystem::copy_file() 复制⽂件boost::filesystem::copy_directory() 复制⽬录boost::filesystem::absolute() 获取⽂件或⽬录的绝对路径boost::filesystem::current_path() 如果没有参数传⼊，则返回当前⼯作⽬录；否则，则将传⼊的⽬录设为当前⼯作⽬录三、⽬录迭代（Directory Iterators）boost::filesystem::directory_iterator() 迭代⽬录下的所有⽂件boost::filesystem::recursive_directory_iterator() 递归地遍历⼀个⽬录和⼦⽬录，也就是迭代整个⽬录结构下的所有⽂件四、⽂件流（File Streams）头⽂件<fstream>定义的⽂件流不能将boost::filesystem::path定义的⽬录作为参数。

题目：C++读取整个文件内容的最简洁高效写法在C++编程中，读取整个文件的内容是一个常见的需求。

有时候我们需要对文件进行处理或者分析，而需要先将文件内容读取到内存中。

在这篇文章中，我们将探讨C++中读取整个文件内容的最简洁高效写法，帮助大家更好地理解和应用这一技巧。

1. 使用STL库中的ifstream和string在C++中，我们可以使用STL(标准模板库)中的ifstream和string来实现快速读取文件内容的操作。

下面是一个简单的示例代码：```cpp#include <iostream>#include <fstream>#include <string>std::string readEntireFile(const std::string& filename) {std::ifstream file(filename);if (file) {return std::string((std::istreambuf_iterator<char>(file)), (std::istreambuf_iterator<char>()));}return "";}int main() {std::string content = readEntireFile("example.txt");std::cout << content << std::endl;return 0;}```在这段代码中，我们首先包含了iostream、fstream和string这三个头文件。

然后定义了一个读取整个文件内容的函数readEntireFile，以及在main函数中调用该函数并输出文件内容的示例。

这段代码的关键点是使用了std::ifstream来打开文件，然后利用std::istreambuf_iterator<char>构造了一个string对象，从而将文件内容读取到了内存中。

boost：：filesystem经常使⽤使⽤⽅法具体解释提⽰：filesystem库提供了两个头⽂件，⼀个是<boost/filesystem.hpp>，这个头⽂件包括基本的库内容。

它提供了对⽂件系统的重要操作。

同⼀时候它定义了⼀个类path。

正如⼤家所想的。

这个是⼀个可移植的路径表⽰⽅法，它是filesystem库的基础。

⼀个是<boost/filesystem/fstream.hpp>。

是对std::fstream的⼀个补充，使⽤能够使⽤类boost::path作为參数。

从⽽使得filesystem库与标准库的关系更亲热。

由于⽂件系统对于⼤多数系统来说都是共享的，所以不同的进程能够同⼀时候操作同⼀个对象，因此filesysetm不提供这⽅⾯的特性保证。

当然这样的保证也是不可能的。

或者⾄少昂贵的。

filesystem在不论什么时候，仅仅要不能完毕对应的任务。

它都可能抛出 basic_filesystem_error异常。

当然并不是总会抛出异常。

由于在库编译的时候能够关闭这个功能。

同⼀时候有两个函数提供了⽆异常版本号。

这是由于在任务不能完毕时并不是是异常。

filesystem库的全部内容定义在boost名字空间的⼀个下级名字空间⾥，它叫boost::filesytem。

在使⽤boost.filesytem之后，链接时须要加“-lboost_filesystem-mt”选项，由于这个须要额外的链接，并不是⼀个纯头⽂件的库。

本⽂中所⽤boost库为1_54#include<boost/filesystem.hpp>{boost::filesystem::path path("/test/test1"); //初始化boost::filesystem::path old_cpath = boost::filesystem::current_path(); //取得当前程序所在⽂件夹boost::filesystem::path parent_path = old_cpath.parent_path();//取old_cpath的上⼀层⽗⽂件夹路径boost::filesystem::path file_path = old_cpath / "file"; //path⽀持重载/运算符if(boost::filesystem::exists(file_path)) //推断⽂件存在性{std::string strPath = file_path.string();int x = 1;}else{//⽂件夹不存在;boost::filesystem::create_directory(file_path); //⽂件夹不存在。

boost常用库的使用介绍第一讲[object Object]Boost是一个C++库集合，包含了许多常用的工具和组件，用于增强C++的功能和性能。

Boost库广泛应用于各种领域，如网络编程、多线程、数据结构、算法等。

Boost库的使用可以大大简化C++开发过程，提高开发效率。

下面是一些常用的Boost库和它们的使用介绍：1. Boost.Filesystem：用于处理文件和目录的库。

它提供了一组易于使用和跨平台的API，可以进行文件和目录的创建、删除、移动、复制等操作。

2. Boost.Regex：正则表达式库，提供了强大的正则表达式功能，可以进行字符串匹配、替换等操作。

Boost.Regex支持多种正则表达式语法，包括Perl、ECMAScript等。

3. Boost.Thread：多线程库，提供了线程的创建、同步、互斥等功能。

Boost.Thread可以简化多线程编程，提高程序的并发性能。

4. Boost.Asio：网络编程库，提供了异步网络编程的功能。

它支持TCP、UDP、SSL等协议，可以用于开发高性能的网络应用程序。

5. Boost.SmartPtr：智能指针库，提供了shared_ptr、weak_ptr等智能指针类，用于管理动态分配的内存。

使用智能指针可以避免内存泄漏和悬挂指针等问题。

6. Boost.Algorithm：算法库，提供了一系列常用的算法，如排序、查找、字符串处理等。

Boost.Algorithm可以方便地进行各种数据处理操作。

7. Boost.Date_Time：日期和时间库，提供了日期和时间的表示、计算和格式化等功能。

它支持多种日期和时间表示方式，如Gregorian、Julian等。

8. Boost.Serialization：序列化库，用于将对象转换成字节流或从字节流中恢复对象。

Boost.Serialization可以方便地进行对象的序列化和反序列化操作。

使用boost中的filesystem类库遍历某个目录所有的文件#include <boost/filesystem/operations.hpp>#include <boost/filesystem/path.hpp>使用boost中的filesystem类库遍历某个目录所有的文件int GetAllFileOfPath(const string strPath){namespace fs = boost::filesystem;// 得到配置文件夹.if ( strPath.size() < 2 ){return 0;}fs::path full_path( fs::initial_path() );full_path = fs::system_complete( fs::path( strPath, fs::native ) );unsigned long file_count = 0;unsigned long dir_count = 0;unsigned long err_count = 0;if ( !fs::exists( full_path ) ){std::cout << "找不到配置文件目录,请检查该目录是否存在:"std::cout << full_path.native_file_string() << std::endl;return -1;}// 遍历配置文件所在的文件夹,得到所有的配置文件名.if ( fs::is_directory( full_path ) ){fs::directory_iterator end_iter;for ( fs::directory_iterator dir_itr( full_path );dir_itr != end_iter;++dir_itr ){try{if ( fs::is_directory( *dir_itr ) ){string strSubDir(full_path.native_directory_string()) ;strSubDir.append("\\");strSubDir.append(dir_itr->leaf());// 如果有子目录,则递归遍历.GetAllFileOfPath(strSubDir);}else{// 先组成包括完整路径的文件名string strFileName(full_path.native_directory_string());strFileName.append("\\");strFileName.append(dir_itr->leaf());fs::path full_file( fs::initial_path() );full_file = fs::system_complete(fs::path(strFileName, fs::native));// 加载解析文件中的信息.//do something;}}catch ( const std::exception & ex ){++err_count;string strMsg = dir_itr->leaf();strMsg.append(",出现错误：");strMsg.append(ex.what());std::cout << strMsg.c_str() << std::endl;}}//<--for()}else // must be a file{string strMsg = full_path.native_file_string();strMsg.append(",不是文件目录.");std::cout << strMsg.c_str() << std::endl;return -1;}return err_count;}。

C/C++中判断某一文件或目录是否存在2011-08-31 12:39C/C++中判断某一文件或目录是否存在1.C++很简单的一种办法：#include <iostream>#include <fstream> usingnamespace std;#define FILENAME "stat.dat"int main(){fstream _file;_file.open(FILENAME,ios::in);if(!_file){cout<<FILENAME<<"没有被创建";}else{cout<<FILENAME<<"已经存在";}return 0;}2.利用 c 语言的库的办法：函数名: access功能: 确定文件的访问权限用法: int access(const char *filename, intamode);以前一直没用过这个函数,今天调试程序发现了这个函数,感觉挺好用,尤其是判断一个文件或文件夹是否存在的时候,用不着再find了,文件的话还可以检测读写权限,文件夹的话则只能判断是否存在,下面摘自MSDN：int_access(constchar*path,int mode);Return ValueEach of these functions returns 0 if the file has the given mode. The function returns –1 if the named file does not exist or is not accessible in the given mode; in this case,errno is set as follows:EACCESAccess denied: file’s permission setting does not allow specified access.ENOENTFilename or path not found.ParameterspathFile or directory pathmodePermission settingRemarksWhen used with files, the_access function determines whether the specified file exists and can be accessed as specified by the value ofmode. When used with directories,_access determines only whether the specified directory exists; in Windows NT, all directories have read and write access.mode Value Checks File For00 Existence only02 Write permission04 Read permission06 Read and write permissionExample/* ACCESS.C: This example uses _access to check the* file named "ACCESS.C" to see if it exists and if* writing is allowed.*/#include <io.h>#include <stdio.h>#include <stdlib.h>void main( void ){/* Check for existence */if( (_access( "ACCESS.C", 0 )) != -1 ){printf( "File ACCESS.C exists" );/* Check for write permission */if( (_access( "ACCESS.C", 2 )) != -1 )printf( "File ACCESS.C has write permission" );}}OutputFile ACCESS.C existsFile ACCESS.C has write permission 3.在windows平台下用API函数FindFirstFile(...):(1)检查文件是否存在:#define _WIN32_WINNT 0x0400#include "windows.h"intmain(int argc, char *argv[]){WIN32_FIND_DATA FindFileData;HANDLE hFind;printf ("Target file is %s.", argv[1]);hFind = FindFirstFile(argv[1], &FindFileData);if (hFind == INVALID_HANDLE_VALUE) {printf ("Invalid File Handle. Get Last Error reports %d", Get LastError ());} else {printf ("The first file found is %s", FindFileData.cFileName); FindClose(hFind);}return (0);}(2)检查某一目录是否存在：///目录是否存在的检查：bool CheckFolderExist(conststring&strPath){WIN32_FIND_DATA wfd;bool rValue = false;HANDLE hFind = FindFirstFile(strPath.c_str(), &wfd);if ((hFind != INVALID_HANDLE_VALUE) && (wfd.dwFileAttributes& FILE_ATTRIBUTE_DIRECTORY)){rValue = true;}FindClose(hFind);return rValue;}4.使用boost的filesystem类库的exists函数#include <boost/filesystem/operations.hpp>#include <boost/filesystem/path.hpp>#include <boost/filesystem/convenience.hpp>int GetFilePath(std::string&strFilePath){string strPath;int nRes = 0;//指定路径strPath = "D:/myTest/Test1/Test2";namespace fs = boost::filesystem;//路径的可移植fs::path full_path( fs::initial_path() );full_path = fs::system_complete( fs::path(strPath, fs::native) );//判断各级子目录是否存在，不存在则需要创建if ( !fs::exists( full_path ) ){// 创建多层子目录bool bRet = fs::create_directories(full_path);if (false == bRet){return -1;}}strFilePath = full_path.native_directory_string(); return 0;}。

VBA中的文件夹遍历技巧VBA是一种广泛使用的编程语言，用于在Microsoft Office套件中自动化任务。

其中一个常见的任务是在文件夹中查找特定类型的文件或处理文件夹中的所有文件。

为了实现这些功能，您需要了解VBA中的文件夹遍历技巧。

文件夹遍历是指迭代一个文件夹中的所有文件或子文件夹。

通过使用递归或循环结构，您可以遍历整个文件夹结构，并对其中的每个文件或文件夹执行所需的操作。

在VBA中，您可以使用File System Object(FSO)来遍历文件夹。

FSO提供了许多有用的方法和属性，可以帮助您处理文件夹和文件。

要使用FSO，请先添加对Microsoft Scripting Runtime库的引用，并在代码中声明一个FileSystemObject对象。

以下是一些常用的文件夹遍历技巧：1. 遍历文件夹中的所有文件：对于需要处理文件夹中的所有文件的任务，您可以使用File对象和Files集合来实现。

通过使用FSO的GetFolder方法，您可以获取指定路径下的文件夹对象。

然后，使用Files属性遍历该文件夹中的所有文件。

```vbaSub TraverseFiles()Dim FSO As ObjectDim Folder As ObjectDim File As ObjectSet FSO = CreateObject("Scripting.FileSystemObject") Set Folder = FSO.GetFolder("C:\Path\To\Folder\")For Each File In Folder.Files' 处理文件的操作Next FileSet FSO = NothingSet Folder = NothingSet File = NothingEnd Sub```2. 遍历文件夹中的所有子文件夹：如果您需要遍历文件夹及其所有子文件夹中的文件，可以使用Folders集合和File对象的递归方法。

C++遍历⽂件夹下所有⽂件的多种⽅法为数不多的好⽤的代码，遍历⽂件夹获取所有⼦⽂件名，"filespec"可⽤通配符“*?”。

注意如果⽤相对路径的话，获取所有⽂件名后应再调⽤SetInitDir将初始⽬录改为当前⽬录，否则中间⽣成的⽂件都会放在之前的“InitDir”内。

C/C++遍历⽂件夹感觉真是很不好⽤，建议还是使⽤C/C++做单任务处理，然后通过脚本语⾔实现遍历⽐较合理。

CBrowseDir.h#include <io.h>#include <stdlib.h>#include <direct.h>#include <iostream>#include <string>#include <vector>using namespace std;class CBrowseDir{protected://存放初始⽬录的绝对路径，以'\'结尾char m_szInitDir[_MAX_PATH];public://缺省构造器CBrowseDir();//设置初始⽬录为dir，如果返回false，表⽰⽬录不可⽤bool SetInitDir(const char *dir);//开始遍历初始⽬录及其⼦⽬录下由filespec指定类型的⽂件//filespec可以使⽤通配符 * ?，不能包含路径。

//如果返回false，表⽰遍历过程被⽤户中⽌bool BeginBrowse(const char *filespec);vector<string> BeginBrowseFilenames(const char *filespec);protected://遍历⽬录dir下由filespec指定的⽂件//对于⼦⽬录,采⽤迭代的⽅法//如果返回false,表⽰中⽌遍历⽂件bool BrowseDir(const char *dir,const char *filespec);vector<string> GetDirFilenames(const char *dir,const char *filespec);//函数BrowseDir每找到⼀个⽂件,就调⽤ProcessFile//并把⽂件名作为参数传递过去//如果返回false,表⽰中⽌遍历⽂件//⽤户可以覆写该函数,加⼊⾃⼰的处理代码virtual bool ProcessFile(const char *filename);//函数BrowseDir每进⼊⼀个⽬录,就调⽤ProcessDir//并把正在处理的⽬录名及上⼀级⽬录名作为参数传递过去//如果正在处理的是初始⽬录,则parentdir=NULL//⽤户可以覆写该函数,加⼊⾃⼰的处理代码//⽐如⽤户可以在这⾥统计⼦⽬录的个数virtual void ProcessDir(const char *currentdir,const char *parentdir);};CBrowseDir.cpp#include "CBrowseDir.h"CBrowseDir::CBrowseDir(){//⽤当前⽬录初始化m_szInitDirgetcwd(m_szInitDir,_MAX_PATH);//如果⽬录的最后⼀个字母不是'\',则在最后加上⼀个'\'int len=strlen(m_szInitDir);if (m_szInitDir[len-1] != '\\')strcat(m_szInitDir,"\\");}bool CBrowseDir::SetInitDir(const char *dir){return false;//判断⽬录是否存在if (_chdir(m_szInitDir) != 0)return false;//如果⽬录的最后⼀个字母不是'\',则在最后加上⼀个'\'int len=strlen(m_szInitDir);if (m_szInitDir[len-1] != '\\')strcat(m_szInitDir,"\\");return true;}vector<string> CBrowseDir::BeginBrowseFilenames(const char *filespec) {ProcessDir(m_szInitDir,NULL);return GetDirFilenames(m_szInitDir,filespec);}bool CBrowseDir::BeginBrowse(const char *filespec){ProcessDir(m_szInitDir,NULL);return BrowseDir(m_szInitDir,filespec);}bool CBrowseDir::BrowseDir(const char *dir,const char *filespec){_chdir(dir);//⾸先查找dir中符合要求的⽂件long hFile;_finddata_t fileinfo;if ((hFile=_findfirst(filespec,&fileinfo)) != -1){do{//检查是不是⽬录//如果不是,则进⾏处理if (!(fileinfo.attrib & _A_SUBDIR)){char filename[_MAX_PATH];strcpy(filename,dir);strcat(filename,);cout << filename << endl;if (!ProcessFile(filename))return false;}} while (_findnext(hFile,&fileinfo) == 0);_findclose(hFile);}//查找dir中的⼦⽬录//因为在处理dir中的⽂件时，派⽣类的ProcessFile有可能改变了//当前⽬录，因此还要重新设置当前⽬录为dir。

C++作为一种强大的编程语言，对文件和路径的操作是非常常见的需求。

在实际编程过程中，我们经常需要获取指定路径下的所有文件名，以便对这些文件进行进一步的操作。

本文将介绍如何在C++中编写一个函数来实现这一功能。

1. 使用标准库在C++中，我们可以使用标准库中的一些函数来实现获取路径下文件名的功能。

其中，`<filesystem>`是C++17新增的标准库，提供了一些方便的文件和路径操作函数。

在使用这些函数之前，需要在编译选项中添加`-std=c++17`来支持C++17标准。

2. 实现函数接下来，我们将编写一个函数`getFilesInDirectory`来获取指定路径下的文件名列表。

我们将使用`<filesystem>`中的`directory_iterator`来遍历指定路径下的所有文件，并将文件名存储到一个字符串数组中。

以下是`getFilesInDirectory`函数的实现：```cpp#include <iostream>#include <string>#include <filesystem>std::vector<std::string> getFilesInDirectory(const std::string path) {std::vector<std::string> files;for (const auto entry : std::filesystem::directory_iterator(path)) {if (entry.is_regular_file()) {files.push_back(entry.path().filename().string());}}return files;}```3. 调用示例现在，我们可以编写一个简单的示例来调用`getFilesInDirectory`函数，以演示如何获取指定路径下的文件名列表。

boost--⽂件、⽬录操作filesystem库是⽂件系统操作库，可以使⽤其中的basic_path类⽤来操作⽬录、⽂件，使⽤需要包含编译好的system库和filesystem库，我们⼀般不直接使⽤basic_path，⽽是使⽤typedef : path和wpath。

使⽤它需要包含"boost/filesystem.hpp"。

boost::filesystem::path p1("D:\\dir"); //windows下既可使⽤斜杠也可使⽤反斜杠（资源管理器地址栏中使⽤的就是反斜杠），⼜因为在c++中反斜杠是转义字符的标志，所以使⽤反斜杠的话还得再加⼀个反斜杠 boost::filesystem::path p2("D:/dir/data.dat"); //windows下推荐使⽤正斜杠boost::filesystem::path p3("/user/dir"); //linux下使⽤正斜杠boost::filesystem::path p4 = "./dir"; //path的构造函数没有声明为explicit，字符串可以隐式转换为path对象p1 /= "child"; //path重载了 /=，其功能与成员append()相同。

cout << p1 << endl; //⽀持流输出操作，输出为"D:\dir\child"if (p1 == p2); //⽀持⽐较操作auto iter = p1.begin(); //⽀持迭代器来迭代其中的字符串std::string strDir = p1.string(); //获取字符串（构造函数中传⼊的字符串为相对路径的话这⾥也是相对路径）bool bRes = boost::filesystem::portable_posix_name(strDir); //判断是否符合posix⽂件命名规范boost::filesystem::windows_name(strDir); //判断是否符合windows⽂件命名规范boost::filesystem::portable_name(strDir); //相当于portable_posix_name() && windows_nameboost::filesystem::native(strDir); //在windows下相当于windows_name，其它操作系统下只是简单的判断⽂件名不是空格且不含斜杠boost::filesystem::path parentPath = p3.parent_path(); //获得⽗路径boost::filesystem::path parentPath = p3.system_complete(); //获得全路径（绝对路径）std::string name = p2.filename().string(); //⽂件名: data.datstd::string s = p2.stem().string(); //不含扩展名的⽂件名: datastd::string extName = p2.extension().string(); //扩展名: datp1.is_complete(); //是否是⼀个完整的绝对路径p1.relative_path(); //获得path的相对路径boost::filesystem::path p("C:/xxx/yyy");p1.root_path(); //根路径: "C:/"p1.root_name(); //根名字："C:"p1.root_directory(); //根⽬录: "/"p1.remove_filename(); //删除当前路径中最后的⽂件名p1.replace_extension("hxx"); //改变⽂件扩展名// filesystem使⽤异常来处理⽂件操作时发⽣的错误，所以使⽤的时候应该加上异常处理try{boost::filesystem::file_size(p1); //获得⽂件⼤⼩，⽂件不存在则会抛出异常}catch (boost::filesystem::filesystem_error& e){cout << e.path1() << endl;cout << e.what() << endl;}boost::filesystem::exists(p1); //是否存在boost::filesystem::is_directory(p1); //是否是⽬录boost::filesystem::is_regular_file(p1); //是否是普通⽂件boost::filesystem::is_empty(p1); //⽬录是否为空或⽂件⼤⼩是否为0boost::filesystem::is_symlink(p1); //是否为链接⽂件boost::filesystem::is_other(p1); //当⽂件存在且不是普通⽂件、⽬录或链接⽂件时返回true，其它⽂件类型可以通过⽂件状态类file_status获得boost::filesystem::current_path(); //获得当前路径boost::filesystem::initial_path(); //获得进⼊main函数时的当前路径boost::filesystem::last_write_time(p1); //获得⽂件最后修改时间boost::filesystem::space(p1); //获得路径下磁盘空间分配情况boost::filesystem::remove(p1); //删除⽂件或空⽬录boost::filesystem::remove_all(p1); //删除⽬录boost::filesystem::create_directory(p1); //创建⼀级⽬录boost::filesystem::create_directories(p1); //创建多级⽬录boost::filesystem::copy_file(p1, p2); //拷贝boost::filesystem::rename(p1, p2); //改名void recursive_dir(const boost::filesystem::path& dir){//使⽤directory_iterator递归遍历⽬录boost::filesystem::directory_iterator end; //空的directory_iterator构造函数⽣成⼀个指向end的迭代器boost::filesystem::directory_iterator pos(p1); //传⼊⼀个path对象后可以使⽤++开始迭代操作for (; pos != end; pos++){if (boost::filesystem::is_directory(*pos))recursive_dir(*pos); //directory_iterator迭代器返回的类型其实不是path，但它定义了⼀个到path的类型转换函数，因此这⾥是隐式转换elsecout << *pos << endl; //输出⽂件名}}//directory_iterator不⽀持深度遍历，可以使⽤效率更⾼的recursive_directory_iterator或wrecursive_directory_iteratortypedef boost::filesystem::recursive_directory_iterator rd_iterator;rd_iterator end;rd_iterator pos(p1);for (; pos != end; pos++){//if (boost::filesystem::is_directory(*pos))//pos.no_push(); //退出当前⽬录层次的遍历，相当于使⽤directory_iteratorcout << pos.level() << endl; //获得当前⽬录深度cout << *pos << endl; //输出⽂件名}。

boost的用法Boost是一种非常强大的C++库，它提供了大量的函数，满足C++程序员的日常开发需求。

由于它的优秀的性能和全面的功能，boost已经成为C++开发人员必备的类库之一。

本文将对boost的用法进行详细介绍，帮助C++程序员更好地理解、使用它。

一、boost库的使用方法1.境搭建：首先，开发者需要先在自己的电脑上搭建boost的开发环境，包括安装boost库、boost相关的头文件和库文件。

在Windows平台上使用Visual Studio开发，需要把boost的编译过的头文件和库文件加入到Visual Studio的引用路径中。

2.含头文件：在使用boost库的各种函数和类之前，需要先在程序中引入对应的头文件。

例如，使用boost::filesystem库中的相关函数，需要在程序中加入#include <boost/filesystem.hpp>这行代码，来包含filesystem头文件。

3.接库文件：如果程序中使用到了boost库中的库文件，则需要在工程属性中链接对应的库文件：如果要使用filesystem库，则需要链接boost_filesystem库文件。

4. 代码编写：只要所有的环境设置都完成，就可以正常使用boost库里的各种函数和类了。

例如，可以使用boost::filesystem 库来实现文件系统操作，如创建、删除、拷贝目录或文件等。

二、boost的部分功能Boost提供了大量的函数和类，可以满足各种C++程序员的开发需求。

下面介绍一些常用的功能：1.据类型：Boost提供了很多种类型的容器，可以存储各种数据，如vector、list、deque、map、set等，可以帮助程序员实现数据的快速存取。

2.符串处理：除了提供基本的字符串操作函数，Boost还提供了丰富的字符串处理功能，如字符串分割、比较、查找、替换等。

例如，可以使用boost::algorithm::split函数来对字符串进行分割，其语法简单，容易理解。

C#遍历⽬录下所有⽂件⽅法C#遍历指定⽂件夹中的所有⽂件DirectoryInfo TheFolder=new DirectoryInfo(folderFullName);//遍历⽂件夹foreach(DirectoryInfo NextFolder in TheFolder.GetDirectories())this.listBox1.Items.Add();//遍历⽂件foreach(FileInfo NextFile in TheFolder.GetFiles())this.listBox2.Items.Add();Directory⽂件夹static类CreateDirectory(string path)：创建⽂件夹全路径void Delete(string path, bool recursive)：删除⽂件夹path， recursive表⽰是否也删除⼦⽂件及⼦⽂件夹。

如果⽂件夹不为空，recursive=false，则抛异常；bool Exists(string path)：判断⽂件夹是否存在EnumerateFiles、 EnumerateDirectories遍历⽂件和⽂件夹；如何获取指定⽬录包含的⽂件和⼦⽬录1. DirectoryInfo.GetFiles()：获取⽬录中（不包含⼦⽬录）的⽂件，返回类型为FileInfo[]，⽀持通配符查找；2. DirectoryInfo.GetDirectories()：获取⽬录（不包含⼦⽬录）的⼦⽬录，返回类型为DirectoryInfo[]，⽀持通配符查找；3. DirectoryInfo. GetFileSystemInfos()：获取指定⽬录下（不包含⼦⽬录）的⽂件和⼦⽬录，返回类型为FileSystemInfo[]，⽀持通配符查找；如何获取指定⽂件的基本信息；FileInfo.Exists：获取指定⽂件是否存在；，FileInfo.Extensioin：获取⽂件的名称和扩展名；FileInfo.FullName：获取⽂件的全限定名称（完整路径）；FileInfo.Directory：获取⽂件所在⽬录，返回类型为DirectoryInfo；FileInfo.DirectoryName：获取⽂件所在⽬录的路径（完整路径）；FileInfo.Length：获取⽂件的⼤⼩（字节数）；FileInfo.IsReadOnly：获取⽂件是否只读；FileInfo.Attributes：获取或设置指定⽂件的属性，返回类型为FileAttributes枚举，可以是多个值的组合FileInfo.CreationTime、stAccessTime、stWriteTime：分别⽤于获取⽂件的创建时间、访问时间、修改时间；⽂件读取using (FileStream fs = new FileStream(@"d:\1.txt", FileMode.Open)){byte[] bytes =new byte[4];int len;while((len = fs.Read(bytes, 0, bytes.Length))>0){String s = Encoding.Default.GetString(bytes,0,len);Console.Write(s);}}。

readdir_r is deprecated -回复为了更好地理解这个主题，我们首先需要了解一些背景知识。

在计算机编程领域，有很多函数和方法被用于访问文件系统中的目录和文件。

readdir_r函数是其中之一，它被用来读取一个目录中的目录项。

然而，由于一些安全和可用性问题，readdir_r在新的C标准中被弃用了。

那么，为什么readdir_r函数被弃用了呢？我们来一步一步回答这个问题。

第一步：了解readdir_r函数的作用和用法readdir_r函数是用于遍历一个目录并读取其中的文件和子目录的函数。

它的函数原型如下：int readdir_r(DIR *dirp, struct dirent *entry, struct dirent result);参数说明：- dirp：要遍历的目录对象指针- entry：存储读取到的目录项的结构体指针- result：存储函数返回的目录项的结构体指针这个函数的作用是读取目录中的下一个目录项，并将其存储在entry指向的结构体中。

如果成功读取到了一个目录项，则返回0；如果已经读取到了目录的末尾，则返回1；如果发生了错误，则返回一个非0的错误码。

第二步：理解readdir_r函数存在的问题尽管readdir_r函数在过去被广泛使用，但是它存在一些安全和可用性问题，这些问题导致了它被弃用。

以下是这些问题的概述：1. 线程安全性问题：readdir_r函数在设计时考虑了线程安全性，因为它通过使用传入的缓冲区来存储目录项，并且不会使用全局变量。

然而，许多操作系统的实现并没有遵循这个设计，导致了在多线程环境下使用readdir_r函数可能发生竞态条件。

2. 可重入性问题：readdir_r函数虽然是为了提高可重入性而设计的，但是在一些操作系统实现中并没有完全遵循这个设计。

这使得在某些情况下，readdir_r函数无法在嵌套的目录遍历中正确地工作。

3. 可用性问题：readdir_r函数的接口相对复杂，容易出错。

boost遍历文件原理Boost是一个C++库集合，它提供了很多用于程序开发的工具和组件。

其中，Boost.Filesystem库提供了对文件系统操作的支持，包括遍历文件。

在使用Boost.Filesystem库遍历文件时，可以使用以下步骤：1. 引入头文件：首先需要引入Boost.Filesystem库的头文件，如下所示：cpp#include <boost/filesystem.hpp>2. 定义路径：定义需要遍历的文件夹路径，可以使用boost::filesystem::path 对象表示路径，如下所示：cppboost::filesystem::path directoryPath("path/to/directory");3. 遍历文件：使用boost::filesystem::directory_iterator对象遍历文件夹中的文件，如下所示：cppfor (boost::filesystem::directory_iterator fileIterator(directoryPath); fileIterator != boost::filesystem::directory_iterator(); ++fileIterator)boost::filesystem::path filePath = *fileIterator;对文件进行操作，如获取文件名、判断是否是文件夹等}在这个循环中，每次迭代会将路径赋值给filePath变量，可以通过这个变量进行文件的操作。

例如，可以通过filePath.filename()获取文件名，通过boost::filesystem::is_directory(filePath)判断是否为文件夹等。

4. 递归遍历子文件夹：如果要递归遍历文件夹及其子文件夹中的所有文件，可以使用boost::filesystem::recursive_directory_iterator对象，如下所示：cppfor (boost::filesystem::recursive_directory_iteratorfileIterator(directoryPath); fileIterator !=boost::filesystem::recursive_directory_iterator(); ++fileIterator){boost::filesystem::path filePath = *fileIterator;对文件进行操作，如获取文件名、判断是否是文件夹等}在这个循环中，与上述的遍历文件夹相比，使用的是boost::filesystem::recursive_directory_iterator对象，它会自动遍历所有子文件夹中的文件。

计算点云法向量1.先mark⼀个⽂件操作：遍历（或者迭代遍历）指定⽬录，boost::filesystem可真好⽤1for (const auto& it : boost::filesystem::directory_iterator("/your/path")) {2if (it.path().extension() == ".pcd") {3 std::cout << it.path() << ", " << it.path().filename() << ", " << it.path().stem() << ", " << it.path().extension() << std::endl;4 }5 }67for (const auto& it : boost::filesystem::recursive_directory_iterator("/your/path")) {8if (it.path().extension() == ".pcd") {9 std::cout << it.path() << ", " << it.path().filename() << ", " << it.path().stem() << ", " << it.path().extension() << std::endl;10 }11 }// it.path() it.path().filename() it.path().stem() it.path().extension()// "/path/pairs_12_7.pcd", "pairs_12_7.pcd", "pairs_12_7", ".pcd"2.⽤pcl::NormalEstimation简直就是坑爹，计算出的点云法向量有40~50%都是有问题的1 pcl::search::KdTree<PointS>::Ptr kdtree_submap(new pcl::search::KdTree<PointS>);2 kdtree_submap->setInputCloud(cloud_submap);// Make sure the tree searches the surface3 pcl::NormalEstimation<PointS, PointS>::Ptr ne(new pcl::NormalEstimation<PointS, PointS>);4 ne->setInputCloud(cloud_ds_angle_);5 ne->setSearchSurface(cloud_submap);6 ne->setSearchMethod(kdtree_submap);7 ne->setRadiusSearch(search_r_ne);8 ne->compute(*cloud_ds_angle_);⽤pca和kdtree⾃⼰计算，效果赞赞赞，⽽且效率与上⾯的⼀样1void my_normal_estimation(const KdTreePtr &kdtree, PCloudTPtr &cloud, double search_r) {2for (auto &pt : cloud->points) {3 std::vector<int> k_indices;4 std::vector<float> k_sqr_distances;5if (kdtree->radiusSearch(pt, search_r, k_indices, k_sqr_distances) < 3) {6continue;7 }8 PCloudTPtr cloud_search(new PCloudT);9 pcl::copyPointCloud(*(kdtree->getInputCloud()), k_indices, *cloud_search);10 pcl::PCA<PointT> pca;11 pca.setInputCloud(cloud_search);12 Eigen::Matrix3f eigen_vector = pca.getEigenVectors();13 Eigen::Vector3f vect_2 = eigen_vector.col(2);// please fit to your own coordinate14 pt.normal_x = vect_2[0];15 pt.normal_y = vect_2[1];16 pt.normal_z = vect_2[2];17 }18 }。