¿Cómo mantener abierta la ventana de la consola en Visual C ++?

Estoy comenzando en Visual C ++ y me gustaría saber cómo mantener la ventana de la consola.

Por ejemplo, esta sería una aplicación típica de "hola mundo":

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

¿Cuál es la línea que me falta?

Comience el proyecto con en Ctrl+F5lugar de solo F5.

La ventana de la consola ahora permanecerá abierta con el Press any key to continue . . .mensaje después de que el programa salga.

Tenga en cuenta que esto requiere la Console (/SUBSYSTEM:CONSOLE)opción del vinculador, que puede habilitar de la siguiente manera:

1. Abra su proyecto y vaya al Explorador de soluciones. Si me sigue en K&R, su "Solución" será 'hola' con 1 proyecto debajo, también 'hola' en negrita.
2. Haga clic derecho en 'hola "(o el nombre de su proyecto).
3. Elija "Propiedades" en el menú contextual.
4. Elija Propiedades de configuración> Vinculador> Sistema.
5. Para la propiedad "Subsistema" en el panel de la derecha, haga clic en el cuadro desplegable en la columna de la derecha.
6. Elija "Consola (/ SUBSISTEMA: CONSOLA)"
7. Haga clic en Aplicar, espere a que termine de hacer lo que sea que haga, luego haga clic en Aceptar. (Si "Aplicar" está atenuado, elija otra opción de subsistema, haga clic en Aplicar, luego regrese y aplique la opción de consola. Mi experiencia es que OK por sí solo no funcionará).

CTRL-F5 y las sugerencias del subsistema funcionan juntas; No son opciones separadas.

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

La forma estándar es cin.get()antes de su declaración de devolución.

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

Pon un punto de interrupción en la returnlínea.

Lo estás ejecutando en el depurador, ¿verdad?

Otra opción es usar

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

Aunque esto no es muy portátil porque solo funcionará en Windows, pero imprimirá automáticamente

Pulse cualquier tecla para continuar...

Para los proyectos de archivo MAKE, la solución aceptada falla debido a un error en Visual Studio (que está presente al menos hasta la versión 2012; aún no he probado 2013). Este error se detalla aquí .

Para que la consola se detenga después de la finalización del programa en un proyecto de archivo MAKE, realice estos pasos (esto puede diferir para versiones distintas de 2010 - 2012):

1) Pase /SUBSYSTEM:CONSOLEal enlazador. - EDITAR : ver más abajo.

2) Abra su archivo de proyecto (.vcxproj) en un editor de texto.

3) Dentro de la <project>etiqueta raíz , inserte lo siguiente:

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

4) Vuelva a cargar el proyecto en su solución.

5) Ejecute el programa sin depurar (CTRL + F5).

EDITAR:

Según mi comentario a continuación, configurar la opción del vinculador /SUBSYSTEM:CONSOLEes realmente irrelevante para proyectos de archivo MAKE (y no necesariamente es posible, si está utilizando un compilador que no sea MSVC). Lo único que importa es que la configuración se agrega al archivo .vcxproj, como se indica en el paso 3 anterior.

Puede usar cin.get();o cin.ignore();justo antes de su declaración de devolución para evitar que la ventana de la consola se cierre.

solo ponga un punto de interrupción en el último soporte rizado de main.

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

funciona para mí, no es necesario ejecutarlo sin depurarlo. También ejecuta destructores antes de llegar al punto de interrupción para que pueda verificar cualquier mensaje impreso en estos destructores si tiene alguno.

Simplemente agregue un punto de interrupción al corchete de cierre de su _tmainmétodo. Esta es la forma más fácil, además de que no tiene que agregar código para depurar.

Coloque un punto de interrupción en la llave final de main(). Se disparará incluso con múltiples returndeclaraciones. El único inconveniente es que una llamada aexit() no será capturada.

Si no está depurando, siga los consejos de la respuesta de Zoidberg y comience su programa con Ctrl+ en F5lugar de solo F5.

Mis 2 centavos:

Opción 1: agregar un punto de interrupción al final de main()

Opción 2: agregue este código, justo antes de 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');

Necesitas incluir <iomanip>parastd::numeric_limits

simplemente agregue el sistema ("pausa") al final del código antes de devolver 0 como este

#include <stdlib.h>

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

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

cin.get()O system("PAUSE"). No he escuchado que puedas usarreturn(0);

Incluyo #include <conio.h>y luego, agrego getch();justo antes de la return 0;línea. Eso es lo que aprendí en la escuela de todos modos. Los métodos mencionados anteriormente aquí son bastante diferentes, veo.

Tuve el mismo problema Estoy usando _getch()justo antes de la declaración de devolución. Funciona.

(Algunas opciones se pueden llamar con diferentes nombres. No uso la versión en inglés)

Tuve el mismo problema, cuando creé proyectos con la opción "proyecto vacío", Crear proyecto como "Aplicación de consola Win32" en lugar de "proyecto vacío". En el cuadro de diálogo que aparece ahora, presiona "continuar" y luego puede marcar la opción "proyecto vacío" y presionar confirmar. Después de eso, CTRL + F5 abrirá una consola que no se cierra automáticamente.

Yo tuve el mismo problema; En mi aplicación hay múltiples puntos de salida () y no había forma de saber exactamente dónde sale, entonces descubrí esto:

atexit(system("pause"));

o

atexit(cin.get());

De esta manera, se detendrá sin importar dónde salgamos del programa.

Otra opción:

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

En principal:

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

En realidad, la solución real es la selección de la plantilla del proyecto en sí. DEBE seleccionar la aplicación de consola Win32 en VS anteriores, o complete primero el nombre del proyecto y luego haga doble clic en el asistente de escritorio de Windows y luego seleccione la aplicación de consola Win32. Luego seleccione proyecto vacío en este punto. Esto permite lo que realmente quería el interrogador original sin agregar un punto de detención adicional y un código de retención. Pasé por este problema también. La respuesta también está en el sitio de MSDN.

Aquí hay una manera de mantener abierta la ventana de comandos, independientemente de cómo se detenga la ejecución sin modificar ningún código:

En Visual Studio, abra las páginas de propiedades del proyecto -> Depuración .

Para Comando , ingrese$(ComSpec)

Para Argumentos de comando , ingrese/k $(TargetPath) . Agregue cualquier argumento a su propia aplicación.

Ahora F5 o Ctrl-F5 ejecuta Windows / System32 / cmd.exe en una nueva ventana y / k asegura que el símbolo del sistema permanezca abierto después de que se complete la ejecución.

La desventaja es que la ejecución no se detendrá en los puntos de interrupción.

Como algunos ya han señalado, la solución de Zoidbergs no adjunta el depurador, que es algo que generalmente no desea.

La mejor opción es configurar su VS en consecuencia (a partir de VS 2017 en adelante), vaya a Herramientas> Opciones> Depuración> General. Allí desmarca "Cerrar automáticamente la consola cuando se detiene la depuración" (en la parte inferior), que probablemente esté marcada en su caso.

solo puedes poner keep_window_open (); antes del regreso aquí hay un ejemplo

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