从两条绝对路径中获取相对路径
Get relative path from two absolute paths
我有两个绝对的文件系统路径(A和B(,我想生成第三个文件系统路径,表示"相对于B的A"。
用例:
- 管理播放列表的媒体播放器
- 用户将文件添加到播放列表
- 相对于播放列表路径,添加到播放列表的新文件路径
- 将来,整个音乐目录(包括播放列表(都会移到其他地方
- 所有路径仍然有效,因为它们是相对于播放列表的
boost::filesystem
似乎有complete
来解析relative ~ relative => absolute
,但没有相反的操作(absolute ~ absolute => relative
(。
我想用Boost路径来做这件事。
对于C++17及其从boost进化而来的std::filesystem::relative
,这是一个很容易的问题:
#include <filesystem>
#include <iostream>
namespace fs = std::filesystem;
int main()
{
const fs::path base("/is/the/speed/of/light/absolute");
const fs::path p("/is/the/speed/of/light/absolute/or/is/it/relative/to/the/observer");
const fs::path p2("/little/light/races/in/orbit/of/a/rogue/planet");
std::cout << "Base is base: " << fs::relative(p, base).generic_string() << 'n'
<< "Base is deeper: " << fs::relative(base, p).generic_string() << 'n'
<< "Base is orthogonal: " << fs::relative(p2, base).generic_string();
// Omitting exception handling/error code usage for simplicity.
}
输出(第二个参数为基础(
Base is base: or/is/it/relative/to/the/observer
Base is deeper: ../../../../../../..
Base is orthogonal: ../../../../../../little/light/races/in/orbit/of/a/rogue/planet
它使用std::filesystem::path::lexically_relative
进行比较。与纯词法函数的区别在于,std::filesystem::relative
解析符号链接,并使用std::filesystem::weakly_canonical
(它是为relative
引入的(。
1.60.0版本的boost.filesystem确实支持此功能。您正在查找成员函数path lexically_relative(const path& p) const
。
原始,1.60.0之前的答案如下。
Boost不支持这一点;这是一个悬而未决的问题#1976(完全反函数(—然而,这似乎并没有得到太多的支持。
这里有一个看似天真的变通方法,似乎可以奏效(不确定是否可以改进(:
#include <boost/filesystem/path.hpp>
#include <boost/filesystem/operations.hpp>
#include <boost/filesystem/fstream.hpp>
#include <stdexcept>
/**
* https://svn.boost.org/trac/boost/ticket/1976#comment:2
*
* "The idea: uncomplete(/foo/new, /foo/bar) => ../new
* The use case for this is any time you get a full path (from an open dialog, perhaps)
* and want to store a relative path so that the group of files can be moved to a different
* directory without breaking the paths. An IDE would be a simple example, so that the
* project file could be safely checked out of subversion."
*
* ALGORITHM:
* iterate path and base
* compare all elements so far of path and base
* whilst they are the same, no write to output
* when they change, or one runs out:
* write to output, ../ times the number of remaining elements in base
* write to output, the remaining elements in path
*/
boost::filesystem::path
naive_uncomplete(boost::filesystem::path const p, boost::filesystem::path const base) {
using boost::filesystem::path;
using boost::filesystem::dot;
using boost::filesystem::slash;
if (p == base)
return "./";
/*!! this breaks stuff if path is a filename rather than a directory,
which it most likely is... but then base shouldn't be a filename so... */
boost::filesystem::path from_path, from_base, output;
boost::filesystem::path::iterator path_it = p.begin(), path_end = p.end();
boost::filesystem::path::iterator base_it = base.begin(), base_end = base.end();
// check for emptiness
if ((path_it == path_end) || (base_it == base_end))
throw std::runtime_error("path or base was empty; couldn't generate relative path");
#ifdef WIN32
// drive letters are different; don't generate a relative path
if (*path_it != *base_it)
return p;
// now advance past drive letters; relative paths should only go up
// to the root of the drive and not past it
++path_it, ++base_it;
#endif
// Cache system-dependent dot, double-dot and slash strings
const std::string _dot = std::string(1, dot<path>::value);
const std::string _dots = std::string(2, dot<path>::value);
const std::string _sep = std::string(1, slash<path>::value);
// iterate over path and base
while (true) {
// compare all elements so far of path and base to find greatest common root;
// when elements of path and base differ, or run out:
if ((path_it == path_end) || (base_it == base_end) || (*path_it != *base_it)) {
// write to output, ../ times the number of remaining elements in base;
// this is how far we've had to come down the tree from base to get to the common root
for (; base_it != base_end; ++base_it) {
if (*base_it == _dot)
continue;
else if (*base_it == _sep)
continue;
output /= "../";
}
// write to output, the remaining elements in path;
// this is the path relative from the common root
boost::filesystem::path::iterator path_it_start = path_it;
for (; path_it != path_end; ++path_it) {
if (path_it != path_it_start)
output /= "/";
if (*path_it == _dot)
continue;
if (*path_it == _sep)
continue;
output /= *path_it;
}
break;
}
// add directory level to both paths and continue iteration
from_path /= path(*path_it);
from_base /= path(*base_it);
++path_it, ++base_it;
}
return output;
}
我刚刚编写了可以将绝对路径转换为相对路径的代码。它适用于我的所有用例,但我不能保证它是完美无瑕的。
为了可读性,我将boost::filesystem省略为"fs"。在函数定义中,可以使用fs::path::current_path((作为"relative_to"的默认值。
fs::path relativePath( const fs::path &path, const fs::path &relative_to )
{
// create absolute paths
fs::path p = fs::absolute(path);
fs::path r = fs::absolute(relative_to);
// if root paths are different, return absolute path
if( p.root_path() != r.root_path() )
return p;
// initialize relative path
fs::path result;
// find out where the two paths diverge
fs::path::const_iterator itr_path = p.begin();
fs::path::const_iterator itr_relative_to = r.begin();
while( itr_path != p.end() && itr_relative_to != r.end() && *itr_path == *itr_relative_to ) {
++itr_path;
++itr_relative_to;
}
// add "../" for each remaining token in relative_to
if( itr_relative_to != r.end() ) {
++itr_relative_to;
while( itr_relative_to != r.end() ) {
result /= "..";
++itr_relative_to;
}
}
// add remaining path
while( itr_path != p.end() ) {
result /= *itr_path;
++itr_path;
}
return result;
}
我只是想将boost::filesystem
用于同一任务,但由于我的应用程序同时使用Qt和Boost库,我决定使用Qt,它通过一个简单的方法QString QDir::relativeFilePath(const QString&fileName(:来完成此任务
QDir dir("/home/bob");
QString s;
s = dir.relativeFilePath("images/file.jpg"); // s is "images/file.jpg"
s = dir.relativeFilePath("/home/mary/file.txt"); // s is "../mary/file.txt"
它就像一个符咒,救了我几个小时的命。
以下是我在boost文件系统之上构建的库中的操作方法:
步骤1:确定"最深的共同根"。基本上,它就像是两条路径的最大公约数。例如,如果有两个路径是"C:\a\b\C\d"answers"C:\a\\b\C\l.txt",那么它们共享的公共根是"C:\a\b\C\"。
要做到这一点,请将这两个路径转换为绝对形式,而不是规范形式(您希望能够为推测路径和符号链接执行此操作(。
步骤2:要从A转到B,您需要在A后面加上足够多的"../"副本,以将目录树向上移动到公共根,然后添加字符串,使B沿着目录树向下移动到它。在windows上,您可以有两个没有公共根的路径,因此从任何A到任何B都不可能。
namespace fs = boost::filesystem;
bool GetCommonRoot(const fs::path& path1,
const fs::path& path2,
fs::path& routeFrom1To2,
std::vector<fs::path>& commonDirsInOrder)
{
fs::path pathA( fs::absolute( path1));
fs::path pathB( fs::absolute( path2));
// Parse both paths into vectors of tokens. I call them "dir" because they'll
// be the common directories unless both paths are the exact same file.
// I also Remove the "." and ".." paths as part of the loops
fs::path::iterator iter;
std::vector<fs::path> dirsA;
std::vector<fs::path> dirsB;
for(iter = pathA.begin(); iter != pathA.end(); ++iter) {
std::string token = (*iter).string();
if(token.compare("..") == 0) { // Go up 1 level => Pop vector
dirsA.pop_back();
}
else if(token.compare(".") != 0) { // "." means "this dir" => ignore it
dirsA.push_back( *iter);
}
}
for(iter = pathB.begin(); iter != pathB.end(); ++iter) {
std::string token = (*iter).string();
if(token.compare("..") == 0) { // Go up 1 level => Pop vector
dirsB.pop_back();
}
else if(token.compare(".") != 0) { // "." means "this dir" => ignore it
dirsB.push_back( *iter);
}
}
// Determine how far to check in each directory set
size_t commonDepth = std::min<int>( dirsA.size(), dirsB.size());
if(!commonDepth) {
// They don't even share a common root- no way from A to B
return false;
}
// Match entries in the 2 vectors until we see a divergence
commonDirsInOrder.clear();
for(size_t i=0; i<commonDepth; ++i) {
if(dirsA[i].string().compare( dirsB[i].string()) != 0) { // Diverged
break;
}
commonDirsInOrder.push_back( dirsA[i]); // I could use dirsB too.
}
// Now determine route: start with A
routeFrom1To2.clear();
for(size_t i=0; i<commonDepth; ++i) {
routeFrom1To2 /= dirsA[i];
}
size_t backupSteps = dirsA.size() - commonDepth; // # of "up dir" moves we need
for(size_t i=0; i<backupSteps; ++i) {
routeFrom1To2 /= "../";
}
// Append B's path to go down to it from the common root
for(size_t i=commonDepth; i<dirsB.size(); ++i) {
routeFrom1To2 /= dirsB[i]; // ensures absolutely correct subdirs
}
return true;
}
这将做你想做的事情-你从A向上,直到你找到它和B都是其后代的公共文件夹,然后向下到B。你可能不需要我的"commonDirsInOrder"返回,但"routeFrom1To2"返回是你想要的。
如果您计划实际将工作目录更改为"B",则可以直接使用"routeFrom1To2"。请注意,尽管有".."部分,该函数仍将生成一个绝对路径,但这应该不是问题。
我已经为这个技巧写下了一个简单的解决方案。boost库上没有使用,只有STL的std::string
、std::vector
。
Win32平台已经过测试。
只是打电话:
strAlgExeFile = helper.GetRelativePath(PathA, PathB);
并且,它将返回从PathA
到PathB
的相对路径。
示例:
strAlgExeFile = helper.GetRelativePath((helper.GetCurrentDir()).c_str(), strAlgExeFile.c_str());
#ifdef _WIN32
#define STR_TOKEN "\"
#define LAST_FOLDER "..\"
#define FOLDER_SEP "\"
#define LINE_BREAK "rn"
#else
#define STR_TOKEN "/"
#define LAST_FOLDER "../"
#define FOLDER_SEP "/"
#define LINE_BREAK "n"
#endif // _WIN32
void CHelper::SplitStr2Vec(const char* pszPath, vector<string>& vecString)
{
char * pch;
pch = strtok (const_cast < char*> (pszPath), STR_TOKEN );
while (pch != NULL)
{
vecString.push_back( pch );
pch = strtok (NULL, STR_TOKEN );
}
}
string& CHelper::GetRelativePath(const char* pszPath1,const char* pszPath2)
{
vector<string> vecPath1, vecPath2;
vecPath1.clear();
vecPath2.clear();
SplitStr2Vec(pszPath1, vecPath1);
SplitStr2Vec(pszPath2, vecPath2);
size_t iSize = ( vecPath1.size() < vecPath2.size() )? vecPath1.size(): vecPath2.size();
unsigned int iSameSize(0);
for (unsigned int i=0; i<iSize; ++i)
{
if ( vecPath1[i] != vecPath2[i])
{
iSameSize = i;
break;
}
}
m_strRelativePath = "";
for (unsigned int i=0 ; i< (vecPath1.size()-iSameSize) ; ++i)
m_strRelativePath += const_cast<char *> (LAST_FOLDER);
for (unsigned int i=iSameSize ; i<vecPath2.size() ; ++i)
{
m_strRelativePath += vecPath2[i];
if( i < (vecPath2.size()-1) )
m_strRelativePath += const_cast<char *> (FOLDER_SEP);
}
return m_strRelativePath;
}
我需要在没有Boost的情况下完成这项工作,而另一个基于std的解决方案不适合我,所以我重新实现了它。当我在做这项工作时,我意识到我以前也做过。。。
不管怎样,它不像其他一些那样完整,但可能对人们有用。它是特定于Windows的;使其成为POSIX的更改涉及字符串比较中的目录分隔符和区分大小写。
在我实现并工作后不久,我不得不将周围的功能转移到Python,所以所有这些都归结为os.path.relpath(to, from)
。
static inline bool StringsEqual_i(const std::string& lhs, const std::string& rhs)
{
return _stricmp(lhs.c_str(), rhs.c_str()) == 0;
}
static void SplitPath(const std::string& in_path, std::vector<std::string>& split_path)
{
size_t start = 0;
size_t dirsep;
do
{
dirsep = in_path.find_first_of("\/", start);
if (dirsep == std::string::npos)
split_path.push_back(std::string(&in_path[start]));
else
split_path.push_back(std::string(&in_path[start], &in_path[dirsep]));
start = dirsep + 1;
} while (dirsep != std::string::npos);
}
/**
* Get the relative path from a base location to a target location.
*
* param to The target location.
* param from The base location. Must be a directory.
* returns The resulting relative path.
*/
static std::string GetRelativePath(const std::string& to, const std::string& from)
{
std::vector<std::string> to_dirs;
std::vector<std::string> from_dirs;
SplitPath(to, to_dirs);
SplitPath(from, from_dirs);
std::string output;
output.reserve(to.size());
std::vector<std::string>::const_iterator to_it = to_dirs.begin(),
to_end = to_dirs.end(),
from_it = from_dirs.begin(),
from_end = from_dirs.end();
while ((to_it != to_end) && (from_it != from_end) && StringsEqual_i(*to_it, *from_it))
{
++to_it;
++from_it;
}
while (from_it != from_end)
{
output += "..\";
++from_it;
}
while (to_it != to_end)
{
output += *to_it;
++to_it;
if (to_it != to_end)
output += "\";
}
return output;
}
- 从 GUID 获取 USB 卷路径
- 获取当前正在运行的 exe 名称(不是路径)
- 如何从 Skia 路径几何体中获取网格?
- 从 C 中的变量获取文件的路径,C++
- 获取 H5::D ataSet 的hid_t和文件中的路径以使用 H5OCopy
- 如何获取 CMake 单元测试的相对路径?
- 如何获取当前用户的默认RAS电话簿路径?
- 我应该如何获取配置文件的绝对路径与 Windows .exe一起发布?
- 获取每个目录或子目录中第一个文件的路径
- 如何自动获取我的项目的路径并删除一些文件
- 获取 JAR 文件中二进制文件的路径
- 如何使用提升获取当前文件路径?
- 如何在 c++ 中获取当前文件路径?
- 无法获取进程 ID 4 (ntoskrnl.exe) 的可执行路径
- 有没有一种简单的方法可以从 c++ 中的路径获取文件名?
- 运行正则表达式时未选中的异常 - 从文件路径获取不带扩展名的文件名
- POSIX 或 Linux API 函数,用于从路径获取文件扩展名
- 通过路径获取 Windows 可执行文件的显示名称
- 从USB设备的设备路径获取卷名
- 如何从其路径获取进程PID