Hola y bienvenidos.
En este vídeo, voy a mostrarte cómo construir y ejecutar el programa del vídeo anterior.
Si recuerdas, teníamos un pequeño programa que básicamente pedía al usuario que introdujera su número favorito
y luego imprimía ese número favorito.
Por lo tanto, de los vídeos anteriores, usted debe entender que hay muchos pasos para crear un programa que se puede
ejecutar.
Hay que compilar, enlazar y crear el binario.
Y así hasta este punto, hemos sido capaces de compilar con éxito.
No vemos ningún error.
Ahora necesitamos básicamente tomar todas las dependencias externas para este programa, escribir el archivo de encabezado
estándar i o y cualquier otra librería proporcionada por el lenguaje de programación C.
Tomas todo eso que pueden ser muchos archivos O y tomas todo ese código externo para crear un solo
ejecutable.
¿Verdad?
Así que aquí tenemos nuestro código fuente.
Verás que tenemos el código fuente agrupado.
Usted puede hacer este código un poco más legible mediante la adición de algunas líneas nuevas, algo como esto.
Sólo lo hace un poco más legible.
Ahora, como he mencionado, ya lo hemos compilado.
Para refrescarte la memoria, puedes compilar un archivo fuente de muchas formas distintas.
Puede hacer clic derecho en el archivo de origen y decir compilar, o puede seleccionar ese archivo de
origen, ir a construir y puede decir compilar el archivo actual.
Si seleccionamos nuestro proyecto, verás muchas opciones diferentes relacionadas con la construcción.
Ves construir, reconstruir, limpiar, parar, construir.
Hablemos primero de la limpieza.
Limpiar básicamente borrará cualquier archivo antiguo que tuvieras.
Así que recuerda de antemano en videos anteriores que un programa en C cuando se compila, estás compilando cada archivo fuente
y un programa puede consistir en muchos archivos fuente.
Punto principal C ¿Algún otro archivo también?
Hay programas que contienen miles y miles de archivos fuente en C.
Una vez que compilas todos esos archivos C, crea todos los archivos antiguos y luego tomas esos archivos
antiguos y los enlazas para crear un solo ejecutable.
Ahora, cuando seleccionas el proyecto, configurando el yo del proyecto y dices limpiar, lo que estás haciendo es
que básicamente estás borrando todos esos archivos viejos, estás borrando cualquier artefacto extra, estás borrando
el ejecutable del programa y estás empezando de cero.
Esencialmente, estás obteniendo un espacio de trabajo limpio que luego puedes recompilar, reconstruir, volver a vincular y recrear
un programa en sí.
Típicamente quieres usar clean si te estás encontrando con errores y tal vez sólo quieres recompilar
cada archivo fuente porque típicamente cuando ejecutas un compilador C, si el código como no cambia y tratas de compilar ese código,
usualmente no lo recompila.
Y así, si usted acaba de ejecutar en problemas, usted tiene un montón de archivos de origen, que está viendo los errores
que no tienen sentido.
Puede ser bueno empezar desde un estado limpio, ir a limpiar, limpiar todo.
Dices limpio y te mostrará exactamente eso.
Es básicamente eliminar todo de su carpeta de depuración de construcción.
De nuevo, todos esos puntos os el ejecutable que estás empezando desde cero.
Es una buena manera de resolver cualquier tipo de dependencias o cualquier tipo de problemas sin recompilar todo
el proyecto de nuevo para empezar de cero.
Así que después de ejecutar limpio, no tenemos nada compilado o nada construido y podríamos ir a través y podemos compilar archivos
individuales diciendo compilar y haga clic en cada archivo.
Si tienes muchos archivos fuente, no es una buena forma de llegar al ejecutable final.
Por lo general, lo que sucederá es que usted quiere asegurarse de que tiene su proyecto de aplicación
y que normalmente acaba de decir construir y que va a ir a través de todo el código fuente en el proyecto y construir todos los archivos.
Así que cuando se pulsa construir, verás que ir a través y agarrar todos los códigos fuente y reconstruir.
Y lo mismo si haces click derecho y dices reconstruir, esto no reconstruirá todos los archivos o solo
reconstruirá los archivos que han cambiado.
Y así se puede decir construir, lo que hace que sea un poco más fácil que simplemente compilar cada archivo de origen.
La compilación volverá a compilar todos los archivos fuente, pero también los enlazará para que puedas verlos en
la salida, ¿verdad?
Si vas a la ventana de salida de compilación, puedes ver que primero estamos emitiendo un comando GCC dash C, que
es la bandera para compilar en main dot C, A continuación, pasamos parámetros para la optimización de 64 arquitecturas, algo
de depuración estándar C, 99 advertencias para todas las advertencias.
Y luego hacemos el guión o para enlazar con el Principal. cpp.
Básicamente vamos a incluir también algunos directorios de inclusión.
Y luego, en el siguiente paso, a la derecha, emitimos el guión cero para hacer nuestra vinculación a cada dependencia externa.
En este caso, realmente no tenemos muchos, sólo tenemos básicamente la vinculación, estamos vinculando estáticamente
con el Dash L y básicamente estamos construyendo este texto de la lista de objetos.
La gran cosa importante aquí es que en realidad está creando un ejecutable llamado nuestro primer programa.
Ver.
Y así construir hace los dos pasos de un programa en C, ¿verdad?
Lo compila, lo enlaza y crea el ejecutable.
Y por lo que sólo hace las cosas más fáciles mediante la construcción en lugar de compilar todo al principio.
Ahora, es posible que desee compilar archivos individuales sólo para tal vez ver lo que está pasando, para asegurarse de que su
código fuente es correcto y no está listo para la vinculación.
Puedes tener cinco archivos aquí.
Usted selecciona cada uno que desea decir, está bien, acabo de escribir algo de código, vamos a compilarlo,
asegúrese de que está todo bien para ir, y luego voy a ir y hacia fuera en el siguiente archivo, compilar eso y luego, finalmente, construir
todo.
Ahora que tenemos un ejecutable de programa real que se crea, podemos realmente ejecutar nuestro programa.
Y así que usted quiere asegurarse de que usted tiene su programa, su proyecto como el proyecto activo y lo han puesto de relieve,
y entonces usted puede ir a construir y usted puede simplemente decir ejecutar.
Ahora, cuando selecciones "Ejecutar", es probable que aparezca una ventana emergente que dice: "¿Desea volver a compilar y ejecutar?
Ahora ya has construido, así que no hace falta.
Puedes decir simplemente ejecuta.
Puedes marcar la casilla para asegurarte de que no aparezca siempre.
Y cuando huyes, no siempre se reconstruye.
Depende de ti.
Reconstruirlo todo requiere algo de tiempo de procesamiento de la CPU, pero probablemente no te preocupe.
Así que siempre se puede decir construir y ejecutar y no tener un pop up o siempre se puede simplemente ejecutar.
Ahora, si seleccionamos ejecutar, va a tomar ese ejecutable y se va a ejecutar.
Y lo que notarás es que te pide que introduzcas tu número favorito, el usuario.
Así que puedes poner el número 45, pulsar la tecla Intro en el teclado y aparecerá
el número 45.
De nuevo, un programa muy simple pide entrada, muestra, salida, y luego puede pulsar cualquier tecla para continuar
y cerrar esa ventana.
Ahora, si volvemos a nuestra vista de espacio de trabajo, nuestra ventana de espacio de trabajo, nuestro panel de espacio de trabajo, como
quieras llamarlo, te das cuenta de que tenemos tres proyectos, ¿verdad?
Destacamos nuestro primer programa.
Ese es el proyecto activo.
Los otros proyectos siguen teniendo sus archivos fuente, ¿verdad?
Punto principal C, Derecha.
Y nuestros otros proyectos, son bastante plantillas.
Hola, Código Mundial.
Pero lo que no ves es que no ves ninguno de los archivos objeto, los archivos punto
cero, no ves el archivo ejecutable, nada de eso.
Ahora puedes verlos haciendo clic en la pestaña Explorador y puedes especificar la carpeta que quieres abrir.
Y normalmente esta debería ser la carpeta raíz de donde estás creando todos tus espacios de trabajo.
Así que normalmente los pongo, creo que los pongo en los documentos dentro de la derecha dentro de los documentos.
Tengo mis espacios de trabajo.
Verás que tiene un montón de cosas aquí.
Así que por lo general usted quiere poner que local, pero usted verá que usted tiene el espacio de trabajo uno y el espacio de trabajo dos, y
verás que ese espacio de trabajo tiene el archivo de la luz de código de puntos.
En realidad, probablemente sea mejor abrir los archivos exactos del espacio de trabajo, ¿no?
Porque eso es realmente lo único que nos interesa.
El espacio de trabajo dos es el que nos interesa.
Así que vamos a decir seleccione la carpeta, espacio de trabajo dos, y luego vamos a seguir adelante y cerrar nuestros nuestros documentos existentes por lo que podemos
seguir adelante y sólo podemos decir cerrar.
Así que ahora tenemos Workspace dos y ahora podemos ver realmente todos nuestros ejecutables para todos
nuestros proyectos y todos nuestros archivos.
Y entonces te das cuenta de que hay una carpeta de luz de código allí.
Ese directorio de luz de código sólo contiene algunas de las preferencias para el espacio de trabajo y así sucesivamente.
Tenemos nuestra carpeta build debug.
Esto contiene nuestro directorio binario que contiene nuestro ejecutable y te darás cuenta de que también tenemos un directorio R primer programa
y que está dentro de depuración construir porque ese espacio de trabajo, que el proyecto se ha construido y verás que ahí tenemos nuestros
archivos de objetos y cualquier otra dependencia que se construyen esta lista
de objetos.
Ya tenemos nuestro primer proyecto de programa, ¿verdad?
Y eso concierne a nuestro archivo fuente y cualquier otro archivo make y demás.
Y lo mismo ocurre con los demás proyectos.
Y luego en la parte inferior se ven los comandos de compilación, punto JSON.
Suele utilizarse para completar código.
Ves un archivo make y luego ves un archivo workspace.
Pero la pestaña Explorar nos ayuda a ver todo el diseño de nuestro espacio de trabajo, todos nuestros proyectos, todo lo que se ha construido, todos los archivos
de configuración del proyecto y todos los archivos de origen del proyecto, y luego también cualquier dependencia de los archivos de finalización
de código y así sucesivamente para el propio espacio de trabajo.
Y entonces hablamos de limpiar, ¿verdad?
Cómo limpiar realmente puede eliminar todo, todos los archivos objeto en el ejecutable.
Así que si volvemos a la vista de espacio de trabajo y destacamos nuestro primer proyecto de programa cuando hacemos
clic derecho y decimos limpiar, que va a eliminar todos esos.
Así que ahora si vuelves a la pestaña Explorador y vas a la depuración de construcción, verás que verás todo lo que
hay porque no se ha actualizado.
Así que puedes refrescar esta vista.
Así que voy a hacer clic derecho en nuestro espacio de trabajo y voy a decir refrescar la carpeta de depuración de construcción.
Así que por lo general se elimina, pero no hay nada dentro de ella, ¿verdad?
Puede que vuelvas a tener una papelera.
Normalmente eso se limpia.
Depende de los permisos, pero no tienes archivos antiguos.
No tienes tu ejecutable después de hacer una limpieza.
Ahora, de nuevo, si volvemos al espacio de trabajo, se puede ver este pequeño menú desplegable que le dice lo que construir, si usted está
construyendo para la depuración o si usted está construyendo para la liberación.
Cuando se construye para depuración, se incluye información de depuración en el propio ejecutable del programa.
Eso suele ocurrir cuando estás desarrollando tu código.
Quieres información de depuración y en caso de que necesite ejecutar el depurador y así sucesivamente.
Eso no siempre es bueno hacerlo cuando se libera algún programa en el campo o a un cliente en modo de producción
para que pueda cambiar la liberación a la liberación cuando se está construyendo y desea distribuir este programa
en alguna parte.
Y entonces cuando lo construyas, lo que notarás es que si vas a la pestaña explorar, verás de nuevo hacer una
actualización.
Verás una carpeta build release y esta carecerá de la información de depuración esencialmente por lo que no tendrás que
preocuparte.
Básicamente, si usted tiene información de depuración, puede generar un archivo de núcleo y puede tener hackers
que pueden tipo de obtener información acerca de su código fuente.
Así que sólo construir depuración para el modo de depuración cuando se está desarrollando y que lo cambiaría a construir el modo de liberación
cuando usted está tal vez la liberación de su programa a un cliente.
De nuevo, depende de si estás trabajando en algún sitio o si estás trabajando para un empleado, si estás realmente
entregando algún código en algún sitio.
Normalmente no se modifica nada en la pestaña Explorador.
Sólo te da una vista de lo que se construye y sus ejecutables y así sucesivamente.
De nuevo, he mencionado que ves algunos archivos de ayuda.
Puedes mirar algunas de estas cosas.
Algunas de estas cosas se generarán automáticamente.
Puedes ver un archivo make aquí.
Y esto es en realidad un archivo make que se puede generar en función de la configuración del proyecto.
Este es un archivo make para todo el espacio de trabajo.
Puedes mirar programas específicos y ver algunos de los archivos make que se generan de nuevo, pero normalmente no querrás
meterte con nada de esto.
Esto sólo proporciona de nuevo un archivo make para compilar.
A veces, cuando tienes errores, puedes mirar el archivo make para ver exactamente lo que está pasando.
Puede que algo no se haya generado correctamente.
Código como a veces tiene algunos errores dependiendo de lo que hacen sistema que utiliza.
De nuevo, solemos usar el sistema de archivos UNIX si estás en Windows y si estás en Linux o Mac
OS, puedes usar el sistema por defecto.
Así que eso es básicamente todo, ¿verdad?
Puedes cerrar estos archivos, pero puedes ver lo que está pasando en el Explorador y en las vistas del área de trabajo.
Ahora en la vista Espacio de trabajo, de nuevo, si selecciona un proyecto, también puede decir detener, construir.
Así que a veces la compilación y la construcción y su ejecutable puede tomar mucho tiempo.
Si tienes miles de archivos, podrías estar construyendo durante 30 minutos.
Así que para, construir sólo le permite dejar de construir cualquier cosa, ya sabes, compilar y vincular cualquier cosa, cualquiera
de los proyectos.
Una vez más, útil para cuando se tiene un largo proceso de compilación, pero por lo general no se ve que en algunos de los códigos que vamos
a estar escribiendo para nuestra clase.
Otra cosa que podría estar bien es que si resaltas la vista del espacio de trabajo, puedes construir todos los proyectos
de una sola vez.
Puedes decir build workspace o clean workspace y borrar todas las dependencias de todos los proyectos.
Pero si usted dice construir espacio de trabajo, que va a construir todos los proyectos, independientemente de si está activo y
eso es lo que se ve en la ventana de salida.
Bien.
Estamos construyendo el Proyecto tres, estamos construyendo el Proyecto dos y estamos construyendo nuestro primer programa.
Y así, de nuevo, sólo un rápido resumen de cómo se puede realmente construir y ejecutar el código del proyecto activo, algunos
de los ajustes y cómo se puede ver la ficha Explorador.
Gracias, señor.