c++ - 如果其他进程被杀死，则杀死我的进程

Question

我想编写一个代码来启动一个进程并在另一个进程被终止时终止我的进程。

你知道好的解决方案吗？

我当前的代码:

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);
}

Answer 1

您可以做的是让父进程等待子进程退出，然后关闭父进程。

Win API 遗留函数，如 ShellExecute 不返回进程标识符，父进程可以使用它来等待子进程退出。所以你必须使用 core 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 process ，代码将如下所示:

// 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页