bibliotecas - boost c++

Obtener ruta de ejecutable

Question

Sé que esta pregunta ya se hizo antes, pero todavía no he visto una respuesta satisfactoria, o un "no, no se puede hacer" definitivamente, así que volveré a preguntar.

Todo lo que quiero hacer es obtener la ruta al ejecutable actualmente en ejecución, ya sea como una ruta absoluta o relativa a donde se invoca el ejecutable, de una manera independiente de la plataforma. Aunque el boost :: filesystem :: initial_path fue la respuesta a mis problemas, pero parece que solo maneja la parte de la pregunta "independiente de la plataforma", aún devuelve la ruta desde la cual se invocó la aplicación.

Por un poco de historia, este es un juego que usa Ogre, y estoy tratando de crear un perfil usando Very Sleepy, que ejecuta el ejecutable de destino desde su propio directorio, así que por supuesto al cargar el juego no encuentra archivos de configuración, etc. . Quiero poder pasar una ruta absoluta a los archivos de configuración, que sé que siempre vivirán junto al ejecutable. Lo mismo ocurre con la depuración en Visual Studio. Me gustaría poder ejecutar $ (TargetPath) sin tener que establecer el directorio de trabajo.

Answer 1

Bueno, he encontrado una solución muy interesante para los usuarios de Linux (probado) y también puede funcionar para Windows.

Aqui esta el link

Puede crear el archivo exe en Linux tipeando esto en la terminal: g ++ -o test test.cpp

Answer 2

De esta forma usa boost + argv. Usted mencionó que esto puede no ser multiplataforma porque puede incluir o no el nombre del ejecutable. Bueno, el siguiente código debería funcionar alrededor de eso.

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

El siguiente código obtiene el directorio de trabajo actual que puede hacer lo que necesita

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

Nota Solo se dio cuenta de que basename( ) estaba en desuso así que tuve que cambiar a .stem()

Answer 3

En caso de que necesite manejar rutas Unicode para Windows:

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

Answer 4

Esta es una forma específica de Windows, pero es al menos la mitad de su respuesta.

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

Sugiero usar la detección de plataforma como directivas de preprocesador para cambiar la implementación de una función de envoltura que llama a GetThisPath para cada plataforma.

Answer 5

Esta fue mi solución en Windows. Se llama así:

std::wstring sResult = GetPathOfEXE(64);

Donde 64 es el tamaño mínimo que crees que será el camino. GetPathOfEXE se llama recursivamente, duplicando el tamaño del búfer cada vez hasta que obtiene un búfer lo suficientemente grande como para obtener la ruta completa sin truncamiento.

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

Answer 6

Este método funciona tanto para Windows como para 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;
}

Answer 7

La función boost::dll::program_location es uno de los mejores métodos de plataforma cruzada para obtener la ruta del archivo ejecutable que conozco. La biblioteca DLL se agregó a Boost en la versión 1.61.0.

La siguiente es mi solución. Lo he probado en Windows, Mac OS X, Solaris, BSD gratuito y GNU / Linux.

Requiere Boost 1.55.0 o superior. Utiliza la biblioteca Boost.Filesystem directamente y la biblioteca Boost.Locale y la biblioteca Boost.System indirectamente.

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_

Tengo un proyecto completo, que incluye una aplicación de prueba y archivos de compilación CMake disponibles en SnKOpen - / cpp / executable_path / trunk . Esta versión es más completa que la versión que proporcioné aquí. También es compatible con más plataformas.

He probado la aplicación en todos los sistemas operativos compatibles en los siguientes cuatro escenarios.

1. Ruta relativa, ejecutable en el directorio actual: ie ./executable_path_test
2. Ruta relativa, ejecutable en otro directorio: es decir ./build/executable_path_test
3. Ruta completa: ie / some / dir / executable_path_test
4. Ejecutable en ruta, solo nombre de archivo: es decir, executable_path_test

En los cuatro escenarios, las funciones executable_path y executable_path_fallback funcionan y devuelven los mismos resultados.

Notas

Esta es una respuesta actualizada a esta pregunta. Actualicé la respuesta para tener en cuenta los comentarios y sugerencias de los usuarios. También agregué un enlace a un proyecto en mi Repositorio SVN.

Answer 8

Lo siguiente funciona como una solución rápida y sucia, pero tenga en cuenta que está lejos de ser infalible:

#include <iostream>
using namespace std ;
int main( int argc, char** argv)
{
cout << argv[0] << endl ;
return 0;
}

Answer 9

No estoy seguro acerca de Linux, pero prueba esto para 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;
}
}

Answer 10

No hay una plataforma cruzada que yo sepa.

Para Linux: readlink / proc / self / exe

Windows: GetModuleFileName

Answer 11

Para Windows puede usar GetModuleFilename ().
Para Linux, vea BinReloc .

Answer 12

Para Windows, tiene el problema de cómo quitar el ejecutable del resultado de GetModuleFileName() . La API de Windows llama a PathRemoveFileSpec() que Nate usó para ese propósito en su respuesta, cambió entre Windows 8 y sus predecesores Entonces, ¿cómo seguir siendo compatible con ambos y seguro? Afortunadamente, hay C ++ 17 (o Boost, si está usando un compilador anterior). Hago esto:

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

Answer 13

Para ventanas:

GetModuleFileName - devuelve el nombre de archivo exe ruta + exe

Para eliminar el nombre del archivo
PathRemoveFileSpec

Answer 14

QT proporciona esto con la abstracción del sistema operativo como QCoreApplication::applicationDirPath()

Answer 15

Usando args [0] y buscando ''/'' (o ''//'):

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

EDITADO: Si ''/'' no existe, pos == - 1 entonces el resultado es correcto.

Answer 16

en Unix (incluido Linux) intente ''which'', en Windows intente ''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;
}

Answer 17

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