Как мне получить каталог, из которого запущена программа?

Для Win32 GetCurrentDirectory должен помочь.

Нет, стандартного способа нет. Я считаю, что стандарты C / C++ даже не рассматривают существование каталогов (или других организаций файловых систем).

В Windows GetModuleFileName () вернет полный путь к исполняемому файлу текущего процесса, если для параметра hModule установлено значение НУЛЕВОЙ. Я не могу помочь с Linux.

Также вы должны уточнить, хотите ли вы текущий каталог или каталог, в котором находится образ программы / исполняемый файл. В настоящее время ваш вопрос немного двусмысленен по этому поводу.

Если вам нужен стандартный способ без библиотек: Нет. Вся концепция каталога не включена в стандарт.

Если вы согласны с тем, что некоторая (переносимая) зависимость от почти стандартной библиотеки допустима: используйте Библиотека файловой системы Boost и запросите initial_path ().

ИМХО, это как можно ближе, с хорошей кармой (Boost - это хорошо зарекомендовавший себя высококачественный набор библиотек)

На платформах POSIX вы можете использовать getcwd ().

В Windows вы можете использовать _getcwd (), поскольку использование getcwd () устарело.

Для стандартных библиотек, если бы Boost был для вас достаточно стандартным, я бы предложил Boost :: filesystem, но, похоже, они удалили нормализацию пути из предложения. Возможно, вам придется подождать до TR2 становится доступным, чтобы получить полностью стандартное решение.

Может быть, объединить текущий рабочий каталог с argv [0]? Я не уверен, будет ли это работать в Windows, но это работает в Linux.

Например:

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

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

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

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

    return 0;
}

При запуске выводит:

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

Вы не можете использовать argv [0] для этой цели, обычно он содержит полный путь к исполняемому файлу, но не обязательно - процесс может быть создан с произвольным значением в поле.

Также учтите, что текущий каталог и каталог с исполняемым файлом - это две разные вещи, поэтому getcwd () вам тоже не поможет.

В Windows используйте GetModuleFileName (), в Linux - файлы / dev / proc / procID / ...

initial_path() Boost Filesystem ведет себя как getcwd() POSIX, и ни один из них не делает то, что вы хотите, но добавление argv[0] к любому из них должно сделать это.

Вы можете заметить, что результат не всегда хорош - вы можете получить такие вещи, как /foo/bar/../../baz/a.out или /foo/bar//baz/a.out, но я считаю, что это всегда приводит к правильному пути, который называет исполняемый файл (обратите внимание, что последовательные косые черты в пути свернуты до одного).

Ранее я писал решение, используя envp (третий аргумент main(), который работал в Linux, но не казался работоспособным в Windows, поэтому я по существу рекомендую то же решение, что и кто-то ранее, но с дополнительным объяснением, почему это так. на самом деле правильно, даже если результаты не очень хороши.

Если вы выбираете текущий каталог при первом запуске вашей программы, то вы фактически получаете каталог, из которого была запущена ваша программа. Сохраните значение в переменной и обратитесь к нему позже в своей программе. Это отличается от каталог, в котором находится текущий исполняемый файл программы. Это не обязательно тот же каталог; если кто-то запускает программу из командной строки, то программа является бежать от текущим рабочим каталогом командной строки, даже если файл программы находится в другом месте.

getcwd - это функция POSIX, которая "из коробки" поддерживается всеми POSIX-совместимыми платформами. Вам не нужно делать ничего особенного (кроме включения правильных заголовков unistd.h в Unix и direct.h в Windows).

Поскольку вы создаете программу на языке C, она будет связана с библиотекой времени выполнения c по умолчанию, с которой связаны ВСЕ процессы в системе (исключение специально созданных исключений), и она будет включать эту функцию по умолчанию. CRT никогда не считается внешней библиотекой, поскольку она обеспечивает базовый стандартный интерфейс для ОС.

В Windows функция getcwd устарела в пользу _getcwd. Я думаю, вы могли бы использовать это таким образом.

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

 char cCurrentPath[FILENAME_MAX];

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

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

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

Вот код для получения полного пути к исполняющему приложению:

Окна:

char pBuf[256];
size_t len = sizeof(pBuf); 
int bytes = GetModuleFileName(NULL, pBuf, len);
return bytes ? bytes : -1;

Linux:

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

Просто чтобы с опозданием навалить сюда ...

стандартного решения не существует, потому что языки не зависят от базовых файловых систем, поэтому, как говорили другие, концепция файловой системы на основе каталогов выходит за рамки языков c / C++.

кроме того, вам нужен не текущий рабочий каталог, а каталог, в котором работает программа, который должен учитывать, как программа попала туда, где она находится, то есть была ли она порождена как новый процесс через вилку и т. д. Чтобы получить каталог, в котором выполняется программа, как показали решения, необходимо, чтобы вы получили эту информацию из структур управления процессами рассматриваемой операционной системы, которая является единственным авторитетом по этому вопросу. Таким образом, по определению, это решение для конкретной ОС.

Как упоминалось в Минок, такая функциональность не указана в стандарте C или стандарте C++. Это считается чисто специфической функцией ОС и определено, например, в стандарте POSIX.

Thorsten79 дал хорошее предложение, это библиотека Boost.Filesystem. Однако это может быть неудобно, если вы не хотите иметь какие-либо зависимости времени компоновки в двоичной форме для вашей программы.

Хорошей альтернативой, которую я бы порекомендовал, является сбор 100% только заголовков Библиотеки STLSoft C++Мэтью Уилсон (автор обязательных к прочтению книг о C++). Есть переносимый фасад. PlatformSTL предоставляет доступ к системному API: WinSTL для Windows и UnixSTL в Unix, так что это переносимое решение. Все системные элементы указываются с использованием трейтов и политик, поэтому это расширяемая структура. Конечно, есть библиотека файловой системы.

В Windows самый простой способ - использовать функцию _get_pgmptr в stdlib.h, чтобы получить указатель на строку, которая представляет собой абсолютный путь к исполняемому файлу, включая имя исполняемого файла.

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

Для системы Windows в консоли вы можете использовать команду system (dir). Консоль дает вам информацию о каталоге и т. д. Прочтите о команде dir в cmd. Но для Unix-подобных систем я не знаю ... Если эта команда запущена, прочтите команду bash. ls не отображает каталог ...

Пример:

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

Это из cplusplus форум

В окнах:

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

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

В Linux:

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

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

В HP-UX:

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

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

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

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

  return std::string( result );
}

#include <windows.h>
using namespace std;

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

Вот что я сделал для относительных путей. Я знаю возраст этого вопроса, я просто хочу предложить более простой ответ, который работает в большинстве случаев:

Скажем, у вас есть такой путь:

"path/to/file/folder"

По какой-то причине исполняемые файлы Linux, созданные в eclipse, отлично с этим работают. Однако окна очень запутываются, если им задан такой путь для работы!

Как указывалось выше, есть несколько способов получить текущий путь к исполняемому файлу, но самый простой способ, который, как я считаю, работает очаровательно в большинстве случаев, - это добавить это к ПЕРЕДНЕМУ вашего пути:

"./path/to/file/folder"

Простое добавление "./" должно помочь вам разобраться! :) Затем вы можете начать загрузку из любого каталога, который хотите, при условии, что он находится с самим исполняемым файлом.

Обновлено: Это не сработает, если вы попытаетесь запустить исполняемый файл из code :: blocks, если используется среда разработки, поскольку по какой-то причине code :: blocks не загружает материал правильно ...: D

EDIT2: Я обнаружил некоторые новые вещи: если вы укажете статический путь, подобный этому, в своем коде (при условии, что вам нужно загрузить Example.data):

"resources/Example.data"

Если вы затем запустите свое приложение из фактического каталога (или в Windows вы создадите ярлык и установите рабочий каталог в каталог вашего приложения), тогда оно будет работать так. Помните об этом при отладке проблем, связанных с отсутствующими путями к ресурсам / файлам. (Особенно в IDE, которые устанавливают неправильный рабочий каталог при запуске сборки exe из IDE)

Я знаю, что уже очень поздно давать ответ на этот вопрос, но я обнаружил, что ни один из ответов не был для меня так полезен, как мое собственное решение. Очень простой способ получить путь от вашего CWD к вашей папке bin выглядит следующим образом:

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

Теперь вы можете просто использовать это как основу для своего относительного пути. Так, например, у меня есть такая структура каталогов:

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

и я хочу скомпилировать исходный код в bin и написать журнал для тестирования. Я могу просто добавить эту строку в свой код.

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

Я пробовал этот подход в Linux, используя полный путь, псевдоним и т. д., И он отлично работает.

ПРИМЕЧАНИЕ:

Если вы работаете в Windows, в качестве разделителя файлов следует использовать символ '\', а не '/'. Вам также придется избежать этого, например:

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

Я думаю, что это должно сработать, но не тестировал, поэтому будут признательны за комментарии, если это сработает, или исправление, если нет.

Файловая система TS теперь стандарт (и поддерживается gcc 5.3+ и clang 3.9+), поэтому вы можете использовать из нее функцию current_path():

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

В gcc (5.3+) для включения файловой системы вам необходимо использовать:

#include <experimental/filesystem>

и свяжите свой код с флагом -lstdc++fs.

Если вы хотите использовать файловую систему с Microsoft Visual Studio, тогда прочитай это.

Команда linux bash какое имя программы сообщит путь к программе.

Даже если можно было бы выполнить команду which из вашей программы и направить вывод в файл tmp и программу впоследствии читает этот файл tmp, он не скажет вам, выполняется ли эта программа. Он только сообщает вам, где находится программа с таким именем.

Что требуется, так это получить номер идентификатора вашего процесса и разобрать путь к имени

В моей программе я хочу знать, была ли программа выполняется из каталога bin пользователя или из другого каталога по пути или из / usr / bin. / usr / bin будет содержать поддерживаемую версию. Мне кажется, что в Linux есть одно портативное решение.

Библиотечное решение (хотя я знаю, что об этом не просили). Если вы используете Qt: QCoreApplication::applicationDirPath()

Используйте realpath() в stdlib.h следующим образом:

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

Работает с C++ 11, начиная с экспериментальной файловой системы, и с C++ 14-C++ 17, а также с официальной файловой системой.

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
}

Всего два цента, но разве следующий код не работает на C++ 17?

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

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

Кажется, у меня работает по крайней мере на Linux.

Основываясь на предыдущей идее, теперь у меня есть:

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

При реализации:

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

И трюк с инициализацией в main():

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

Спасибо @Sam Redway за идею argv [0]. И, конечно же, я понимаю, что C++ 17 не было много лет, когда ОП задал вопрос.

Путь к текущему .exe

#include <Windows.h>

std::wstring getexepathW()
{
    wchar_t result[MAX_PATH];
    return std::wstring(result, GetModuleFileNameW(NULL, result, MAX_PATH));
}

std::wcout << getexepathW() << std::endl;

//  -------- OR --------

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

std::cout << getexepathA() << std::endl;