実行可能ファイルのパスを取得する


114

この質問が以前に尋ねられたことは知っていますが、満足のいく答え、または「いいえ、これを行うことはできません」という決定的な回答がまだないので、もう一度尋ねます。

私がやりたいのは、現在実行中の実行可能ファイルへのパスを、絶対パスとして、または実行可能ファイルの呼び出し元からの相対パスとして、プラットフォームに依存しない方法で取得することだけです。私はboost :: filesystem :: initial_pathが私の問題の答えでしたが、それは質問の「プラットフォームに依存しない」部分のみを処理するようです-それでもアプリケーションが呼び出されたパスを返します。

ちょっとした背景として、これはOgreを使用したゲームで、Very Sleepyを使用してプロファイリングしようとしています。これは、独自のディレクトリからターゲットの実行可能ファイルを実行するため、ロード時にゲームが構成ファイルなどを検出せず、すぐにクラッシュします。構成ファイルへの絶対パスを渡せるようにしたいのですが、実行可能ファイルと一緒に常に存在することがわかっています。Visual Studioでのデバッグについても同様です。作業ディレクトリを設定せずに$(TargetPath)を実行できるようにしたいと思います。



9
回答がないことを証明することは不可能であるため、最終的な NOを取得することはできません。私はあなたに権威のあるNOを提供させていただきます:)
MSalters


ゲームのロード時に構成ファイルなどが見つかりません。」ので、ゲームは現在のディレクトリで構成ファイルを検索しますか?これは悪い考えであり、潜在的にセキュリティの脆弱性です。構成ファイルは標準の場所に保存する必要があります。
curiousguy

1
私もここ回答を投稿しました。ブーストを使用してプラットフォーム全体で作業しているあなたの質問にも回答する関連質問
jtbr

回答:


86

私が知っているクロスプラットフォームの方法はありません。

Linuxの場合:readlink / proc / self / exe

Windows:GetModuleFileName


9
プラットフォームの独立性は、単にプラットフォームの依存関係を隠すことの問題です。この場合、方法を選択するためにpredef.sourceforge.net/preos.htmlで詳述されている事前定義されたOSマクロを使用することは簡単です。
クリフォード、

4
それで、C ++で実行可能ファイルのパスを見つけたいときはいつでもこれを行うのですか?これはすでにboostのようなライブラリに実装されているので、シンプルなサウンドが欲しいと思っていました。
ベンハイマーズ

2
@curiousguyよくわからない それがこの質問の要点であると私はかなり確信しています:)
Ben Hymers

6
@curiousguy:たとえば、プログラムがユーザーが選択したディレクトリにインストールされる可能性がある場合に実行します。どういうわけか
グレイフェード

1
@ダックは私のライブラリへのリンクであなたの答えを更新しますか?私のコメントはリストの下に埋もれています。
Gregory Pakosz、2015

35

ブースト:: DLL :: program_locationの機能は、私の知っていることを実行している実行可能ファイルのパスを取得する最良のクロスプラットフォームの方法の一つです。DLLライブラリはバージョン1.61.0でBoostに追加されました。

以下は私の解決策です。Windows、Mac OS X、Solaris、Free BSD、GNU / Linuxでテストしました。

Boost 1.55.0以上が必要です。Boost.Filesystemライブラリを直接使用し、Boost.LocaleライブラリとBoost.Systemライブラリを間接的に使用します。

src / executable_path.cpp

#include <cstdio>
#include <cstdlib>
#include <algorithm>
#include <iterator>
#include <string>
#include <vector>

#include <boost/filesystem/operations.hpp>
#include <boost/filesystem/path.hpp>
#include <boost/predef.h>
#include <boost/version.hpp>
#include <boost/tokenizer.hpp>

#if (BOOST_VERSION > BOOST_VERSION_NUMBER(1,64,0))
#  include <boost/process.hpp>
#endif

#if (BOOST_OS_CYGWIN || BOOST_OS_WINDOWS)
#  include <Windows.h>
#endif

#include <boost/executable_path.hpp>
#include <boost/detail/executable_path_internals.hpp>

namespace boost {

#if (BOOST_OS_CYGWIN || BOOST_OS_WINDOWS)

std::string executable_path(const char* argv0)
{
  typedef std::vector<char> char_vector;
  typedef std::vector<char>::size_type size_type;
  char_vector buf(1024, 0);
  size_type size = buf.size();
  bool havePath = false;
  bool shouldContinue = true;
  do
  {
    DWORD result = GetModuleFileNameA(nullptr, &buf[0], size);
    DWORD lastError = GetLastError();
    if (result == 0)
    {
      shouldContinue = false;
    }
    else if (result < size)
    {
      havePath = true;
      shouldContinue = false;
    }
    else if (
      result == size
      && (lastError == ERROR_INSUFFICIENT_BUFFER || lastError == ERROR_SUCCESS)
      )
    {
      size *= 2;
      buf.resize(size);
    }
    else
    {
      shouldContinue = false;
    }
  } while (shouldContinue);
  if (!havePath)
  {
    return detail::executable_path_fallback(argv0);
  }
  // On Microsoft Windows, there is no need to call boost::filesystem::canonical or
  // boost::filesystem::path::make_preferred. The path returned by GetModuleFileNameA
  // is the one we want.
  std::string ret = &buf[0];
  return ret;
}

#elif (BOOST_OS_MACOS)

#  include <mach-o/dyld.h>

std::string executable_path(const char* argv0)
{
  typedef std::vector<char> char_vector;
  char_vector buf(1024, 0);
  uint32_t size = static_cast<uint32_t>(buf.size());
  bool havePath = false;
  bool shouldContinue = true;
  do
  {
    int result = _NSGetExecutablePath(&buf[0], &size);
    if (result == -1)
    {
      buf.resize(size + 1);
      std::fill(std::begin(buf), std::end(buf), 0);
    }
    else
    {
      shouldContinue = false;
      if (buf.at(0) != 0)
      {
        havePath = true;
      }
    }
  } while (shouldContinue);
  if (!havePath)
  {
    return detail::executable_path_fallback(argv0);
  }
  std::string path(&buf[0], size);
  boost::system::error_code ec;
  boost::filesystem::path p(
    boost::filesystem::canonical(path, boost::filesystem::current_path(), ec));
  if (ec.value() == boost::system::errc::success)
  {
    return p.make_preferred().string();
  }
  return detail::executable_path_fallback(argv0);
}

#elif (BOOST_OS_SOLARIS)

#  include <stdlib.h>

std::string executable_path(const char* argv0)
{
  std::string ret = getexecname();
  if (ret.empty())
  {
    return detail::executable_path_fallback(argv0);
  }
  boost::filesystem::path p(ret);
  if (!p.has_root_directory())
  {
    boost::system::error_code ec;
    p = boost::filesystem::canonical(
      p, boost::filesystem::current_path(), ec);
    if (ec.value() != boost::system::errc::success)
    {
      return detail::executable_path_fallback(argv0);
    }
    ret = p.make_preferred().string();
  }
  return ret;
}

#elif (BOOST_OS_BSD)

#  include <sys/sysctl.h>

std::string executable_path(const char* argv0)
{
  typedef std::vector<char> char_vector;
  int mib[4]{0};
  size_t size;
  mib[0] = CTL_KERN;
  mib[1] = KERN_PROC;
  mib[2] = KERN_PROC_PATHNAME;
  mib[3] = -1;
  int result = sysctl(mib, 4, nullptr, &size, nullptr, 0);
  if (-1 == result)
  {
    return detail::executable_path_fallback(argv0);
  }
  char_vector buf(size + 1, 0);
  result = sysctl(mib, 4, &buf[0], &size, nullptr, 0);
  if (-1 == result)
  {
    return detail::executable_path_fallback(argv0);
  }
  std::string path(&buf[0], size);
  boost::system::error_code ec;
  boost::filesystem::path p(
    boost::filesystem::canonical(
      path, boost::filesystem::current_path(), ec));
  if (ec.value() == boost::system::errc::success)
  {
    return p.make_preferred().string();
  }
  return detail::executable_path_fallback(argv0);
}

#elif (BOOST_OS_LINUX)

#  include <unistd.h>

std::string executable_path(const char *argv0)
{
  typedef std::vector<char> char_vector;
  typedef std::vector<char>::size_type size_type;
  char_vector buf(1024, 0);
  size_type size = buf.size();
  bool havePath = false;
  bool shouldContinue = true;
  do
  {
    ssize_t result = readlink("/proc/self/exe", &buf[0], size);
    if (result < 0)
    {
      shouldContinue = false;
    }
    else if (static_cast<size_type>(result) < size)
    {
      havePath = true;
      shouldContinue = false;
      size = result;
    }
    else
    {
      size *= 2;
      buf.resize(size);
      std::fill(std::begin(buf), std::end(buf), 0);
    }
  } while (shouldContinue);
  if (!havePath)
  {
    return detail::executable_path_fallback(argv0);
  }
  std::string path(&buf[0], size);
  boost::system::error_code ec;
  boost::filesystem::path p(
    boost::filesystem::canonical(
      path, boost::filesystem::current_path(), ec));
  if (ec.value() == boost::system::errc::success)
  {
    return p.make_preferred().string();
  }
  return detail::executable_path_fallback(argv0);
}

#else

std::string executable_path(const char *argv0)
{
  return detail::executable_path_fallback(argv0);
}

#endif

}

src / detail / executable_path_internals.cpp

#include <cstdio>
#include <cstdlib>
#include <algorithm>
#include <iterator>
#include <string>
#include <vector>

#include <boost/filesystem/operations.hpp>
#include <boost/filesystem/path.hpp>
#include <boost/predef.h>
#include <boost/version.hpp>
#include <boost/tokenizer.hpp>

#if (BOOST_VERSION > BOOST_VERSION_NUMBER(1,64,0))
#  include <boost/process.hpp>
#endif

#if (BOOST_OS_CYGWIN || BOOST_OS_WINDOWS)
#  include <Windows.h>
#endif

#include <boost/executable_path.hpp>
#include <boost/detail/executable_path_internals.hpp>

namespace boost {
namespace detail {

std::string GetEnv(const std::string& varName)
{
  if (varName.empty()) return "";
#if (BOOST_OS_BSD || BOOST_OS_CYGWIN || BOOST_OS_LINUX || BOOST_OS_MACOS || BOOST_OS_SOLARIS)
  char* value = std::getenv(varName.c_str());
  if (!value) return "";
  return value;
#elif (BOOST_OS_WINDOWS)
  typedef std::vector<char> char_vector;
  typedef std::vector<char>::size_type size_type;
  char_vector value(8192, 0);
  size_type size = value.size();
  bool haveValue = false;
  bool shouldContinue = true;
  do
  {
    DWORD result = GetEnvironmentVariableA(varName.c_str(), &value[0], size);
    if (result == 0)
    {
      shouldContinue = false;
    }
    else if (result < size)
    {
      haveValue = true;
      shouldContinue = false;
    }
    else
    {
      size *= 2;
      value.resize(size);
    }
  } while (shouldContinue);
  std::string ret;
  if (haveValue)
  {
    ret = &value[0];
  }
  return ret;
#else
  return "";
#endif
}

bool GetDirectoryListFromDelimitedString(
  const std::string& str,
  std::vector<std::string>& dirs)
{
  typedef boost::char_separator<char> char_separator_type;
  typedef boost::tokenizer<
    boost::char_separator<char>, std::string::const_iterator,
    std::string> tokenizer_type;
  dirs.clear();
  if (str.empty())
  {
    return false;
  }
#if (BOOST_OS_WINDOWS)
  const std::string os_pathsep(";");
#else
  const std::string os_pathsep(":");
#endif
  char_separator_type pathSep(os_pathsep.c_str());
  tokenizer_type strTok(str, pathSep);
  typename tokenizer_type::iterator strIt;
  typename tokenizer_type::iterator strEndIt = strTok.end();
  for (strIt = strTok.begin(); strIt != strEndIt; ++strIt)
  {
    dirs.push_back(*strIt);
  }
  if (dirs.empty())
  {
    return false;
  }
  return true;
}

std::string search_path(const std::string& file)
{
  if (file.empty()) return "";
  std::string ret;
#if (BOOST_VERSION > BOOST_VERSION_NUMBER(1,64,0))
  {
    namespace bp = boost::process;
    boost::filesystem::path p = bp::search_path(file);
    ret = p.make_preferred().string();
  }
#endif
  if (!ret.empty()) return ret;
  // Drat! I have to do it the hard way.
  std::string pathEnvVar = GetEnv("PATH");
  if (pathEnvVar.empty()) return "";
  std::vector<std::string> pathDirs;
  bool getDirList = GetDirectoryListFromDelimitedString(pathEnvVar, pathDirs);
  if (!getDirList) return "";
  std::vector<std::string>::const_iterator it = pathDirs.cbegin();
  std::vector<std::string>::const_iterator itEnd = pathDirs.cend();
  for ( ; it != itEnd; ++it)
  {
    boost::filesystem::path p(*it);
    p /= file;
    if (boost::filesystem::exists(p) && boost::filesystem::is_regular_file(p))
    {
      return p.make_preferred().string();
    }
  }
  return "";
}

std::string executable_path_fallback(const char *argv0)
{
  if (argv0 == nullptr) return "";
  if (argv0[0] == 0) return "";
#if (BOOST_OS_WINDOWS)
  const std::string os_sep("\\");
#else
  const std::string os_sep("/");
#endif
  if (strstr(argv0, os_sep.c_str()) != nullptr)
  {
    boost::system::error_code ec;
    boost::filesystem::path p(
      boost::filesystem::canonical(
        argv0, boost::filesystem::current_path(), ec));
    if (ec.value() == boost::system::errc::success)
    {
      return p.make_preferred().string();
    }
  }
  std::string ret = search_path(argv0);
  if (!ret.empty())
  {
    return ret;
  }
  boost::system::error_code ec;
  boost::filesystem::path p(
    boost::filesystem::canonical(
      argv0, boost::filesystem::current_path(), ec));
  if (ec.value() == boost::system::errc::success)
  {
    ret = p.make_preferred().string();
  }
  return ret;
}

}
}

include / boost / executable_path.hpp

#ifndef BOOST_EXECUTABLE_PATH_HPP_
#define BOOST_EXECUTABLE_PATH_HPP_

#pragma once

#include <string>

namespace boost {
std::string executable_path(const char * argv0);
}

#endif // BOOST_EXECUTABLE_PATH_HPP_

include / boost / detail / executable_path_internals.hpp

#ifndef BOOST_DETAIL_EXECUTABLE_PATH_INTERNALS_HPP_
#define BOOST_DETAIL_EXECUTABLE_PATH_INTERNALS_HPP_

#pragma once

#include <string>
#include <vector>

namespace boost {
namespace detail {
std::string GetEnv(const std::string& varName);
bool GetDirectoryListFromDelimitedString(
    const std::string& str,
    std::vector<std::string>& dirs);
std::string search_path(const std::string& file);
std::string executable_path_fallback(const char * argv0);
}
}

#endif // BOOST_DETAIL_EXECUTABLE_PATH_INTERNALS_HPP_

SnKOpen-/ cpp / executable_path / trunkにあるテストアプリケーションとCMakeビルドファイルを含む完全なプロジェクトがあります。このバージョンは、ここで提供したバージョンよりも完全です。また、より多くのプラットフォームをサポートしています。

次の4つのシナリオで、サポートされているすべてのオペレーティングシステムでアプリケーションをテストしました。

  1. 現在のディレクトリで実行可能な相対パス:./executable_path_test
  2. 別のディレクトリで実行可能な相対パス:./build/executable_path_test
  3. 絶対パス:/ some / dir / executable_path_test
  4. パスで実行可能、ファイル名のみ:ie_executable_path_test

4つのシナリオすべてで、executable_path関数とexecutable_path_fallback関数の両方が機能し、同じ結果を返します。

ノート

これは、この質問に対する更新された回答です。ユーザーのコメントや提案を考慮に入れるように回答を更新しました。また、SVNリポジトリにプロジェクトへのリンクを追加しました。


1
これは、妥当なフォールバックを備えた非常に完全なソリューションのように見えます。+1!ただし、1つの質問:固定されたchar [1024]バッファーを、パスが初期サイズを超えた場合にサイズ変更できるvector <char>のようなものに置き換えることは理にかなっていますか?
ダニエルウルフ

はい。それは素晴らしい提案です。もちろん、エラーのチェック、バッファのサイズ変更、再試行などの追加の変更を行う必要があります。
Ben Key

1
フォールバックは正しくないと思います。argv[0]単に実行可能な名前にすることもできPATHます。その場合、* nixシステムで検索する必要があります。
のMichałGórny

1
これを使ってみました。ブーストが必要ですよね?私はそれがスタンドアロンであると思った
manatttta

1
"boost :: dll :: program_location"で私を迎えました
Thomas

31

この方法では、boost + argvを使用します。実行可能ファイルの名前が含まれている場合と含まれていない場合があるため、これはクロスプラットフォームではない可能性があります。さて、次のコードはそれを回避するはずです。

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

次のコードは、現在の作業ディレクトリを取得します。

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

basename()が廃止されたことに気づいたので、.stem()


stemは、実行可能ファイルからWindows上のパスと拡張子を除いただけのように見えますが、それは重要ではありません。私が知りたいのは、argv [0]が正しくない可能性があることを回避する方法です。これはWindowsでのテストでは機能しますが、実際にはargv [0]が実行可能ファイルの絶対パスとして渡されるため、system_completeの作業がかなり簡単になります:)
Ben Hymers

1
いいえ-彼は作業ディレクトリを必要としません。argvは役に立ちません。argvに実行可能ファイル名のみが含まれている場合はどうしますか?シンボリックリンクを介してプログラムが呼び出されたときに何をすべきか?
Ichthyo、2011

4
"// Without file name"-欲しい.parent_path()、ではない.stem()、いいえ?
Claudiu 2015年

2
これは私のプラットフォーム(macOS El Capitan)では動作しないようです。代わりに、現在の作業ディレクトリを取得します。また、@Claudiu言ったように、それはそうあるべきだと思います.parent_path()
samvv 2017

20

Linuxについてはわかりませんが、Windowsの場合は以下を試してください。

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

3
Unicodeサポートを使用してコンパイルする場合は、を使用してWCHAR ownPth..をラップする必要があることに注意してください#ifdef UNICODE。そうでない場合は、提供されているコードを使用してください。
Dr1Ku 2013

1
記録のためだけに、GetModuleDirectoryが ".."の部分を含むパスを返す、たとえば、コマンドラインlolから文字列pure rawを取得する場合のように、変なケースが発生しています。この場合、実際にはビジュアルスタジオがプロセスを起動しており、..はデバッグパスの一部です。$(projectDir)../ some.exeのようなもの私はShwlibのPathCanonicalizeを使用しましたが、このlibにリンクする必要があります。これは望ましくない場合があります。
v.oddou 2014年

1
charではなく、ownPathにTCHARを使用することもお勧めします。とにかくいい答え。
anhoppe 2015

これが失敗することは可能ですか?一見するとありそうもないようです...HMODULE hModule = GetModuleHandle(NULL);
kayleeFrye_onDeck

1
GetModuleFileNameの最初のパラメータがNULLの場合、現在のプロセスの実行可能ファイルのパスを取得します。
lsalamon、

12

Windowsの場合:

GetModuleFileName -exeパス+ exeファイル名を返します

ファイル名を削除するには
PathRemoveFileSpec


1
PathRemoveFileSpecのドキュメントノート:This function is deprecated. We recommend the use of the PathCchRemoveFileSpec function in its place
javs

12

C ++ 17、Windows、Unicode、ファイルシステムの新しいAPIを使用:

#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("%S", dir.c_str());
    return 0;
}

このソリューションは移植可能である必要があると思われますが、Unicodeが他のOSでどのように実装されているかはわかりません。

weakly_canonicalは、パスを簡略化するために出力ディレクトリとして上位フォルダー参照( '..')として使用する場合にのみ必要です。使用しない場合は削除してください。

ダイナミックリンクライブラリ(.dll /.so)から操作している場合、argvがない可能性があります。次の解決策を検討できます。

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
}

ヘッダー内のガードは、ファイルシステムの存在を適切にテストするものではありません。cppreferenceは、機能テストマクロの値がファイルシステムヘッダー自体で定義されていることを示しているため、含める前にテストすることはできません。__has_include()は、こちらのより良い標準テストです。
Meteorhead

8

QTはこれにQCoreApplication :: applicationDirPath()としてOS抽象化を提供します


これで取得:QCoreApplication::applicationDirPath: Please instantiate the QApplication object first。それを解決する方法はありますか?
GuySoft 2016年

@GuySoft:だけのインスタンス作成QCoreApplicationそれほどなどをQApplication application(argc, argv);(自分の中でこれを行うmain(argc, argv)と、あなたが変更しないということargc/argv(チェックこれらの必要性がQCoreApplicationの寿命にわたって有効で滞在しているため、ドキュメントを
テッド

5

これはWindows固有の方法ですが、答えの少なくとも半分です。

GetThisPath.h

/// 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);

GetThisPath.cpp

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

mainProgram.cpp

TCHAR dest[MAX_PATH];
GetThisPath(dest, MAX_PATH);

プラットフォーム検出をプリプロセッサディレクティブとして使用してGetThisPath、各プラットフォームを呼び出すラッパー関数の実装を変更することをお勧めします。


3

args [0]を使用して '/'(または '\\')を探します:

#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) || 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 << "Path: " << path << std::endl;
    std::cout << "Name: " << name << std::endl;
}

編集: '/'が存在しない場合、pos ==-1になるため、結果は正しいです。


パスに「/」が存在しない場合はどうなりますか?そのケースのチェックはなく、私はそれがかなり可能性があると信じています-Windowsはバックスラッシュを使用し、args[0]実際にはまったくパスではないかもしれません。
ベンハイマーズ2014

'/'が存在しない場合、rfindは-1を返すため、 "path" = aux.substr(0,0)および "name" = aux.substr(0):結果は正しいです。Windowsに関連して、あなたは正しい、「/」は「\\」に変更する必要があります。私もWindowsを許可するように変更します。「/」を使用したファイル名もテストしましたが、これはコード化されており、問題は発生しません。
Adrian Maire、2014

1
これは、詳細な部分ですargs[0]必ずしもその気に私の実行可能ファイルのパスされていません。Windowsに対するあなたの答えを修正してくれてありがとう:)
Ben Hymers '12 / 07/12

1
パスを指定せずにコマンドを実行した場合(つまり、PATH env varで指定されたディレクトリにあることによって検出された場合)、args [0]は、パスなしの実行可能ファイルの名前になります。
ケビン

@Kevin:あなた(と他の人)は正しいです。これは、95%のケースで機能する小さなツールのシンプルなソリューションです。深刻なソフトウェアの場合は、構成ファイルや環境変数、あるいはその両方がおそらくより適切です。また、これは通常、あまり良くない(または間違っている)設計を意味します。
Adrian Maire


1

次の方法は迅速でダーティなソリューションとして機能しますが、絶対確実というわけではないことに注意してください。

#include <iostream>

using namespace std ;

int main( int argc, char** argv)
{
    cout << argv[0] << endl ;
    return 0;
}

17
他のSOの質問で、これが常に機能するとは限らず、argv [0]には実行可能ファイルへの絶対パス、実行可能ファイルの名前だけ、またはその他のゴミを含めることができることを確認しました。
ベンハイマーズ

7
「サポートファイル」などを開こうとしている場合、argv [0]を信頼すべきではありません。Argvは変更される可能性があり、悪意のある呼び出し元はすべて、この値を変更できます。ロギングなどに使用する場合を除き、ファイルを開くために使用されるパスの構築には使用しないでください。
Qix-モニカは

これはWindowsでは機能しません。argv [0]には絶対パスがありません。.exeファイルのみ。bashシェルで試さないでください。標準のコンソールで試して、再現するには<< argv [0]を実行してください。
フレディマルティネスガルシア

@FreddyMartinezGarciaさて、私はWindowsでテストしたので、YMMVです。これは、コードの起動に使用されたものです。CWDで実行可能ファイルを使用している場合は、ファイル名のみが取得されます。
クリフォード

0

WindowsのUnicodeパスを処理する必要がある場合:

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

0

Windowsの場合、の結果から実行可能ファイルを取り除く方法に問題がありGetModuleFileName()ます。PathRemoveFileSpec()Nateが彼の回答でその目的で使用したWindows API呼び出しは、Windows 8とその前のバージョンの間で変更されました。それでは、両方との互換性を維持し、安全を保つにはどうすればよいでしょうか。幸い、C ++ 17(または古いコンパイラを使用している場合はBoost)があります。私はこれをします:

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

0

他の人が述べたように、argv[0]プラットフォームが実際に実行可能パスを渡せば、非常に優れたソリューションです。これは確かに、WindowsであるOS(WinAPIが実行可能パスを見つけるのに役立つ)よりも可能性が低いわけではありません。文字列を削除して実行可能ファイルが存在するディレクトリへのパスのみを含める場合、そのパスを使用して他のアプリケーションファイル(プログラムがゲームの場合はゲームアセットなど)を見つけることは完全に問題ありません。作業ディレクトリ、または指定されている場合はルート。


0

これは私が終わったものです

ヘッダーファイルは次のようになります。

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

}

実装


#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() + 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, &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& filePath) {
   return access( filePath.c_str(), 0 ) == 0;
}

}

0

SDL2(https://www.libsdl.org/)ライブラリには、幅広いプラットフォームに実装された2つの関数があります。

  • SDL_GetBasePath
  • SDL_GetPrefPath

したがって、ホイールを再発明したくない場合...残念なことに、ライブラリ全体を含めることを意味しますが、非常に寛容なライセンスがあり、コードをコピーすることもできます。その上、それは他の多くのクロスプラットフォーム機能を提供します。


0

ほとんどの主要なデスクトッププラットフォームをカバーしながら、これはおそらくそれを行う最も自然な方法です。確かではありませんが、プラットフォームマクロチェックをすべてカバーするように変更すれば、FreeBSDだけでなく、すべてのBSDで動作するはずです。Solarisのインストールに慣れたら、必ずそのプラットフォームをサポートリストに追加します。

Windowsでの完全なUTF-8サポートを特徴としています。これは、誰もがそれほど遠くまで気にかけているわけではありません。

procinfo / win32 / procinfo.cpp

#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

procinfo / macosx / procinfo.cpp

#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) + "\0";
  }
  return path;
}
#endif

procinfo / linux / procinfo.cpp

#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/") + to_string(pid) + string("/exe");
  char *buffer = realpath(link.c_str(), NULL);
  path = buffer ? : "";
  free(buffer);
  return path;
}
#endif

procinfo / freebsd / procinfo.cpp

#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) + "\0";
    }
  }
  return path;
}
#endif

procinfo / procinfo.cpp

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

procinfo / procinfo.h

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

これにより、ほとんどすべてのプロセスIDの実行可能ファイルへの完全なパスを取得できます。ただし、Windowsでは、セキュリティ属性があり、許可されないプロセスがあるため、このソリューションは完璧ではありません。

質問がより正確に何を求めているかに対処するには、次のようにします。

procinfo.cpp

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

次のコマンドで上記のファイル構造を構築します。

procinfo.sh

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

上記のファイルのコピーをダウンロードするには:

git clone git://github.com/time-killer-games/procinfo.git

より多くのクロスプラットフォームプロセス関連のメリット:

https://github.com/time-killer-games/enigma-dev

含まれているほとんどの関数のリストについては、Readmeを参照してください。


0

C ++ 17を使用している場合は、実行可能ファイルへのパスを取得するために次のことができます。

#include <filesystem>

std::filesystem::path getExecutablePath()
{
    return std::filesystem::canonical("/proc/self/exe");
}

上記の回答は、G ++ 9.3.0を使用するDebian 10でテストされています


これは、/ proc / self / exeが存在し、アクセス可能である場合にのみ機能することに注意してください。これが事実であるかどうかを確認する必要があります。
ズリン

-1

C ++ 17現在:

stdファイルシステムが含まれていることを確認してください。

#include <filesystem>

そして今、あなたはこれを行うことができます。

std::filesystem::current_path().string()

boostファイルシステムが標準libの一部になりました。

それが見つからない場合は、以下を調べてみてください。

std::experimental::filesystem

10
これはバイナリのパスではなく、現在の作業ディレクトリです。
Zitrax

-2

これがWindowsでの私の解決策でした。これは次のように呼ばれます:

std::wstring sResult = GetPathOfEXE(64);

ここで、64はパスが予想される最小サイズです。GetPathOfEXEはそれ自体を再帰的に呼び出し、切り捨てずにパス全体を取得するのに十分な大きさのバッファを取得するまで、毎回バッファのサイズを倍にします。

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());
    }
}

new(間違った)を使用する理由は何deleteですか?を使用したstd::vector場合、コードは未定義の動作を示さなかったでしょう。
IInspectable

さらに、GetModuleFileNameW成功した場合に最後のエラーコードを設定しません。そのコードは多くの点で壊れています。これを偶然見つけた場合は使用しないでください。
IInspectable

-3
char exePath[512];
CString strexePath;
GetModuleFileName(NULL,exePath,512);
strexePath.Format("%s",exePath);
strexePath = strexePath.Mid(0,strexePath.ReverseFind('\\'));

2
これはWindows専用であり、MFCを使用しているため、クロスプラットフォームからは程遠いので、申し訳ありません。
ベンハイマーズ

1
これもWindowsのやり方ではありません。PathRemoveFileSpec()代わりに、関連する関数を見てください。
Remy Lebeau

-4

Unix(Linuxを含む)では「which」を、Windowsでは「where」を試してください。

#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 %s > my.path", argv[0]);
#else
        sprintf(cmd, "where %s > 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;
}

-4

この方法は、WindowsとLinuxの両方で機能します。

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

2
これは、同じではない可能性がある実行可能ファイルへのパスではなく、現在の作業ディレクトリを返します。
Dave Durbin
弊社のサイトを使用することにより、あなたは弊社のクッキーポリシーおよびプライバシーポリシーを読み、理解したものとみなされます。
Licensed under cc by-sa 3.0 with attribution required.