Por que meu executável não executa quando clico nele?

3

Por que parece que não consigo abrir um arquivo executável criado em C ++ clicando duas vezes nele?

Eu tenho um arquivo que eu corri de um IDE e gostaria de saber se há uma maneira de definir esse arquivo para abrir o terminal quando clicar nele como um arquivo .exe no Windows fará.

Possibilidades:

  • Um código em C ++ que eu poderia adicionar ao meu código-fonte que permitirá isso.

  • Configure meu PC para abri-lo.

Estou tentando evitar toolkits quanto possível Eu recentemente compilado um aplicativo no Windows (Graças ao meu primo, ele tem um PC com windows)

E seria ótimo se pudesse fazer o mesmo pode ser feito no Windows no Linux, porque temos 2 pastas de lançamento.

E eu gostaria que este simples aplicativo baseado em Terminal pudesse funcionar sem ser um especialista.

Eu adicionei esta linha:

system ("gnome-terminal");

Ele abre no terminal, mas mostra o caminho do arquivo e não o programa atual alguma sugestão?

    
por Leandro 14.06.2011 / 10:16

5 respostas

5

Eu esperaria que você precisa definir o bit "executável" no arquivo que é gerado pelo compilador Linux C ++, não acho que isso seja feito por padrão por razões de segurança.

Simplesmente "cd" para o diretório em que o executável gerado está

chmod +x myexecutable

Substituindo "myexecutable" pelo nome da saída do seu compilador.

Em seguida, tente executá-lo com ./myexecutável

Eu acredito que isso também deve tornar o programa "executável" usando o clique do mouse, bem como pelo console.

Da mesma forma, se você precisar executar um "script" de comandos, tente o seguinte em um arquivo de script, salve-o como "myexe.sh" ou algo semelhante:

#!/bin/sh
command1
command2

Em seguida, use novamente

chmod +x myexe.sh 

para que você possa executar o script clicando nele.

    
por 14.06.2011 / 10:32
3

Acho que a raiz do seu problema é que você não entende realmente a distinção entre um emulador de terminal e um shell e como o Linux descobre como iniciar processos.

Primeiro, há o "Terminal Emulator", no ambiente baseado no Gnome, geralmente é o Gnome Terminal.

Depois, há o "Shell", no Linux, isso geralmente é bash, embora outras shells sejam possíveis.

Um "Shell" é executado dentro de um "Emulador de Terminal". Essa distinção vem da idade dos terminais físicos, onde um terminal físico é o hardware que recebe dados, grava texto em cores, etc., e o Shell é um software que processa o comando do usuário e gerencia outros processos com base nos comandos fornecidos.

Hoje em dia, temos uma tela de uso geral que pode exibir qualquer imagem, portanto não usamos mais um Terminal físico, mas temos "Emuladores de Terminal", um software que emula o trabalho de um terminal físico, e o Shell, que ainda é o mesmo shell velho que anteriormente (bem, os shells modernos se aproveitam de estar em um emulador de terminal de software, como não sendo limitado pela limitação física de um papel, etc, mas a divisão permanece).

Um "Shell" nem sempre é executado dentro de um emulador de terminal; há também o Graphical Shell, como o Nautilus (dica de sugestão, Nautilus é o nome de uma criatura marinha com um grande shell) ou o Windows Explorer (não deve ser confundido com o Internet Explorer).

Em um shell de linha de comando, por exemplo bash, e uma concha gráfica, e. Nautilus, um executável é marcado por ter seu execute bit definido.

Em um shell de linha de comando, você pode usar ls -l para exibir os bits de permissão de um arquivo, por exemplo, rwxrwxrwx significa que todos podem ler / escrever / executar o programa; rwxr-xr-- significa que o proprietário tem permissão total, as pessoas no grupo do arquivo podem ler e executar, mas não escrever, e outras pessoas só podem ler o arquivo. No Nautilus, você pode clicar com o botão direito do mouse em um arquivo > Propriedades > Aba de permissão. Na página de propriedades Permissão, você pode obter a permissão do arquivo, semelhante ao shell da linha de comando.

Um arquivo que tem seu conjunto de bits de execução é tratado como executável e pode ser executado fazendo-se ./filename (shell de linha de comando) ou clicando duas vezes (shell gráfico).

Por último, existem algumas outras sutilezas sobre como um shell executa um arquivo. Na maioria dos shell Linux, você pode "executar" um script escrito em python / perl / php / bash que não é um executável compilado. Como esses arquivos não são compilados nativamente, eles precisam de um intérprete (por exemplo, interpretador python) para ser executado. Ao contrário do shell do Windows (Explorer), que descobre o intérprete para invocar através da extensão do arquivo; O shells do Linux descobre o interpretador correto olhando a linha "hashbang" que se parece com isso

#!/usr/bin/python

quando o bit de execução de um arquivo é definido e o arquivo tem essa linha de hashbang, o shell invocará o interpretador / usr / bin / python com o arquivo atual como argumento.

O Nautilus também pode reconhecer quando um programa é um aplicativo de linha de comando e oferece a você a execução do aplicativo dentro de um Terminal. Quando você clica duas vezes em um script executável, o Nautilus pergunta se você deseja executá-lo em um Terminal, executar sem Terminal ou editar o arquivo em um Editor de Texto.

    
por 15.06.2011 / 19:53
1

crie um script para executá-lo dentro de um xterm ou algo assim. Verifique se o seu programa interage com o usuário antes de terminar. (Funciona quando você o executa dentro de um xterm? Ele funciona quando você o executa dentro de uma shell típica do bash?)

xterm -e command [args1 args2]
    
por 14.06.2011 / 10:55
1

Em palavras simples:

  1. Seu arquivo binário executável gerado pode não ter o bit executável . Sistemas baseados em Unix usam esse recurso por motivos de segurança. Defina-o com: chmod +x yourbinary .
  2. O binário pode realmente ser executado, mas como o linux não roda um emulador de terminal (que é um pouco como a interface entre você e o stdout ) para executá-lo por padrão, você está não é capaz de ver nada.

Para o último caso, você pode:

  1. Crie um script que execute seu executável por meio de um emulador de terminal, como:

    exo-open --launch TerminalEmulator -e 'yourbinary'
    

    Para executá-lo no seu terminal padrão (se você tiver o comando exo ), ou use explicitamente um.

  2. Crie um arquivo desktop para executá-lo.

  3. Dê a eles uma extensão personalizada e especial como .exec e configure-os para executar usando o comando na sugestão 1. (ou similar) nas configurações de extensão de arquivo (se o sistema operacional suportar esse recurso).

por 12.07.2014 / 04:21
0

Se você compilou no windows e é um exe, não vejo razão para que um terminal não abra no windows quando você clica duas vezes no executável. Tem certeza de que o código não é desligado (segfault etc.)? Seria uma boa ideia certificar-se de que o programa não falha.

    
por 14.06.2011 / 10:22

Tags