blocks|key|1437259|text|下面的方法是一个快速而棘手的解决方案，但请注意，它远不是万无一失的：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1437260|#include+<iostream>

using+namespace+std+;

int+main(+int+argc,+char**+argv)
{
++++cout+<<+argv[0]+<<+endl+;
++++return+0;
}|code-block|syntax|javascript|1437261|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

The following works as a quick and dirty solution, but note that it is far from being foolproof:

<pre><code>#include &lt;iostream&gt;

using namespace std ;

int main( int argc, char** argv)
{
 cout &lt;&lt; argv[0] &lt;&lt; endl ;
 return 0;
}
</code></pre>

blocks|key|1437280|text|这种方式使用了boost+%2B+argv。您提到这可能不是跨平台的，因为它可能包含也可能不包含可执行文件名称。好的，下面的代码应该可以解决这个问题。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1437281|#include+<boost/filesystem/operations.hpp>

#include+<boost/filesystem/path.hpp>

#include+<iostream>

namespace+fs+=+boost::filesystem;


int+main(int+argc,char**+argv)
{
++++fs::path+full_path(+fs::initial_path<fs::path>()+);

++++full_path+=+fs::system_complete(+fs::path(+argv[0]+)+);

++++std::cout+<<+full_path+<<+std::endl;

++++//Without+file+name
++++std::cout+<<+full_path.stem()+<<+std::endl;
++++//std::cout+<<+fs::basename(full_path)+<<+std::endl;

++++return+0;
}|code-block|syntax|javascript|1437282|下面的代码获取当前工作目录，它可能会执行您需要的操作|1437283|#include+<boost/filesystem/operations.hpp>
#include+<boost/filesystem/path.hpp>

#include+<iostream>

namespace+fs+=+boost::filesystem;


int+main(int+argc,char**+argv)
{
++++//current+working+directory
++++fs::path+full_path(+fs::current_path<fs::path>()+);

++++std::cout+<<+full_path+<<+std::endl;

++++std::cout+<<+full_path.stem()+<<+std::endl;
++++//std::cout+<<+fs::basepath(full_path)+<<+std::endl;

++++return+0;
}|1437284|注意:刚刚意识到basename()已被弃用，因此必须切换到.stem()|offset|length|style|CODE|1437285|entityMap^0|0|0|0|0|8|9|U|7|0^^$0|@$1|2|3|4|5|6|7|S|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|T|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|U|8|@]|9|@]|A|$]]|$1|I|3|J|5|D|7|V|8|@]|9|@]|A|$E|F]]|$1|K|3|L|5|6|7|W|8|@$M|X|N|Y|O|P]|$M|Z|N|10|O|P]]|9|@]|A|$]]|$1|Q|3|-4|5|6|7|11|8|@]|9|@]|A|$]]]|R|$]]

This way uses boost + argv. You mentioned this may not be cross platform because it may or may not include the executable name. Well the following code should work around that.

<pre><code>#include &lt;boost/filesystem/operations.hpp&gt;

#include &lt;boost/filesystem/path.hpp&gt;

#include &lt;iostream&gt;

namespace fs = boost::filesystem;


int main(int argc,char** argv)
{
 fs::path full_path( fs::initial_path&lt;fs::path&gt;() );

 full_path = fs::system_complete( fs::path( argv[0] ) );

 std::cout &lt;&lt; full_path &lt;&lt; std::endl;

 //Without file name
 std::cout &lt;&lt; full_path.stem() &lt;&lt; std::endl;
 //std::cout &lt;&lt; fs::basename(full_path) &lt;&lt; std::endl;

 return 0;
}
</code></pre>

The following code gets the current working directory which may do what you need

<pre><code>#include &lt;boost/filesystem/operations.hpp&gt;
#include &lt;boost/filesystem/path.hpp&gt;

#include &lt;iostream&gt;

namespace fs = boost::filesystem;


int main(int argc,char** argv)
{
 //current working directory
 fs::path full_path( fs::current_path&lt;fs::path&gt;() );

 std::cout &lt;&lt; full_path &lt;&lt; std::endl;

 std::cout &lt;&lt; full_path.stem() &lt;&lt; std::endl;
 //std::cout &lt;&lt; fs::basepath(full_path) &lt;&lt; std::endl;

 return 0;
}
</code></pre>

Note
Just realized that <code>basename(</code>) was deprecated so had to switch to <code>.stem()</code>

blocks|key|1222400|text|据我所知，没有跨平台的方式。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1222401|对于Linux：readlink+/proc/self/exe|offset|length|1222402|Windows：GetModuleFileName|1222403|entityMap|0|LINK|mutability|MUTABLE|url|https://linux.die.net/man/2/readlink|1|https://msdn.microsoft.com/en-us/library/windows/desktop/ms683197(v=vs.85).aspx^0|0|8|8|0|0|8|H|1|0^^$0|@$1|2|3|4|5|6|7|R|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|S|8|@]|9|@$D|T|E|U|1|V]]|A|$]]|$1|F|3|G|5|6|7|W|8|@]|9|@$D|X|E|Y|1|Z]]|A|$]]|$1|H|3|-4|5|6|7|10|8|@]|9|@]|A|$]]]|I|$J|$5|K|L|M|A|$N|O]]|P|$5|K|L|M|A|$N|Q]]]]

There is no cross platform way that I know. 

For Linux: <a href="https://linux.die.net/man/2/readlink" rel="noreferrer">readlink</a> /proc/self/exe

Windows: <a href="https://msdn.microsoft.com/en-us/library/windows/desktop/ms683197(v=vs.85).aspx" rel="noreferrer">GetModuleFileName</a>

blocks|key|1437389|text|我对Linux不太确定，但在Windows上试试这个：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1437390|#include+<windows.h>
#include+<iostream>

using+namespace+std+;

int+main()
{
+++++char+ownPth[MAX_PATH];+

+++++//+When+NULL+is+passed+to+GetModuleHandle,+the+handle+of+the+exe+itself+is+returned
+++++HMODULE+hModule+=+GetModuleHandle(NULL);
+++++if+(hModule+!=+NULL)
+++++{
+++++++++//+Use+GetModuleFileName()+with+module+handle+to+get+the+path
+++++++++GetModuleFileName(hModule,+ownPth,+(sizeof(ownPth)));+
+++++++++cout+<<+ownPth+<<+endl+;
+++++++++system("PAUSE");
+++++++++return+0;
+++++}
+++++else
+++++{
+++++++++cout+<<+"Module+handle+is+NULL"+<<+endl+;
+++++++++system("PAUSE");
+++++++++return+0;
+++++}
}|code-block|syntax|javascript|1437391|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

I'm not sure about Linux, but try this for Windows:

<pre><code>#include &lt;windows.h&gt;
#include &lt;iostream&gt;

using namespace std ;

int main()
{
 char ownPth[MAX_PATH]; 

 // When NULL is passed to GetModuleHandle, the handle of the exe itself is returned
 HMODULE hModule = GetModuleHandle(NULL);
 if (hModule != NULL)
 {
 // Use GetModuleFileName() with module handle to get the path
 GetModuleFileName(hModule, ownPth, (sizeof(ownPth))); 
 cout &lt;&lt; ownPth &lt;&lt; endl ;
 system("PAUSE");
 return 0;
 }
 else
 {
 cout &lt;&lt; "Module handle is NULL" &lt;&lt; endl ;
 system("PAUSE");
 return 0;
 }
}
</code></pre>

blocks|key|1222544|text|这是Windows特有的方式，但它至少是您答案的一半。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1222545|GetThisPath.h|offset|length|style|CODE|1222546|///+dest+is+expected+to+be+MAX_PATH+in+length.
///+returns+dest
///+++++TCHAR+dest[MAX_PATH];
///+++++GetThisPath(dest,+MAX_PATH);
TCHAR*+GetThisPath(TCHAR*+dest,+size_t+destSize);|code-block|syntax|javascript|1222547|GetThisPath.cpp|1222548|#include+<Shlwapi.h>
#pragma+comment(lib,+"shlwapi.lib")

TCHAR*+GetThisPath(TCHAR*+dest,+size_t+destSize)
{
++++if+(!dest)+return+NULL;
++++if+(MAX_PATH+>+destSize)+return+NULL;

++++DWORD+length+=+GetModuleFileName(+NULL,+dest,+destSize+);
++++PathRemoveFileSpec(dest);
++++return+dest;
}|1222549|mainProgram.cpp|1222550|TCHAR+dest[MAX_PATH];
GetThisPath(dest,+MAX_PATH);|1222551|我建议使用平台检测作为预处理器指令，以更改为每个平台调用GetThisPath的包装器函数的实现。|1222552|entityMap^0|0|0|D|0|0|0|F|0|0|0|F|0|0|S|B|0^^$0|@$1|2|3|4|5|6|7|Y|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|Z|8|@$D|10|E|11|F|G]]|9|@]|A|$]]|$1|H|3|I|5|J|7|12|8|@]|9|@]|A|$K|L]]|$1|M|3|N|5|6|7|13|8|@$D|14|E|15|F|G]]|9|@]|A|$]]|$1|O|3|P|5|J|7|16|8|@]|9|@]|A|$K|L]]|$1|Q|3|R|5|6|7|17|8|@$D|18|E|19|F|G]]|9|@]|A|$]]|$1|S|3|T|5|J|7|1A|8|@]|9|@]|A|$K|L]]|$1|U|3|V|5|6|7|1B|8|@$D|1C|E|1D|F|G]]|9|@]|A|$]]|$1|W|3|-4|5|6|7|1E|8|@]|9|@]|A|$]]]|X|$]]

This is a Windows specific way, but it is at least half of your answer.

<code>GetThisPath.h</code>

<pre><code>/// dest is expected to be MAX_PATH in length.
/// returns dest
/// TCHAR dest[MAX_PATH];
/// GetThisPath(dest, MAX_PATH);
TCHAR* GetThisPath(TCHAR* dest, size_t destSize);
</code></pre>

<code>GetThisPath.cpp</code>

<pre><code>#include &lt;Shlwapi.h&gt;
#pragma comment(lib, "shlwapi.lib")

TCHAR* GetThisPath(TCHAR* dest, size_t destSize)
{
 if (!dest) return NULL;
 if (MAX_PATH &gt; destSize) return NULL;

 DWORD length = GetModuleFileName( NULL, dest, destSize );
 PathRemoveFileSpec(dest);
 return dest;
}
</code></pre>

<code>mainProgram.cpp</code>

<pre><code>TCHAR dest[MAX_PATH];
GetThisPath(dest, MAX_PATH);
</code></pre>

I would suggest using platform detection as preprocessor directives to change the implementation of a wrapper function that calls <code>GetThisPath</code> for each platform.

blocks|key|1437516|text|char+exePath[512];
CString+strexePath;
GetModuleFileName(NULL,exePath,512);
strexePath.Format("%25s",exePath);
strexePath+=+strexePath.Mid(0,strexePath.ReverseFind('\\'));|type|code-block|depth|inlineStyleRanges|entityRanges|data|syntax|javascript|1437517|unstyled|entityMap^0|0^^$0|@$1|2|3|4|5|6|7|G|8|@]|9|@]|A|$B|C]]|$1|D|3|-4|5|E|7|H|8|@]|9|@]|A|$]]]|F|$]]

<pre><code>char exePath[512];
CString strexePath;
GetModuleFileName(NULL,exePath,512);
strexePath.Format("%s",exePath);
strexePath = strexePath.Mid(0,strexePath.ReverseFind('\\'));
</code></pre>

blocks|key|1222616|text|在Unix(包括Linux)中，try+'which'，在Windows中try+'where‘。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1222617|#include+<stdio.h>

#define+_UNIX

int+main(int+argc,+char**+argv)
{
++++++++char+cmd[128];
++++++++char+buf[128];
++++++++FILE*+fp+=+NULL;
#if+defined(_UNIX)
++++++++sprintf(cmd,+"which+%25s+>+my.path",+argv[0]);
#else
++++++++sprintf(cmd,+"where+%25s+>+my.path",+argv[0]);
#endif
++++++++system(cmd);
++++++++fp+=+fopen("my.path",+"r");
++++++++fgets(buf,+sizeof(buf),+fp);
++++++++fclose(fp);

++++++++printf("full+path:+%25s\n",+buf);
++++++++unlink("my.path");

++++++++return+0;
}|code-block|syntax|javascript|1222618|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

in Unix(including Linux) try 'which', in Windows try 'where'.

<pre><code>#include &lt;stdio.h&gt;

#define _UNIX

int main(int argc, char** argv)
{
 char cmd[128];
 char buf[128];
 FILE* fp = NULL;
#if defined(_UNIX)
 sprintf(cmd, "which %s &gt; my.path", argv[0]);
#else
 sprintf(cmd, "where %s &gt; my.path", argv[0]);
#endif
 system(cmd);
 fp = fopen("my.path", "r");
 fgets(buf, sizeof(buf), fp);
 fclose(fp);

 printf("full path: %s\n", buf);
 unlink("my.path");

 return 0;
}
</code></pre>

blocks|key|1222702|text|使用args并查找'/‘(或'\')：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1222703|#include+<string>
#include+<iostream>+//+to+show+the+result

int+main(+int+numArgs,+char+*args[])
{
++++//+Get+the+last+position+of+'/'
++++std::string+aux(args[0]);

++++//+get+'/'+or+'\\'+depending+on+unix/mac+or+windows.
#if+defined(_WIN32)+%7C%7C+defined(WIN32)
++++int+pos+=+aux.rfind('\\');
#else
++++int+pos+=+aux.rfind('/');
#endif

++++//+Get+the+path+and+the+name
++++std::string+path+=+aux.substr(0,pos%2B1);
++++std::string+name+=+aux.substr(pos%2B1);
++++//+show+results
++++std::cout+<<+"Path:+"+<<+path+<<+std::endl;
++++std::cout+<<+"Name:+"+<<+name+<<+std::endl;
}|code-block|syntax|javascript|1222704|编辑:如果'/‘不存在，pos==-1，所以结果是正确的。|1222705|entityMap^0|0|0|0^^$0|@$1|2|3|4|5|6|7|K|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|L|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|M|8|@]|9|@]|A|$]]|$1|I|3|-4|5|6|7|N|8|@]|9|@]|A|$]]]|J|$]]

Using args[0] and looking for '/' (or '\\'):

<pre><code>#include &lt;string&gt;
#include &lt;iostream&gt; // to show the result

int main( int numArgs, char *args[])
{
 // Get the last position of '/'
 std::string aux(args[0]);

 // get '/' or '\\' depending on unix/mac or windows.
#if defined(_WIN32) || defined(WIN32)
 int pos = aux.rfind('\\');
#else
 int pos = aux.rfind('/');
#endif

 // Get the path and the name
 std::string path = aux.substr(0,pos+1);
 std::string name = aux.substr(pos+1);
 // show results
 std::cout &lt;&lt; "Path: " &lt;&lt; path &lt;&lt; std::endl;
 std::cout &lt;&lt; "Name: " &lt;&lt; name &lt;&lt; std::endl;
}
</code></pre>

EDITED:
If '/' does not exist, pos==-1 so the result is correct.

blocks|key|1222759|text|QT为其提供了作为QCoreApplication::applicationDirPath()的操作系统抽象|type|unstyled|depth|inlineStyleRanges|entityRanges|offset|length|data|1222760|entityMap|0|LINK|mutability|MUTABLE|url|http://doc.qt.io/qt-5/qcoreapplication.html#applicationDirPath^0|9|12|0|0^^$0|@$1|2|3|4|5|6|7|L|8|@]|9|@$A|M|B|N|1|O]]|C|$]]|$1|D|3|-4|5|6|7|P|8|@]|9|@]|C|$]]]|E|$F|$5|G|H|I|C|$J|K]]]]

QT provides this with OS abstraction as <a href="http://doc.qt.io/qt-5/qcoreapplication.html#applicationDirPath" rel="noreferrer">QCoreApplication::applicationDirPath()</a>

blocks|key|1222784|text|此方法适用于Windows和Linux：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1222785|#include+<stdio.h>
#include+<string>
#ifdef+_WIN32
#include+<direct.h>
#define+GetCurrentDir+_getcwd
#elif+__linux__
#include+<unistd.h>
#define+GetCurrentDir+getcwd
#endif

std::string+GetCurrentWorkingDir()+
{
++++char+buff[FILENAME_MAX];
++++GetCurrentDir(buff,+FILENAME_MAX);
++++std::string+current_working_dir(buff);
++++return+current_working_dir;
}|code-block|syntax|javascript|1222786|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

This method works for both Windows and Linux:

<pre><code>#include &lt;stdio.h&gt;
#include &lt;string&gt;
#ifdef _WIN32
#include &lt;direct.h&gt;
#define GetCurrentDir _getcwd
#elif __linux__
#include &lt;unistd.h&gt;
#define GetCurrentDir getcwd
#endif

std::string GetCurrentWorkingDir() 
{
 char buff[FILENAME_MAX];
 GetCurrentDir(buff, FILENAME_MAX);
 std::string current_working_dir(buff);
 return current_working_dir;
}
</code></pre>

blocks|key|1437774|text|对于Windows，您遇到了如何从GetModuleFileName()的结果中剥离可执行文件的问题。Nate在他回答中用于此目的的Windows+API调用PathRemoveFileSpec()在Windows8及其前身之间发生了变化。那么如何才能同时兼容和安全呢？幸运的是，有C%2B%2B17+(或者Boost，如果您使用的是较旧的编译器)。我这样做：|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|1437775|#include+<windows.h>
#include+<string>
#include+<filesystem>
namespace+fs+=+std::experimental::filesystem;

//+We+could+use+fs::path+as+return+type,+but+if+you're+not+aware+of
//+std::experimental::filesystem,+you+probably+handle+filenames
//+as+strings+anyway+in+the+remainder+of+your+code.++I'm+on+Japanese
//+Windows,+so+wide+chars+are+a+must.
std::wstring+getDirectoryWithCurrentExecutable()
{
++++int+size+=+256;
++++std::vector<wchar_t>+charBuffer;
++++//+Let's+be+safe,+and+find+the+right+buffer+size+programmatically.
++++do+{
++++++++size+*=+2;
++++++++charBuffer.resize(size);
++++++++//+Resize+until+filename+fits.++GetModuleFileNameW+returns+the
++++++++//+number+of+characters+written+to+the+buffer,+so+if+the
++++++++//+return+value+is+smaller+than+the+size+of+the+buffer,+it+was
++++++++//+large+enough.
++++}+while+(GetModuleFileNameW(NULL,+charBuffer.data(),+size)+==+size);
++++//+Typically:+c:/program+files+(x86)/something/foo/bar/exe/files/win64/baz.exe
++++//+(Note+that+windows+supports+forward+and+backward+slashes+as+path
++++//+separators,+so+you+have+to+be+careful+when+searching+through+a+path
++++//+manually.)

++++//+Let's+extract+the+interesting+part:
++++fs::path+path(charBuffer.data());++//+Contains+the+full+path+including+.exe
++++return+path.remove_filename()++//+Extract+the+directory+...
+++++++++++++++.w_str();+++++++++++//+...+and+convert+to+a+string.
}|code-block|syntax|javascript|1437776|entityMap^0|H|J|27|K|0|0^^$0|@$1|2|3|4|5|6|7|M|8|@$9|N|A|O|B|C]|$9|P|A|Q|B|C]]|D|@]|E|$]]|$1|F|3|G|5|H|7|R|8|@]|D|@]|E|$I|J]]|$1|K|3|-4|5|6|7|S|8|@]|D|@]|E|$]]]|L|$]]

For Windows, you have the problem of how to strip the executable from the result of <code>GetModuleFileName()</code>. The Windows API call <code>PathRemoveFileSpec()</code> that Nate used for that purpose in his answer changed between Windows 8 and its predecessors. So how to remain compatible with both and safe? Luckily, there's C++17 (or Boost, if you're using an older compiler). I do this:

<pre><code>#include &lt;windows.h&gt;
#include &lt;string&gt;
#include &lt;filesystem&gt;
namespace fs = std::experimental::filesystem;

// We could use fs::path as return type, but if you're not aware of
// std::experimental::filesystem, you probably handle filenames
// as strings anyway in the remainder of your code. I'm on Japanese
// Windows, so wide chars are a must.
std::wstring getDirectoryWithCurrentExecutable()
{
 int size = 256;
 std::vector&lt;wchar_t&gt; charBuffer;
 // Let's be safe, and find the right buffer size programmatically.
 do {
 size *= 2;
 charBuffer.resize(size);
 // Resize until filename fits. GetModuleFileNameW returns the
 // number of characters written to the buffer, so if the
 // return value is smaller than the size of the buffer, it was
 // large enough.
 } while (GetModuleFileNameW(NULL, charBuffer.data(), size) == size);
 // Typically: c:/program files (x86)/something/foo/bar/exe/files/win64/baz.exe
 // (Note that windows supports forward and backward slashes as path
 // separators, so you have to be careful when searching through a path
 // manually.)

 // Let's extract the interesting part:
 fs::path path(charBuffer.data()); // Contains the full path including .exe
 return path.remove_filename() // Extract the directory ...
 .w_str(); // ... and convert to a string.
}
</code></pre>

blocks|key|1222923|text|这是我在Windows中的解决方案。名字是这样的：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1222924|std::wstring+sResult+=+GetPathOfEXE(64);|code-block|syntax|javascript|1222925|其中64是您认为路径的最小大小。GetPathOfEXE递归地调用自己，每次都会将缓冲区的大小增加一倍，直到它获得足够大的缓冲区，以便在不截断的情况下获得整个路径。|1222926|std::wstring+GetPathOfEXE(DWORD+dwSize)
{
++++WCHAR*+pwcharFileNamePath;
++++DWORD+dwLastError;
++++HRESULT+hrError;
++++std::wstring+wsResult;
++++DWORD+dwCount;

++++pwcharFileNamePath+=+new+WCHAR[dwSize];

++++dwCount+=+GetModuleFileNameW(
++++++++NULL,
++++++++pwcharFileNamePath,
++++++++dwSize
++++);

++++dwLastError+=+GetLastError();

++++if+(ERROR_SUCCESS+==+dwLastError)
++++{
++++++++hrError+=+PathCchRemoveFileSpec(
++++++++++++pwcharFileNamePath,
++++++++++++dwCount
++++++++);

++++++++if+(S_OK+==+hrError)
++++++++{
++++++++++++wsResult+=+pwcharFileNamePath;

++++++++++++if+(pwcharFileNamePath)
++++++++++++{
++++++++++++++++delete+pwcharFileNamePath;
++++++++++++}

++++++++++++return+wsResult;
++++++++}
++++++++else+if(S_FALSE+==+hrError)
++++++++{
++++++++++++wsResult+=+pwcharFileNamePath;

++++++++++++if+(pwcharFileNamePath)
++++++++++++{
++++++++++++++++delete+pwcharFileNamePath;
++++++++++++}

++++++++++++//there+was+nothing+to+truncate+off+the+end+of+the+path
++++++++++++//returning+something+better+than+nothing+in+this+case+for+the+user
++++++++++++return+wsResult;
++++++++}
++++++++else
++++++++{
++++++++++++if+(pwcharFileNamePath)
++++++++++++{
++++++++++++++++delete+pwcharFileNamePath;
++++++++++++}

++++++++++++std::ostringstream+oss;
++++++++++++oss+<<+"could+not+get+file+name+and+path+of+executing+process.+error+truncating+file+name+off+path.+last+error+:+"+<<+hrError;
++++++++++++throw+std::runtime_error(oss.str().c_str());
++++++++}
++++}
++++else+if+(ERROR_INSUFFICIENT_BUFFER+==+dwLastError)
++++{
++++++++if+(pwcharFileNamePath)
++++++++{
++++++++++++delete+pwcharFileNamePath;
++++++++}

++++++++return+GetPathOfEXE(
++++++++++++dwSize+*+2
++++++++);
++++}
++++else
++++{
++++++++if+(pwcharFileNamePath)
++++++++{
++++++++++++delete+pwcharFileNamePath;
++++++++}

++++++++std::ostringstream+oss;
++++++++oss+<<+"could+not+get+file+name+and+path+of+executing+process.+last+error+:+"+<<+dwLastError;
++++++++throw+std::runtime_error(oss.str().c_str());
++++}
}|1222927|entityMap^0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|M|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|N|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|O|8|@]|9|@]|A|$]]|$1|I|3|J|5|D|7|P|8|@]|9|@]|A|$E|F]]|$1|K|3|-4|5|6|7|Q|8|@]|9|@]|A|$]]]|L|$]]

This was my solution in Windows. It is called like this:

<pre><code>std::wstring sResult = GetPathOfEXE(64);
</code></pre>

Where 64 is the minimum size you think the path will be. GetPathOfEXE calls itself recursively, doubling the size of the buffer each time until it gets a big enough buffer to get the whole path without truncation.

<pre><code>std::wstring GetPathOfEXE(DWORD dwSize)
{
 WCHAR* pwcharFileNamePath;
 DWORD dwLastError;
 HRESULT hrError;
 std::wstring wsResult;
 DWORD dwCount;

 pwcharFileNamePath = new WCHAR[dwSize];

 dwCount = GetModuleFileNameW(
 NULL,
 pwcharFileNamePath,
 dwSize
 );

 dwLastError = GetLastError();

 if (ERROR_SUCCESS == dwLastError)
 {
 hrError = PathCchRemoveFileSpec(
 pwcharFileNamePath,
 dwCount
 );

 if (S_OK == hrError)
 {
 wsResult = pwcharFileNamePath;

 if (pwcharFileNamePath)
 {
 delete pwcharFileNamePath;
 }

 return wsResult;
 }
 else if(S_FALSE == hrError)
 {
 wsResult = pwcharFileNamePath;

 if (pwcharFileNamePath)
 {
 delete pwcharFileNamePath;
 }

 //there was nothing to truncate off the end of the path
 //returning something better than nothing in this case for the user
 return wsResult;
 }
 else
 {
 if (pwcharFileNamePath)
 {
 delete pwcharFileNamePath;
 }

 std::ostringstream oss;
 oss &lt;&lt; "could not get file name and path of executing process. error truncating file name off path. last error : " &lt;&lt; hrError;
 throw std::runtime_error(oss.str().c_str());
 }
 }
 else if (ERROR_INSUFFICIENT_BUFFER == dwLastError)
 {
 if (pwcharFileNamePath)
 {
 delete pwcharFileNamePath;
 }

 return GetPathOfEXE(
 dwSize * 2
 );
 }
 else
 {
 if (pwcharFileNamePath)
 {
 delete pwcharFileNamePath;
 }

 std::ostringstream oss;
 oss &lt;&lt; "could not get file name and path of executing process. last error : " &lt;&lt; dwLastError;
 throw std::runtime_error(oss.str().c_str());
 }
}
</code></pre>

blocks|key|1222985|text|如果您需要处理Windows的unicode路径：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1222986|#include+<Windows.h>
#include+<iostream>

int+wmain(int+argc,+wchar_t+*+argv[])
{
++++HMODULE+this_process_handle+=+GetModuleHandle(NULL);
++++wchar_t+this_process_path[MAX_PATH];

++++GetModuleFileNameW(NULL,+this_process_path,+sizeof(this_process_path));

++++std::wcout+<<+"Unicode+path+of+this+app:+"+<<+this_process_path+<<+std::endl;

++++return+0;
}|code-block|syntax|javascript|1222987|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

In case you need to handle unicode paths for Windows:

<pre><code>#include &lt;Windows.h&gt;
#include &lt;iostream&gt;

int wmain(int argc, wchar_t * argv[])
{
 HMODULE this_process_handle = GetModuleHandle(NULL);
 wchar_t this_process_path[MAX_PATH];

 GetModuleFileNameW(NULL, this_process_path, sizeof(this_process_path));

 std::wcout &lt;&lt; "Unicode path of this app: " &lt;&lt; this_process_path &lt;&lt; std::endl;

 return 0;
}
</code></pre>

blocks|key|1223102|text|正如其他人提到的，如果平台确实通过了可执行文件路径，那么argv[0]是一个相当好的解决方案，这肯定不会比操作系统更有可能(+WinAPI可以帮助找到可执行文件路径)。如果您希望将字符串剥离为仅包含可执行文件所在目录的路径，则使用该路径查找其他应用程序文件(例如，如果您的程序是游戏，则为游戏资产)是完全可以的，因为打开文件是相对于工作目录的，或者，如果提供了根目录，则是相对的。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|1223103|entityMap^0|S|7|0^^$0|@$1|2|3|4|5|6|7|H|8|@$9|I|A|J|B|C]]|D|@]|E|$]]|$1|F|3|-4|5|6|7|K|8|@]|D|@]|E|$]]]|G|$]]

As others mentioned, <code>argv[0]</code> is quite a nice solution, provided that the platform actually passes the executable path, which is surely not less probable than the OS being Windows (where WinAPI can help find the executable path). If you want to strip the string to only include the path to the directory where the executable resides, then using that path to find other application files (like game assets if your program is a game) is perfectly fine, since opening files is relative to the working directory, or, if provided, the root.

blocks|key|1223184|text|C%2B%2B17，windows，unicode，使用文件系统的新api：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1223185|#include+"..\Project.h"
#include+<filesystem>
using+namespace+std;
using+namespace+filesystem;

int+wmain(int+argc,+wchar_t**+argv)
{
++++auto+dir+=+weakly_canonical(path(argv[0])).parent_path();
++++printf("%25S",+dir.c_str());
++++return+0;
}|code-block|syntax|javascript|1223186|我怀疑这个解决方案应该是可移植的，但不知道unicode是如何在其他操作系统上实现的。|1223187|仅当您将上层文件夹引用('..')用作输出目录时，才需要weakly_canonical简化路径。如果你不使用它--把它去掉。|1223188|如果您正在使用动态链接库(.dll+/.so)进行操作，那么您可能没有argv，那么您可以考虑以下解决方案：|1223189|application.h：|1223190|#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();|1223191|application.cpp：|1223192|#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
}|1223193|entityMap^0|0|0|0|0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|W|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|X|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|Y|8|@]|9|@]|A|$]]|$1|I|3|J|5|6|7|Z|8|@]|9|@]|A|$]]|$1|K|3|L|5|6|7|10|8|@]|9|@]|A|$]]|$1|M|3|N|5|6|7|11|8|@]|9|@]|A|$]]|$1|O|3|P|5|D|7|12|8|@]|9|@]|A|$E|F]]|$1|Q|3|R|5|6|7|13|8|@]|9|@]|A|$]]|$1|S|3|T|5|D|7|14|8|@]|9|@]|A|$E|F]]|$1|U|3|-4|5|6|7|15|8|@]|9|@]|A|$]]]|V|$]]

C++17, windows, unicode, using filesystem new api:

<pre><code>#include "..\Project.h"
#include &lt;filesystem&gt;
using namespace std;
using namespace filesystem;

int wmain(int argc, wchar_t** argv)
{
 auto dir = weakly_canonical(path(argv[0])).parent_path();
 printf("%S", dir.c_str());
 return 0;
}
</code></pre>

Suspect this solution should be portable, but don't know how unicode is implemented on other OS's.

weakly_canonical is needed only if you use as Output Directory upper folder references ('..') to simplify path. If you don't use it - remove it.

If you're operating from dynamic link library (.dll /.so), then you might not have argv, then you can consider following solution:

application.h:

<pre><code>#pragma once

//
// https://en.cppreference.com/w/User:D41D8CD98F/feature_testing_macros
//
#ifdef __cpp_lib_filesystem
#include &lt;filesystem&gt;
#else
#include &lt;experimental/filesystem&gt;

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

std::filesystem::path getexepath();
</code></pre>

application.cpp:

<pre><code>#include "application.h"
#ifdef _WIN32
#include &lt;windows.h&gt; //GetModuleFileNameW
#else
#include &lt;limits.h&gt;
#include &lt;unistd.h&gt; //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 &gt; 0) ? count : 0);
#endif
}
</code></pre>

blocks|key|1438136|text|截至C%2B%2B17：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1438137|确保包含std文件系统。|1438138|#include+<filesystem>|code-block|syntax|javascript|1438139|现在你可以这么做了。|1438140|std::filesystem::current_path().string()|1438141|boost文件系统成为标准库的一部分。|1438142|如果您找不到它，请尝试在以下目录中查找：|1438143|std::experimental::filesystem|1438144|entityMap^0|0|0|0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|U|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|V|8|@]|9|@]|A|$]]|$1|D|3|E|5|F|7|W|8|@]|9|@]|A|$G|H]]|$1|I|3|J|5|6|7|X|8|@]|9|@]|A|$]]|$1|K|3|L|5|F|7|Y|8|@]|9|@]|A|$G|H]]|$1|M|3|N|5|6|7|Z|8|@]|9|@]|A|$]]|$1|O|3|P|5|6|7|10|8|@]|9|@]|A|$]]|$1|Q|3|R|5|F|7|11|8|@]|9|@]|A|$G|H]]|$1|S|3|-4|5|6|7|12|8|@]|9|@]|A|$]]]|T|$]]

As of C++17:

Make sure you include std filesystem.

<pre><code>#include &lt;filesystem&gt;
</code></pre>

and now you can do this.

<pre><code>std::filesystem::current_path().string()
</code></pre>

boost filesystem became part of the standard lib. 

if you can't find it try to look under:

<pre><code>std::experimental::filesystem
</code></pre>

blocks|key|1223419|text|这就是我最终得到的结果|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1223420|头文件如下所示：|1223421|#pragma+once

#include+<string>
namespace+MyPaths+{

++std::string+getExecutablePath();
++std::string+getExecutableDir();
++std::string+mergePaths(std::string+pathA,+std::string+pathB);
++bool+checkIfFileExists+(const+std::string&+filePath);

}|code-block|syntax|javascript|1223422|实现|1223423|#if+defined(_WIN32)
++++#include+<windows.h>
++++#include+<Shlwapi.h>
++++#include+<io.h>+

++++#define+access+_access_s
#endif

#ifdef+__APPLE__
++++#include+<libgen.h>
++++#include+<limits.h>
++++#include+<mach-o/dyld.h>
++++#include+<unistd.h>
#endif

#ifdef+__linux__
++++#include+<limits.h>
++++#include+<libgen.h>
++++#include+<unistd.h>

++++#if+defined(__sun)
++++++++#define+PROC_SELF_EXE+"/proc/self/path/a.out"
++++#else
++++++++#define+PROC_SELF_EXE+"/proc/self/exe"
++++#endif

#endif

namespace+MyPaths+{

#if+defined(_WIN32)

std::string+getExecutablePath()+{
+++char+rawPathName[MAX_PATH];
+++GetModuleFileNameA(NULL,+rawPathName,+MAX_PATH);
+++return+std::string(rawPathName);
}

std::string+getExecutableDir()+{
++++std::string+executablePath+=+getExecutablePath();
++++char*+exePath+=+new+char[executablePath.length()];
++++strcpy(exePath,+executablePath.c_str());
++++PathRemoveFileSpecA(exePath);
++++std::string+directory+=+std::string(exePath);
++++delete[]+exePath;
++++return+directory;
}

std::string+mergePaths(std::string+pathA,+std::string+pathB)+{
++char+combined[MAX_PATH];
++PathCombineA(combined,+pathA.c_str(),+pathB.c_str());
++std::string+mergedPath(combined);
++return+mergedPath;
}

#endif

#ifdef+__linux__

std::string+getExecutablePath()+{
+++char+rawPathName[PATH_MAX];
+++realpath(PROC_SELF_EXE,+rawPathName);
+++return++std::string(rawPathName);
}

std::string+getExecutableDir()+{
++++std::string+executablePath+=+getExecutablePath();
++++char+*executablePathStr+=+new+char[executablePath.length()+%2B+1];
++++strcpy(executablePathStr,+executablePath.c_str());
++++char*+executableDir+=+dirname(executablePathStr);
++++delete+[]+executablePathStr;
++++return+std::string(executableDir);
}

std::string+mergePaths(std::string+pathA,+std::string+pathB)+{
++return+pathA%2B"/"%2BpathB;
}

#endif

#ifdef+__APPLE__
++++std::string+getExecutablePath()+{
++++++++char+rawPathName[PATH_MAX];
++++++++char+realPathName[PATH_MAX];
++++++++uint32_t+rawPathSize+=+(uint32_t)sizeof(rawPathName);

++++++++if(!_NSGetExecutablePath(rawPathName,+&rawPathSize))+{
++++++++++++realpath(rawPathName,+realPathName);
++++++++}
++++++++return++std::string(realPathName);
++++}

++++std::string+getExecutableDir()+{
++++++++std::string+executablePath+=+getExecutablePath();
++++++++char+*executablePathStr+=+new+char[executablePath.length()+%2B+1];
++++++++strcpy(executablePathStr,+executablePath.c_str());
++++++++char*+executableDir+=+dirname(executablePathStr);
++++++++delete+[]+executablePathStr;
++++++++return+std::string(executableDir);
++++}

++++std::string+mergePaths(std::string+pathA,+std::string+pathB)+{
++++++++return+pathA%2B"/"%2BpathB;
++++}
#endif


bool+checkIfFileExists+(const+std::string&+filePath)+{
+++return+access(+filePath.c_str(),+0+)+==+0;
}

}|1223424|entityMap^0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|O|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|P|8|@]|9|@]|A|$]]|$1|D|3|E|5|F|7|Q|8|@]|9|@]|A|$G|H]]|$1|I|3|J|5|6|7|R|8|@]|9|@]|A|$]]|$1|K|3|L|5|F|7|S|8|@]|9|@]|A|$G|H]]|$1|M|3|-4|5|6|7|T|8|@]|9|@]|A|$]]]|N|$]]

This is what I ended up with 

The header file looks like this:

<pre class="lang-cpp prettyprint-override"><code>#pragma once

#include &lt;string&gt;
namespace MyPaths {

 std::string getExecutablePath();
 std::string getExecutableDir();
 std::string mergePaths(std::string pathA, std::string pathB);
 bool checkIfFileExists (const std::string&amp; filePath);

}

</code></pre>

Implementation

<pre class="lang-cpp prettyprint-override"><code>
#if defined(_WIN32)
 #include &lt;windows.h&gt;
 #include &lt;Shlwapi.h&gt;
 #include &lt;io.h&gt; 

 #define access _access_s
#endif

#ifdef __APPLE__
 #include &lt;libgen.h&gt;
 #include &lt;limits.h&gt;
 #include &lt;mach-o/dyld.h&gt;
 #include &lt;unistd.h&gt;
#endif

#ifdef __linux__
 #include &lt;limits.h&gt;
 #include &lt;libgen.h&gt;
 #include &lt;unistd.h&gt;

 #if defined(__sun)
 #define PROC_SELF_EXE "/proc/self/path/a.out"
 #else
 #define PROC_SELF_EXE "/proc/self/exe"
 #endif

#endif

namespace MyPaths {

#if defined(_WIN32)

std::string getExecutablePath() {
 char rawPathName[MAX_PATH];
 GetModuleFileNameA(NULL, rawPathName, MAX_PATH);
 return std::string(rawPathName);
}

std::string getExecutableDir() {
 std::string executablePath = getExecutablePath();
 char* exePath = new char[executablePath.length()];
 strcpy(exePath, executablePath.c_str());
 PathRemoveFileSpecA(exePath);
 std::string directory = std::string(exePath);
 delete[] exePath;
 return directory;
}

std::string mergePaths(std::string pathA, std::string pathB) {
 char combined[MAX_PATH];
 PathCombineA(combined, pathA.c_str(), pathB.c_str());
 std::string mergedPath(combined);
 return mergedPath;
}

#endif

#ifdef __linux__

std::string getExecutablePath() {
 char rawPathName[PATH_MAX];
 realpath(PROC_SELF_EXE, rawPathName);
 return std::string(rawPathName);
}

std::string getExecutableDir() {
 std::string executablePath = getExecutablePath();
 char *executablePathStr = new char[executablePath.length() + 1];
 strcpy(executablePathStr, executablePath.c_str());
 char* executableDir = dirname(executablePathStr);
 delete [] executablePathStr;
 return std::string(executableDir);
}

std::string mergePaths(std::string pathA, std::string pathB) {
 return pathA+"/"+pathB;
}

#endif

#ifdef __APPLE__
 std::string getExecutablePath() {
 char rawPathName[PATH_MAX];
 char realPathName[PATH_MAX];
 uint32_t rawPathSize = (uint32_t)sizeof(rawPathName);

 if(!_NSGetExecutablePath(rawPathName, &amp;rawPathSize)) {
 realpath(rawPathName, realPathName);
 }
 return std::string(realPathName);
 }

 std::string getExecutableDir() {
 std::string executablePath = getExecutablePath();
 char *executablePathStr = new char[executablePath.length() + 1];
 strcpy(executablePathStr, executablePath.c_str());
 char* executableDir = dirname(executablePathStr);
 delete [] executablePathStr;
 return std::string(executableDir);
 }

 std::string mergePaths(std::string pathA, std::string pathB) {
 return pathA+"/"+pathB;
 }
#endif


bool checkIfFileExists (const std::string&amp; filePath) {
 return access( filePath.c_str(), 0 ) == 0;
}

}

</code></pre>

blocks|key|1223552|text|这可能是最自然的方式，同时覆盖了大多数主要的桌面平台。我不确定，但我相信这应该适用于所有的BSD，而不仅仅是FreeBSD，如果你改变平台宏检查来涵盖所有它们。如果我打算安装Solaris，我一定会将该平台添加到支持列表中。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1223553|在Windows上提供了完整的UTF-8支持，但并不是每个人都足够关心这一点。|1223554|procinfo/win32/procinfo.cpp|1223555|#ifdef+_WIN32
#include+"../procinfo.h"
#include+<windows.h>
#include+<tlhelp32.h>
#include+<cstddef>
#include+<vector>
#include+<cwchar>

using+std::string;
using+std::wstring;
using+std::vector;
using+std::size_t;

static+inline+string+narrow(wstring+wstr)+{
++int+nbytes+=+WideCharToMultiByte(CP_UTF8,+0,+wstr.c_str(),+(int)wstr.length(),+NULL,+0,+NULL,+NULL);
++vector<char>+buf(nbytes);
++return+string{+buf.data(),+(size_t)WideCharToMultiByte(CP_UTF8,+0,+wstr.c_str(),+(int)wstr.length(),+buf.data(),+nbytes,+NULL,+NULL)+};
}

process_t+ppid_from_pid(process_t+pid)+{++++++++
++process_t+ppid;+++++++
++HANDLE+hp+=+CreateToolhelp32Snapshot(TH32CS_SNAPPROCESS,+0);++++++
++PROCESSENTRY32+pe+=+{+0+};++++++++
++pe.dwSize+=+sizeof(PROCESSENTRY32);+++++++
++if+(Process32First(hp,+&pe))+{++++++++
++++do+{++++++++
++++++if+(pe.th32ProcessID+==+pid)+{++++++++
++++++++ppid+=+pe.th32ParentProcessID;++++++
++++++++break;++++++
++++++}+++++
++++}+while+(Process32Next(hp,+&pe));+++++++
++}+++++
++CloseHandle(hp);++++++
++return+ppid;++++++
}

string+path_from_pid(process_t+pid)+{
++string+path;
++HANDLE+hm+=+CreateToolhelp32Snapshot(TH32CS_SNAPMODULE,+pid);
++MODULEENTRY32W+me+=+{+0+};
++me.dwSize+=+sizeof(MODULEENTRY32W);
++if+(Module32FirstW(hm,+&me))+{
++++do+{
++++++if+(me.th32ProcessID+==+pid)+{
++++++++path+=+narrow(me.szExePath);
++++++++break;
++++++}
++++}+while+(Module32NextW(hm,+&me));
++}
++CloseHandle(hm);
++return+path;
}
#endif|code-block|syntax|javascript|1223556|procinfo/macosx/procinfo.cpp|1223557|#if+defined(__APPLE__)+&&+defined(__MACH__)
#include+"../procinfo.h"
#include+<libproc.h>

using+std::string;

string+path_from_pid(process_t+pid)+{
++string+path;
++char+buffer[PROC_PIDPATHINFO_MAXSIZE];
++if+(proc_pidpath(pid,+buffer,+sizeof(buffer))+>+0)+{
++++path+=+string(buffer)+%2B+"\0";
++}
++return+path;
}
#endif|1223558|procinfo/linux/procinfo.cpp|1223559|#ifdef+__linux__
#include+"../procinfo.h"
#include+<cstdlib>

using+std::string;
using+std::to_string;

string+path_from_pid(process_t+pid)+{
++string+path;
++string+link+=+string("/proc/")+%2B+to_string(pid)+%2B+string("/exe");
++char+*buffer+=+realpath(link.c_str(),+NULL);
++path+=+buffer+?+:+"";
++free(buffer);
++return+path;
}
#endif|1223560|procinfo/freebsd/procinfo.cpp|1223561|#ifdef+__FreeBSD__
#include+"../procinfo.h"
#include+<sys/sysctl.h>
#include+<cstddef>

using+std::string;
using+std::size_t;

string+path_from_pid(process_t+pid)+{
++string+path;
++size_t+length;
++//+CTL_KERN::KERN_PROC::KERN_PROC_PATHNAME(pid)
++int+mib[4]+=+{+CTL_KERN,+KERN_PROC,+KERN_PROC_PATHNAME,+pid+};
++if+(sysctl(mib,+4,+NULL,+&length,+NULL,+0)+==+0)+{
++++path.resize(length,+'\0');
++++char+*buffer+=+path.data();
++++if+(sysctl(mib,+4,+buffer,+&length,+NULL,+0)+==+0)+{
++++++path+=+string(buffer)+%2B+"\0";
++++}
++}
++return+path;
}
#endif|1223562|procinfo/procinfo.cpp|1223563|#include+"procinfo.h"
#ifdef+_WiN32
#include+<process.h>
#endif
#include+<unistd.h>
#include+<cstddef>

using+std::string;
using+std::size_t;

process_t+pid_from_self()+{
++#ifdef+_WIN32
++return+_getpid();
++#else
++return+getpid();
++#endif
}

process_t+ppid_from_self()+{
++#ifdef+_WIN32
++return+ppid_from_pid(pid_from_self());
++#else
++return+getppid();
++#endif
}

string+dir_from_pid(process_t+pid)+{
++string+fname+=+path_from_pid(pid);
++size_t+fp+=+fname.find_last_of("/\\");
++return+fname.substr(0,+fp+%2B+1);
}

string+name_from_pid(process_t+pid)+{
++string+fname+=+path_from_pid(pid);
++size_t+fp+=+fname.find_last_of("/\\");
++return+fname.substr(fp+%2B+1);
}|1223564|procinfo/procinfo.h|1223565|#ifdef+_WiN32
#include+<windows.h>
typedef+DWORD+process_t;
#else
#include+<sys/types.h>
typedef+pid_t+process_t;
#endif
#include+<string>

/*+windows-only+helper+function+*/
process_t+ppid_from_pid(process_t+pid);

/*+get+current+process+process+id+*/
process_t+pid_from_self();

/*+get+parent+process+process+id+*/
process_t+ppid_from_self();

/*+std::string+possible_result+=+"C:\\path\\to\\file.exe";+*/
std::string+path_from_pid(process_t+pid);

/*+std::string+possible_result+=+"C:\\path\\to\\";+*/
std::string+dir_from_pid(process_t+pid);

/*+std::string+possible_result+=+"file.exe";+*/
std::string+name_from_pid(process_t+pid);|1223566|这允许获得几乎任何进程id的可执行文件的完整路径，除了在Windows上有一些具有安全属性的进程根本不允许这样做，所以wysiwyg，这个解决方案并不完美。|1223567|为了更准确地回答问题所问的问题，您可以这样做：|1223568|procinfo.cpp|1223569|#include+"procinfo/procinfo.h"
#include+<iostream>

using+std::string;
using+std::cout;
using+std::endl;

int+main()+{
++cout+<<+dir_from_pid(pid_from_self())+<<+endl;
++return+0;
}|1223570|使用以下命令构建上述文件结构：|1223571|procinfo.sh|1223572|cd+"${0%25/*}"
g%2B%2B+procinfo.cpp+procinfo/procinfo.cpp+procinfo/win32/procinfo.cpp+procinfo/macosx/procinfo.cpp+procinfo/linux/procinfo.cpp+procinfo/freebsd/procinfo.cpp+-o+procinfo.exe|1223573|用于下载上面列出的文件的副本：|1223574|git+clone+git://github.com/time-killer-games/procinfo.git|1223575|要获得更多跨平台的流程相关优势：|1223576|https://github.com/time-killer-games/enigma-dev|offset|length|1223577|有关包含的大多数函数的列表，请参阅自述文件。|1223578|entityMap|0|LINK|mutability|MUTABLE|url^0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|1B|0|0|0^^$0|@$1|2|3|4|5|6|7|21|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|22|8|@]|9|@]|A|$]]|$1|D|3|E|5|6|7|23|8|@]|9|@]|A|$]]|$1|F|3|G|5|H|7|24|8|@]|9|@]|A|$I|J]]|$1|K|3|L|5|6|7|25|8|@]|9|@]|A|$]]|$1|M|3|N|5|H|7|26|8|@]|9|@]|A|$I|J]]|$1|O|3|P|5|6|7|27|8|@]|9|@]|A|$]]|$1|Q|3|R|5|H|7|28|8|@]|9|@]|A|$I|J]]|$1|S|3|T|5|6|7|29|8|@]|9|@]|A|$]]|$1|U|3|V|5|H|7|2A|8|@]|9|@]|A|$I|J]]|$1|W|3|X|5|6|7|2B|8|@]|9|@]|A|$]]|$1|Y|3|Z|5|H|7|2C|8|@]|9|@]|A|$I|J]]|$1|10|3|11|5|6|7|2D|8|@]|9|@]|A|$]]|$1|12|3|13|5|H|7|2E|8|@]|9|@]|A|$I|J]]|$1|14|3|15|5|6|7|2F|8|@]|9|@]|A|$]]|$1|16|3|17|5|6|7|2G|8|@]|9|@]|A|$]]|$1|18|3|19|5|6|7|2H|8|@]|9|@]|A|$]]|$1|1A|3|1B|5|H|7|2I|8|@]|9|@]|A|$I|J]]|$1|1C|3|1D|5|6|7|2J|8|@]|9|@]|A|$]]|$1|1E|3|1F|5|6|7|2K|8|@]|9|@]|A|$]]|$1|1G|3|1H|5|H|7|2L|8|@]|9|@]|A|$I|J]]|$1|1I|3|1J|5|6|7|2M|8|@]|9|@]|A|$]]|$1|1K|3|1L|5|H|7|2N|8|@]|9|@]|A|$I|J]]|$1|1M|3|1N|5|6|7|2O|8|@]|9|@]|A|$]]|$1|1O|3|1P|5|6|7|2P|8|@]|9|@$1Q|2Q|1R|2R|1|2S]]|A|$]]|$1|1S|3|1T|5|6|7|2T|8|@]|9|@]|A|$]]|$1|1U|3|-4|5|6|7|2U|8|@]|9|@]|A|$]]]|1V|$1W|$5|1X|1Y|1Z|A|$20|1P]]]]

This is probably the most natural way to do it, while covering most major desktop platforms. I am not certain, but I believe this should work with all the BSD's, not just FreeBSD, if you change the platform macro check to cover all of them. If I ever get around to installing Solaris, I'll be sure to add that platform to the supported list.

Features full UTF-8 support on Windows, which not everyone cares enough to go that far.

procinfo/win32/procinfo.cpp

<pre><code>#ifdef _WIN32
#include "../procinfo.h"
#include &lt;windows.h&gt;
#include &lt;tlhelp32.h&gt;
#include &lt;cstddef&gt;
#include &lt;vector&gt;
#include &lt;cwchar&gt;

using std::string;
using std::wstring;
using std::vector;
using std::size_t;

static inline string narrow(wstring wstr) {
 int nbytes = WideCharToMultiByte(CP_UTF8, 0, wstr.c_str(), (int)wstr.length(), NULL, 0, NULL, NULL);
 vector&lt;char&gt; buf(nbytes);
 return string{ buf.data(), (size_t)WideCharToMultiByte(CP_UTF8, 0, wstr.c_str(), (int)wstr.length(), buf.data(), nbytes, NULL, NULL) };
}

process_t ppid_from_pid(process_t pid) { 
 process_t ppid; 
 HANDLE hp = CreateToolhelp32Snapshot(TH32CS_SNAPPROCESS, 0); 
 PROCESSENTRY32 pe = { 0 }; 
 pe.dwSize = sizeof(PROCESSENTRY32); 
 if (Process32First(hp, &amp;pe)) { 
 do { 
 if (pe.th32ProcessID == pid) { 
 ppid = pe.th32ParentProcessID; 
 break; 
 } 
 } while (Process32Next(hp, &amp;pe)); 
 } 
 CloseHandle(hp); 
 return ppid; 
}

string path_from_pid(process_t pid) {
 string path;
 HANDLE hm = CreateToolhelp32Snapshot(TH32CS_SNAPMODULE, pid);
 MODULEENTRY32W me = { 0 };
 me.dwSize = sizeof(MODULEENTRY32W);
 if (Module32FirstW(hm, &amp;me)) {
 do {
 if (me.th32ProcessID == pid) {
 path = narrow(me.szExePath);
 break;
 }
 } while (Module32NextW(hm, &amp;me));
 }
 CloseHandle(hm);
 return path;
}
#endif
</code></pre>

procinfo/macosx/procinfo.cpp

<pre><code>#if defined(__APPLE__) &amp;&amp; defined(__MACH__)
#include "../procinfo.h"
#include &lt;libproc.h&gt;

using std::string;

string path_from_pid(process_t pid) {
 string path;
 char buffer[PROC_PIDPATHINFO_MAXSIZE];
 if (proc_pidpath(pid, buffer, sizeof(buffer)) &gt; 0) {
 path = string(buffer) + "\0";
 }
 return path;
}
#endif
</code></pre>

procinfo/linux/procinfo.cpp

<pre><code>#ifdef __linux__
#include "../procinfo.h"
#include &lt;cstdlib&gt;

using std::string;
using std::to_string;

string path_from_pid(process_t pid) {
 string path;
 string link = string("/proc/") + to_string(pid) + string("/exe");
 char *buffer = realpath(link.c_str(), NULL);
 path = buffer ? : "";
 free(buffer);
 return path;
}
#endif
</code></pre>

procinfo/freebsd/procinfo.cpp

<pre><code>#ifdef __FreeBSD__
#include "../procinfo.h"
#include &lt;sys/sysctl.h&gt;
#include &lt;cstddef&gt;

using std::string;
using std::size_t;

string path_from_pid(process_t pid) {
 string path;
 size_t length;
 // CTL_KERN::KERN_PROC::KERN_PROC_PATHNAME(pid)
 int mib[4] = { CTL_KERN, KERN_PROC, KERN_PROC_PATHNAME, pid };
 if (sysctl(mib, 4, NULL, &amp;length, NULL, 0) == 0) {
 path.resize(length, '\0');
 char *buffer = path.data();
 if (sysctl(mib, 4, buffer, &amp;length, NULL, 0) == 0) {
 path = string(buffer) + "\0";
 }
 }
 return path;
}
#endif
</code></pre>

procinfo/procinfo.cpp

<pre><code>#include "procinfo.h"
#ifdef _WiN32
#include &lt;process.h&gt;
#endif
#include &lt;unistd.h&gt;
#include &lt;cstddef&gt;

using std::string;
using std::size_t;

process_t pid_from_self() {
 #ifdef _WIN32
 return _getpid();
 #else
 return getpid();
 #endif
}

process_t ppid_from_self() {
 #ifdef _WIN32
 return ppid_from_pid(pid_from_self());
 #else
 return getppid();
 #endif
}

string dir_from_pid(process_t pid) {
 string fname = path_from_pid(pid);
 size_t fp = fname.find_last_of("/\\");
 return fname.substr(0, fp + 1);
}

string name_from_pid(process_t pid) {
 string fname = path_from_pid(pid);
 size_t fp = fname.find_last_of("/\\");
 return fname.substr(fp + 1);
}
</code></pre>

procinfo/procinfo.h

<pre><code>#ifdef _WiN32
#include &lt;windows.h&gt;
typedef DWORD process_t;
#else
#include &lt;sys/types.h&gt;
typedef pid_t process_t;
#endif
#include &lt;string&gt;

/* windows-only helper function */
process_t ppid_from_pid(process_t pid);

/* get current process process id */
process_t pid_from_self();

/* get parent process process id */
process_t ppid_from_self();

/* std::string possible_result = "C:\\path\\to\\file.exe"; */
std::string path_from_pid(process_t pid);

/* std::string possible_result = "C:\\path\\to\\"; */
std::string dir_from_pid(process_t pid);

/* std::string possible_result = "file.exe"; */
std::string name_from_pid(process_t pid);
</code></pre>

This allows getting the full path to the executable of pretty much any process id, except on Windows there are some process's with security attributes which simply will not allow it, so wysiwyg, this solution is not perfect.

To address what the question was asking more precisely, you may do this:

procinfo.cpp

<pre><code>#include "procinfo/procinfo.h"
#include &lt;iostream&gt;

using std::string;
using std::cout;
using std::endl;

int main() {
 cout &lt;&lt; dir_from_pid(pid_from_self()) &lt;&lt; endl;
 return 0;
}
</code></pre>

Build the above file structure with this command:

procinfo.sh

<pre><code>cd "${0%/*}"
g++ procinfo.cpp procinfo/procinfo.cpp procinfo/win32/procinfo.cpp procinfo/macosx/procinfo.cpp procinfo/linux/procinfo.cpp procinfo/freebsd/procinfo.cpp -o procinfo.exe
</code></pre>

For downloading a copy of the files listed above:

<pre><code>git clone git://github.com/time-killer-games/procinfo.git
</code></pre>

For more cross-platform process-related goodness:

<a href="https://github.com/time-killer-games/enigma-dev" rel="nofollow noreferrer">https://github.com/time-killer-games/enigma-dev</a>

See the readme for a list of most of the functions included.

blocks|key|1438429|text|我没有阅读我的解决方案是否已经发布，但在linux和osx上，您可以在main函数中读取0参数，如下所示：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1438430|int+main(int+argument_count,+char+**argument_list)+{
++++std::string+currentWorkingDirectoryPath(argument_list[currentWorkingDirectory]);
++++std::size_t+pos+=+currentWorkingDirectoryPath.rfind("/");++++++//+position+of+"live"+in+str
++++currentWorkingDirectoryPath+=+currentWorkingDirectoryPath.substr+(0,+pos);|code-block|syntax|javascript|1438431|在argument_list的第一项中，集成了可执行文件的名称，但上面的代码将其删除。|1438432|entityMap^0|0|0|0^^$0|@$1|2|3|4|5|6|7|K|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|L|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|M|8|@]|9|@]|A|$]]|$1|I|3|-4|5|6|7|N|8|@]|9|@]|A|$]]]|J|$]]

I didn't read if my solution is already posted but on linux and osx you can read the 0 argument in your main function like this:
<pre><code>int main(int argument_count, char **argument_list) {
 std::string currentWorkingDirectoryPath(argument_list[currentWorkingDirectory]);
 std::size_t pos = currentWorkingDirectoryPath.rfind(&quot;/&quot;); // position of &quot;live&quot; in str
 currentWorkingDirectoryPath = currentWorkingDirectoryPath.substr (0, pos);
</code></pre>
In the first item of argument_list the name of the executable is integrated but removed by the code above.

I know this question has been asked before but I still haven't seen a satisfactory answer, or a definitive "no, this cannot be done", so I'll ask again!

All I want to do is get the path to the currently running executable, either as an absolute path or relative to where the executable is invoked from, in a platform-independent fashion. I though boost::filesystem::initial_path was the answer to my troubles but that seems to only handle the 'platform-independent' part of the question - it still returns the path from which the application was invoked.

For a bit of background, this is a game using Ogre, which I'm trying to profile using Very Sleepy, which runs the target executable from its own directory, so of course on load the game finds no configuration files etc. and promptly crashes. I want to be able to pass it an absolute path to the configuration files, which I know will always live alongside the executable. The same goes for debugging in Visual Studio - I'd like to be able to run $(TargetPath) without having to set the working directory.

Get path of executable

Visual Studio

文件系统

编译器

Windows

FreeBSD

Solaris

Linux

Unix

我知道这个问题以前已经被问过了，但是我仍然没有看到一个令人满意的答案，或者一个明确的“不，这不能做”，所以我再问一次！我所要做的就是以独立于平台的方式获取当前运行的可执行文件的路径，可以是绝对路径，也可以是相对于调用可执行文件的位置。我认为boost::filesystem::initial_path是我的问题的答案，...

问获取可执行文件的路径
EN

社区

活动

资源

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问获取可执行文件的路径EN

社区

活动

资源

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问获取可执行文件的路径
EN