¿Cómo obtener el Directorio actual?

He estado haciendo esto en C # y Delphi, pero C ++ es malo. El propósito es crear un archivo en el directorio actual (donde se ejecuta el ejecutable).

Mi código:

LPTSTR NPath = NULL; DWORD a = GetCurrentDirectory(MAX_PATH,NPath); HANDLE hNewFile = CreateFile(NPath,GENERIC_WRITE,0,NULL,CREATE_ALWAYS,FILE_ATTRIBUTE_NORMAL,NULL); 

Obtengo una excepción en GetCurrentDirectory ().

Por favor, dime por qué recibo una excepción y ¿cómo puedo hacerlo más fácil en C ++?

Yo recomendaría leer un libro en C ++ antes de ir más lejos, ya que sería útil tener una base más firme. Acelerado C ++ por Koenig y Moo es excelente.

Para obtener la ruta ejecutable, use GetModuleFileName :

 char buffer[MAX_PATH]; GetModuleFileName( NULL, buffer, MAX_PATH ); 

Aquí hay una función de C ++ que obtiene el directorio sin el nombre del archivo:

 #include  #include  #include  using namespace std;; string ExePath() { char buffer[MAX_PATH]; GetModuleFileName( NULL, buffer, MAX_PATH ); string::size_type pos = string( buffer ).find_last_of( "\\/" ); return string( buffer ).substr( 0, pos); } int main() { cout << "my directory is " << ExePath() << "\n"; } 

GetCurrentDirectory no asigna espacio para el resultado, depende de usted hacer eso.

 TCHAR NPath[MAX_PATH]; GetCurrentDirectory(MAX_PATH, NPath); 

Además, eche un vistazo a la biblioteca Boost.Filesystem si desea hacer esto de la manera C ++.

En mi humilde opinión aquí hay algunas mejoras a la respuesta de anon .

 #include  #include  #include  std::string GetExeFileName() { char buffer[MAX_PATH]; GetModuleFileName( NULL, buffer, MAX_PATH ); return std::string(buffer); } std::string GetExePath() { std::string f = GetExeFileName(); return f.substr(0, f.find_last_of( "\\/" )); } 

Debe proporcionar un marcador de posición de búfer válido. es decir:

 TCHAR s[100]; DWORD a = GetCurrentDirectory(100, s); 

No olvide inicializar sus búferes en algo antes de utilizarlos. Y lo que es igual de importante, dale espacio a tus buffers de cadena para la terminación nula

 TCHAR path[MAX_PATH+1] = L""; DWORD len = GetCurrentDirectory(MAX_PATH, path); 

Referencia

Puede eliminar el nombre de archivo de GetModuleFileName() de una manera más elegante:

 TCHAR fullPath[MAX_PATH]; TCHAR driveLetter[3]; TCHAR directory[MAX_PATH]; TCHAR FinalPath[MAX_PATH]; GetModuleFileName(NULL, fullPath, MAX_PATH); _splitpath(fullPath, driveLetter, directory, NULL, NULL); sprintf(FinalPath, "%s%s",driveLetter, directory); 

¡Espero eso ayude!

 #include  #include  #include  std::string current_working_directory() { char* cwd = _getcwd( 0, 0 ) ; // **** microsoft specific **** std::string working_directory(cwd) ; std::free(cwd) ; return working_directory ; } int main(){ std::cout << "i am now in " << current_working_directory() << endl; } 

No pude usar GetModuleFileName correctamente. Encontré este trabajo muy bien. acaba de probar en Windows, aún no probar en Linux 🙂

GetCurrentDirectory () obtiene el directorio actual, que es donde se invoca el exe. Para obtener la ubicación del exe, use GetModuleFileName (NULL …). si tiene el control para el exe, o puede derivarlo de GetCommandLine () si no lo hace.

Como señala el Sr. Butterworth, no necesitas un mango.

 WCHAR path[MAX_PATH] = {0}; GetModuleFileName(NULL, path, MAX_PATH); PathRemoveFileSpec(path); 
 #include  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); } 

¿Por qué nadie aquí considera usar este código simple?

 TCHAR szDir[MAX_PATH] = { 0 }; GetModuleFileName(NULL, szDir, MAX_PATH); szDir[std::string(szDir).find_last_of("\\/")] = 0; 

o incluso más simple

 TCHAR szDir[MAX_PATH] = { 0 }; TCHAR* szEnd = nullptr; GetModuleFileName(NULL, szDir, MAX_PATH); szEnd = _tcsrchr(szDir, '\\'); *szEnd = 0; 

Fragmentos de código de mi proyecto CAE con entorno de desarrollo unicode:

 /// @brief Gets current module file path. std::string getModuleFilePath() { TCHAR buffer[MAX_PATH]; GetModuleFileName( NULL, buffer, MAX_PATH ); CT2CA pszPath(buffer); std::string path(pszPath); std::string::size_type pos = path.find_last_of("\\/"); return path.substr( 0, pos); } 

Simplemente use el templete CA2CAEX o CA2AEX que llama a la API interna :: MultiByteToWideChar o :: WideCharToMultiByte .

Para encontrar el directorio donde está el ejecutable, puede usar:

 TCHAR szFilePath[_MAX_PATH]; ::GetModuleFileName(NULL, szFilePath, _MAX_PATH); 
 String^ exePath = Application::ExecutablePath;
MessageBox::Show(exePath);