Bir programın çalıştığı dizini nasıl edinebilirim?

C / C ++ kullanarak bir programın çalıştığı dizinin tam yolunu elde etmek için platform-agnostik ve dosya sistemi-agnostik bir yöntem var mı? Geçerli çalışma dizini ile karıştırılmamalıdır. (Lütfen clib veya STL gibi standart olanlar olmadıkça kütüphaneleri önermeyin.)

(Platform / dosya sistemi-agnostik yöntemi yoksa, belirli dosya sistemleri için Windows ve Linux'ta çalışan öneriler de kabul edilir.)

Yürütme uygulamasının tam yolunu almak için kod:

Pencereler:

int bytes = GetModuleFileName(NULL, pBuf, len);
return bytes ? bytes : -1;

Linux:

int bytes = MIN(readlink("/proc/self/exe", pBuf, len), len - 1);
if(bytes >= 0)
    pBuf[bytes] = '\0';
return bytes;

Programınız ilk başlatıldığında geçerli dizini alırsanız, programınızın başlatıldığı dizine etkili bir şekilde sahip olursunuz. Değeri bir değişkende saklayın ve daha sonra programınızda bakın. Bu, geçerli yürütülebilir program dosyasını içeren dizinden farklıdır . Mutlaka aynı dizin değildir; birisi programı komut isteminden çalıştırıyorsa , program dosyası başka bir yerde yaşıyor olsa bile program komut isteminin geçerli çalışma dizininden çalıştırılıyor demektir .

getcwd bir POSIX işlevidir ve tüm POSIX uyumlu platformlar tarafından kutunun dışında desteklenir. Özel bir şey yapmak zorunda kalmazsınız (Unix'te unistd.h ve pencerelerde direct.h başlıklarını dahil etmek dışında).

Bir C programı oluşturduğunuzdan, sistemdeki TÜM işlemlerle (özel hazırlanmış istisnalardan kaçınılması) bağlanan varsayılan c çalışma zamanı kitaplığına bağlanacak ve varsayılan olarak bu işlevi içerecektir. CRT hiçbir zaman harici bir kütüphane olarak kabul edilmez, çünkü bu işletim sistemine temel standart uyumlu arayüz sağlar.

Windows'da getcwd işlevi _getcwd lehine kullanımdan kaldırılmıştır. Bence bu şekilde kullanabilirsiniz.

#include <stdio.h>  /* defines FILENAME_MAX */
#ifdef WINDOWS
    #include <direct.h>
    #define GetCurrentDir _getcwd
#else
    #include <unistd.h>
    #define GetCurrentDir getcwd
 #endif

 char cCurrentPath[FILENAME_MAX];

 if (!GetCurrentDir(cCurrentPath, sizeof(cCurrentPath)))
     {
     return errno;
     }

cCurrentPath[sizeof(cCurrentPath) - 1] = '\0'; /* not really required */

printf ("The current working directory is %s", cCurrentPath);

Bu cplusplus forumundan

Pencerelerde:

#include <string>
#include <windows.h>

std::string getexepath()
{
  char result[ MAX_PATH ];
  return std::string( result, GetModuleFileName( NULL, result, MAX_PATH ) );
}

Linux'ta:

#include <string>
#include <limits.h>
#include <unistd.h>

std::string getexepath()
{
  char result[ PATH_MAX ];
  ssize_t count = readlink( "/proc/self/exe", result, PATH_MAX );
  return std::string( result, (count > 0) ? count : 0 );
}

HP-UX'te:

#include <string>
#include <limits.h>
#define _PSTAT64
#include <sys/pstat.h>
#include <sys/types.h>
#include <unistd.h>

std::string getexepath()
{
  char result[ PATH_MAX ];
  struct pst_status ps;

  if (pstat_getproc( &ps, sizeof( ps ), 0, getpid() ) < 0)
    return std::string();

  if (pstat_getpathname( result, PATH_MAX, &ps.pst_fid_text ) < 0)
    return std::string();

  return std::string( result );
}

Kütüphanesiz standart bir yol istiyorsanız: Hayır. Bir dizinin tüm konsepti standarda dahil değildir.

Standartlara yakın bir lib'a ( taşınabilir) bağımlılığın iyi olduğunu kabul ediyorsanız: Boost'un dosya sistemi kütüphanesini kullanın ve initial_path () öğesini isteyin .

IMHO, alabildiğiniz kadar yakın, iyi karma ile (Boost, iyi kurulmuş yüksek kaliteli bir kütüphaneler dizisidir)

Dosya sistemi TS artık bir standarttır (ve gcc 5.3+ ve clang 3.9+ tarafından desteklenmektedir), böylece current_path()ondan işlevi kullanabilirsiniz :

std::string path = std::experimental::filesystem::current_path();

Gcc'de (5.3+) Dosya Sistemini dahil etmek için şunları kullanmanız gerekir:

#include <experimental/filesystem>

ve kodunuzu -lstdc++fsbayrakla ilişkilendirin.

Dosya Sistemini Microsoft Visual Studio ile kullanmak istiyorsanız bunu okuyun .

Bu soruya bir cevap atmak için çok geç olduğunu biliyorum ama cevapların hiçbirinin benim için benim çözümüm kadar faydalı olmadığını buldum. CWD'nizden bin klasörünüze giden yolu almanın çok basit bir yolu şöyledir:

int main(int argc, char* argv[])
{
    std::string argv_str(argv[0]);
    std::string base = argv_str.substr(0, argv_str.find_last_of("/"));
}

Artık bunu göreli yolunuz için bir temel olarak kullanabilirsiniz. Yani örneğin ben bu dizin yapısı var:

main
  ----> test
  ----> src
  ----> bin

ve bin için kaynak kodumu derlemek ve test etmek için bir günlük yazmak istiyorum Ben sadece bu satırı benim kod ekleyebilirsiniz.

std::string pathToWrite = base + "/../test/test.log";

Bu yolu Linux üzerinde tam yol, takma ad vb. Kullanarak denedim ve gayet iyi çalışıyor.

NOT:

Pencerelerde iseniz, dosya ayırıcı olarak '/' değil '\' kullanmalısınız. Bundan da kaçmanız gerekecek, örneğin:

std::string base = argv[0].substr(0, argv[0].find_last_of("\\"));

Bence bu işe yarıyor ama test değil, bu yüzden eğer çalışırsa yorum ya da değilse bir düzeltme takdir olurdu.

Hayır, standart bir yol yok. C / C ++ standartlarının dizinlerin (veya diğer dosya sistemi kuruluşlarının) varlığını bile dikkate almadığına inanıyorum.

Windows'ta, hModule parametresi NULL olarak ayarlandığında GetModuleFileName () yöntemi geçerli işlemin yürütülebilir dosyasının tam yolunu döndürür . Linux ile yardım edemem.

Ayrıca geçerli dizini veya program görüntüsünün / yürütülebilir dosyasının bulunduğu dizini isteyip istemediğinizi açıklamalısınız. Bu durumda, sorunuz bu noktada biraz belirsiz.

Windows'ta en basit yol, yürütülebilir dosya adı da dahil olmak üzere yürütülebilir dosyanın mutlak yolunu temsil eden bir dizeye işaretçi almak için _get_pgmptrişlevi kullanmaktır stdlib.h.

char* path;
_get_pgmptr(&path);
printf(path); // Example output: C:/Projects/Hello/World.exe

Belki mevcut çalışma dizinini argv [0] ile birleştirin? Bunun Windows'da çalışıp çalışmayacağını bilmiyorum ama linux'da çalışıyor.

Örneğin:

#include <stdio.h>
#include <unistd.h>
#include <string.h>

int main(int argc, char **argv) {
    char the_path[256];

    getcwd(the_path, 255);
    strcat(the_path, "/");
    strcat(the_path, argv[0]);

    printf("%s\n", the_path);

    return 0;
}

Çalıştırıldığında çıktı verir:

jeremy @ jeremy-desktop: ~ / Masaüstü $ ./test
/home/jeremy/Desktop/./test

Win32 için GetCurrentDirectory hile yapmalıdır.

Bu amaçla argv [0] kullanamazsınız, genellikle yürütülebilir dosyanın tam yolunu içerir, ancak zorunlu olarak değil - işlem alanda rastgele bir değerle oluşturulabilir.

Ayrıca, geçerli dizinin ve yürütülebilir dosyanın bulunduğu dizinin iki farklı şey olduğunu unutmayın, bu nedenle getcwd () de size yardımcı olmaz.

Windows'ta GetModuleFileName (), Linux okuma / dev / proc / procID / .. dosyalarını kullanın.

Sadece geç saatlerde buraya yığılmak için ...

standart bir çözüm yoktur, çünkü diller temeldeki dosya sistemlerinden bağımsızdır, bu nedenle diğerlerinin söylediği gibi, dizin tabanlı bir dosya sistemi kavramı c / c ++ dillerinin kapsamı dışındadır.

Bunun üzerine, geçerli çalışma dizinini değil, programın çalıştığı dizini istersiniz, bu da programın bulunduğu yere nasıl geldiğini dikkate almalıdır - yani bir çatal aracılığıyla yeni bir işlem olarak ortaya çıkmıştı. Çözümlerin de gösterdiği gibi, bir programın içinde çalıştığı dizini almak için bu bilgileri söz konusu işletim sisteminin işlem denetim yapılarından almanızı gerektirir, bu da bu sorudaki tek otoritedir. Böylece, tanımı gereği, işletim sistemine özgü bir çözümdür.

Konsoldaki Windows sistemi için system ( dir) komutunu kullanabilirsiniz. Ve konsol size dizin vb. Hakkında bilgi verir. Adresindeki dirkomutu okuyun cmd. Ancak Unix benzeri sistemler için bilmiyorum ... Bu komut çalıştırılırsa bash komutunu okuyun. lsdizin göstermiyor ...

Misal:

int main()
{
    system("dir");
    system("pause"); //this wait for Enter-key-press;
    return 0;
}

#include <windows.h>
using namespace std;

// The directory path returned by native GetCurrentDirectory() no end backslash
string getCurrentDirectoryOnWindows()
{
    const unsigned long maxDir = 260;
    char currentDir[maxDir];
    GetCurrentDirectory(maxDir, currentDir);
    return string(currentDir);
}

POSIX platformlarında getcwd () kullanabilirsiniz .

Windows'ta, getcwd () kullanımı kullanımdan kaldırıldığı için _getcwd () öğesini kullanabilirsiniz .

Standart kitaplıklar için, Boost sizin için yeterince standart olsaydı, Boost :: dosya sistemini önerirdim, ancak yol normalleştirmesini tekliften kaldırmış gibi görünüyorlar. Tamamen standart bir çözüm için TR2'nin hazır olmasını beklemeniz gerekebilir .

Göreli yollar için işte yaptığım şey. Bu sorunun yaşının farkındayım, sadece vakaların çoğunda çalışan daha basit bir cevaba katkıda bulunmak istiyorum:

Diyelim ki böyle bir yolunuz var:

"path/to/file/folder"

Bazı nedenlerden dolayı, tutulma ile yapılan Linux tarafından inşa edilen yürütülebilir dosyalar bununla iyi çalışır. Ancak, böyle bir yol ile çalışmak için windows çok karışık olur!

Yukarıda belirtildiği gibi, çalıştırılabilir yolun mevcut yolunu almanın birkaç yolu vardır, ancak bulmanın en kolay yolu, vakaların çoğunda bir çekicilik sağlar, bunu yolunuzun ÖNÜNE eklemektir:

"./path/to/file/folder"

Sadece "./" ekleyerek sıralamanız gerekir! :) Daha sonra, yürütülebilir dosyada olduğu sürece, istediğiniz dizinden yüklemeye başlayabilirsiniz.

DÜZENLEME: Bu, eğer kullanılan geliştirme ortamı kod :: blokları çalıştırılabilir çalıştırmayı denerseniz işe yaramaz, çünkü bazı nedenlerden dolayı, kod :: blokları doğru şeyler yüklemiyor ...: D

EDIT2: Bulduğum bazı yeni şeyler, kodunuzda böyle bir statik yol belirtirseniz (Örnek.data yüklemeniz gereken bir şey varsayalım):

"resources/Example.data"

Daha sonra uygulamanızı asıl dizinden başlatırsanız (veya Windows'ta bir kısayol yaparsınız ve çalışma dizinini uygulama dizininize ayarlarsanız) bu şekilde çalışır. Eksik kaynak / dosya yollarıyla ilgili sorunları ayıklarken bunu aklınızda bulundurun. (Özellikle IDE'den bir yapı exe başlatırken yanlış çalışma yönünü ayarlayan IDE'lerde)

Bir kütüphane çözümü (bunun istenmediğini bilmeme rağmen). Qt kullanıyorsanız: QCoreApplication::applicationDirPath()

Sadece iki sentim, ancak aşağıdaki kod taşınabilir olarak C ++ 17'de çalışmıyor mu?

#include <iostream>
#include <filesystem>
namespace fs = std::filesystem;

int main(int argc, char* argv[])
{
    std::cout << "Path is " << fs::path(argv[0]).parent_path() << '\n';
}

En azından benim için Linux üzerinde çalışıyor gibi görünüyor.

Önceki fikre dayanarak, şimdi var:

std::filesystem::path prepend_exe_path(const std::string& filename, const std::string& exe_path = "");

Uygulama ile:

fs::path prepend_exe_path(const std::string& filename, const std::string& exe_path)
{
    static auto exe_parent_path = fs::path(exe_path).parent_path();
    return exe_parent_path / filename;
}

Ve başlatma hilesi main():

(void) prepend_exe_path("", argv[0]);

@Sam Redway argv [0] fikri için teşekkürler. Ve elbette, OP'nin soruyu sorduğunda C ++ 17'nin uzun yıllar civarında olmadığını anlıyorum.

Dosya Sistemini Artırın initial_path() POSIX'leri gibi davranır getcwd()ve kendi başınıza istediğinizi yapmaz, ancak argv[0]her ikisine de eklemek bunu yapmalıdır.

Sonucun her zaman hoş olmadığını belirtebilirsiniz; /foo/bar/../../baz/a.out ya da/foo/bar//baz/a.out , ancak her zaman yürütülebilir dosyayı adlandıran geçerli bir yolla sonuçlandığına inanıyorum (bir yoldaki ardışık eğik çizgilerin birine daraltıldığını unutmayın).

Daha önce envp( main()Linux üzerinde çalışan ancak Windows'ta uygulanabilir görünmeyen üçüncü argüman) kullanarak bir çözüm yazdım , bu yüzden daha önce başka biriyle aynı çözümü öneriyorum, ancak bunun neden doğru olduğuna dair ek açıklama ile sonuçlar güzel olmasa bile.

Olarak Minok belirtildiği gibi böyle bir işlevsellik ini Cı standart veya C ++ standart belirtilen vardır. Bu yalnızca işletim sistemine özgü bir özellik olarak kabul edilir ve örneğin POSIX standardında belirtilir.

Thorsten79 iyi bir öneri verdi, Boost.Filesystem kütüphanesi. Ancak, programınız için ikili biçimde herhangi bir bağlantı zamanı bağımlılığı istemiyorsanız bu durum uygun olmayabilir.

Tavsiye edebileceğim iyi bir alternatif, sadece% 100 başlık STLSoft C ++ Kütüphaneleri Matthew Wilson (C ++ hakkında okunması gereken kitapların yazarı) koleksiyonudur . PlatformSTL, sisteme özel API'ye erişim sağlar: Windows için WinSTL ve Unix üzerinde UnixSTL, taşınabilir bir çözümdür. Sisteme özgü tüm unsurlar, özelliklerin ve politikaların kullanımı ile belirtilir, bu nedenle genişletilebilir bir çerçevedir. Tabii ki sağlanan dosya sistemi kütüphanesi var.

Progname linux bash komutu programa giden yolu bildirecektir.

Biri programınızdan hangi komutu verebilir ve çıktıyı bir tmp dosyasına yönlendirse ve program daha sonra bu tmp dosyasını okuyabilse bile, o programın yürütülmekte olup olmadığını size söylemez. Yalnızca bu ada sahip bir programın nerede bulunduğunu söyler.

Gerekli olan işlem kimlik numaranızı elde etmek ve adın yolunu ayrıştırmaktır

Programımda, programın kullanıcının bin dizininden mi yoksa başka bir yoldan mı yoksa / usr / bin'den mi yürütüldüğünü bilmek istiyorum. / usr / bin desteklenen sürümü içerir. Bence Linux'ta taşınabilir tek bir çözüm var.

Kullanım realpath()içinde stdlib.hböyle:

char *working_dir_path = realpath(".", NULL);

C ++ 11'den başlayarak, deneysel dosya sistemi ve C ++ 14-C ++ 17'nin yanı sıra resmi dosya sistemi kullanarak da çalışır.

application.h:

#pragma once

//
// https://en.cppreference.com/w/User:D41D8CD98F/feature_testing_macros
//
#ifdef __cpp_lib_filesystem
#include <filesystem>
#else
#include <experimental/filesystem>

namespace std {
    namespace filesystem = experimental::filesystem;
}
#endif

std::filesystem::path getexepath();

application.cpp:

#include "application.h"
#ifdef _WIN32
#include <windows.h>    //GetModuleFileNameW
#else
#include <limits.h>
#include <unistd.h>     //readlink
#endif

std::filesystem::path getexepath()
{
#ifdef _WIN32
    wchar_t path[MAX_PATH] = { 0 };
    GetModuleFileNameW(NULL, path, MAX_PATH);
    return path;
#else
    char result[PATH_MAX];
    ssize_t count = readlink("/proc/self/exe", result, PATH_MAX);
    return std::string(result, (count > 0) ? count : 0);
#endif
}