Como manter a janela do console aberta no Visual C ++?

Estou começando no Visual C ++ e gostaria de saber como manter a janela do console.

Por exemplo, este seria um aplicativo típico "olá mundo":

int _tmain(int argc, _TCHAR* argv[])
{
    cout << "Hello World";
    return 0;
}

Qual é a linha que estou perdendo?

Inicie o projeto em Ctrl+F5vez de apenasF5 .

A janela do console agora ficará aberta com o Press any key to continue . . . mensagem após a saída do programa.

Observe que isso requer a Console (/SUBSYSTEM:CONSOLE)opção vinculador, que você pode ativar da seguinte maneira:

1. Abra seu projeto e acesse o Solution Explorer. Se você está acompanhando comigo na K&R, sua "Solução" será 'olá' com 1 projeto abaixo, também 'olá' em negrito.
2. Clique com o botão direito do mouse em 'olá' (ou qualquer que seja o nome do seu projeto.)
3. Escolha "Propriedades" no menu de contexto.
4. Escolha Propriedades de configuração> Vinculador> Sistema.
5. Para a propriedade "Subsistema" no painel direito, clique na caixa suspensa na coluna direita.
6. Escolha "Console (/ SUBSYSTEM: CONSOLE)"
7. Clique em Aplicar, aguarde o término do processo e clique em OK. (Se "Aplicar" estiver acinzentado, escolha outra opção de subsistema, clique em Aplicar e volte e aplique a opção de console. Minha experiência é que o OK por si só não funcionará.)

CTRL-F5 e as dicas do subsistema trabalham juntas; eles não são opções separadas.

(Cortesia de DJMorreTX de http://social.msdn.microsoft.com/Forums/en-US/vcprerelease/thread/21073093-516c-49d2-81c7-d960f6dc2ac6 )

A maneira padrão é cin.get()antes da sua declaração de retorno.

int _tmain(int argc, _TCHAR* argv[])
{
    cout << "Hello World";
    cin.get();
    return 0;
}

Coloque um ponto de interrupção na returnlinha.

Você está executando no depurador, certo?

Outra opção é usar

#include <process.h>
system("pause");

Embora isso não seja muito portátil, pois funcionará apenas no Windows, mas imprimirá automaticamente

Pressione qualquer tecla para continuar...

Para projetos de makefile, a solução aceita falha, devido a um erro no Visual Studio (que está presente pelo menos até a versão 2012 - ainda não testei 2013). Este bug é detalhado aqui .

Para que o console seja pausado após o término do programa em um projeto de makefile, execute estas etapas (isso pode ser diferente para versões diferentes de 2010 - 2012):

1) Passe /SUBSYSTEM:CONSOLEpara o vinculador. - EDIT : veja abaixo.

2) Abra seu arquivo de projeto (.vcxproj) em um editor de texto.

3) Dentro da <project>marca raiz , insira o seguinte:

<ItemDefinitionGroup>
  <Link>
    <SubSystem>Console</SubSystem>
  </Link>
</ItemDefinitionGroup>

4) Recarregue o projeto na sua solução.

5) Execute o programa sem depuração (CTRL + F5).

EDITAR:

Conforme meu comentário abaixo, definir a opção de vinculador /SUBSYSTEM:CONSOLEé realmente irrelevante para projetos de makefile (e nem sempre é possível, se você estiver usando um compilador que não seja o MSVC). O que importa é que a configuração seja adicionada ao arquivo .vcxproj, conforme a etapa 3 acima.

Você pode usar cin.get();ou cin.ignore();imediatamente antes da sua declaração de retorno para evitar que a janela do console se feche.

basta colocar um ponto de interrupção no último colchete do main.

    int main () {
       //...your code...
       return 0;
    } //<- breakpoint here

funciona para mim, não há necessidade de executar sem depuração. Ele também executa destruidores antes de atingir o ponto de interrupção, para que você possa verificar se há alguma mensagem impressa nesses destruidores.

Basta adicionar um ponto de interrupção ao colchete de fechamento do seu _tmainmétodo. Essa é a maneira mais fácil, e você não precisa adicionar código para depurar.

Coloque um ponto de interrupção na chave final de main(). Ele disparará mesmo com várias returninstruções. A única desvantagem é que uma ligação para exit()não será atendida.

Se você não estiver depurando, siga os conselhos da resposta de Zoidberg e inicie seu programa com Ctrl+ em F5vez de apenas F5.

Meus 2 centavos:

Opção 1: adicione um ponto de interrupção no final de main()

Opção 2: adicione esse código, logo antes do return 0;:

std::cout << "Press ENTER to continue..."; //So the User knows what to do
std::cin.ignore(std::numeric_limits<std::streamsize>::max(), '\n');

Você precisa incluir <iomanip>parastd::numeric_limits

basta adicionar system ("pause") no final do código antes de retornar 0 como este

#include <stdlib.h>

int main()
{
    //some code goes here
    system("pause")
    return 0;
}

int main()
{
    //...
    getchar();
    return 0;
}

cin.get(), Ou system("PAUSE"). Eu não ouvi você pode usarreturn(0);

Incluo #include <conio.h>e depois adiciono getch();logo antes da return 0;linha. Foi o que aprendi na escola de qualquer maneira. Os métodos mencionados acima aqui são bem diferentes, eu vejo.

Teve o mesmo problema. Estou usando _getch()pouco antes da declaração de retorno. Funciona.

(Algumas opções podem ser chamadas por nomes diferentes. Eu não uso a versão em inglês)

Eu tive o mesmo problema, quando criei projetos com a opção "projeto vazio", crie projeto como "aplicativo de console Win32" em vez de "projeto vazio". Na caixa de diálogo que aparece agora, você pressiona "continuar" e depois pode marcar a opção "projeto vazio" e pressionar confirmar. Depois disso, CTRL + F5 abrirá um console que não fecha automaticamente.

Eu tive o mesmo problema; No meu aplicativo, há vários pontos exit () e não havia como saber exatamente onde ele sai; então, descobri isso:

atexit(system("pause"));

ou

atexit(cin.get());

Dessa forma, ele irá parar, não importa onde saímos no programa.

Outra opção:

#ifdef _WIN32
#define MAINRET system("pause");return 0
#else
#define MAINRET return 0
#endif

Principalmente:

int main(int argc, char* argv[]) {
    MAINRET;
}

Na verdade, a solução real é a seleção do próprio modelo de projeto. É necessário selecionar o aplicativo de console do Win32 no VS antigo ou preencher primeiro o nome do projeto, clicar duas vezes no assistente da área de trabalho do Windows e selecionar o aplicativo de console do Win32. Em seguida, selecione o projeto vazio neste momento. Isso permite o que o questionador original realmente queria sem adicionar um ponto de parada extra e manter o código. Eu também passei por esse problema. A resposta também está no site do MSDN.

Aqui está uma maneira de manter a janela de comando aberta, independentemente de como a execução é interrompida sem modificar nenhum código:

No Visual Studio, abra Páginas de propriedades do projeto -> Depuração .

Para Comando , insira$(ComSpec)

Para argumentos de comando , insira/k $(TargetPath) . Anexe todos os argumentos ao seu próprio aplicativo.

Agora, F5 ou Ctrl-F5 executa o Windows / System32 / cmd.exe em uma nova janela e / k garante que o prompt de comando permaneça aberto após a conclusão da execução.

A desvantagem é que a execução não para em pontos de interrupção.

Como alguns já apontaram, a solução Zoidbergs não anexa o depurador, que é algo que você geralmente não deseja.

A melhor opção imo é configurar seu VS de acordo (a partir do VS 2017), acessando Ferramentas> Opções> Depuração> Geral. Lá, desmarque "Feche automaticamente o console quando a depuração parar" (na parte inferior), o que provavelmente está marcado no seu caso.

você pode simplesmente colocar keep_window_open (); antes do retorno aqui é um exemplo

int main()
{
    cout<<"hello world!\n";
    keep_window_open ();
    return 0;
}