Como chamar um programa externo com parâmetros?

Question

Gostaria de chamar um programa de janelas dentro do meu código com parâmetros determinados dentro do próprio código.

Eu não estou olhando para chamar uma função fora ou método, mas um .exe real ou em lote / arquivo de script dentro do ambiente de WinXP.

C ou C ++ seria o idioma preferido, mas se este é mais facilmente feito em qualquer outra língua deixe-me saber (ASM, C #, Python, etc).

Answer 1

Quando você chamar CreateProcess (), system (), etc., certifique-se de dupla citar suas cordas de nome de arquivo (incluindo o nome do arquivo programa de comando) no caso do seu nome do arquivo (s) e / ou o caminho totalmente qualificado têm espaços caso contrário, as partes do caminho nome do arquivo será analisado pelo interpretador de comandos como argumentos separados.

system("\"d:some path\\program.exe\" \"d:\\other path\\file name.ext\"");

Para o Windows é recomendado o uso CreateProcess (). Ele tem configuração mais confusa, mas você tem mais controle sobre a forma como é lançado os processos (como descrito por Greg Hewgill). Para rápido e sujo você também pode usar WinExec (). (System () é portátil para UNIX).

Ao lançar arquivos em lote você pode precisar de lançamento com cmd.exe (ou command.com).

WinExec("cmd \"d:some path\\program.bat\" \"d:\\other path\\file name.ext\"",SW_SHOW_MINIMIZED);

(ou SW_SHOW_NORMAL se você quiser a janela de comando exibido).

Windows deve encontrar command.com ou cmd.exe no caminho do sistema assim em não precisa ser totalmente qualificado, mas se você quer ter certeza de que você pode compor o nome do arquivo totalmente qualificado usando CSIDL_SYSTEM (não simplesmente usar C: \ Windows \ system32 \ cmd.exe).

Answer 2

C ++ exemplo:

char temp[512];
sprintf(temp, "command -%s -%s", parameter1, parameter2);
system((char *)temp);

C # exemplo:

    private static void RunCommandExample()
    {
        // Don't forget using System.Diagnostics
        Process myProcess = new Process();

        try
        {
            myProcess.StartInfo.FileName = "executabletorun.exe";

            //Do not receive an event when the process exits.
            myProcess.EnableRaisingEvents = false;

            // Parameters
            myProcess.StartInfo.Arguments = "/user testuser /otherparam ok";

            // Modify the following to hide / show the window
            myProcess.StartInfo.CreateNoWindow = false;
            myProcess.StartInfo.UseShellExecute = true;
            myProcess.StartInfo.WindowStyle = ProcessWindowStyle.Maximized;

            myProcess.Start();

        }
        catch (Exception e)
        {
            // Handle error here
        }
    }

Answer 3

Eu acho que você está procurando o CreateProcess função da API do Windows. Há realmente uma família de chamadas relacionadas, mas isso vai ajudar a começar. É bastante fácil.

Answer 4

Uma das maneiras mais simples de fazer isso é usar a função system() biblioteca de tempo de execução. Leva uma única string como um parâmetro (muito menos parâmetros do que CreateProcess!) E executa-lo como se fosse digitado na linha de comando. system() também espera automaticamente para o processo de acabamento antes de retornar.

Existem também limitações:

• você tem menos controle sobre o stdin e stdout do processo lançado
• você não pode fazer mais nada enquanto o outro processo está em execução (como decidir para matá-lo)
• você não pode obter um identificador para o outro processo, a fim de consultá-lo de qualquer maneira

A biblioteca de execução também fornece uma família de funções exec* (execl, execlp, execle, execv, execvp, mais ou menos), que são derivadas a partir do Unix herança e oferecem um maior controlo sobre o processo.

No nível mais baixo, em Win32 todos os processos são lançados pela função CreateProcess, que lhe dá o máximo de flexibilidade.

Answer 5

simples c ++ exemplo (encontrado depois de pesquisar alguns sites)

#include <bits/stdc++.h>
#include <cassert>
#include <exception>
#include <iostream>

int main (const int argc, const char **argv) {
try {
    assert (argc == 2);
    const std::string filename = (const std::string) argv [1];
    const std::string begin = "g++-7 " + filename;
    const std::string end = " -Wall -Werror -Wfatal-errors -O3 -std=c++14 -o a.elf -L/usr/lib/x86_64-linux-gnu";
    const std::string command = begin + end;
    std::cout << "Compiling file using " << command << '\n';

    assert (std::system ((const char *) command.c_str ()) == 0);
    std::cout << "Running file a.elf" << '\n';
    assert (std::system ((const char *) "./a.elf") == 0);

    return 0; }
catch (std::exception const& e) { std::cerr << e.what () << '\n'; std::terminate (); }
catch (...) { std::cerr << "Found an unknown exception." << '\n'; std::terminate (); } }