获取命令行参数的各种变化

最新推荐文章于 2024-04-14 19:12:19 发布

lineCode

最新推荐文章于 2024-04-14 19:12:19 发布

阅读量2.4k

点赞数

分类专栏：备忘录文章标签： null 测试 linker c object 扩展

备忘录专栏收录该内容

32 篇文章 0 订阅

订阅专栏

http://blog.csdn.net/silvergingko/article/details/6072083

通常，在VC++中获取命令行参数的有如下几种方式:

在控制台程序中：

C++运行时库通过入口函数main传递进来的参数int argc 和 char* argv[]。其中第二个参数将一个完整的命令行分割成指向各参数的字符串指针数组，数组中的每一个元素是一个指向参数的字符串指针。其中， argv[0] 指向应用程序名自身。

如果想获得像窗口形式的完整命令行参数CmdLine的话，可以调用API GetCommandLine() 获得。

在窗口程序中：

C++运行时库通过入口函数WinMain传递进来的参数LPTSTR pszCmdLine。pszCmdLine是一个完整的命令行参数，包含应用程序名自身。

如果想获得像控制台形式的被分割的命令行参数指针数组的话。可以使用如下代码获得：

[cpp]view plaincopy 
   
 //C++ code  
 pszCmdLineW = GetCommandLineW();  
 argv = CommandLineToArgvW(pszCmdLineW, &argc);  
 if (argv != NULL) LocalFree(argv);  

需要注意的是， CommandLineToArgvW只有Unicode的版本，因此省略第二行的代码，而直接将入口函数中提供的参数lpCmdLine传给 CommandLineToArgvW 可能会存在问题，这取决于项目使用的字符集属性，幸好从 VS2005 开始，项目默认使用的字符集就是 Unicode！

然而，在实际使用命令行参数，其实并不像如上所述那么简单，还有几个不确定的因素会导致获得的命令行参数发生变化。

首先，给出三个测试程序， ConApp 是一个控制台程序，WinApp 是一个窗口程序，这两个程序在内部将获取命令行参数并进行显示，AppCaller是另外一个控制台程序，它将分几次调用 ConApp 和 WinApp ，并为它们传递不同的参数。

测试步骤为：

AppCaller创建ConApp 和 WinApp 子进程，并在控制台上输出传给 ConApp 和 WinApp 的参数，然后等待子进程结束。 ConApp 和 WinApp 显示命令行参数后返回， AppCaller再次调用 ConApp 和 WinAPP 并传递其他参数。

三个程序的代码为：

WinApp:

[cpp]view plaincopy 
   
 //C++ code  
 //Win32 project.  
 //WinApp.cpp  
   
 #include <Windows.h>  
 #include <tchar.h>  
 #include <strsafe.h>  
 #include <stdarg.h>  
   
 //使用XP风格的控件。  
 #if defined _M_IX86  
 #pragma comment(linker,"/manifestdependency:/"type='win32' name='Microsoft.Windows.Common-Controls' version='6.0.0.0' processorArchitecture='x86' publicKeyToken='6595b64144ccf1df' language='*'/"")  
 #endif  
   
 //函数前导声明。  
 HRESULT FormatTextW(WCHAR **, size_t *, LPCWSTR, ...);  
 HRESULT AppendTextW(WCHAR **, size_t *, LPCWSTR);  
 HRESULT AppendMemHexW(WCHAR **, size_t *, LPBYTE, int);  
   
 int WINAPI _tWinMain(HINSTANCE hInstance, HINSTANCE /*hPrevInstance*/,  
     LPTSTR lpCmdLine, int nCmdShow)  
 {  
     int argc = 0;  
     int chLen = 0;  
     size_t bufLen = 0;  
     HRESULT hr = S_OK;  
     LPWSTR pszCmdLineW = NULL;  
     LPWSTR *argv = NULL;  
     WCHAR szText[1024] = { 0 };  
     LPWSTR pCur = NULL;  
   
     pszCmdLineW = GetCommandLineW();  
     argv = CommandLineToArgvW(pszCmdLineW, &argc);  
   
     //对命令行参数进行一些格式化，存储到szText中，最后通过MessageBox进行显示。  
     bufLen = _countof(szText);  
     pCur = szText;  
     if (SUCCEEDED(  
         hr = FormatTextW(&pCur, &bufLen, L"GetCommandLineW=%s", pszCmdLineW)  
         ) && SUCCEEDED(  
         hr = AppendMemHexW(&pCur, &bufLen, (LPBYTE)pszCmdLineW,  
         wcslen(pszCmdLineW)*sizeof(WCHAR))  
         ) && SUCCEEDED(  
         hr = AppendTextW(&pCur, &bufLen, L"/r/n")  
         ) && SUCCEEDED(  
         hr = AppendTextW(&pCur, &bufLen, L"CommandLineToArgvW:/r/n")  
         ) && SUCCEEDED(  
         hr = FormatTextW(&pCur, &bufLen, L"argc=%d/r/nargv:/r/n", argc)))  
     {  
         for (int i = 0; i < argc; i++)  
         {  
             hr = FormatTextW(&pCur, &bufLen, L"[#%u]%s", i, argv[i]);  
             if (FAILED(hr)) break;  
             hr = AppendMemHexW(&pCur, &bufLen, (LPBYTE)argv[i],  
                 wcslen(argv[i])*sizeof(WCHAR));  
             if (FAILED(hr)) break;  
         }  
     }  
   
     if (argv != NULL) LocalFree(argv);  
   
     if ((SUCCEEDED(hr)) || (hr == STRSAFE_E_INSUFFICIENT_BUFFER))  
     {  
         MessageBoxW(NULL, szText, L"Win App", MB_OK | MB_ICONINFORMATION);  
     }  
   
     return 0;  
 }  
   
 //格式化文本到缓冲区。  
 HRESULT FormatTextW(WCHAR **ppBuf, size_t *pBufLen, LPCWSTR pszFormat, ...)  
 {  
     va_list argList;  
     va_start(argList, pszFormat);  
     int chLen = 0;  
     HRESULT hr = S_OK;  
   
     hr = StringCchVPrintfExW(*ppBuf, *pBufLen, ppBuf, pBufLen,  
         STRSAFE_IGNORE_NULLS, pszFormat, argList);  
     va_end(argList);  
   
     return hr;  
 }  
   
 //添加文本到缓冲区。  
 HRESULT AppendTextW(WCHAR **ppBuf, size_t *pBufLen, LPCWSTR pszText)  
 {  
     return StringCchCatExW(*ppBuf, *pBufLen, pszText, ppBuf, pBufLen,  
         STRSAFE_IGNORE_NULLS);  
 }  
   
 //添加16进制形式的内存字节到缓冲区。  
 HRESULT AppendMemHexW(WCHAR **ppBuf, size_t *pBufLen, LPBYTE pMem, int cbLen)  
 {  
     HRESULT hr = S_OK;  
     WCHAR sz[512] = { 0 };  
   
     hr = StringCchCatEx(*ppBuf, *pBufLen, L"(", ppBuf, pBufLen,  
         STRSAFE_IGNORE_NULLS);  
   
     for (int i = 0; i < cbLen; i += 2)  
     {  
         hr = StringCchPrintfEx(*ppBuf, *pBufLen, ppBuf, pBufLen,  
             STRSAFE_IGNORE_NULLS, L"%02x%02x", pMem[i], pMem[i+1]);  
         if (FAILED(hr)) break;  
         if (i != (cbLen - 2))  
         {  
             hr = StringCchCatEx(*ppBuf, *pBufLen, L" ", ppBuf, pBufLen,  
                 STRSAFE_IGNORE_NULLS);  
             if (FAILED(hr)) break;  
         }  
     }  
   
     if (SUCCEEDED(hr))  
     {  
         hr = StringCchCatEx(*ppBuf, *pBufLen, L")/r/n", ppBuf, pBufLen,  
             STRSAFE_IGNORE_NULLS);  
     }  
     return hr;  
 }  
   
 //end of WinApp.cpp  

ConApp:

[cpp]view plaincopy 
   
 //C++ code  
 //Console project.  
 //ConApp.cpp  
   
 #include <stdio.h>  
 #include <tchar.h>  
 #include <Windows.h>  
   
 //函数前导声明。  
 void PrintMem(LPBYTE, int);  
   
 int _tmain(int /*argc*/, _TCHAR* /*argv[]*/)  
 {  
     int argc = 0;  
     LPWSTR pszCmdLineW = GetCommandLineW();  
     LPWSTR *argv = CommandLineToArgvW(pszCmdLineW, &argc);  
   
     //对命令行参数进行一些格式化，然后输出到控制台上。  
     wprintf(L"GetCommandLineW=%s", pszCmdLineW);  
     PrintMem((LPBYTE)pszCmdLineW, wcslen(pszCmdLineW)*sizeof(WCHAR));  
     _tprintf(_T("/r/n"));  
   
     _tprintf(_T("CommandLineToArgvW:/r/n"));  
     _tprintf(_T("argc=%d/r/nargv:/r/n"), argc);  
     for (int i = 0; i < argc; i++)  
     {  
         wprintf(L"[#%u]%s", i, argv[i]);  
         PrintMem((LPBYTE)argv[i], wcslen(argv[i])*sizeof(WCHAR));  
     }  
     return 0;  
 }  
   
 //输出16进制形式的内存字节。  
 void PrintMem(LPBYTE pMem, int len)  
 {  
     _puttchar(_T('('));  
   
     for (int i = 0; i < len; i += 2)  
     {  
         //内存字节是 Unicode 字符集数据，一次打印两个字节。  
         _tprintf(_T("%02x%02x"), pMem[i], pMem[i+1]);  
         if (i != (len - 2))  
         {  
             _puttchar(_T(' '));  
         }  
     }  
     _tprintf(_T(")/r/n"));  
 }  
   
 //end of ConApp.cpp  

AppCaller:

[c-sharp]view plaincopy 
   
 //C++ code  
 //Console project.  
 //AppCaller.cpp  
  
 #include <stdio.h>  
 #include <tchar.h>  
 #include <Windows.h>  
   
 //函数前导声明。  
 void CallApp(LPCTSTR, LPTSTR);  
   
 int _tmain(int argc, _TCHAR* argv[])  
 {  
     //假设 WinApp.exe 和 CmdApp.exe 在当前目录中。  
     LPCTSTR pszWinApp = _T("WinApp.exe");  
     LPCTSTR pszConApp = _T("ConApp.exe");  
     TCHAR szCmdLine1[] = { _T("/t123") };  
     TCHAR szCmdLine2[] = { _T(" 123") };  
     TCHAR szWinCmdLine1[] = { _T("/"WinApp.exe/"") };  
     TCHAR szWinCmdLine2[] = { _T("WinApp.exe") };  
     TCHAR szConCmdLine1[] = { _T("/"ConApp.exe/"") };  
     TCHAR szConCmdLine2[] = { _T("ConApp.exe") };  
       
     //窗口程序测试。  
     CallApp(pszWinApp, NULL);  
     CallApp(pszWinApp, szWinCmdLine1);  
     CallApp(pszWinApp, szWinCmdLine2);  
     CallApp(pszWinApp, szCmdLine1);  
     CallApp(pszWinApp, szCmdLine2);  
       
     //控制台程序测试。  
     CallApp(pszConApp, NULL);  
     CallApp(pszConApp, szConCmdLine1);  
     CallApp(pszConApp, szConCmdLine2);  
     CallApp(pszConApp, szCmdLine1);  
     CallApp(pszConApp, szCmdLine2);  
       
     return 0;  
 }  
   
 void CallApp(LPCTSTR pszApp, LPTSTR pszCmdLine)  
 {  
     static int c = 0;  
     BOOL bRet = FALSE;  
     STARTUPINFO si = { sizeof(si) };  
     PROCESS_INFORMATION pi = { 0 };  
   
     _tprintf(_T("------------------------------------------/r/n/r/n"));  
     _tprintf(_T("<CASE %d>/r/n/r/n"), c);  
     c++;  
     _tprintf(_T("pszCmdLine -- %s/r/n"),  
         pszCmdLine == NULL ? _T("NULL") : pszCmdLine);  
     bRet = CreateProcess(pszApp, pszCmdLine, NULL, NULL, FALSE, 0,  
         NULL, NULL, &si, &pi);  
     if (bRet != FALSE)  
     {  
         if (WAIT_OBJECT_0 == WaitForSingleObject(pi.hProcess, INFINITE))  
         {  
             CloseHandle(pi.hThread);  
             CloseHandle(pi.hProcess);  
         }  
     }  
     _tprintf(_T("/r/n------------------------------------------/r/n"));  
 }  
   
 //end of AppCaller.cpp  

如果单独测试 ConApp 和 WinApp ，不为它们传递任何参数，

WinApp 在 VS 调试环境中按 F5 调试启动或者在资源管理器中双击文件启动，显示的消息框内容都为：

ConApp 在 VS 调试环境中按 F5 调试启动，输出的内容为：

GetCommandLineW="E:/test/CppConsole/ConApp/Debug/ConApp.exe" (2200 4500 3a00 5c
00 7400 6500 7300 7400 5c00 4300 7000 7000 4300 6f00 6e00 7300 6f00 6c00 6500 5c
00 4300 6f00 6e00 4100 7000 7000 5c00 4400 6500 6200 7500 6700 5c00 4300 6f00 6e
00 4100 7000 7000 2e00 6500 7800 6500 2200 2000 2000)

CommandLineToArgvW:
argc=1
argv:
[#0]E:/test/CppConsole/ConApp/Debug/ConApp.exe(4500 3a00 5c00 7400 6500 7300 740
0 5c00 4300 7000 7000 4300 6f00 6e00 7300 6f00 6c00 6500 5c00 4300 6f00 6e00 410
0 7000 7000 5c00 4400 6500 6200 7500 6700 5c00 4300 6f00 6e00 4100 7000 7000 2e0
0 6500 7800 6500)

如果在控制台中启动，输出的内容为：

GetCommandLineW=ConApp(4300 6f00 6e00 4100 7000 7000)

CommandLineToArgvW:

argc=1

argv:

[#0]ConApp(4300 6f00 6e00 4100 7000 7000)

首先，在窗口和控制台应用程序都未获得参数时，调用 GetCommandLine 和 CommandLineToArgvW 都会成功，返回的内容都是应用程序文件名（含扩展名），且 argc 等于1。

但是，通过比较 ConApp 在两种启动方式中，获得的内容是不同的。

在 VS 调试模式中启动，命令行参数包含文件的完整路径，在控制台中启动，不包含文件路径。

然后，启动 AppCaller 后， ConApp 输出的内容与 WinApp 输出的内容基本上是一致的，且 AppCaller 是在 VS 中启动还是在控制台中启动，都没有差异。并且当没有参数传递给 WinApp 和 ConApp 时，这两个子进程所获得的命令行参数是它们对应的文件名，且不含文件路径。

AppCaller 和 ConApp 在控制台中输出的内容为：

------------------------------------------

pszCmdLine -- NULL
GetCommandLineW="ConApp.exe"(2200 4300 6f00 6e00 4100 7000 7000 2e00 6500 7800 6
500 2200)

CommandLineToArgvW:
argc=1
argv:
[#0]ConApp.exe(4300 6f00 6e00 4100 7000 7000 2e00 6500 7800 6500)

------------------------------------------
------------------------------------------

pszCmdLine -- "ConApp.exe"
GetCommandLineW="ConApp.exe"(2200 4300 6f00 6e00 4100 7000 7000 2e00 6500 7800 6
500 2200)

CommandLineToArgvW:
argc=1
argv:
[#0]ConApp.exe(4300 6f00 6e00 4100 7000 7000 2e00 6500 7800 6500)

------------------------------------------
------------------------------------------

pszCmdLine -- ConApp.exe
GetCommandLineW=ConApp.exe(4300 6f00 6e00 4100 7000 7000 2e00 6500 7800 6500)

CommandLineToArgvW:
argc=1
argv:
[#0]ConApp.exe(4300 6f00 6e00 4100 7000 7000 2e00 6500 7800 6500)

------------------------------------------
------------------------------------------

pszCmdLine -- 123
GetCommandLineW= 123(0900 3100 3200 3300)

CommandLineToArgvW:
argc=2
argv:
[#0]()
[#1]123(3100 3200 3300)

------------------------------------------
------------------------------------------

pszCmdLine -- 123
GetCommandLineW= 123(2000 3100 3200 3300)

CommandLineToArgvW:
argc=2
argv:
[#0]()
[#1]123(3100 3200 3300)

------------------------------------------

需要注意的问题是，比较 CASE 5 和 CASE 6 ：

CASE 5 中， pszCmdLine 是 NULL ，这意味着没有参数传给 ConApp ，ConApp 调用 GetCommandLineW 获得的文件名被双引号扩住（Unicode值0x2200），但调用 CommandLineToArgvW 获得的 argv[0] ，对应的文件名是不包含双引号的。而且，如果不是通过CreateProcess启动 ConApp ，而是在控制台中直接启动 ConApp ，正如上面给出的结果， ConApp 调用 GetCommandLineW 是不包含双引号的。

在 CASE 6 中，pszCmdLine 为 "ConApp.exe" ，注意它是参数，不是程序名，完整的命令行类似于 ConApp "ConApp.exe" ，在参数中特意加了双引号，此时，ConApp 调用 GetCommandLineW 和 CommandLineToArgvW 后，获得的命令行参数与 CASE 5 中的内容完全一致，即：不为 ConApp 传递参数和为 ConApp 传递且仅传递一个参数 "ConApp" 时，两者在获取命令行方面没有差异！

因此，在写关于获取及解析命令行参数的代码时，需要考虑这种极为特殊的情况。事实上，似乎是没有办法来区分用户到底是用哪种方式调用了 ConApp 。也许，在控制台输入 ConApp "ConApp"的用户，本意是想调用ConApp，并传递一个参数 "ConApp" ，但如果在程序中只是简单解析成，该命令行不包含任何参数（因为无法区分 CASE 5 还是 CASE 6），并如传统做法那样显示一个关于程序的 Usage ，会造成用户的困惑。

因此，在开发程序时，如果程序允许用户传递参数给程序，则该程序应当设计成，参数含前导字符的形式：如 ConApp /"ConApp" 或 ConAPP -"ConApp"，这样的程序才是正确的设计方法。同时，也能避免 CASE 8 和 CASE 9 将前导空格符（Unicode值0x2200）和TAB制表符（Unicode值0x0900）当做参数进行解析的问题。

以上讨论的结果是基于这样一种情况：调用 CreateProcess 时，为第一个参数传递文件名，为第二个参数传递子进程需要使用的参数。根据 MSDN 文档解释，调用 CreateProcess 时，可以将第一个参数设为 NULL ，为第二个参数传递一个完整的命令行参数即可，即第二个参数的形式为 ConApp /123 。尽管这两种调用方式都能成功创建子进程，然而，对于要解析命令行的子进程而言，这两种不同的调用方式会直接影响到子进程对命令行参数的解析。原因是，子进程在不同的调用方式中被创建后，子进程调用 GetCommandLine 和 CommandLineToArgvW 所获得的内容是不一样的。以上已列出了其中一种调用方式，传递各种不同参数，子进程获得命令行参数的结果。

接下去，需要修改 AppCaller 的代码，对 CreateProcess 使用两种调用方式，观察它对子进程的影响。

新的 AppCaller代码为：

[cpp]view plaincopy 
   
 //C++ code  
 //Console project.  
 //(New)AppCaller.cpp  
   
 #include <stdio.h>  
 #include <tchar.h>  
 #include <Windows.h>  
   
 //函数前导声明。  
 void CallApp(LPCTSTR, LPTSTR);  
   
 int _tmain(int argc, _TCHAR* argv[])  
 {  
     //假设 WinApp.exe 和 CmdApp.exe 在当前目录中。  
     BOOL bRet = FALSE;  
       
     // 构建一组 ConApp 命令行测试用例。  
     // ----------------------------------------------------------------------------------  
     LPCTSTR pszConApp0 = _T("ConApp.exe"); //szCmdLine0 is NULL.  
     LPCTSTR pszConApp1 = _T("ConApp.exe"); TCHAR szConCmdLine1[] = { _T("/123") };  
     LPCTSTR pszConApp2 = _T("ConApp.exe"); TCHAR szConCmdLine2[] = { _T("/t/123") };  
     LPCTSTR pszConApp3 = _T("ConApp.exe"); TCHAR szConCmdLine3[] = { _T(" /123") };  
     LPCTSTR pszConApp4 = _T("ConApp.exe"); TCHAR szConCmdLine4[] = { _T("ConApp.exe") };  
     LPCTSTR pszConApp5 = _T("ConApp.exe"); TCHAR szConCmdLine5[] = { _T("/"ConApp.exe/"") };  
     // ----------------------------------------------------------------------------------  
     LPCTSTR pszConApp6 = NULL;             TCHAR szConCmdLine6[] = { _T("ConApp.exe") };  
     LPCTSTR pszConApp7 = NULL;             TCHAR szConCmdLine7[] = { _T("ConApp.exe /123") };  
     LPCTSTR pszConApp8 = NULL;             TCHAR szConCmdLine8[] = { _T("ConApp.exe /t/123") };  
     LPCTSTR pszConApp9 = NULL;             TCHAR szConCmdLine9[] = { _T("ConApp.exe  /123") };  
     LPCTSTR pszConApp10 = NULL;            TCHAR szConCmdLine10[] = { _T("ConApp.exe ConApp.exe") };  
     LPCTSTR pszConApp11 = NULL;            TCHAR szConCmdLine11[] = { _T("ConApp.exe /"ConApp.exe/"") };  
       
     LPCTSTR ppszConApps[] =  
     {  
         pszConApp0, pszConApp1, pszConApp2, pszConApp3,  
         pszConApp4, pszConApp5, pszConApp6, pszConApp7,  
         pszConApp8, pszConApp9, pszConApp10, pszConApp11  
     };  
     LPTSTR ppszConCmdLines[] =  
     {  
         NULL,           szConCmdLine1, szConCmdLine2, szConCmdLine3,  
         szConCmdLine4,  szConCmdLine5, szConCmdLine6, szConCmdLine7,  
         szConCmdLine8,  szConCmdLine9, szConCmdLine10, szConCmdLine11  
     };  
   
     // 构建一组 WinApp 命令行测试用例。  
     // ----------------------------------------------------------------------------------  
     LPCTSTR pszWinApp0 = _T("WinApp.exe"); //szCmdLine0 is NULL.  
     LPCTSTR pszWinApp1 = _T("WinApp.exe"); TCHAR szWinCmdLine1[] = { _T("/123") };  
     LPCTSTR pszWinApp2 = _T("WinApp.exe"); TCHAR szWinCmdLine2[] = { _T("/t/123") };  
     LPCTSTR pszWinApp3 = _T("WinApp.exe"); TCHAR szWinCmdLine3[] = { _T(" /123") };  
     LPCTSTR pszWinApp4 = _T("WinApp.exe"); TCHAR szWinCmdLine4[] = { _T("WinApp.exe") };  
     LPCTSTR pszWinApp5 = _T("WinApp.exe"); TCHAR szWinCmdLine5[] = { _T("/"WinApp.exe/"") };  
     // ----------------------------------------------------------------------------------  
     LPCTSTR pszWinApp6 = NULL;             TCHAR szWinCmdLine6[] = { _T("WinApp.exe") };  
     LPCTSTR pszWinApp7 = NULL;             TCHAR szWinCmdLine7[] = { _T("WinApp.exe /123") };  
     LPCTSTR pszWinApp8 = NULL;             TCHAR szWinCmdLine8[] = { _T("WinApp.exe /t/123") };  
     LPCTSTR pszWinApp9 = NULL;             TCHAR szWinCmdLine9[] = { _T("WinApp.exe  /123") };  
     LPCTSTR pszWinApp10 = NULL;            TCHAR szWinCmdLine10[] = { _T("WinApp.exe WinApp.exe") };  
     LPCTSTR pszWinApp11 = NULL;            TCHAR szWinCmdLine11[] = { _T("WinApp.exe /"WinApp.exe/"") };  
   
     LPCTSTR ppszWinApps[] =  
     {  
         pszWinApp0, pszWinApp1, pszWinApp2, pszWinApp3,  
         pszWinApp4, pszWinApp5, pszWinApp6, pszWinApp7,  
         pszWinApp8, pszWinApp9, pszWinApp10, pszWinApp11  
     };  
     LPTSTR ppszWinCmdLines[] =  
     {  
         NULL,           szWinCmdLine1, szWinCmdLine2, szWinCmdLine3,  
         szWinCmdLine4,  szWinCmdLine5, szWinCmdLine6, szWinCmdLine7,  
         szWinCmdLine8,  szWinCmdLine9, szWinCmdLine10, szWinCmdLine11  
     };  
   
     // 进行测试。  
     for (size_t i = 0; i < _countof(ppszConApps); i++)  
     {  
         CallApp(ppszConApps[i], ppszConCmdLines[i]);  
     }  
   
     /* 
     for (size_t i = 0; i < _countof(ppszWinApps); i++) 
     { 
         CallApp(ppszWinApps[i], ppszWinCmdLines[i]); 
     } 
     */  
     return 0;  
 }  
   
 void CallApp(LPCTSTR pszApp, LPTSTR pszCmdLine)  
 {  
     static int c = 0;  
     BOOL bRet = FALSE;  
     STARTUPINFO si = { sizeof(si) };  
     PROCESS_INFORMATION pi = { 0 };  
   
     _tprintf(_T("------------------------------------------/r/n/r/n"));  
     _tprintf(_T("<CASE %d>/r/n/r/n"), c);  
     c++;  
     _tprintf(_T("pszCmdLine -- %s/r/n"),  
         pszCmdLine == NULL ? _T("NULL") : pszCmdLine);  
   
     bRet = CreateProcess(pszApp, pszCmdLine, NULL, NULL, FALSE, 0,  
         NULL, NULL, &si, &pi);  
     if (bRet != FALSE)  
     {  
         if (WAIT_OBJECT_0 == WaitForSingleObject(pi.hProcess, INFINITE))  
         {  
             CloseHandle(pi.hThread);  
             CloseHandle(pi.hProcess);  
         }  
     }  
     _tprintf(_T("/r/n------------------------------------------/r/n"));  
 }  
   
 //end of (New)AppCaller.cpp  

输出结果为：

------------------------------------------

pszCmdLine -- NULL
GetCommandLineW="ConApp.exe"(2200 4300 6f00 6e00 4100 7000 7000 2e00 6500 7800 6
500 2200)

CommandLineToArgvW:
argc=1
argv:
[#0]ConApp.exe(4300 6f00 6e00 4100 7000 7000 2e00 6500 7800 6500)

------------------------------------------
------------------------------------------

pszCmdLine -- /123
GetCommandLineW=/123(2f00 3100 3200 3300)

CommandLineToArgvW:
argc=1
argv:
[#0]/123(2f00 3100 3200 3300)

------------------------------------------
------------------------------------------

pszCmdLine -- /123
GetCommandLineW= /123(0900 2f00 3100 3200 3300)

CommandLineToArgvW:
argc=2
argv:
[#0]()
[#1]/123(2f00 3100 3200 3300)

------------------------------------------
------------------------------------------

pszCmdLine -- /123
GetCommandLineW= /123(2000 2f00 3100 3200 3300)