我希望编写一段代码，可以在启动另一个进程时也同时启动我的进程，并能在另一个进程结束时结束我的进程。
您知道有什么好的解决方案吗？
以下是我目前的代码：
std::string exeFile{ ExePath() + "\\DTMlibrary.exe" };
if (is_file_exist(exeFile.c_str()))
{
ShellExecute(NULL, "open", exeFile.c_str(), NULL, NULL, SW_SHOWDEFAULT);
EndDialog(0);
}
else
{
MessageBox("Setup DTMlibrary.exe not found ", "System Information", MB_ICONINFORMATION);
EndDialog(0);
}
ShellExecute 这样的 Win API 遗留函数不返回进程标识符，因此必须直接使用核心系统调用 CreateProcess。然后，您可以使父进程等待子进程退出/终止。您可以使用 WaitForSingleObject Win API 同步函数来实现此操作。以下示例演示了所述技术：/*
This program is free software: you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program. If not, see <http://www.gnu.org/licenses/>.
*/
#include <cstdlib>
#include <cstdio>
#include <cstring>
#ifdef _WIN32
# define HAS_BSOD
# include <windows.h>
#endif // _WIN32
#if defined(unix) \
|| defined(__unix) \
|| defined(_XOPEN_SOURCE) \
|| defined(_POSIX_SOURCE)
# include <sys/types.h>
# include <sys/wait.h>
#endif // defined
#if defined(__GNUC__) && !defined(_alloca)
# define _alloca(__s) __builtin_alloca( (__s) )
#endif // __GNUC__
/// execute an external command and suspend current thread until this command exit
int execute_and_wait(const char* command, const char *args);
#ifdef HAS_BSOD
int execute_and_wait(const char* command, const char *args)
{
::STARTUPINFOW cif;
std::memset(&cif, 0, sizeof(cif));
cif.cb = sizeof(cif);
::PROCESS_INFORMATION pi;
std::memset( &pi, 0, sizeof(pi) );
// MS API expecting single line path and program arguments
const std::size_t len = std::strlen(command) + std::strlen(args) + 2;
char* cmdline = static_cast<char*>( _alloca( len ) );
std::memset(cmdline, 0, len);
std::strcat(cmdline, command);
std::strcat(cmdline, " ");
std::strcat(cmdline, args);
// We need to convert our command line into UTF-16LE, since MS API like
// this UNICODE representation, and don't like UTF-8
// furthermore may crash a whole application or even show blue screen of doom when UTF-8, depending on something we don't know
::UINT acp = ::GetACP(); // obtain current ISO like code-page i.e. CP1252
const std::size_t wlen = ::MultiByteToWideChar(acp, 0, cmdline, len, nullptr, 0) + 1;
wchar_t* wcmdline = static_cast<wchar_t*>( _alloca(wlen) );
std::memset(wcmdline, 0, wlen );
::MultiByteToWideChar(acp, 0, cmdline, len, wcmdline , wlen );
if ( ::CreateProcessW(
NULL, /* Say hello to MS DOS and OS/2 and left NULL */
wcmdline, /* command and arguments */
NULL, /* Some security structure, with void* pointer on another security structure, needs to be NULL to be inherited from parent */
NULL, /* Some security structure, with void* pointer on another security structure, needs to be NULL to be inherited from parent */
FALSE, /*
copy all opened files and sockets if TRUE,
almost fork if
typedef int BOOL;
#define TRUE 1
#define FALSE 0
*/
NORMAL_PRIORITY_CLASS, /* 20 possible flags */
NULL, /* add ability to add a few additional environment variables, or change existing like PATH (actually nice feature) */
NULL, /* execution directory, nice feature but needs to be NULL to be inherited from parent */
&cif,
&pi)
)
{
::WaitForSingleObject( pi.hProcess, INFINITE );
int ret = EXIT_FAILURE;
::GetExitCodeProcess(pi.hProcess,LPDWORD(&ret));
// Close process and thread handles.
::CloseHandle( pi.hProcess );
::CloseHandle( pi.hThread );
return ret;
}
return EXIT_FAILURE;
}
#else // no Blue Screen of Doom (Some UNIX variant like Linux/Mac/FreeBSD etc)
int execute_and_wait(const char* command, const char *args)
{
::pid_t child_pid = ::fork();
if(child_pid < 0)
return EXIT_FAILURE;
if(0 == child_pid) {
// UTF-8 in most cases, if it's not - we don't expect a crash or kernel panic
::execl(command, args);
// if we here something went wrong
::exit(EXIT_FAILURE);
}
int ret;
::waitpid(child_pid, &ret, 0);
return ret;
}
#endif // HAS_BSOD
#ifdef HAS_BSOD
static const char *SYS_EDITOR = "notepad.exe";
#else
static const char *SYS_EDITOR = "less";
#endif // HAS_BSOD
int main(int argc, const char** argv)
{
std::printf("About to fork with: %s \n", __FILE__ );
int exit_code = execute_and_wait(SYS_EDITOR, __FILE__);
std::printf("This is it, exit code :%d \n", exit_code);
return 0;
}
如果您能使用Boost处理过程, 代码将如下所示:
// This example code is under public domain
#include <iostream>
#include <boost/process.hpp>
#ifdef _WIN32
static const char *SYS_EDITOR = "notepad.exe ";
#else
static const char *SYS_EDITOR = "vi ";
#endif
int main()
{
std::string path(SYS_EDITOR);
path.append( __FILE__ );
std::cout << "About to fork with command : " << path << std::endl;
std::error_code ec;
boost::process::child c(path);
c.wait(ec);
return c.exit_code();
}
我的建议是最好不要阅读这个MSDN页面
CreateProcess 调用是错误的。同时传递 lpApplicationName 和 lpCommandLine 是为特定情况保留的，即应用程序不遵循将应用程序名称作为第一个命令行参数传递的约定。这个调用不会做你希望它做的事情。 - IInspectable SHELLEXECUTEINFO ShExecInfo = { 0 };
ShExecInfo.cbSize = sizeof(SHELLEXECUTEINFO);
ShExecInfo.fMask = SEE_MASK_NOCLOSEPROCESS;
ShExecInfo.hwnd = NULL;
ShExecInfo.lpVerb = NULL;
ShExecInfo.lpFile = exeFile.c_str();
ShExecInfo.lpParameters = "";
ShExecInfo.lpDirectory = NULL;
ShExecInfo.nShow = SW_SHOW;
ShExecInfo.hInstApp = NULL;
ShellExecuteEx(&ShExecInfo);
ShowWindow(SW_HIDE);
WaitForSingleObject(ShExecInfo.hProcess, INFINITE);
EndDialog(0);