Obtenez chemin relatif à partir de deux chemins absolus

De la version 1.60.0 coup de pouce.système de fichiers prend en charge cette. Vous êtes à la recherche pour la fonction de membre path lexically_relative(const path& p) const.

D'origine, pré-1.60.0 réponse ci-dessous.

Boost ne prend pas en charge ce; c'est une question ouverte — #1976 (fonction Inverse pour terminer) — qui, néanmoins, ne semble pas obtenir beaucoup de traction.

Voici un vaguement naïf solution qui semble faire l'affaire (pas sûr si elle peut être améliorée):

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

Je viens de penser à l'aide de boost::filesystem pour la même tâche, mais depuis mon application utilise Qt et bibliothèques Boost, j'ai décidé d'utiliser Qt qui ne de cette tâche avec une méthode simple 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"

Il fonctionne comme un charme et m'a sauvé quelques heures de ma vie.

Voici comment je le fais dans la bibliothèque-je construire sur le dessus de boost, système de fichiers:

Étape 1: Déterminer "la plus profonde racine commune". Fondamentalement, c'est comme le plus grand dénominateur commun pour les 2 chemins. Par exemple, si vous êtes 2 chemins sont "C:\a\b\c\d" et "C:\a\b\c\l.txt" puis la racine commune qu'ils partagent est "C:\a\b\c\".

Pour l'obtenir, convertir les deux chemins en absolu - NON canonique de la forme (vous aurez envie d'être capable de faire cela à des fins de spéculation chemins & liens symboliques).

Étape 2: pour aller de A À B, vous suffixe Un avec suffisamment de copies de "../" pour déplacer vers le haut de l'arborescence du répertoire à la racine commune, puis ajouter la chaîne pour B de descendre de l'arbre. Sur windows, vous pouvez avoir 2 voies avec pas de racine commune, afin d'aller de A à aucun B n'est pas toujours possible.

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;

}

Cela va faire ce que vous voulez - vous aller de Un jusqu'à ce que vous frappez le dossier commun et B sont tous deux des descendants de, puis allez vers le bas à un point B. Vous n'avez probablement pas besoin de la "commonDirsInOrder" retour que j'ai, mais le "routeFrom1To2" retour EST celui que vous demandez.

Si vous prévoyez de changer le répertoire de travail "B", vous pouvez utiliser "routeFrom1To2" directement. Sachez que cette fonction produit un chemin d'accès absolu en dépit de toutes les ".." de pièces, mais cela ne devrait pas être un problème.

Je dois écrire une solution simple pour cette astuce.
Il n'y a pas d'utilisation sur les bibliothèques boost, seulement STL std::string, std::vector.

La plate-forme Win32 a été testé.

Juste appeler:

strAlgExeFile = helper.GetRelativePath(PathA, PathB);

Et, il serait de retour chemin relatif à partir de PathA à PathB.

Exemple:

strAlgExeFile = helper.GetRelativePath((helper.GetCurrentDir()).c_str(), strAlgExeFile.c_str());
#ifdef _WIN32                                                                              
#define STR_TOKEN "\\"                                                                 
#define LAST_FOLDER "..\\"                                                             
#define FOLDER_SEP "\\"                                                                
#define LINE_BREAK "\r\n"                                                              
#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;                                                              
}