c++ 如何正确使用GetModuleFileName？

58wvjzkj  于 2023-06-25  发布在  其他
关注(0)|答案(6)|浏览(134)

以下代码：

  1. #include <iostream>
  2. #include <Windows.h>
  4. using namespace std;
  6. int main ()
  7. {   LPWSTR buffer; //or wchar_t * buffer;
  8.     GetModuleFileName(NULL, buffer, MAX_PATH) ;
  9.     cout<<buffer;
  10.     cin.get();
  11.     cin.get();
  13. }

应该显示程序执行的完整路径。但是在VS 2012中，我得到了错误：
使用了未初始化的局部变量“buffer”
代码有什么问题？

c++

6条答案

按热度按时间
cunj1qz1

cunj1qz11#

你需要给予它一个缓冲区，可以容纳一些字符;

  1. wchar_t buffer[MAX_PATH];

例如。

赞(0）分享  回复(0）举报  2023-06-25
vof42yt1

vof42yt12#

VS正确地指出你正在使用一个未初始化的缓冲区-buffer var是一个指向WSTR的指针，但是它没有被静态缓冲区初始化，也没有被分配。另外，您应该记住MAX_PATH通常是不够的，特别是在具有长路径名的现代系统上。
既然你正在使用C++，那么使用它的特性将是一个很好的实践。我可以假设以下代码：

  1. vector<wchar_t> pathBuf; 
  2. DWORD copied = 0;
  3. do {
  4.     pathBuf.resize(pathBuf.size()+MAX_PATH);
  5.     copied = GetModuleFileName(0, &pathBuf.at(0), pathBuf.size());
  6. } while( copied >= pathBuf.size() );
  8. pathBuf.resize(copied);
  10. wstring path(pathBuf.begin(),pathBuf.end());
  12. cout << path;
  • 注意：在C++11之前，std::string和std::wstring的标准不保证具有连续的数据，并且可能不安全地用作缓冲区。但是，它们在所有主要标准库中都是连续的。
展开查看全部
赞(0）分享  回复(0）举报  2023-06-25
vktxenjb

vktxenjb3#

这是Win32 API的一个普遍问题，函数将字符串返回到一个有限大小的缓冲区，你永远不知道你的缓冲区是否足够大来容纳整个字符串。正如kingsb提到的，即使MAX_PATH现在也不是一个足够好的路径常量。
我倾向于使用一个通用的helper函数来实现这个目的：

  1. template <typename TChar, typename TStringGetterFunc>
  2. std::basic_string<TChar> GetStringFromWindowsApi( TStringGetterFunc stringGetter, int initialSize = 0 )
  3. {
  4.     if( initialSize <= 0 )
  5.     {
  6.         initialSize = MAX_PATH;
  7.     }
  9.     std::basic_string<TChar> result( initialSize, 0 );
  10.     for(;;)
  11.     {
  12.         auto length = stringGetter( &result[0], result.length() );
  13.         if( length == 0 )
  14.         {
  15.             return std::basic_string<TChar>();
  16.         }
  18.         if( length < result.length() - 1 )
  19.         {
  20.             result.resize( length );
  21.             result.shrink_to_fit();
  22.             return result;
  23.         }
  25.         result.resize( result.length() * 2 );
  26.     }
  27. }

对于GetModuleFileName，可以这样使用：

  1. extern HINSTANCE hInstance;
  3. auto moduleName = GetStringFromWindowsApi<TCHAR>( []( TCHAR* buffer, int size )
  4. {
  5.     return GetModuleFileName( hInstance, buffer, size );
  6. } );

对于LoadString，像这样：

  1. std::basic_string<TCHAR> LoadResourceString( int id )
  2. {
  3.     return GetStringFromWindowsApi<TCHAR>( [id]( TCHAR* buffer, int size )
  4.     {
  5.         return LoadString( hInstance, id, buffer, size );
  6.     } );
  7. }
展开查看全部
赞(0）分享  回复(0）举报  2023-06-25
zengzsys

zengzsys4#

而且，在我下面的答案的旁注/补充：有时候，你想访问一个函数size_t GetString(char* buf = NULL, size_t bufsize = 0);，如果你不带任何参数调用它，它将返回必要的缓冲区大小，如果你正常调用它，最多写入bufsize字符到buf（或者直到它想要返回的字符串的末尾，无论先到的），返回实际写入的字符数。一个实现可能看起来像这样：

  1. class GetterClass
  2. {
  3. private:
  4.     size_t String2Buffer(const std::string& string, char* const pBuffer = NULL, size_t size = 0)
  5.     {
  6.         size_t s, length = string.length() + 1;
  7.         if (!pBuffer) return length;
  8.         s = std::min<>(length, size);
  9.         memcpy(pBuffer, string.c_str(), s);
  10.         return s;
  11.     }
  12. public:
  13.     size_t GetterFunc(char* p, size_t len)
  14.     {
  15.         const static std::string s("Hello World!");
  16.         return String2Buffer(s, p, len);
  17.     }
  18. };

这通常发生在类工厂中，这些工厂位于DLL中，并且由于内存管理的原因，不想交换复杂类型，如std：：string。要使用接口，您通常会以丑陋的代码结束：

  1. GetterClass g;
  2. GetterClass* pg = &g;
  3. std::string s(pg->GetterFunc() - 1, '\0');
  4. pg->GetterFunc(&s[0], s.size());

这很糟糕，原因很明显，一个是你不能直接在流插入中使用它。经过一些拖延和撕扯我的头发，我想出了几乎色情的解决方案，至少在模板和成员函数指针的使用方面：

  1. template <typename tClass>
  2. struct TypeHelper
  3. {
  4.     typedef size_t(tClass::* MyFunc)(char*, size_t);
  5.     static std::string Get(MyFunc fn, tClass& c)
  6.     {
  7.         size_t len = (c.*fn)(NULL, 0);
  8.         std::string s(len - 1, '\0');
  9.         size_t act = (c.*fn)(&s[0], len - 1);
  10.         assert(act == s.size());
  11.         return s;
  12.     }
  13. };

其然后可以以以下方式使用：

  1. GetterClass Foo;
  2. GetterClass* pFoo = &Foo;
  3. std::string s1 = TypeHelper<GetterClass>::Get(&GetterClass::GetterFunc, Foo); // Class version.
  4. std::string s2 = TypeHelper<GetterClass>::Get(&GetterClass::GetterFunc, *pFoo); // Pointer-to-Instance version.

仍然有点复杂，但大部分繁重的工作都隐藏在幕后。

展开查看全部
赞(0）分享  回复(0）举报  2023-06-25
5m1hhzi4

5m1hhzi45#

我还遇到了信任char pszPath[_MAX_PATH]足以让::GetModuleFilename()正常工作的问题（事实并非如此！）。因此，我冒昧地对Ivan的建议进行了一点修改，得出了以下代码

  1. template <typename TChar, typename TStringGetterFunc>
  2. std::basic_string<TChar> GetStringFromWindowsApi(TStringGetterFunc stringGetter, typename std::basic_string<TChar>::size_type initialSize = _MAX_PATH)
  3. {
  4.     std::basic_string<TChar> sResult(initialSize, 0);
  5.     while(true)
  6.     {
  7.         auto len = stringGetter(&sResult[0], sResult.length());
  8.         if (len == 0) return std::basic_string<TChar>();
  10.         if (len < sResult.length() - 1)
  11.         {
  12.             sResult.resize(len);
  13.             sResult.shrink_to_fit();
  14.             return sResult;
  15.         }
  17.         sResult.resize(sResult.length() * 2);
  18.     }
  19. }

你可以用多种方式来使用，e。例如：

  1. std::string sModuleFileName = GetStringFromWindowsApi<char>([](char* buffer, int size)
  2. {
  3.     return ::GetModuleFileNameA(NULL, buffer, size);
  4. });

如果你对lambda表达式没问题的话。如果成员变量是必需的，因为在DLL中经常会将HMODULE存储在DllMain(HMODULE hm, DWORD ul_reason_for_call, LPVOID)中，则必须添加this指针，如下所示：

  1. std::string sModuleFileName = GetStringFromWindowsApi<char>([this](char* buffer, int size)
  2. {
  3.     return ::GetModuleFileNameA(m_MyModuleHandleHere, buffer, size);
  4. });

当然，“老式的方式”也可以像这个测试用例中所示的那样工作：

  1. typedef int (PGetterFunc)(char*, int);
  2. int MyGetterFunc(char* pszBuf, int len)
  3. {
  4.     static const char psz[] = "**All your base are belong to us!**";
  5.     if (len < strlen(psz) + 1)
  6.     {
  7.         strncpy(pszBuf, psz, len - 1);
  8.         return len;
  9.     }
  10.     strcpy(pszBuf, psz);
  11.     return static_cast<int>(strlen(psz));
  12. }
  14. void foo(void)
  15. {
  16.     std::string s = GetStringFromWindowsApi<char, PGetterFunc>(MyGetterFunc, _MAX_PATH);
  17. }

你甚至可以使用TCHAR进行ANSI/UNICODE抽象，类似于这样：

  1. std::basic_string<TCHAR> sModuleFileName = GetStringFromWindowsApi<TCHAR>([](TCHAR* buffer, int size)
  2. {
  3.     return ::GetModuleFileName(NULL, buffer, size);
  4. });

或者#include <tstdlib.h>，我不知道从哪里弄来的：

  1. #include <string>
  2. #include <sstream>
  3. #include <iostream>
  4. #include <fstream>
  5. #include <stdlib.h>
  6. #include <assert.h>
  8. #ifdef _WIN32
  9. #include <tchar.h> // For _T() macro!
  10. #else // Non Windows Platform!
  11. #ifdef _UNICODE
  12. typedef wchar_t TCHAR;
  13. #ifndef _T
  14. #define _T(s) L##s
  15. #endif
  16. #ifndef _TSTR
  17. #define _TSTR(s) L##s
  18. #endif
  19. #else
  20. typedef wchar_t TCHAR;
  21. #ifndef _T
  22. #define _T(s) s
  23. #endif
  24. #ifndef _TSTR
  25. #define _TSTR(s) s
  26. #endif
  27. #endif
  28. #endif
  30. /// <summary>
  31. /// The tstd namespace contains the STL equivalents to TCHAR as defined in <tchar.h> to allow
  32. /// all the Unicode magic happen with strings and streams of the STL.
  33. /// Just use tstd::tstring instead of std::string etc. and the correct types will automatically be selected
  34. /// depending on the _UNICODE preprocessor flag set or not.
  35. /// E. g.
  36. /// tstd::tstring will resolve to std::string if _UNICODE is NOT defined and
  37. /// tstd::tstring will resolve to std::wstring _UNICODE IS defined.
  38. /// </summary>
  39. namespace tstd
  40. {
  41. #ifdef _UNICODE
  42.     // Set the wide character versions.
  43.     typedef std::wstring tstring;
  44.     typedef std::wostream tostream;
  45.     typedef std::wistream tistream;
  46.     typedef std::wiostream tiostream;
  47.     typedef std::wistringstream tistringstream;
  48.     typedef std::wostringstream tostringstream;
  49.     typedef std::wstringstream tstringstream;
  50.     typedef std::wifstream tifstream;
  51.     typedef std::wofstream tofstream;
  52.     typedef std::wfstream tfstream;
  53.     typedef std::wfilebuf tfilebuf;
  54.     typedef std::wios tios;
  55.     typedef std::wstreambuf tstreambuf;
  56.     typedef std::wstreampos tstreampos;
  57.     typedef std::wstringbuf tstringbuf;
  59.     // declare an unnamed namespace as a superior alternative to the use of global static variable declarations.
  60.     namespace
  61.     {
  62.         tostream& tcout = std::wcout;
  63.         tostream& tcerr = std::wcerr;
  64.         tostream& tclog = std::wclog;
  65.         tistream& tcin = std::wcin;
  67.         /// <summary>
  68.         /// Unicode implementation for std::endl.
  69.         /// </summary>
  70.         /// <param name="output">Output character stream.</param>
  71.         /// <returns>Output character stream.</returns>
  72.         std::wostream& tendl(std::wostream& output)
  73.         {
  74.             output << std::endl;
  75.             return output;
  76.         }
  78.         /// <summary>
  79.         /// wstr to tstr conversion for Unicode. Nothing to do here but copying things.
  80.         /// </summary>
  81.         /// <param name="arg">Input string.</param>
  82.         /// <returns>Output string conversted from std::wstring to tstd::tstring.</returns>
  83.         tstring wstr_to_tstr(const std::wstring& arg)
  84.         {
  85.             return arg;
  86.         }
  88.         /// <summary>
  89.         /// str to tstr conversion for Unicode. Internally calls mbstowcs() for conversion..
  90.         /// </summary>
  91.         /// <param name="arg">Input string.</param>
  92.         /// <returns>Output string conversted from std::string to tstd::tstring.</returns>
  93.         tstring str_to_tstr(const std::string& arg)
  94.         {
  95.             tstring res(arg.length() + 1, L'\0'); // +1 because wcstombs_s() always wants to write a terminating null character.
  96.             size_t converted;
  97.             mbstowcs_s(&converted, const_cast<wchar_t*>(res.data()), res.length(), arg.c_str(), arg.length()); // Using the safer version of mbstowcs() here even though res is always defined adequately.
  98.             assert(converted - 1 == arg.length()); // Sanity test.
  99.             res.resize(res.size() - 1); // Remove '\0'.
  100.             return res;
  101.         }
  103.         /// <summary>
  104.         /// tstr to wstr conversion for Unicode. Nothing to do here but copying things.
  105.         /// </summary>
  106.         /// <param name="arg">Input string.</param>
  107.         /// <returns>Output string conversted from tstd::tstring to std::wstring.</returns>
  108.         std::wstring tstr_to_wstr(const tstring& arg)
  109.         {
  110.             return arg;
  111.         }
  113.         /// <summary>
  114.         /// tstr to str conversion for Unicode. Internally calls wcstombs() for conversion.
  115.         /// </summary>
  116.         /// <param name="arg">Input string.</param>
  117.         /// <returns>Output string conversted from tstd::tstring to std::string.</returns>
  118.         std::string tstr_to_str(const tstring& arg)
  119.         {
  120.             std::string res(arg.length() + 1, '\0'); // +1 because wcstombs_s() always wants to write a terminating null character.
  121.             size_t converted;
  122.             wcstombs_s(&converted, const_cast<char*>(res.data()), res.length(), arg.c_str(), arg.length()); // Using the safer version of wcstombs() here even though res is always defined adequately.
  123.             assert(converted - 1 == arg.length()); // Sanity test.
  124.             res.resize(res.size() - 1); // Remove '\0'.
  125.             return res;
  126.         }
  127.     }
  129. #else
  131.     // Set the multibyte versions.
  132.     typedef std::string tstring;
  133.     typedef std::ostream tostream;
  134.     typedef std::istream tistream;
  135.     typedef std::iostream tiostream;
  136.     typedef std::istringstream tistringstream;
  137.     typedef std::ostringstream tostringstream;
  138.     typedef std::stringstream tstringstream;
  139.     typedef std::ifstream tifstream;
  140.     typedef std::ofstream tofstream;
  141.     typedef std::fstream tfstream;
  142.     typedef std::filebuf tfilebuf;
  143.     typedef std::ios tios;
  144.     typedef std::streambuf tstreambuf;
  145.     typedef std::streampos tstreampos;
  146.     typedef std::stringbuf tstringbuf;
  148.     // declare an unnamed namespace as a superior alternative to the use of global static variable declarations.
  149.     namespace
  150.     {
  151.         tostream& tcout = std::cout;
  152.         tostream& tcerr = std::cerr;
  153.         tostream& tclog = std::clog;
  154.         tistream& tcin = std::cin;
  156.         /// <summary>
  157.         /// Multibyte implementation for std::endl.
  158.         /// </summary>
  159.         /// <param name="output">Output character stream.</param>
  160.         /// <returns>Output character stream.</returns>
  161.         std::ostream& tendl(std::ostream& output)
  162.         {
  163.             output << std::endl;
  164.             return output;
  165.         }
  167.         /// <summary>
  168.         /// wstr to tstr conversion for multibyte. Internally calls wcstombs() for conversion.
  169.         /// </summary>
  170.         /// <param name="arg">Input string.</param>
  171.         /// <returns>Output string conversted from std::wstring to tstd::tstring.</returns>
  172.         tstring wstr_to_tstr(const std::wstring& arg)
  173.         {
  174.             tstring res(arg.length()+1, '\0'); // +1 because wcstombs_s() always wants to write a terminating null character.
  175.             size_t converted;
  176.             wcstombs_s(&converted, const_cast<char*>(res.data()), res.length(), arg.c_str(), arg.length()); // Using the safer version of wcstombs() here even though res is always defined adequately.
  177.             assert(converted-1 == arg.length()); // Sanity test.
  178.             res.resize(res.size() - 1); // Remove '\0'.
  179.             return res;
  180.         }
  182.         /// <summary>
  183.         /// str to tstr conversion for multibyte. Nothing to do here but copying things.
  184.         /// </summary>
  185.         /// <param name="arg">Input string.</param>
  186.         /// <returns>Output string conversted from std::string to tstd::tstring.</returns>
  187.         tstring str_to_tstr(const std::string& arg)
  188.         {
  189.             return arg;
  190.         }
  192.         /// <summary>
  193.         /// tstr to wstr conversion for multibyte. Internally calls mbstowcs() for conversion..
  194.         /// </summary>
  195.         /// <param name="arg">Input string.</param>
  196.         /// <returns>Output string conversted from tstd::tstring to std::wstring.</returns>
  197.         std::wstring tstr_to_wstr(const tstring& arg)
  198.         {
  199.             std::wstring res(arg.length()+1, L'\0'); // +1 because wcstombs_s() always wants to write a terminating null character.
  200.             size_t converted;
  201.             mbstowcs_s(&converted, const_cast<wchar_t*>(res.data()), res.length(), arg.c_str(), arg.length());
  202.             assert(converted-1 == arg.length()); // Sanity test.
  203.             res.resize(res.size() - 1); // Remove '\0'.
  204.             return res;
  205.         }
  207.         /// <summary>
  208.         /// tstr to str conversion for multibyte. Nothing to do here but copying things.
  209.         /// </summary>
  210.         /// <param name="arg">Input string.</param>
  211.         /// <returns>Output string conversted from tstd::tstring to std::string.</returns>
  212.         std::string tstr_to_str(const tstring& arg)
  213.         {
  214.             return arg;
  215.         }
  216.     }
  218. #endif
  219. }
展开查看全部
赞(0）分享  回复(0）举报  2023-06-25
3j86kqsm

3j86kqsm6#

你可以试试这个：

  1. {
  2.     TCHAR szPath[MAX_PATH];
  3.     GetModuleFileName(NULL, szPath, MAX_PATH);
  4. }
赞(0）分享  回复(0）举报  2023-06-25
我来回答

相关问题

    查看更多

    热门标签

    更多
    JavaquerypythonNode开发语言requestUtil数据库Table后端算法LoggerMessageElementParser

    最新问答

    更多
    • 蜀ICP备13028337号-1 大数据知识库 https://www.saoniuhuo.com © All rights reserved
    • 本站内容来源互联网,如果侵犯您的权益请联系我们删除, 联系方式：448109455@qq.com