filesystem path Sınıfı

Giriş
Şu satırı dahil ederiz.

#include <boost/filesystem.hpp>

Kolay kullanım için şu satırı dahil ederiz.

using namespace boost::filesystem;

C++17 ile gelen path Sınıfı ile aynıdır.

Bu sınıfı dahil edince cout nesnesine wstring yazdırılabilir. Açıklaması şöyle

boost::filesystem::path has an implicit conversion constructor from string_type, which is defined as std::basic_string<value_type>. And value_type is defined variably depending upon environment. Notably, wchar_t on Windows. Which means on Windows, string_type is std::basic_string<wchar_t>, a.k.a. std::wstring.

So your wstring is being implicitly converted to a boost::filesystem::path, which is overloaded for printing through operator<<.

Constructor - char *
Şöyle yaparız.

char *filePath = ...
bfs::path p (filePath);

Şöyle yaparız.

bfs::path p ("/R&D/Project \"boost\"");

& ve " karakterleri için escape karakteri olarak & karakterini kullanır. Bunu cout'a yazdırırsak çıktı olarak şunu alırız.

"/R&&D/Project &"boost&""

Copy Constructor
Şöyle yaparız.

bfs::path folderPath = bfs::path("C:\\Users\\Videos");

directory_iterator nesnesi tarafından oluşturulabilir. Şöyle yaparız.

bfs::directory_iterator itr = ...
bfs::path folderPath = itr->path();

absolute metodu
İmzası şöyle

path absolute (const path& p,const path& base=current_path());

append metodu
İki iterator aralığını nesnemize ekler. Şöyle yaparız.

bfs::path a_From = ...;
bfs::path ret;
bfs::path::const_iterator  itrTo = from.begin();
itrTo++;
ret.append (itr, from.end() );

begin metodu
Iterator döndürür. Şöyle yaparız.

bfs::path from = ...;
bfs::path::const_iterator fromIter = from.begin();

Iterator'ün içine şöyle erişiriz.

if( (*fromIter) != "." ) {...}

empty metodu
Şöyle yaparız.

bfs::path p = ...;

if (p.parent_path().empty())
{...}

end metodu
İterator döndürür. Şöyle yaparız.

bfs::path from = ...;
bfs::path::const_iterator fromIter = from.begin();
// Loop through both
while (fromIter != from.end())
{
  ...
  ++fromIter;
}

extension metodu
Şöyle yaparız. Çıktı olarak ".cpp" alırız.

bfs::path p ("C:\\test.cpp");
bfs::path extension = p.extension();

Uzantının bir set içinde olup olmadığını anlamak için şöyle yaparız.

std::unordered_set<std::string> extensions = { ".txt",".mp3",".jpg" };
auto searchResult = extensions.find(p.extension().string());
if (searchResult != extensions.end())
{
  ...
}

Eğer kendimiz C ile kodlasaydık şöyle yaparız. Burada strrchr() ile en son '.' karakteri bulunur.

int isImage(struct dirent *fichier)
{
  char nomFichier[256];
  strncpy (nomFichier, fichier->d_name, 255);

  char *dot = strrchr(nomFichier, '.');

  if (dot == NULL)
    return 0;  // no extension => it's not an image

  char * listeExtensionImage[] = {".png", ".jpg", ".jpeg", ".bmp" };
  int len = sizeof(listeExtensionImage)/sizeof(listeExtensionImage[0]);

  printf(dot); //Just to test

  for (int i=0; i<len; i++)
  {
    if (strcmp(listeExtensionImage[i], dot) == 0)
      return 1;   // image extension found
  }

  return 0;   // no image extension found
}

filename metodu

İmzası şöyle.

path filename() const;

Yanlış kullanım
Posix sistemlerde bu metod üye bir alanı döner. Bu da kodlama hatalarına sebep oluyor. Şöyle yapmamak lazım.

filesystem::path p = ...;;

const string& s2 = p.filename().string();

Şöyle yaparız.

std::string const s2 = p.filename().string();

Örnek
Dizinin ismini almak için şöyle yaparız.

if (p.filename().string() == L"system32") {...}

Örnek
Dizinin ismini almak için şöyle yaparız.

bfs::path path( "c:/foo/foo1/foo2/foo3/file.txt" );
bfs::path target (path);
target.remove_filename ();
target= target.filename () / path.filename ();

Çıktı olarak şunu alırız

"foo3/file.txt"

is_absolute metodu
Şöyle yaparız.

path a = "/usr/home/";
path b = "/abc";
path c;

if (b.is_absolute())
  c = b;
else
  c = a / b;

is_relative metodu
is_absolute() metodunun tersini yapar. Örnek ver.

lexically_normal metodu
Açıklaması şöyle

Returns *this with redundant current directory (dot), parent directory (dot-dot), and directory-separator elements removed.

Şöyle yaparız.

cout << boost::filesystem::path{"./test"}.lexically_normal().string() << "\n";

operator / metodu
Açıklaması şöyle

Effects:

Appends path::preferred_separator to pathname, converting format and encoding if required ([path.arg.convert]), unless:

• an added separator would be redundant, or
• would change an relative path to an absolute path, or
• p.empty(), or
• *p.native().cbegin() is a directory separator.

Then appends p.native() to pathname.

Returns: *this

Mevcut yola ekleme yapar. Şöyle yaparız.

bfs::path finalPath = ...;
finalPath /= "...";

make_preferred metodu
Açıklaması şöyle

Effects: The contained pathname is converted to the preferred native format. [Note: On Windows, the effect is to replace slashes with backslashes. On POSIX, there is no effect. -- end note]

Şöyle yaparız. Windows'ta / karakterini \ olarak değiştirir.

namespace bfs = boost::filesystem;
bfs::path slash("/");
bfs::path::string_type preferredSlash = slash.make_preferred().native();

operator << metodu
path nesnesini stream'e yazar. Şöyle yaparız.

std::cout << p << std::endl;

Çıktı olarak şuna benzer bir şey alırız.

"../dir/dir2/foo.pcd"

parent_path metodu
Bir üst dizinine erişmek için şöyle yaparız.

bfs::path p ("/path/to/directory/session#/node.conf");
bfs::path target (p.parent_path( ) / "_node.xy");

preferred_separator alanı
Şöyle kullanırız.

bfs::path::preferred_separator

Şöyle yaparız.

std::cout << boost::filesystem::path::preferred_separator << std::endl;

remove_filename metodu
Dosya yolunun bulunduğu dizini almak için şöyle yaparız. parent_path() ile aynı kapıya çıkar.

bfs::path p ("/path/to/directory/session#/node.conf");
p.remove_filename( );

string metodu

Yeni imzası şöyle

string string(const codecvt_type& cvt=codecvt()) const;

Eskiden imzası şöyleydi. Windows'ta std::string, POSIX'te ise std::string& dönüyordu.

#   ifdef BOOST_WINDOWS_API
  const std::string string() const
  {
    [...]
  }
#   else   // BOOST_POSIX_API
    //  string_type is std::string, so there is no conversion
  const std::string&  string() const { return m_pathname; }
    [...]
#   endif

Örnek
Şöyle yaparız.

std::string targetFile = + bfs::path.filename().string();

Örnek
Bir path vector'ünü string vector'e dönüştürmek istersek şöyle yaparız.

std::transform(
  v.begin(), v.end(), std::back_inserter(pathStrs),
  [](const auto &pth) -> decltype(auto) {return pth.string();});

string metodu - template
Şöyle yaparız.

bfs::path p = ...;
std::string str = path.string<std::string>();

Şöyle yaparız.

boost::filesystem::path p = ...;
std::ifstream fin (p.string());

value_type alanı
Açıklaması şöyle

On Windows boost::filesystem::path::value_type is wchar_t, because Windows paths use strings of 16-bit UTF-16 characters. 

Diğer
ofstream ile kullanmak için şöyle yaparız.

boost::filesystem::path fPath{"myfile.txt"};
boost::filesystem::ofstream f{fPath, ios::app};
f << userInput;