como capturar o exit\_code e stderr do comando que é executado em c ++?
<p>estou escrevendo um programa c ++ que executa e gera (em tempo real) um script shell, makefile ou apenas outro programa. no entanto, eu gostaria que meu programa retornasse de maneira diferente quando houver erros ou nenhum erro.</p><pre><code>#include "execxi.h" using namespace std; int execxi::run(string command) { file *in; char buff[512]; // is this the check for command execution exited with not 0? if(!(in = popen(command.c\_str(), "r"))){ // i want to return the exit code and error message too if any return 1; } // this part echoes the output of the command that's executed while(fgets(buff, sizeof(buff), in)!=null){ cout &lt;&lt; buff; } pclose(in); return 0; } </code></pre><p>é o que eu tenho até agora.</p><p>digamos que esse script executou <code>make</code> para criar um programa e deu um erro como esse</p><pre><code>on\_target\_webkit\_version out/release/obj/gen/webkit\_version.h traceback (most recent call last): file "../build/webkit\_version.py", line 107, in &lt;module&gt; sys.exit(main()) file "../build/webkit\_version.py", line 103, in main return emitversionheader(*sys.argv[1:]) file "../build/webkit\_version.py", line 86, in emitversionheader webkit\_revision = getwebkitrevision(webkit\_dir, version\_file) file "../build/webkit\_version.py", line 60, in getwebkitrevision version\_info = lastchange.fetchversioninfo( attributeerror: 'module' object has no attribute 'fetchversioninfo' make: *** [out/release/obj/gen/webkit\_version.h] error 1 </code></pre><ul> <li> <p>é possível que eu saiba que isso ocorreu com erro?</p> <ul> <li> <p>isso sai com o código <code>else than 0</code> já que é um erro?</p> </li> <li> <p>essa última parte é produzida em <code>stderr</code>?</p> </li> </ul> </li> </ul><p>considerando que <code>make</code> saiu com o código não <code>0</code>, digamos <code>1</code>, e ele sai em <code>stderr</code>, não é possível capturar esses códigos de saída e mensagem de erro no final?</p><p>como capturar o código de saída e <code>stderr</code> após a saída dos resultados do programa e retornar o <code>exit code</code>/<code>stderr</code> na função?</p>
<p>se você estiver interessado no código de erro, é uma maneira mais portátil de obtê-lo, em vez de dividir por 256:</p><pre><code>printf("exit code: %i\n", wexitstatus(pclose(fp))); </code></pre><p>no entanto, <code>popen</code> é uma maneira, então você está criando outras soluções alternativas pelo estilo de redirecionamento usual no shell ou segue este código não testado para fazer o certo:</p><pre><code>#include &lt;unistd.h&gt; #include &lt;stdio.h&gt; /* since pipes are unidirectional, we need two pipes. one for data to flow from parent's stdout to child's stdin and the other for child's stdout to flow to parent's stdin */ #define num\_pipes 2 #define parent\_write\_pipe 0 #define parent\_read\_pipe 1 int pipes[num\_pipes][2]; /* always in a pipe[], pipe[0] is for read and pipe[1] is for write */ #define read\_fd 0 #define write\_fd 1 #define parent\_read\_fd ( pipes[parent\_read\_pipe][read\_fd] ) #define parent\_write\_fd ( pipes[parent\_write\_pipe][write\_fd] ) #define child\_read\_fd ( pipes[parent\_write\_pipe][read\_fd] ) #define child\_write\_fd ( pipes[parent\_read\_pipe][write\_fd] ) void main() { int outfd[2]; int infd[2]; // pipes for parent to write and read pipe(pipes[parent\_read\_pipe]); pipe(pipes[parent\_write\_pipe]); if(!fork()) { char *argv[]={ "/usr/bin/bc", "-q", 0}; dup2(child\_read\_fd, stdin\_fileno); dup2(child\_write\_fd, stdout\_fileno); /* close fds not required by child. also, we don't want the exec'ed program to know these existed */ close(child\_read\_fd); close(child\_write\_fd); close(parent\_read\_fd); close(parent\_write\_fd); execv(argv[0], argv); } else { char buffer[100]; int count; /* close fds not required by parent */ close(child\_read\_fd); close(child\_write\_fd); // write to child’s stdin write(parent\_write\_fd, "2^32\n", 5); // read from child’s stdout count = read(parent\_read\_fd, buffer, sizeof(buffer)-1); if (count &gt;= 0) { buffer[count] = 0; printf("%s", buffer); } else { printf("io error\n"); } } } </code></pre><p>o código é daqui:</p><p> <a href="http://jineshkj.wordpress.com/2006/12/22/how-to-capture-stdin-stdout-and-stderr-of-child-program/">http://jineshkj.wordpress.com/2006/12/22/how-to-capture-stdin-stdout-and-stderr-of-child-program/</a> </p>
<p>eduardo, a sua lógica parece correta. você está recebendo erro de compilação? talvez ele não esteja compilando pois este método lança uma exceção, então seria necessário envolver um trecho do seu código em um <code>try/catch</code>.</p>
<p>veja o exemplo da documentação oficial neste link: <a href="https://msdn.microsoft.com/en-us/library/zh1hkw6k%28v&#61;vs.110%29.aspx" rel="nofollow">https://msdn.microsoft.com/en-us/library/zh1hkw6k(v&#61;vs.110).aspx</a></p> <p>oi thiago tudo bem?</p>
<p>você tem que usar o laço for para fazer o código. veja como eu fiz e tente fazer depois sozinho.</p>
<pre class="prettyprint"><code>#include &lt;stdio.h&gt;

int main()
{ 

 int a;
 printf(&#34;entre um número inteiro positivo\n&#34;);
 scanf(&#34;%d&#34;, &amp;a);

 int b;
 printf(&#34;entre um outro número inteiro positivo\n&#34;);
 scanf(&#34;%d&#34;, &amp;b);

 int soma&#61;0;
 int contador;
 for(contador &#61; a&#43;1; contador &lt; b; contador&#43;&#43;)
 {
 soma&#61;soma&#43;contador;
 }


 printf(&#34;a soma é %d\n&#34;, soma);
 return 0;
}
</code></pre><p>espero ter ajudado!!!</p> <p>tente isto:</p><pre><code>$str = preg\_replace\_callback('/\\\\u([0-9a-fa-f]{4})/', function ($match) { return mb\_convert\_encoding(pack('h*', $match[1]), 'utf-8', 'ucs-2be'); }, $str); </code></pre><p>caso seja baseado em utf-16, c/c++/java/json-style:</p><pre><code>$str = preg\_replace\_callback('/\\\\u([0-9a-fa-f]{4})/', function ($match) { return mb\_convert\_encoding(pack('h*', $match[1]), 'utf-8', 'utf-16be'); }, $str); </code></pre> <p>aqui está uma versão que funciona em c/c++ que não depende de tamanhos inteiros ou tem o problema de estouro (ou seja, x * y&gt; = 0 não funciona)</p><pre><code>bool samesign(int x, int y) { return (x &gt;= 0) ^ (y &lt; 0); } </code></pre><p>claro, você pode dar uma olhada e criar um modelo:</p><pre><code>template &lt;typename valuetype&gt; bool samesign(typename valuetype x, typename valuetype y) { return (x &gt;= 0) ^ (y &lt; 0); } </code></pre><p>nota: como estamos usando exclusive ou, queremos que o lhs e o rhs sejam diferentes quando os sinais forem os mesmos, portanto, a verificação diferente será zero.</p> <p>vamos primeiro ver o que acontece se um programa for iniciado a partir de um shell interativo (conectado a um terminal) sem <code>&amp;</code> (e sem nenhum redirecionamento). então, vamos supor que você acabou de digitar <code>foo</code>:</p><ul> <li>o processo executando <code>foo</code> é criado.</li> <li>o processo herda stdin, stdout e stderr do shell. portanto, também está conectado ao mesmo terminal.</li> <li>se o shell receber um <code>sighup</code>, ele também envia um <code>sighup</code> para o processo (o que normalmente causa o término do processo).</li> <li>caso contrário, o shell aguarda (está bloqueado) até o processo terminar.</li> </ul><p>agora, vejamos o que acontece se você colocar o processo em segundo plano, ou seja, digite <code>foo &amp;</code>:</p><ul> <li>o processo executando <code>foo</code> é criado.</li> <li>o processo herda stdout/stderr do shell (portanto, ele ainda grava no terminal).</li> <li>o processo em princípio também herda stdin, mas assim que tenta ler a partir de stdin, ele é interrompido.</li> <li>ele é colocado na lista de trabalhos em segundo plano que a shell gerencia, o que significa especialmente: <ul> <li>ele está listado com <code>jobs</code> e pode ser acessado usando <code>%n</code> (onde <code>n</code> é o número do trabalho).</li> <li>ele pode ser transformado em um trabalho em primeiro plano usando <code>fg</code>, caso em que continua como se você não tivesse usado <code>&amp;</code> (e se foi interrompido devido à tentativa de leitura da entrada padrão, agora pode prosseguir com a leitura do terminal).</li> <li>se o shell recebeu um <code>sighup</code>, ele também envia um <code>sighup</code> para o processo. dependendo do shell e possivelmente das opções definidas para o shell, ao finalizar o shell, ele também enviará um <code>sighup</code> para o processo.</li> </ul> </li> </ul><p>agora <code>disown</code> remove o trabalho da lista de trabalhos do shell, para que todos os subpontos acima não se apliquem mais (incluindo o processo que está sendo enviado um <code>sighup</code> pelo shell). no entanto, observe que <em> ainda </em> está conectado ao terminal, portanto, se o terminal for destruído (o que pode acontecer se for um pty, como os criados por <code>xterm</code> ou <code>ssh</code>, e o programa de controle é finalizado, fechando o xterm ou finalizando a <a href="http://en.wikipedia.org/wiki/secure\_shell"> ssh </a> conexão), o programa falhará assim que tentar ler da entrada padrão ou gravar na saída padrão.</p><p>o que <code>nohup</code> faz, por outro lado, é separar efetivamente o processo do terminal:</p><ul> <li>ele fecha a entrada padrão (o programa <em> não </em> consegue ler qualquer entrada, mesmo que seja executada em primeiro plano. não é interrompido, mas será receba um código de erro ou <code>eof</code>).</li> <li>ele redireciona a saída padrão e o erro padrão para o arquivo <code>nohup.out</code>, para que o programa não falhe ao gravar na saída padrão se o terminal falhar, portanto, o que o processo gravar não será perdido.</li> <li>impede que o processo receba um <code>sighup</code> (portanto, o nome).</li> </ul><p>observe que <code>nohup</code> <em> não remove </em> o processo do controle de tarefas do shell e também não o coloca em segundo plano (mas desde que um primeiro plano <code>nohup</code> trabalho é mais ou menos inútil, você geralmente o coloca em segundo plano usando <code>&amp;</code>). por exemplo, diferentemente de <code>disown</code>, o shell ainda informa quando o trabalho nohup foi concluído (a menos que o shell seja encerrado antes, é claro).</p><p>então, para resumir:</p><ul> <li><code>&amp;</code> coloca o trabalho em segundo plano, ou seja, impede a tentativa de ler as entradas e faz com que o shell não espere sua conclusão.</li> <li><code>disown</code> remove o processo do controle de trabalho do shell, mas ainda o deixa conectado ao terminal. um dos resultados é que o shell não enviará um <code>sighup</code>. obviamente, ele só pode ser aplicado a trabalhos em segundo plano, porque você não pode inseri-lo quando um trabalho em primeiro plano está em execução.</li> <li><code>nohup</code> desconecta o processo do terminal, redireciona sua saída para <code>nohup.out</code> e o protege de <code>sighup</code>. um dos efeitos (o de nomeação) é que o processo não receberá nenhum <code>sighup</code> enviado. é completamente independente do controle do trabalho e pode, em princípio, ser usado também para trabalhos em primeiro plano (embora isso não seja muito útil).</li> </ul> <p>para reconstruir o cache de comandos executáveis, use <code>rehash</code> ou <code>hash -rf</code>.</p><p>verifique se você não desmarcou o <code>hash\_list\_all</code> opção (causa menos acessos ao disco, mas faz com que o cache seja atualizado com menos frequência).</p><p>se não quiser digitar um comando, você pode dizer ao zsh para não confiar no cache ao concluir, colocando a seguinte linha no seu <code>~/.zshrc</code>¹:</p><pre><code>zstyle ":completion:*:commands" rehash 1 </code></pre><p>existe um custo de desempenho, mas hoje é insignificante em uma configuração típica de área de trabalho. (não é se você tiver <code>$path</code> no nfs ou em um sistema sem memória ram.)</p><p>o comando <code>zstyle</code> está documentado na página do manual <code>zshmodule</code>. os valores dos estilos estão documentados nas páginas de manual <code>zshcompsys</code> e <code>zshcompwid</code>, ou você pode ler a fonte (aqui, das <code>\_command\_names</code> função). se você quiser alguma documentação legível ... se você encontrar alguma, me avise!</p><p>¹ <sub>requer zsh≥4.3.3, obrigado <a href="https://unix.stackexchange.com/users/1107/chris-johnsen">chris johnsen</a> </sub></p> <p>olá rayanne, tudo bom?
o ideal que você tenha o costume de salvar a cada momento de código que você termina de fazer.
salvar e debugar.
o vscoder ele tem a opção de salvar automaticamente( mas eu recomendo você criar o habito).</p> Você já tentou o menu Preferências JDE, guia Simulator, depuração sub-seção? Há uma opção lá rotulado como "Não parar a execução quando uma exceção é capturado por catch (Throwable)". Talvez isso iria fazê-lo? (Isso pressupõe que você lançar o simulador do JDE) <p>adicione o seguinte a ~/.bashrc</p><pre><code># avoid duplicates histcontrol=ignoredups:erasedups # when the shell exits, append to the history file instead of overwriting it shopt -s histappend # after each command, append to the history file and reread it prompt\_command="${prompt\_command:+$prompt\_command$'\n'}history -a; history -c; history -r" </code></pre> no começo do arquivo .patch tem o caminho esperado do arquivo que será alterado. nesse caso é esperado que vc esteja na raiz de onde extraiu o kernel. daí é mandar aplicar executar o comando informando o arquivo .patch.

por exemplo, vc extraiu o código fonte em /home/thiago/downloads/linux-5.10.9

…