Transcripciones
1. INTRODUCCIÓN: Bienvenido al curso
Primoris Arts C plus plus para principiantes. Si estás aquí, probablemente
te interese
aprender a codificar, pero te sientes un poco perdido
en cuanto a por dónde empezar. Lo pillo. Yo también estuve ahí. Cuando intenté
aprender a codificar por primera vez, dediqué más tiempo a
buscar un curso completo, seguir contenido a lo
que ya había aprendido y/o respuestas a preguntas básicas
que realmente aprendiendo. Además, sentí
que me estaban
enseñando a realizar
los movimientos cuando lo que
realmente necesitaba y quería era saber cómo funcionaban
las cosas y cuándo usarlas para poder comenzar mis propios proyectos Eso justo ahí es por
lo que
creamos este curso para que no
tuvieras que lidiar con
esas mismas luchas en tu viaje para
convertirte en programador. Todo lo que necesitas
para comenzar está aquí en un solo
lugar, desde temas principiantes hasta avanzados
con soporte real disponible cuando más lo necesitas. Entonces, ¿por qué deberías aprender C
plus plus específicamente? C plus plus es un potente lenguaje
versátil utilizado
en el desarrollo de juegos, navegadores
web,
bases de datos y más. Con él, tendrás
la base para
comenzar a crear tus
propios proyectos en una escala que es muy valorada en la industria
tecnológica en constante crecimiento. Y si bien C plus
se considera un lenguaje más difícil de
aprender basado en el lenguaje C, puede ser una herramienta esencial
para aquellos que buscan dominar programación en campos donde memoria y la velocidad son
de gran preocupación, y proporciona una
base sólida que facilita mucho el aprendizaje otros lenguajes basados en
C como de
otros lenguajes basados en
C como C Sharp o Java
. Con eso en mente, este
curso va a comenzar con lo básico absoluto. Si nunca has escrito
una sola línea de código, no te preocupes,
vas a estar bien. Nos sumergiremos en los fundamentos como variables y
poco a poco
nos abriremos camino hasta temas más
avanzados como clases u objetos,
abstracción, encapsulación,
polimorfismo, herencia A partir del capítulo tres, tendrás
la oportunidad de
ponerte manos a la obra con desafíos de
codificación diseñados
específicamente para ayudarte a solidificar tu comprensión de los conceptos que se enseñan a
lo largo
del conceptos que se enseñan a
lo largo
del Entonces, ¿por qué deberías elegir este curso para
aprender C plus plus? Porque en lugar de
solo mostrarte cómo pasar por los
movimientos y que
termines con algún
proyecto que no
tienes idea de cómo
recrear por tu cuenta, te
estaré enseñando no
solo a escribir el código,
sino más importante,
cuándo usarlo y por qué sino más importante,
cuándo usarlo y Al enseñarte a pensar
como programador, en realidad
obtendrás una comprensión mucho
más profunda de cada concepto enseñado para que
al final del curso, estés listo para abordar tus propios proyectos con confianza. Y para mejorar aún más las cosas, todo lo que usamos en
este curso es gratuito, lo que significa que no hay pruebas gratuitas ni cuotas ocultas de las que preocuparse. Ahora bien, ¿para quién es este curso? Este curso es perfecto para principiantes
absolutos
que buscan comenzar, programadores
experimentados
que buscan refrescar o ampliar sus habilidades
y todos los demás Y recuerda, no hay prisa. Siéntase libre de ir a su
propio ritmo y regresar y
volver a visitar
lecciones específicas cuando sea necesario Aquí en Primoris Arts, estamos comprometidos a ayudarte a tener éxito en cada paso del camino Entonces, si estás listo para
comenzar tu viaje de codificación, entonces no hay mejor
momento que ahora mismo. Te invitamos a unirte a nosotros
hoy en el siguiente video mientras nos sumergimos en la programación
paso a paso con lecciones claras, concisas y
fáciles de seguir. Gracias por mirar, y te
veré en la siguiente.
2. Capítulo 1 (Configuración): instala Visual Studio: Bienvenidos al
primer episodio
del curso C plus plus para
principiantes. En este episodio, te
estaré mostrando cómo instalar Visual Studio, un programa completamente gratuito
que estaremos usando para escribir y ejecutar
todo nuestro código. Ahora, desafortunadamente, si
estás en un Mac OS o Linux, necesitarás descargar
otro programa que te
permita escribir y ejecutar código
C plus plus. Pero no te preocupes,
una vez que hagas eso, podrás
seguirlo muy bien. Y hay múltiples programas
gratuitos disponibles, así
como un montón de tutoriales en
línea sobre cómo
comenzar con ellos. Luego, en el próximo episodio, me aseguraré de
que todos estén exactamente en la misma página para que
puedas seguirlo independientemente
del programa que estés usando. Muy rápido aquí y
solo algunos ejemplos de algunos programas que recomendaría. Ya sea que estés en
macOS o Linux. Puedes usar Visual Studio Code. Otro que puedes
usar son los bloques de código. Y por último, para
los usuarios de macOS específicamente, puedes usar el software
Xcode incorporado. modos, para todos los
que están en Windows, Visual Studio es el programa
más popular y el que recomendaría
usar ya que es muy fácil de configurar
y comenzar. Entonces lo primero que
vas a querer hacer es ir a Visual
Studio.Microsoft.com. Después en la parte superior,
ve a descargas. Entonces verás tu Visual
Studio con C plus plus. Sigue adelante y ve al cuadro desplegable de
descargas y ve a donde
dice Community Free. Asegúrate de no hacer clic en el que dice prueba gratuita. Luego, una vez que se descargue, continúe y abra la aplicación Visual
Studio Setup y asegúrese de aceptar cualquier mensaje que pueda
aparecer en su pantalla. Entonces sigue adelante y espera a que termine de descargarse
e instalar. Ahora, una vez que haya
terminado de instalar, puede seguir adelante y crear
una cuenta gratuita si lo desea. Como creo
te hará crear una cuenta
en algún momento, aunque el programa
sea completamente gratuito. No obstante, en este momento, sólo
voy a seguir adelante y seguir sin cuenta. Para que de esa manera ninguno de los ajustes
anteriores de mi cuenta esté ahí y que podamos repasar
todo junto con un fresco y cráneo. Así que voy a seguir adelante y
hacer clic no ahora, tal vez más tarde. Ahora, recomendaría encarecidamente
ir con un tema oscuro. No solo un Visual Studio, sino cualquier programa que utilices para
escribir código en el futuro, ya que definitivamente será
mucho mejor para tus ojos. Entonces en cuanto a los ajustes de
desarrollo, solo
voy a seguir adelante
y dejarlos en general. Después seguiremos adelante y
golpearemos Iniciar Visual Studio. Bien, una vez que esté abierto, vamos a seguir adelante
y crear un nuevo proyecto. Y lo que vas
a buscar por aquí en la parte superior es C plus, plus. Otra cosa que puedes hacer es
simplemente ir a donde dice todos los idiomas y dar
click en C plus plus. Y deberías ver uno
para aplicación de consola. Así que voy a hacer clic en
eso y luego presionar Siguiente. Entonces vas a seguir adelante y darle un nombre a tu proyecto. Ahora, puedes dar
el nombre que quieras, pero te recomendaría seguir con una convención de nomenclatura de Pascal Case. Es decir, no vas
a tener ningún espacio. Vas a comenzar
con una letra mayúscula y cada palabra posterior
también comenzará con una letra
mayúscula. Así que adelante y dale
un nombre rápido. Ahora, notarás que el nombre de
tu solución aquí en la parte inferior es exactamente el
mismo que el nombre de tu proyecto.
Para este curso. Vamos a seguir adelante
y dejarlo así. Pero solo debes saber que
en el futuro, tu solución y el nombre del proyecto no tienen que ser los mismos. Además, puedes
seguir adelante y elegir cualquier ubicación que quieras
para este proyecto. Entonces asegúrate este cuadro
aquí abajo en la parte inferior que dice play solution en project
en el mismo directorio. Como desmarcado. Ya que esta es generalmente
una buena práctica. Entonces sigue adelante y pulsa Crear. Bien, entonces puedes seguir
adelante y cerrar esto. Y ahí lo tienes. Ahora instalamos
Visual Studio, y hemos creado nuestro
primer proyecto C Plus Plus. Ahora lo que quiero que
hagas es ir al archivo en la parte superior y presionar Guardar todo, y asegúrate de hacerlo
al final de todos
y cada uno de los videos a menos que
se indique lo contrario. Ahora, sé que no todos
ustedes están usando Visual Studio. Entonces, en el siguiente video,
voy a estar
asegurándome de que todos ustedes estén exactamente
en la
misma página que yo y estén
listos para aprender a leer y escribir código juntos. Y no te preocupes, esos
son el único programa que voy a tener instalados a
lo largo de este curso. De todos modos, gracias por mirar, y te veré
en la siguiente.
3. Capítulo 1 (Configuración): haz que todos los participantes en la misma página: En este video, voy
a estar asegurándome
de que todos ustedes estén exactamente en la
misma página que yo, para que puedan seguir fácilmente junto con el resto
del curso. Y recuerda, si
necesitas alguna ayuda en absoluto. Por favor avíseme abajo en la sección de discusión a continuación y estaré más que
feliz de ayudarte. De todos modos, comencemos. Ahora muy rápido, para aquellos de ustedes que están usando Visual Studio, vamos a ir a
herramientas en la parte superior y bajar a Opciones. Y bajo el pinche,
haga clic en General. Luego desplácese hacia abajo hasta la parte inferior. Y deberías ver una
casilla de verificación que dice cerrar
automáticamente la
consola al depurar sellos. Asegúrese de que esto esté verificado. Entonces adelante y haz clic en Bien. Entonces, independientemente del
programa que estés usando, si tienes algún otro texto
fuera de este hashtag, incluye la línea iostream en
este corchete cerrado. Entonces todo aquí mismo, solo sigue adelante y
deshazte de todo lo demás. Así. Bien, entonces esto debería ser lo único que queda
en tu pantalla. Ahora bien, si esto no está
en tu pantalla, sigue
adelante y copia esto exactamente. Ahora, una vez que tu código
se vea como el mío, en realidad
vamos
a seguir adelante y agregar algunas líneas adicionales de código. Ahora, no te preocupes, no tienes que entender nada de esto. Vamos a repasarlo
por completo en el siguiente video. Pero por ahora, solo
quiero
asegurarme de que el
código de todos esté funcionando. Así que justo después de esta línea de
HelloWorld aquí, justo después del punto y coma, vamos a seguir adelante y clic en Entrar para
crear una nueva línea. Y vamos a escribir
std, colon, colon, punto
C, punto
C, obtener paréntesis abiertos, cerrar
paréntesis, punto y coma. Después golpearemos de nuevo a Enter.
Crean una nueva línea. Voy a escribir return. Después el número 0
seguido de otro punto y coma. Entonces el código de todos debería
verse exactamente así. Ahora, independientemente del
programa que estés usando, deberías poder
ejecutar el código tal como está. Ahora para aquellos de ustedes que
usan Visual Studio, simplemente pueden hacer clic en este
botón Reproducir aquí en la parte superior, o el hockey es F5. Ahora para aquellos de ustedes que
usen otro programa, tendrán que averiguar
cómo ejecutar su código. Y si hay una
tecla de acceso rápido para hacerlo, definitivamente
recomendaría
recordarlo ya que lo estaremos haciendo
mucho a lo largo de este curso. De todos modos, una vez que tu código se ejecuta, simplemente
debería decir hola mundo. Y cuando presionas Enter, debo salir del
código. Así como así. Ahora, es posible que todos ustedes no obtengan una ventana de consola que
aparezca cuando se ejecute su código. Y eso está perfectamente bien. Mientras tu código se ejecute
y diga hola mundo, todos están bien para ir. En cuanto al resto de ustedes, lo primero que quiero verificar, su código se ve
exactamente como el mío. Entonces si sigues
teniendo problemas, por favor avíseme abajo en la
sección de discusión abajo, y estaré más que
feliz de ayudarte. De todos modos. Eso
es todo para este video. El siguiente video,
vamos a estar
repasando lo que realmente significa todo este
código. Así que gracias por mirar, y te veré
en la siguiente.
4. 3: En este video,
vamos a
repasar brevemente todo el
código que tenemos aquí. Ahora, no te preocupes, no espero que recuerdes
todo ya que vamos a repasarlo todo con
más detalle más adelante
en el curso. Sólo quiero darles
una breve introducción lo que está pasando. Y al final del video, te
voy a dar un breve resumen de los pocos puntos clave que quiero que
recuerdes a medida que avanzamos. Entonces al principio aquí, tenemos esta declaración include, que básicamente
le dice al compilador que queremos
tomar el código
del archivo de encabezado llamado iostream
y ponerlo en nuestro programa. El compilador como lo que traduce
todo aquí en binario o unos y ceros para que nuestro equipo pueda entenderlo
realmente. Y un archivo de encabezado es básicamente solo una colección
de código que está hecha para ser utilizada por
otros programas. A continuación, tenemos nuestra función principal. La función principal es
importante porque cada programa C plus plus
tiene una función principal, ya que aquí es donde su
programa comenzará y terminará. Y todo lo que forma parte de la función principal necesita colocarse entre estos corchetes abiertos
y cercanos. Y aquí es donde se escribirá
la mayoría de nuestro código. A continuación, tenemos esta línea de código que imprime Hello world. Y sigamos adelante y
desglosemos eso rápido. Así que primero escribimos std, que es un espacio de nombres que contiene una definición
para el objeto C out. Y volveremos a los
espacios de nombres aquí en un minuto. Ahora, vea como un objeto
utilizado para mostrar texto. Y siempre va
seguido del operador de inserción, que es dos menos que símbolos. Y lo que está a la derecha
del operador de inserción es lo
que realmente quieres imprimir. Cuando quieres imprimir
textos literalmente, o quieres imprimir
exactamente lo que escribes. Necesitas tenerlo entre dos comillas
dobles así. Y toda esta línea aquí como una declaración o una
instrucción para nuestro programa. Y la mayoría de las declaraciones
terminaremos con punto y coma. Entonces, para resumir,
básicamente estamos diciendo que queremos usar el objeto C out para
imprimir hola mundo. Entonces esta línea que
agregamos en el último video básicamente solo dice
que queremos
obtener entrada del usuario. Y la única razón por la que
ponemos esto aquí como para que nuestro programa no se
cierre inmediatamente después de ejecutarse. Como suele ser, una vez que un programa ha pasado por todas
sus líneas de código, asumirá
que está hecho y se cerrará
automáticamente. Ahora, dependiendo del programa
que estés
usando realmente para escribir código, tu código puede permanecer abierto
con o sin esta línea. Pero para aquellos de
ustedes que lo necesiten, voy a dejarlo aquí en
pantalla como recordatorio. Entonces solo para mostrarte rápido, si me deshago de esta línea de código e intento ejecutar mi programa, se ejecutaría instantáneamente y
luego se apagaría de inmediato. Entonces, si vuelvo a poner eso
y vuelvo a ejecutar mi código, ahora
necesito presionar
Enter para cerrar. Ahora bien,
en realidad me permitirá escribir varias letras y números. Pero una vez que golpee Enter, se apagará de inmediato. Y eso es porque
este método get aquí está esencialmente esperando. Toman la entrada del usuario y como suponiendo que hayas terminado
cuando presionas la tecla Enter. Y por último, tenemos esta declaración de retorno
aquí en la parte inferior, que solo dice que queremos devolver el número entero cero. Y la razón por la que estamos
devolviendo cero como porque nuestra función principal tiene un tipo de
retorno de un entero. Una vez que el código que invoca nuestra función principal
recibe este cero. Y esos son código que se
ejecutó con éxito. Y algo que puedes ver aquí, indistintamente con el cero es el éxito de
salida con un guión bajo en el medio y en todas las mayúsculas. Al igual que así. Esto va a funcionar bien. Al igual que en C plus, plus. Esto es exactamente lo mismo que simplemente poner en los números
reales cero. Y en realidad
lo voy a dejar así para mayor claridad. Para aquellos de ustedes
que sí lo necesitan. No obstante, dicho eso, C Plus Plus en realidad te
permite simplemente eliminar esta línea y
devolverá cero automáticamente. Pero como dije, voy a dejar esto
aquí por el bien de la claridad, ya que esto es lo que realmente está
sucediendo en el fondo. Tan rápido,
volvamos al espacio de nombres std. El espacio de nombres es
básicamente solo eso. Se trata de un espacio con nombre en el
que reside el código. Y puedes
pensar en esto como el apellido de una persona, por ejemplo, si te acabo de mencionar el nombre de
alguien, tal vez no sepas de quién
estaba hablando, pero si te dijera
su apellido, entonces cuando dije
su nombre de pila, no
tienes contexto en cuanto
a a quién me refería. Exactamente. Eso es lo mismo
con nuestro código aquí. Entonces cuando decimos que el pecado
como parte del std, namespace y nose
fueron enviados como viniendo de por si acaso hay otros objetos que también
tienen ese mismo nombre. Y este espacio de nombres std proviene de este archivo de encabezado
iostream, que se utiliza para
entrada y salida estándar, razón por la
cual
verá este archivo de encabezado usado y muchos programas C
plus plus. Entonces algo que podamos hacer, en lugar de poner
este espacio de nombres antes que todo lo que es parte de ese espacio de nombres
tiene en la parte superior aquí, justo debajo de nuestra declaración
include. Podemos decir usando espacio de nombres. Std y luego un
punto y coma al final. Y ahora automáticamente
sabrá de dónde
vienen estos objetos. Y nos meteremos más en los objetos
más adelante en el curso. Como C plus plus es un lenguaje de
programación orientado a objetos. Entonces ahora que estamos
diciendo que estamos usando este espacio de nombres y
sabe de dónde vienen estos
objetos, en realidad
podemos simplemente eliminar
este prefijo aquí por completo. Así como así. Y si ejecuto el programa, se
puede ver que
funciona bien. No obstante, dicho eso, algunas personas les gusta dejar a
los que están ahí por el bien de la claridad. Pero yo personalmente, prefiero
simplemente escribir C out o CN, ya que
se usan con tanta frecuencia. Entonces seguiré adelante
y lo quitaré
así y guardaré el programa. Y esto es lo que vamos a
utilizar en el futuro. Así que asegúrense de que
ustedes tenían esta línea de código y estarán
todos atrapados en. Por último, volvamos a
este texto de Hello World aquí. Quizás se esté preguntando
qué
es esta diagonal inversa n y por qué no apareció
cuando ejecutamos nuestro código. Entonces como pueden ver, cuando ejecuto un código, dice Hola mundo, signo de
exclamación. Entonces nuestro cursor está parpadeando aquí
abajo en la parte inferior. Y eso es porque
este backslash n dice que queremos
bajar a una nueva línea. Así que sigamos adelante y eliminemos eso rápido y volvamos
a ejecutar nuestro código. Y como pueden ver, nuestro cursor se encuentra ahora al final de la línea. Entonces esa diagonal inversa n básicamente solo dice que queremos
bajar a una nueva línea. Ahora bien, ¿y si quisieras escribir más texto en la nueva línea? Algunos de ustedes pueden ir
instintivamente así. Makerspace, hola comenzó
y ejecuta ese código. Pero notarás
que ese espacio
en realidad está registrado como un
espacio en la nueva línea. Entonces si no queremos eso
habrá que quitar
el espacio de aquí. Porque como dije antes, todo entre estas comillas
dobles se
imprimirá literal
o exactamente. Sin embargo, esta diagonal inversa es en realidad un carácter de
escape especial que leerá
al siguiente personaje después ella y hará algo
específico con él. Y había toda una lista de
secuencias
especiales de escape que puedes usar. Y vamos a repasar
una pareja como ejemplo. El primero es
el backslash n, que ya has visto
por crear una nueva línea. También puede hacer una diagonal
inversa, una diagonal inversa para
imprimir una diagonal inversa. Al igual que así. Otra
sería la comilla de la diagonal inversa. Para realmente
imprimir una comilla. En lugar de significar
el fin de nuestro tiempo. Ejecuto un código. Puedes ver las
comillas dobles justo ahí mismo. De todos modos, sigamos adelante y
eliminemos eso y solo pongamos la diagonal inversa n fondo
fue así en muy rápido, algo que puede ver en lugar de la diagonal inversa n es lo siguiente. Entonces después de una comilla doble, es posible que vea otro
operador de inserción seguido la palabra end con una l
minúscula, así. Y luego se asegura de que el
punto y coma aún esté al final. Si ejecutamos nuestro código. Esto también
bajará a una nueva línea. Y L es simplemente la
abreviatura de la línea N. Y puedes usar estos
indistintamente ya que hacen exactamente lo mismo, solo para recordar
que la diagonal inversa y necesita ir dentro
de tus cotizaciones. Y el extremo L necesita
estar solo después otro
operador de inserción, así. De todos modos, voy a seguir adelante y volver
a poner eso a la manera en que estaba. Ahora muy rápido. Algo que me gustaría mencionar es que
aunque llamé
a esto
la función principal, posible
que oigas a la gente decir método
principal como método de función a menudo
se usan indistintamente. Y puede que estés acostumbrado a que la
gente diga método, sobre todo si vienes de
otro lenguaje de programación. De todos modos, sigamos
adelante y recapitulemos muy rápido mientras
tenemos una pantalla. Entonces primero, tenemos esta declaración
include, que básicamente dice
que queremos usar código del archivo de encabezado
iostream. Entonces estamos diciendo
que vamos a estar usando el espacio de nombres std, que le dice a nuestro programa
que este objeto c out y sent viene
del namespace std. Y como dije, básicamente
se puede pensar en
un espacio de nombres como el apellido de
alguien. Y básicamente solo una manera especificar de dónde
viene algo o a qué
nos referimos. Cuando dijimos cuero cabelludo, saben que
queremos usar c out del espacio de nombres std. Bien, entonces estamos incluyendo
código de iostream. Estos dos objetos aquí
siendo C out y C n, provienen del nombre space std. Entonces tenemos nuestra función principal, o un método que es parte
del programa array C plus plus, ya que aquí es donde nuestro
programa comenzará y terminará. Y dentro de aquí,
solo tenemos un par de declaraciones. Tenemos este primero, que es el objeto CL
para imprimir Hello World. Tenemos este sin.gov, que básicamente está a la espera de
obtener la entrada del usuario. Y luego simplemente tenemos ahí
para que nuestro programa no cierre inmediatamente hasta que
presionemos la tecla Enter. Entonces tenemos éxito de
salida de retorno, que es lo mismo que
decir retorno cero ya nuestra función principal
necesita devolver un valor entero
o un número entero. Y normalmente
devolverá cero cuando
haya tenido éxito y su funcionamiento. Entonces esto y esto son
exactamente lo mismo. Y como dije,
C plus plus en realidad te permitirá simplemente
eliminar eso y escribir. Bien, de todos modos, eso
es todo para este video. Asegúrense de que
vean lo que tienen. Y no te preocupes si no recuerdas todo lo
que hablamos aquí. Lo único que
realmente quiero que recuerdes en el futuro ya el código R va a tener lugar dentro de la función principal. Y entonces cada programa C
plus plus tiene una función principal
porque aquí es donde comienza y termina
nuestro programa. Y a partir de
este punto en adelante, vamos a desglosar cada pequeña cosa paso a paso en su propio video individual para que puedas
seguirlo fácilmente, realmente comprender
lo que está pasando para que puedas usarlo
en tus propios programas. De todos modos, gracias por mirar, y te veré
en la siguiente.
5. Capítulo 2: Espacio blanco: En este video, vamos a estar hablando de espacios en blanco. Espacios en blanco y C
plus base sobre tus dos primeros
caracteres que se utilizan para formatear,
como espacios, tabulaciones en líneas
a veces nuevas. Y el
compilador C plus plus o lo que está tomando todo
este código y convirtiéndolo en binario para que la computadora
pueda
entenderlo generalmente
ignorará los espacios en blanco. No obstante, hay
algunas excepciones por las que vamos a pasar
en este video. Entonces, para darte un
ejemplo de espacios en blanco, puedes usar tantas líneas nuevas, tantas veces, tantos
espacios como quieras, general. Incluso
entre cosas. Entonces tu código
funcionará bien. ¿Bien? Entonces, básicamente, quieres
usar espacios en blanco para que
el código sea lo más legible
posible para ti. Y si vas a estar
trabajando con otros, querrás
que sea lo más legible
posible también
querrás
que sea lo más legible
posible para ellos. Entonces, ¿cuándo
no se ignoran los espacios en blanco? Bueno, cuando usamos
comillas para decirle a nuestro programa que queremos
que imprima exactamente lo que
hay entre ellas. Se supone que cuando ponemos en un espacio que queremos espacio. Entonces cuando pusimos aquí un espacio
entre hola y mundo, pero se presentó y nuestro programa. Como con cualquier otro espacio con el
que jugamos aquí. Como puedes ver aquí.
La otra vez es cuando tenemos un operador
que usa dos caracteres, como con nuestro
operador de inserción aquí. Si tuvieras que poner
espacios en el medio, que ya no
entendería qué era esto. Y luego realmente
solo hay otra vez donde el compilador
no ignorará los espacios en blanco. Y es entonces cuando tienes una
palabra clave como return aquí, no
puedes separarla así. Y ahí lo tienes. Ya conoces los espacios en blanco como
en la programación C plus plus. Básicamente, puedes usar
tantas líneas nuevas, tantos espacios y
tantas pestañas como quieras para
que tu código sea lo más legible
posible. Con las excepciones siendo, no poder
romper palabras clave. Cualquier espacio donde le
digas a tu programa que quieres que imprima exactamente lo que le dices. Y no se pueden romper operadores que tengan dos
o más personajes. De todos modos. Gracias por mirar, y te
veré en la siguiente.
6. Capítulo 2: escritura para la consola: En este video, solo
vamos a volver atrás y
repasar cómo imprimir
textos en la consola. Entonces la forma principal que vas a proteger a la consola
y C plus, además, como con un objeto C, seguido del operador de
inserción. Solo recuerda que si por alguna
razón tu código no aceptará esto como porque necesitas
incluir el iostream. Y querrás dejar
tu código ahora que
estás usando el espacio de nombres std. De lo contrario, se puede
decir explícitamente que es desde
el espacio de nombres std, escribiendo S, T, D dos puntos, dos puntos, seguido de C out. Pero por ahora, sólo
voy a seguir adelante
y quitar eso. Como ya hemos
dicho que estamos usando ese espacio de nombres aquí mismo. Y personalmente encuentro esto
mucho más fácil de leerlo. Así que solo voy a
limpiar esto un poco para que
sepamos todo nuestro código aquí mismo. Entonces me gustaría que
ustedes lo siguieran. Y básicamente
vamos a quitar esta línea y escribir textos a la
consola desde cero. Entonces saldremos y nos
desharemos de eso. Y cada vez que quieras
escribir textos en la consola, solo
vas a decir
C out en minúsculas. Sí, la capitalización sí
importa a la hora de programar. Seguido por el operador de
inserción. Entonces diremos C out space, el operador de inserción
puso en otro espacio. Y luego entre comillas, vamos a escribir lo que
queramos decir. Entonces podría decir, escucha muchos textos de primer nombre y siéntete libre de poner ahí lo
que quieras. Y luego después de la
última comilla, simplemente
vas a ingresar
sentencia con punto y coma. Y luego ejecutamos nuestro código. Dirán, esta es
mi primera línea de texto y nuestro cursor se quedará
ahí al final. Porque no lo
pusimos si queríamos que
bajara a una nueva línea. Bien, entonces ahí tienes. Así es como puedes imprimir una sola línea de
texto en la consola. Pero, ¿y si quisieras
imprimir varias líneas? Bueno, tienes un
par de opciones. Siempre puedes
simplemente decir backslash n. Y luego
dices algo así como,
Esta es mi segunda línea. Y cuando tu programa, y ahí vas. Y puedes hacer esto
tantas veces como quieras. Ahora bien, aunque
podríamos seguir escribiendo diagonal invertida n seguida de cualquier texto
extra que queramos escribir. Esto eventualmente se pondrá bastante desordenado y hará que nuestro
código sea difícil de leer. Entonces sí tenemos otra opción. Sigamos adelante y eliminemos
este código extra aquí. Entonces copiemos y peguemos
esta línea abajo. Y vamos a decir algo así como, Esta es mi segunda línea. Como dije, siéntete libre tirar ahí lo
que quieras. Y luego seguiremos adelante
y ejecutaremos nuestro código. Y como pueden ver, solo dice que esta es
mi primera línea de texto. Entonces esta es mi segunda línea de texto sin espacios,
sin puntuación. No está en una nueva línea. Nada. Eso es porque en la programación, tu código va a hacer
exactamente lo que le digas. Y no va a hacer nada
extra para ayudarte. Entonces, básicamente, si quieres que
algo suceda, tienes que hacerlo realidad. Entonces, si queremos
limpiar esto y hacerlo llegar
a cualquier línea, tener alguna puntuación
ahí, cosas así. Tendríamos
que escribirlo manualmente. Entonces puedo decir que esta es
mi primera línea de texto. Periodo. Barra diagonal inversa n
creará una nueva línea. Y entonces se puede poner un punto. Creo que esa también. Cuando vuelva a codificar
y ahí va usted. Probablemente un poco más cerca de
lo que esperabas antes. Y si quieres una línea en blanco entre
estas dos líneas, bueno,
simplemente podrías simplemente lanzar otra diagonal invertida n
al principio aquí. Y ahí tienes.
Tienes una nueva línea. Y en realidad puedes
seguir haciendo eso para obtener más
líneas nuevas en el medio. En caso de que elija. De todos modos, voy a seguir
adelante y quitar eso. Y si recuerdas
nuestra otra opción, en vez de decir barras invertida n y algo que también puedes ver frecuentemente sería
después de comillas dobles para ponerlo en otro operador de
inserción. Insight end l, todo minúscula. Y antes del punto y coma. Entonces si volvemos a ejecutar un programa, se
puede ver que
funciona bien. Si recuerdas,
te dije que los espacios en blanco generalmente
podrían ser
ignorados por C plus plus. Entonces, si tuviera que volver
atrás y quitar todos los espacios entre
C a su operador, las comillas aquí. Y al final aquí,
voy a programar. Seguiría funcionando bien. Sin embargo, simplemente les dije que
pusieran en un espacio, ya que escribimos esto
para legibilidad, ya que algo que siempre
querrán asegurarse de hacer a hora de programar es hacer su código como legible
como sea posible. Porque aunque
puedes construir una lectura y entenderla
hoy y puedes pensar que cualquier
otra persona que la mire puede llegar a
entenderla también. Quieres
asegurarte de que puedas entender eso mañana, dentro de
una semana, un mes, o incluso años más
adelante sin problema. Y eso es algo que quiero que
tengas en mente y
practiques a medida que continuamos a
lo largo de este curso. De todos modos, eso
es más o menos para imprimir texto. Pero voy a
mostrarte un último truco. Entonces así como podemos lanzar otro
operador de inserción para lanzar en esta línea N aquí para
crear una nueva línea. También podemos simplemente poner en
los textos ahí también. Entonces, en lugar de crear una declaración C out
completamente nueva, en realidad solo
puede copiar este texto junto con las citas. Deshazte de esta línea por completo. Y después de este operador de
inserción extra, solo
podemos pegar en nuestra línea. Y en realidad voy
a llevar esto a
una línea separada solo para que todo
quede dentro de la pantalla aquí. Así como así. Y esto va a funcionar bien. E incluso podríamos
lanzar nuestra línea M aquí junto con otro operador de
inserción en el medio. Y todo esto
correrá como antes. Vete tú. Así que cada vez que uses el objeto CLI para imprimir
texto en la pantalla, me voy a asegurar de que
incluyas el iostream, es que como eran el
objeto viene de. Y cuando pase el mouse sobre él, se
puede ver que viene
del espacio de nombres std, que dijimos aquí mismo. Entonces siempre lo seguimos
con el operador de inserción, que va a
insertar lo que ponemos después de él en nuestro programa. Entonces en cualquier momento que quieras
agregar más de una cosa, simplemente la sigues con
otro operador de inserción. Entonces dijimos C fuera. Entonces dijimos que queremos
poner exactamente lo que hay entre estas
comillas dobles a la pantalla. Por lo que dijo Esta es nuestra
primera línea de texto. Poner otro operador
de inserción. Poner una línea final aquí para significar que queremos
bajar a una nueva línea. Y si recuerdas, también
codificamos solo ponemos la diagonal inversa n, así. Entonces porque estamos
agregando algo más, nos ponemos otro operador de
inserción. Y luego ponemos en
otra línea literal de textos que queremos que
se imprima en la consola, significada nuevamente por
comillas dobles. Entonces, por último, al final de esta declaración O
instrucción para nuestro programa, simplemente
ponemos un punto y coma. De todos modos, usaremos el objeto CL muchas veces a
lo largo de este curso. Así que no te preocupes si no lo
tienes todo abajo ahora, vas a estar recibiendo un
montón de práctica práctica. Y sólo para
recapitular rápidamente la sintaxis o las reglas sobre
cómo escribir textos en la consola. Simplemente vas a decir Cl, seguido del operador de
inserción, seguido de comillas dobles,
y un punto y coma al final. Y dentro de esas citas es donde va a ir tu texto
. E incluso no puedes poner
nada ahí en absoluto y va a funcionar bien. Así que adelante y
juega un poco con eso. Vuelve a ver el video
si es necesario, y te veré
en el siguiente.
7. Capítulo 2 (Hello World): comentarios: En este video,
vamos a estar hablando comentarios en programación.
Muy rápido. adelante y eliminemos
todo este código extra fuera de su estado de cuenta de Cintiq
y nuestro estado de cuenta de devolución. Entonces cuáles son nuestros comentarios
y programación, bueno, básicamente son
justo lo que piensas. Un comentario son básicamente
textos que escribes
tú mismo para que tu
código sea más legible. Así que muy rápido, vamos a seguir adelante
y poner de nuevo en nuestros textos. Estamos escribiendo hola
mundo a la consola. Entonces diremos C out, operador de
inserción. Y luego en comillas
ven a decir hola mundo. Y no olvides el
punto y coma al final. Entonces ya hemos trabajado con este programa algunas veces ahora. Ya sabemos lo que
hace. Cuando ejecutamos nuestro código. Simplemente va a decir
Hello World en una sola línea. Pero y si quisiéramos
agregar en unas pocas líneas propias para que este
código sea más legible. Ahora, ahora mismo, me doy cuenta de que
nuestro programa es bastante pequeño y básico y esto
no es súper necesario. Pero a medida que nos acercamos más adelante y comenzamos a trabajar con programas
más complejos, definitivamente
querrás
agregar tantos comentarios como sea posible para que tu código
sea lo más legible posible. Porque aunque puedas
saber lo que dice hoy, quieres poder mirar
estos años a partir de ahora cuando
no recuerdas haber escrito nada de eso y aún así poder leerlo. No hay problema. Entonces, ¿cómo escribimos un comentario? En cualquier línea de nuestro código aquí, podemos poner dos barras
hacia adelante y todo después de esas
dos barras hacia adelante será ignorado por completo. Cuando ejecutamos nuestro programa. Pones algún texto como
este y ejecutas nuestro código. Y sólo va
a decir HelloWorld, tal como lo hice antes. En este comentario,
terminará automáticamente una vez que bajemos
a una nueva línea. Ahora, hay una manera de hacer comentarios que se extenderán
a través de múltiples líneas. Entonces, si escribes slash hacia adelante seguido del símbolo real, todo lo que haya pasado ese
punto será un comentario. Como puedes ver, está comentado
todo más allá de eso. El camino a n, Eso es lo que es otro símbolo de Astro
seguido de nuevo por el slash delantero. Entonces como pueden ver, eso tanto como quiero
aquí, pero una nueva línea. Y todo va a funcionar igual
que lo hice antes. Ahí vas. De todos modos, voy a
seguir adelante y remover eso para que lo tengas. Ya sabes cómo
agregar comentarios a tu código para que
sea más legible. Pero hay un caso de
uso más para los comentarios, lo cual es increíblemente útil, que voy a repasar con ustedes ahora. Entonces, debido a que cualquier cosa dentro de
un comentario será ignorada, en realidad
puedes salir
una sola o varias líneas de código para probar tu
programa sin ellas. Esto puede ser increíblemente útil cuando se trata de
averiguar qué está causando un problema o simplemente para ver cómo
se ejecuta tu código sin algo. Entonces, por ejemplo,
sigamos adelante y
copiemos y peguemos esta línea de
HelloWorld unas cuantas veces. Así como así. Y comentaremos
un par de ellos. Así podría ejecutar mi código
tal como lo hacía antes. Pero sólo va a
imprimir Hello World tres veces porque esta cuarta
de aquí está comentada. Ahora bien, obviamente este no es un gran ejemplo de
cuándo usar esto, pero vamos a estar haciendo esto a
lo largo del curso. Por lo tanto, obtendrá algo
de experiencia práctica al usar esto a su favor. Pero solo quería hacerte consciente de eso como sea posible y
hacerte consciente de todos los casos de
uso para comentarios. De todos modos, eso
es prácticamente todo para este video muy rápido. Sólo quiero mencionar eso a
partir de este punto, cuando estaba iniciando
cada video con un borrón y cuenta nueva que
se ve así. Y vamos a estar haciendo eso a partir de este punto a menos que se indique
lo contrario. Entonces gracias por mirar y te
veré en la siguiente.
8. Capítulo 3 (variables): introducción a las variables: En este video, vamos a
estar hablando de variables. Una variable es básicamente solo
un contenedor para almacenar valores de
datos o un nombre dado
a una ubicación de memoria. Hasta el momento hemos
aprendido a imprimir algo al usuario. Pero, ¿y si realmente
quisiéramos recuperar la información? ¿O qué pasaría si quisiéramos información a la
que pudiéramos referirnos, acceder y manipular posteriormente? Bueno, ahí es donde entran en juego
las variables. Entonces, ¿cómo creamos una variable? Bueno, repasemos eso. Entonces la sintaxis para
crear una variable, o en las reglas sobre cómo crear una variable es la siguiente. Primero vas a
comenzar con el tipo de datos. Y esto representa
el tipo de datos que se quiere almacenar
dentro de la variable. Es posible que desee
almacenar números, palabras, caracteres, o un valor verdadero o
falso, etcétera. Y vamos a repasar
los diferentes tipos de datos en los próximos videos. Después del tipo de datos,
vas a poner el nombre de la variable. Ahora, al nombrar una variable, quieres
asegurarte de que tu nombre sea descriptivo de
lo que estás almacenando. Entonces, por ejemplo, digamos que
estabas haciendo un juego de pinball. Querías guardar
la partitura actual. En lugar de simplemente llamar a
este número uno, posible que
queramos
llamarlo puntaje actual. Entonces podríamos querer
otra variable para almacenar la
puntuación alta, por ejemplo. Y no quisiéramos
nombrarlos en consecuencia. Ahora bien, al nombrar una variable, hay algunas convenciones de
nomenclatura comunes que te
recomendaría usar ya que las
verás con bastante frecuencia. Y sobre todo si estás
trabajando con otras personas, es probable que
esto sea lo
que ellos también estén haciendo. Entonces generalmente, al
nombrar una variable, siempre comenzará
con una letra minúscula. Además, recomendaría
escribirlo de manera CamelCase,
es
decir, que la primera letra va a ser minúscula. No va a haber
espacios ni signos de puntuación. Y el inicio de cada palabra posterior
después de la primera, comenzaremos con
una letra mayúscula. La otra opción, que
verás frecuentemente para nombrar variables
es caso serpiente garantiza a quienes las separan por solo tener una letra
mayúscula
al comienzo de cada palabra
posterior a la 1ra, solo
los separarás con un guión bajo. Y entonces puedes dejar
la primera letra minúscula
así. Ahora para lo que resta
de este curso, voy a estar escribiendo
nuestras variables con una primera letra minúscula,
y luego con la mayúscula Kimball. Debido a que la z
es la más frecuente y me resulta más
fácil de leer personalmente. Entonces voy a
seguir adelante y escribir nombre de
variable, así. Y les estaré mostrando
otras
convenciones de nomenclatura cuando se trata otras cosas
a medida que
continuamos a lo largo del curso. Entonces, para declarar una variable
o básicamente declarar que vas
a necesitar una variable. En este programa, vamos
a comenzar con un tipo de datos, seguido del nombre, y
luego un punto y coma al final. Y entonces tienes que
has creado una variable. Como dije en los
próximos videos, vamos a
repasar los diferentes tipos de
datos y cómo
crearlos específicamente
y sus casos de uso. Ahora, antes de que realmente usemos
esta variable e
ingresemos código, necesitamos darle
un valor inicial. Hay un par
de formas de hacer esto. Entonces, antes que nada, digamos que esta variable
estaba almacenando un número entero. Bien, entonces tenemos nuestro tipo de datos
para almacenar un número entero. Y luego
llamemos a esta partitura. Por ejemplo. Digamos que esto fue una partitura y un partido de futbol
o algo así. Bueno, podríamos establecer su
valor inicial igual a 0, así. Esto es perfectamente válido y ahora hemos declarado y le damos a nuestra variable un valor inicial para que podamos
usarla en el futuro. Nunca querrías usar una
variable antes de darle un valor inicial para que
termines con varios errores. Otra opción
sería declararlo ahora, como ya lo tenemos, y
darle un valor inicial posteriormente. Entonces déjame mostrarte
cómo se ve eso. Así que después de haber declarado
una variable aquí arriba, podemos hacer referencia a ella y darle un valor inicial
más adelante en nuestro código. Entonces, ¿cómo hacemos eso?
Primero, solo decimos el nombre de la variable a la
que queremos hacer referencia. Entonces podemos decir alcance, entonces le
damos el
valor que queremos. Entonces podría decir que es igual a cinco. Por ejemplo. Esto también
funcionaría. Siempre y cuando demos un valor a nuestras
variables antes usarlas más adelante, todos
estamos bien para ir. Ahora, hay otra
forma de declarar e inicializar variables que te
voy a mostrar ahora mismo. Pero en lo personal, en
realidad no lo recomendaría. Pero en caso de que lo veas, sí
quiero hacerte saber
que está ahí fuera. Y quién sabe, tal
vez decidas usarlo en un proyecto futuro. Entonces lo que voy a estar
mostrándote es cómo declarar e inicializar múltiples
variables en la misma línea. Entonces podemos hacer decir el tipo de
datos
seguido de los nombres de las variables que quieras de
ese mismo tipo de datos. Entonces, por ejemplo,
digamos que quería crear múltiples variables
para almacenar números. Lo pondría en el tipo de datos
adecuado, seguido del nombre
de mi primera variable. Entonces sólo voy a decir var uno, por ejemplo,
separado por una coma. Y entonces puedo hacer tantas
variables como me gustaría. Puedo hacer si R1, R2, R3, así sucesivamente. Ahora estos pueden tener
el nombre que quieras. Yo sólo estaba poniendo 123
como ejemplo básico. Ahora bien, aunque esto declara múltiples variables
del mismo tipo de datos, también
puedes darle a cada una un valor
inicial si lo deseas. Entonces después de cualquiera de ellos, puedo decir iguales. Y luego, y podría
hacer esto por cada uno. Podría hacerlo solo por uno
o dos de ellos, etcétera. Entonces esta es una forma de
declarar e inicializar múltiples variables
en la
misma línea siempre que tengan
el mismo tipo de datos. Y aún así
siempre podrías
inicializarlos más tarde,
como hicimos anteriormente. Entonces por ejemplo, aquí abajo, puedo decir var tres equivale a cuatro. Ahora, lo habría declarado aquí e
inicializarlo aquí abajo. Y esto sería
perfectamente válido. De todos modos, eso es todo
para este video. El siguiente video,
en realidad vamos a
empezar a trabajar con nuestro primer tipo de datos
siendo enteros. Así que gracias por mirar, y te veré
en la siguiente.
9. Capítulo 3 (variables): intérpretes: En este video,
vamos a repasar nuestro primer tipo de
datos variable, siendo enteros. Los enteros se utilizan para
almacenar números enteros, van a repasar los tipos de datos
que pueden almacenar números con puntos
decimales o números de
coma flotante más adelante. Muy rápido, los enteros no son el único tipo de datos para
almacenar números enteros. Pero debido a
que es la que más se usa es la que hoy vamos
a repasar. Y no te preocupes si alguna vez necesitaste usar uno
de los otros. Se usan
exactamente de la misma manera. La única diferencia es el rango de valores en los que pueden almacenar y la cantidad de
memoria y que ocupan. Entonces, antes que nada, hay dos tipos
diferentes de enteros. Básicamente la única diferencia
entre asignado y un entero
sin signo
es que los asignados son capaces de ir por debajo de 0. Para que puedan almacenar cualquier cosa desde este valor negativo aquí
hasta este positivo aquí. Y un entero sin signo no tiene permiso
para ir por debajo de 0. Pero por eso, puede almacenarlo dos veces el valor positivo y que existe la única
diferencia entre los dos. Entonces, ¿cuándo querrías
usar un entero sin signo? Bueno, para mí personalmente, si sé que mi entero
no necesita ir por debajo de 0, siempre
voy
a usar un
entero sin signo para que tenga la mayor cantidad
máxima posible de positivo números
disponibles para mí sin usar ninguna memoria extra mediante el
uso de un tipo de datos diferente. Entonces, por ejemplo,
digamos que hiciste un programa para hacer un
seguimiento de digamos, un partido de fútbol y ninguno de los
equipos posiblemente pueda ir por debajo de 0, bien
podrías
usar un entero sin signo. Así que sigamos adelante y creamos nuestra primera variable
del tipo de datos entero. Entonces, si recuerdas, la sintaxis para crear una
variable es la siguiente. Primero, vamos a
comenzar con el tipo de datos. En este caso, vamos
a decir en todas minúsculas para afirmar que queremos crear un entero seguido del nombre. Para este ejemplo, sigamos
adelante y digamos edad, y luego un punto y coma al final. Y ahí la tienes
con declarada nuestra primera variable entera. Ahora, antes de usar
esta variable, necesitamos darle
un valor inicial. Además, este es un buen
momento para hacerle saber que todo nuestro código se lee de arriba a abajo dentro
de nuestra función principal aquí. Por lo que no puedo inicializar la variable edad antes de
la declaración de la misma. Entonces por ejemplo, si
aquí arriba traté de decir que la edad es igual a 0 con punto y
coma al final. No sabría qué es la edad. Porque como dije, se
lee de arriba a abajo. Pero si tomamos eso
y lo ponemos aquí abajo, va a funcionar bien. Así que solo recuerda que el código antiguo
se lee de arriba a abajo. Entonces en esta primera línea, declaramos una variable. Y la segunda línea, inicializamos una variable. Si recuerdas,
podemos hacer ambas exactamente en la misma línea. Entonces voy a seguir adelante y
borrar esos rápido. Y vamos a decir que la edad es igual a 0 y luego un
punto y coma al final. Ahora bien, ¿y si
quisiéramos imprimir esta variable al usuario? Bueno, básicamente lo
hacemos de la misma manera que
imprimimos textos al usuario. Entonces aquí abajo,
vamos a decir C0. Y luego el operador de inserción, seguido del nombre
de nuestra variable. Recuerda en cualquier momento que queramos
acceder o editar una variable, necesitamos el nombre de un usuario. Entonces vamos a decir CL para imprimir
algo al usuario. Entonces sólo vamos a escribir H. Y la capitalización,
por cierto, tiene
que ser exactamente la
misma que la de aquí arriba. Entonces si, por ejemplo, cambié esto a una a mayúscula, ya no se reconoce
esta variable. ¿Bien? Entonces como dije,
su capitalización
en la programación es
muy importante. Entonces, si quisiéramos
capitalizar aquí, y también necesitamos ser
un capital aquí abajo. Ahora, sigamos adelante
y ejecutemos nuestro programa. Y como pueden ver,
imprime 0 en la consola. También podemos editar el valor de una variable después de que
haya sido declarada. Entonces, por ejemplo, aquí abajo, podríamos decir que la edad es igual a tres. Ahora, podríamos haberlo
hecho así, donde declaramos nuestra
variable y luego inicializamos aquí y luego la
imprimimos aquí abajo. Pero solo
te estoy mostrando que después de dar una variable
y un valor inicial, puedes editarlo más adelante. Entonces dijimos que queríamos crear
un entero llamado la edad. Lo establecemos igual a 0. Después volvimos a hacer referencia a H. Y así queremos
fijarlo igual a tres. Después lo imprimimos
en la consola. Entonces ejecuto un código. Y ahí tienes. Imprimimos tres. Ahora bien, si echamos un
vistazo a nuestra variable aquí, no es muy descriptivo. Al ver es que solo imprime
el valor real de H aquí. Entonces, ¿por qué no tiramos
algunos textos defectos que. Entonces aquí atrás, escribimos CL
después del operador de inserción. Sigamos adelante y ponlo entre comillas,
seguido de otro operador de
inserción antes de nuestro nombre de variable aquí. Entonces dentro de estas citas, vamos a decir que tu edad es el espacio de dos puntos, así como esto. Y nuevamente, ahora es mucho
más fácil de leer. Entonces esta es tu edad, son tres. Ahora, una última cosa
quiero repasar
contigo antes de pasar
al siguiente video. Es eso porque nuestro código se
lee de arriba a abajo. Si copiamos
aquí el esquema y lo ponemos después de nuestra declaración
de una variable, así. De hecho, podemos imprimir H dos veces con los dos valores
diferentes. Así vamos a crear una variable
entera llamada age, ponerla igual a 0. Y luego
lo imprimiremos aquí abajo. Después lo cambiaremos a tres
e imprimiremos de nuevo. Cuando nuestro programa, puedes ver
cómo se ve eso aquí. Y ahí tienes. El
primero imprime en 0, y el segundo
imprime tres. Y recuerda si
queremos seguir adelante y arreglarlo para que se vea
un poco más limpio. Al inicio de
este de aquí abajo, simplemente
podemos decir código de barras reversas, barras traseras n y código R. Crea una línea en blanco para nosotros. Y ahí lo tienes. Ya sabes cómo crear
y trabajar con enteros. Y no te preocupes, vamos a estar usando estos mucho a
lo largo del curso. Así que vas a tener un montón
de práctica práctica. Además, la forma en que la
tenemos aquí arriba, donde declaramos e
inicializamos una variable en la misma línea
generalmente se considera buena práctica cuando
puedes hacerlo. La razón de esto es
porque no quieres
usar una variable antes de
darle un valor inicial. Cuando lo
declaras, simplemente le das un valor inicial de inmediato. Evitarás cualquier problema serio. Y por último, antes
de olvidar esto aquí se considera un entero con signo. Ese es el tipo
entero predeterminado. Si quieres, incluso
puedes
definir explícitamente esto como un
entero con signo
diciendo espacio con signo y
luego terminar así. Pero esto, y esto es exactamente lo mismo. Si quieres crear
un entero sin signo, simplemente
puedes decir
sin signo, así. De todos modos, eso es todo
por este video. Gracias por mirar, y te
veré en la siguiente.
10. Capítulo 3 (variables): puntos flotantes: En este video,
vamos a estar hablando tipos de
coma flotante o
números con decimales. Ahora no vamos a repasar cada tipo de
punto flotante en C plus plus. Pero vamos a estar
repasando los dos principales. Y te diré cómo
puedes tomar el conocimiento
que obtienes de este video y aplicarlo también a otros
tipos de coma flotante. Entonces, sigamos adelante
y echemos un vistazo a estos dos
tipos principales de coma flotante en C plus, plus. El primero que
tenemos aquí es un flotador. Y un flotador puede contener aproximadamente
siete dígitos significativos. Ahora bien, si no sabes qué son los dígitos
significativos y sí planeas trabajar
con tipos de punto flotante. Recomiendo encarecidamente
buscarlo. No obstante, para
resumir brevemente lo que son. Los dígitos significativos son cada uno de los dígitos de un número
que se utilizan para
expresarlo con el
grado de precisión requerido a partir del
primer dígito distinto de cero. Ahora, ojalá eso tuviera sentido. Si no, no te preocupes por ello, siempre
puedes
buscarlo en otro
momento y no
va a afectar tu capacidad de seguir adelante en este curso son realmente
decodificar en general. Sin embargo, dicho eso, si planeas trabajar con datos, eso tiene que ser
increíblemente preciso, cuando planeas trabajar con punto decimal y valores. Recomiendo encarecidamente que lo
busques para que sepas lo que cada uno de los tipos de punto
flotante puede almacenar con precisión. Entonces nuestro segundo
aquí es un doble, que puede almacenar aproximadamente
15 dígitos significativos. Y la razón por la que se le llama
doble es porque en realidad ocupa el doble
de espacio en la memoria. Y la precisión de
un doble en comparación con un flotador también es aproximadamente el doble. De todos modos, sigamos adelante y echemos
un vistazo a cómo podemos crear tipos de punto
flotante de r. Así que al igual que con
cualquier otra variable, vamos a comenzar
con el tipo de datos. Entonces para nuestro primero aquí, vamos a decir flotar,
todos en minúsculas así. Entonces diremos algo así
como la altura para el nombre. Entonces pongamos esto igual
a algo así como 4.3. Y luego sólo pondremos
punto y coma al final. Ahora bien, una cosa que sí
quiero mostrarles aquí es que si paso el mouse
sobre este valor, pueden
ver que cree
este valor aquí como un doble. Y eso se debe a que el tipo de datos de punto
flotante predeterminado en C plus plus es un doble. Entonces, si en realidad no estás
trabajando con un double, necesitas decirle explícitamente
al compilador que
puedes hacerlo agregando un sufijo específico
dependiendo del tipo de punto flotante con el
que quieras trabajar. Y para una carroza
que va a ser una minúscula, así como así. Ahora bien, si paso el ratón sobre esto, se
puede ver
que ahora es un flotador. Bien, así que si no estás
trabajando con un doble, necesitas agregar un sufijo basado en el
tipo de punto flotante con el que estás trabajando. Y puede encontrar fácilmente toda
esa información en línea para los diferentes tipos de punto
flotante si elige ingresar
a ellos. Pero como dije,
porque la mayoría de estos serán los dos
tipos que usarás. Entonces también sigamos adelante
y creamos un doble. Entonces por debajo de esto, vamos a
decir doble tipo de datos. Y una vez más, eso
fue todo minúscula. Entonces para un nombre, pongamos esto igual a 5.6,
algo así. Porque el tipo de
datos predeterminado para números de punto
flotante es un doble. No necesitamos agregar un sufijo. Ahora, solo para hacérselo saber, la sintaxis para crear otros tipos de coma flotante
va a ser exactamente la
misma que la de aquí. Así como lo es con
todas las demás variables. Vamos a comenzar
con tu tipo de datos, seguido del nombre
de tu variable. Y recuerden, solo
necesitamos estas dos cosas
para declararlo. Y luego también podemos
asignarlo en la misma línea, como hicimos aquí
agregando en este signo igual o lo que algunos de ustedes pueden conocer
como el operador de asignación. Y voy a estar usando estas
palabras indistintamente. Sólo debes saber que
es lo mismo, seguido de un valor aquí. Entonces, como estaba diciendo, podríamos haber declarado
nuestras variables así. Acceda a ellos más tarde
usando solo el nombre. Y luego ponerlos iguales a algo más adelante en nuestro código. Así. Eso también habría
funcionado bien. De todos modos, voy a
seguir adelante y deshacer eso. Y una cosa más que
quiero
mencionar brevemente es que a diferencia de los tipos de datos de número
entero, los tipos coma flotante no pueden
ser firmados ni desfirmados. Todos ellos son simplemente asignados, lo que significa que pueden especie de números
positivos y negativos. A continuación, sigamos adelante e imprimimos
ambas variables. Entonces aquí abajo,
vamos a decir CL. Después agregaremos otro operador de
inserción, y diremos inline. No agregues
aquí otro operador de
inserción y saluda a. Así como así. Y así ahora hemos
creado un flotador llamado height y le hemos dado
un valor de 4.3. Después agregamos el sufijo
para especificar que
se trataba de otro
tipo de punto flotante distinto de un doble, que es el predeterminado. Luego creamos un doble así llamado altura dos y lo
pusimos igual a 5.6. Y una vez más, un
doble no come un sufijo porque un doble es el tipo de datos predeterminado para números de
coma flotante
y/o números con un decimal. Entonces dijimos que queremos
imprimir algo. Y lo que sea
que
queramos imprimir, queríamos imprimir
la altura siendo 4.3. Por cierto, esta f no
se imprimirá. Esto es solo un sufijo para que el compilador
diga explícitamente cuál es este tipo de datos. Entonces dijimos que queríamos bajar
a una nueva línea. Entonces agregamos en esta línea aquí, y en nuestra nueva línea la
imprimimos en altura a 5.6. Entonces, si ejecutamos un código, se
puede ver que todo
está funcionando bien. Una vez más, tenga en cuenta
que los sufijos para los tipos de
punto flotante
no se imprimen. Entonces ahí tienes. Así es como se puede crear y trabajar con tipos de punto flotante. Y también verás
más ejemplos de esto más adelante en
el curso. De todos modos, eso es todo
para este video. Gracias por mirar, y te
veré en la siguiente.
11. Capítulo 3 (variables): booleanos: En este episodio, vamos a
estar hablando de booleanos, también conocidos como
toros, ojo de toro, o un tipo de datos para almacenar valores
verdaderos o falsos, también conocidos como on o
off o yes o no, o one o 0. Entonces, sigamos adelante y
creemos un ejemplo de uno. Por ejemplo,
digamos que estamos creando un programa para una luz. Es posible que queramos almacenar
una variable para saber si esta luz está encendida o apagada. Entonces, ¿cómo hacemos esto? Bueno, igual que con
cualquier otra variable, vamos a empezar
con su tipo de datos. En este caso, vamos
a decir Bool, todo minúscula. Entonces lo vamos a
seguir con el nombre. Nombrará esto
algo así como es. Entonces seguiremos adelante y
pondremos esto igual a falso. Por cierto, sólo
como referencia aquí arriba. Si algo es cierto en sí, quiera
llamarlo es lo
mismo como
quiera
llamarlo es lo
mismo que establecerlo igual a uno, están diciendo que el
valor de la misma es uno. Y si algo es falso, ahora te tengo a ti. Es lo mismo que decir que es 0. Entonces esto aquí hay una
bola siendo está en set a false como lo mismo que decir
como on es 0. Y esto funcionará de cualquier manera. De todos modos, voy a
seguir adelante y ponernos de vuelta. Asegúrese de que la palabra false
en todas las minúsculas también. De todos modos, sigamos adelante y pongamos esto a la consola
y veamos qué pasa. Entonces digamos que algo
como CL está encendido. Impresionante. Los cantantes estarán
imprimiendo cosas un tiempo a la consola a
lo largo del curso. Sólo voy a estar diciendo Cl, seguido de lo que
es vamos a estar imprimiendo solo para que las cosas
sigan y el diálogo sea un poco más limpio. De todos modos, sigamos adelante
y ejecutemos nuestro programa. Verás que
en realidad imprime 0. Porque como dije,
falso es lo mismo que 0 en verdad como lo mismo que uno. Por cierto,
sólo puede contener uno o 0. O puedes escribir explícitamente false o true en todas las minúsculas, pero no puede contener otros
números fuera de eso. Ahora, en realidad hay
una manera de que se
imprima en falso en lugar de solo 0. Y te lo voy a mostrar
aquí en un minuto. Muy rápido. Voy a seguir adelante y
cambiar esto a verdad. Y cuando vuelva a programar, se
puede ver
que imprime uno. Ahora bien, lo que quiero que
hagan es en realidad copiar el
esquema de RSC aquí con punto y coma. Y luego abajo de eso,
vamos a decir CO. Entonces vamos
a decir alfa genial. Después un punto y coma al final. Así como así. Una vez que escribimos esto,
en realidad estamos habilitando algo. Entonces básicamente, una vez que
esto está habilitado
, cada vez que
imprimimos un valor
alcista, en realidad va a
decir verdadero o falso. Entonces si pegamos nuestra línea, acabamos de copiar abajo aquí abajo, ahora
debería decir una
porque nuestro valor es cierto. Y luego después de que
encendamos el carrete Alpha aquí, dirá
verdad. Y asegurémonos de que
esto esté en una nueva línea, en nuestra primera línea
aquí al final. Y sigamos adelante y agreguemos
otro operador de inserción. Y vamos a decir final de
línea así, o terminar l, debería decir. Cuando ejecutamos nuestro programa. Y ahí tienes. Ahora dice uno y luego cierto. Y esto sería lo mismo si seguimos adelante
y cambiamos esto a false y ejecutamos un programa, se ejecutará exactamente de la misma manera. ¿Bien? Y lo que
vamos a hacer es copiar de nuevo esta línea superior
con nuestro enésimo enlace aquí. Después eliminaremos este
inferior y los pegaremos, este nuevo, así. Entonces vamos a seguir
adelante y pegar un par de veces más. Y luego por debajo de eso dirá CL, no, Alfa, todo en minúsculas. Así como así. Después seguiremos adelante y pegaremos
contorno unas cuantas veces más. Entonces cuando habilitamos
para alfa aquí, en lugar de imprimir valores
booleanos como 0 o uno, dirá verdadero o falso. Y luego cuando lo deshabilitamos
diciendo No Bull Alpha, que era el predeterminado, va a
volver a decir 000. Entonces solo voy a tener
un par de comentarios aquí. Y ejecuta nuestro código. Como puedes ver, 0
la primera vez, luego imprimirlo
falso tres veces, y luego 03 veces. Entonces tenemos una línea en blanco porque aquí
bajamos una línea. Por cierto, el
spool Alpha en no, alpha es parte
del espacio de nombres std. Si quisieras
decir explícitamente que, una vez más, podrías decir std
colon colon
seguido de alfa también es aceptable. Pero como
ya tenemos aquí arriba y que estamos usando
ese espacio de nombres, no
necesitamos redefinir de
dónde
viene esto ni decir explícitamente de
dónde viene esto. Nuevamente, una última cosa
para concluir el video. Algo que puedes hacer
en vez de simplemente decir que vas a usar este espacio de
nombres en general, que en este punto
estamos usando para CL, N line y vamos a Alpha. Puedes decir explícitamente qué cosas vas a
usar desde ese espacio de nombres. Entonces podría decir usando colon std, colon en línea con un punto y coma
al final, así. Y entonces podrías
hacer lo mismo por CL y tirar Alpha y
portátiles celular. Pero voy a seguir
adelante y
volver a poner eso como era. De todas formas. Entonces ya sabes cómo usar
y crear variables booleanas, y las usaremos más lo largo del curso también. Eso es todo para este video.
Gracias por mirar, y te veré
en la siguiente.
12. 11: En este video,
vamos a estar
hablando del tipo de datos char. Ahora char es la abreviatura de carácter
y, por lo tanto, el tipo de datos se usa para
almacenar un solo carácter. El rango para este
tipo de datos es negativo 120 2027, firmado, o cero a 255 sin signo. Y puedes hacer una versión con signo
y sin signo la misma manera que hicimos con
la variable integer. Ahora, el tipo de datos del gráfico también
puede usar ASC, valores
ISI, tos, jugar
ciertos personajes también. Si quieres saber
cuáles son estos, simplemente
puedes buscar una referencia de tabla
A-S-C-I-I. Esta es la abreviatura del
American Standard Code for Information
Interchange. De todos modos, sigamos adelante y
creemos un tipo de datos de gráfico. Entonces vamos a decir gráfico para decir el tipo de datos de la
variable que estamos creando, tal como lo haríamos con
cualquier otra variable. Entonces le daremos un nombre a esto. Por ejemplo, llamaremos a esta
carta. Así como así. Entonces vamos a seguir adelante e
inicializarlo ahora mismo también. Y vamos a decir
algo así como iguales. Y luego en C plus, cuando le estás dando a
algo el valor de un solo carácter o un char, quieres ponerlo entre comillas
simples. Y entonces podríamos decir,
podríamos hacer capitalmente si quisiéramos. Esto se
imprimirá tal como lo haría si pusiéramos
esto entre comillas dobles, una sobre C out declaraciones. Tan gordo como mayúscula, se imprimirá como mayúscula. Y si tiene una minúscula, se imprimirá como tal. Podemos seguir adelante y
probarlo ahora mismo. Así que aquí abajo, estoy
tratando de decir, sí. Carta. Después un
punto y coma al final. Por cierto, para
aquellos de ustedes que usan Visual Studio mientras
escribían, pueden notar este cuadro
desplegable. Y en realidad puedes
acceder a él usando las flechas arriba y abajo y luego golpeando Enter
para seleccionar una. Aquí, automáticamente
aparece
nuestro nombre de variable a
medida que lo estamos escribiendo. Y podemos presionar Enter para
llenarlo automáticamente. Y esto va a ser cada
vez más útil ya que nos estábamos quedando sin programas más grandes
y escribiendo bastante. O si tienes nombre de
variable más largo. De todos modos, sigamos adelante
y ejecutemos nuestro programa. Y como pueden ver, L errata. También puedes seguir adelante e
imprimir un
carácter aleatorio A-S-C-I-I escribiendo un número
asociado a uno aquí. Entonces e.g. Sólo voy a poner 25. Ahora bien, esto no es en realidad
aleatorio y cada vez va a
imprimir
lo mismo. Solo quise decir que no
sé qué personaje va a
imprimir este personaje . Así que hemos
llegado a ejecutarlo. Y como puedes ver aquí, imprime una flecha hacia abajo. Y sólo para demostrar
que no es aleatorio, si vuelvo a ejecutar
esto, va a imprimir una flecha hacia abajo cada vez. Como dije, siempre puedes
buscar una tabla de referencia de los personajes de ASC II si quieres ver
cuáles son esos y meterse con eso. Observe eso porque no
pusimos un solo carácter como el valor de nuestra variable
char aquí. Sacamos las comillas simples. Además, solo para mostrarte esto, sigamos adelante y eliminemos
el valor de 25 años. Vuelva a poner nuestras cotizaciones individuales. Y luego solo voy a seguir
adelante y escribir el número como tres y ejecutar nuestro código. Eso también funcionará. Y solo para mostrarte
esto, solo dice antes, puedes seguir adelante y hacer de este un gráfico
firmado tomando seno. Recuerda que este
es el valor por defecto. Entonces esto y esto son exactamente lo mismo para decir,
sin firmar, así. Y entonces esto sólo puede
tener un valor positivo. Ahora bien, si queremos volver a llamarlo, se
puede ver que sigue funcionando. De todos modos, eso es todo
por este video. En el siguiente video,
vamos a repasar el tipo de datos de cadena utilizado para almacenar múltiples
caracteres, palabras o frases. Así que gracias por mirar, y te veré
en la siguiente.
13. Capítulo 3 (variables): cadenas: En este episodio, vamos
a estar hablando de cadenas, que es un tipo de datos para contener una serie de personajes o
una secuencia de personajes. Así que básicamente cada vez que
quieras almacenar una serie de texto o números
más largos que un solo carácter, querrás usar una cadena. También vamos a incluir la cadena
del archivo de encabezado. Entonces, a continuación, esto
copiará lo que hay arriba. Así dicen que el hashtag incluye
el símbolo menos que. Diremos cadena,
seguida del símbolo mayor que. Y ahí tienes. Bueno ahora tenemos acceso a todo
el código dentro de este archivo. Además, para aquellos de
ustedes en Visual Studio, realidad pueden hacer clic derecho sobre esto y bajar a
un documento de referencia. Y en realidad puedes mirar
el código dentro de ese archivo. Pero para la mayoría
de ustedes y para mí, Eso no es realmente importante. Pero para aquellos de ustedes que pueden terminar necesitándolo o simplemente
son curiosos, hay una manera de
seguir adelante y mirar eso. Entonces, ¿cómo creamos una cadena? Bueno, igual que cualquier
otra variable. Así que vamos a hacer una cadena, tipo de datos y todo minúscula. Entonces vamos a seguir adelante
y darle un nombre. Entonces llamemos a este
nombre, por ejemplo. Entonces seguiremos adelante y lo
pondremos igual a John Doe. Recuerda, cada vez que estemos trabajando con una serie de textos, vamos a usar
comillas dobles. Y cuando estemos trabajando con un
solo carácter, usaremos las comillas simples. Porque queremos almacenar
una cadena de caracteres, vamos a usar
las comillas dobles. Y vamos a decir John,
así como así. Y si queremos
imprimir esto, simplemente
podemos decir C out. Y si ejecutamos nuestro programa, se
puede ver que dice John Doe. Y por cierto, una cadena, junto con muchas
otras cosas que hemos usado y que usará en el futuro son todas parte
de este espacio de nombres std. Puedes definirlo explícitamente
ahí si lo deseas. Incluso puedes ver que si paso
el mouse sobre esto
en Visual Studio, me deja saber que
es parte de ese espacio de nombres. Pero para lo que resta
del curso, sólo
voy a
dejar esto aquí que cualquier cosa que
haga una parte de eso, no tenga que mencionarlo
explícitamente. Ahora, muy rápido, antes
de terminar el video, en realidad
vamos a repasar algunas funciones que forman
parte de la clase string. Como dije, vamos a estar repasando son funciones en clases. Más adelante en el curso. Va a haber
varios videos en él. Así que no te preocupes por
entender qué son o cómo
funcionan ahora mismo. Pero solo quería
repasar algunas de ellas
contigo para que sepas
cómo usarlas. Y solo para que tengas una
idea de qué tipo de funcionalidad
hay para las cadenas. Entonces, por ejemplo, sigamos
adelante y limpiemos
esta línea aquí. Entonces después de una c out y
el operador de inserción, Sigamos adelante y
pongamos comillas dobles. Y diremos Mi nombre
es. Así como así. No lo olvides, necesitamos agregar
otro operador de inserción para separar nuestra variable
de esta aquí. Por cierto, esta cosa aquí entre estas comillas dobles, Sí, sé que es texto, pero también se le
conoce como literal de cadena. Ahora, cuando ejecutemos un programa, dirán Mi nombre es espacio y luego el
nombre que insertamos. Pero sigamos adelante y
también echemos
un vistazo a algunas funciones para
la clase string. Tan rápido,
sigamos adelante y agreguemos en algunos comentarios. Aquí. Voy a decirme cadena. Aquí mismo, voy a decir. Y luego abajo, vamos a decir la longitud de
nuestro nombre, incluyendo espacios. Y luego aquí abajo, diremos la versión plural. Y te voy a mostrar por qué
en tan solo un minuto. Bien, entonces el primer método, vamos a seguir adelante y
probar como el método de longitud. Y como dije, vamos a repasar funciones métodos
indoor más adelante
en el curso. Entonces, por ahora, solo
síguense solo para
ver como funcionan. Así que vamos a hacer es decir nombre, siendo el nombre real
de nuestra cadena aquí, y luego morir, también conocido como
el operador de acceso miembro, o un símbolo de punto. Y luego vamos
a decir longitud, todas minúsculas, paréntesis de apertura
y cierre, y un punto y coma al final. Entonces aquí abajo,
vamos a hacer otra diciendo nombre. Dieta, push, todo en minúsculas, subrayado hacia atrás, y luego abrir y cerrar paréntesis
y un punto y coma al final. Y luego dentro de
esos paréntesis, en realidad
necesitamos
poner un personaje. Y si pasamos el mouse sobre esto, se
puede ver que
dentro de los paréntesis ahí que dice que
toma un valor char. Entonces vamos a poner
comillas simples. Y luego una S Así como así, porque sólo estamos trabajando
con un solo personaje. Utilizamos las comillas simples. Y ahora lo que
va a imprimir es que nuestro nombre es John Doe. Porque eso es lo
que escribimos aquí mismo. O lo que sea que
escribas ahí se imprimirá. Y entonces va
a decir la longitud de nuestro nombre, incluyendo espacios. Yo sólo voy a cumplir ocho. Entonces esta función
aquí realmente agrega una S al final de nuestra cadena o cualquier
letra que ingresemos aquí. Sin embargo, esto no
va a hacer nada. Entonces, si ejecutamos nuestro código, va a funcionar. Y como pueden ver, corre tal como lo hacía antes. El problema es que
en realidad estamos haciendo cualquier cosa
con estos valores. Así que a pesar de
que ahora tengo la longitud, no la
imprimimos en la consola. Entonces sigamos adelante y hagamos eso. Vamos a decir CO,
seguido del operador de inserción y
luego nuestro nombre longitud de punto. Y esto va a funcionar bien. Entonces como pueden ver, ahí está
John Doe y luego ocho. Y podemos seguir adelante conmensurable nueva línea diciendo como
lo hemos hecho en el pasado. Y otro
operador de inserción, así. Y eso va a limpiar eso de inmediato. Y luego aquí abajo, en realidad
podemos imprimir
este año porque todo lo que está haciendo es agregar una
S a nuestro nombre aquí. Entonces después de esto,
vamos a seguir adelante y decir CL para crear una nueva línea. Y luego
imprimiremos nuestro nombre. Asegúrate de poner
punto y coma al final. Y vamos a ejecutar nuestro código. Ahora dice Mi nombre es John Doe. Imprimimos la longitud
de nuestro nombre ya que esto es lo que esta función aquí
devuelve como ese valor. Y somos capaces de poner ese valor aquí
mismo y nuestra declaración
c out. Y luego aquí abajo, probamos otra función que
formaba parte de la clase string, lo que nos permite agregar un carácter al
final de nuestra cadena. Entonces, en vez de John Doe, dice John Dos. Y teníamos una impresión
que en una línea separada. Así. Y como dije,
realmente no te
preocupes por bajar todo
eso ahora mismo. Solo quería
mostrarte algunas de las posibilidades
con cuerdas ahí. Pero no vas a tener que
saberlo en el futuro. Y si te interesa, siéntete libre de buscar la clase de cuerdas y algunas de sus otras
posibles funciones. Lo único que realmente
necesitas quitar de este video es que al
trabajar con una cadena o
un MP lanzando
el
archivo de encabezado de cadena usando esta
declaración include en la parte superior. Luego creamos una
cadena igual hicimos con cualquier
otro tipo de variable, excepto que
especificamos que era una cadena y no era un
entero o algo así. Entonces lo usamos de
la misma manera si lo
haríamos con cualquier otra variable
al imprimirlo. Y mientras estamos aquí, quiero mostrarles
que si intentamos escribir un valor diferente, como 54 o
algo así, inmediatamente
vamos
a obtener este error. Y nos va a decir que esto no es adecuado
para ese tipo de datos. Entonces es bueno señalar que no
va a
dejar que te equivoques. Si intentas poner
el tipo de datos incorrecto. Solo te va a hacer
saber de
inmediato que es incorrecto, al
menos cuando se trata de
algo tan drásticamente diferente como cadenas
y enteros. Y a lo que me refiero con eso, nos
meteremos en un futuro video aquí, pero solo quería
mostrarte eso de todos modos, así que eso es todo para este video. Y a partir de ahora a través
del resto del curso, en realidad
vamos
a seguir adelante y dejar esta declaración include
para el archivo string. De todos modos, gracias por mirar, y te veré
en la siguiente.
14. Capítulo 3 (variables): constantes: En este video, vamos a estar hablando de constantes. Ahora bien, una constante es
básicamente sólo una variable. Nunca quieres cambiar. Y tal vez te estés preguntando,
¿por qué haría eso? Bueno, la razón es
que cuando se trata de programación, quieres hacer todo lo posible
para
asegurarte de que nada pueda salir
mal con tu código, teniendo en cuenta el error humano. Entonces, por ejemplo,
digamos que estabas haciendo un programa
a las cuatro en punto, y querías que ese reloj supiera que hay 60 minutos en una hora. Y eso nunca,
jamás iba a cambiar. Querrías
convertirlo en una
variable constante de tal manera que
no hubiera manera posible que
pudiera
estropearse y meterse con el resto de
tu código en el futuro. Entonces lo que vamos a
hacer un decir const, que es una palabra clave para
representar que queremos hacer una variable constante para
que una CON como t. Y
luego vamos a decir, y luego diremos minutos
por hora para el nombre ahí. Y luego vamos a
seguir adelante y ponerle eso igual a 60 y poner punto y
coma al final. Ahí vas. Ahora hemos creado una variable constante que no se
puede cambiar. Esto se puede hacer con todos los
diferentes tipos de variables. Bueno, hay que hacer es
poner esta palabra clave constante antes del tipo de datos. Entonces básicamente la sintaxis o la regla para hacer
una variable constante. Y vas a decir const, seguido del tipo de datos, seguido del nombre, luego la asignación de la variable. Así que ponles el operador de
asignación, seguido del valor. Ahora, una cosa a tener en cuenta con constantes que no podemos
simplemente declararlo así. Y luego después, digamos minutos
por hora es igual a diez. Por ejemplo. Si paso el ratón
sobre el punto y coma aquí, puede ver por qué es eso. Esta es la variable const. Minutos por hora
requiere un inicializador. Si vas a hacer
una variable constante que nunca
quieres cambiar. Necesitas
inicializarlo y darle ese valor que
quieres que quede permanente,
correcto, cuando
declares la variable. Entonces, a diferencia de las variables normales, no se
puede declarar
una variable constante y luego inicializarla más tarde. Eso es todo lo que tengo para estar exactamente
en la misma línea. Entonces diremos const
int minutos por hora es igual a 60, así como así. Y sólo para mostrarles que
no podemos cambiar esto más tarde. Ahora, sé que no parece un gran problema en estos momentos. Pero a medida que comienzas a trabajar con programas
cada vez más grandes que tienen múltiples líneas de código y
pueden ser varias páginas. Quieres asegurarte de que no
hay manera posible. Por lo tanto, los minutos por hora podrían
cambiarse porque
necesita ser de 60. Y sobre todo si estamos
haciendo un reloj, bien, si eso es incluso un solo dígito apagado al final de
un mes o de un año. Quienquiera que sea el reloj que
sea, va a estropearse, ¿verdad? Así que solo queremos
asegurarnos de que hacemos lo más
difícil posible difícil posible nuestro código sea usado incorrectamente. Y aunque
el programa en sí no va a hacer nada, no
le dices que haga. ¿Quieres dar cuenta
del error humano? Además, no es tan
difícil simplemente agregar en estas palabras clave rápidas y
asegurarse de que ese
valor sea permanente. Y sólo para mostrarles esto, si yo fuera a decir minutos, Nuestro aquí abajo, y luego tratar de ponerla igual
a algo así como diez. Voy a obtener
un error inmediato diciéndome que este no es un valor modificable porque
este es un valor constante. Mientras que si tuviera
que quitar esto, ya no es constante. Puedo cambiarlo a
lo que quiera. Así que voy a seguir adelante
y poner eso de nuevo. Y por cómo funcionan
las constantes y por cómo se
lee el código de arriba a abajo, aunque tuviera varias líneas que ya no lo metieron
en mi código. En cuanto ponga ahí esa palabra clave
constante, va a hacer que
todo
lo que intente ajustar este valor
surja como un error, haciéndome saber que
eso no se puede hacer. Entonces, si había
algo que estaba metiendo con eso
antes de lanzar esta palabra clave const me va a dar
fácilmente
acceso a cualquier cosa. Estaba tratando de
meterse con ese valor. Y una última cosa antes de que
terminemos este video, solo
quiero mostrarles
que aunque este valor sea constante y que no
podamos cambiarlo, todavía
tenemos acceso
al valor se considera
una lectura valor único. Puedes leerlo pero no puedes escribirle, no
puedes meterte con él. Entonces, si decimos CL minutos por
hora y luego ejecutamos nuestro código, puedes ver que
aún podemos reunir ese valor. Todavía podemos decir que son 60, pero simplemente no podemos cambiarlo. Y ahí lo tienes. Ya sabes todo lo que
hay que saber sobre constantes y programación. De todos modos, eso es todo
para este video. Gracias por mirar, y te
veré en la siguiente.
15. Capítulo 4: entrada de usuarios en Cin: En este video,
finalmente voy a
mostrarte cómo podemos realmente recuperar la entrada
del usuario en lugar de
simplemente enviársela. Entonces, por ejemplo,
sigamos adelante y pidamos algunos bits diferentes de información al usuario
y luego sigamos adelante e imprimirla nuevamente en la consola. Tan rápido, sólo voy
a añadir en algunos comentarios. Entonces le pediremos
su nombre de pila. Entonces les preguntaremos por
su apellido. Y por último, vamos a
preguntar por su edad. Entonces vamos a seguir adelante e
imprimir todo esto de nuevo a ellos. Este es solo un
ejemplo rápido del uso de comentarios para hacer que el
código sea más legible. Pero cuando realmente
empiezas a escribir programas cada
vez más grandes, definitivamente
recomendaría entrar en muchos más detalles
y realmente
desglosar lo que cada línea de código, donde cada la función está haciendo
cuando lleguemos a ese punto. Porque cuando vuelves
y miras tu código, ya sean días, semanas, meses o incluso
años en el futuro, o alguien que nunca antes había visto tu código, lo
echa un vistazo. Será mucho
más fácil averiguar qué está pasando
aquí arriba en la cima. Sigamos adelante y
creamos algunas variables para almacenar su información. Entonces primero, seguiremos
adelante y crearemos una cadena para almacenar
el FirstName. Entonces diremos el nombre de la cadena. Entonces simplemente pondremos punto y coma
aquí al final. Entonces por debajo de eso,
diremos cadena LastName. Y por debajo de eso,
vamos a seguir adelante y decir edad. Así como así. Hemos creado tres variables
y las acabamos de declarar. No hemos dado estos
y valor inicial. Entonces aunque
podríamos seguir adelante y poner un valor inicial
para cada uno de estos, voy a
seguir adelante y dejarlos en blanco solo para
mostrarte que podemos hacer que el usuario ponga un valor
inicial en lugar de poniendo en un valor inicial y simplemente permitiendo que
ellos lo cambien. Justo aquí, vamos a
seguir adelante y decir CL. Y luego entre comillas
dirá escribe tu nombre. Espacio de colon. Así como así. Aquí no pongo punto y coma
al final. Y luego abajo, en realidad
vamos
a seguir adelante y recopilar esta información
del usuario. Y para ello,
vamos a seguir adelante y decir c n. Entonces el símbolo
mayor que dos veces, seguido de nuestro nombre de variable, nombre pila, y luego un punto y coma
al final, así como esto. Mientras que aquí arriba dijimos c out para dar salida a la
información al usuario. Vamos a decir C N para recuperar la
entrada del usuario. Y también en lugar de
escuchar operador, eso va a
insertar algo en el programa o la consola. En este caso, utilizamos el operador de
extracción para extraer algo de nuestro
programa de vuelta a nuestro código aquí. Entonces los dos símbolos menos que
como el operador de inserción, y los dos mayores que símbolos es el operador de extracción. Y en lugar de
dar salida a la información, estábamos recibiendo información. Ahora personalmente, me
gusta pensar en
estos
operadores de inserción y extracción como flechas. E imagina que mi programa
está por aquí en alguna parte. Entonces estoy emitiendo información
a mi programa y estoy insertando de nuevo de esta
manera a donde está mi código. Entonces esa es una forma de
verlo si eso te ayuda. Genial. Entonces ahora mismo, si
ejecutamos nuestro programa, va a decir
escribe tu nombre de pila. Nuestro cursor en la consola
va a terminar aquí mismo. Y pueden escribir
su FirstName. Y luego cuando el
usuario golpea Enter, en realidad
pone su
texto en el programa. Así que en realidad recuperamos
la información. Y eso es lo mismo con
nuestro método get aquí abajo. Y de esa manera confía
o presiona Enter. Una vez que el usuario presiona Enter, en realidad
podemos recuperar
información de ellos. Y así es cuando
todo se ejecuta. Entonces aquí mismo decimos
escribe tu nombre de pila. Pueden escribir lo que
quieran y luego presionar Enter. Y esa información o esa cadena de caracteres
va a ser almacenada aquí mismo en
nuestra cadena FirstName. Pero aún tenemos que
escribirlo de nuevo al usuario o hacer
algo con él. De lo contrario, sólo
va a sentarse aquí en la variable y
nunca la hemos usado realmente. Y va a estar haciendo eso aquí
abajo en tan solo un momento. Pero primero, sigamos adelante
y creamos una línea en blanco. Entonces sólo vamos a decir
CO. Y así así, sigamos adelante y copiemos y
peguemos esto abajo aquí abajo. Ya que
prácticamente vamos a hacer lo
mismo para
obtener su apellido, excepto en lugar de FirstName, vamos a decir lastName, que es el nombre de
nuestra otra variable. Y aquí arriba diremos
escribe tu apellido. Entonces, solo para que todos nuestros textos
no estén agrupados. Sigamos adelante y
agreguemos otra línea en blanco. Entonces no deshice esto. Yo sólo voy a tirar
otro operador de inserción y decir en línea. Y yo haré lo mismo. Entonces vamos a seguir adelante
y copiar todo esto de nuevo y pegarlo
aquí abajo. Entonces diremos escribe tu edad. Entonces la información
que escriben. Queríamos entrar en nuestra era. Bien, y asegúrate de que cuando
lleguemos a esta parte en un programa que realmente
escribas en un número entero. Porque a partir de ahora
no tenemos forma de verificar si realmente
ponen
o no un número
entero o una variable entera solo puede
contener un número entero. Entonces, para evitar cualquier
problema o cualquier error, solo asegúrate de escribir
un número entero. Si no, siempre puedes
cerrarlo y volver a ejecutar tu programa. Más adelante en este curso, realidad
vamos a repasar cómo
podemos verificar
diferentes condiciones. Pero por ahora, solo
nos
aseguraremos de que tomemos
todo correctamente. Entonces vamos a
seguir adelante e
imprimir su nombre completo y edad. Entonces sigamos adelante y digamos CL. Tu nombre es espacio así. Y luego lanzaremos
otro operador de inserción. Y diremos FirstName, seguido de otro operador de
inserción, el espacio
de comillas dobles ahí dentro. Entonces otro
operador de inserción y decir, bien, y luego
abajo de eso, vamos a seguir adelante y
decir línea de ciática. Otro operador de inserción. Y diremos que tu edad es el espacio de colon, otro operador de
inserción. Y luego pasar por menores de edad. Qué punto y coma al final. Déjame alejarme aquí
para que ustedes puedan
asegurarse de que todo su
código coincida con el mío. Entonces seguiremos adelante
y ejecutaremos el programa. Así que vamos a tipo de nombre, tipo, lo que
quieras y pulsa Enter. Va a preguntar
por nuestro apellido. Ahora fíjate cuando
golpeamos Enter después escribir tu nombre, sí contó. Eso va bajando
a la siguiente línea. Entonces entonces esta línea final
aquí bajó una más, y la siguiente
bajó una más. Así que en realidad hay dos espacios. Entonces, si queremos
limpiar eso, en realidad
podemos simplemente quitar una de estas n líneas
de cada una de estas. De lo contrario, creo que se
ve bien tal y como es. Yo sólo quería
hacerte consciente de eso. Después va a escribir
lo que quieras para el
apellido, Enter de nuevo. Entonces voy a pedir h. Voy
a escribir un número entero. Puede ser lo que quieras, realmente no
importa. Y pulsa enter otra vez. Y
cerrará el programa. Y tal vez te estés preguntando
por qué cerraron de inmediato. El motivo es porque
golpeamos Enter al final aquí. En realidad contaba que
como parte del pecado mueren. Entonces lo que vamos a
hacer es simplemente copiar esto y seguir adelante y
pegarlo una vez más. Así que ejecuta el programa otra vez, solo recapitulando nuestras cosas. Y ahí lo tienes. Entonces y eso es por
nombre, tipo, lo que queramos como su
apellido, separar a todos. En cuanto a tu H, lo mismo. Solo asegúrate de que
sea un número entero, ya que eso se está
almacenando en un entero, ten en cuenta, podríamos
haber puesto esto en una cadena y
funcionaría bien. Después lo imprimimos de
nuevo al usuario. Tu nombre es y tu edad va seguida de
su nombre y edad. Y sólo para mostrarles que
esto funcionaría como una cuerda, voy a seguir adelante y poner cadena ahí mismo, ejecutar el programa. Y como pueden ver, funcionó muy bien. Pero solo quería
mostrarte que puedes recopilar diferentes
tipos de variables del usuario. No tiene que ser una cuerda. Ahora, ojalá
aprendiste algo aquí. Si estás confundido en absoluto, te
recomiendo encarecidamente que
vuelvas, vuelvas a ver el video. Y si aún no puedes
entenderlo y solo
avísame abajo en la sección de
discusión a continuación, me pondré en
contacto contigo lo antes posible. Pero no te preocupes si
sientes que lo tienes, pero aun así quieres tener un
poco más de práctica y vamos a estar
haciendo muchísimo con ese tipo de cosas a lo largo del curso. Así que de todos modos, gracias por mirar, y te veré
en la siguiente.
16. Capítulo 4: funciones de Getchar y Getline: ¿Cómo va todo, todo el mundo? En este video, queremos
pedirle
al usuario su nombre completo, almacenarlo en una variable e imprimirlo de nuevo en ellos. Ahora, podrías estar pensando, oye, ¿no es esto lo que
acabamos de hacer en el último video? Bueno, y algo así como, pero en este video, vamos a estar usando
un par de métodos nuevos. Entonces quería seguir
con algo que ya te
era familiar. Vamos a introducir algo nuevo. Así que vamos a seguir adelante y
crear una cadena aquí. Y lo llamaremos nombre completo. Así como así. Y
sólo vamos a declararlo. No vamos a
meter nada. Entonces. Vamos a pedirle al
usuario su nombre completo. Así que adelante y di C fuera. Y luego en comillas
dirá Por favor tome el espacio de dos puntos al final. Y luego aquí abajo, vamos a
imprimir su nombre completo. No olvides tu punto y coma
al final ahí. Así lo dice CL. Y luego entre comillas,
vamos a seguir adelante y poner barra diagonal inversa n. Y diremos tu nombre completo. Espacio de colon, así como así. Y luego lanzaremos otro operador
de
inserción impreso aunque, nombre
completo, el nombre
que nos dieron. Ahora en el último video, seguimos adelante y dijimos pecado
para recoger su nombre completo. Sigamos adelante y volvamos a
hacerlo. Sólo para mostrarte algo. Ustedes sólo van
a sacar esto. Entonces vamos a decir cin, nombre. Y luego después de
imprimir su nombre completo, adelante y poner en otra línea
N aquí. Así como así. Y ya verás por qué pongo
esto aquí en tan solo un momento. Ahora, dependiendo de qué
programa estés usando, debería
haber una manera de
ejecutar tu código sin depurar ni verificar
errores esencialmente. Y en Visual Studio, puedes presionar
Control más F5 o simplemente puedes golpear esta placa vacía bind
aquí en la parte superior. E independientemente del
programa que estés usando, debería
haber una
opción para ejecutar tu código sin depurar. Pero si no, solo puedes
tomar el Sendai get code. Sólo tienes que copiar y pegar esto unas
cuantas veces y deberías obtener el mismo efecto. Es posible que solo tengas que
ingresar algunos términos más, salir o golpear la X en
la parte superior de tu programa. Pero sólo voy
a poner
ahí el que he tenido a lo largo del curso y correr
sin depurar. Y la razón de
esto es un poco más complicada de lo que me importa
meterme en este momento. Pero por ahora, solo intenta ejecutar tu código sin depurar o copiar y pegar esta línea aquí
abajo varias veces
y estarás bien. Entonces cuando ejecutemos nuestro código, va a decir, por favor
escriba su nombre completo. Adelante y toma a
John Doe por ejemplo. Y entonces notarás que solo
dice Mi nombre completo es John. Y luego me pidió
presionar cualquier tecla para continuar. Y eso es por
Visual Studio, al
menos cuando ejecutas tu
código sin depurar, no
se cerrará
automáticamente. Ahora bien, ¿por qué solo dice John? Bueno, ya que debido a
este objeto pecado aquí que usamos para
recuperar la entrada del usuario, realidad
dejaremos de grabar información una vez que pongamos
en este espacio aquí. Es por eso que en
cuanto terminamos escribir a Jon, básicamente decía, bien, solo soy John, justo aquí para el nombre completo. Pero, ¿y si quisiéramos recoger todo incluido el espacio? Bueno, podemos usar una nueva función llamada
la función getline. Ahora mismo, vamos a seguir
adelante y comentar esta línea aquí para que aún
podamos verla, pero en realidad no
va a afectar nuestro código. Así que justo debajo de nuestra
declaración cin que
teníamos, vamos a decir getline y todos los paréntesis abiertos en minúscula, seguido de pecado o
C, espacio de coma, seguido del nombre
de nuestra variable, siendo nombre completo, paréntesis
cercanos y punto y coma al final. Así como esto. Así que ahora lo que estamos haciendo
es que estamos ingresando la información que obtenemos de nuestra función getline aquí
en el nombre completo de la variable. A diferencia de nuestra última declaración aquí, que grabó información
y la puso en una variable hasta que golpeamos la
barra espaciadora o la tecla enter, así obtener la función de línea
o un método aquí va a recopilar hasta que presionemos la tecla Enter. Entonces va a seleccionar
todo en esa línea. Ahora, ejecutamos nuestro código, en realidad
podemos escribir
nuestro nombre completo. Y volverá a imprimir
nuestro nombre completo. Y luego muy rápido, tengo
un último método para mostrarte. Así que sigamos adelante
y comentemos nuestro método getline
que acabamos de usar. Y luego por debajo de eso, vamos a decir
nombre completo es igual a getchar, todo minúscula, abrir
y cerrar paréntesis, y un punto y coma al final. Con este método
o función aquí hace como acaba de obtener el
siguiente carácter escrito en. Y te voy a mostrar cómo funciona
eso luego sigue adelante y cállate tu programa
sin volver a depurar. Recuerda si no puede hacer
eso por alguna razón, solo sigue adelante y copia y pega el getline de puntos sin varias veces. Siempre puedes salir
del programa manualmente. Entonces adentro, solo escribe tu nombre completo, adelante y escribe
lo que quieras. Golpea Enter. Notarás que solo
toma el primer personaje. Entonces seguimos adelante, los
escribimos lo que queramos. Entonces una vez que golpeamos Enter, todo lo que hemos escrito se pone
realmente en el programa. Guarda solo esa primera
letra porque eso es lo le
dijimos que hiciera y nos la
imprimimos de nuevo. Ahí vas. Sí. Cada vez que estamos trabajando
con la consola, ustedes pueden
escribir literalmente como quieran y no
va a hacer nada. Ya que has tenido en
su todo lo que
has escrito en
realidad va a ser puesto en el programa
que estamos ejecutando aquí. Y entonces hará lo que le dijiste con
esa información. De todos modos, eso
es todo para este video, solo
quería
mostrarte este par de métodos
adicionales aquí que puedes usar a la hora de obtener la entrada del usuario. Ahora, la función get char aquí podría no ser súper útil
para usted la mayor parte del tiempo, pero definitivamente va
a haber varias veces para esta función getline
definitivamente sea útil. Y en realidad hay
otras formas de usar este método que puedes
buscar en línea si te interesa. Pero por ahora, ese es
el básico y el que más probablemente
use con más frecuencia. De todos modos, gracias por mirar, y te veré
en la siguiente.
17. Capítulo 4: cadena a la int.: En este video, voy
a estar mostrándote cómo podemos convertir una cadena un número y cómo podemos hacer lo contrario
de convertir
un número en una cadena. Así que vamos a meternos en ello. Ahora mismo aquí, tengo algunos métodos
diferentes que puedes usar. Simplemente demuéstrale que
hay un puñado de ellos ahí fuera. Y en realidad hay mucho
más que solo los tres
que he enumerado, pero solo usaremos este
primero para un ejemplo. Así que vamos a seguir adelante y
crear un entero. Digamos que el número es igual a cinco. Entonces por debajo de eso realmente seguirá
adelante y creará una variable de
cadena. Diremos cadena, número
escrito es igual. Vamos a poner
ese diez dentro de comillas
dobles porque
queremos que sea una cadena. Entonces abajo aquí, seguiremos adelante e
imprimiremos nuestro número entero. Entonces vamos a decir C fuera. Entonces por debajo de eso se
creará una línea en blanco. Y luego por debajo de eso,
vamos a seguir adelante y convertir nuestra cadena en un número. Entonces, ¿cómo podemos
asegurarnos de que esto funcione? Primero, vamos a seguir adelante y decir número siendo nuestro número entero ahí. Y luego lo vamos
a igualar. Entonces aquí vamos
a usar un nuevo método. Entonces vamos a decir S, T, O, y todas minúsculas
entre paréntesis. Vamos a poner el
nombre de nuestra cuerda. Entonces diremos número rojo, cerraremos los paréntesis y
pondremos punto y coma al final. Así que asegúrate de que coincida con mi aquí. Entonces primero creamos un entero llamado números para que los cinco. Luego creamos una
cadena llamada
número aleatorio y la configuramos una cadena que tiene solo el número diez
en ella, nada extra. Y luego abajo de eso, imprimimos el número, saltamos la fila, o
bajamos una línea, debería decir. Y luego establecemos número
igual al número escrito, que debería ser diez. Y lo hicimos con este
método se llama la S, demasiado corto para cadena
a entero, ¿verdad? Porque queremos convertir
esta cadena a un entero para que podamos establecer nuestro entero actual igual a él. Después crearemos
otra línea en blanco. Y también volveremos
a imprimir el número. Por cierto, para el
resto del curso, te
recomiendo simplemente ejecutar tu
código sin depurarlo. Y si estás en Visual Studio, recuerda que solo puedes mantener presionado
Control y presionar F5. Y como pueden ver, dijimos cinco, luego diez. A pesar de que acabamos de
imprimir el número entero dos veces. Porque somos capaces de convertir
este número aquí dentro de nuestra cadena
a un entero. Por cierto, para aquellos de
ustedes en Visual Studio, si mantener el control y
encabezar un cinco es un dolor, siempre pueden
presionar este
botón en la parte superior. O si realmente quieres, puedes ir a Herramientas, Opciones, bajar a
depuración. General. Camino en la parte inferior. Simplemente desmarca esa casilla que
volvimos a marcar en el segundo video. Esto es cerrar automáticamente la consola cuando se detiene la
depuración. De lo contrario siempre puedes
dejarlo marcado y luego tienes ambas opciones disponibles para
ti en un momento dado. Y esto es útil
porque cuando
en realidad envías tu programa
a alguien para
que lo use, no solo va a permanecer abierto como lo es en Visual Studio. Entonces es agradable poder
tener ambas opciones. Pero mientras solo estás codificando
y practicando y aprendiendo, puedes simplemente seguir adelante y
desmarcar eso y presionar Bien. Y esperaremos a
que presiones una tecla antes
de cerrar el programa, incluso cuando lo ejecutes con depuración encendida, con
solo presionar F5. Y puedes seguir adelante y quitar este punto de pecado obtener
si decides hacerlo así como realmente
solo tengo los de aquí para la
gente que pueda necesitarlo. Ahora, lo siguiente que vamos a hacer es convertir un
número en una cadena. Bueno, ¿cómo lo hacemos? Entonces, en lugar de convertir número cinco aquí a
este número siendo diez, convirtiendo nuestra cadena a
un final como lo hicimos aquí arriba. Sigamos adelante y
comentemos ambas líneas. Por cierto, para aquellos de
ustedes en Visual Studio, simplemente pueden resaltar
las líneas que quieran comentar y
luego hacer clic en este botón aquí en la parte superior y saliendo todas las líneas
que van a seleccionarlo. Y si alguna vez
quieres descomentarlos, puedes simplemente hacer clic en
el que está justo
al lado , así como así. Entonces vamos a seguir adelante y
comentarlos. Así que ahora mismo, hemos creado dos variables y hemos
impreso el número. Y luego nos hemos ido por una línea. Entonces aquí abajo, en realidad
vamos a hacer lo contrario. Convertiremos nuestro número
de 5 años a una cadena. Entonces, para hacer esto, vamos a seguir adelante y decir que número de
Gran Bretaña es
nuestro nombre de cadena aquí. Igual y luego
a todas las minúsculas, guión bajo cadena,
todo minúscula de nuevo. Y luego entre paréntesis, vamos a poner nuestro entero. Entonces solo diremos
número,
seguido de paréntesis cercanos y
un punto y coma al final. Entonces, ¿qué va a hacer? Va a comenzar a leer
el número siendo nuestra cadena igual al
valor de cadena de nuestro número. Así que básicamente lo contrario
de lo que hicimos aquí arriba, pero en su lugar usamos
esos dos métodos de cadena que convierte este
año en una cadena. Ahora todo lo que tenemos que
hacer es
imprimirlo para que podamos
ver realmente el resultado de eso. Entonces vamos a decir C fuera. Y luego número escrito. Cuando nuestro programa
reimprime ahora cinco dos veces, una vez siendo de nuestra variable
entera real siendo número, y otra siendo de nuestra cadena, que ahora es igual a cinco, ya que eso es a lo que era igual el
número. Bueno, ahora ya sabes cómo
convertir una cadena un entero y cómo convertir
un entero en una cadena. Y los casos de uso para esto se harán
más evidentes a medida que
continuemos con el
curso y empecemos a meternos en un código más
complicado. De todos modos, eso es todo para este
video y el siguiente video, en realidad
vamos a comenzar a trabajar con alguna aritmética
básica. Así que gracias por mirar, y te veré
en la siguiente.
18. Capítulo 5 (Operadores): Arithmetic básica: En este video,
vamos a estar repasando algunas aritméticas básicas
en la programación. Así que lo primero
que vamos a hacer es crear un par de variables
enteras. Entonces sigamos adelante y digamos
int num uno es igual a cinco. Entonces por debajo de eso diremos
int num dos es igual a diez. Entonces, bueno eso es que vamos a crear otra variable entera, que va a
contener el resultado de cualquier matemática que hagamos
en el futuro aquí. Entonces voy a decir resultado es igual, y vamos a
ponerlo en 0 por ahora. Recuerden, podríamos simplemente
declararlo si quisiéramos,
pero vamos a seguir adelante
e inicializarlo. Entonces aquí abajo, vamos a
seguir adelante y hacer algunas matemáticas. Ahora, las matemáticas en C plus plus
funcionan de la misma manera. No se relaciona.
Para la multiplicación. En realidad vas a usar la división de símbolos de asterisco. Usarás una diagonal hacia adelante, suma, un signo más
y una resta. El símbolo de resta,
también C plus plus, sigue el mismo orden
de operaciones al que estás acostumbrado cuando se
trata de estas cuatro aquí. Y también hay
algunos otros símbolos y diferentes cosas que puedes hacer que también caen en el
orden de la tabla de operaciones. Entonces, si planeas hacer algo serio con las matemáticas
en la programación, te
recomiendo encarecidamente echar
un vistazo al C
plus, además de cualquier
tabla matemática de operaciones y solo ver
cómo funciona todo eso. De todos modos, sigamos adelante y solo hagamos alguna adición básica aquí. Entonces diremos resultado es igual a
num uno más num dos. Por cierto, incluso se puede establecer una variable igual a
otra variable. Entonces, si digo resultado es igual a num, uno, resultado
sería igual a cinco. Pero estamos aquí,
vamos a decir num uno más num dos, que
debería ser 15. Podemos probar esto
diciendo c out. Ejecute nuestro código. Y ahí tienes. Y sólo para mostrarles
que esto sí sigue el orden correcto de
las operaciones generales, y decir multiplicar aquí mismo
después de una M dos por dos otra vez. Entonces, si esto se leía de
izquierda a derecha, sería un cinco más diez, que sería 15 veces
diez haciendo lo que quieres 50. Pero debido a que esto sigue el
mismo orden de operaciones, así que estamos acostumbrados, primero va a hacer la multiplicación. Entonces en realidad va
a ser diez por diez, que es 100, más
cinco, que es 105. Y si ejecutamos nuestro programa aquí, se
puede ver que
ese es el caso. Y en caso de que tuvieras
curiosidad por las matemáticas aquí, puedes decir que el resultado
es igual a los tiempos de resultado. Hasta ahora, va
a decir resultado siendo 0. Queremos establecer igual a num uno, num dos, que sabemos que
va a ser 15. Entonces aquí abajo
vamos a decir resultado, que es 15 igual resultado siendo 15 de nuevo veces
num a ser diez, debería terminar por 1 quinto. Entonces vamos a seguir adelante
e imprimirlo. Y ahí tienes.
Entonces ahí tienes. Ya sabes cómo hacer algunas matemáticas
básicas en C plus plus. Y si quisiéramos, incluso
podríamos seguir adelante y pedirle al usuario estos números. Por ejemplo, en lugar de
configurarlos aquí, puedo seguir adelante y quitar eso. Y simplemente dejaremos que nuestro resultado sea igual a 0 para comenzar. Y luego aquí abajo diremos resultado es igual a num1 más num2. Pero justo antes de eso,
vamos a ver. Entonces en comillas dirá tipo. Persona número dos. Se les agregó flujo que
va a decir C de nuevo. Agregado de segundo orden. Y luego entre esos, vamos a tener que decir CAN uno para el primero que hay. Y luego por debajo de eso,
hemos declarado dos variables
enteras. Hemos declarado e inicializado
una variable de resultado. Luego lo imprimimos y queremos que el usuario escriba el
primer número a agregar. Y en realidad voy
a seguir adelante y poner un espacio de dos puntos aquí
solo para que se vea un poco más agradable que una vez que tomen su primer
número y golpeen Enter. Les va a
pedir un segundo número. Y si queremos,
podemos seguir adelante y poner una nueva línea
así como así. Entonces pueden escribir en su
segundo número y golpear Enter. Y luego justo aquí abajo,
automáticamente va a
seguir adelante y sumar esos
dos números juntos. Y en la parte inferior, podemos
decir algo así. C out y luego cita
y poner en una nueva línea. Diremos que el resultado es espacio de
dos puntos así. Asegúrate de que al final estén
punto y coma. Y antes de que
me olvide, voy a poner este colon
y espacio aquí mismo. Después de que también preguntemos por el
segundo número, seguiremos adelante y ejecutaremos nuestro código. Recuerda hacerlo
sin depurar. No quiero decir
solo 105 o
puedes escribir los
números que quieras para darte tu
resultado aquí mismo. Entonces para mi dice que
mi resultado fue 15. Y ahí vamos. Y entonces si quería
limpiarlo aún
más porque mi abogado me pidió que más porque mi abogado me pidió presionara un botón
antes de continuar. Podría simplemente mostrarme en una nueva línea al final aquí así. Y esto va a funcionar bien. Y ahí tienes. Se ve bastante bien. De todos modos,
eso es todo para este video. En el siguiente video,
voy a estar
mostrándote un par de operadores extra. Así que gracias por mirar, y te veré
en la siguiente.
19. Capítulo 5 (Operadores): aumento y decadencia: En este video, voy a
estar mostrándote un par de nuevos operadores que
quizás no hayas visto antes. Pero estos son bastante comunes
en los lenguajes de programación. Entonces el primero es el operador de incremento
siendo dos símbolos más, simplemente
había agregar uno a
lo que sea que lo estés usando. En el operador decremento, que es simplemente restar uno de lo que sea
que lo estés usando. Entonces déjame seguir adelante y
mostrarte cómo funcionan estos. Primero, seguiremos adelante y
crearemos una variable entera. Entonces solo diremos int
num uno es igual a cinco. Entonces por debajo de eso, seguiremos adelante y realmente usaremos
estos operadores. Entonces, para un ejemplo, vamos a seguir adelante y usar el operador
de incremento. Para ello. Vamos a decir uno más,
más y luego un
punto y coma al final. Y ahí lo tienes. Ahora va a sumar uno a num uno y los
hombros a ti. Seguiremos adelante e
imprimiremos el num uno. Núm uno, así como así
y ejecutamos nuestro programa. Como puedes ver, dice sexo. Y si tuviéramos que hacer lo
contrario aquí y decir menos, menos y volver a ejecutar nuestro programa. Dirá por ahora, esto es exactamente lo mismo que
si hiciéramos lo siguiente. Entonces voy a
comentar eso rápido y solo decir num uno. Num uno menos uno. Así como así. Y cuando voy, como pueden ver, de nuevo, si
tuviera que poner un plus, habría mandado seis. Entonces como pueden ver, es exactamente lo mismo. Simplemente es mucho
más rápido y mucho limpio decir num uno menos, menos o más, más. Después hacer num uno es igual a 91 y luego más o
menos y luego uno. Y a menudo necesitarás
simplemente restar o sumar uno a algo,
especialmente en programación. Entonces esa es otra
razón por la que esto está disponible para ti y por qué
es una buena herramienta para tener. Ahora una cosa más que
quiero
mostrarles es que en realidad puedes poner estos operadores
al otro lado de la variable y en realidad
hace algo diferente. Entonces si seguimos adelante y borramos esa línea que
acabamos de crear y luego descomentar o num uno con el
operador de decremento ahí. Si pongo el menos,
menos en el otro lado o el operador decremento
y ejecuto nuestro código, va a
imprimir lo mismo. Se podría pensar, oh, bueno,
funciona de la misma manera entonces, pero en realidad es algo
diferente que está pasando aquí. Y te puedo mostrar lo que es eso. Entonces, sigamos adelante y
creamos otra variable. Llamaremos a esto num dos
y lo pondremos igual a. También. Sólo para mostrarte algo
rápido mientras estamos aquí, acaso
lo veas en otro lado, puedes hacer lo siguiente. En lugar de decir int
num dos es igual a cinco, podrías simplemente decir int num dos, y luego entre paréntesis, podrías tener cinco. Y esto es exactamente lo mismo. También podrías verlo entre
corchetes, así. Esto también es
exactamente lo mismo que si yo
acabara de decir num dos equivale a cinco. Sólo quiero mostrarte
esto en caso de que lo veas. Pero personalmente, lo encuentro menos elegible y
no lo veo a menudo. Entonces me gusta simplemente decir que mi
variable es igual a lo que sea. ¿Bien? Entonces solo voy a seguir
adelante y decir num dos es igual a 0 por ahora. Ahora aquí abajo, si recuerdas, teníamos r menos menos
y luego num uno, en lugar de poner a nuestro
operador del otro lado. Y cuando ejecutamos nuestro código, hizo exactamente
lo mismo que antes. Restamos uno de
nuestra variable num uno, y luego lo imprimimos. Pero esto en realidad es diferente. Y tal vez te estés preguntando,
¿en qué se diferencia? Bueno, aquí abajo, si digo
num dos es igual a menos, menos num uno, y luego en realidad imprimo num dos
y ejecutamos nuestro código. Va a mirar, ya lo has visto justo antes
porque yo tenía cuatro años. Pero si realmente seguimos adelante y volvemos
a poner esto al otro lado, ya verás cuál es
la diferencia. Entonces si borramos esto
nuevamente y lo movemos
al otro lado donde lo teníamos originalmente y ejecutamos nuestro código. En realidad va a decir cinco. Y si imprimimos el
num uno aquí abajo, voy a seguir adelante y
ponerle eso en una nueva línea, solo para que sea un poco
más legible. Entonces si ejecuto un código,
se puede ver que eso va a imprimirse por ser num uno. Y luego va a
imprimir cinco siendo el num dos. ¿Por qué es eso? Bueno, déjame decirte. Entonces num uno menos menos
restará uno de num uno. Num uno será igual
al resultado de eso. Entonces num uno es igual a cuatro, pero en realidad devuelve el valor antes de que ocurra esta
operación. Entonces es básicamente lo
mismo que si
dijéramos num dos es igual a num uno. Y puedes mirarlo así
si solo resaltamos esto al final de nuestro nombre de variable num
one aquí, básicamente solo dice
num dos es igual a num uno. Y luego después
sucede
esta operación e
imprimimos ese resultado. Pero si movemos eso
al otro lado y luego resaltamos ese mismo rango siendo entumecido a todo el camino
hasta num uno. Se puede ver que la operación
ocurre dentro de eso. Y la operación en realidad
sí sucede primero aquí. Entonces ahora va a
decir que num dos es igual a cualquiera que sea el resultado
de esta operación, num uno aún
se restará. Entonces, sigamos adelante y veamos
cómo se ve eso. Entonces si volvemos a ejecutar nuestro código,
se puede ver que allá atrás
dijimos num uno igual a cinco, m2 es igual a 0. Y entonces num dos fue igual al resultado
de esta operación, que fue para num uno
menos uno es cuatro. Entonces cuando imprimimos el num uno, también tiene cuatro
porque todavía
restamos uno del num uno. Entonces el num uno es ahora
cuatro y M2 es igual a eso siendo para los
del otro lado. Una vez más, solo recuerda
que les estamos pidiendo que, sean iguales a num
uno y luego la operación suceda después, ¿de acuerdo? Entonces ahí lo tienes. Ojalá ahora
sepas cómo usar los operadores de incremento y
decremento. Y si no lo
entiendes del todo, está bien. Lo volveremos a usar más
adelante a lo largo del curso. Pero realmente es, Lo
único que hay que
quitarle es que el operador plus plus o
el operador de incremento, es lo mismo que decir num1 es
igual a num uno más uno. Entonces esto de aquí, esto de aquí
son exactamente lo mismo. Lo mismo sería si dijera
menos menos n, menos uno. Sin embargo, si estás usando
esto en una operación, así que si quería decir num
es igual a num uno más, más, por ejemplo, entonces num dos
será igual a num uno. Y entonces esta operación
sucederá normalmente. O si pongo el plus plus
del otro lado aquí, entonces el num dos será igual
al resultado de esta operación. De todos modos, eso es todo para
este video, el siguiente video, vamos a estar repasando un nuevo operador matemático
llamado el módulo. Así que gracias por mirar, y te veré
en la siguiente.
20. Capítulo 5 (Operadores): Módulo: Este video,
vamos a estar repasando en el operador de módulo, que es el signo
porcentual aquí. Y este operador te da el resto de la división. Entonces lo que quiero decir con eso, bueno, sigamos adelante
y probemos. Entonces primero crearemos
un par de números. Entonces digamos que soy uno igual a diez. Y luego int num
dos es igual a tres. Entonces seguiremos adelante
y usaremos a este operador. Entonces digamos num uno
módulo número dos. Así como así. Y entonces vamos a necesitar asignar el resultado de
esto a algo. Así que en realidad vamos a crear otro
entero llamado la zona. Entonces digamos resultado es igual a
0 por ahora mismo. Y luego aquí abajo, estableceremos el resultado igual a num
uno módulo num dos. Entonces, ¿qué va a hacer esto? Bueno, va a tomar num uno rosado bronceado y dividirlo por 33, va a pasar a 103 veces, y luego queda un
resto de uno. Entonces, si seguimos adelante
y ejecutamos nuestro programa, los resultados deberían ser iguales
a uno, pero aún así tenemos que imprimirlo. Así que adelante y di CL, resultado. Se consiguió ejecutar su código.
Y ahí tienes. Eso es lo que resta
de nuestra división. Y si tuviéramos que dividir
esto y ejecutar nuestro programa, se
puede ver que
obtenemos un resultado de tres. Y eso es porque el
resultado es un valor entero, es
decir, solo contiene números
enteros en tres, solo entra completamente en 103 veces. Entonces es por eso que el
resultado es tres. Y en realidad vamos a estar
hablando de esto un poco más en un
próximo video aquí. De todos modos, eso
es todo para este video. En el siguiente video,
vamos a repasar algunos operadores de
asignación diferentes. Así que gracias por mirar, y te veré
en la siguiente.
21. Capítulo 5 (Operadores): asignación: En este video,
vamos a estar
repasando algunos operadores de asignación. Ahora, en el pasado,
si quisiéramos agregar un número a una variable actual, tendríamos que decir
algo así. Uno, por ejemplo, equivale a diez. Y luego para hacer nuestras matemáticas, tendríamos que decir num es igual a num uno más
cinco, por ejemplo. Y esto
nos dará el resultado 15. Entonces num uno, ahora somos iguales 15 porque nuestro operador de
asignación toma todo del
lado derecho y lo asigna a
lo que hay a la izquierda. De ahí por qué se le llama
el operador de asignación. Ahora bien, algo más que podemos hacer, que es más rápido
es lo siguiente. Podemos decir num uno más iguales. Hola. Esto va a hacer exactamente
lo mismo que tenemos aquí arriba es simplemente más rápido. Entonces déjame seguir adelante y
demostrarte esto. Entonces dijimos int num
uno es igual a diez, y luego num uno es igual a num uno más cinco, que debería ser 15. Entonces para ver esto, vamos a seguir adelante y decir C fuera. Y luego vamos a seguir adelante y crear una nueva línea también. Entonces por debajo de eso
dirá num uno es igual a diez, solo para ponerla de nuevo a
lo que originalmente era. Y luego aquí abajo, lo
volveremos a imprimir. Entonces voy a decir CL uno. Otra vez. Adelante y ejecuta un programa. Entonces ahí vamos. Imprimimos 15 veces. Como dije, los de aquí. Y esto de aquí son
exactamente lo mismo. Es sólo taquigrafía. Y en realidad puedes
reemplazar este símbolo más aquí con cualquiera de nuestros
otros operadores. Entonces podría decir menos
es igual a cinco, por ejemplo, lo
sé impreso, impreso 15 de este primero
y luego cinco de aquí abajo. Es sólo una
forma mucho más rápida de hacerlo. Y sólo para
mostrarte que incluso
funciona con el operador de módulo. Y cuando un programa en el resto de diez
dividido por cinco 0. Entonces de todos modos, eso
es todo para este video. En el siguiente video,
vamos a estar
hablando de algo llamado
la concatenación. Así que espero verte ahí. Gracias por mirar y nos
vemos la próxima vez.
22. Capítulo 5 (Operadores): Concatenación: En este video, vamos a estar hablando de
concatenación de cadenas. Esencialmente lo que esto dice
es la capacidad de tomar dos cadenas diferentes y combinarlas en
una nueva cadena. Entonces, sigamos adelante y echemos
un vistazo a cómo hacer esto. Primero, sigamos adelante y creamos dos cadenas diferentes
para combinar juntas. Así que vamos a decir cadena
firstName es igual, y luego seguir adelante y poner
en el nombre que quieras. Y luego vamos a hacer lo
mismo por LastName. Entonces vamos a seguir adelante y hacer una cadena más para un nombre completo. Entonces vamos a decir cadena por mí. Y sólo vamos a declarar éste en vez de
inicializarlo. Así como así. Entonces sigamos adelante y en realidad concatenar y o combinar
estas cadenas juntas. Así que simplemente vamos
a decir nombre completo es igual a nombre, apellido. Bien, ahora si seguimos
adelante e imprimimos eso, entonces podría simplemente decir CL, nombre completo. Por cierto, si estás
usando Visual Studio y tienes algún tipo
de error ortográfico, o simplemente quieres
renombrar cualquier variable, realidad
puedes simplemente
hacer clic derecho sobre ella. Y luego haz clic en Cambiar nombre. Y luego solo sigue adelante y
pon aquí el nuevo nombre. Entonces puedes
seguir adelante, golpear vista previa. Y esto realmente
te mostrará todos los lugares en los que
va a estar reemplazando el
nombre de esa variable. Y puedes seguir adelante y desplazarte por tu
código aquí abajo para ver cómo se
verá eso y luego presionar aplicar. Y ahí tienes. Bien, entonces ahora si seguimos
adelante y ejecutamos nuestro programa, se
puede ver que junta
ambos nombres. Y digamos que queríamos tener estos separados por un espacio. Bueno, podríamos simplemente poner un espacio aquí
arriba y nuestro nombre o
apellido, o podemos simplemente
tirarlo aquí abajo. Para que podamos seguir adelante y poner
en un espacio vacío así, lanzar un, otro
signo más así, y ahí vamos. Entonces como se puede ver
impreso o nombre completo e incluso
a través de nuestra cadena literal ahí mismo.
Y ahí tienes. Esa es probablemente la forma
más fácil de combinar dos o más cuerdas juntas. Y solo recuerda que esto
en realidad se llama
concatenación de cadenas. Y hay una manera más. Voy a seguir
adelante y mostrarte. Este método es técnicamente
más rápido que el primero. Pero no lo uso con tanta frecuencia solo porque personalmente
encuentro esto mucho más fácil de leer y
porque es más
fácil combinar más que solo
dos cosas juntas. Pero seguiré adelante y te
mostraré esto de todas formas. También solo un aviso. Podríamos haber hecho lo
mismo
aquí arriba cuando declaramos
nuestro nombre completo. Entonces, si
quisiéramos, podríamos simplemente copiar todo
esto aquí mismo. Y entonces aquí arriba,
podríamos haber dicho iguales, pegar eso en el trabajo como casa. Y así seguiré adelante y ejecutaré mi código aquí solo para que veas que ahí vas. No hay diferencia alguna. Entonces, ¿a qué hace esta otra manera a la
que me refería? Entonces, en lugar de usar el signo más para combinar dos o más encogimiento
juntos, bueno, podemos hacer es simplemente
seguir adelante y eliminar esto fuera de nuestro
nombre aquí, así como así. Y entonces sólo
vamos a decir punto append en todas minúsculas. Y luego entre paréntesis, en realidad
podemos simplemente lanzar la variable o la cadena que queremos combinar a esto. Y una
nota más rápida para aquellos de ustedes que usan Visual Studio, esta cajita que
aparece que
te muestra lo que
está buscando este método. De hecho puedes hacer click
en las flechas ahí y te mostrará las
diferentes opciones que tienes. Entonces solo un aviso sobre eso. De todos modos, vamos a
seguir adelante y tipo de apellido aquí. Así. Y lo que esos van a hacer, va a tomar
nuestro FirstName
y agregarle el lastName. Ahora bien, si seguimos adelante
y ejecutamos nuestro código, se
puede ver que hace
exactamente lo mismo. Sin embargo, como
dije, personalmente me parece esto
un poco menos legible y más molesto si quisiera agregar más de
una cosa juntos, concedido, podríamos
simplemente poner un espacio
aquí arriba y nuestro apellido,
y eso va a funcionar. Pero y si estuviéramos
obteniendo esta información del usuario y no
escribiéndola directamente, sería un poco incómodo de
usar de esa manera. Así que vamos a seguir adelante y dejarlo así.
Y ahí tienes. Ahí
están las dos formas principales en las que vas a concatenar o combinar cadenas juntas
en C plus plus. Así que gracias por mirar, y te veré
en la siguiente.
23. Capítulo 5 (Operadores): fundición y truncación: En este video,
vamos a estar hablando casting además de truncar. Ahora el casting es básicamente tomar un tipo de datos y
convertirlo en otro. Y truncar es básicamente cortar el
final de algo. Y te voy a mostrar
lo que quiero decir con eso aquí en sólo un segundo. Bien, entonces primero, sigamos
adelante y echemos un
vistazo a truncar. Así que solo vamos a
crear un flujo básico, digamos float num1 es igual a 5, y luego ir y escribir cualquier número decimal
que quieras allí. Y luego Dumbo eso. Vamos a seguir adelante
y decir int num dos y ponerla igual a num uno. Además, no olvides poner una F al final de
aquí, valor flotante aquí, para que le digas a nuestro
programa aquí que esto es en realidad un flotador
y no un doble. Muy bien, entonces ahora si seguimos
adelante e imprimimos el num dos, en realidad solo va
a imprimir cinco. Y voy a ir a
mostrarte eso ahora. Entonces, como pueden ver,
solo imprimió cinco. Y tal vez estés pensando que este número apenas se está
redondeando a la baja, pero ahora te voy a mostrar
que ese no es el caso. Entonces incluso si tuviera que
poner algo así como 5.99999 y volver a ejecutar nuestro código. Todavía sólo
va a decir cinco. Y eso es porque un valor
entero no puede tener ninguna precisión después de
un punto decimal, ¿verdad? Simplemente tiene números enteros. Y lo que realmente sucede
en C plus plus como
eso, solo va a truncar todo después
del punto decimal. Como dije al
inicio del video, truncar significa
simplemente cortar algo. Entonces básicamente cualquier
número que tengas que convertir
a un entero, y solo va a
mantener el número entero e ignorar el punto decimal y todo lo
pasó por completo. Entonces, sea cual sea este número, no importa lo que haya pasado
el punto decimal, solo va a
guardar el número entero. Y este tipo de
casting donde
convertimos un tipo de datos siendo nuestro flujo aquí a otra mano. No tuvimos que
hacer nada extra. Acabas de escribir esto ya que
estableceríamos cualquier variable igual a otra se
llama casting implícita. Se cambia automáticamente sin ningún
trabajo extra de nuestra parte. Ahora, voy a
seguir adelante y mostrarles un ejemplo de x más
un casting donde le
decimos a nuestro programa aquí que
queremos cambiar de un tipo de
datos a otro. En concreto, te voy a mostrar
cómo esto va a ser útil. Muchas veces tu programa
va a seguir adelante y simplemente lanzar
implícitamente algo o convertirlo de un tipo de
datos a otro. Y sólo tienes que seguir adelante
y correr normalmente. Y no va a tener
ningún problema haciendo eso. Como dije, si
fuéramos a correr
eso, va a funcionar bien. No hay problemas. Eso solo va
a cortar todo más allá del punto decimal
porque un entero no puede contener un número entero. E incluso si tuviéramos
que hacer un doble aquí en vez de un flujo y poner en algún número largo loco después del
punto decimal así, y luego cambiarlo a un flujo. Entonces nuestro num dos ahora es
un flujo y va a cambiar este doble
aquí en un valor flotante. Y si ejecutamos nuestro programa, se
puede ver que simplemente
sostenía lo que pudo. Y la forma en que hace esta conversión es un poco
confusa y no siempre va a funcionar lo hizo aquí donde
parece que acaba de redondearse
más allá de cierto punto. Realmente no
recomendaría hacer esto a menos que realmente no te importe la precisión extra ya que la forma en que se maneja, como dije, puede ser bastante confusa y
a veces podrías obtener un
número completamente diferente al que esperabas. Entonces solo un aviso
sobre eso ahora mismo, déjame seguir adelante y
mostrarte un ejemplo de cuándo
querrías convertir explícitamente algo
a un tipo de datos diferente. Entonces, sigamos adelante
y borremos todo esto. Vamos a seguir adelante y
decir int num uno es igual a diez. Y luego int num
dos es igual a tres. Así como así. Entonces vamos a seguir adelante y
crear un flotador llamado resultado. Establecerlo igual a num
uno dividido por num, comenzando diez,
dividiéndolo por tres. Y luego abajo de esto, sigamos adelante e
imprimamos o volemos. Entonces digamos C salir
y ejecutar un programa. Como puede ver, acaba de
imprimir tres, aunque diez dividido por
tres no es exactamente tres. Y la razón de
esto es porque ambos de estos aquí
son valores enteros. La ecuación se
realiza con números enteros, y los enteros no pueden
contener un número entero. Entonces solo nos dio tres y luego puso resultado
aquí igual a eso. Pero si queremos que obtenga el valor
de flotación adecuado de esta división, en realidad
podemos convertir
explícitamente ambos
números en un flotador. Y la forma más fácil de hacerlo,
que verás en muchos lenguajes de programación basados en el lenguaje C es
ser la siguiente. Entonces vamos a seguir adelante
y poner paréntesis antes de nuestra variable aquí. Y luego dentro de
estos paréntesis, simplemente
vamos a poner
el tipo de datos que queremos, esta variable aquí, o el tipo estándar
aquí, lo convertimos a. Entonces vamos a seguir adelante y decir
flotar así como así. Y entonces aquí vamos a hacer lo mismo. Entonces ahora tenemos que
flotar variables, siendo
una diez y la
otra tres, y van a ser divididas. Y entonces el resultado de
esa ecuación se pondrá aquí
en nuestra variable de resultado, que luego se
imprimirá en la consola. Entonces seguiremos adelante
y ejecutaremos un programa. Y como pueden ver ahora, tenemos el valor adecuado. Y eso es porque la
ecuación se hizo con flotadores. Se almacenó en un valor de flotación. Y nuestro resultado aquí fue
ese igual a eso. Ahora bien, ¿y si seguimos adelante y eliminamos uno de estos moldes de un tipo de datos a otro
de nuestra ecuación aquí, y luego volvemos a ejecutar nuestro programa? Como se puede ver, aún funcionó. Y aunque acabemos de
hacerlo con el otro, así y ejecutamos nuestro programa. Yo también trabajaría. Sin embargo, no haría esto
solo para estar en el lado seguro, pesar de que esta era una ecuación bastante básica y
funcionó, recomendaría
hacerlo con ambos números. Otro ejemplo de esto
que nos viene bien
sería como si estuviéramos trabajando
con un tipo de datos char. Entonces, por ejemplo, si
cambiamos nuestro primer entero aquí a char num1 y lo
pusimos igual a diez debido al gráfico
de tabla A-S-C-I-I, esto no es en realidad diez. Y te puedo mostrar que si
tuviéramos que imprimir esto, si sub c out num uno, así como esto y
ejecuto nuestro programa, en realidad imprimimos una pestaña
radical, creo. Déjame seguir adelante y cambiar
esto a otro número. Un mejor ejemplo aquí. Como puedes ver,
imprimió z y eso es por
ese gráfico de tabla del que hablamos cuando
hablamos de chars, ese 122 no es en realidad
el valor 122. Pero si quisiéramos imprimir 122 de nuestra variable char aquí, podríamos haberla
convertido aquí abajo. Entonces digamos que queremos convertir esto en un int
que una vez más, solo poniendo entre paréntesis, el tipo de datos que queremos
y ejecutando nuestro programa. Y ahí tienes. Y ahora imprimió
el valor entero de nuestro char siendo 122. Ahora, C plus plus en realidad ofrece una forma diferente de convertir de un tipo de datos a
otro explícitamente. Eso es diferente de
muchos lenguajes de programación que se basan en
el lenguaje C. Entonces la forma en que se hizo esto, como si siguiéramos adelante y
quitáramos nuestro costo anterior aquí y dijimos estática todo bajo caso,
subrayado, elenco. Y luego dentro de un símbolo
menor que y mayor que, poner el tipo de datos al que
queremos convertir esto. Entonces por ejemplo, y luego la variable que queremos
convertir dentro de paréntesis. Al igual que si ejecutamos nuestro programa, puedes ver que esto
funciona bien. Ahora bien, si
lo quieres hacer de esta manera, puedes. Técnicamente, es mucho
más seguro hacerlo de esta manera. Y también es más notorio
que estamos cambiando esto a un tipo de datos diferente
usando el casting siempre. Porque también trabajo con otros lenguajes de programación
C, prefiero simplemente
hacerlo de otra manera. Y tampoco encuentro
realmente que los riesgos de hacerlo sean tan dramáticos
que
no me gustaría escribir todo
esto cada vez que
simplemente quiero cambiar de un tipo
de datos a otro. Entonces, personalmente,
esto me parece mucho más fácil. Creo que es mucho más limpio
y mucho más rápido de escribir. Y a menos que estés
haciendo un montón de conversión o haciendo algo
muy específico con él. Que como dije, si tienes
más curiosidad por eso, siéntete libre de
buscar las diferencias y por qué el otro tipo está disponible en C
plus plus en primer lugar. Pero para mí personalmente y durante todo el
resto de este curso, cada vez que hagamos cualquier
tipo de casting, solo lo
voy a hacer de
esta manera porque sí me resulta mucho más fácil y está hecho de la misma manera y otros lenguajes de programación
C. Entonces me gusta simplemente trabajar con una forma independientemente del idioma
que esté usando. Entonces ahí tienes. Ahora ya
sabes cómo convertir de un tipo de datos a otro
explícitamente cosa como esta. Y siendo implícitamente como cuando lo
llevamos de un
flotador a un entero, y se hizo automáticamente. No tuvimos que poner
ninguna cosa extra. De todos modos. Eso es todo
para este video. Gracias por mirar, y te
veré en la siguiente.
24. Capítulo 6 (Conditionals): alcance: En este video,
vamos a estar hablando variables, alcances de variables. El alcance es básicamente
solo una sección de su código donde se puede acceder a una
variable. Y en
términos generales, hay tres lugares principales donde se puede declarar una
variable. El primero está dentro de una
función como la que hemos estado haciendo, o dentro de un bloque de código, que se entiende por un
corchete abierto y cerrado como este. El segundo estaría
dentro de la definición de un parámetro de función y
donde se ubicaría ese. Por ejemplo, en
nuestra función principal aquí está entre
estos paréntesis. Ahora vamos a entrar en los parámetros de
función cuando
hablemos de funciones
y/o métodos allí más adelante en el curso. Y el tercer lugar principal
donde verás una variable declarada está fuera
de tu función por completo. Y a esto se le llama
una variable global. Entonces voy a seguir adelante
y mostrarte eso ahora y te mostraré las
diferencias entre una variable declarada
dentro de un bloque de código o función aquí y una
declarada fuera de una. Ahora las variables rápidas reales
declaradas incentivo, un bloque de código o
función generalmente se
van a llamar
una variable local, quiere, declararla
fuera de eso, se va
a llamar global variable. Entonces déjame seguir adelante y
mostrarte eso ahora. Entonces un ejemplo de una variable
global
sería si dijéramos en Louisville, simple y la pusiéramos igual a cinco. Ahora, para mostrarte un ejemplo
de una variable local, con la
que hemos estado trabajando lo largo de todo este curso. Sólo diremos int número local. Este igual a cinco también. Bien, así que ahí tienes. Esta de aquí es una variable
global. Esta de aquí abajo
es una variable local. Entonces, ¿cuáles son las principales
diferencias entre estos dos? Bueno, debido a que esta variable se encuentra fuera de
cualquier bloque de código, una vez más significada por corchetes abiertos
y cercanos, se puede acceder a
ellos en
cualquier parte de nuestro programa. Concedido, solo recuerda que el código se lee de arriba a abajo. Entonces, en cualquier lugar por debajo de esto, podríamos usar y acceder a
esta variable como de costumbre. Entonces, por ejemplo, pueden
imprimirlo aquí abajo. Y si ejecutamos nuestro código,
verías que funciona bien. Sin embargo, no se puede
acceder a nuestra
variable local fuera del
bloque de código en el que se creó o por encima de ella, porque el código se lee
de arriba a abajo. Ahora, actualmente,
sólo estamos trabajando con una función siendo
nuestra función principal. Pero a medida que nos metamos en trabajar con programas cada vez más grandes, vamos a tener
múltiples funciones. Así que fuera de solo nuestra
función principal también tendremos funciones que hemos creado
nuestro yo, por ejemplo. Y esta variable local no
podría
ser accedida fuera de
nuestra función principal aquí. Eso es porque para uno, no
fue declarado ni
creado en ningún lugar por encima de esto. Y debido a que es local y solo está disponible dentro de
este bloque de código, cuanto tengamos algún código
fuera de este bloque aquí, ya no es accesible. En términos generales, bien
podría simplemente no existir fuera de ese
bloque que fui creado. Y ahora, sólo para recapitular, una variable local como una creada, básicamente dentro de una función
o dentro de un bloque de código. Y una variable global como una
creada fuera de eso. Y en términos generales,
una variable gobo estará disponible en
todas partes de tu código. Y una variable local
sólo estará disponible dentro del bloque que
se creó y esa es la
forma más fácil de pensarlo. Uno es local al
bloque que se creó en y cuando como crédulo
disponible en todas partes. De todos modos, si no
entiendes completamente este concepto, no te
preocupes por ello. Vamos a estar trabajando
con ello un montón, así que obtendrás un montón de cosas
sobre la práctica y los ejemplos. Pero sólo quiero
hacerte consciente de este concepto. De todos modos, eso es todo
para este video. El siguiente video, por fin
vamos a estar hablando de
declaraciones condicionales son no a
poder comprobar por diferentes condiciones
lo que va a ampliar
infinitamente
las posibilidades que tienes con tu código. De todos modos, gracias por mirar, y te veré
en la siguiente.
25. Capítulo 6 (Conditionals): introducción a los condicionales: En este video, sólo
voy a estar dando una breve introducción a las declaraciones
condicionales. Entonces básicamente una
declaración condicional como algo que comprueba para ver si la
condición es verdadera o falsa. Y sólo si esa
condición es cierta, bueno, ejecuta el bloque de
código asociado a ella. Recuerde, un bloque de
código
suele estar representado por un corchete abierto y
cerrado. Entonces por ejemplo, ¿si dijimos
es cinco mayor que uno? Bueno, sí, porque cinco
es mayor que uno, esta condición sería cierta y se
imprimiría Hola. No obstante, si preguntábamos si
cinco es menor que uno, esa condición sería falsa en este código se
saltaría por completo. Entonces eso es básicamente lo es
una declaración condicional y cómo funciona. Básicamente solo comprueba para
ver si una condición es verdadera. Y si lo es, ejecutará el bloque de código
asociado a él. De lo contrario ese bloque
de código se omite. Ahora estaremos trabajando
con esto muchísimo en los próximos videos y creando nuestras propias declaraciones
condicionales. Así que vas a tener una tonelada
de práctica práctica. ¿Cómo es que estos se pueden usar para
un sinfín de cosas diferentes? Por ejemplo, digamos que
estabas creando un juego. Quizás quieras ver si
alguien es el primer jugador o si presiona el botón o completó cierto nivel
o algo así. Entonces espero que haya sido bastante
fácil de entender. Si no, como dije, no te
preocupes por ello. Vas a estar recibiendo
mucha práctica y más información y
los próximos videos. Yo sólo quería darle
una breve introducción concepto
de declaraciones
condicionales
antes de que sigamos adelante. Así que gracias por mirar, y te veré
en la siguiente.
26. Capítulo 6 (Conditionals): operadores de relación y de igualdad: En este video, vamos a estar repasando
operadores condicionales. Ahora, los operadores condicionales están ahí
para ayudarte a verificar diferentes condiciones. Entonces, sigamos adelante y echemos un vistazo a los seis tipos
diferentes. Entonces el primero que tenemos aquí, que se crea
usando dos signos iguales, comprueba si algo es
igual a otra cosa. Entonces, por ejemplo,
cinco equivalen a cinco. Y es importante
recordar que esto requiere de dos signos iguales
porque es solo uno de ellos sería el operador de
asignación con el que hemos estado trabajando
en los videos pasados. Entonces, si quieres verificar si
algo es igual a otro, usaremos un signo doble
igual como este. Ahora bien, el que está debajo de esto, que usa un signo de
exclamación y luego un signo igual comprueba si algo no es
igual a otra cosa. Y luego
al lado de estos, voy a seguir adelante y
darte un ejemplo de donde este operador
crearía una verdadera condición. Entonces podemos decir que cinco
es igual a cinco. Y luego aquí abajo, para
esto no es igual a uno, obtenemos decir, tres
no es igual a cinco. Y esto será cierto porque
tres no es igual a cinco. Entonces ahora es solo un signo de
exclamación seguido de un signo de igual. Y no te preocupes, los
usaremos en los
próximos videos, compartiremos y pondremos algo de
práctica con estos. Yo solo quería
darte una introducción a cada uno de los diferentes operadores
condicionales. El siguiente es el símbolo
mayor que, que estoy seguro que muchos de ustedes
han visto en el pasado, que es sólo el símbolo
mayor que y algo
así sería cierto. Entonces, ¿diez es mayor que tres? Sí, sí, lo es. Entonces esto sería cierto. Y entonces podríamos hacer lo
contrario aquí abajo. Entonces digamos tres, menos de diez. Y este es
solo el
símbolo menos que que
probablemente hayas visto antes. Ahora bien, este de aquí es un poco diferente a lo que has
visto en el pasado, donde normalmente
tendrías la línea debajo del símbolo mayor que. Pero es bastante sencillo. Sólo vas a ser
el símbolo mayor que seguido de un signo igual. Sólo vamos a comprobar
si lo que está a la izquierda es mayor o igual que
lo que está a la derecha. Y todos estos
van a ir de izquierda a derecha, solo para que lo sepas. Entonces, por ejemplo,
podemos decir que es diez mayor o igual a cinco? Y que habría
verdad porque diez es
mayor o igual a cinco y
así incluso podría ser diez, y eso sería cierto también. Y luego abajo, tenemos
el menor que o igual a, que es sólo un símbolo
menor que, seguido del signo igual aquí. Y podemos tener
algo así como cinco, menos o igual a diez. Ahora bien, estos son solo algunos ejemplos
muy básicos, pero solo tenga en cuenta que en lugar de arrojar valores
reales aquí, en realidad
podemos arrojar
variables que hemos creado, lo que realmente amplía las
posibilidades porque entonces podríamos hacer cosas basadas en la entrada
del usuario, por ejemplo. Entonces van, estos son todos los diferentes
operadores condicionales que puedes usar al trabajar con declaraciones
condicionales. El siguiente video,
vamos a estar
repasando solo unos pocos operadores más. Y luego después de eso,
en realidad vamos a crear nuestra primera declaración
condicional. Así que gracias por mirar, y te veré
en la siguiente.
27. Capítulo 6 (Conditionals): operadores lógicos: En este video,
vamos a estar hablando los tres
operadores lógicos diferentes y C plus plus. Y estos son algunos operadores
más que puedes usar al trabajar
con sentencias condicionales. El primero que tenemos
es el operador y, que se crea
usando dos símbolos n o signos ampersand. Y la forma en que este funciona, ya que comprobará si la
expresión de la izquierda y la expresión de
la derecha son ambas verdaderas, y si eso es cierto, entonces esta condición
en su conjunto será cierta. Por ejemplo, ¿cinco son
mayores que tres? Es tres menos que bien, porque ambos son ciertos. Esto sería cierto sólo si
ambas expresiones son verdaderas. Bueno, sería una verdadera condición. Ahora bien, el de abajo que
es el operador u. Y esto fue creado con estos
dos símbolos radicales aquí. Y la forma en que este funciona es que solo
voy a comprobar si
la expresión de la izquierda o si la expresión
de la derecha es verdadera, si al menos una
de esas es verdadera, la condición en
su conjunto será verdadera. Entonces, por ejemplo, podemos decir, ¿cinco son mayores que tres? Bueno, sí lo
es, ¿tres son
mayores que cinco aunque? La respuesta es no. Porque
éste es cierto. Toda esta condición es cierta
porque solo queríamos
saber si una u
otra era verdad. Y por último, tenemos este operador
NOT que viste en el último video con el
no igual a operador ahí, que básicamente
solo devuelve true si la condición aquí es falsa. Porque cinco es menos de
tres, lo cual es falso. Y estamos preguntando, ¿esto
no es verdad esencialmente, entonces toda esta
condición sería cierta. Entonces solo para recapitular que la forma en que
esto funcionaría aquí como f, lo que hay aquí es falso. La condición en su conjunto
volvería true porque
esencialmente va a estar recuperando lo contrario
de este operador NOT. Y otra forma de
pensarlo, como básicamente estamos
diciendo, ¿no es esto cierto? Y por esta
falsa, no es verdad. Entonces de todos modos, eso
es todo para este video. el siguiente video,
en realidad vamos a crear nuestras primeras
declaraciones condicionales que finalmente
puedes obtener alguna
práctica práctica con el uso estos diferentes operadores y con la creación
declaraciones condicionales. Así que gracias por mirar, y te veré
en la siguiente.
28. Capítulo 6 (Conditionals): si las declaraciones: En este video, estaremos
creando y trabajando con nuestra primera declaración
condicional siendo la declaración if. Y esta es la declaración
condicional más básica que verás
en la programación. Entonces, sigamos adelante y echemos un vistazo a cómo se creó esto. Entonces primero, voy a
seguir adelante y mostrarte
la sintaxis de
cómo crear una declaración if y puedes
copiarlas si quieres. De lo contrario, solo puedes seguir un
poco. Bien, entonces ahí tienes. Básicamente, vamos a decir
f y luego m paréntesis. Vamos a poner una
condición que queremos
comprobar para ver si es verdad
o no. Y si es cierto,
vamos a hacer todo en nuestro bloque de código. Y te habrás dado cuenta de que esto es básicamente lo que
te mostré cuando te presenté por primera vez las declaraciones
condicionales. Así que sigamos adelante y
creamos nuestro primero. Aquí abajo. Vamos a seguir adelante y decir si cinco es mayor que tres. Y luego entre corchetes aquí, vamos a decir C out. Cinco es mayor que tres. Se ve así. Ahora, si ejecutamos nuestro programa, veremos que
se acreditan cinco que tres se
imprimirán en la consola. Y eso es porque nuestra
condición aquí era cierta. Así que básicamente
solo estamos diciendo que si esta condición es
cierta, ejecute este código. Y sólo para mostrarles que esto no
funcionaría si esta
condición fuera falsa, vamos a seguir adelante y
darle la vuelta a esto. Entonces vamos a decir que son cinco,
menos de tres. Y cuando vuelva a nuestro código, ya se puede ver que
no pasa nada. Y eso es porque
todo dentro este bloque de código
se omitirá por completo. Además, algo más que puedes hacer, en
lugar de poner
una expresión aquí es simplemente eliminar
esto por completo. Sólo puedo decir si es cierto, y esto realmente va a
funcionar bien. Como puedes ver, nuestro código corrió. Y también se puede hacer lo
contrario diciendo si es falso. Y ahí tienes. Ahora realmente no puedo pensar en
un gran ejemplo de cuándo
usarías esto en
una declaración if. Pero solo quiero
mostrarte que puedes poner verdadero o falso directamente
en la condición. Y sólo para mostrarte un ejemplo
rápido de cómo usar el operador
NOT del que hablamos
en el último video. Simplemente pondremos
esos falsos aquí, paréntesis, y luego pondremos nuestro operador NOT en el exterior. Y así básicamente estamos
diciendo si lo que hay aquí no es cierto, lo
cual es por esta
falsa, ejecutamos nuestro código. Verás que nuestro código dentro de nuestro
bloque de código ahí se ejecutará. Y van. Ahora, sigamos adelante
y eliminemos ese clic. Y yo solo voy a
poner la verdad aquí solo para que sepas que nuestro
código debería funcionar. Y en realidad voy a quitar estos corchetes solo para mostrarte algo
que puedes hacer, si así lo eliges. Ahora bien, si tuviéramos que ejecutar esto, este código se ejecutaría sin
nuestros corchetes ahí dentro. Y si tuviera que
cambiarlo a falso, así. Y vuelva a ejecutar nuestro código, esto en realidad se saltaría. Y eso es porque C plus plus en realidad te permite eliminar los corchetes cuando solo
estabas poniendo una declaración como esta. Ahora, personalmente, no
recomendaría esto. Creo que es una forma muy
desordenada de escribir código, pero no quería
mostrarte que es posible en caso de que alguna vez lo
veas en el futuro. Bien, así que sigamos adelante
y volvamos a poner nuestros corchetes y
volver a poner nuestro
código dentro. De todos modos, ahí tienes.
Ahora ya sabes cómo crear una sentencia if se convirtió en la declaración condicional más
básica que puedes crear. Muy rápido solo para mostrarte que esto sí funciona con variables. Vamos a crear una pareja aquí. Entonces podemos decir que uno es igual a cinco. Y chico, ese era el número
dos es igual a tres. Entonces aquí abajo,
podemos decir simplemente es num uno mayor que dos? Y porque lo es, nuestro código se ejecutará. Ahora, otra cosa que quiero
mostrarte es que
podrías ponerlos en la misma
línea como yo lo hice aquí arriba. Entonces esto, como pueden ver, eso va a funcionar bien. Y muchas veces voy a
hacer esto si tengo algo muy pequeño para correr dentro
de mi declaración if, Pero normalmente hablando, sí
me parece mucho más limpio tener mis
corchetes en líneas separadas. Además, para aquellos de
ustedes en Visual Studio, realidad pueden simplemente
escribirlo y luego tocar pestaña y automáticamente la
llenará por usted. Así que esa es una forma bastante práctica crear inmediatamente
una declaración if. En hay otras cosas
así que puedes haber creado automáticamente
y Visual Studio. Pero durante este curso, te
recomendaría que
acabas de escribir esto para obtener
la práctica práctica. Ahora, otra cosa que
quería mostrarles a todos ustedes, porque
en realidad pueden poner expresiones mucho más grandes aquí. Entonces, por ejemplo, podríamos decir num uno
mayor que num dos. Y sólo diremos diez
mayores que 35, mayores que uno. Y porque todos
estos son ciertos, esto debería correr, ejecutar un código. Se puede ver
que funcionó bien. Pero si tuviera que cambiar esto a Secretario muestra al final
aquí y vuelva a ejecutar nuestro código. Porque todos esos no
eran ciertos. Esto no corre. Puedes mezclarlos y
combinarlos con signos AND,
o, OR y nos hace
expresión el tiempo que quieras. Pero cuanto más largo y más grande y más complicado hagas esto,
te recomendaría usar paréntesis, igual que lo harías con expresiones
matemáticas para definir tu orden
de operaciones. Entonces, por ejemplo,
podría querer poner estos dos aquí en lugar
de paréntesis. Entonces esto se comprobó primero
y luego verifique esto después. O incluso puedo poner el o
firmar aquí y luego decir como diez mayor que 35
es mayor que seis. Y porque esto sería falso, entonces esto tendría que ser cierto porque me
gustaría saber si esto
o todo
dentro de aquí era cierto. Entonces porque este
se mostrará aquí, aunque este sea falso,
o se ejecutaría código. Porque estamos comprobando si esto es cierto o si esto es cierto. También nota que si no
pones nada dentro de tu paréntesis
aquí, obtendrás un error. Y te pedirá que pongas
algún tipo de expresión. De todos modos, solo para recapitular rápidamente, lo que quiero
que se lleven de este video es que creen
una declaración if. Sólo vas a decir si en todas minúsculas y
luego entre paréntesis, vas a poner una condición
que quieras comprobar si es verdad o no. Entonces dentro de los corchetes, estás esperando poner todo
el código que quieras
ejecutar si se cumple esa condición. Entonces ahí lo tienes. Eso es todo para este video. Gracias por mirar, y te
veré en la siguiente.
29. 28: En este video, vamos a estar hablando de
anidar declaraciones if. Ahora bien, ¿a qué me refiero con eso? Bueno, básicamente es solo
uno a uno si la declaración anida o se establece dentro de otra. Entonces, sigamos adelante y echemos un vistazo a cómo
sería eso. Entonces primero, seguiremos
adelante y crearemos una declaración básica if así. Y luego crearemos otra sentencia
if dentro
del bloque de código para esa
sentencia if. Así como esto. Y luego aquí abajo, vamos a seguir
adelante y cambiar éste a falso, así. Y entonces aquí vamos a seguir
adelante y decir C fuera. Y vamos a imprimir una segunda
declaración así. Entonces sigamos adelante y
copiemos toda esa línea de código y pongamos eso dentro de nuestra
primera declaración if también. Así como esto, cambiaremos
éste para que diga primero. Entonces, básicamente, cómo va a funcionar esta
primera declaración
if es tan
normal como va a verificar. ¿Es cierta esta condición? Y si es así, todo dentro de
este bloque de código se ejecutará. Y si no,
solo va a
seguir adelante y omitirlo por completo. Entonces esta segunda sentencia if
también va a comprobar si la condición dentro
de aquí es verdadera. Y si lo es, sólo
va a ejecutar el código dentro de su bloque de código
estando aquí mismo. Si es falso, se llama
bloque se omitirá por completo. Y entonces el resto
del código de la instrucción del primer paso
se ejecutará de forma normal. Porque si eres miembro, código se lee de arriba a abajo. Entonces como pude como siendo rojo, va a comprobar si
esta condición es cierta. Si es genial, va a seguir adelante y
comenzar a leer este código. Entonces se va a comprobar
si esta condición es cierta. Si es L, lee todo el código
dentro de ahí, y luego continúa. Si no es cierto, este bloque de código
simplemente se omitirá y luego
continuaría con normalidad. Entonces, si ejecutamos nuestro código en este momento, solo
va a
imprimir primero la declaración if. Y si el código dentro
de aquí también era cierto. Entonces, si solo cambiamos eso
a true por ahora, run, nuestro código va a decir segunda declaración if y
luego primero if declaración. Y la razón por la que dijo segunda declaración if primero es porque mi código se lee
de arriba a abajo. Entonces, a pesar de que esta primera afirmación
si era cierta, todavía tenía
que leer
si la segunda era verdadera primero y hacer
todo dentro de ella primero si eso era cierto
antes de continuar aquí
abajo para mostrar tú
que ese es el caso. Si tuviera que cortar este código
y ponerlo por encima de esta primera declaración if así
y volver a ejecutar nuestro código. puede ver que ahora
lo hizo al revés. Entonces ahí lo tienes. Ya sabes
anidar si declaraciones. Y puedes hacer esto tantas
veces como quieras. Ahora, antes de terminar este video, también
volvamos
a un tema anterior, que fue cuando hablamos variables
locales y globales. Recuerden como dije que
una variable local solo
está disponible dentro su alcance o dentro del bloque de código del
que fue creada. Entonces, si creamos una
variable global aquí arriba, llamemos a esto un hueso bajo
y pongamos que sea igual a cinco. Entonces, debido a que aquí tenemos esta variable
global, está disponible
en todas partes en su código debajo de ella. Entonces, lo que eso significa es, en lugar de nuestra
primera declaración if, podemos decir primero si declaración. Y luego después de eso,
podemos imprimir global. Sigamos adelante y
creamos una nueva línea. Y entonces incluso en nuestra
segunda declaración if, también
tenemos acceso a global. Esto también funcionará. Entonces, si ejecutamos nuestro código, va a decir
primero si la sentencia cinco es nuestra variable global. Segundo si declaración. Y también solo para mostrarte que
esto también es posible. Y nuestra variable global, podríamos
declararla aquí y luego inicializarla aquí abajo. Recuerda, quieres
asegurarte de darle un valor inicial a
una variable antes de usarla. Entonces antes de imprimir
eso aquí afuera, quiero decir global, luego darle un valor
inicial, tres. Y esto va a funcionar justamente así
primero si declaración tres. Segundo si declaración tres. Pero ahora sigamos
adelante y echemos un
vistazo a algunas variables locales. Entonces, si nos deshacemos de
eso, antes que nada, notarás que
ya no sabe lo que es global. Simplemente elimine que
son de alguna manera, si tuviéramos que crear
una variable dentro de nuestra función principal, también estaría disponible dentro de nuestras dos declaraciones
if. Y eso es porque por ejemplo si dijimos num uno aquí, y busca ese
igual a cinco, por ejemplo, esto ahora estará
disponible en todas partes debajo de él dentro de su bloque de código. Entonces todo el camino hacia abajo hasta este corchete cerrado
aquí para ese método, en este caso es nuestro método principal. Entonces solo para resumir, nuestra variable local
va a estar disponible en todas partes
debajo de ella porque código se lee de
arriba a abajo dentro su alcance siendo
todo este método aquí. Pero, ¿y si tuviéramos que crear una variable local dentro
de una de estas declaraciones if? Bueno, sólo va a estar
disponible dentro de su bloque. Entonces, si dijimos num
uno es igual a cinco, fuera de ese
bloque de código estando aquí abajo, porque el bloque de código
se ejecuta de aquí para aquí, ya no
podemos acceder a él. Bien podría simplemente no existir. Entonces num uno equivale a diez no trabajo porque
no sabemos lo que es num uno. Es indefinido. Esta variable no existe porque su alcance
está aquí mismo. No obstante, existiría en
nuestra segunda declaración if. Entonces aquí mismo,
todavía podríamos imprimir num uno porque está
dentro del alcance. Entonces ahí lo tienes. Yo solo quería
darte un mejor ejemplo de lo que estaba
hablando cuando hablamos de variables
locales y globales. Así que solo recuerda, una
variable global es una creada fuera del bloque de código en una variable local es
una creada dentro. Una variable global estará disponible en todas partes
después de su creación, una variable local solo
estará disponible en todas partes después de que se haya creado hasta
el final de su bloque de código. Entonces ahí lo tienes. Ojalá eso tuviera sentido. Si no, sigue adelante y
juega un poco con variables
locales y globales solo para ver si el alcance de
su disponibilidad. De todos modos, eso es todo para
este video, el siguiente video, estaremos echando un
vistazo a otro tipo de declaración
condicional conocida
como la declaración if else. Así que gracias por mirar, y te
veré en la siguiente.
30. Capítulo 6 (Conditionals): declaraciones en otras declaraciones: En este video,
vamos a estar echando un vistazo a la declaración if else. Entonces déjame seguir adelante y
mostrarte la sintaxis para la declaración o las reglas cómo se crea esta
declaración. Así que al igual que antes, vas a crear
una instrucción IF básica donde vas a decir
f y luego paréntesis. Pondrás la condición
que quieras verificar. Si es cierto, entonces tu bloque de
código después de él. Sin embargo, justo después de eso, vas a seguir adelante y
poner en la palabra clave else, que también es un todo minúscula, igual que F aquí. Y luego justo
después de que digas otra cosa, vas a poner
solo otro bloque de código sin condición. Entonces básicamente estamos diciendo que si
esta condición aquí es cierta, queremos hacer esto
igual que de lo normal, o puedes pensar en esto
como de otra manera hacer esto. Entonces, sigamos adelante y
veamos cómo funciona esto. Así que aquí abajo, vamos a crear
una sentencia if básica. Entonces vamos a decir si, digamos
cinco es mayor que tres, entonces después de ese
bloque de código vamos a decir más y a notar y
Visual Studio aquí, cómo automáticamente
resalta ambos de estos para mostrarme
esos están conectados. También puedes simplemente
golpear pestaña y
automáticamente creará el
resto de esto para ti. De lo contrario,
básicamente vas a poner otro corchete
abierto y cerrado como este. Así que ahora hemos creado
nuestra declaración FL, pero sigamos adelante
y
veamos mejor cómo funciona esto. Entonces aquí, sigamos
adelante y veamos cómo era cierta
la condición de impresión. Entonces en nuestra declaración else
o bien bloque de código aquí, sigamos adelante y
digamos condición CL. Y la razón por la que nos hice
escribir
thes específicamente es tal conducir a casa
cómo está funcionando esto. Entonces básicamente, vamos a comprobar esta condición como normal. Pero si esta condición es falsa, este bloque de código aquí se ejecutará en una
condición fija es verdadera. Este código aquí se ejecutará. Así que básicamente quieres
usar una sentencia if else cuando quieres ejecutar algo solo si la condición era verdadera, pero también quieres ejecutar algo si la
condición es falsa. Y entonces ahora si seguimos adelante
y ejecutamos nuestro código aquí, van a ver que
va a decir que la condición era cierta porque cinco
es mayor que tres. Pero si seguimos adelante y damos la
vuelta a esto ahora, diré que son cinco,
menos de tres. Y cuando
vuelvan a cortarse, va a
decir que la condición era falsa. Entonces todo en tu bloque de código
F se ejecutará si la condición es
verdadera y todo lo demás. El bloque de código se ejecutará si
la condición es falsa. Sé que solo hemos estado
poniendo una declaración o solo una pieza de código
dentro de estos bloques de código. Pero esto puede ser tan grande
como te gustaría. Ahora mismo, algunos de
ustedes se estarán preguntando, ¿por qué no tomamos
esto y lo dejamos aquí abajo? Bueno, quizá no
hubiéramos querido decir que nuestra condición era falsa
si no lo fuera, cierto. Entonces esto solo nos permite tener un bloque de código específico solo
se ejecutará si eso es cierto en un
bloque específico de código que solo
se ejecutará si es falso. Entonces ahí lo tienes. Ahora ya sabes cómo crear
una declaración if else. En el siguiente video,
vamos a estar viendo algo llamado declaraciones
else-if. Entonces como siempre, gracias por mirar y
te veré en la siguiente.
31. Capítulo 6 (Conditionals): declaraciones de otras declaraciones: En este video, vamos a
estar echando un vistazo a la creación una sentencia else donde básicamente
podemos verificar
si una condición es verdadera, entonces podemos verificar si otra o múltiples otras
condiciones son verdaderas, entonces todavía podemos tener algo corrido si no se cumplió ninguna de esas
condiciones. Entonces, sigamos adelante y echemos
un vistazo a cómo funciona esto. Entonces la sintaxis básica
para esto es que creamos una declaración if tal
como la teníamos en el pasado. Y si esa condición es cierta, este código aquí se ejecutará y luego todo lo demás
se saltaría hasta el final. Pero podemos
tirar esto de aquí para ver si otra condición es cierta en
caso de que la primera no lo fuera, entonces si eso es cierto, que solo se
ejecutará este código y se
omitirá el resto. Y entonces todavía podemos tener otra declaración donde podamos decir que si ninguna de
esas cosas era verdad, todavía
querríamos hacer esto. Y ahí tienes. Esa es la sintaxis básica
para una sentencia else. Así que vamos a seguir adelante y crear
uno de nuestros muy jóvenes. Y solo para
divertirnos un poco con él, sigamos adelante y
creamos un
programa sencillo para esto también. Entonces vamos a decir num uno. Y luego por debajo de eso,
vamos a decir int num dos. Entonces sigamos adelante
y realmente obtengamos alguna entrada del usuario para estos. Entonces diremos les envió
golpe que dirá pecado. Entonces al final de
todo eso va a crear nuestra declaración else. Entonces digamos si uno entumecido
es mayor que dos, entonces queremos
hacer lo siguiente. Entonces di C fuera uno. Y luego entre
comillas aquí, diremos que es mayor que. Entonces también agregaremos. Para hacer eso. Seguiremos adelante y subrayaremos. Y voy a tirar aquí
un par de espacios, solo para que se vea mucho
más limpio cuando se imprima. Entonces abajo de eso,
diremos otra cosa. Y una vez más, todo esto es menos
minúscula que el num dos. Entonces queremos imprimir
lo contrario. Entonces diga CL num uno, num dos. Y luego por debajo de eso
diremos otra cosa. Y entonces recuerden,
no ponemos una condición, solo
estamos diciendo otra cosa. ¿Quieres decir que uno es
igual a dos m? Así como así. Básicamente, vamos a tomar dos y mascotas y tomar una entrada para ellos uno y luego
poner para el número dos. Y entonces vamos
a decir si uno entumecido es mayor que num dos, entonces sólo
vamos a imprimir num uno es mayor que num dos. Else-si o no, si num
uno es menor que num dos, entonces queremos imprimir num
uno es menor que num dos. De lo contrario, si ninguno
de los dos es cierto, bueno, entonces deben ser iguales. Entonces dijimos más num uno
es igual a num dos. Y luego si queremos limpiar esto,
para que se vea un poco
mejor al usuario
o a nosotros en este ejemplo de aquí arriba, podemos seguir adelante y
hacer lo siguiente. Podemos decir C out número, espacio de
dos puntos así. Y luego sólo vamos a
copiar y pegar eso abajo de nuestra sentencia cin num one como así vamos a
decir tipo a, otro número. Y luego seguiré adelante
y alejaré rápido para que ustedes puedan echar un vistazo
completo al código,
asegurarse de que el suyo coincida con el mío. Entonces seguiremos adelante y ejecutaremos nuestro código para
asegurarnos de que está funcionando. Y asegúrate de
ejecutarlo sin depurar o agregar un montón de
estos getline sin dot. Entonces, adelante, ingresa un número. Entonces para tu segundo número, sigue
adelante e ingresa un
número menor que el primero. Y debo decir que nuestro primer número fue
mayor que nuestro segundo número. Y entonces podemos seguir adelante
y volver a ejecutar nuestro programa. Pero esta vez vamos a escribir un número menor
para nuestro primero. Y ahí lo tienes establecido. Nuestro primer número fue
menos de un segundo. Y si lo volvemos a ejecutar, podemos escribir dos
del mismo número exacto. Y hay que decir
que son iguales. Y ahí tienes,
todo está funcionando. Y solo una nota rápida antes de
que terminemos el video, sí
quiero
hacerte saber que
puedes tener múltiples más. Si condiciona aquí dentro
de tu declaración, podrías decir Alice num uno es igual a num
dos por ejemplo, y luego tener un
bloque de código para eso también. Y eso va a funcionar bien. Ahora, obviamente en este ejemplo, bien
podríamos simplemente usar else. Pero entiendes mi punto. Puedes tener tantas
más si declaraciones o condiciones debo
decir como te gustaría. Además, ni siquiera
necesitas esta otra declaración
en la parte inferior. Esto es solo algo
que puedes tener, pero puedes deshacerte
de él por completo en tu código seguirá
funcionando de forma normal. Entonces, si ejecuto mi programa, se
puede ver que está en
funcionamiento, no hay problemas. Entonces, ¿cuándo querrías
usar una sentencia else if? Bueno, en cualquier momento que
quieras verificar por más de una
condición y
todos están relacionados como están aquí. Puedes usar una declaración else. Puedes tener tantos de estos
como quieras, como dije. Y entonces aún puedes incluso arrojar tu sentencia else para que se ejecute un trozo de código
si todo era falso. Y si vuelvo
aquí a lo que teníamos, solo recuerda que en
cuanto se cumpla una de estas
condiciones, todo lo demás que
como parte de esta otra cosa si declaración aquí
va a ser omitido. Si esta condición es cierta, solo va a leer
lo que hay en este bloque de código y luego saltar
hasta el fondo aquí. Si ese primero
es falso y luego el segundo es verdadero, entonces solo leerá lo que hay en
ese bloque de código y se
saltará todo lo demás. Y entonces si nada era cierto, entonces nuestra declaración else
se ejecutará si tenemos una. Así que solo ten cuidado con eso, pero sí se lee de
arriba a abajo y luego solo va a importar la primera afirmación que se haga realidad. Entonces aunque y else-if
declaración aquí, damos la vuelta a esto
y dijimos que es mayor o igual a. Y luego ejecutamos nuestro código, num uno, pongo diez. Para el número dos, pongo
cinco, por ejemplo. Y solo va a
imprimir la pluma es mayor que cinco y menos porque cuanto una de estas
condiciones sea cierta, no le importa el resto independientemente de cuántas declaraciones
else-if tener. Así que solo ten cuidado con eso
y asegúrate de que si quieres verificar
primero una condición, que tengas esa
en la parte superior. Ahí lo tienes. Ojalá tengas una buena
comprensión ahora de cómo funcionan las declaraciones
if else-if y if
else. Y si no, te
recomiendo encarecidamente vuelvas a ver
el video en el que
estás teniendo problemas y tal vez juegues un poco más con él solo para entender
mejor cómo funciona todo. Ahora que dicho esto, verás más a
lo largo del curso. Entonces obtendrás algunas manos más
naturales en la práctica. De todos modos, eso es todo
para este video. Gracias por mirar, y te
veré en la siguiente.
32. Capítulo 6 (Conditionals): cambie las declaraciones: En este video, vamos
a estar echando un vistazo al crear lo que se llama
una declaración switch. Y lo que esto hace es básicamente
tomar un valor entero y luego ejecutar un bloque de código
basado en lo que es ese valor. Entonces aquí mismo, tengo la sintaxis
básica de eso para ti. Así que básicamente vamos a
decir switch y todo minúscula. Y luego entre paréntesis, vamos a poner
nuestro valor entero. Y este podría incluso
ser el nombre de una variable que sea
un valor entero. Entonces vamos a tener corchetes abiertos
y cercanos. Y dentro de eso, vamos a decir mayúsculas, todas minúsculas,
seguidas del número. Queremos comprobar si eso es
lo que es este número. Entonces podemos decir en caso de que
este número sea uno, queremos hacerlo. Después de eso, vamos
a decir romper con coma para romper
esa sección de código. Y entonces aquí abajo
podemos decir el caso dos, queremos hacer esto y luego
lo rompemos también. Y podemos seguir haciendo
esto una y otra y otra vez. Y entonces también podemos
tener un default, o simplemente decimos default en todas minúsculas
seguido de dos puntos. Entonces podríamos hacer esto. Entonces podemos tener
una declaración break al final de eso también, aunque esta no
es necesaria. Entonces cerrando el corchete, y solo puedes tener
una declaración de caso aquí, o dos
o tres , o como dije,
tantos como quieras. Yo sólo tengo un dos aquí para
mostrarles que podemos
tener más de uno. Entonces ojalá eso no fuera
demasiado confuso para ti. Si lo fuera, vamos a seguir adelante y crear uno desde cero. Se puede tener una mejor idea
de cómo funciona esta cosa. Ahora, muy rápido,
es posible que algunos de ustedes ya hayan hecho la conexión de que
esto se ve muy similar a nuestra declaración else. Bueno, eso es porque es las únicas diferencias reales
aquí son que para uno, esto toma un valor entero. En lugar de poder
poner en una condición de falla nuestra expresión que queremos
comprobar para ver si es verdad, entonces simplemente hacemos algo
basado en lo que es ese número. Entonces puedes ver
esto como diciendo f, poniendo nuestro número
y luego algo más, Ceph los números,
este número es este, y luego nuestra otra declaración. Pero solo quiero hacerles
saber que una declaración switch es más rápida. Y muchos casos, si
solo estás tratando de ver
qué es un número, esto va a ser
mucho más legible. Así que sigamos adelante y
creamos uno propio. Así que aquí abajo,
vamos a seguir adelante y decir int respuesta es igual a 0. Entonces por debajo de eso, sigamos
adelante y digamos que el CEO dirá, por favor elija una opción. Y voy a decir espacio de colon. Y luego vamos a poner en un
inline ahí también. Entonces a continuación eso creará
otra sentencia c out. Digamos que escriba uno para el botón Menú principal
y una línea final aquí, o cree una nueva línea. Yo sólo voy a
decir barra inversa n. Para esta, vamos a hacer lo
mismo a continuación, decir cinta a cuatro
opciones. Así como así. Y voy a crear una
nueva capa de nuevo y por debajo de esto
realmente va a crear nuestro switch. Pero antes de hacer eso, sigamos adelante y aceptemos
la respuesta del usuario. Entonces diremos correspondencia. Entonces el acreedor
cambia, si recuerdas, vamos a decir cambiar
y todo en minúsculas. Y luego entre paréntesis, pondremos en un
entero o nuestra variable, en este caso siendo respuesta. Y luego después de eso,
voy a tener llaves
abiertas y cerradas. Y luego entre
esos corchetes, crearemos nuestros casos. O lo que queremos
comprobar para ver si nuestra respuesta o nuestro
entero aquí es igual a. Entonces, por ejemplo, diremos
mayúsculas y minúsculas, por cierto, espacio uno para nuestro valor
que queremos verificar, y luego dos puntos. Entonces después de eso,
diremos CL menú principal. Entonces, bueno que
vamos a seguir adelante y decir romper todas minúsculas con
punto y coma al final. Después de eso, crearemos
otro caso para dos, y diremos
opciones. Así decir caso. Opciones de SEO de Coleman. Por cierto, para aquellos de ustedes que
utilicen Visual Studio, es posible
que hayan notado que automáticamente
pondrá una segunda
comilla para usted. Sin embargo, si
terminas escribiendo otra
cotización por tu cuenta, simplemente
se saltará eso. No va a
causar ningún problema. No va a lanzar
una segunda y
puedes seguir escribiendo. Pero es agradable que crea
turno para ti por si te olvidas. Entonces seguiremos adelante
y pondremos punto y coma
al final y volveremos a
decir break. Y en realidad
voy a seguir adelante y poner nuestra c aquí
en una línea separada. Vamos a matar. Creo que se
ve un poco más limpio. Entonces aquí abajo, si
quisiéramos, podríamos seguir lanzando
más casos para verificar. O incluso podemos lanzar un
default si también lo queremos. Y sigamos adelante y
hagamos eso solo por diversión. Así decir default.
Entonces vamos a, eso, vamos a decir CL va a decir opción es en realidad va a seguir
adelante y decir su elección. Como dije, aquí podrías arrojar
otro desglose. Si así lo eliges, algunos de
ustedes pueden encontrar que se ve más simétrico
o lo que tienes, pero no
necesariamente, esencialmente, el SprayC simplemente te
saca de esta sección de código ya que no
los sostiene por corchetes, como hemos visto en el pasado. Y además, a pesar de que
solo tenemos una línea
de código
y agradable, y puedes tener
tantas como quieras, igual que cualquier otro
bloque de código. Ahora voy a
alejarme aquí rápido, para que ustedes puedan asegurarse que tienen
todo esto copiado. Y también crecen rápido para aquellos de ustedes que
se preguntan cuáles eran estos pequeños bloques menos. Para aquellos de ustedes que
usan Visual Studio y muchos otros programas,
cómo esto también, realidad pueden
hacer clic en
eso y en realidad
colapsará todo dentro
de lo que sea que sea. Esto está en If Statements, está en métodos y
otras cosas así, pero aún así dejará
lo que es para ti. Y entonces incluso va a tener las llaves
eran tres puntos aquí. Y si pasas el mouse sobre eso, puedes ver qué código se
está minimizando ahora mismo. Ahora, el código seguirá funcionando. El código seguirá funcionando. Es solo minimizar básicamente. Quiero decir, simplemente puedes
hacer clic en ese
botón más ahora y
minimizarlo por ti. Entonces, si tal vez estás trabajando con mucho
código en algún
momento y la pantalla de repente
se ven un poco desordenadas. Simplemente puedes
cerrar eso una vez que hayas terminado trabajar con algo o si estás tratando de
trabajar en otra cosa. En fin, sólo pensé que te lo
mostraría rápido. De todos modos. Ahora bien, si sigo adelante y ejecuto
nuestro código, ya lo pueden ver. Así que vamos a elegir una opción, escribir uno para mí, muchas
de tipo dos opciones. Entonces sigamos adelante y tecleemos
uno solo para ver qué funciona. Ahí vas. Dice Menú Principal. Y en realidad
voy a lanzar una nueva línea en ambos
solo para limpiarlo un poco, o todos ellos,
debería decir así. Y vuelve a ejecutar nuestro código. Si tomamos dos y
va a decir opciones. Y si lo ejecutamos una
vez más aquí y solo escribimos cualquier número entero
fuera de lo que hemos hecho un caso y presionamos Enter. Puedes ver que
dirá tus elecciones y válido porque ninguno de
nuestros casos fue cierto. Entonces, como puedes ver, funciona muy similar a
una sentencia else if, excepto dentro de
estos paréntesis, necesitarás un valor entero. Y si
quisiéramos, en realidad
podríamos haber escrito un número como este
y ejecutar nuestro código. Y sigue esperando escribamos algo
para respuesta. Para que puedas seguir adelante y hacer eso. Pero independientemente de
lo que escribamos, va a decir menú principal, porque lo que estaba en
nuestro interruptor era uno. Y ahí tienes. Ahora, obviamente no hay realmente una gran razón por la
que harías esto. Normalmente, solo
vas a tirar tu variable aquí y tomar alguna entrada ya que un
interruptor
suele estar ahí
para verificar múltiples opciones, ¿verdad? Entonces vas a tomar
algo que puede variar. Ahora sí quería advertirles, sobre todo para aquellos de ustedes
que pueden estar viniendo de otro
lenguaje de programación si eliminan una de estas declaraciones
break. Entonces en nuestro caso uno aquí, si seguí adelante
y eliminé
eso, en realidad va a ejecutar todo
este código hasta que llegue a otra
declaración break independientemente de si nuestra respuesta fue dos. Y si seguimos adelante y
ejecutamos nuestro código aquí, se
puede ver que eso es cierto. Entonces, si escribo uno, por ejemplo y presiono Enter, va a guardar Menú principal y opciones aunque
escribimos una. Eso es porque
sin ese descanso, en realidad
hace algo
llamado fall-through, donde solo va
a ejecutar y
ejecutar todo el código
dentro de tu switch
hasta que llegue a ejecutar todo el código
dentro de tu switch una sentencia break o al final del interruptor. Y si saqué aquí nuestra otra declaración de
break, se
puede ver que incluso
imprimiría sus elecciones y es válida
si escribimos una. Sin embargo, esta caída
sólo comenzará desde
donde era cierto. Entonces, si escribo en, si vuelvo a ejecutar un programa aquí, debería decir Opciones y luego
tus elecciones y saldo. Entonces ahí tienes. Ahora bien, puede haber
casos en los que quieras que
esta caída pase. A lo mejor se te
ocurra alguna idea ordenada dónde va a ser útil. Y C plus plus es uno de
los pocos idiomas que
conozco que te permitirá hacer eso, al menos por defecto. Pero normalmente, probablemente no van
a querer que eso suceda. Entonces quieres
asegurarte de lanzar el descanso después de cada uno
de estos fuera
del sentido predeterminado, se
detendrá automáticamente una vez
que golpee este corchelo
cerrado de todos modos. Y por último, sólo voy a mostrarles cómo
sería esto. esto hubiera sido otra declaración, solo para mostrarte las
similitudes aquí. Entonces podríamos haber dicho si la
respuesta es igual a uno, y luego ponerlo en nuestro código
aquí fuera del descanso. Y luego por debajo de eso,
vamos a establecer la fuente es igual a dos. Entonces por debajo de eso, solo podemos
decir otra cosa y poner esto adentro. Entonces ojalá puedas ver
las similitudes aquí. Como dije, básicamente
funcionan de la misma manera. Sin embargo, esto
nos permite ponerlo en una condición mucho mayor. Queremos comprobar si
es cierto o esto acaba de poner en
un valor entero. Y personalmente, si esto es
lo que estás haciendo es simplemente verificar un valor entero y querer ver a qué
es igual. Creo que esto
se ve mucho más limpio y también corre más rápido. Entonces ahí tienes. Ahora ya sabe cómo crear una sentencia
switch. De todos modos, eso
es todo para este video. Gracias por mirar, y te
veré en la siguiente.
33. Capítulo 6 (Conditionals): Operador ternario: En este video, vamos
a estar echando un vistazo a un trabajo con algo
llamado el operador ternario. Y también puede
ver esto
referido como un operador condicional. Entonces la sintaxis para un
operador ternario es como tal, vas a tener
una condición que
quieres verificar si
es verdadera o falsa. Y entonces eso va a ir
seguido de un signo de interrogación. Después de eso, vas a tener una expresión o un trozo de
código que quieras ejecutar. Si esa condición era cierta, seguido de dos puntos. Y luego una segunda expresión
o un trozo de código que quieres ejecutar si esa
condición es falsa. Y por último,
vas a cerrar esto con punto y coma. Ahora, abajo aquí, ya
tengo un ejemplo para ti solo para
mostrarte cómo funciona esto. Y no te preocupes,
vamos a estar creando uno propio. Solo quería
mostrarte cómo se vería esto escritura real o
en el código. Entonces mi condición, esta es
una mayor que cinco, seguida de un signo de interrogación
y luego mi primera expresión, o un trozo de código aquí. Entonces en este caso, le
dije C fuera hola, entonces tuve mi colon. Y luego la segunda expresión
o pieza de código que
quiero que se ejecute si la
condición era falsa. Entonces esta C fuera. Entonces, debido a que este
no es mayor que cinco, este trozo de código se ejecutará. Si ejecuto mi programa aquí. Se puede ver que dice comprar. Pero si le damos la vuelta a esto aquí y preguntamos ¿Es uno
menos de cinco? Porque esto es cierto. Entonces nuestro primer
trozo de código aquí, que está en el
lado izquierdo de nuestros dos puntos, volverá a ejecutar el código. Se puede ver que dice Hola. Además, quiero que se den
cuenta de que no puse coma después de
mis comillas dobles. Y eso es porque
este es el final de la declaración, no esto. Bien, así que sigamos adelante y creamos uno de nuestros muy jóvenes. Entonces voy a seguir adelante
y quitar eso. Y luego vamos a decir una. Y por debajo de eso,
diremos el número CN, ¿verdad? Entonces tomaremos un
número que tecleamos. Y luego vamos a seguir adelante y
crédito operador ternario. Entonces vamos a decir
num uno mayor que 0. Y esta será nuestra condición. Después de eso, pondremos
en nuestro signo de interrogación, y luego
seguiremos esto con una expresión o un
trozo de código que
queramos ejecutar si esta
condición es cierta. Entonces vamos a decir C fuera, no uno. Entonces entre comillas aquí, sigamos adelante y digamos que
es un número positivo. Entonces seguiremos
eso con dos puntos. Entonces después de eso, volveremos a
decir C out. Núm uno. Y entonces esta vez vamos a
decir que es negativo. Observe que pongo un espacio antes está en ambos de estos
porque no
va a haber uno por defecto después nuestro num uno esté impreso
o sean enteros ahí. Ahora bien, si ejecutamos el código, podría decir algo así como cinco. Digamos que cinco es
un número positivo. ¿Bien? Pero si volvemos a ejecutar esto, y pongo
cinco negativo y centro, dirán que cinco negativo
es un número negativo. Y eso es porque dijimos
este num uno mayor que 0. Entonces si lo es, dijimos que queríamos imprimir num uno es un número positivo. Y si no fuera mayor a 0, queríamos imprimir num uno es un número negativo, ¿verdad? Ahí vas. Esa es la forma básica de
usar un operador ternario. Y muchas veces
básicamente verás esto usado en lugar de una declaración if else. Entonces, sigamos adelante y
creamos cómo se
vería esto como una declaración de FL. Podríamos haber dicho simplemente
si uno es mayor que 0. Y luego dentro de ahí impreso el num uno
es un número positivo. Entonces solo voy a copiar
y pegar esto desde arriba. Y debajo de eso diremos
más y pegaremos esto en. Y tendremos que
asegurarnos de poner un punto y coma al final de ambas declaraciones de
C out. Y ahí tienes. Así es como podríamos haber
hecho lo mismo con una declaración if else. Pero hay algunas
formas más en las que podemos usar esto. Entonces, sigamos adelante y
echemos un vistazo a eso. Y voy a seguir adelante y eliminar nuestra declaración if-else. Ahora, sigamos adelante
y echemos un vistazo a otra forma en que podemos usar
el operador ternario. Entonces aquí abajo, sigamos adelante
y digamos resultado de cadena. Y pondremos esto igual
a un operador ternario. Entonces aquí mismo vamos a
decir num uno mayor que 0, seguido de un signo de interrogación. Y luego
dependiendo de lo que sea, queremos en realidad simplemente
establecer nuestra cadena igual a dos es un número positivo
o un número negativo, poco como lo hicimos antes. Está justo aquí. Después seguirlo con dos puntos, y luego poner aquí esta
otra cadena. Entonces nuestro punto y coma
al final. Ahora creamos una cadena
llamada result y la estamos estableciendo igual al resultado de
este operador ternario, toda
esta operación aquí. Entonces va a decir como
num uno mayor que 0. Si es así, nuestra cadena
será igual a esto. Y si no lo es, entonces nuestra cadena será igual a esto. Y ahora aquí abajo, sigamos
adelante e imprimirlo. Entonces diremos C out num uno. Entonces después de eso,
imprimo el resultado, va a crear una nueva
línea así. Entonces sigamos adelante y eliminemos nuestra operación ternaria anterior
ahí y ejecutemos nuestro código. Ahora, puedes ver
que prácticamente
funciona de la
misma manera que antes,
con la única diferencia es que en realidad
usamos este
operador ternario aquí para establecer algo igual a un
resultado basado en esto aquí. Y sigamos adelante y volvamos a poner esto en una declaración if else. Entonces digamos que si uno entumecido
es mayor que 0, entonces queremos establecer un
resultado igual a este aquí. De lo contrario Alice establecerá resultado igual a dos es
un número negativo. Así. Ahora puedes
usar lo que quieras, lo que encuentres
preferible con tu situación actual
en tu programación. Solo quería
mostrarte las diferentes formas en las que puedes usar esto. Y en realidad hay
una última forma que vamos a repasar, que es que en realidad se pueden
anidar operaciones ternarias. Entonces todo fuera de nuestra declaración entera
y de nuestra línea de pecado, Sigamos adelante y deshagámonos de él. Entonces. Vamos a seguir adelante y crear una
cadena y llamarlo resuelto. Y no vamos a darle un valor a
esto en estos momentos. Entonces aquí abajo, vamos a seguir
adelante y ver el resultado. Establezca esto igual a. Sigamos adelante y
pongamos en la condición para operador ternario. Entonces, entre paréntesis, en realidad
vamos a decir que num uno es igual a 0. Entonces vamos a dar
seguimiento a eso con un signo de interrogación entre comillas
ahí, así como así. Después pondremos un colon y luego otra operación ternaria. Así que adelante y pon
un paréntesis abierto. Y diremos num
uno mayor que 0, seguido de un paréntesis
cerrado. Entonces lo pondremos en
otro signo de interrogación. Y ahí vamos a decir
citas positivas. Después de eso, pondremos dos puntos
seguidos de negativo
en comillas ahí. Y luego vamos a poner entre paréntesis
cerrados
y punto y coma. Y luego aquí atrás donde
dijimos num uno mayor que 0, vamos a poner entre paréntesis abiertos. Bien, así que sigamos adelante
y desglosemos esto. Personalmente, creo que
parece confuso, pero si ves esto
en el código de alguien, quiero que puedas
leer esto y saber cómo funciona esto. Tan rápido, solo
por mencionar esto. Sí, podríamos haber puesto todo
esto aquí mismo. Simplemente no quería agregar más
a esto ya loco
en línea de cosas. Granitic solo
quiere establecer cadena. De todos modos, sigamos adelante
y repasemos esto. Entonces establecemos un resultado igual, y luego queríamos
establecerlo igual a cualquiera que fuera el resultado de
toda esta locura. Dijimos, es num uno igual a 0. Si lo fuera, entonces queremos
decir que el resultado es igual a 0. Bien, genial. Entonces, si num uno es igual a
0, vamos a decir 0. Pero si no es igual a 0, entonces vamos a hacer otra operación
ternaria por aquí. Entonces yo es num uno mayor que 0. Entonces queremos establecer
resultado igual a positivo y f nada
fue igual a negativo. Y luego echamos todos
estos paréntesis solo para asegurarnos de que el orden
de las operaciones era el adecuado. Entonces dijo como num uno
igual a 0 en caso afirmativo, entonces dijimos 0. Si no, entonces queríamos establecer el resultado igual a lo que fuera entre estos paréntesis
que queríamos hacer con toda
esta operación. Primero, dijimos num uno
mayor que 0 para esta condición, caso afirmativo, entonces
comenzaremos por el positivo. Si no,
lo pondremos en negativo. Y así acabamos de lanzar
eso entre su propio conjunto de paréntesis
para asegurarnos de que el resultado fuera igual
al resultado completo de
esta operación, ¿verdad? Entonces ahí lo tienes. Ya sabes cómo usar
el operador ternario. Ahora, yo personalmente, no
uso mucho esto, pero lo he visto en un montón
de otros programadores de código. Así que sí quería
asegurarme de lanzar este curso para que
ustedes supieran qué era, qué significaba y cómo funciona. Y quién sabe. Personalmente puede que
realmente te guste y quieras usarlo para ti mismo. De todos modos, eso
es todo para este video. Gracias por mirar, y te
veré en la siguiente.
34. Capítulo 7: introducción a los bucles: En este video, solo
voy a estar dando una breve introducción a los
loops y la programación. En los próximos videos, estaremos creando
diferentes tipos de saltos propios. Entonces aquí mismo, tengo
la sintaxis básica o una regla de cómo funciona un bucle. Básicamente vas
a tener una condición, y esta condición funciona la misma manera que
en una declaración if. Entonces, esencialmente, si esta
condición es cierta, vamos a ejecutar un
cierto bloque de código. Y luego después de que ese
bloque de código
se haya corrido, va a volver a verificar si
esa condición es verdadera. Y si es así,
vamos a hacer esto de nuevo. Y sólo va
a seguir haciendo esto y
otra y otra
y otra vez hasta que nuestra
condición sea falsa. Y luego una vez que esa
condición
sea falsa, saldrá
del bucle y continuará leyendo código. Ahí dentro, lo tienes. Básicamente, vamos
a tener la condición, y esa condición es cierta. Vamos a ejecutar algún código
y seguiremos ejecutando ese código hasta que la
condición sea falsa. Entonces ojalá eso tuviera sentido. Si no, vas a
ver múltiples ejemplos de esto en los próximos videos. Entonces como siempre, gracias
por mirar, y te veré
en la siguiente.
35. 34: En este video, vamos a estar hablando del bucle while, que probablemente sea el loop más
básico que verás. Tengo la sintaxis
para eso aquí mismo. Entonces lo que vas a hacer
es que vas a escribir bien y todo en minúsculas. Y luego entre paréntesis, vas a poner
una condición que
quieras comprobar para
ver si es verdad, pues guau, esa
condición es cierta. Vas a hacer
todo lo que tengas dentro de tu bloque de código
o tus corchetes. Después de eso, se
va a seguir ejecutando este bloque de código hasta que
esta condición sea falsa. Entonces, sigamos adelante y
escribamos uno de los nuestros. Y también voy a
hablar de algunos de los temas con los que te puedes
encontrar si no tienes cuidado. Entonces, por ahora, sigamos
adelante y creamos un entero. Voy a llamar a este iterador
y ponerlo igual a cero. Entonces, bueno eso va a
crear nuestro bucle while. Entonces vamos a decir, guau. Y luego entre paréntesis, diremos iterador
es menor que 100. Y luego tire de eso entre corchetes creará un bloque de código que
queremos ejecutar. Así que sigamos adelante y digamos
algo así como el iterador CL. Después en la fila. Ahora bien, no te
adelantes aquí y ejecutas este bloque de código ya que
puede que bloquee tu programa, si no tu computadora y Jenna, y te diré por qué. Así que tenemos int
iterador es igual a cero. Y entonces dijimos, bueno, nuestro
iterador es menor a 100. Queremos imprimirlo. Pero esta condición
nunca será falsa, ¿verdad? Entonces va a correr
a través, va a imprimir iterador. Y entonces va
a decir, bien, revisemos de nuevo nuestro estado. La condición sigue siendo cierta. Hagamos esto una y otra y otra y otra y
otra y otra vez. Entonces lo que tenemos que
hacer es hacer una manera o nuestra condición para que sea falsa. Porque si no haces esto,
este código se ejecutará infinitamente. Así que abajo aquí, vamos a seguir adelante y
decirlo, iterador plus, plus. Voy a poner punto y coma al final. Así que ahora nuestro iterador
va a aumentar uno cada vez que se ejecute este
bloque de código, entonces comprobará la
condición y seguirá haciendo esto hasta que el iterador sea igual a 100 porque entonces ya no
será inferior a 100. Así que adelante y ejecuta el código. Como puede ver, inmediatamente imprimió diferentes
líneas de código comenzando desde cero
hasta 99. Y si quisiéramos
imprimir de uno a 100, por ejemplo, podríamos simplemente cambiar nuestro
iterador aparecer a uno y hacer esto diga menos de
o igual a 100. Volvimos a ejecutar esto,
va a imprimir uno todo el camino a través del 100. Ahora, una cosa a tener en cuenta es
que no volverá a verificar la condición hasta el final del bloque de código. Entonces va a ejecutar
todo dentro tu cuadra cada vez que
esta condición sea cierta, luego vuelve a verificar la condición. Y sólo una vez que esa
condición es falsa, qué salir de
ahí y seguir leyendo tu código. Entonces, si por ejemplo aquí
abajo, dijimos C out, done, arrojó una línea N allí
y volvimos a ejecutar nuestro código. Se puede ver que en
cuanto llega a los 100, se imprime hecho. Ahora, otra cosa de la
que quiero hacerte consciente, que sí funciona con
declaraciones if así como con eso, porque una es lo mismo que verdad, porque no es como héroe. Esencialmente, poner uno aquí
es lo mismo que decir verdad. Y poner el cero aquí es lo
mismo que decir falso. Entonces cero es lo mismo que falso, y uno es lo mismo que verdadero. Cada, nunca querrías
poner mientras cierto aquí. Porque aunque
esto como sea posible, no
vas a poder
conseguir que esto diga falso. Entonces ahí tienes. Sé cómo crear y usar un bucle while. Y sí, se puede. Ayudas a poner bucles
y declaraciones if o el código que
quieras dentro de eso. Así que solo para recapitular, para crear un bucle while,
solo vas a decir, bueno, vas a poner
una condición que
eventualmente puede volverse falsa y convertirá en falsa dentro
del contexto de tu bucle. Entonces antes teníamos iterador
menor o igual a 100, y luego teníamos una manera de
que esa condición se volviera falsa si no lo era ya cuando
cruzamos el mundo por primera vez. Porque si este es falso, esto se habría
saltado en primer lugar. Entonces vas a decir,
bueno, entre paréntesis, tendrás una condición que
puede llegar a ser falsa dentro del contexto de tu bucle si
ya no es falsa. Y por último,
tendrás tu bloque de código. Lo que hicimos aquí, donde teníamos un iterador por el que
recorrer cada vez. Nuestra marca loop es una forma muy común de
salir de un bucle en
algún momento. Ahora, antes de concluir, sigamos adelante y veamos
otro caso de uso para esto. Entonces vayamos a nuestro
medio de esto y diremos int respuesta. Establezca esto igual a uno. Y entonces Dumbo,
eso va a decir, guau, entre paréntesis va a enviar
respuesta no es igual a cero. Y luego en nuestras
corchetes, digamos C out. Por favor tome cero y
emplee eso dirá
Ver en respuesta. Ahora acreditamos una tinta llamada respuesta y esta
n igual a uno. Y entonces dijimos que una respuesta no
es igual a cero, lo
que definitivamente no
será la primera vez. Vamos a imprimir, por favor
escriba cero y haga clic en Enter. Y si el usuario
no escribe cero, este código se ejecutará de nuevo. Sin embargo, una vez que
hicieron el tipo cero, solo dirá hecho. Entonces, si ejecutamos un programa, va a decir Please
take zero and hit Enter. Y podemos tomar cualquier
número y darle a Enter. Y nos va a pedir que volvamos a hacer. Podríamos hacer esto
para siempre si lo queremos. De lo contrario, si tecleamos
cero y golpeamos Enter, dirá hecho, y ahí vamos. Entonces ese es solo otro ejemplo
de cómo podríamos haber usado nuestro bucle while y haber
tenido una manera de
salir de él sin
usar un iterador. Ahora, muy rápido, sí quiero
dejar algo muy claro. Si estuviéramos aquí arriba, establecemos la respuesta igual a cero, por ejemplo, entonces en nuestra condición de
bucle while, dicha respuesta es igual a uno, esto en realidad se ejecutaría para siempre. Y la razón de esto es
porque en realidad estaríamos asignando uno a respuesta. Entonces decimos que la respuesta es igual a uno. Y debido a esto, el bucle while en realidad
miraría esto como solo esto. Y como sabemos, uno es lo mismo que decir verdad. Entonces esto bien podría
decir: Bueno, cierto. A pesar de que nos referimos
a la comprobación de si respuesta era igual a una. Entonces, cada vez que esté
trabajando con una condición, se
asegura de que nunca solo use el operador de
asignación. Y siempre dices es igual a poniendo
dos signos iguales, ya que definitivamente no
quieres bloquear tu programa, sobre todo si se trata de un trozo
de código en el que llevas mucho tiempo
trabajando y no han guardado o
algo así. Puede ser bastante traumático. Entonces solo quería
avisarte sobre eso. Entonces ojalá ahora
sepas escribir y usar un
bucle while e incluso puedas pensar en algunos ejemplos
y tu cabeza de donde esto sería útil. De todos modos, lo que en realidad
quiero que hagan
es que sigan adelante y guarden
lo que tienen aquí. Así que vamos a estar usándolo
en el siguiente video cuando
hablemos de un bucle do while. Entonces como siempre, gracias
por mirar, y te veré
en la siguiente.
36. Capítulo 7: haz mientras haces bucles: En este video,
vamos a estar hablando algo llamado
bucle do while. Y si recuerdas
en el último video, te
pedí que guardaras
todo lo que tenías. No obstante, si por alguna razón no
hiciste eso, no te preocupes. Sólo tienes que seguir adelante y
pausar el video. Copia este
pedacito de código aquí, y deberías estar
todo listo para ir. Entonces tengo la sintaxis básica para un bucle do-while aquí mismo. Vale la pena la regla de
cómo escribir una. Lo vas a hacer
en minúsculas. Y luego entre corchetes, vas a tener tu
bloque de código que quieres
ejecutar al menos una vez. Y ahí sólo va a
correr una vez, pase lo que pase. Después de eso,
vas a decir, bueno, igual que lo hemos hecho en el pasado, y luego paréntesis,
tendrás una condición. Si esa condición es verdadera, tu bloque de código
se ejecutará una y otra vez hasta que
la condición sea falsa, entonces también necesitas un punto y coma
después de esa condición. Entonces, la principal diferencia
entre un bucle do while, un bucle while que no sea
como se escribe ya tu bloque de código se ejecutará
una vez pase lo que pase. Y entonces sólo voy a repetir
mientras la condición sea cierta. Bien, así que sigamos
adelante y echemos un vistazo a cómo crear esto y
hacer uno para nosotros mismos. Así que aquí abajo, vamos a
cambiar nuestro bucle while en un bucle do-while solo para
mostrarte lo comparables
que son realmente. Entonces aquí mismo, vamos
a decir hacer en todas minúsculas. Y luego
vamos a seguir adelante y cortar nuestro bloque de código aquí de nuestro bucle while anterior y colocarlo frente a
la palabra do. Y luego después de una condición de bucle
while, simplemente
pondremos un
punto y coma así como así. Y ahí tienes. Ahora hemos creado
un bucle do while. Entonces lo que va a hacer ahora es decir Please type 0 y pulsa Enter. Y luego dejaré que
el usuario ponga en una respuesta siendo
nosotros en este caso. Y entonces mientras la respuesta no
es igual a 0, pero siguen adelante y
cambian eso ahí
va a seguir repitiendo. Y luego una vez que hayamos terminado
y va a decir,
Sigamos adelante y cambiemos eso
a algo así como gracias. Ahora si ejecutamos nuestro código, va a decir Por favor
escribe aquí y pulsa enter como para respuesta. Y mientras esa
respuesta no sea 0, va a seguir repitiéndose. Lo que es un es 0,
dirá, gracias. Entonces, si ejecutamos nuestro código aquí, puedes ver que
dice por favor escribe 0
y podemos escribir lo que queramos y
seguir golpeando Enter y una y
otra y otra y otra
y otra vez hasta que
realmente escribamos 0. Entonces entramos, dirá, gracias, y ahí vamos. Así que observe que este código se ejecutó aunque la respuesta era igual a 0 en esta condición era falsa porque
la respuesta era 0. Esto sólo habría sido cierto
y no era igual a 0. Entonces, como dije, la única diferencia entre un bucle while y un bucle do while es la sintaxis o cómo la
vas a escribir ahí, y el hecho de que tu
código se ejecutará una vez. Entonces, independientemente de cuál fue la
respuesta antes, este código se va a ejecutar una vez. Y luego se va a verificar
para asegurarse de que la respuesta es 0 antes de
romper este código. Porque dijimos que si la respuesta no
es igual a 0, queríamos seguir
ejecutando este código. Y ahí lo tienes.
Ya sabes cómo crear un bucle do while. De todos modos, eso
es todo para este video. Gracias por mirar, y te
veré en la siguiente.
37. Capítulo 7: para los bucles: En este video, estaremos
buscando crear y trabajar con algo
llamado bucle for. Tengo la sintaxis básica para
uno para ti aquí mismo. Así que antes que
nada,
vas a ahorrar en minúsculas y
luego entre paréntesis, vamos a tener
algunas cosas diferentes. En primer lugar, va a tener una inicialización de
variables. Y no te preocupes, te
estaré mostrando lo que quiero decir con eso
aquí en un poquito. Entonces vas a darle seguimiento a
eso con punto y coma. Y luego después de eso
vas a tener una condición. Vamos a condicionar funciona
igual que lo hace en cualquier otro bucle. Entonces, si bien la condición es verdadera, tu código va a
seguir repitiéndose. Y luego después de eso,
vas a tener una actualización de variables, que es donde
vas a estar actualizando la variable que las
crees. Entonces déjame seguir adelante y mostrarte lo que parece eso muy rápido. Yo quería que
supieras que todas estas cosas
técnicamente podrían eliminarse de un for-loop
sin ningún error
siempre y cuando dejes los dos puntos y
comas ahí dentro. No obstante, si no tienes la condición que va
en el medio ahí, esto siempre se
considerará cierto. Y tendrías
un bucle infinito, que como dije en el pasado, normalmente siempre
quieres evitar. Así que vamos a seguir adelante y
crear un bucle for alrededor. Y las mujeres crean un bucle for. En realidad vamos
a estar tratando de obtener el mismo resultado que
hicimos con nuestro bucle while
en un video anterior, donde imprimimos uno
a 100 en líneas separadas. Sólo para poder mostrarte
si las diferencias entre un bucle for
y un bucle while. Así que solo apague,
vamos a decir cuatro. Y luego entre paréntesis, vamos a decir
int I es igual a 0, el punto y coma al final.
Y ahí lo tienes. Justo ahí tenemos nuestro techo de inicialización de
variables creado e inicializado
una variable. Y puedes ponerle el nombre que
quieras. También puedes establecer esto igual
a lo que quieras, pero muchas veces configurándolo igual a 0 y verlo llamado I es lo más común
siendo la abreviatura de iterador. Y verás por qué
en tan solo un momento. A continuación, tendremos nuestra condición. Entonces vamos a decir que
menos o igual a un 100. No pongo punto y
coma después de eso. Y luego justo después de eso, vamos a tener nuestra
actualización de variables donde quiera que vayas a actualizar el valor
de nuestra variable. Entonces digamos que yo más, más. Y entonces tendremos nuestro bloque de
código dentro de aquí. Simplemente vamos a imprimir, voy a decir C0. Y luego crearemos
una nueva línea así. Y este bucle es
bueno para ir como está. Entonces, sigamos adelante y resumimos
lo que está pasando aquí. Entonces dijimos para,
para declarar que estamos
creando un bucle for. Y luego entre paréntesis, tenemos todas las
cosas que son básicas para bucle tendremos,
hemos oído hablar de variable
donde dijimos int I es igual a 0. Entonces ponemos punto y coma para separar esto
de la condición, déjenme decir
que menos o igual a 100. Esta es la condición
que se necesita cumplir para que un bucle for se ejecute
en primer lugar. Y si va
a seguir funcionando, esto debe seguir siendo cierto. Y luego después de cada vez que
nuestro código haya pasado por
alto, va a
aumentar yo en uno. Y
también podríamos haber dicho simplemente yo más igual a uno o yo
igual a I más uno. Realmente no importa. Este es solo el espacio
que quieres tener para actualizar tu variable. Así que muchas veces
así es como
vas a ver un for-loop
calificado igual a 0, yo con una condición
y luego yo más, más o más más I. Como dije, me queda
corto para iterador, pero tú puedes llamarlo como
quieras. Y luego en lugar de for loop, simplemente
seguimos adelante
y lo imprimimos. Luego creé una nueva línea. Y lo que esto va a hacer
es imprimir del 0 al 100. Pero si cambiamos
esto a uno aquí, sólo
voy a imprimir 100. Así que sigamos adelante
y ejecutemos nuestro código. Y ahí vas, uno todo el camino a través de un 100. Entonces, cuando creas un for-loop, normalmente
vas a crear algún tipo de variable con la que trabajar. Tendrás la condición
que quieres que te cumplan. Y si se cumple esa condición, va a
pasar por tu código. Y luego después de que
haya pasado por tu código, va a ir a tu
variable hasta aquí, haz lo que se le diga que haga. Entonces en este caso
dijimos yo más más. Entonces voy a aumentar uno porque eso es
lo que hace I plus plus, como sabemos del pasado. Y luego después de esta actualización de la
variable, comprobará nuestro estado. Otra vez. Si aún no
se cumple nuestra condición, volverá a pasar por este
bloque de código. Entonces una vez
que esta
condición sea falsa, continuará con nuestro código. Y eso lo sabemos del pasado. Y si quisiéramos,
podríamos decir C0, hecho aquí abajo y
línea así. Y lo que ha hecho,
se imprimirá. Bien. Ahora bien, ¿y si no quisiéramos
aumentar yo en solo uno? Bueno, como dije, ya
sabes, pon aquí
lo que quieras. Pero este es el spot que quieres tener para actualizar tu variable. Entonces podríamos decir que
igual a I más dos. Y ahí vamos. Y va a imprimir una porque nuestra condición era cierta. Siempre me parece impreso
uno y luego se le agrega a I. Así que ahora tenía tres años. Eso sigue siendo menos de un 100 impreso a tres, y así sucesivamente. Y si tuviéramos que
cambiarlos a 0 aquí, entonces esencialmente simplemente
imprimiría todos los números pares. Entonces como pueden ver,
24681012 y así sucesivamente. Bien, entonces, ¿cuándo
usarías un bucle for-loop en lugar
de un bucle while? Bueno, para uno, un bucle for es
más rápido que un bucle while. Además, normalmente quieres
usar un for-loop cuando sabes exactamente cuántas veces
quieres correr a través de un bucle, solo
hagamos algo
como esto. Yo menos de diez. Imprimiremos ese yo y
aumentaremos i en uno. Ahora bien, si lo atravesamos, pasará
exactamente diez veces. Así que conseguimos 12345678910. Entonces, cuando sabes cuántas veces quieres correr a
través de un bucle, normalmente, usarás un bucle for cuando la condición que necesitas cumplir para dejar de
correr en vivo. Como más complejo, por lo general
querrás usar un bucle while. Y luego para un bucle do-while, solo
quieres usar
eso cuando sabes, quieres que un trozo de código se ejecute
al menos una vez, y luego quieres que se
repita si se cumple una condición. Pero la mayoría de las veces, probablemente solo
estarás usando bucles
for y while loops. Ahora bien, para concluir este video, sí
quiero volver rápidamente
a lo que hablé antes donde dije que podemos tener
un bucle for así como este. Y esto será
completamente válido. No obstante, sin una condición, correrá infinitamente. Pero dicho eso, esto es válido y puedes
poner lo que quieras. Tan rápido,
repasemos un ejemplo de sacar todo
excepto nuestra condición. Entonces podríamos haber dicho int i. Entonces en nuestra
inicialización de variables, podríamos simplemente establecer i igual a 0, o podríamos haberlo
sacado por completo y dicho es igual a 0 aquí arriba y simplemente no tenía un
inicialización de variables. No obstante, todavía necesitamos el punto y coma para
separarlo de la condición aquí. Entonces dijimos intención de iOS e incluso
podríamos sacar
nuestra actualización de variables. No hay problema. Sin embargo, si hacemos
eso, como dije, siempre
querrás asegurarte de que hay una manera de que tu bucle detenga dentro del reino
de tu bucle ahí. Entonces dentro de nuestro bucle, podríamos haber dicho código
I plus plus. Y como se puede ver por aquí igual que antes, no hay problemas. No es necesario tenerlo
todo en la misma línea aquí, y va a funcionar bien. Solo asegúrate de que
todavía tienes alguna forma de
salir
del bucle y tienes una variable con la que
realmente puedas trabajar. Entonces por eso la
creamos aquí atrás. Ahora, solo quería
mostrarte que eso era posible. La mayoría de las veces probablemente
no vas a estar haciendo eso, pero esa es una opción. Y en caso de que veas eso
en el código de otra persona, sabrás por qué, sabrás
cómo está funcionando y así sucesivamente. Pero la mayoría de las veces probablemente solo lo
harás la manera habitual
que lo hacíamos antes. De todos modos, eso
es todo para este video. Gracias por mirar, y te
veré en la siguiente.
38. 37: En este video, vamos a estar hablando de bucles de anidación. Y bucles anidados es básicamente el mismo concepto que cuando pasamos por encima y anidación
de declaraciones. Básicamente es solo un
bucle dentro de un bucle. Y puedes seguir haciéndolo una y
otra y otra vez, igual que podrías con esas declaraciones
o cualquier otra cosa. Entonces, sigamos adelante y echemos un
vistazo a cómo podría funcionar esto. Así que vamos a
crear un par de bucles for para este ejemplo. Entonces vamos a decir para
int I es igual a cero, yo menos de diez, y luego yo más más. Recuerda, así
va a ser como se ven todos tus
for-loops básicos. Así que de todos modos, dentro de
aquí, voy a decir CL. Simplemente me gusta eso. Entonces por debajo de eso, vamos
a crear otro bucle for. Entonces voy a decir
para j es igual a cero, j es menor que diez. J más más. Y el bloque de código para eso, solo
voy a decir cl j. Y antes de ejecutar un código, vamos a
seguir adelante y eliminar la línea M de aquí arriba. O dijimos
CRI y me voy a ir. Entonces echemos un
vistazo a lo que pasó aquí. Entonces primero imprimimos es cero porque eso es lo que era yo. Y luego nos metemos en
nuestro otro bucle for. Y solo llamaremos a esto
nuestro pronombre j for-loop. También de otra manera es posible que
oigas hablar de bucles referidos cuando tienes bucles de anidación
como los internos y los externos. Primero imprimió
I, eso fue cero, y luego lo imprime j, que también era cero. Entonces J se incrementó en uno. Entonces j era igual a uno, que sigue siendo inferior a diez. Y así imprimió de nuevo J en una nueva línea porque aquí
tenemos esta línea N. Y lo siento todo
el camino hasta las nueve. Una vez que golpeé nueve, Jay ya
no tenía menos de diez. Por lo que no volvió a imprimir j. Entonces me incrementaron en uno. Entonces yo era ahora uno y
lo imprime uno. Después de eso,
comenzó nuestro bucle for sobre j era igual a cero. J es menos de diez. Imprimir j, j era cero y volvió a pasar por nueve. Y seguí haciendo esto y haciendo esto y haciendo
esto y haciendo esto hasta que finalmente tuve nueve años. Ella volvió a cero, imprimirlos todo el camino. Y luego una vez siempre
igual a diez, se detuvo. Ahora bien, si quisiéramos que esto
se viera un poco más agradable, por ejemplo, podríamos haber impreso
yo junto con él. Entonces aquí abajo, sigamos
adelante y digamos C fuera I. Y luego imprimiremos j.
Entonces sigamos adelante y
quitemos el CLI de aquí arriba. Y ahora cuando ejecutamos nuestro código, en realidad
va a decir 00 porque i y j eran ambos cero, luego cero para i, uno para j, cero Froude a para j Y va a seguir haciendo
eso hasta las nueve . Sólo voy a
imprimir uno para IA porque IA va a aumentar
en 10 para j y así sucesivamente. Y a pesar de que estamos
imprimiendo dos números diferentes, en realidad simplemente
imprimimos cero hasta el 99 allí. Y una forma interesante en la que
podríamos haber impreso 100 es dentro de nuestro bucle J4. Podríamos haber dicho
si yo es igual a nueve y j es igual a nueve, entonces queremos ver 100. Entonces si volvemos a ejecutar nuestro código, se
puede ver que hemos
impreso de cero a 99, igual que antes, excepto que una vez yo era igual a
nueve y j era igual a nueve, también
imprimimos 100. Entonces ahí tienes. De todos modos, gracias por mirar, y te veré
en la siguiente.
39. Capítulo 7: declaraciones de descomposición: En este video, vamos a estar hablando del comunicado
break. La declaración break
es algo que
realmente has visto antes
cuando trabajamos con switches y tecleamos
algo como esta línea de ruptura
con punto y coma. Ahora bien, la sentencia break,
como puedes ver aquí, solo
puede ser utilizada dentro de
un loop o un switch. Y ya hemos visto cómo
funciona dentro de un switch. Hoy voy a
estar mostrándote cómo podemos usarlo con loops. Ahora bien, lo que hace el
tronco cerebral es sacarte
automáticamente del bucle, y lo hace
instantáneamente y
no continúa con el
resto del código. Entonces, sigamos adelante y
veamos cómo funciona eso. Así que aquí mismo,
vamos a seguir adelante y
crear un entero. Simplemente llamaremos a esto i
y lo pondremos igual a 0. Entonces por debajo de eso,
vamos a crear un bucle while infinito. Ahora, sé que dije, normalmente
no quieres crear un bucle infinito porque nunca
saldrás de él. Pero con una declaración de descanso,
en realidad se puede. Entonces te voy a
mostrar cómo
funciona eso ahora mismo. Entonces
vamos a decir guau. Y luego dentro de eso,
vamos a decir verdad y crear un bloque de código. Entonces ahora mismo, este bucle
correría infinitamente, pero en realidad vamos a
lograrlo para que podamos salir de esto. Y dentro de aquí,
vamos a decir yo más, más, así como así. Abajo de eso, vamos
a crear una declaración if. Voy a decir def
que es igual a diez. Entonces queremos
salir del bucle. Y solo vas
a decir break y todo minúscula con
punto y coma al final. Y eso nos
sacará de todo el bucle. Bien, entonces aquí abajo, vamos a decir CL loop. Así como así. También note que pongo
nuestro iterador siendo yo, en este caso,
fuera de nuestro bucle. Y el operador final es básicamente
algo que estás usando para iterar a través de
un bucle x cantidad de veces. Entonces, si queremos
ponerlo aquí en su lugar, sería infinitamente porque cada vez que corremos
por un bucle, me habrían creado
y establecido igual a 0. Me habría
aumentado con una mano, nunca
hubiera igualado diez. Y esto sucederá una
y otra y otra y otra vez. Pero si lo ponemos
al revés de nuestro bucle, entonces esta variable se almacena
y guarda fuera del bucle. Recuerda que lo aumentamos uno la próxima vez
a través del bucle, va a aumentar en uno. De nuevo, un poco como cuando
teníamos este
bucle for interno y lo sacamos. Entonces, ¿qué va a pasar? Vamos a crear un entero llamado i, establecerlo igual a 0. Este va a ser nuestro iterador
para nuestro próximo directo. Entonces creamos un bucle infinito cuando dijimos: Bueno, cierto. Pero cada vez que
pasamos por un bucle, vamos a aumentar en uno. Entonces va a comenzar en
0 e ir a 1234, etc. entonces una vez que sea igual a diez, tenemos
aquí esta declaración break para echarnos del bucle. Y luego abajo de eso, en realidad quiero imprimir, solo
me gusta eso. Y pondremos una
nueva línea cada vez. Y te voy a mostrar por qué
en sólo un segundo. Ahora, sigamos adelante
y ejecutemos nuestro código. Ahora, como pueden ver, fuimos 123456789, pero
no imprimimos diez. Una vez. Yo estaba igual a diez de
nosotros aumentándolo en uno, aquí
mismo, lo comprobó
a través de nuestra declaración if. Dije que sí, y luego
nos salió de él y no continuó con el resto del
código y nuestro bucle, inmediatamente
nos
salen de él en cuanto golpea esta declaración de break y
continúa con el código. Por eso
no imprimimos diez. Entonces ahí
lo tienes. Ya sabes cómo usar la declaración break. Básicamente,
solo vas a tomar descanso, lanzar un punto y coma, y te
echará de un bucle o te
echará de un bloque de código cuando usas con interruptores, como hemos visto en el pasado. Y es esencialmente la
única manera en la que vas a
poder
echarte de un bucle infinito, como ves aquí. Pero puedes usar esto de otras
maneras y no solo en
bucles infinitos, ¿verdad? Podríamos haber dicho,
si yo es menos de un 100, y entonces esto habría corrido
un 100 veces y se detuvo. Pero una vez que pegamos diez, o vamos
a poner esto en algo así como 30, solo
va a seguir adelante
y echarnos de todos modos. Entonces como pueden ver, una vez que obtuvimos los 30, nos
echó y no se
molestó en imprimirlo. Así es como usa la declaración break para
echarte de un bucle temprano. Hay múltiples razones por las
que quizás quieras hacer esto. Obviamente aquí parece
un poco redundante, pero es posible que desee ejecutar un bucle una cierta
cantidad de veces hasta que se cumpla
una determinada condición y luego simplemente continúe y salga de
él en ese momento y ahí. Y para mostrarte un
ejemplo de esto, podríamos haber dicho
contraseña de cadena y ponerla igual a, pondremos igual
a nada por ahora. Y luego dentro de aquí,
podríamos haber dicho, Bueno, contraseña no es igual a. Y luego solo diremos la contraseña 123 porque tenemos la contraseña
más segura del mundo, la derecha. Y luego aquí abajo
vamos a decir cin password, así como así. Y entonces si la contraseña
es igual a, digamos que pare. Sigamos adelante y
cambiemos esto para salir. Vamos a seguir adelante y
simplemente salir del bucle. Entonces, si bien la contraseña no es
igual a la contraseña 123, vamos a seguir
pidiendo una contraseña. Y en realidad puedes seguir adelante y hacer eso
aquí mismo, dirás, por favor escribe la contraseña
correcta. Así como así. Entonces te pediremos una contraseña. Si lo ponen en
la contraseña correcta aquí
abajo, voy a decir. Y sigamos adelante y cortemos eso. Y dentro de nuestro bucle, diremos que la contraseña es igual a. Y luego diremos contraseña. 123, vamos a decir enhorras. De lo contrario, si la contraseña
es igual a salir, seguiremos adelante y saldremos. Y seguiré adelante
e imprimiré salida. Dirá algo como
salir o salir. Ahora, obviamente esto
no es perfecto. Realmente no tenemos
nada después de esto, pero esto es solo
un ejemplo de cómo podrías usar un bucle while y por qué podrías querer tener una declaración break
para otras opciones. Así que adelante y ejecutarlo. Ahora va a
pedir una contraseña. Puedo escribir lo que
quiera Eso se va a
guardar en la cadena. Si no es el camino contraseña. Sólo va a seguir
diciéndome que si nosotros y salimos, dirá salido,
y ahí vamos. Ahora bien, si lo vuelvo a ejecutar
y me llevo la contraseña 123, voy a decir enhorras. Ahora bien, ¿y si quisiéramos darle
al usuario sólo tantos intentos? Bueno, después de que hicimos esto y después comprobamos si la
contraseña era igual a 123, e incluso podríamos lanzar
otro descanso aquí. Si lo queremos aquí abajo, diremos que la contraseña era correcta. Entonces después de eso, diremos i. Y luego los intentos. Contraseña incorrecta. Intentos. Y luego fuera de nuestro labio va a crear un vacío. Establecerlo igual a. Entonces en realidad vamos a seguir adelante y
ponerla igual a, bien, porque no
quiero que tengan alguna cantidad de intentos. Y luego aquí abajo,
justo debajo de ella, justo por encima de nuestra línea CL
dirá yo menos menos, y luego pondremos punto y coma. Entonces va a ver como la
contraseña es incorrecta. Entonces voy a imprimir i intentos, ¿
verdad? Entonces comencemos con cinco. No lo hagas bien. Diré que para la contraseña es incorrecta para
los intentos izquierda, centro, ¿verdad? Así que adelante y ejecuta nuestro código. Hemos tomado algo, digamos que contraseña es incorrecta
para los intentos que quedan, por favor escriba la
contraseña correcta, 3210. Y desafortunadamente
solo va a seguir entrando en negativo a menos que hagamos
algo al respecto. Entonces aquí mismo, podemos decir, si yo es igual a 0, imprimirte en ruptura antes,
así como así. Y después de esto,
sigamos adelante y hagamos una nueva línea para que limpie un poco
mejor
nuestro código cuando fallemos. Está justo aquí. Por favor, para tener la contraseña correcta
escrita en algo mal. Servidores incorrectos. Te quedan cuatro veces, quedan
tres temas a 10 veces restantes. Juventud, Ben, encerrado
, y ahí tienes. Ahora hemos creado
una idea muy básica para un programa de contraseñas. Entonces ojalá
tengas una buena idea de lo que los rompe
como cómo usarlo. Y a lo mejor ahora tienes algunas
ideas de cuándo usarlo. Entonces ojalá hayas disfrutado
el video como siempre, gracias por verlo, y te
veré en el siguiente.
40. Capítulo 7 (loops): continúe las declaraciones: En este video,
vamos a estar echando un vistazo a la declaración
continue. Ahora, al igual
que la declaración break de la que hablamos
en el último video, la declaración continue también se usa cuando se trabaja con loops. Entonces, sigamos adelante y echemos
un vistazo a cómo funciona esto. En primer lugar, vamos a seguir
adelante y crear un bucle for. Entonces vamos a decir para
int I, ponlo igual a 0. Entonces si hay menos de diez, yo más, más, así como así. Luego dentro de nuestro
for-loop aquí, vamos a seguir adelante
e imprimir i. Así que vamos a decir que
creo una nueva línea
después, así. Entonces arriba de nuestra declaración c
out aquí, Sigamos adelante y
creamos una declaración if. Entonces vamos a
decir que es igual a. Y vamos a seguir adelante y
poner algo como cinco aquí. Entonces queremos
hacer lo siguiente. Lo vamos a hacer es poner en
el comunicado de continuar. Entonces vamos a decir
continuar, todo en minúsculas. Y lo que esto hace
es que en realidad se salta la iteración actual de un bucle. Y también te voy a mostrar cómo
funciona esto y un bucle while también. Entonces, ¿qué va a pasar aquí? Bueno, si no tuviéramos
esta declaración if, sabemos que normalmente
imprimiríamos del 0 al nueve, pero porque sí
tenemos esto aquí, cuanto sea igual a cinco, va a leer esto
continuar declaración. Sólo vamos a saltarnos
todo lo demás después de eso. Pero a diferencia de una declaración break, que nos echaría
del bucle por completo, lo que va a pasar en su lugar, ya que va a subir aquí y
leer nuestra actualización de variables. Entonces
me va a actualizar por uno en este caso. Y luego se va a
revisar el estado nuevo y luego continuar adelante. Entonces lo que va a pasar es
que imprimiremos del 0 cuatro y luego iremos
al sexo y adelante. Y si ejecutamos nuestro código aquí, se
puede ver que eso
es lo que pasó. Por lo que imprimió 01234. Entonces una vez fui igual a
cinco, eso es lo que continúo. Entonces seguí adelante,
salté aquí a nuestra actualización de variables, leí eso por uno. Entonces ahora tenía seis años y
luego continuó con normalidad. Entonces ahí tienes. Así es como
funciona continue statement en un for-loop. Muy rápido, por cierto, con la sentencia continue
y la sentencia break, si se tiene un bucle anidado. Entonces digamos que tuvimos otro
bucle fuera de este. Entonces, si tuviéramos
algo como esto, ahora, ustedes no tienen
que copiar esto aquí mismo. Sólo estoy tratando de
mostrarles a lo que me refiero. Pero básicamente, si
tienes un bucle anidado aquí, tu sentencia continua y, o tu sentencia break
solo afectarán al bucle que es. Y así esto aquí solo
afectaría a este bucle y
no al bucle externo. Y si esto fuera una declaración
break, sólo nos sacaría
del bucle interno y
no del exterior. Entonces si sigo adelante e imprimo,
me gusta esto e imprimo j. aquí
consigo mi nueva línea y ejecuto mi código. Entonces ahora si
miras nuestro código aquí, puedes ver que hemos
impreso 0 para r I, y luego para la variable J, fuimos 01234,
saltamos a la siguiente
iteración de nuestro bucle, que también
aumentó j en uno en este caso, luego continuar adelante. Y lo hizo cada vez por nuestra
continua declaración. Y cómo golpeamos una declaración
break aquí, como la usamos en el último
video y ejecutamos nuestro código. puede ver que sólo
se desprende del bucle de corriente. Y así solo pasamos de 0 a
cuatro con nuestra variable j, y sigue haciéndolo cada vez a través de. Entonces ahí tienes. Entonces, ¿cómo continúa declaración de trabajo,
el bucle while? Bueno, funciona
exactamente de la misma manera excepto que no tenemos
una actualización de variables. Entonces si es algo así como
int yo es igual a 0 aquí arriba. Y luego en nuestro bucle while, dijimos mientras tengo menos diez y dentro de
nuestro bloque de código aquí, solo
vamos a
seguir adelante e imprimir creo una nueva línea. Y entonces también queremos
asegurarnos de que tenemos una manera de salir de
este bucle while, ¿verdad? No quiero que esto
continúe para siempre. Entonces digo yo más, más así. Entonces, sin que
se le haga nada a esto, sabemos que va
a imprimir aquí el código de uno a diez Fahrenheit. Podemos ver que
ese es el caso. Pero, ¿y si lanzamos
nuestra declaración continua? Entonces, si decimos si yo
es igual a cinco, una vez más, tenga
cuidado de asegurarse que esto sea igual a. Y entonces aquí sólo vamos a
decir continuar. Así. Una vez que llegue a nuestra declaración
continua aquí, eso solo va a volver a verificar el estado y no
hacer nada extra. Y esa es otra razón por la que
quisiéramos o yo plus plus o nuestro iterador aquí para
estar antes del sostenimiento. Porque si fuera después, así, antes
que nada, correría,
aumentaría eso en uno. Entonces digamos uno,
imprimirlo y seguir haciendo eso
hasta que yo tenía cinco años. Ahora, una vez que tuviera cinco años, continuaría y volvería a
verificar nuestro estado. Y cinco es menos de diez. Así que para volver a pasar por esto y continuar y seguir corriendo y corriendo y corriendo para siempre. Entonces queremos asegurarnos de
que lo que está causando nuestro bucle while termine
suceda antes de esto aquí, al
menos en esos casos, como para no crear un dolor de
bucle infinito que bloquee nuestro programa. Entonces, si ejecuto el código aquí, se
puede ver que hemos
impreso 1234. Una vez que golpeamos F5, continuamos
y volvemos a renderizar la condición seis. Entonces ya no es igual a cinco, y luego continuó
imprimiendo. Entonces ahí tienes. Ya sabes cómo crear y usar la sentencia continue. Y recuerda, todo
lo que hace es omitir la iteración actual
del bucle. Y con un bucle while, sólo
va a
volver a comprobar el estado. Y con un bucle for, si tienes una
actualización variable ahí, eso va a
hacer eso primero y luego revisar tu
condición de todos modos, eso es todo para este video. Como siempre, gracias por mirar y
te veré en la siguiente.
41. Capítulo 7: validación de la entrada de usuarios: En este video, voy
a estar mostrándote cómo podemos
validar realmente la entrada del usuario. Hasta ahora, en este curso, solo
nos hemos estado
asegurando de que hemos estado escribiendo los valores adecuados. Entonces, por ejemplo, si uno de los usuarios o nosotros mismos
en estos casos, para escribir un entero, solo
hemos estado escribiendo
un número entero. Pero si realmente fuéramos a escribir algo
como hola, nos encontraríamos con algunos problemas. Ahora, dependiendo del tipo
de programa que esté haciendo, esto puede o no
ser realmente un problema para ti, ya que es posible que nunca necesites tomar entrada
aleatoria del usuario que necesitas para
asegurarte de que sea correcta. Pero sí quiero
mostrarte cómo se
hace esto en caso de que lo necesites, o en caso de que
quieras implementarlo en cualquier programa
que puedas crear bien, tratando de aprender y
entender el lenguaje. Y solo para que tengas esto
a tu disposición y puedas reconocerlo si lo ves
en el código de otra persona. Ahora, solo un rápido descargo de responsabilidad, probablemente no voy a usar esto en absoluto durante el
resto de este curso. Este video solo estará aquí
para referencia y para que
aprendas a hacer esto,
debes usar elegir. La razón principal para ello. Solo seremos por
la complejidad extra, pero siento que se
suma al código. Y personalmente simplemente no lo
uso mucho en el código que hago
usando C plus plus. Y déjanos solo porque
suelo trabajar con el desarrollo de
juegos y no
tengo a los usuarios simplemente escribiendo
cosas aleatorias para rellenar una variable. Pero porque estamos trabajando
con una aplicación de consola y pidiendo al usuario que escriba lo que quiera para
rellenar una variable. Simplemente me parece relevante enseñarte
cómo funciona esto. Lo siento mucho por ese
poco de perorata, pero sigamos adelante
y comencemos. Así que antes que nada,
vamos a seguir adelante y decir, simplemente me gusta eso. Y luego vamos a seguir
adelante y crear un bucle while infinito
para obtener la entrada del usuario. Entonces vamos a decir guau. Y luego dentro de aquí, solo
diremos verdad. Recuerda, otra forma en la que
podríamos crear un bucle infinito es crear un bucle for como
este y luego simplemente hacer eso. Y eso es en lo que estamos para siempre porque ahí no hay una
condición. Y solo asumirá que la condición es
verdadera esencialmente. Pero me gusta usar el
Wiley personalmente porque
creo que es un poco
más legible que un cuatro-bucle vacío. Así que vamos a hacer es seguir adelante y pedirle
al usuario que escriba un número. Entonces diremos C out, por favor escriba un número entero. Haremos espacio de colon así. Y luego debajo de esto,
vamos a seguir adelante y crear
una declaración if. Entonces vamos a
ver en así. Ahora vamos a escribir
un montón de código que no va a tener
ningún sentido para ti. Pero por ahora, solo sigue
adelante y sigue y voy a repasarlo todo contigo al final
e intentar que sea lo fácil
posible de
entender. Bien, perdón,
aquí dentro, vamos a decir romper así. Entonces sólo voy a poner
en una declaración de descanso. Y luego por debajo de eso
vamos a decir otra cosa. Y luego en el bloque de código
para nuestra declaración else aquí, vamos a seguir adelante
y guardar lo siguiente. Vamos a decir C fuera. Esta entrada estaba en el espacio válido, por favor escriba el número. Y luego Dumbo que
vamos a decir cn punto Borrar y luego abrir y cerrar paréntesis,
luego un punto y coma. Entonces por debajo de eso vamos
a decir c m punto ignorar. Y luego entre paréntesis, vamos a decir numéricos. Todo minúscula, Por cierto, el guión bajo limita el símbolo
menor que, tamaño de flujo. Todo una palabra, todo minúscula. Y luego el
símbolo mayor que seguido de dos puntos. Ahí, voy a decir
max, todo minúscula, abrir y cerrar el espacio de coma
entre paréntesis. Y luego vamos a poner entre
comillas simples así,
una
diagonal inversa n, seguida otra comillas simples
o paréntesis cercanos, y luego un punto y coma al final. Y esto es todo lo
que necesitamos para validar. Nuestro aporte es un poco mucho
en mi opinión personal, pero esta es la manera de
hacerlo en C plus plus. Así que vamos a meternos en ello. Entonces aquí mismo en
la parte superior dijimos, por favor escriba un número entero. Entonces aquí abajo, dijimos si CNI,
Entonces, lo que realmente
va a hacer esto es tomar entrada igual que normal y
luego poner la entrada en alta. Y si la operación funciona, esto volverá cierto. Entonces va a
saltar al bloque de código artístico aquí, lo que
nos va a sacar del bucle porque finalmente obtuvimos la
entrada que estamos buscando. No obstante, si esta
operación falla, entonces tenemos nuestra otra
declaración aquí para cubrirnos. Entonces le decimos al usuario, Hey, esta entrada no fue válida, por favor escriba un número entero. Entonces lo que hicimos es que dijimos cn punto claro qué
es esto como método para básicamente limpiar el aire
que habría surgido de tratar de poner lo que
el usuario haya escrito en I. Ese no era un número entero . Bien, así que esa es básicamente
la forma más fácil de
pensar en este método ya que
solo estamos limpiando el aire que habría surgido
del usuario tratando de
poner el tipo de datos incorrecto en I. Un pequeño comentario aquí,
claro para intentar ingresar el
tipo de datos incorrecto en nuestro entero. Y en realidad
sólo voy a decir variable. Entonces mira, ya sabes,
que esto funcionaría con cualquier otro
tipo de datos básicamente. Entonces aquí abajo
dijimos cin.ignore. Y luego después de eso, esencialmente
pones
la cantidad de personajes que quieres que se ignoren. Y así todo
esto de aquí, hasta este máximo
aquí básicamente dice que queremos ignorar la cantidad máxima de caracteres que
se ingresaron
hasta este carácter de la diagonal inversa n. Ahora, la razón por la que
ignoramos todo. Hasta el nuevo carácter de línea, que en este caso sería cuando el usuario tecleó
enter como porque
sabemos que al final de lo que el usuario
decidió escribir, digamos que escribieron
todo un libro de palabras. Cuando les pedimos que
escriban un número entero, que nuestro programa aquí, va a ignorar
todo lo que acaban de escribir. Porque al final de
todo lo que escribieron, golpearon la tecla enter, que es lo mismo que
un nuevo carácter de línea. Ignora todo
hasta el nuevo carácter de línea. Entrar. Ahora bien, ¿por qué hicimos esto? Bueno, antes que nada, borramos
el error que surgió
del usuario para ingresar y escribir datos
incorrectos
en una variable. Entonces si
hubiéramos pasado por nuestro bucle otra vez sin
esta línea de código aquí, básicamente solo
habríamos
obtenido el mismo error exacto y esto nunca funcionaría y simplemente
estaríamos atrapados en esto bucle. Básicamente, lo que hicimos básicamente
es decir a
nuestro programa, Oye, solo ignora todo lo
que era solo tipo, vamos a empezar
completamente frescos. Entonces, al ignorar el
aire y decirle a
nuestro programa que ignore
todo lo que estaba apretado, básicamente
estamos comenzando
con una pizarra nueva y limpia. Bien, así que ojalá
eso tenga sentido. Además, otra cosa que
rápidamente quiero mencionar como cada vez que estés trabajando
con algo como esto, que potencialmente podría causar un bucle infinito como cualquier tipo de pausa en tu programa al
usar un bucle infinito. Bueno, muchas veces sé
un buen a prueba de fallas para que
tu programa se bloquee. Pero yo siempre diría, solo para asegurarnos de que hemos
visto mucho de esto antes. La única diferencia
es que ahora
sabes que puedes ingresar
algo como esto. Entonces podemos decir CAN
seguido de una variable como la
que hemos hecho en el pasado. Y esto en realidad
devolverá verdadero o falso dependiendo de si esto funcionó
o no. Bien, y luego aquí abajo
tenemos nuestra declaración de ruptura que hemos visto en el
pasado que
nos va a romper de este bucle por completo. Entonces así es como podemos
salir de nuestro bucle infinito. Y abajo en la parte inferior, tenemos esto aquí mismo
que básicamente solo dice,
oye, tu entrada no era válida
si esto devolvía falso. Y luego tenemos
estas dos líneas de código para que nos den un borrón y cuenta nueva. Así que sigamos adelante
y ejecutemos nuestro programa. Y pidió un número entero. Y sólo voy a tomar
algo como hola. Y fíjate que nuestro
programa no se estrelló, no se le
ocurrieron errores locos. Y en realidad solo para
mostrarte una cosa más aquí de vuelta en nuestra declaración if, Sigamos adelante e imprima
eso. Voy a crear una nueva
línea así. Entonces hagamos lo mismo dentro de nuestro bloque de código else aquí. Ve ahí afuera en la
fila para que sepas que podemos usar esos
para abril y
no estamos teniendo ningún error. ¿Bien? Entonces puedo escribir lo que sea
que quieran y entrar y no
va a causar ningún problema. Imprimí, sé tema. Y solo para estar seguros, pesar de que esta huella
muerta fuera 0, en realidad recomendaría
que inicialicemos i aquí arriba. Personalmente, te
recomendaría que le des ojo en el valor inicial antes de
hacer algo como esto. Pero como viste, sí
funcionó, sí imprimió 0 en este caso. Pero generalmente para estar seguros, Eso es algo que
recomendaría. Bien. Para que puedas escribir
lo que quieras. Y después de eso,
se puede ver que hemos impreso yo sirvo ellos
usan IA, no hay problema. Y aquí abajo dijimos que
imponen a válido, Por favor diga el número entero. Y si hubiéramos querido
limpiar esto y podríamos
haber hecho lo siguiente. Sólo podemos sacar nuestra c. Por favor tome el número y
póngalo aquí fuera
de nuestro bucle while. Y eso va a funcionar bien. Así que por ahí atrás,
lo que queramos. Podemos seguir haciendo esto tanto
como queramos porque tenemos
un bucle infinito. Aquí hay un buen ejemplo de
cuando un bucle infinito es útil cuando estamos
tratando de obtener alguna entrada como esta. Y realmente no sabemos cuándo vamos a
querer que esto se detenga. Ahora bien, concedido, esto
es un infinitamente, este es un buen ejemplo de
cuando querrías usar un bucle while
sobre un bucle for es cuando la condición
que quieres
que te cumplan es más
complicada y tú no sabes la
cantidad exacta de veces que quieres correr a
través del bucle, ¿verdad? Porque normalmente
con un for-loop, vas a decir
cuando nuestro iterador o mucha temperatura
estás acostumbrado a I en el pasado como taquigrafía para
iterador es
menor o mayor que un cierto número o
algo así. De todos modos, si seguimos adelante y escribimos un
número entero como pedimos, eso va a
imprimirlo y echarnos de nuestro bucle y
todos estamos bien para ir. Pero hay otra
manera de hacer esto. Entonces si dices algo
como CAN, aquí mismo, aquí abajo en la sentencia if, realidad
se puede decir c n punto fallar. Sin embargo, para nuestro
bloque de código dibujado aquí, en realidad
queremos ver
si no falló. Podríamos simplemente decir, si
no fallar así. Y si ejecutamos nuestro código. Se puede ver que esto funciona
de la misma manera que antes. Y si escribo un número entero, BAM, nos echa. Así como así. Todo bien para ir. Entonces ahí tienes. También puede usar el método
CN dot fail para ver si esa operación
falló o no. Entonces, si no quisimos hacer eso, hazlo simplemente cortar esto aquí, pégalo abajo,
córtanos a todos aquí, y ponlo en una
declaración if y quita esto. Y esto funcionaría
bien siempre y cuando
pongamos aquí
mismo una declaración de continuar, ¿verdad? Así que cada vez que fallaba, en realidad simplemente
saltaríamos la
condición del verificador, que es cierto y lo ejecutaríamos. Y si no fallaba, bueno, saldríamos de ella. Entonces para mi código aquí otra vez, veamos si tomamos lo que sea. Yo sólo voy a seguir adelante. Repetir. Pero todavía estamos en
nuestro bucle, ¿verdad? Porque solo vemos esta
oscuridad contiene declaración que hablamos
en un video anterior para volver a través y verificar su estado y saltarse
el resto del código. Pero si en realidad escribimos
un número, ahí tienes. Patea esto tal
como cabríamos de esperar. Ahora, muy rápido para
aquellos de ustedes que se preguntan, como ya hemos visto bastantes veces la palabra
stream, hemos estado obteniendo código
del archivo de encabezado iostream. Estamos hablando de
un tamaño de arroyo aquí. Si paso el mouse sobre C n y C out, todos
vienen de
ese archivo de flujo. Entonces, ¿qué es una cadena? Y no te preocupes, realmente no necesitas una
comprensión completa de esto para este curso. Yo sólo quería
decirte qué es esto. Ahora básicamente en C plus, más, un stream es solo un stream de caracteres que
se transfieren entre el programa
y la salida de entrada. Y así nuestro C out
y C n son lo que
hemos estado usando para interactuar
con la entrada y salida. Y cuando tenemos esto aquí, esta es esencialmente nuestra corriente. Se trata de nuestros personajes que se transfieren entre el programa. Y como sabemos, solo se transfieren
al programa cuando golpeamos Enter y todo este texto aquí, tanto la salida del código
R como la entrada de nosotros. Entonces el carácter
se está transfiriendo de
ida y vuelta entre nuestro programa y el usuario es parte de esta
entrada, flujo de salida. Entonces cuando dijimos Hey, queremos que nuestro programa ignore el tamaño
del stream bancario de los caracteres, escriba, o básicamente diciendo cualquier cosa
posible que pudieran haber escrito en nuestra consola
aquí, adelante e ignorarlo. Y así empezamos
con borrón y cuenta nueva. No tenemos que preocuparnos de que
el error vuelva a subir, etcétera. Eso es
más o menos. Así es como
validas la entrada del usuario es esencialmente con estas
dos líneas aquí mismo. Y asegurándose de que
la entrada pasara por. De todos modos, déjalo caer, el video. Sólo voy a recapitular rápidamente todo lo que
acabamos de hablar. Había novedades en este video. Entonces, antes que nada,
sabemos que podemos usar nuestra sentencia CN
aquí directamente en una condición y devolverá
true si la inserción de lo que el usuario haya escrito
en la variable tuvo éxito y false de lo contrario, entonces también aprendimos sobre
el método seat y dot fill, que devolverá true
si esta operación falló y false si no, entonces aprendimos sobre
estos dos métodos aquí. Y solo recuerda
que el punto cn clear aquí básicamente
solo borra el error que surge
del usuario tratando ingresar datos incorrectos en la variable. Entonces tenemos el método
cin.ignore, que básicamente ignora la
cantidad de caracteres que le
pedimos hasta el
punto en que le pedimos que pare, que en este caso es simplemente todo lo que
el usuario mecanografiado. Y esto es sólo para evitar que el aire vuelva enseguida. Bien, así que ojalá esto
no sea demasiado complicado. Ahora, como dije, no
voy a usar esto mucho a
lo largo del curso ya que
creo que es mucho código
que enreda un poco
los videos sobre un tema
específico. Pero en los casos en los
que sí tengo un hacer un programa completo, voy a seguir adelante y tirar esto solo para
mostrarles que esto es algo que deberíamos hacer
si estuviéramos pidiendo entrada
del
usuario y para recordarte cómo para hacer esto y cuándo. De todos modos, espero que hayas
disfrutado del video. Gracias por mirar, y te
veré en la siguiente.
42. Capítulo 7: Operador de resolución de alcance: En este video, les voy
a estar hablando operador de resolución
de alcance y lo que es
este operador para acceder a una variable global tiene el
mismo nombre, una variable local. Entonces, en términos generales, no te
recomendaría que tengas dos variables
del mismo nombre. Pero en el raro
caso en el que sí tengas esto por cualquier razón, voy a mostrar
cómo puedes acceder a la variable
global y a la local por separado. Pero en términos generales, no lo
recomendaría, y recomendaría tener nombres de variables más
específicos. Así que siempre sabes exactamente con
qué estabas trabajando. Porque a pesar de que hemos estado
viendo cosas como int x, por ejemplo, si estaba
usando esto, el gráfico, el marcador en un partido de fútbol, me gustaría llamar a esta puntuación y no a algo genérico como esto, donde no voy a saber qué es lo que sostiene esa variable. Bien, así que sigamos
adelante y veamos cómo usar el operador de
resolución de alcance. Entonces antes que nada, normalmente, si tenemos dos variables
del mismo nombre como esta e
intentamos ejecutar nuestro código, vamos a obtener un error. Y eso es porque tienes dos variables con
el mismo nombre. Y si miras aquí abajo,
en realidad obtuve un error que dice int x redefinición. Traté de encontrar la
misma variable dos veces. No obstante, te permitirá tener dos variables
del mismo nombre. Si, por ejemplo, uno es
global y otro es local. Y como pueden ver, si intento ejecutar mi código ahora, funciona bien y no
llegamos ahí. Ahora bien, ¿y si quisiera acceder a esta variable sobre esta
variable o viceversa? Entonces, sigamos adelante y
separemos estos con algún tipo de valor para que
podamos ver a cuál
estamos accediendo. Este valor a las diez, y
le voy a dar una variable local, un valor de cinco. Entonces vamos a
seguir adelante y decir x, así como así y ejecutar nuestro código. Y como pueden ver
, imprime cinco. Y eso es porque por defecto, estarás accediendo a
la variable local. Pero con el operador de
resolución de alcance, se
puede acceder a la variable
global. Entonces si lo vuelven a ver, como hicimos antes y
luego antes de nuestra variable, si solo ponemos en Colin's así y ejecutamos nuestro código, se
puede ver entonces imprimimos cinco y también
imprimimos fuera diez. Y eso es porque
estas dos columnas aquí son el
operador de resolución de alcance que te
permitirá acceder a la
variable global versus la variable
local. Y eso es prácticamente
todo lo que hay para ello. Entonces, si lo haces con dos
variables con el mismo nombre, usas dos puntos siendo el operador de resolución de alcance
para acceder al global. Y no haces nada diferente
para acceder al local. De todos modos, eso es todo
para este video. Gracias por mirar, y te
veré en la siguiente.
43. Capítulo 8: números aleatorios: números de introducción a números aleatorios: En este video, voy a estar dando una introducción a los números
aleatorios en la
programación en su conjunto. Y luego después de eso,
en el siguiente video, realidad
estaremos generando números
aleatorios dentro un rango deseado en C plus plus. Entonces comencemos. En primer lugar, cuando queremos
generar números aleatorios, vas a
querer agregar estos dos archivos a tu programa. Así que arriba en la parte superior aquí, vamos a decir que el hashtag incluye dentro de un símbolo menor que
y mayor que. Vamos a decir C std LIB. Y eso es solo la biblioteca estándar
C como con otros cortos para. Y luego esta siguiente, vamos a hacer lo
mismo, excepto que vamos
a poner C tiempo. Y este de aquí es con el que
estamos trabajando, bien, así que voy a seguir adelante
y mover esto aquí abajo. Ahora cuando se trata de los números
aleatorios en la programación, porque las computadoras simplemente hacen
lo que se les dice que en realidad no se
puede
obtener un número aleatorio. No es posible,
independientemente de todos
los programas y
aplicaciones que hayas visto, en realidad no
es
generar un número aleatorio. No obstante, para el usuario, sí
se ve al azar. Y déjame explicarte
cómo funciona eso. Entonces, antes que nada, está esta ecuación
realmente complicada por ahí en la que puedes poner un
número para empezar. Y te dará
lo que parece ser un número aleatorio basado en
lo que le diste. No obstante, si seguiste
dándole el mismo número, te va a devolver
el mismo número. Entonces en la programación donde realmente
quieres hacer es darle a esa ecuación un
número diferente cada vez. Entonces, si un usuario cree
que siempre está obteniendo un número aleatorio en la forma en que lo hacemos es dándole a esta ecuación la hora actual. Y debido a que lleva
la fecha y la hora, ese número
siempre será diferente. En otra cosa que quiero
mostrarles chicos en este video es algo que se
llama desbordamiento. Entonces, en primer lugar, una variable
entera tiene esto como su número máximo. Y de otra manera
podríamos conseguir esto sin solo
recordar y decir int subrayado max
y solo un aviso. Hay otras
palabras clave como esta por ahí de las que no
hablaremos en este curso. Entonces, si te interesa, eso es algo que siempre
puedes investigar. De todos modos, lo que
voy a hacer aquí, digamos que x es igual a
punto y coma al final. Y luego vamos
a decir x plus plus. Entonces vamos a agregar uno a eso y luego imprimirlo. Y para mostrarte
lo que está pasando, sigamos adelante y hagamos el teléfono. Y esta es la línea CL. Y luego los hombres, así como esto, y esto nos va a dar
el valor entero mínimo. Como puede ver, son
exactamente lo mismo. Y la razón de eso es que una
vez que un entero pasa como valor
máximo hace algo
llamado desbordamiento, que es donde
simplemente se envuelve de
nuevo a su valor mínimo. Y luego estaremos
contando a partir de ahí. Ahora bien, ¿qué tenemos para hacer de
esto un entero sin signo? Entonces diríamos int max, y esto
nos dará el valor máximo para un entero sin signo. Luego ejecuta un programa, en realidad mantente un número positivo y simplemente vuelve a 0, ya que ese es el
rango mínimo para un int sin signo. De todos modos, solo quería
mostrarte qué desbordamiento
fue muy rápido y entenderás
esa mejor idea de por qué te lo mostré
en el siguiente video. Además es algo bueno
saber para el futuro. De todos modos, lo principal que
quiero que le
quites a este video es
que los números aleatorios y el programa no son
realmente aleatorios y son lo que
llamamos pseudo aleatorios, así que simplemente aparecen
aleatorios a la usuario. Y lo que realmente está sucediendo
ya que estamos ingresando un número en una gran ecuación que nos
da un número aparentemente
aleatorio. Y al cambiar lo que es
este número, podemos obtener un número aparentemente
aleatorio cada vez. Y es por eso que insertamos la hora actual
en esta ecuación porque usa la fecha y hora dándonos un número
diferente. De todos modos, eso es todo
para este video. Asegúrense de que ustedes agreguen estas bibliotecas y nosotros
solo
las vamos a dejar aquí por el
resto del curso ya que no va
a doler nada. Gracias por mirar y te
veré en la siguiente.
44. Capítulo 8 (números aleatorios): generar números aleatorios: En este video, voy a estar
mostrándote cómo podemos obtener números
aparentemente aleatorios en C plus plus. Ahora, solo ignora esta línea de textos que tengo aquí mismo, y te voy a mostrar lo que esto
significa y un poquito. De todos modos, sigamos adelante
y creemos un programa que simule rodar diez veces un dado de
seis lados. Entonces antes que nada, lo que
vamos a hacer es que vamos a decir para int I es igual a 0, yo menos de diez. Yo más, más. Así como así. Dentro de nuestro bucle,
vamos a decir CL, rand, todos minúsculas, abrir y cerrar paréntesis y poner
punto y coma al final. Y lo que esto iba a
hacer es automáticamente simplemente darnos un
número aleatorio entre 0. Entonces número entre rand max. Ahora, rand max tiene un valor
mínimo de 32,767. Así que vamos a conseguir esta
loca gama de números. Como dije, ese es el valor
mínimo, no el máximo. Entonces, antes de ejecutar nuestro código, sigamos adelante y
pongamos a todos en una nueva línea. Entonces vamos a seguir adelante y ejecutarlo. Como puedes ver, hemos conseguido diez números aparentemente aleatorios. No obstante, sigamos adelante y tratemos de memorizar un
par de estos. Entonces este primero
es para 1184676334. Esos son nuestros tres primeros. Y si volvemos a ejecutar un programa, oh, ¿mirarías eso? Tenemos los mismos números exactos. Y si lo volviéramos a hacer,
volveríamos a obtener los mismos números. Y esto seguirá sucediendo para siempre porque como dije, no
es realmente aleatorio. Y se nos da la ecuación que hablé
en el último video, el mismo número exacto para
comenzar cada vez. Entonces obtienen más números
aparentemente aleatorios. Tenemos que responder a un valor
diferente en la ecuación que nos da
un número aparentemente aleatorio. Ahora bien, para hacer esto,
lo que vamos a hacer está en lo más alto de nuestro programa. Y por cierto, sólo
van a
querer hacer esto una vez. De lo contrario, no obtendrá números
aparentemente aleatorios como potencialmente podría. Vas a decir ese
hilo, todo minúscula. Y luego entre paréntesis, vamos a decir
tiempo todo en minúsculas. Y entre paréntesis otra vez, vamos a poner no. También puede ver a la gente poner 0 y es esencialmente
lo mismo. Y si paso el ratón sobre
él, se puede ver, pero también es 0. Y luego al
final, pondremos un punto y coma así que lo que esto va a hacer es
cuando nuestro programa se ejecute, vamos a estar poniendo la
hora y la fecha directamente en la ecuación que da nos un número aparentemente
aleatorio. Y entonces este método aleatorio aquí nos
va a dar
el resultado de eso. A pesar de que esto nos dio diez números
aparentemente aleatorios,
el problema era, como viste, una vez
que lo
volvimos a llamar y comenzamos
nuestro programa por completo. Esos diez primeros números
eran los mismos cada vez. Y podríamos haber
hecho unos 100 números y rehacer nuestro programa. Y habrían sido
los mismos 100 números. Nuevamente, aunque esos 100
números fueran diferentes. Entonces ahora cuando se ejecuta un programa, porque va
a usar la hora y fecha en que el programa se inicia por
primera vez. La ecuación de la que he
hablado nos va a dar una lista de números aleatorios
aparentemente diferentes cada vez, porque el tiempo debería ser diferente cada vez
que ejecutemos nuestro programa. Muy rápido, lo que esta
cosa hace como semilla, la ecuación aleatoria
con un número. Y en realidad puedes simplemente poner aquí
un número positivo, como cinco. Y esto va a funcionar. Y como pueden ver, si ejecuto nuestro programa sobre números
y los muertos antes. Pero si lo vuelvo a ejecutar, habrá los mismos números. Así que voy a volver aquí. Entonces de todos modos, ¿por qué solo
queremos
tener esto en nuestro programa una vez? Y ¿por qué no lo
pusimos en nuestro bucle for? Bueno, el problema es que
tu computadora lee tan rápido que al tener
este bucle for interno, potencialmente
podemos imprimir el mismo número
varias veces porque hubiéramos tenido el
mismo número exacto sembrado en nuestra ecuación. Debido a que esta línea de código aquí, puede
que se haya corrido dos veces
durante el mismo tiempo exacto, y por lo tanto, los
números no habrían sido tan aleatorios como podría haber sido si solo hubiéramos corrido esto una vez al inicio
de nuestro programa. Y debido a
que esto te permitirá obtener una lista de números, solo
quieres hacer esto una vez. Y como dije, solo pon esto al inicio
de tu programa. Si estás tratando de
obtener un número aleatorio y estarás todo listo para ir. Podemos apelar a esto
tantas veces como queramos. Como dije, cuando incluso
podemos aumentar esto si queremos y ejecutar nuestro código, se
puede ver que obtenemos
un 100 números. Y si nos fijamos en estos
tres primeros y es un poco
memorizar esos muy rápido. Una vez más pude,
se puede ver que
ya no son las mismas cada vez, que es exactamente lo que queremos. Ahora, como dije, estamos tratando de crear
un programa aquí, el simula un dado de seis lados. Y bueno, estos
números son una locura. Entonces, ¿cómo solucionamos esto? Bueno, recuerda ese
operador de módulo del que
hablamos cuando hablamos de operadores matemáticos
básicos. Bueno, este es un gran ejemplo de cuándo esto va a ser útil. Entonces, lo que vamos a hacer es alrededor de nuestro
método aleatorio llamar aquí. Y como dije,
entraremos en las
llamadas de método más adelante en el curso. Vamos a seguir adelante
y poner paréntesis. Así. Y luego aquí dentro, vamos a poner el operador de
módulo
seguido del número que
queramos, así que digamos sexo. Y ahora sabemos que
sólo podemos obtener un valor entre 05 porque este operador, si recuerdas,
nos da el resto de este número dividido
por este número. Pero si estamos tratando de
simular tirada de dados, probablemente
querrá un número
entre 16 y no 0 a cinco. Y bueno, no es un problema. Porque después, digamos
más uno, así como así. Ahora vamos a conseguir uno a seis. Y si ejecutamos nuestro
programa, ahí tienes. 12345678910, números aparentemente
aleatorios entre 16. Y podemos ejecutar esto
tantas veces como queramos. Y como puedes ver, parecen estar al
azar cada vez. Entonces ahí tienes. Esa es la forma más fácil de obtener números
aparentemente aleatorios
dentro de un rango que deseas. Entonces una cosa más que
quiero tocar es que dependiendo de
lo que estemos usando, este número aleatorio cuatro, existe la posibilidad de que
dependiendo de cuál sea ese número, lo
hagamos un error. Y puede ser difícil para nosotros
conseguir que ese número vuelva
a subir, sobre
todo dependiendo del rango que hagamos de él. Así que puedes hacer es
en realidad solo ahorrar este tiempo, ningún valor en alguna parte, y luego imprimirlo para que en el momento en que
obtengas el aire, tengas este valor para
retroceder en tu programa. Entonces lo que podríamos hacer
es decir algo así como sin firmar esta semilla y
ponerla igual al tiempo. Así como así. También puede ver esto
referido como tiempo 0. Esto hace exactamente lo mismo. No hay diferencia
entre esta línea aquí y esta. Entonces, si lo ves hace
un momento, lo mismo. Y luego aquí abajo, podemos seguir adelante y aguantar. Entonces podríamos decir que C out
Seed creó una línea. Ahora si ejecutamos un programa,
qué puedes hacer, si obtuviste algún tipo de error al ejecutar
tu programa aquí, puedes copiar este número exacto, volver a tu programa. Y solo eliminaré
esto aquí rápido. Y donde tenemos
ESR y aquí
solo puedes ingresar el mismo número
exacto que teníamos. Y porque esto necesita un valor entero
sin signo y no un int para una cabeza hace
y atrapar esas dos enzimas. Así. Ahí vas. Ahora podemos obtener el mismo número
cada vez que obtuvimos cuando tuvimos nuestro error
y diagnosticarlo de esa manera. que sea solo algo que
quieras tener en cuenta que quizás quieras una forma obtener el valor que se
ingresó en tu programa. Si has jugado algún tipo de juego como Minecraft o
algo así, donde tienen generación de
números aleatorios y te dan una semilla que te permite volver a obtener ese mismo mapa.
Bueno, ahí tienes. Eso es porque esa
generación de mapas en realidad no es aleatoria. Y solo puedes volver a poner ese
mismo valor en
la ecuación y volver a obtener el mismo mapa.
Y ahí tienes. Así es como obtienes
números aleatorios en C plus plus. Y ahora también sabes cómo obtener el mismo conjunto de
números aleatorios debe usar de jugo. De todos modos, espero que
este video te haya resultado útil. Gracias por mirar, y te
veré en la siguiente.
45. Capítulo 9 (contenedores): introducción a los contenedores: En este video, te voy a estar hablando de contenedores. Un contenedor es esencialmente
solo un objeto que contiene otros objetos y los
objetos que sostiene, o a menudo se conoce
como sus elementos. Otra cosa de los contenedores
es que tienen un montón de funciones que puedes usar para trabajar con todos los
elementos dentro de ellos. Ahora hay un montón
de diferentes contenedores en C plus plus. Y en este curso sólo
vamos a estar repasando un puñado de ellos. Pero
te animo mucho a que busques todos los diferentes
contenedores y al menos veas qué es lo que
hacen para que, ya
sabes, estén disponibles
para ti en caso de que los necesites. También solo cubriremos
algunas funciones y nuestros métodos para cada tipo de contenedor
que vamos a estar cubriendo. Entonces una vez más, si quieres
aprender más sobre ellos, recomiendo encarecidamente buscar
las diferentes funciones que
existen para que también puedas ver qué hay
disponible para eso. Ahora, al decidir
qué contenedor quieres usar
para tu proyecto, querrás no solo
elegir uno en función de
lo bien que maneja el trabajo a través de
todas sus diferentes funciones, sino también basado en las propias
funciones. Como cada uno tendrá
algo pueden hacer un poco
diferente al otro. Es, como dije, se
quiere elegir en función rapidez con la que cada uno lo haga, una tarea u otra, así
como la funcionalidad
que tiene a su disposición. Y para aquellos de
ustedes que vienen de otro fondo de
lenguaje de programación, es posible que también hayan visto estos
referidos como colecciones. De todos modos, eso es todo
para este video. Gracias por mirar, y te
veré en la siguiente.
46. Capítulo 9 (contenedores): ensayos: En este video, vamos
a estar hablando de arreglos. Ahora. Las matrices son el
primer contenedor del que hablaremos
en este curso y a menudo se consideran uno de los tipos de
contenedores más básicos que también
verás en otros lenguajes de
programación. Entonces, en primer lugar, las matrices son
básicamente solo un grupo de elementos del mismo
tipo almacenados en secuencia. Y también te
van a permitir
acceder a múltiples elementos
usando el mismo identificador. Recuerde, un contenedor
es básicamente algo que
contiene múltiples objetos. Y los objetos
dentro de ese contenedor son referidos como elementos. Entonces de ahí viene esa
palabra. Así que vamos a seguir adelante
y echar un vistazo a la sintaxis básica para una matriz. Entonces primero
vas a tener el datos seguido del nombre, seguido de corchetes abiertos y
cerrados. Y luego terminarás
eso con punto y coma. Y luego dentro de
esos corchetes, vas a tener
el tamaño de una matriz. Ahora cuando creas
y usas una matriz, empezaste a conocer el tamaño o cuántos elementos
quieres almacenarla en esa matriz, ya que es realmente ineficiente
ir con cambiar esto. Así que vamos a seguir adelante y crear matriz
básica de enteros. Entonces para hacer eso, vamos a
seguir adelante y saludar para comprar int array así. Y luego dentro de
estos corchetes, le
daremos una talla
de cinco, por ejemplo. Y luego pondremos punto y
coma al final. Así que esto aquí va a
crear una matriz int llamada int array con cinco
enteros en ella. Y podemos nombrar a esto como
queramos. Simplemente decidí llamarlo int
array por simplicidad. Ahora bien, fíjate si paso el
mouse sobre
esto, dice que
no están inicializados. Eso significa que aún no
tienen un valor inicial. Y hay algunas maneras en las que podemos seguir adelante y darle una. Entonces el primero sería
ponerlo antes del punto y coma. Entonces, hasta ahora, acabamos de
declarar esta matriz, pero no hemos dado ninguno de los enteros ahí
y el valor inicial. Entonces después de esto
podemos decir iguales y luego para abrir y
cerrar llaves,
así, noté esas líneas punteadas se
fueron en mi pantalla aquí. Y ahora cada entero en nuestra
matriz tiene un valor de 0. Entonces esta es una manera. Se puede
dar a cada valor entero 0, pero también podemos
seguir adelante y darles un valor exacto y diferentes valores dentro de
estos corchetes. Entonces para hacer eso,
simplemente podemos decir algo
como esto donde irías por
ciento veintidós,
veintiuno , y setenta y
seis o algo así. Así que ahora las cinco de nuestras variables
enteras en nuestra matriz int tienen un
valor inicial que hemos establecido. Entonces el primero será para, el segundo
será uno, y así sucesivamente. También en C más más, se
le permite simplemente
eliminar este signo igual y este será exactamente lo
mismo que si lo tuviéramos ahí. Personalmente, me gusta tenerlo
ahí ya que ya usamos el operador de asignación aquí para inicializar cosas como variables
y cosas así. Pero como dije,
puedes sacarlo. Entonces sí ve el
código de alguien sin eso, ya
sabes que es
exactamente lo mismo que con él. Ahora bien, ¿y si
quisiéramos seguir adelante e imprimir todos los phyla
son enteros? ¿Cómo accedemos a estos? Bueno, vamos a seguir adelante
y crear un bucle for. Así que vamos a decir cuatro, y luego vamos a decir
int I es igual a 0, yo menos de cinco, yo más, más. Y luego dentro de
nuestro bloque de código aquí, vamos a decir C0,
voy a decir int array, porque ese es el
nombre de nuestra matriz, seguido de corchetes abiertos y
cerrados y un punto y coma al final. Y luego dentro de aquí, tenemos que poner
el índice del que queremos imprimir. Y porque ya
tenemos un iterador que va a pasar de 0 a cuatro. Sólo vamos a poner en. Ahora para mostrarte cuáles son los
índices en consecuencia. La forma en que funcionan las matrices como esta
primera variable entera, NRA está en el índice 0. Entonces, si solo quisiera
imprimir este, pondría 0 aquí así, y luego va 01234, etc. así que solo vamos a
seguir adelante y poner una I. Y luego después de esto, sigamos
adelante y echemos una aerolínea y ejecutar nuestro código. Y como puedes ver, hemos
impreso 41520 a 121 en 76,
bien, y para
mostrarte que todos estos obtuvieron
un valor inicial de 0
sin nada aquí dentro bien, y para
mostrarte que todos estos obtuvieron . Si ejecutamos nuestro código
sin nada ahí dentro, ellos imprimirán 0. Bien, ahora sigamos
adelante y echemos un vistazo a la otra forma de inicializar
los valores en nuestro array. Así que vamos a seguir adelante y deshacernos de estos iguales y los
corchetes aquí. Y de la misma manera que
accedimos a los valores de nuestra
matriz para imprimirlos. También podemos acceder a los
valores para inicializarlos. Entonces podemos decir int array. Y luego entre corchetes, podríamos poner 0, por ejemplo. Sólo decir es igual a lo que
queramos, así. Y luego poner un
punto y coma al final. Y esto va a funcionar bien. Podríamos pasar
así si quisiéramos ir
1234 y obtener a cada uno de
estos un valor diferente. Bien, si ejecutamos un código, puedes ver que esto
funciona bien. Y fuimos 01234. Podríamos haber hecho esto en
cualquier orden si queremos. Ahora, digamos que queríamos
obtener todos estos el mismo valor exacto de digamos, 30. Y digamos que teníamos mucho
más de cinco y nuestra matriz. Entonces digamos que
tenemos un 100 de ellos. Bueno, en lugar de hacer esto, lo que nos llevaría para siempre, podemos ir justo aquí abajo. Entonces yo menos de un 100. Y luego aquí abajo, solo
agregaremos otra línea arriba donde estamos imprimiendo nuestros valores de matriz
y digamos int array. Voy a usar i para índice
una vez más aquí, y diremos es igual a 30. Y ahora se
imprimirá 3000 veces. Y no voy
a contar estos, pero confía en mí, hay un 100. Bien, entonces existen
las diferentes formas inicializar sus matrices. Además, podemos seguir adelante
y establecer la variable igual al valor dentro de una
matriz si quisiéramos también. Entonces podemos decir x es igual a int array y luego lanzar un índice como a, por ejemplo. Y si fuéramos a seguir adelante
e imprimir así, voy a seguir adelante y
comentar esta línea. Entonces puedes ver que eso
está funcionando ya que ahí hay un montón de 30
y ahí vas. Entonces ahí lo tienes. Ahora ya sabes cómo
trabajar con arreglos. Ahora, cuando quieras
usar una matriz, bueno,
antes que nada, recuerda que el
tamaño de una matriz es fijo. Entonces necesitas saber
el valor exacto, pero vas a estar
poniendo en él. Y te lo puedo demostrar
haciendo lo siguiente. Entonces si seguimos adelante y
borramos los de aquí y dicho x es igual a un 100, y luego tratamos de poner x aquí
para el tamaño de nuestra matriz. Se puede ver que obtenemos un
error porque tiene que ser un valor constante
que no puede cambiar. Ahora bien, podríamos hacer de esto una constante y esto
funcionaría bien. Pero solo tenga en cuenta que el tamaño de su matriz debe
conocerse de antemano. Además, son eficientes para recuperar los valores de ellos como lo hicimos aquí abajo
cuando los imprimimos. Y son geniales para
cuando quieres obtener los elementos dentro de tu
matriz en orden, como también lo hicimos aquí abajo. Ahora fui a evitar usarlos. Bueno, debes
evitarlos cuando quieras insertar o eliminar
elementos de la matriz, porque como dije,
son de tamaño fijo. Entonces, si no vas
a saber el tamaño cuando inicies tu programa, eso es un problema. Y un buen ejemplo de cuando no
querrías
usar estoy en lo cierto? De todos modos, eso
es todo para este video. En el siguiente video, vamos a estar
hablando de algo llamado matriz
multidimensional. Así que gracias por mirar, y te veré
en la siguiente.
47. 46: En este video, vamos a estar hablando de arreglos
multidimensionales. Ahora, la mejor manera de pensar
probablemente multidimensionales
como matrices de matrices. Además, una
matriz multidimensional puede tener tantas dimensiones como
necesites o desees, pero ten en cuenta que
la memoria se agota, sube drásticamente con
cada caso de dimensión agregada. Entonces eso es algo de lo
que hay que tener en cuenta. Entonces tengo un ejemplo de una
matriz bidimensional aquí para ti, que estará creando
aquí en un minuto. Entonces, para la matriz 2D, vas a tener
tu tipo de datos, tu nombre igual que antes. Pero ahora en lugar de solo un
juego de corchetes, vas a tener que hacerlo, si quisieras hacer una matriz
tridimensional, tendrías un tercer juego de
corchetes y así sucesivamente. Y entonces necesitas el tamaño
para cada una de estas dimensiones. Y yo solo pongo filas y columnas para ayudarte a
visualizar
cómo sería esto si
visualizas esto como una cuadrícula 2D donde
tienes filas y columnas, y puedes visualizar los elementos de una
matriz bidimensional con tres filas
y tres columnas que se visualizan como tal. Ahora bien, para acceder realmente a
cada uno de estos elementos, estaríamos haciendo lo que está
por aquí en consecuencia. Entonces esta primera
será 000102. Entonces vamos a bajar
a la fila uno, columna cero, porque recuerden, los índices empiezan en cero cuando se
trata de contenedores. Entonces esto será
10111220, t1, t2. Bien, así que vamos a seguir adelante
y de hecho crear esto e imprimirlo como está aquí arriba. Bien, entonces lo que vamos a
hacer es que vamos a decir, voy a decir más tipo array. Y luego
entre corchetes aquí, vamos a decir
tres después de eso. Y volveremos a decir tres. Voy a poner punto y coma al final. Además, podemos
seguir adelante e inicializar nuestra matriz multidimensional de
una manera similar a como
hicimos una matriz regular. Entonces podemos decir
algo así como iguales y luego tener dos
llaves así. Y todos estos se
inicializarán a cero. También. Podemos hacerlo de otra manera donde ponemos
un valor directamente. Entonces, si quisiéramos
que los valores se vieran
así aquí, podríamos decir una coma dos, coma tres, así. Y luego crear otro conjunto de corchetes para la siguiente fila. Se podría decir 456,
y luego volver a hacerlo. Entonces siete, nueve. Y ahora lo último que
tenemos que hacer para que esto funcione como poner todo esto y otro conjunto de
llaves. Entonces iremos así. Y también necesitamos poner una
coma entre cada conjunto. Así que así como así. Y si te resulta
más fácil de visualizar, puedes hacer algo como esto. Pero de todos modos, voy a seguir adelante y moverlos de
nuevo a como era. Entonces vamos a seguir adelante
y de hecho imprimir todos los valores y son matriz
multidimensional. Pero antes de hacer eso, voy a mostrarte
una última cosa que olvidé mostrarte
en el último video, y te mostraré
cómo funciona con una
matriz multidimensional también. Así que en caso de que lo
encuentres, ya que
normalmente no recomendaría hacer esto porque
puedes encontrarte algunos problemas inesperados es que
puedes decir int mi matriz, por ejemplo, le
daremos a esto un
tamaño de nada. Y entonces podemos decir iguales
y luego simplemente
inicializarlo en nuestras
llaves así. Y esto en realidad va a
funcionar bien. Y automáticamente
sabrá que
va a ser del tamaño de cuatro. Ahora, puedes hacer lo mismo aquí, pero solo puedes eliminar
este primer valor. Entonces en este caso, sería como eliminar la cantidad de filas, que se calculará por cuántos conjuntos de
llaves tenemos. Entonces la cantidad de columnas
que necesitas especificar, porque esto no va a funcionar. Como puede ver, inmediatamente
obtenemos un error, ¿verdad? Así que sólo quería
mostrártelo rápido. Después del tamaño de nuevo
allí explícitamente también. Entonces sigamos adelante
e imprimimos nuestra matriz aquí de una manera
que se vea así. Así que haz esto,
vamos a crear dos bucles
for que
vamos a decir para nuestros ceros son menos de
tres, r plus plus. Y luego dentro de aquí, voy a agregar otro
for-loop y decir int c es igual a cero, menos de tres, C más, más. Y vamos a crear unos
corchetes así. Y luego vamos a seguir adelante
e imprimir los valores. Entonces vamos a decir
C fuera. ¿Bien? Y luego
entre corchetes aquí, vamos a poner R y luego en su lugar son
otros corchetes. Entonces después de eso, simplemente
imprimiremos un espacio en blanco así. Y luego por debajo de ese bucle for, dentro de nuestro otro,
vamos a crear una línea en blanco. Además, al igual que un aviso,
esos Hollywood acceden, inicializan y editan cualquiera de los valores y nuestro array
multidimensional. Así que antes de donde
simplemente nos gustaría escribir
el nombre de la matriz seguido por el
índice del elemento. Aquí, nuestro índice se
vería algo así como te
mostré antes. Entonces, lo que va a
pasar es que vamos a pasar por nuestro primer bucle for. Y llamé a esta variable
son cortos para filas, pero podrías llamarla como
quisieras. Entonces la primera vez a través de R
va a ser igual a cero y c
será igual a cero. Entonces va a obtener el
índice 00 e
imprimir uno porque eso es
lo que tenemos, ¿verdad? Y luego va a volver a
pasar por este bucle otra vez e
imprimir dos y luego tres. Y entonces un pollo
estaba de vuelta, las filas cambiarán a una. Entonces vamos a estar a las
01:01, 112, etcétera. Entonces sigamos adelante y ejecutemos esto
y van a imprimirlo. 123, McDonald línea 456, y al final de la línea otra vez, 789. Y ahí lo tienes. Ahora, también podríamos haber
creado un bucle double for como este para inicializar todos
estos valores del uno al
nueve, como hicimos aquí arriba. Así que vamos a seguir adelante y ver
cómo se
vería eso si seguimos adelante y copiamos esos double for loop y los
pegamos aquí arriba,
fíjate que no obtuvimos ningún error porque
ambos de estos, ambos son locales a su bloque de código específico y
no existen fuera de él. Tener arte aquí y
C aquí, y R aquí, y mira aquí, no
causa ningún problema. Entonces sigamos adelante y eliminemos nuestra
inicialización inicial aquí arriba. Pero podemos seguir adelante e
inicializarlos a todos a cero. Eso está bien. Y luego abajo de
esto vamos a decir int I es igual a uno. Y entonces aquí
vamos a decir, en lugar de imprimir esto, diremos
RNC multitasa igual que antes. Pero en cambio
vamos a decir iguales. Y luego justo debajo de eso
dirá yo más más, para que
aumente en uno cada vez. Bien, ahora, sigamos
adelante y ejecutemos nuestro código. Como puedes ver, eso todo
inicializado, simplemente bien. Y la única razón por la que
en realidad está bajando algunas líneas aquí, solo porque
les dejamos la nueva línea. Pero como pueden ver, la
misma manera que
pudimos imprimirlos en orden usando este
double for loop. Pudimos
inicializarlos en orden usando un double
for loop, ¿verdad? Porque básicamente
es exactamente lo mismo. Pero en lugar de simplemente
imprimirlo, le
dimos un valor inicial, haciendo solo aumentar
yo en uno cada vez que les dan
un valor en orden. Y aunque en realidad
tenemos todos esos cortados, podría mostrarles cómo
podemos hacer rápidamente una tabla de multiplicar
y si quisiéramos. Así que vamos a seguir adelante y
cambiarlos a diez, por ejemplo, o incluso podríamos hacer algo así como, digamos
algo así como 30. Y entonces aquí abajo va a cambiar, subió a 34, nuestro valor r. Y ambos de estos, y
lo mismo con nuestro propio valor. Y los vamos a
empezar a ambos en uno en todos los casos aquí. Entonces, porque estábamos
disparando a ambos a la vez, si realmente quisiéramos que la mesa
tuviera 30 dígitos completos, querríamos cambiarlos
todos a 31, así. Entonces aquí mismo, vamos
a quitar este I plus, plus. Y así poniéndolo igual a i, vamos a decir R
por C, así como así. Ahora podemos quitar corazón
y yo variable por completo. Bien, así que ahora hemos creado una
matriz multidimensional de tamaño 31. Luego creamos un for-loop con una variable entera
que comienza en uno y continúa viviendo
siempre y cuando sea menor que 31. Y aumentamos nuestro
en uno cada vez, luego hacemos
lo mismo con C aquí abajo. Entonces ponemos r y
c para nuestros índices aquí y solo establecemos el
índice igual a R veces C. Y luego vamos a
seguir adelante y eliminar esto, la sentencia line aquí. Pero lo dejaremos en
el de aquí abajo. Entonces, en lugar de simplemente poner aquí
un solo espacio en blanco, solo
vamos
a poner en una pestaña. Y una manera fácil de hacer
esto sería poner en una sola cita como esta o un conjunto de
comillas simples, debería decir. Y luego barra diagonal inversa t, que creará una pestaña. Por cierto, cada vez que tengas la barras oblicuas y un personaje, Let's se puede considerar simplemente como un solo personaje para un char. Bien, así que
voy a correr bien. Ahora, sigamos adelante y
ejecutemos nuestro programa. Y como pueden ver, esto en realidad es
bastante grande aunque. Sigamos adelante y bajemos
esto a algo así como 11 para cada uno de estos. Y vuelve a ejecutar nuestro código. Y van 1-1012 veces
dos por dos es cuatro. Y si miramos por aquí, seis por 636, etcétera, y ahora hemos creado nuestra propia
tabla de multiplicación con solo unos cuantos bucles for y
una matriz multidimensional. Entonces es bastante ordenado de todos modos, eso es todo para este video. Gracias por mirar, y te
veré en la siguiente.
48. Capítulo 9 (contenedores): vectores: En este video, estaremos
hablando de vectores. Y se puede pensar en los vectores como esencialmente una matriz redimensionable con alguna funcionalidad adicional. Y eso es porque
hay un montón de funciones o métodos
adicionales
asociados con ellos. Y te estaré mostrando algunos de los que están aquí en este video. Pero si quieres ver todos
los métodos o
funciones posibles por ahí, te
recomiendo que los
busques ya que hay un montón de ellos. Ahora, muy rápido, seguí
adelante y volví a poner aquí la sintaxis para una matriz. Entonces, si recuerdas, vamos a poner
el tipo de datos, el nombre, y luego el tamaño
y algunos corchetes. Sin embargo, la sintaxis de un
vector es ligeramente diferente. Así que vamos a decir vector y todo en minúsculas seguido
del tipo de datos en el medio, un símbolo menor que y
mayor que. Y por último, tendremos el nombre seguido de un
punto y coma al final. Ahora antes de echar
un vistazo a cómo crear y usar un
vector propio, necesitamos agregar
otro archivo de encabezado
en la parte superior de nuestro código aquí. Entonces vamos a
decir hashtag include. Y luego entre el símbolo
menor que y mayor que, sólo
vamos a decir lector, así como así, ahora
tendremos acceso a
todo lo que necesitamos. Así que sigamos adelante
y comencemos. En primer lugar,
vamos a decir vector. Y luego entre el símbolo
menor que y mayor que, tendremos nuestro tipo de datos
seguido del nombre, y simplemente llamaremos a esto mi
el vector, así como así. Y dentro de aquí, igual que con otros contenedores, vas a poner
multitud de tipos de datos. Hasta ahora, hemos estado
usando enteros, pero en este caso,
¿por qué no simplemente seguimos adelante y ponemos cadenas? Bien, entonces solo diremos cadena, y en lugar de
llamarlo mi vector, ¿por qué no
lo llamamos simplemente mochila, así? Y luego al igual que
podríamos con las matrices, en realidad
podemos seguir adelante
e inmediatamente poner algunos elementos en
nuestro vector
aquí, aquí mismo, podríamos
decir iguales y luego entre llaves. Ahora bien, fíjate aquí que no
tenemos el tamaño de nuestro vector y eso es porque
dije que es redimensionable. Básicamente es un tamaño dinámico, lo que significa que puede cambiar a
medida que nuestro código se ejecuta. Entonces aquí mismo, podemos
seguir adelante y darle un tamaño predeterminado
arrojando algunos valores predeterminados. Así que vamos a fingir que estábamos
llenando una mochila aquí. Entonces pondremos algunas cadenas. Entonces podríamos decir algo
como libro, Kama, lápiz. Y también vamos a tirar en el bloc de notas. Bien, ahora, obviamente estas
son palabras arbitrarias y justas, pero entiendes la idea aquí abajo. De hecho, podemos
imprimir cosas de nuestro vector de la misma manera
que lo haríamos con una matriz. Así que en realidad podemos
decir mochila y luego abrir y cerrar
corchetes dentro. Pondremos el índice y
el índice funciona exactamente de la misma manera
que lo hizo con las matrices, donde va 012. Entonces dijimos uno de biotecnología y
queríamos imprimirlo. Diríamos C out
mochila uno, así. Y si ejecuto mi código aquí, se
puede ver que dice
lápiz porque esa es la cadena en nuestro primer
índice aquí o en el índice uno. Ahora bien, lo interesante los vectores comparados con los arrays
es que como dije, es un tamaño dinámico. De hecho, podemos agregar
cosas a esto y se agregarán
al final. En también, como dije
al principio, hay algunas funciones o
métodos extra asociados a
vectores que podemos usar. Sigamos adelante y
echemos un vistazo a uno de esos ahora mismo también. Entonces aquí abajo podemos decir mochila o el símbolo de época ahí. Vas a ver una
lista de opciones aquí, al
menos algún estudio visual. Pero en realidad sólo vamos
a seguir adelante y escribir en tamaño y luego abrir y cerrar paréntesis y un
punto y coma al final. Lo que esto va
a hacer es decirnos el tamaño exacto de
nuestro vector mochila. Y si quisiéramos, podríamos
gastarlo también. Digo C fuera antes de
eso, así como así. Y sigamos adelante y
echemos una nueva línea aquí. Hay un plazo para eso, solo para que no esté en
la misma línea que esta. Y ahora cuando nuestro código se ejecute, va a imprimir a lápiz. En este caso al menos. Y luego aquí mismo, va a
imprimir el tamaño. Y a diferencia de con los índices
donde va 012, el tamaño va a ir 123, tal como cabría esperar cuando quería saber
el tamaño de algo, ellos sabrán exactamente
cuántos artículos hay en él. Entonces hay que imprimir tres. Y si ejecutamos nuestro código aquí, puedes ver que
eso es lo que hace. Lo imprimimos a lápiz
y luego en una nueva línea, lo
imprimimos tres. Entonces, ¿cómo
agregamos elementos a nuestro vector? Bueno, si bajamos aquí, podemos simplemente filmarla ahí
atrás otra vez para que sepa
a qué nos estamos refiriendo o con qué queremos trabajar, que sería
mochila en este caso. Y luego vamos a decir punto y luego ver este método de
retroceso aquí. Eso es lo que
vamos a estar escribiendo. Vamos a decir push
y el marcador de vuelta. Y luego entre paréntesis, vamos a poner lo
que queremos agregar a nuestro vector. Entonces solo vamos a poner el
valor que queremos agregar, así como ponemos un lápiz
en el Bloc de notas aquí arriba, agregamos otra cadena, ya que nuestro vector está
compuesto por cadenas. Entonces aquí mismo, tomemos
algo como thriller y
pondremos punto y coma al final. Y ahora gobernante
va a estar en el índice tres porque tenemos 012 y
luego estamos agregando éste. Entonces esto sería tres. Y aquí abajo decimos
CL mochila tres. Y sigamos adelante
y asegurémonos de que se puso en una nueva línea. Así que solo diremos la línea M
así y ejecutaremos nuestro código. Se puede ver eso como
el estuche lápiz. Aparecer, imprimir tres, agregar una regla y luego imprimirlo lo que
estaba en el índice tres. Ahora bien, aquí mismo, es bastante
fácil para nosotros decir que este elemento de regla que acabamos de
agregar está en el índice tres, diciendo es que todo está aquí
mismo en los federales, aquí
mismo en nuestra pantalla. Pero, ¿y si solo
quisiéramos imprimir el último elemento de nuestro vector? Pero no sabíamos exactamente
qué índice era ese. Bueno, debido a que tenemos este método de tamaño
podemos usar que nos
dirá el tamaño exacto del mismo. De hecho, podríamos
decir tamaño de punto de mochila. Entonces después de esto,
tenemos que decir menos uno. Ahora bien, la razón por la que tenemos este menos uno aquí como porque a
pesar de que nuestra mochila o
unas horquillas de tamaño vectorial ,
aquí
tenemos cuatro artículos no tiene un índice de
cuatro porque va 0123. Y si queremos acceder
al valor real aquí
e imprimirlo, en lugar de simplemente
imprimir tres aquí mismo, vamos a poner esto
entre corchetes después del nombre de nuestro vector, igual que lo haríamos
si estuviéramos tratando de
acceder a cualquier otro valor aquí. Sigamos adelante y cortemos eso. Y diremos mochila
entre corchetes. Sigamos adelante y
peguemos eso así. Ahora va a imprimir
cuál es esa mochila índice cuatro menos uno o lo que sea
el tamaño máximo es menos uno, que siempre será
el último artículo en nuestro, bien, así es como puedes obtener el último artículo,
¿deberías necesitarlo? Y si ejecutamos nuestro
código aquí mismo, se
puede ver trigo que
de hecho imprime regla. Ahora también podemos eliminar elementos de nuestro vector
y ahí se
eliminarán en el mismo orden. Así que al igual que lo agrega hasta
el final de nuestro vector, podemos eliminar cosas
del final de nuestro vector. Tan rápido,
sólo voy a
seguir adelante y sacar
esta mochila c out. Una línea que tenemos aquí, así que creamos una mochila. Imprimimos la talla, que en este caso es de tres. Agregamos un artículo, imprimimos cuál es
nuestro último artículo, luego en realidad
vamos a seguir adelante y eliminar ese último artículo. Entonces aquí abajo, vamos a decir esa op, subrayarlo de nuevo. Todo minúscula ahí,
abrir y cerrar paréntesis y un
punto y coma al final. Y lo que esto
va a hacer es empujar el último ítem justo
fuera de nuestro vector. Entonces si copiamos nuestra impresión
del último artículo aquí y pegamos eso abajo y lo que no son abrigo, puedes ver eso, bueno, primero creamos
una nueva línea, luego imprimimos
tres porque eso es el tamaño de nuestro vector. Después agregamos un elemento de regla, imprimimos el último elemento
siendo el gobernante diciendo es que
acabamos de agregar eso y luego
nos deshicimos de la regla. Entonces ahora nuestro último artículo es Bloc y lo imprimimos también. Entonces ahí tienes. Ahora ya sabes
cómo crear y usar a. y estos tres métodos
aquí siendo el tamaño,
el método pushback y el método pop
back son probablemente los tres métodos y funciones
OR más
comunes que vas a usar
cuando se trata de vectores. Entonces, ¿cuándo
quieres usar un vector? Bueno, cuando quieres que un montón
de datos se almacenen en orden tal como lo
fue con una matriz. Y cuando no
conoces el tamaño en tiempo de
compilación o cuando
ejecutas tu código. Entonces no sabíamos cuál iba a ser
el tamaño, y no teníamos que introducir un tamaño como lo hicimos
con una matriz. Simplemente fue capaz de cambiar
dinámicamente a medida que nuestro código de renta. Entonces, si eso es
algo que
necesitas, quizás quieras
considerar usar un vector. Y si planeas agregar
y eliminar elementos desde el final del
contenedor que estás usando, entonces un vector es otra buena opción porque
como has visto aquí, hay un método para eso. Y debido a que nuestra información
se almacena en orden, podríamos haber iterado
a través de esto e imprimirlo todo tal como
pudimos con nuestra matriz. Ahora bien, ¿cuándo no
querrías usar un vector? Bueno, si estás tratando
de agregar o eliminar elementos en la
parte frontal del vector, es
decir, como aquí atrás
donde el libro estaba en índice 0 o
en algún lugar en el medio. Especialmente si tienes
muchos más artículos aquí, entonces esto probablemente
no sea para ti. Además, si ya
conoces el tamaño
del contenedor y eso
no va a cambiar. Bien podría usar una matriz. Ahora está oscuro aquí. Sigamos adelante e imprimimos todo en nuestro vector
solo para mostrarte un poco más un pequeño
truco más ordenado que podemos hacer con un vector debido a
estas funciones adicionales. Entonces aquí mismo, voy a decir
para int yo es igual a 0, yo es menor que
mochila tamaño dado. Entonces yo más, más, y luego por debajo de eso
en corchetes
simplemente van a decir mochila. Y luego corchetes. Diremos hola, y
después de eso solo
crearemos una nueva línea así. Y ahora va a
imprimir todo en su mochila independientemente de cuántos artículos haya en
nuestro Peck, Peck, ¿verdad? Porque
ahora es dinámico basado en el tamaño. Y luego sigamos adelante y
eliminemos todo aquí arriba, igual que antes, nuestro
bucle for y ejecutemos nuestro código. Y como pueden ver, hemos impreso
libro, lápiz, bolígrafo. E incluso si cambiamos
nuestro tamaño aquí, y podríamos hacer esto aquí arriba, o podríamos hacerlo usando nuestra función
push-back nuevamente. Entonces diremos mochila
dot push back. Entonces entre paréntesis
va a decir algo así como decenas. Y luego si ejecutamos nuestro código sin cambiar nada aquí, puedes ver que
ahora imprimimos bolígrafos. Entonces ahí tienes. Solo hay otro caso de uso para
el método size. Y otra razón por la que
quizás quieras usar un factor para la funcionalidad extra de la que hablamos
al principio. Y eso es porque
como puedes ver, podemos cambiar nuestro vector
aumentando el tamaño y
disminuyendo el tamaño. Y nuestro for-loop
nunca tiene que cambiar. Y antes de que me olvide, vamos a seguir adelante y dejar este archivo de encabezado vectorial y nuestro código a partir de ahora junto
con el resto de estos. Y vamos a seguir
haciendo eso de aquí en adelante. Cada vez que
añadimos un archivo de encabezado, solo lo vamos a dejar a menos que
se indique lo contrario. De todos modos, eso es todo
para este video. Gracias por mirar, y te
veré en la siguiente.
49. Capítulo 9 (contenedores): colas: En este video, vamos
a estar hablando de colas. Ahora una cola es otro
tipo de contenedor. Suelen decir primero en entrar, primero en salir tipo de arreglo. Entonces básicamente lo que sea que esté
frente a la cola, primero iba a salir
de la cola. Y se puede pensar
en esto como hacer cola para
llegar a la caja registradora en una tienda de abarrotes o
algo así. Quien llegue primero
va a salir primero. Entonces primero en entrar, primero en salir. Ahora la sintaxis para esto
es muy similar a la sintaxis de un vector que acabamos de ver
en el último video. Pero en vez de decir vector, sólo
vamos a decir cola. Una vez más en todas minúsculas. En la parte superior aquí,
vamos a seguir adelante e incluir también el archivo de encabezado. Y eso solo
se va a llamar cola y estar seguro de mantener eso ahí por
el resto del curso. Entonces en la parte superior aquí, y vamos a decir hashtag
incluyen así. Ahora, sigamos adelante y
creamos y trabajemos con agudo. Entonces para este ejemplo, solo
crearemos una
cola de enteros. Aquí. Vamos a decir Q, luego R datos con ellos el símbolo
menor que y mayor que. Entonces diremos, luego después, le
daremos un nombre a esto. ¿Por qué no simplemente llamamos a esto
algo así como puntajes de quiz? Bien, entonces sigamos
adelante y en realidad sumemos algunos enteros a r en cubos. Entonces abajo aquí para hacer esto, tenemos que hacer es decir el
nombre de nuestra cola para que sepa de lo que estamos hablando en
primer lugar. No quiero decir punto,
push y entre paréntesis, solo
ponemos lo que queremos
agregar en punto y coma inalámbrico al final y decir
algo así como un 100. Y sigamos adelante y sumemos unos cuantos más que podamos poner en el
número que quieras. Me gusta. Entonces con una cola, si queremos
imprimir algo,
Enter q, en realidad no podemos hacer. Tenemos en el pasado, así que no podemos decir puntaje de quiz. Y luego
entre corchetes, digamos como dos, por ejemplo, con punto y coma
al final es esto no funciona. Y se puede ver aquí, y si
tratara de decir C aquí afuera, no
nos permitiría hacer eso, vamos a obtener un error. Entonces, ¿cómo lo hacemos? Bueno, si quieres
pronunciar toda tu cola, vas a hacer lo siguiente. Entonces antes que nada, vamos
a crear un bucle while y luego vamos a poner el símbolo
not y nuestra
condición aquí, seguido del nombre de
nuestra cola, las puntuaciones de los quiz. Y entonces vamos a decir morir,
vacío, todo minúscula con paréntesis
abiertos y cerrados, así. Entonces lo que estamos diciendo
aquí es que si bien quiz puntúa siendo
nuestro q, no está vacío, así que este vacío
volverá verdadero si está vacío y falso
si no está vacío. Pero si recuerdas, porque tenemos este nudo aquí, conseguirá el efecto contrario. Vestirse bien,
las puntuaciones de los quiz no están vacías. Queríamos hacer lo siguiente. Y lo que queremos
hacer es imprimir lo que está al
frente de nuestra cola. Y si recuerdas,
el contenedor Q usa un primero en entrar, primero en salir. Entonces porque si miramos aquí, 100 fue el primero, va a ser
el primero que imprimimos. Y para ello, simplemente
vamos a decir CL. Y después
vamos a decir puntajes de quiz. Y esto va a
imprimir lo que está
al frente de la cola. Eso solo fueron paréntesis abiertos y
cerrados así en punto y coma al final. Entonces, lo que hace este
método frontal aquí es devolver el valor al
frente de la cola. Y también hay un método de respaldo para obtener lo que hay al
final de la cola. Pero si queremos poder
conseguir todo, así que no solo la
parte delantera o la trasera, todo lo demás, en realidad
vamos a tener que
empezar a eliminarlas. Entonces como dije, se puede pensar que una cola se está poniendo
en fila en alguna parte. La primera persona
va a ir en la segunda, la tercera, la cuarta. Y todo
va a ir en orden. Y así
va a ser aquí. ¿Bien? Así que justo debajo de aquí, en realidad
vas
a decir puntuaciones de los exámenes, abrir y cerrar paréntesis
y un punto y coma al final. Entonces yo, quiz scores dot plot hace, es que en realidad elimina
el elemento y el frente de nuestra cola
simplemente se deshace de él. Esto se habrá ido. Ahora bien, lo que va
a pasar es
que primero creamos una cola diciendo Q, R tipo de datos entre el símbolo
menor que y
mayor que y le dimos un nombre. Después agregamos elementos con sólo
decir su nombre dot push, y sea cual sea el orden que
agreguemos estos en el orden, estarán en un RQ, y también es el
orden que dejarán. El primero va primero, segundo, segundo, tercero, tercero, y así sucesivamente. Entonces aquí abajo
para poder imprimirlos. Porque como dije, solo
podemos
acceder a este frontal en este trasero ya sea con el método
front o con el método front. Pero aquí solo usamos
el que se llama front. Y dijimos, guau, las
puntuaciones de los exámenes no están vacías, lo que significa
que todavía hay algo en nuestra cola. Vamos a
imprimir lo que hay en el frente y luego deshacernos de lo que hay en el frente
usando el método pop. Y es posible que reconozcas
la palabra pop y la palabra push de cuando
trabajamos con vectores
en el último video, excepto que tuvimos que guardar
pushback en, pop back. Ahora, antes de ejecutar
nuestro código aquí, sigamos adelante y
lanzemos una nueva línea aquí. Entonces, cuando un código, ya se puede ver
imprimimos 18034 del archivo. Y luego antes de que
terminemos este video, solo
voy a
mostrarte un último método. Entonces justo antes de un tiempo en vivo, si decimos puntuaciones de quiz, tamaño de
punto, apertura, paréntesis de
cierre y punto y coma al final. Y vamos a seguir adelante e imprimirlo de
hecho. Entonces digamos CL justo antes de
eso también
crearemos uno nuevo después
y ejecutaremos nuestro código. Se puede ver que
imprime el tamaño, igual que podríamos hacer
con nuestro gusto allí. Así que eso siempre es agradable. Entonces tenemos 1803455 para diferentes elementos aquí con
la impresión que hacia fuera u obtener ese valor con el método
size donde, pero comprueba si está vacío
con el método vacío. También aprendimos
a revisar el frente del cubo con
el método front. Y también sabemos que podemos obtener la parte de atrás de la cola
con el método back, que está escrito tal
como pensarías, donde dices atrás en todas las
minúsculas y configuras por adelantado. Y si estás
pensando en esto como una línea en una tienda o
algo así, entonces esta será la primera línea y esto
estará al final de la línea. Entonces esa es una
manera fácil de recordar qué valor estás obteniendo
cuando dices adelante o atrás. Entonces ya sabes cómo crear
y trabajar con la señal, cómo agregar valores
y eliminar valor. Observamos que es un tipo de
contenedor
primero en entrar, primero en salir y conocemos algunos de los métodos
asociados a él. Y al igual que con los
otros contenedores, hay algunas otras
funciones que puedes usar con esto son las que
están asociadas a él. Y si te
interesa, no dudes en
ir a verlas de todos modos. Pero eso es todo para este video. Pero antes de pasar
al siguiente, pero quiero que
hagas es seguir adelante y guardar todo lo que
tengas porque lo
vamos a usar en el siguiente
video cuando hablemos un contenedor muy similar
llamado pila. De todos modos, gracias por mirar, y te veré
en la siguiente.
50. 49: En este video,
vamos a estar hablando otro
tipo de contenedor llamado pila. Como pueden ver, aquí tengo
este código de nuestro último video porque
por si te lo perdiste, quería que
guardaran lo que teníamos de ellos porque lo vamos a
usar de nuevo en este video. Y si te olvidaste, no te preocupes, sólo tienes que seguir adelante y copiar lo que
tengo aquí en pantalla. Ahora, antes de entrar en las existencias, necesitamos agregar
otro archivo de encabezado. Así que arriba en la cima aquí, vamos a decir hashtag food. Y luego entre el símbolo
menor que y
mayor que, simplemente
vamos a
decir eso así como así. Y una vez más, vamos a dejar esto para el resto del curso. Así que asegúrate
de estar diciendo que
ahora están aquí abajo con
el código real. Sigamos adelante y
echemos un vistazo a las diferencias entre
una pila y una cola. En primer lugar, la única diferencia de
sintaxis entre una pila y una cola, porque eso en vez
de decir q, vamos a decir pila. ¿Qué tan fácil es eso? Entonces vamos a decir pila.
Así como así. Podemos dejar nuestro nombre
aquí si quisiéramos. Incluso podemos dejar aquí estos
métodos si queremos, porque han trabajado exactamente
de la misma manera. Y además tiene un
método push que pone a estos uno frente al otro. Sin embargo, una pila
funciona y último en entrar, primero en salir tipo de arreglo. Entonces, si quieres pensar en
apilar bloques están poniendo una carta encima de otra y luego siempre
dibujando desde arriba. Básicamente cómo funciona esto. Así que esto de aquí
en realidad va a ser como nuestra carta inferior, por ejemplo, y luego tendremos nuestra
encima de eso, la que está encima de eso y
la otra encima de esa. Y luego cuando
sacemos de estos, vamos a volver en sentido contrario así. El último en va
a ser el primero. Entonces esta de aquí es la
parte superior de nuestra pila. Aquí está el fondo. Así que solo recuerda que ahora nuestro método de tamaño aquí
incluso funciona también. Así que ahí no hay que
cambiar nada. Ahora, cuando lleguemos
a nuestro bucle while aquí, vas a notar que
este método asustado tiene un error, y eso es porque ya no
tenemos el método llamado front. En cambio, solo decimos arriba. Entonces, la parte superior de nuestra pila es lo que
obtendremos cuando digamos pop aquí para ti, haciendo estallar la
parte superior de nuestra pila, bien, para que todo lo demás
pueda permanecer exactamente igual. Déjanos fantásticos. Si quieres trabajar
con una pila o cola, prácticamente nada
va a cambiar excepto con los métodos que hemos visto
aquí donde está la función, solo
quieres
cambiar esto en lugar
del método front que nos dio el primer valor puesto
en nuestra cola, tenemos este
método top fue porque ese es el último valor
puesto en nuestra cola, porque trabajamos con un tipo de last-in, first one out arreglo cuando se
trata de pilas. Entonces, si seguimos adelante
y ejecutamos nuestro código aquí, se
puede ver que
todo está funcionando. Sin embargo,
imprimimos nuestros números y la dirección opuesta a la que
hicimos con nuestra cola, ya que es una pila y
funciona como último en entrar, primero en salir en lugar
de primero en entrar, primero en salir. Entonces porque 55 estaba en
la parte superior de nuestra pila y fue el primero en salir de
nuestras suites de refrigerios con 553,480.100. Y la razón
tenemos cuatro aquí arriba como porque también
imprimimos el tamaño y tenemos
cuatro elementos ahí dentro. Ahora, también quiero mencionar porque el
método front no existe, tampoco el método back. No se puede obtener
este valor inferior, y eso
es prácticamente todo para este video. Ahora, al igual que con los
otros contenedores u otras funciones y
nuestros métodos que existen. Y te animo mucho
a que los revises si estás interesado en usar una
pila en tu programa. Entonces, ¿cuándo
querrías usar una cola y cuándo
querrías usar una pila? Entonces, cuando quieras un
contenedor que funcione en un
estilo primero en entrar, primero en salir, usa la cola. Y cuando quieres
contenerlo funciona en un estilo de último ingreso, primero en salir. Puedes usar la pila,
pero solo recuerda, realmente solo tienes
acceso a ese último valor que pones en una
pila y una cola, tienes acceso a ambos. Sin embargo, con una cola, sólo se
puede sacar el primer valor que se puso con una pila
es el último valor. Así que tienes que ser el
último en entrar, primero en salir y el primero en entrar, primero en salir. Pero si necesitas trabajar
con esos valores medios, recuerda,
probablemente solo querrán
usar un contenedor diferente. Y ya hemos hablado
de algunos de ellos, pero hay
otros por ahí. Entonces, si estás
interesado en esos, ve a comprobarlo. De lo contrario, sí tenemos
al menos uno más que
viene en un futuro video en
este curso llamado mapa. Así que estén atentos para eso. De todos modos, eso es todo
para este video. Gracias por mirar, y te
veré en la siguiente.
51. Capítulo 10: Introducción a los bucles para cada bucle: En este video,
vamos a estar
hablando de un nuevo tipo de bucle. El para cada bucle, lo que hace a para cada bucle es que ejecuta una sección de código para cada elemento en un contenedor de un tipo especificado estará
creando uno de estos. Y el siguiente video, veremos exactamente de qué es lo
que estoy hablando, pero solo quería darte un breve video de introducción qué son
y qué hacen. Entonces, la otra cosa a tener en cuenta sobre un bucle foreach
es que en realidad
copian los valores en un contenedor que están
usando para su operación. Y te voy a mostrar un ejemplo de esto cuando también trabajemos
en estos. Además, por cada bucles solo corren a través de un
contenedor en orden. Esto es algo
a tomar nota, que pasará del
índice 0 hasta el final. Ahora, déjame darte un
par de ejemplos de cuándo podrías querer
usar un para cada bucle. Ahora bien, un ejemplo podría ser
que quieres
imprimir todo en un contenedor. Así que puedes
imprimir el valor de cada elemento y tal vez quieras obtener
el tamaño de una matriz. Por ejemplo, bueno,
podrías tener una variable y luego en
tu a para cada bucle, podrías decir para cada
elemento de nuestra matriz,
vamos a
seguir adelante y aumentar
esa variable en vamos a
seguir adelante y aumentar uno. Por lo que también podrías usar
un para cada bucle para obtener el tamaño de un contenedor, solo como ejemplo, todos modos, eso
es todo para este video. En el siguiente video,
vamos a estar creando un bucle for-each
y trabajando con él, además de compararlo un for-loop del que hemos
aprendido en el pasado. Solo para que veas las
diferencias y aprendas cuándo querrías
usar una sobre la otra. Entonces gracias por mirar y te
veré en la siguiente.
52. Capítulo 10: los bucles de Foreach: En este video, en
realidad estaremos creando un working with
para cada loops y comparándolos con el
bucle FOR para que puedas ver la diferencia y
saber cuándo usar uno sobre el otro. Ahora bien, la razón por la que
decidí dividir un bucle sencillo en
dos videos diferentes, es porque personalmente, encontré para cada labios bastante confuso, al
menos la forma en que me
explicaron cuando primero los aprendió. Entonces solo quería
asegurarme de que eso pudiera desglosarlo paso a paso y realmente asegurarme de
que entiendas cómo y cuándo usarlos
sin ningún problema. Así que antes que nada, vamos
a empezar por crear una matriz de diez enteros. Así que vamos a decir mi
matriz de corchetes aquí. Pondremos diez, así. Y aquí no vamos a
darle un valor a esto. Y luego dijo que lo vamos a
hacer en un bucle for. Entonces aquí abajo, vamos a decir
para int I es igual a 0, yo menos de diez, yo más, más. Luego dentro de nuestro
for-loop aquí, vamos a dar cada elemento en nuestra matriz y valor inicial. Así que vamos a decir
mi matriz en el índice. I. ¿
Recuerdas que acabas de poner
eso entre corchetes, así es igual, verdad? Ahora, vamos a
poner esto a cinco. Entonces arriba o para bucle. Sigamos adelante y digamos sram. Y si recuerdas cómo
usar esto dentro de aquí, vamos a decir tiempo, y entre paréntesis diremos que no. Y si te das cuenta cuando
pasamos el mouse sobre S
aquí mismo y realmente
toma un int sin firmar. Entonces a algunas personas les gusta
asegurarse de que van a
obtener un int sin firmar vuelta y solo decir sin firmar así
entre paréntesis ahí. Y se
asegurarán de que obtengas un valor positivo
de este método del tiempo. Entonces aquí abajo, en lugar de poner todo
igual a cinco, diremos rand
entre paréntesis así, seguido del operador de
módulo. Y lo pondremos un 100 más uno. Y sigamos adelante y pongamos esto entre paréntesis solo para
asegurar el orden de las operaciones como correcto o para definirlo
explícitamente. Y luego abajo de eso, sigamos adelante y creamos un, otro bucle for para
imprimir nuestra variable. Sí, sé que podríamos
imprimirlo aquí, pero ya verás por qué estamos
haciendo esto en un momento. Entonces aquí abajo, vamos
a decir que el tiempo es igual a 0, yo, menos de diez. Yo más, más. Y luego entre corchetes
diré mi índice de matriz I. Y en realidad vamos a
decir C fuera de mi índice de matriz, voy a crear una nueva línea
después de cada una, así. Ahora por debajo de esto, vamos a hacer exactamente lo mismo que hicimos
en estos dos bucles for. Lo que vamos a hacer
en R para cada bucle. Pero primero, sigamos
adelante y ejecutemos nuestro programa y asegurémonos de
que todo esté funcionando. Entonces, como pueden ver,
aquí tenemos diez números aparentemente aleatorios, entre 1100. Y ahora. Sigamos adelante y comentemos todo eso
muy rápido. Y en realidad lo
vamos a dejar aquí, así que no lo borres. Y luego por debajo de eso, vamos a hacer
lo mismo en un para cada bucle. Así que aquí abajo,
vamos a crear nuestro
primer bucle foreach. Y la sintaxis para esto
va a ser la siguiente. Entonces la sintaxis para a, para cada bucle se ve así.
Vamos a decir cuatro. Y luego entre paréntesis, vamos a decir el tipo de
datos de nuestros elementos, seguido de un
nombre de variable, luego dos puntos. Y por último el nombre de nuestro contenedor con el que
vamos a estar trabajando. Entonces aquí vamos a tener nuestro
contenedor así como así. Y en caso de que no estés seguro a lo que me refería con todo esto aquí. Verás en un segundo cuando
sigamos adelante y lo creamos, y luego volveré sobre él. Voy a cargar al final para
asegurarme de que entiendas. Así que ahora vamos a
seguir adelante y realmente crear uno que funcione
con nuestra matriz. Digamos para en nuestro tipo de
datos de matriz como un int. Entonces ese va a ser el tipo de datos
de nuestros elementos ahí. Entonces aquí, digamos para int, entonces nuestro nombre de variable
puede ser lo que queramos. Así que vamos a seguir adelante y
poner algo así como huevos. Y luego después de eso, poner dos puntos
seguidos del nombre del contenedor, que en este caso es
mi array, así. Y después de eso, tengo un
juego de corchetes. Y ahí tienes. Ahora hemos creado
un para cada bucle. Entonces, ¿cómo lees exactamente esto? Bueno, sé lo que
vincula a esos cuatro aquí, pero imagínese
aquí por un minuto. Esto es para cada
elemento de nuestra matriz, quiere crear
una variable llamada x y establecer que sea igual
al elemento. Entonces, a medida que pasa por
nuestra matriz aquí, x va a ser igual a cada elemento a medida
que recorre. Entonces ojalá eso tenga sentido. Si no, vamos a seguir
adelante e imprimir el resultado de lo que estoy
hablando aquí. Entonces primero, tenemos que seguir adelante e inicializar todas las
variables en nuestro array. De hecho, podemos hacer eso con
nuestro período de bucle foreach. Pero primero, vamos
a tener que decir algo así. Diremos que i es igual a 0. Y luego cada vez que corremos
a través de nuestro bucle foreach, que va a ser
la misma cantidad de tiempo en cuanto a
elementos en nuestra matriz, porque nuestro
bucle foreach se ejecuta una vez por elemento en nuestra matriz. Entonces aquí dentro, vamos
a decir yo más más. Y también vamos a decir mi matriz
entre corchetes aquí. Vamos a decir i es igual, y vamos a seguir adelante
y establecerlo igual a I. Luego abajo de eso, vamos a crear otro para
cada bucle a través de nuestra matriz. Así que digamos para una matriz. Y en este bloque de código sólo lo
imprimirá. Entonces di x line y cuál es nuestro código. Entonces, para darte una mejor visión
de lo que está sucediendo aquí, sigamos adelante y pasemos
a mi matriz aquí, aquí abajo, y volvamos a ejecutar
nuestro código. Bien, así como pueden ver, hemos creado una matriz, tal como lo hicimos en el
pasado con diez enteros. Entonces creamos un
iterador aquí simplemente
creando una variable llamada I
y configurándola igual a 0. Entonces dijimos para cada
entero en nuestra matriz, queremos crear una
variable llamada x Luego dijimos para cada
entero en nuestra matriz, queremos ejecutar este
bloque de código. Y cuando hacemos eso, queremos establecer x igual a cada
elemento a medida que avanzamos. Entonces la primera vez a través de x
será igual al elemento 0, luego uno, luego 23, etc. Ahora bien, no tenemos que
preocuparnos por el hecho de que esto fue ininicializado porque
no hicimos nada con x. En cambio, nosotros acaba de decir
mi matriz en i, yo estaba 0. Entonces el índice 0 es igual a I, que la primera
vez a través es 0. Entonces lo aumentamos en uno y lo
pasamos diez veces, dando a nuestros elementos el
valor del 0 al nueve. Después de eso creamos
otro para cada bucle. Dijimos por cada
entero y nuestra matriz, vamos a ejecutar a través de
este bloque de código. No quiero establecer x igual a cada uno de los elementos a
medida que avanzamos. Entonces porque el elemento 0 era 0, x es 0, y luego imprimirlo 0. Entonces la siguiente vez a través, porque el elemento uno era uno, X0, X1, y luego imprimirlo uno y así sucesivamente todo el camino a través. Y esto es exactamente lo mismo que si tomáramos nuestro interés
aquí y lo moviéramos arriba. Me comentan nuestro código aquí. Y voy a seguir adelante y
cortar esto al azar pueden aquí y simplemente ponerla
igual a I y en código. Y como puede ver,
hemos impreso 0 al nueve de nuestros
dos bucles for, y lo imprimimos de
0 a nueve una
vez más con nuestros cuatro bucles cada uno. Entonces hicimos lo mismo
aquí que aquí. Entonces, ¿cuándo
querrías usar un para cada bucle en lugar
de un bucle for of? Bueno, personalmente,
creo que cuando estamos inicializando los
valores en nuestro array, esto se ve mucho más
limpio que uno. Nuestro iterador está en
un todo separado. Entonces nuestra
actualización de variables aquí siendo I plus plus también está
en una línea separada. Tampoco está claro
cuántos elementos hay en nuestra matriz en este
bloque de código aquí. Entonces, personalmente,
creo que esto se ve mucho más limpio para
nuestra inicialización. Ahora bien, ¿qué pasa cuando solo
queríamos imprimir todo
en nuestra matriz? Bueno, esto de aquí, tuvimos que, antes que nada saber
cuántos elementos hay en él. Entonces tuvimos que crear una
variable para iterar a través. Entonces tuvimos que
incrementarlo en uno cada vez. Y también tuvimos que escribir
el nombre de nuestra matriz poder de un índice coloreado
por nuestra variable iteradora. Mientras que aquí acabamos de decir por
cada entero en nuestra matriz, vamos a establecer
este valor igual a cada elemento y
bam impreso. Entonces, personalmente, si fuera
yo, haría algo. Como creo que esto
se ve mucho más limpio. Ahora en este caso, puedes hacer lo que sea con lo que te
sientas más cómodo. Pero personalmente,
creo que esto sí se ve mucho más limpio y
también está muy claro que solo queremos
ejecutar este bucle para
tantos elementos que hay en
nuestra matriz versus esto, donde Assad estaba justo
leyendo esto aquí. Sólo dice que menos de diez. Y entonces podemos
asumir que esa es la cantidad de variables
que estamos en nuestra matriz. Esto es muy claro que
iban a ejecutar esto para tantos elementos como
haya en nuestra matriz. Y esto aún quedaría
claro si esto aquí era una cola o una pila o
un vector, etcétera. Ahora, sigamos adelante y hagamos una cosa
más con esto aquí. Así que vamos a poner de nuevo en nuestra declaración
aleatoria aquí. Entonces diremos es igual al
módulo rand a 100 más uno. Entonces aquí abajo, vamos a
crear una variable que digamos el valor más alto. Entonces podemos decir el número más alto. Entonces esto igual a 0. Entonces dentro de nuestro bucle foreach, simplemente
podemos decir
algo como esto. X es menor que el número más alto. Entonces queremos establecer el número
más alto igual. Así como así. Recuerdo que
esto no tiene que ser x. Podemos llamarlo como
queramos. Entonces, por ejemplo, si
quisiera dejar esto claro, podrían decir renombrar
elemento, ¿verdad? Entonces, si el elemento actual en nuestra matriz es menor que
el número más alto, entonces el número más alto es igual
al elemento actual. Y ahora aquí abajo, justo después de nuestro bucle foreach, simplemente
podemos decir algo así
como el número más alto. Y luego antes de eso, sigamos
adelante y pongamos algún texto. Digamos el espacio numérico. Vamos a tirar ahí mismo
otro
operador de inserción. Y cuando código y el, y la razón por la que
imprimió 0, porque esto realmente
necesita decir si el elemento actual es mayor que el
número más alto que queremos establecer, mayor número igual a
el elemento actual. Y ahí vamos. Nuestro número más alto
fue quizás seis. Por lo que dijimos el número
más alto de 96. Entonces solo hay otro
caso de uso para un, para cada bucle. Ahora, volveremos a usar para cada
loops en este curso. Entonces, si no
lo entiendes completamente , no te preocupes por ello. Como dije,
los volveremos a usar en el futuro. Y sigamos adelante y recapitulemos
rápidamente uno adecuado. Y básicamente cómo
interpretar esta línea aquí. Entonces vas a decir para todas las minúsculas y
luego m paréntesis, tengo el tipo de datos de los
elementos de la matriz. Entonces tenemos una
matriz int, así que dijimos int, entonces crearás
un nombre de variable, y esto puede ser lo que
quieras. Entonces acabamos de decir elemento actual, entonces vas
a tener dos puntos. Y luego finalmente el nombre de
tu contenedor, seguido de paréntesis cerrados y corchetes. Lo siento. Básicamente diciendo para cada
elemento de nuestro array, vamos a crear
esta variable. Y esta variable se
va a establecer igual a cada uno de los valores en nuestro
array a medida que vaya atravesando. Y va a
comenzar en el índice 0 e ir
hasta el final. Ahora, en el último video,
si recuerdas, dije a través del para
cada bucle en realidad copia la matriz
para su funcionamiento. Ahora bien, ¿a qué me refería con eso? Bueno, déjame mostrarte. Entonces, si sigo adelante y elimino
este código aquí por un momento, si dijéramos algo así como elemento
actual es igual a diez, y luego aquí arriba
crear un iterador. Entonces, si dijiste que igual a 0, y luego aquí abajo
diremos yo más, más. Y luego imprima nuestra
matriz en el índice i cada vez. Entonces, vamos a crear una
nueva línea después. Y luego seguiremos
adelante y borraremos esta línea de aquí abajo
y ejecutaremos nuestro código. Se puede ver que todo
en nuestra matriz no cambió. Y eso es porque este elemento
actual aquí es solo la copia de los
valores en nuestro array. Y si tuviéramos que
imprimir el elemento actual aquí, en cambio, se puede ver que somos capaces de
establecer eso en diez e imprimirlo. Pero cuando lo teníamos, cómo lo
hacía hace apenas un minuto. Si ejecutamos nuestro código aquí, puedes ver que no imprime diez para cada uno de estos. Y eso es porque el elemento
actual aquí es solo una variable a la que
queremos que sea igual. Cada elemento de nuestra matriz. medida que pasaba, la
primera vez, era igual a
mi índice de matriz 0, luego mi índice de matriz uno. Pero cambiar el elemento actual en realidad
no cambia
el valor en nuestra matriz. Así que esta variable aquí
es solo una copia de cada uno de los elementos enteros en nuestra matriz no es realmente tener ningún efecto sobre los
elementos de nuestra matriz. Entonces ahí lo tienes. Ojalá eso tuviera sentido. Si no, estaremos
trabajando con para cada loops más a
lo largo del curso. De todos modos, eso es todo
para este video. Gracias por mirar, y te
veré en la siguiente.
53. 52: En este video,
vamos a estar
hablando de la palabra clave automática. Entonces, básicamente, lo que
es es que la palabra clave auto es esencialmente solo un
marcador de posición para un tipo, pero no es un tipo en sí, lo que significa que no puedes lanzarle un tipo de datos
diferente. Ahora bien, si estás usando
la palabra clave auto, la variable debe
ser inicializada. Y te voy a mostrar lo que quiero
decir con eso aquí mismo. Entonces, si estaba creando una variable aquí
abajo y en lugar de poner el tipo de datos
directamente, simplemente me senté sobre ellos. Y luego a, así, obtendría un error porque las variables
automáticas necesitan inicializarse. Ahora, permítanme
repasar rápidamente algunas de las cosas útiles sobre el
uso de la palabra clave auto. Y luego
entraremos en algunos ejemplos y veremos dónde y
cuándo puede ser útil. Ahora personalmente,
no soy un gran usuario. La palabra clave auto. Y si vienes de
otro lenguaje de programación, di algo como C-Sharp por ejemplo y es básicamente
algo así como tener la palabra clave var o
algo así. Ahora, una razón por la
que podrías querer usar la palabra clave auto es
por su robustez. Si la expresión es
type ha cambiado, esto incluye cuando un tipo de
retorno de función ha cambiado, seguirá funcionando. Y sé que en realidad no hemos hablado mucho de funciones, pesar de que hemos usado
para conseguir un puñado de ellas. Pero verás a lo que nos referimos
con esto en un próximo video. Después está la actuación. Y lo que quiero decir con
eso es
que tienes garantizado que
no habrá conversión y
obtendrás el tipo correcto
que necesites. Y te lo voy a mostrar
aquí en un minuto. A continuación, tenemos la usabilidad. Y como eso
entra en juego es que no tienes
que preocuparte por escribir el nombre, las dificultades de
ortografía y los errores tipográficos. Entonces, si te metes en nombres de tipo
más largos, y de hecho nos
meteremos en uno de estos en el siguiente video cuando
hablemos de mapas, lo bueno de la palabra clave
auto es que es mucho más corta y estás
menos propenso a errores. A continuación, está la
eficiencia o simplemente escribiendo esto porque
es una palabra tan corta, estás cortando puede ser más
eficiente en ese sentido. Ahora, sigamos adelante
y echemos un vistazo a cómo usar la palabra clave auto. Y como dije,
es esencialmente solo un marcador de posición para un tipo, aunque no es
un tipo en sí. Y como funciona es que
cuando escribes auto, nuestro programa aquí automáticamente
averiguará qué
tipo necesitamos. Entonces, sigamos adelante y
echemos un vistazo a eso con la creación de algunas variables
diferentes. Entonces, si quisiera
crear un entero, solo podría
decir que el
número automático es igual a cinco. Y si paso el mouse sobre esto, puedes ver que creé
una variable entera. Y si convertimos esto
en un flotador como este, se
puede ver que ahora es un flotador. Y si lo convertimos en
algo así, se
puede ver que automáticamente se
convierte en un doble. Entonces como dije,
básicamente puedes usar
esta palabra clave para que automáticamente
averiguara qué tipo necesitas. Déjame seguir adelante y cambiar
esto de nuevo a una tinta rápida. Y en realidad sólo
vamos a llamar a esto directamente. Y aquí abajo,
vamos a decir algo así como número automático, Café es igual a número,
así como así. Y ahora esto automáticamente
copiará este valor en aquí, tal como hemos
visto en el pasado. Y se puede ver que
esos automáticamente una variable entera. Y este es un pequeño
y muy sencillo ejemplo de cuándo esto podría ser
útil. Porque ahora si seguimos adelante
y cambiamos el tipo de datos de número para decir un flotador e
hicimos algo así. Se puede ver que esto
automáticamente se convierte en un flotador. Ni siquiera tuvimos que meternos
con nuestro código aquí abajo. Y luego también,
digamos que queríamos tener algún código para
imprimir una matriz, lo que hemos hecho en el pasado. Así que déjame seguir adelante y
quitar esto rápido. Justo aquí,
diremos int mi matriz. Y entonces los corchetes
dirán algo así como cinco. Así como para
crear una matriz entera de cinco variables. Entonces sigamos adelante y
vayamos a cada uno de estos valores de K. Entonces digamos
algo como esto. Bien, entonces ahora los cinco
tienen un valor inicial. Y recuerda si lo deseas, en realidad
puedes simplemente eliminar
de este número aquí, no, automáticamente averiguar que
queremos cinco valores en lista. Y luego aquí abajo,
podemos imprimir todo en nuestra matriz
usando un para cada bucle, que funcionará automáticamente independientemente de cuántos
elementos haya en nuestra matriz. Podríamos decir algo así como
cuatro x dos puntos mi matriz. Entonces podríamos simplemente decir
C fuera X en la línea. Y después de ejecutar código, como sabemos del pasado, esto va a
seguir adelante e imprimir todo en el arte ¿verdad? Ahora, a pesar de que aquí mismo en una pequeña pieza de código, es muy obvio que estamos trabajando con una matriz entera. Algo que podríamos
hacer es simplemente decir auto, y ahora ni siquiera
tenemos que preocuparnos por ello. Esto automáticamente
va a saber qué tipo de datos hay en nuestra matriz. No tenemos que pensarlo. Si aquí tuviéramos una
pieza de código más grande, no
tenemos que volver atrás y verificar qué
tipo de datos estamos usando. Ya lo sabemos aquí mismo. Queremos poner el
tipo de datos de nuestro contenedor. De todos modos, muchas veces solo decir auto
va a ser más fácil, sobre todo si estamos trabajando con un tipo de datos más complicado, que verás
en el siguiente video. Al hacer algo como esto, este es probablemente uno de mis casos de uso
más favoritos para esta palabra clave. Sólo puedo decir auto, no
tengo que pensarlo. Sé que quiero el tipo de datos
de esto de todos modos. Y si recuerdas
desde aquí arriba, sabemos que no va a
haber ningún tipo de conversión. Simplemente va a obtener el tipo de datos
exacto que necesitamos. Y eso es lo que queríamos
poner aquí de todos modos. Y también,
digamos en el futuro, dependiendo de para qué fue nuestra
matriz aquí, Estábamos como, Sabes qué, no
voy
a poder usar números enteros ya no
voy
a poder usar números enteros
para lo que estoy haciendo. Necesito usar flotadores. Bueno, podríamos simplemente
cambiarlos para que todos estos sean un valor
flotante así. Y puedes poner cualquier
número que no estuvieras aquí, realmente
no va a
hacer ninguna diferencia. Y oye, mira eso. Ni siquiera tengo que meterme
con mi código aquí abajo. Entonces eso es fantástico. Ahora que dicho eso, hay algunas deficiencias
en el uso de auto, y solo quiero que también te den
cuenta de esas. Además, como
dije, no uso
mucho auto personalmente, pero sé que hay
mucha gente ahí fuera que lo hace. Y muchas veces si estás
leyendo el código de otra persona, es muy
probable que los
veas usar la palabra clave auto. E incluso he visto a
algunas personas solo usan auto y ni siquiera
escriben ahí, escriben en absoluto. Esos, solo di auto y úsalo para
prácticamente todo. Ahora, personalmente,
digamos que estamos creando una variable como esta
y x es igual a cinco. Ahora, sé que esto es un entero. lo puedo decir. Soy
una mirada muy rápida. Ni siquiera tengo que
pensarlo, pero si escribo fuera de aquí, bueno,
sí, probablemente pueda
deducir que esto es un número entero al verificar aquí
este número de sondeo. O si tuviera algo
como esto donde
decimos auto El es igual a x, bueno, ni siquiera
sé
qué es b a menos que vaya por aquí y pase el mouse sobre esto solo para averiguar que
esto es un entero porque aquí también
hay un número entero. Y sé que al
principio dije, bueno, oye, si tuviéramos que cambiar esto
de un int a un flotador, entonces no tenemos que
cambiar este tallo aquí. No obstante, ¿y si
tuviéramos un método que requiriera el tipo original? Ahora, vamos
a tener que pasar por y
averiguar qué métodos estaban
todos estropeados por eso. Y ten en cuenta cuál es el
nuevo tipo de datos, etcétera. Y se puede poner bastante desordenado. Entonces, personalmente,
prefiero ver el tipo en la mayoría de los casos, pero siéntete libre de
experimentar con él tú mismo y ver qué
prefieres hacer. No obstante, como dije,
para casos como este, sobre todo cuando se trabaja con tipos de datos
más complicados donde sé
que solo quiero que el tipo de datos exacto de mi
contenedor esté aquí mismo. Bueno, yo también podría
decir auto, es mucho más fácil. Realmente no tengo
que pensarlo. Y si por alguna razón mi tipo de
matriz cambió aquí arriba, y solo estoy
imprimiendo esos valores de todos modos porque no tengo ningún método
específico aquí. Bueno, sólo puedo decir auto. No tengo que pensarlo. No tengo que preocuparme por
cambiar esto más adelante. Esto sólo va a funcionar de todos modos. Eso
es todo para este video. Yo solo quería
hacerte consciente de lo la palabra clave auto y
¿qué es esta bifurcación? Porque sé a ciencia cierta, si te metes en la programación, vas a ver
la palabra clave auto. Si vienes de otro lenguaje de
programación, es muy probable
que hayas visto la palabra clave var y nos preguntamos si C Plus
Plus tenía algo similar. Entonces ahí tienes. Entonces ojalá tengas una
buena comprensión de
cómo usar la palabra clave auto y para
qué sirve básicamente, solo la arrojas en
nuestro programa aquí para averiguar qué
tipo de datos necesitamos por sí solo. Y no quieres tener que
decirlo explícitamente. Pero si quieres que
tu tipo de datos sea escrito explícitamente, bueno, entonces solo vas a necesitar ponerlo
ahí tú mismo. De todos modos. Gracias por mirar, y te
veré en la siguiente.
54. 53: En este video,
vamos a estar hablando otro contenedor
llamado los mapas. Ahora, los mapas y C plus son un tipo de contenedor
que almacena elementos y moda sin mapear
donde se tiene una clave así como un valor mapeado. Ahora el valor de clave generalmente
se usa para ordenar e identificar de manera única los elementos en su
contenedor mientras que el valor mapeado almacena el contenido asociado a esta clave. Ahora, en lugar de confundirte
con un montón de mapas, vamos a seguir adelante y
crear uno nosotros mismos. Y antes de hacerlo, vas
a querer seguir adelante y agregar en este archivo de encabezado siendo solo mapa. Así que sigamos adelante
y comencemos. Ahora la sintaxis para un
mapa es la siguiente. Primero vas a decir mapa, todo minúscula, el símbolo
menos que, seguido de un tipo de datos que va a
ser para tu clave. Así que así, entonces vas a tener
una coma
seguida de tu tipo de datos de mapa. Entonces cuando el símbolo mayor que, y después de eso
vas a tener el nombre del mapa
seguido de un punto y coma. Entonces como puedes verlo como
muy similar a crear un vector o una cola o una pila. Sin embargo, en lugar de
tener solo un tipo de datos, ahora
tenemos que recordar que su tipo de datos clave suele ser
ordenar e
identificar de manera única cualquiera que sea su tipo de datos
mapeado en estos tipos de datos pueden
ser diferente por cierto. Para que no tengas que
almacenarlo, solo termina. Podrías almacenarlo en y una cuerda o esencialmente
lo que quieras allí. Así que sigamos adelante
y creamos un mapa. Y vamos a seguir
adelante y basar esto en la
guía telefónica en nuestro caso, solo porque todos saben
lo que es una guía telefónica. Entonces, ojalá sea más fácil
entender de esa manera. Entonces aquí abajo, vamos a decir mapa y luego el símbolo
menos que. Y luego vamos a identificar de manera única
a cada uno de la guía
telefónica por su nombre. Entonces sigamos adelante
y solo digamos cadena, igual que esa coma. Y entonces el número de todos
se almacenará como un número entero. Entonces diremos int. Llamaremos a esta guía telefónica. Así como así. Entonces
aquí mismo tenemos nuestro mapa vacío. Y luego aquí abajo
seguiremos adelante y agregaremos algunos elementos a nuestro mapa. Bien, así que sigamos adelante y agreguemos algunos elementos a nuestro mapa. Y para ello,
sólo vamos a decir el nombre de nuestra guía telefónica de mapas. Entonces vamos a usar el modificador de acceso de
miembros. Entonces vamos a decir punto ahí, insertar todas las minúsculas por cierto. Y luego entre paréntesis
vamos a poner el tipo ahora porque nuestro mapa contiene dos tipos de datos
diferentes como lo Hace que estén conectados. Esto en realidad se llama pagador. Entonces un padre y C
plus es esencialmente solo un contenedor que
almacena dos valores. Y estos valores pueden o
no ser del mismo tipo de datos, justo aquí, vamos
a decir inserción de puntos de agenda telefónica. Y luego después de eso, vamos a decir pelo,
todo en minúsculas aquí. Y luego un símbolo menos que seguido de los mismos
tipos de datos de nuestro mapa. Entonces, si quisieras,
en realidad podrías simplemente copiarlos
y pegarlos. Pero vamos
a sacar esto, solo tratando de practicar
aquí, así como así. Y luego entre paréntesis, necesitamos poner en los valores
que queremos insertar en la cadena y la cadena. Vamos a poner un nombre aquí,
algo así como Jack coma, y luego el valor entero. Y podemos simplemente echar cualquier
número de diez dígitos que queramos representar su número de teléfono. Entonces solo pondremos punto y
coma al final, y sigamos adelante y
sumamos algunos números más. Y en lugar de escribir
todo esto otra vez, solo
voy a seguir adelante y copiar
y pegar eso unas cuantas veces. Después
pasaremos por cada uno de estos ocho nombres clave diferentes. Y vas a
querer que este primer valor aquí sea único para todos. Entonces no querrías
poner el nombre de Jack y múltiples alelos. Y si en realidad estás
haciendo una guía telefónica, querrías tener
un apellido, por ejemplo, pero ya que solo estamos trabajando con algo
pequeño como aquí, todos
entendéis el punto. Entonces diremos Jack, John, Pam, y algo así. Y voy a dar a cada uno de estos
ocho números diferentes. Y siéntete libre de tirar los números que
quieras
en lugar de
tener que copiar lo que
tengo aquí exactamente
ya que no va a hacer ninguna diferencia
para nuestro ejemplo. Ahora bien, ¿y si queremos seguir
adelante e imprimir mapa? Bueno, podríamos hacerlo
usando a para cada bucle. Entonces si vamos a decir
y luego podemos decir par, seguido por el
símbolo menos que y luego tensar. Y el símbolo mayor que. Y luego después de eso, diremos persona,
espacio, espacio de dos puntos, nuestro nombre de mapa, había una guía telefónica y luego un corchete
abierto y cerrado, así. Y luego podemos seguir adelante
e imprimir cada uno, y te mostraré
cómo hacemos esto. Entonces vamos a decir CO, seguido de persona,
porque esa es la variable que estamos usando para acceder a cada una de estas. Vamos a decir dieta. Y luego notar que se le ocurre una primera y una segunda. El primero como este primer valor es nuestra cadena, así
que ese será su nombre. Y entonces el segundo
sería el valor entero, o en este caso,
el número de todos. Entonces vamos a decir persona punto primero, y luego después de eso, vamos a
poner en un espacio así. Y luego diremos
persona esa segunda, seguida de la línea N,
así como así. Y si ejecutamos nuestro código aquí, puedes ver que todos nuestros números están
realmente estropeados. Ahora, ¿por qué es eso? Bueno, como mencioné antes, un entero solo puede contener
un cierto rango y luego eventualmente un envoltorio
y seguir adelante. Ya hemos hablado de esto
en un video pasado ahí. Entonces, ¿cómo podemos arreglar esto? Bueno, este es un gran
ejemplo de cuándo
querrás buscar un tipo de
datos diferente que se adapte a tus necesidades y los
errores que podrían surgir si tu tipo de datos
es demasiado corto para ello, el valor que eres
tratando de mantener, en cuyo caso aquí, mi valor más alto
que estoy tratando de
mantener su más de 8 mil millones. Y si paso el ratón sobre él, se
puede ver que asume que
ese valor es un pulmón. Pulmón. Y como
no vamos a darle a nadie un valor negativo de número de
teléfono, también
podríamos hacer que
esta variable no esté firmada. Entonces, para arreglar esto aquí arriba, vamos a decir sin firmar, largo, largo, así como así. Y vamos
a copiar y pegar esto abajo para cada uno de ellos. Así, asegúrate de copiar esto para cada elemento
que agregamos, así
como una R para cada bucle. Así que ahora hemos creado un mapa la cadena de todo el día
y una larga,
larga sin signo , que puede contener un número entero positivo muy
grande. Y a esto le llamamos agenda de mapas. Luego insertamos
múltiples elementos
diciendo el nombre de nuestro mapa seguido de este método de inserción. Y entonces nuestro tipo de datos aquí
era un par que como dije, son dos tipos de valores diferentes, o puede contener dos tipos de valores
diferentes. Debería decir, como podríamos haber
formado ambos, una cadena o un int o
lo que queramos ahí. Pero en este caso establecemos una
cadena y una larga sin firmar, larga para representar una guía telefónica. Entonces aquí abajo, acabamos de crear un simple bucle foreach donde
dijimos por cada par de una
cadena y sin firmar largo, largo en nuestra guía telefónica o un
contenedor aquí siendo un mapa. En este caso, queremos
crear una variable llamada person y establecerla igual a cada elemento a medida
que recorremos. Así que somos capaces de
imprimir punto persona primero, que será nuestro primer
valor aquí y nuestro par, luego tiramos en
un espacio y luego también imprimimos persona en segundo lugar, que es nuestro segundo valor aquí, seguido de la creación de una nueva línea. Y si volvemos a ejecutar nuestro código, puedes ver que esto
ahora funciona bien. Y nuestros números son los que
escribimos aquí arriba porque
un largo,
largo sin firmar es capaz de mantener un valor
tan grande. Ahora bien, fíjate como este tipo de datos
ocupa mucho espacio, y francamente,
se ve un poco feo. Bueno, hay una manera
fácil de arreglar esto usando la palabra clave auto de la que acabamos hablar en el último video. Podemos simplemente decir auto, y ahora no necesitamos poner
todas esas cosas extra. Y si ejecutamos nuestro código, puedes ver que funciona
bien sin ningún problema. Como palabra clave automática
descubrió automáticamente el tipo de
datos exacto que necesitábamos. Entonces, ¿qué tan grande es eso? Y se ve mucho
más limpio que esto, en mi opinión. No obstante, puedes
hacerlo de cualquier manera. No obstante, sólo para
mostrarte algo, no
podemos poner auto aquí arriba
ya que esto no va a funcionar. Entonces, aquí tienes un ejemplo de cuándo
no puedes usar la palabra clave auto. Y en cambio tenemos que poner el valor directamente.
Entonces ahí lo tienes. Hay una forma básica de crear
un mapa, agregar elementos y usar un para cada bucle con un mapa para imprimir
los valores dentro de él. Ahora, antes de que
terminemos este video, solo
voy a mostrarte
un par de métodos adicionales, pero puedes usar con
tu contenedor de mapas. Pero como siempre,
hay un montón más. Así que siéntete libre de
buscarlos si decides usar un mapa en
uno de tus programas. Entonces el primero que
vamos a ver es cómo
eliminar un elemento de nuestro mapa. Pero antes de hacer eso, sólo
voy a añadir aquí
un comentario extra. Mapa de manivela. Y luego aquí mismo,
vamos a eliminar la columna de cantidad. Tan rápido, si
recuerdas al
principio del video, dije que un mapa está trazado
algo así como un mapa real. Vamos a tener valores clave
y luego valores mapeados en esta clave aquí no es solo para ordenar los elementos
dentro de su contenedor, sino también para ubicar elementos
dentro de su contenedor. Entonces aquí abajo, si queremos eliminar un
elemento en nuestro contenedor, simplemente
necesitamos conocer
esa clave del elemento. Y déjame seguir adelante y
mostrarte cómo se hace eso. Entonces aquí mismo, vamos
a decir agenda siendo el nombre de nuestro mapa, borrado de puntos. Y luego entre paréntesis, simplemente
vamos
a poner el valor clave del elemento
que queremos eliminar. Entonces digamos que John,
por la razón que sea, se mudó fuera de la ciudad
y ya no
necesitamos su número en
nuestra guía telefónica. Bueno, podemos simplemente poner John entre
comillas porque estamos trabajando con una cadena y
poner punto y coma al final. Ahora, cuando ejecutemos nuestro código, John ya no será
parte de nuestra guía telefónica. Entonces ahí mismo, así es como
eliminas elementos de a. y déjame seguir adelante y mostrarte algo más sobre
este método también. Entonces si seguimos adelante y copiamos esta línea aquí donde
insertamos a John y/o
guía telefónica y pegamos así
y le damos a
ésta un color diferente. Así. Y ejecuta nuestro código. Se puede notar que ni John existe, y eso es porque esto en realidad
eliminará cada elemento con esa clave. Hay otro ejemplo de por qué quieres asegurarte de que cada elemento en
tu contenedor de mapas tenga un valor clave diferente. Ahora, sigamos adelante
y echemos un vistazo a un último método que
podemos usar con los mapas aquí. Ahora bien, este es solo el último
que te voy a mostrar,
recuerdas que hay muchos más por ahí si te interesa. Entonces con este que
aquí vamos a hacer es permitirnos imprimir el número de teléfono de la persona
que estamos buscando. Otro gran ejemplo
de por qué quieres
darle a todos una clave específica. Y en realidad voy
a seguir adelante y eliminar este John extra que agregamos
a nuestra guía telefónica aquí. Entonces aquí abajo, vamos
a decir elemento basado en. Entonces abajo, todo lo que tenemos que
hacer como guía telefónica de CEO. Y luego entre paréntesis puso su valor clave dentro
de las comillas aquí, porque estamos trabajando con
cadenas para nuestro valor clave, puedo decir, Oye, vamos a conseguir el número de Tams,
así como así. E
imprimiremos el número de Pam. Y en realidad voy a seguir
adelante y comentar nuestro bucle foreach
solo para que no esté ocupando espacio cuando
ejecutemos nuestro programa. Y si ejecuto nuestro código,
oye, ahí vamos. Ahí está el
número de chulos. Entonces ahí tienes. Ojalá ahora tenga una comprensión básica de
cómo funcionan los contenedores de mapas en C plus plus y tiene una comprensión básica de
su funcionalidad. ¿Deberías querer usarlo en
un futuro programa tuyo? De todos modos, espero que hayas
disfrutado del video. Gracias por mirar, y te
veré en la siguiente.
55. Capítulo 10: Iteradores: En este video, te
voy a estar dando una
introducción muy básica o muy breve a los iteradores. Y honestamente,
ni siquiera iba a lanzar esto en C plus plus para curso de
principiantes, pero lo veo tan a menudo
que simplemente
decidí, solo voy a
tirarlo ahí. Así que al menos
ustedes saben lo que es cuando se encuentran con él. No obstante, en el ejemplo
que voy a dar no es realmente el mejor caso de
uso para ello. Pero como dije, sí lo
veo todo el tiempo. Así que solo quiero asegurarme de que ustedes no estén completamente
desprevenidos cuando lo vean muy temprano
cuando se metan en hacer sus propios programas y mirar código
de
otras personas como referencia. Entonces comencemos. Entonces, antes que nada, ¿qué
es un iterador? Un iterador es un objeto utilizado para iterar sobre elementos
en un contenedor. De todos modos, existe la
idea básica de lo que es un iterador. Es como dije, es
solo un uso adjetivo para iterar sobre elementos
en un contenedor, que es algo que
hemos hecho en el pasado. Pero ahora
te voy a mostrar cómo hacer esto usando un objeto iterador real. Y también
te voy a mostrar cómo podemos hacer lo mismo usando
un para cada bucle, como lo hemos hecho en el pasado, solo para que veas las
comparaciones entre ellos. Y como dije,
este realmente no es el mejor caso de uso para esto. Y normalmente solo
usaría un bucle for-each. Y verás a lo que me
refiero aquí en un momento. Entonces antes que nada, vamos a seguir
adelante y crear un vector. Voy a escribir así. Y luego simplemente
llamaremos a estos números y lo pondremos iguales
a los siguientes. Entonces, entre corchetes aquí, solo sigue adelante e inserta
cualquier vista de cinco números. Sólo voy a decir
12345 por el bien de la simplicidad. Y en realidad hemos
echado un vistazo a cómo
iterar a través de esto con un
par de métodos diferentes. Entonces, si recuerdas,
hicimos esto con un bucle for, y lo hemos hecho
con un para cada bucle. Ahora bien, para hacer esto con un para
cada bucle, si recuerdas, era simplemente decir algo
así como número de puerto, números de
dos puntos como así. Y entonces un bloque de código enter era un número de
impresión así. Y esto va a funcionar bien. Esto imprimirá todo
en nuestro vector de números. Pero, ¿cómo hacemos esto
con un iterador? Bueno, primero,
vamos a seguir adelante y declarar un iterador. Y para ello, vamos a reescribir en el tipo contenedor, que es un vector de tipo
int seguido de dos puntos. Y entonces vamos a decir iterador en todas
minúsculas así. Y luego después de esto
necesitamos un nombre y una convención de nomenclatura común. Nombre muy común si borras o un iterador
simplemente va a ser IT. Y esto por sí solo es una
declaración para nuestro iterador. Así que voy a sacar
eso y simplemente llamar a esta declaración de iterador
para nuestros números así. Y solo estoy haciendo
esto como referencia. Entonces ustedes no tienen que copiar esta parte si no quieren. Y dejadme acercar
aquí para ustedes. Pero por debajo de este emigrar
e inicialización para ello. Así iteró
la inicialización, así. Podemos declararlo e
inicializarlo en la misma línea. Entonces digamos
inicialización de iterador en declaración para nuestro vector de
números. Y lo que haríamos para hacer
eso es decir tipo contenedor, seguido de los dos
Colin que iterador, el nombre una vez más. Y luego seguiríamos
eso con donde queremos que comience nuestro iterador. Esencialmente, la forma en
que lo haríamos en este caso
es decir el nombre. Estamos contenedor
siendo números, murió. Otra vez. Ahora, esa es la sintaxis básica para declarar e inicializar
un iterador. Sintaxis del iterador. Recuerda que la sintaxis es básicamente solo la
regla para algo, esencialmente va
a ser el contenedor. Y entonces vas a
tener que hacerlo, Colin es así. Voy a decir iterador, seguido del nombre del iterador. Yo sólo voy a elegir aquí. Y luego si
quieres inicializarlo, vas a decir
iguales seguido del nombre del contenedor real punto. Y entonces si quieres
fijarlo al primer valor, al
menos podrías
decir que empezó. No obstante, existen
otros métodos, por lo que no es necesario iniciarlo desde el primer elemento
del contenedor. De todos modos, voy
a comentar este también. Y sólo vamos a
comenzar con la declaración. Así que aquí abajo,
sólo vamos a decir vector en el iterador de Colin, TI y habrá que poner un
punto y coma al final ahí. Bien, entonces ahí vamos. Hemos declarado nuestro iterador. Ahora, sigamos adelante
y creamos un for-loop. Emoción, nuestro vector aquí arriba. Y en realidad solo voy a copiar este código y moverlo
aquí abajo para que podamos mantenernos al día
en la pantalla aquí para ustedes chicos. Y voy a quitar esta
de aquí arriba. Y podría
comentarlo solo para que no
tengamos eso que realmente se muestre
en la consola ahí. Y crearemos un bucle for
para trabajar con nuestro vector. Entonces vamos a decir cuatro. Y luego dentro de aquí, simplemente
vamos a inicializar nuestro iterador que ya creamos. Voy a decir TI
es igual a números dieta. Otra vez. Como dije, esto va
a poner nuestro iterador
al valor inicial
del vector R siendo uno. Y luego después de eso
por una condición, vamos a decir
esencialmente mientras TI, así que comience
abordando TI aquí. Ser nuestro iterador no
es igual a. Números y real rápido e
iterador en realidad solo apunta a la ubicación en memoria de los elementos
en nuestro contenedor, lo que tal vez un poco confuso. Y nos meteremos en eso un
poco más cuando
hablemos de punteros
en el futuro. Pero por ahora, solo sé que básicamente
apunta a que la ubicación en la
memoria no es lo
mismo que nuestro elemento real. ¿Bien? Entonces básicamente diciendo que queremos crear un iterador que comience en el
primer valor aquí. Y entonces mientras nuestro
iterador no es igual
al último elemento o no está
apuntando al último elemento. Podría decir que queremos
ejecutar nuestro código. Ahora después de esto,
simplemente podemos decir IT
plus, más el nombre de un
generador plus, plus. Y esto va a funcionar bien. Ahora bien, este fin del
método aquí no es en realidad el último valor
en nuestro contenedor. En realidad es esencialmente
el valor después de eso, si existiera como
podríamos mirarlo. Entonces básicamente lo
que no estamos apuntando a un valor que no existe. Por lo que va a comenzar en esta. Aquí vamos, 2345. Y entonces una vez que está apuntando
al sexto elemento imaginario, entonces sería
igual a este fin. Bueno, no es igual a eso. Queremos seguir
ejecutando nuestro código. Entonces ojalá eso tenga sentido. Básicamente si aquí no hubiera un sexto elemento
imaginario, esto es a lo que se refiere esto
aquí. Entonces lo que estamos señalando, todo lo que está
en nuestro contenedor y queremos hacer lo siguiente
e iterar a través de él. Entonces vamos a tener corchetes abiertos
y cercanos. Y luego dentro de aquí, simplemente
vamos a imprimir
ahora creo uno nuevo. Ahora bien, observe que tenemos este error y eso es porque
en realidad necesitamos poner un símbolo de asterisco
antes de decir i t aquí. Ahora bien, ¿por qué tenemos
este asterisco? Y de hecho nos meteremos un poco más en esto cuando
hablemos de punteros. Pero esencialmente, recuerda
cómo dije que un iterador está apuntando a la ubicación en la
memoria donde está este elemento. Bueno, este asterisco
nos permite desreferenciar ese puntero. Entonces, en lugar de devolvernos
la ubicación y la memoria, recuperaremos el valor real. Entonces ojalá eso tuviera sentido. Si no,
hablaremos de más cuando nos
metamos en punteros más adelante
en el curso. Pero solo sé por ahora, ponemos esto aquí para que obtengamos el valor real y no la dirección de ubicación de la
memoria. Entonces, si ejecutamos nuestro código
aquí, y como pueden ver, lo
imprimimos 12345 en líneas
separadas ahí. Y si te estás preguntando
cómo acerqué el zoom en la consola o en
Visual Studio aquí, realidad
puedes
mantener presionado Control y usar la rueda de desplazamiento
para acercar y alejar. Sin embargo, en la
ventana de la consola aquí en realidad solo aumenta y disminuye el tamaño de la ventana en su conjunto, lo que supongo que reanuda
estás de manera rotonda. Pero de todos modos, imprimimos
12345 en líneas separadas. Ahora, como dije, en el caso concreto, yo personalmente
nunca haría esto. Y muchas veces
incluso lo verás escrito donde la declaración e inicialización
está en la misma línea. Entonces si copiamos y
pegamos eso aquí abajo, y no queremos
poner el nombre dos veces. Así que así y
quítate los de aquí. Esto va a funcionar bien. Y muchas veces
así es como lo
verás hecho como con
la declaración del iterador y la
inicialización del en la misma línea exacta. Así es como voy
a seguir adelante y ahora, como dije, en este caso, probablemente nunca
querrías
hacer esto porque esto para cada bucle que
tenemos aquí, funciona mucho mejor. Se ve mucho más limpio. Pero como mencioné al
principio del video, sí
veo esto todo el tiempo. Así que solo quería asegurarme que ustedes sepan lo que
está pasando aquí. Así que básicamente, en nuestro bucle for, estamos creando un iterador poniendo aquí el tipo
contenedor, seguido de dos puntos,
y luego el iterador de palabras clave, luego el nombre de su iterador, que a menudo verás como TI. Pero puedes poner lo que
quieras seguido del operador de asignación
para inicializarlo. Después ponemos el nombre real del
contenedor y le damos un lugar para comenzar. Porque como dije, un iterador apunta a la ubicación en memoria donde un elemento
está en un contenedor. Entonces básicamente estamos diciendo, Oye, solo empieza con el
primer elemento. Entonces dijimos, mientras que
nuestro iterador
esencialmente no está apuntando
al elemento posterior al último. Entonces este es nuestro último elemento. Si estuviera apuntando a un seis elemento
imaginario, Eso es a lo que se
compra este número y sería igual a. Bueno, no estamos
apuntando a eso. Queremos seguir adelante y
aumentar iterado por uno, lo que nos hará avanzar
a lo largo de nuestros elementos aquí. Entonces queremos
imprimir el valor real al que apunta
nuestro iterador y en una nueva línea cada vez. Y hemos trabajado con bucles
for, así sucesivamente. Entonces debes
entender lo básico. Básicamente, somos capaces de declarar e inicializar una variable aquí. Tenemos una condición aquí, y
luego nuestra actualización de variables, que es donde actualizamos
nuestro iterador en este caso. Ahora bien, aunque este ejemplo
no es genial y ese es un uso muy básico de un iterador, ya que hay muchos
otros métodos que puedes usar con él para hacer cosas
diferentes. Hay casos de uso reales que querría
usar un iterador. Y eso se debe a que no
todos los contenedores guardan sus datos de manera continua
donde todo está en orden y solo podrías
usar un bucle básico de cuatro. Y a veces
puede ser necesario un iterador. Si está trabajando con
un tipo diferente de contenedor que
no lo almacena en
valores en un orden secuencial, como lo hace un vector o una matriz. Un iterador puede ser
algo que necesitarás usar y buscar un poco más. Pero esa es una
visión general básica de una, así
como un
ejemplo básico de cómo crear y usar
uno como ejemplo, puede
que veas con bastante frecuencia si empiezas a mirar el código de
otras personas, especialmente de todos modos, eso es
básicamente todo para este video. Solo quiero
asegurarme de que supieras lo era
un iterador y tuvieras
una comprensión básica de cómo podría ser usar uno para que
no estés completamente
desprevenido cuando se te presente. De todos modos, gracias por mirar. Espero que hayas disfrutado el
video y como siempre, te
veré en el siguiente.
56. Capítulo 11 (Enums): introducción a los Enums: En este video, vamos a
estar hablando de enumeraciones. Y sólo voy
a estar dando una breve introducción
en este video. Y luego en los
próximos tres videos, en realidad
vamos
a estar creando y trabajando con ellos. Ahora, normalmente al aprender
un lenguaje de programación, vas a aprender
bastante temprano. Sin embargo, he decidido
detenerlos hasta este
momento porque por un lado, no
me pareció realmente
necesario echarlos demasiado pronto
al campo. Y los encontré un poco confusos cuando estaba
aprendiendo programación por primera vez. Así que pensé en
dejarles entender
el lenguaje básico antes de que los
pusiéramos ahí. Pero los verás muy
a menudo. Ellos sí vienen muy bien. Entonces, sigamos adelante y
adentrémonos en lo que es exactamente una enumeración. Una enumeración, abreviatura de
un tipo enumerado en realidad
va a ser nuestro
primer tipo de datos definido por el usuario. Y verás a lo que
me refiero con eso en el siguiente video cuando sigamos
adelante y realmente creamos uno. Y lo que es una enumeración, es básicamente un grupo
conjunto de valores constantes que tienen un nombre
asociado a ellos que
puedes usar en tu código. Bien, así es el tipo de datos
definido por el usuario. Y lo que es es un grupo de constantes con un valor
integral. ¿Bien? Entonces eso significa que va
a sacar los números enteros, o un número entero, debería decir, con un
nombre asociado a él. Y debido a que estas constantes
tienen un nombre asociado a
ella, hace que tu código sea
mucho más legible, que es más o menos el caso de uso
principal para ello. Y podrás
ver un ejemplo de esto en uno de los
próximos videos aquí. Ahora, sé que en realidad no
hemos
hablado de constantes en bastante tiempo. Yo solo te voy a dar un
breve repaso aquí también. Entonces, ¿qué es una constante? Bueno, es sólo una variable
que no se puede cambiar. Entonces, si recuerdas
crear una, vas a decir
constante y luego
solo vas a crear
una variable como normal. Entonces podríamos decir número constante
y fijarlo igual a cinco. Ahora algo de lo que no
hablé la última vez que
hablamos de constantes fue que
al nombrar una constante, muchas veces
verás a la gente y le darás un nombre en mayúsculas como este para algún prefijo especial para significar que se
trata de una constante. Entonces si más adelante en mi código, traté de decir
números por ejemplo, y veo, oh oye, es un all caps o
veo un prefijo específico. Sé que esta es una variable
constante. No quise que esto
se cambiara nunca, ¿verdad? Porque
no se puede cambiar la constante. Y si intentó
cambiarlo, obtendrá un error. Entonces eso es solo algo de lo
que hay que tener en cuenta. Que muchas veces
verás unos efectos específicos o todos los caps en el nombre como solo
una convención básica de nomenclatura. Entonces esa, ya sabes, oye, esa
es una variable constante, no solo mi
variable promedio normal que puedo cambiar. Bueno, de todos modos, eso
es todo para este video. Entonces lo principal que
quiero que le
quites a esto es que un ENM como un tipo de datos definido por el usuario
y el es un grupo de constantes con un valor integral con un nombre asociado al mismo. Ahora bien, cuando digo con un
nombre asociado a ello, me refiero a cada valor integral
constante, no solo a la enumeración misma. Y podrás ver un ejemplo de eso y uno
de los próximos videos. Como siempre, gracias por mirar, y te veré
en la siguiente.
57. Capítulo 11 (Enums): cómo crear un enum: Hola a todos. En este video, en
realidad vamos a seguir adelante y crear nuestro primero. Ahora, hay dos tipos
diferentes de enumeraciones que puedes crear. Pero en este video, solo
vamos a estar trabajando
con el tipo más básico. Y luego en un futuro video, te
estaré mostrando el otro
tipo que puedes crear. Y en realidad no es
mucho más complicado. Y repasaremos las
diferencias y luego también. Entonces, ¿cómo creamos una enumeración? La sintaxis para una enumeración y, o un
tipo enumerado es la siguiente. Primero vas a decir Ina, luego vas a darle
seguimiento con el nombre de tus ingresos. Y luego entre llaves aquí, vas a tener cada valor que quieras asociado
con tu ENM. Y aquí en realidad vas a
poner un nombre de cadena y luego va a tener una
constante asociada a ella. Ahora bien, esto equivale a 0 no es necesario a la hora de
crear un anime. Yo solo pongo esto aquí
para mostrarte la constante que se asoció
con esos primeros valores. Y luego después de eso, éste
va a tener uno asociado a él y
éste tendrá un dos. Y sólo voy
a seguir subiendo en orden por tantos valores como tengamos. Y te voy a mostrar lo que quiero
decir con eso en un segundo. Si estás un poco confundido ahí. Entonces aquí abajo, escucho, impuesto para ellos otra vez, pero también incluí el valor constante
asociado a cada uno. E incluso podemos crear
variables de nuestra enumeración, ya que es un tipo
definido por simplemente diciendo nuestro nombre EM
seguido de un nombre de nuestra variable y
configurándolo igual a uno de los valores que tenemos
asociados con nuestra enumeración. También, recuerden cómo
dije que una enumeración es un grupo de valores
integrales constantes. Cada uno tiene un nombre
asociado a ellos. Bueno, si recuerdas, a
las constantes también se les debe dar un valor inicial justo
al principio. Así podremos crear una enumeración y luego inicializar los valores posteriormente. Tenemos que hacerlo enseguida. Entonces, sigamos adelante y echemos un vistazo a cómo
crear uno nosotros mismos. Entonces aquí abajo,
vamos a decir, y luego sólo vamos a
llamar a éste, por ejemplo. Y muchas veces es posible que veas que tipos
definidos por el usuario comienzan
con una letra mayúscula. Así que vamos a
seguir adelante y hacer eso por nuestro nombre aquí también. Y luego entre llaves. Y solo recuerden cuando les hago saber diferentes convenciones de
nomenclatura, solo
querrán usar
cualquiera que sea la compañía o lo que
sea para la que utilice la mayoría
de las personas con las que está trabajando. Si solo estás trabajando solo, entonces siéntete libre de darle
tu propio giro a las cosas. Pero de todos modos, así que le damos crédito cualquiera de ellos diciendo Ina,
gracias dándole un nombre. Y luego entre llaves,
vamos a poner en algunos valores
asociados a nuestra enumeración aquí. En lugar de poner
números reales, sólo
vamos a ponerle
nombres de fruta en nuestro caso. Entonces podríamos decir
algo como manzana, plátano, coma naranja,
así como así. Y ahí tienes.
Ahora hemos creado una enumeración llamada a través con tres valores
diferentes en ella. Y si recuerdas, dije
que cada uno en realidad tiene
asociado un valor constante,
que por defecto es un entero. Entonces, si paso el mouse sobre esto aquí, puede ver que Apple está
asociada con el número 0, plátano asociado a uno, naranja a etcétera. Y eso va a seguir adelante. Y después vamos. No han sido
otro y llaman a esta uva y L1
automáticamente se le asignará tres. También puedes darles tu propio valor a
estos. Entonces podría decir que Apple
va a ser igual a cinco, por ejemplo, entonces en realidad
solo contará a partir de ahí si no cambio
ninguno de los demás. Entonces, cualquier cosa que no
tenga su propio valor
definido solo subirá en uno desde
el último valor definido por el usuario. Entonces Apple será cinco ahora, plátano, naranja,
siete, uvas, ocho. E incluso podría decir que el
plátano ahora equivaldrá a diez. Y entonces sólo va a subir de ahí con naranja siendo 11. Y alguien. Ahora una
cosa a tener en cuenta es que si
dijera plátano igual a cuatro, por ejemplo, porque la
naranja seguirá siendo igual a cinco y ahí no va a
haber ningún tema. Pueden tener los mismos
números asociados a ellos, pero solo algo que
quiero que seas. Bien, para que puedas ir
a estos cada año valor y cada uno que
no tenga un valor, simplemente
empezaremos a contar hacia arriba desde el último valor
definido por el usuario. Solo recuerda que las matrices
y otros contenedores, todos
estos comenzarán en 0. Bien, así que esa es la forma
básica de crear una enumeración. Y una cosa más que sí quiero mostrarte es que si recuerdas, te
dije que estos naturalmente
van a ser valores enteros, pero en realidad podemos cambiar
eso si no quisiéramos, cada de estos para
ser una constante y recordar que sí necesita
ser un valor integral. Entonces no vamos
a poder cambiar esto a algo así como un
flotador o un doble, pero no podemos cambiar el valor
integral al que estos están
asociados. Entonces hagámoslo. Después de nuestro nombre enum, vamos a poner dos puntos
seguidos del tipo de datos que no
nos otorgaron. Tiene que ser una
integral de tu tipo de datos. Entonces podríamos
decir explícitamente int si quisiéramos, o podríamos decir algo como unsigned si
quisiéramos también, o podríamos cambiar
el tipo por completo. Entonces podemos decir char por ejemplo. Y esto va a funcionar bien. Ahora es que todos estos tienen un valor gráfico
asociado a ellos, pero no tienes que hacer eso. Simplemente puedes dejarlo como está, y naturalmente,
por defecto serán un entero. De todos modos, eso es todo para este
video y el siguiente video, en realidad
estaremos creando un programa básico con y
sin ningún num para que
puedas ver ese verdadero
caso de uso para uno y cómo
usar realmente uno en código. Así que estén atentos para
eso como siempre, gracias por mirar y te
veré en la siguiente.
58. Capítulo 11 (Enums): cómo usar los Enums: En este video, estaremos creando un programa básico tanto de
ancho como sin enumeraciones, para que puedas ver el
verdadero caso de uso para ellos. En el caso de uso básico para E&M es esencialmente hacer que tu código más legible y organizado. Así que comencemos. Entonces el programa que
vamos a estar creando en este video va
a pedirle al usuario elija una fruta de una
lista de varias opciones que una vez que el
usuario hizo una elección, solo
vamos a significar una confirmación de su
decisión de vuelta a ellos. Así que sigamos adelante
y comencemos. Entonces, antes que nada,
vamos a comenzar por crear una lista de enteros nombre de diferentes frutos y darle a cada uno de estos
un valor constante. Entonces voy a decir
const apple es igual a 0. Nina era una. Naranja equivale a dos. Y sólo haremos una más. Digamos
par constante es igual a tres. Entonces abajo aquí, vamos a seguir
adelante e imprimir la lista de opciones al usuario. Entonces voy a decir C fuera. Por favor, elija en
las opciones de la lista. Entonces crearemos un entero juntos las entradas así que si
pueden y luego soplar
eso dirá cn. Así. Ahora vamos a
crear un interruptor que relacionará su
elección de nuevo con ellos. Y si recuerdas cómo
crear un switch, vamos a decir switch
y luego terminar paréntesis. Pondremos la variable
que estamos comprobando. Entonces vamos a decir switch input, y luego vamos a
decir gustos 0 dos puntos. Y luego vamos a decir C fuera. Y luego cerrar con
una u, muestra una manzana. Así como esto. Y luego
diremos línea M. Y luego conseguimos una playera nueva que también ponemos en nuestra
declaración de descanso. Ahora, vamos a seguir adelante y copiar y pegar esas cuatro veces. Muy bien, y luego aquí abajo, cuando pongo este
igual a uno, este es uno de los dos y este 123 como para que coincida con los valores
asociados a nuestros enteros, entonces solo tenemos que cambiar el texto dentro de
cada caso aquí. Entonces para el caso uno
dirá que elegiste un plátano. Entonces aquí abajo, K es dos. Digamos que elegiste una naranja. Y por último
dirá que elegiste un par. Y luego aquí arriba,
todavía tenemos que darle al usuario una lista de opciones. Entonces diremos C out y
luego las citas dirán una. Manzana. Entonces
crearemos una línea así. Copia y pega esto
algunas veces aquí. Nina, naranja y pera. Y en realidad lo hicimos, este primer 120123. Y antes de ejecutar nuestro código, en realidad
queremos crear
una nueva línea, a la derecha aparecen. Ahora, si ejecutamos nuestro código, podemos ver que
dijimos Por favor haga una fruta basada en la
lista de opciones a continuación, tenemos manzana, plátano,
naranja un par. Y si escribimos un
dos, por ejemplo, digamos que elegiste una naranja, y ahí vamos, nuestro código está funcionando. Ahora cuando se trata
de esto aquí abajo, especialmente si estás trabajando
con un programa mucho más grande, esto no es
lo más razonable del mundo, ¿verdad? Estamos diciendo casos 0, y luego tenemos que
recordar que esto está asociado con Apple, caso uno. Vamos a tener que
recordar que eso está asociado con el plátano. Y aunque nuestro código es
bastante pequeño y esto no es
tan difícil de verificar aquí
y leer aquí mismo. Podríamos hacer esto mucho
más legible con una enumeración. Entonces, en lugar de crear una nueva
constante para cada opción, y luego aquí abajo tratando recordar la
asociación con ella, simplemente
crearemos una enumeración. Entonces aquí arriba, sólo vamos
a eliminar todas estas opciones. Y luego aquí arriba
vamos a decir enum, fruta. Y luego entre corchetes aquí, digamos manzana, plátano, naranja. Entonces aquí abajo,
vamos a seguir adelante y cambiar nuestro entero a algo así
como x ahora mismo. Y luego aquí abajo, vamos a decir fruta siendo nuestro tipo de datos definido por el usuario en esta enum aquí que
acabamos de crear, llamado este enclave
y lo pusimos igual a x Ahora, vamos a obtener una porque no podemos inicializar nuestra variable a un
entero como este, pero en realidad podemos lanzar
esto para escribir fruit. Y esto va a funcionar bien. Entonces si ejecuto nuestro código aquí, puedes ver que
funciona igual que antes. Si elijo una opción
como tres aquí, Digamos que elegiste un par, y eso es porque la
entrada aquí es
igual al
valor entero de esto. Pero debido a que esto
es de tipo fruta, en realidad
podemos simplemente usar estos
valores constantes nombrados aquí. Así que aquí abajo,
solo podría decir caso, manzana. Y por debajo de eso puedo decir plátano. Entonces podemos decir naranja y pera. Y la razón por la
que esto me está dando un error porque en realidad
deletreo banana mal. Y si ejecuto mi código, y ahora se puede ver que
esto funciona bien. Y si elijo una opción. 0 aquí, va a decir
que elegiste una manzana, y ahora no tuvimos que ir
a recordar ninguna de la asociación con ella. Y como pueden ver, esto es mucho más fácil de leer. Ahora solo puedo decir
caso, estuche Apple, estuche
banana, par de estuches naranja. Ahora bien, otra
cosa buena de nuestra enumeración aquí, tener un grupo de constantes
es que
ni siquiera tuvimos que recordar realmente cuáles eran estas. Y te voy a
mostrar a lo que me refiero. Entonces aquí abajo, podría
haber dicho el caso a través del nombre de nuestra enumeración aquí y luego poner
dos dos puntos así. Y en realidad tendría al menos algún Visual
Studio me dio una lista de nuestras diferentes
opciones aquí. Y también me muestra la
constante asociada con ello. Entonces ahora solo puedo decir
caso la fruta era una manzana. Puedo ver la
constante que he asociado con eso y
solo seleccionarla ahí. E incluso puedo simplemente
escribirlo como tal. Y esto va a funcionar bien. Entonces esto es fantástico. Ahora, concedido aquí, solo
tenemos cuatro opciones si estamos trabajando con un programa más grande y teníamos una lista más grande de frutas, por ejemplo, esto
hubiera sido mucho más fácil trabajar con él. Podría haber dicho solo a través de
cada opción que he insertado aquí y solo hice una para cada una
bajando de la línea. Entonces como dije, el caso de uso básico para una ENM como para hacer que tu
código sea más legible. Y aunque solo usamos la
fruta como ejemplo básico, si estás haciendo un juego
o algo así, tenías una ENM de armas
y le daba a cada una
una una una una clave y un identificador de
valor únicos y hacían cosas que manera
igual que otro ejemplo. Ahora bien, otra
cosa buena de esto aquí es
que si tuviéramos que
cambiar el valor almacenado detrás de Apple aquí
por cualquier razón, digamos que cambio esto
a algo así como cinco. Y este demasiado pobre. O lo que tienes es que
no tengo que cambiar esto
aquí abajo en absoluto y
va a funcionar bien. Y si tengo alguna
superposición, entonces por ejemplo, naranja es cinco y
Apple es cinco. También
me avisará aquí abajo que
tengo dos casos que
pedían el mismo número. Entonces no hay problema. Sólo puedo escribirlo aquí. Ahora aquí abajo,
¿cómo hemos estado creando una lista de opciones? Y no queríamos
tener que cambiar esto cada vez que metíamos
con nuestras constantes aquí arriba, podríamos haber hecho lo
siguiente. Así que voy a seguir adelante y
quitar los números de estos. Entonces sigamos adelante y pongamos todos estos en orden
secuencial. Así que simplemente eliminaremos
todos estos de aquí. Y si quisiéramos, solo por claridad,
podríamos decir, oye, este empieza en 0,
aunque eso va a
pasar por defecto. Pero verás que
algunas personas hacen esto. Entonces solo voy a seguir adelante y
mostrarte eso como ejemplo. Y luego aquí abajo, porque solo imprime manzana. Y si ejecutamos nuestro código, diremos 0 y luego apple. Entonces podríamos hacer esto
por el resto, así. Y entonces aquí mismo, podríamos simplemente decir
ese par espacial, como vimos de manera naranja
y ellos invierten nosotros probamos. Ahora bien, si ejecutamos nuestro código, esto en realidad solo imprimirá
que son opciones para nosotros. E incluso si hubiéramos
cambiado los valores aquí, nuestro código seguiría
funcionando bien, lo cual es realmente agradable. Y podemos ver explícitamente con
qué estamos trabajando aquí mismo también cuando
imprimimos las diferentes opciones. Entonces aquí arriba, si tuviera
que cambiar esto a diez, todos mis valores son
diferentes y ejecutaré mi código. Mis opciones
cambiaron dinámicamente con él, y todavía es muy legible
en nuestro código también. De todos modos, eso básicamente
va a ser para este video. Ojalá ustedes ahora
tengan una comprensión básica de cómo crear una enumeración y su caso de uso
haciendo que su código más legible y más dinámico. En algunos casos,
como viste aquí, dándote un grupo de constantes con
nombre
que puedes usar en tu código y también darte un tipo de datos definido por el usuario
para trabajar también. Ahora bien, lo último que sí
quiero mostrarte
rápido es que debido a que nuestros nombres de constantes enum
tienen cada uno un valor real
asociado a ellos, puedes hacer algo
como lo siguiente. Así que aquí abajo, podría decir verdad. Y voy a poner
esto en nuestro caso. Diré que la manzana equivale a
través de Apple. Y por cierto, podría haber dicho manzana, y eso habría
funcionado también. Entonces aquí abajo, voy a decir fruta, plátano igual igual así. Y entonces realmente puedo crear una declaración if que funcione
con las matemáticas detrás de ellos. Entonces puedo decir si Apple
es mayor que banana, y luego ejecutar algún código aquí, porque Apple tiene un número menor asociado a que sea
un diez frente a un 11, entonces este código no se ejecutaría. Pero si sigo adelante y
le doy la vuelta, así, digamos que compré
es plátano mayor. Esto va a funcionar bien. Y en realidad voy a seguir
adelante y mover esto aquí rápido a la
parte superior de nuestro código, igual que imprime
sin ningún problema, pero por debajo de nuestra enumeración aquí. Y si lo ejecuto,
se puede ver que dice que Apple es mayor que el plátano. Pero si seguimos adelante y le damos la vuelta a
esto, no lo haría. Entonces solo quiero
mostrarte que podrías usar enumeraciones en matemáticas como lo harías
si fuera solo una constante integral normal. De todos modos, voy a seguir adelante y deshacerme de ese código extra aquí. Y entonces lo que quiero que
hagan es seguir adelante y guardar todo lo que tenemos aquí porque en realidad lo
vamos a usar en el siguiente video cuando
les muestre el otro tipo de enumeración y las diferencias entre
esa y ésta. Así que asegúrate de guardar lo
que tienes porque lo
vamos a usar en
el siguiente video. De todos modos, como siempre,
gracias por mirar, y te veré
en la siguiente.
59. Capítulo 11 (Enums): clases de Eums vs Enum: En este video,
vamos a estar hablando del otro tipo de suficiente
siendo una clase de E&M, que solo tiene algunas
diferencias una ENM normal como la que
creamos en el último video. Ahora bien, si recuerdas
en el último video, quería que ustedes guardaran
todo el código que
creamos para usarlo en este video. Pero si por alguna razón, te olvidaste, no es gran cosa, la única pieza principal a la
que quiero que se
aferren ahora mismo es que esta aquí es la creación
real de nuestra enumeración. Y yo sólo voy a seguir adelante y
comentar el resto por ahora. Entonces déjame mostrarte un par cosas más sobre las enumeraciones regulares antes de ver cómo crear una clase de enumeración y
las diferencias. En primer lugar, si
intentamos crear una variable con el mismo nombre que cualquiera
de nuestras constantes aquí, en lugar de nuestra suficiente,
vamos a obtener un error. Entonces si digo int
orange, por ejemplo, es igual
a 0 siendo intentado ejecutar mi código, me
va a dar un error. Y eso es porque para uno, se
considera
una enumeración regular sobre el alcance. Entonces, todos estos nombres están esencialmente agotados
para nuestro programa. Y se puede ver
aquí abajo que
dice que la fruta está en
el alcance y que preferiría si usamos una clase de enum sobre
lo suficiente en este caso. Ahora la otra cosa con las enumeraciones
regulares es que
una variable enum, estamos implícitamente
convertidos a un entero. Y déjame seguir adelante y
mostrarte eso ahora mismo. Entonces aquí abajo, si sigo adelante
y me quito esto, bien. No voy a pasar por
toda mi tripulación y ponerla igual para probarla. ¿Bien? Y luego aquí abajo, puedo decir x es igual a
cinco más menos. Entonces si imprimo x, así, obtendré t plus. Podría haber puesto
n igual a mi fruto. Y eso también habría
funcionado. Y va a convertir implícitamente
este valor sobre a esto. Y si eso es lo
que quieres, genial. Pero si hiciéramos de esta
una clase enum, no se
convertiría implícitamente así. Y te lo voy a
mostrar ahora mismo. Entonces, ¿cómo creamos
una clase enum? Bueno, es bastante fácil. Y así la misma enumeración
seguida del nombre de su enum, clase
enum, seguida
del nombre de nuestro genoma. Ahora, como puede ver, inmediatamente obtuvimos
un error y
no va a convertir implícitamente de nuestra clase enum aquí siendo fruto
a un valor entero. Sin embargo, todavía podemos hacerlo
explícitamente diciendo:
Oye, adelante y
haz de eso un entero. Eso está bien. Si ejecutamos nuestro código, todavía
obtendremos diez. Entonces, al convertirla en una clase, no solo
harás conversiones implícitamente de tu tipo de enumeración, otros
dos tipos. En cambio, tendrás
que hacerlo explícitamente. Además, no
toma estos nombres. Así que en realidad podría haber llamado a
esta manzana, por ejemplo. Esto funcionaría bien. Eso es porque nuestra enumeración
ahora tiene un alcance esencialmente. Y estos nombres son locales
para esta clase de aquí, y entraremos en clases
más adelante en el curso. Pero por ahora, solo debes saber
que ahora podemos tener dos del mismo nombre sin
ningún problema aquí. Y esto puede ser útil si
tuviéramos otra clase E&M, por ejemplo, queríamos
tener nombres similares. Entonces tal vez tuve una
clase de enum llamada comida. Entonces dentro de aquí, tenía algunos alimentos diferentes con los
que quería trabajar. Yo podría decir pollo, chips de
manzana así. Y esto funcionará
bien sin ningún problema, mientras que no tendría
con enumeraciones regulares. Entonces hay algunas
de las diferencias. Básicamente, si usas un
nombre y una clase enum, aún
puedes usarlo en otro lugar. Mientras que si lo usa
solo con un ENM regular, no
puede también, enumeraciones
regulares pueden
convertirse implícitamente a otros tipos donde como una clase de enumeración no puede y
tiene que hacerlo explícitamente, que ayuda a garantizar que eso es
lo que quieres que haga. Entonces ahí lo tienes. cómo crear una clase de enumeración versus una E&M y ahora
conoces las diferencias. Entonces como siempre, gracias por mirar y te
veré en la siguiente.
60. Capítulo 12: Introducción a las funciones: En este video, vamos a
estar hablando de funciones. Ahora bien, una función o un
método es esencialmente solo un bloque de código que
se ejecuta sólo cuando está frío. Entonces como dije, una función es esencialmente solo
un bloque de código, como tenemos un
bloque de código aquí. El corre sólo cuando hace frío. Y en realidad hemos estado usando un puñado de
funciones diferentes para diferentes cosas. Por ejemplo, acabamos de
usar un montón de funciones
diferentes cuando
hablamos de contenedores en videos anteriores. Además, prácticamente todo
nuestro código ha sido escrito en esta función principal, que como dije antes, cada programa C plus necesita una función principal
porque se llama justo al principio del programa cuando tu
programa inicia y termina. Y este de aquí es el bloque de código que se ejecuta cuando hace frío. Entonces, ¿por qué querríamos usar
y/o crear una función? Bueno, antes que nada, va
a limpiar tu código. Una de las razones a limpia nuestro código como porque
cada vez que tienes, digamos, un bloque de
código que usas, no
sé, tres veces o
más o algo así. En lugar de tener todo
ese bloque de código copiado y pegado
varias veces, solo
puedes crear
una función que nos
permita usar fácilmente el código y
otra vez sin tener que
copiarlo y pegarlo. Y otra razón por la
que podrías querer usar una función como
porque por ejemplo, digamos que sí teníamos
un bloque de código que usamos una y otra y otra vez. Y seguimos adelante y simplemente lo
copiamos y pegamos y lo copiamos y pegamos y
lo copiamos y pegamos donde lo necesitábamos. Bueno, y si en el futuro, te das cuenta, sabes qué, necesito que esto haga. Algo ligeramente
diferente ahora. Bueno, ahora vas
a tener que ir a buscar todo tu
código que hayas usado una y otra vez
y ajustarlo en todas partes
individualmente. Mientras que si tuvieras una función, podrías simplemente
ajustar la función. Así que esencialmente
funciona dinámicamente. En todas partes se usa. El código ha cambiado porque
podemos simplemente cambiar la
función en lugar de tener que cambiar
cada porción de código que hemos
usado una y otra vez. Bien, así que solo para
resumir una función y nuestro método como un
bloque de código que se ejecuta solo cuando se llama en algunas de las
razones principales por las que querrías usar una función en
primer lugar es limpiar tu código para
hacerlo más dinámico. Y para que puedas usar fácilmente el código una y otra vez sin
tener que reescribirlo. De todos modos, ojalá eso
te dé una comprensión básica de qué es una función y cuándo
querrías usarla. Pero si no lo entiendes
del todo, no te
preocupes porque
vamos a estar creando y trabajando con diferentes ejemplos en
los próximos videos. Así que de todos modos, gracias por mirar, y te veré
en la siguiente.
61. Capítulo 12 (funciones): cómo crear una función: En este video, vamos
a estar creando y trabajando con una función muy básica. Y luego en los próximos videos, vamos a estar trabajando
lentamente con funciones cada vez más complejas para que
puedas tener
una buena idea de cómo usar y crear funciones
propias. Y eso es porque las funciones se utilizan todo el tiempo
en la programación. Y personalmente,
encuentro funciones y, o métodos, como
quiera llamarlos. Tan útil que
ni siquiera tocaré ni trabajaré con un lenguaje de programación
que no tenga esto. Y eso es porque simplemente
limpia tanto tu código. Lo hace
mucho más dinámico, y es mucho más fácil trabajar
y
menos propenso a errores que copiar y pegar
código una y otra y otra vez. Y en la programación, siempre
quieres hacer todo lo
posible para evitar errores humanos porque todos cometemos errores. Y a veces puede
llevar mucho tiempo
averiguar qué es lo que está
causando el problema. De todos modos, basta con esa
peroratoria, sigamos adelante y creamos una función
básica propia. Entonces aquí abajo, fuera
de nuestra función principal, vamos a seguir adelante y
crear una función propia. Para empezar, vamos
a poner nuestro tipo de devolución, y esto es lo que quieres
recuperar del método. Por ejemplo, nuestro método principal aquí como un
tipo de retorno de un entero. Y es por eso que al final
de todos nuestros programas, devolvemos 0, que
es un valor entero. Entonces cuando se llama al
método main, tiene un tipo de retorno integer y devolvemos el entero de vuelta. Y esto debe hacerse
ahora en C plus plus, si ustedes recuerdan, en realidad pueden eliminar
esta línea de código. Y C plus plus
realmente hará esto por ti, al
menos con tu método principal, sin
que tengas que tener esa línea de código
que específicamente. Pero solo me refería a
dejarlo ahí para que ustedes entiendan eso, oye, tenemos un tipo int return, necesitamos devolver un entero. Y también cuando nuestra función principal devuelve 0 y C plus plus, sabemos que todo
nuestro código se ejecutó con éxito y
pudimos llegar al final aquí. Y podríamos haber
puesto un 0 aquí también. Pero también podemos tener
este excelente éxito aquí si quieres que se
explique de manera más explícita. Así que vamos a seguir adelante y
en realidad crear esta cosa. Primero, comenzaremos
con un tipo de devolución. En este caso,
vamos a decir nulo. Y lo que significa vacío
es que, Oye, no
queremos devolver
nada de esta función. Sólo queremos ejecutar
el código dentro de él. Y eso está perfectamente bien. Y nos pondremos
en trabajar con diferentes tipos de devoluciones
y un próximo video. Pero por ahora,
simplemente no vamos a devolver nada
de nuestra función. Así que sólo vamos a ejecutar
el código dentro de él. A continuación, sigamos adelante
y llamemos a esta impresión. Así como así. Tendremos paréntesis abiertos y
cercanos después. Y luego después de eso,
tendremos nuestro bloque de código, que una vez más se acaba definir con llaves abiertas y
cerradas. Todo el código dentro de él
es nuestro bloque de código. Ahora bien, esta parte superior aquí es nuestro método o declaración de
función. Así que algo así como con las variables, cómo podemos hacer declarar e
inicializar una variable. Aquí, podemos declarar una función. Y entonces en nuestro bloque
de código es donde realmente
definimos nuestra función. Entonces aquí abajo, o bloque de código aquí sería
nuestra definición de función. Bien, entonces esta es nuestra
declaración y lo que es enter code block
es nuestra definición. Ahora, sigamos adelante y en realidad pongamos algo de código
aquí para que podamos ver cómo funciona esta cosa y podemos poner lo que
queramos aquí. Pero vamos a seguir adelante
e imprimir hola. Como nuestra función se
llama print hello, luego de vuelta en nuestro método principal, realidad no
llamamos esta función o
no va a hacer nada. Entonces como puedes ver, si ejecutamos nuestro código ahora mismo, no
va a
imprimir nada. Y eso es porque, como
hablamos en el último video, una función es un
bloque de código que sólo se ejecuta cuando se le llama. Entonces, ¿cómo llamamos a nuestra función? Bueno, vamos a decir
el nombre de nuestra función, seguido de paréntesis abiertos, luego un paréntesis cerrado,
y un punto y coma. Ahora bien, no es así como
siempre llamas a una función. Y nos adentraremos en algunas de las diferentes formas cuando comencemos a hablar de argumentos
y parámetros. Pero para llamar aquí a nuestra función, Así es como se hace. Uno, no estamos recopilando
nada de suposición, así que no necesito guardar nada en
ningún lado y no tenemos
nada entre paréntesis. Así que aquí no necesitamos nada
entre paréntesis. Permítanme simplemente poner un
punto y coma al final. Y si tratamos de ejecutar nuestro código, se
puede ver que
obtenemos un error. Eso es porque al igual que con cualquier otra cosa en C plus plus, no se
puede usar
antes de que se defina. Y una forma en que podemos
arreglar esto es en realidad copiando todo
un código aquí abajo, y lo estoy poniendo
por encima de nuestra función principal. Y ahora si ejecutamos nuestro código, puedes ver que no va a
funcionar e imprimir hola. Y sigamos adelante y
quebrado y línea M aquí. Y solo para mostrarte esto, en realidad
podemos copiar y
pegar esos tanto como queramos. Y podemos poner esto en
cualquier parte de nuestro código y va a funcionar bien. Y como pueden ver,
imprimimos hola Por cada vez que
recurrimos a nuestra función. Ahora bien, esta es una función bastante
básica que en realidad
no hace mucho, pero te das la idea de una que diga claramente
lo que estamos tratando de hacer. Sólo vamos a imprimir hola porque dimos nuestro método. Aquí están nuestra función un nombre muy definitivo de
lo que hace esa función. Además, si tuviéramos mucho
más código aquí, por
ejemplo, si estamos
imprimiendo como un párrafo o
algo así, empezaría a verse muy desordenado si tuviéramos una escritura
que aquí cada uno tiempo o copiarlo y pegarlo
ya que sería una gran cantidad de textos para realmente ninguna ganancia
en comparación con sólo dos. Algo como esto
donde solo podemos tener nuestro nombre de función como sub t ha recordado esto
aquí está nuestra función. De todos modos, eso es
más o menos todo para este video. Como dije en los
próximos videos, solo
vamos a estar trabajando
lentamente con funciones cada vez más complejas hasta desglosemos todas las cosas
básicas que
necesitarás para crear funciones
de los tuyos. Entonces, para concluir este video, recapitulemos rápidamente
las principales cosas que querrás
quitar de esto primero, para crear una función muy simple
y/o básica, puedes tener tu
tipo de retorno seguido del nombre, abrir y cerrar paréntesis, y luego su bloque de
código y llaves. Y al igual que con
cualquier otra cosa, nuestro código se lee
de arriba a abajo. Entonces necesita saber
cuál
es nuestra función antes de que podamos usarla. Además, si no devolvemos
nada de una función, simplemente
podemos decir void. Entonces para llamar a una función
o realmente usarla, necesitamos decir el
nombre de nuestra función seguido de paréntesis abrir y
cerrar, al
menos en este caso, porque aquí no hay nada
entre nuestros paréntesis. Y por último, un punto y coma. Ahora bien, si todavía estás
un poco confundido sobre cómo usar las funciones, no te
preocupes por ello. Vas a ver algunos ejemplos más en
los próximos videos. Ahora, antes de pasar
al siguiente video,
por favor, guarda todo lo
que tengas porque lo
vamos a usar en el siguiente video cuando
hablemos de los prototipos de funciones. De todos modos, eso es todo
para este video. Como siempre, gracias por mirar, y te veré
en la siguiente.
62. Capítulo 12 (funciones): prototipos de funciones: En este video, vamos
a estar creando algo llamado una función o
un prototipo de método. Ahora, para seguir adelante y
mostrarte lo que es esto. Si recuerdas en el último
video, cuando nuestro método, declaración y definición aquí, estamos abajo, no
pudimos llamar a nuestro método. Y eso es porque
nuestro programa
no tenía idea de lo que
estábamos hablando. Porque si recuerdas, el código
se lee de arriba a abajo. Así que sigamos muy rápido. Puede mover esto de nuevo hacia abajo a
bajo, nuestra función principal. Así. Si seguimos adelante e
intentamos ejecutar esto, se
puede ver que
obtenemos un error. Y dice imprimir
hola no se encontró. No tiene idea de lo que
estamos hablando. Ahora. Podríamos simplemente hacer lo que
hacíamos antes, obviamente, donde tomamos
toda nuestra función y simplemente tirarla por encima de
nuestra función principal. Sin embargo, muchas veces cuando
estás abriendo tu código, solo
quieres verificar lo que
hay en la función principal. Con suerte,
debería
poder comprender cómo
funciona el código y cómo desplazarse más allá de funciona el código y cómo desplazarse más allá un montón de otros
métodos potencialmente, dependiendo de cuán
complejo sea su código, puede ser realmente
molesto y desordenado. Entonces para solucionar este problema, podemos usar algo llamado
el prototipo de función, y esto es bastante fácil de hacer. Así que vamos a hacer
es copiar esos eran muy de primera línea aquí
de nuestro método. Y luego pegarlo arriba nuestro método principal y poner
punto y coma al final. Y esto es un prototipo de
función. Eso es prácticamente
todo lo que tenemos que hacer. Y ahora cuando nuestro código se
lee de arriba a abajo, va a decir, Oh, bien, hay una función
llamada print hello, y la definición
está justo aquí abajo. Ahora cuando lo llamamos, sabe de lo que estamos
hablando. Y si ejecutamos nuestro código, puedes ver que
funciona bien. Ahora. Eso es un prototipo
de función. Y si quieres una explicación más
detallada de lo que es un prototipo de función, es esencialmente como otra declaración y
necesita tener el tipo de retorno, si lo hay, el nombre junto con
cualquier perímetro en orden. Y nos meteremos en
los amargos en un video posterior. Pero como no
teníamos ninguno aquí, solo
pusimos nuestros paréntesis de apertura
y cierre. Y luego, por último, solo le
das seguimiento con el punto y coma. Y esto deja que el compilador, o la cosa que
traduzca todo este código a binario para que la computadora
pueda entenderlo, sepa qué esperar
en el futuro. Entonces cuando tenemos una llamada a
función más adelante, ya sabe a qué se refiere esta llamada de
función, siendo esta función aquí mismo, la raíz declaró y la
hizo consciente de antemano. Y todo lo hace
esencialmente siempre y cuando a cómo nuestra definición
más adelante en nuestro código. Porque como dije, muchas veces cuando estás
abriendo tu código, solo
quieres poder
mirar la función principal y entender lo que está pasando. No quieres
tener que lidiar con un montón de otros textos de antemano. Sólo quieres llegar
a la carne de las cosas. De todos modos, ojalá eso fuera
bastante fácil de entender. Si no, también estaremos trabajando con estos en los próximos
videos. Porque siempre
recomendaría solo usar un prototipo
de función en lugar de poner tu función sobre tu función principal, pesar de que
funcionará igual, es simplemente mucho más limpia. Así que básicamente solo
recuerda si
quieres tener tu
definición de función más adelante, lo cual siempre recomendaría, todo lo que realmente necesitas hacer es copiar esta línea muy superior aquí, pegarla arriba, y
lanza un punto y coma y vas de todos modos,
eso es todo para este video. Gracias por mirar, y te
veré en la siguiente.
63. 62: En este video, vamos a estar
hablando de tipos de devoluciones. Ahora bien, si recuerdas
crear una función muy básica, vas a comenzar
con el tipo de retorno, seguido del nombre, abrir
y cerrar paréntesis, y luego tu bloque de código. Ahora, en los videos pasados, simplemente
seguimos adelante y dijimos No
queríamos que ella
entregara nada, insertamos la palabra clave void. Pero en este video, en
realidad
vamos a estar echando un
vistazo a cómo recuperar un valor de nuestra función y crear una función
que también haga esto. Así que sigamos adelante
y comencemos. Ahora, para empezar, solo
vamos a
seguir adelante y crear nuestro prototipo de
función. Entonces para hacerlo, vamos a poner
un tipo de retorno, que va a ser int, seguido del nombre, que
va a ser devuelto diez. Y recuerda, esto puede
ser lo que quieras. Por cierto, la convención de
nomenclatura típica para una función es usar camelCase, al igual que hacemos con las variables, pero para comenzar
con mayúscula, entonces vamos a tener paréntesis
abiertos y cercanos y un punto y coma al final, ya que este es nuestro prototipo de
función. Ahora bien, si paso el ratón sobre esto, se
puede ver que sí nos
advierte que no
tenemos una definición
para nuestra función. Pero como puedes ver, la línea squiggly está en verde, lo que básicamente significa que
tu código seguirá funcionando. Pero bueno, esto es
solo un aviso. Básicamente, si ejecutamos nuestro código, no obtenemos ningún error. El código funciona bien. Entonces esto es más
como un heads-up que una advertencia real de que un
código no se ejecutará correctamente. Por eso es en
verde en lugar de rojo, al
menos en Visual Studio. Entonces, para
crear realmente nuestra función, seguiremos adelante y copiaremos todo esto excepto el
punto y coma allí, y lo pegaremos abajo. Entonces tendremos las corchetes abiertas y
cerradas así. Y vamos a poner en nuestro código aquí. Y podemos tener lo que
quisiéramos dentro de nuestro bloque de
código una vez más. Pero en este caso, simplemente
vamos
a devolver un valor de diez. Entonces hoy que todo lo que
vamos a hacer y decir tiempo de espera, seguido de diez y un
punto y coma al final. Y ahí tienes. Y
si pasamos el mouse sobre esto, se
puede ver que esto es
efectivamente un valor entero, entonces solo tenemos nuestro
punto y coma al final. Y si queremos que sea
incluso explícito al respecto, podríamos afirmar
algo como int ten es igual a diez y luego devolver
esa variable directamente. Pero lo que teníamos
aquí está bien. Así que al igual que con
nuestro método principal, donde devuelve un entero
usando esta palabra clave return. Recuerdo que esto aquí
es esencialmente
lo mismo que decir retorno cero. Entonces todo lo que necesitas hacer para devolver
un valor de una función. Simplemente ponemos el tipo de datos que desea devolver antes del nombre de la
función y luego usamos esta palabra clave return
y todas las minúsculas allí, seguido del valor
que desea devolver. Y querrás
asegurarte de que este tipo de datos
sea el mismo que tu tipo de devolución. Entonces aquí arriba, podemos seguir adelante
y recoger este valor. Ahora, sólo para
mostrarte algo aquí, si seguimos adelante y llamamos a
su función diciendo una
vez más el nombre
de nuestra función, seguido de paréntesis de apertura y
cierre. Ya que aquí no tenemos
nada, no
necesitamos nada aquí. Después poniendo un punto y coma
al final y ejecutando nuestro código, puede ver que
funciona bien. Sin embargo, cada vez que tenga una función que
devuelva un tipo de datos, desea almacenar
ese valor en alguna parte. Porque si no
vas a almacenar ese valor, bien
podrías no haber devuelto nada
en primer lugar. Entonces aquí arriba,
diremos algo como int x es igual a retorno diez. Y luego abajo, simplemente
imprimiremos x, así si ejecutamos nuestro código, se
puede ver que ahora
es igual a diez. Eso es porque establecemos x igual al resultado
de esta función. Y debido a que
devuelve un entero, obtenemos un entero de vuelta. Así que todo lo que hicimos fue crear
una variable llamada x y establecerla igual a lo que
nuestra función aquí devuelva. Y si paso el mouse sobre
esa función, se
puede ver que
devuelve un valor entero. Entonces x va a ser igual
al entero devuelto
por nuestra función aquí, que en este caso es. Entonces esta línea aquí es exactamente
la misma que si dijéramos x es igual a diez. Al menos en este caso, podemos simplemente trabajar
con nuestra variable como normal. Entonces ahí tienes. Ahora ya sabes cómo usar un tipo de retorno al
crear una función. Básicamente, en lugar
de decir vacío aquí, pones el tipo de datos
que quieres devolver. Entonces en tu función, dices return seguido del valor del tipo de datos
que quieres que devuelva. Ahora, siempre que
llames a esa función, te devolverá a
ese valor de ese tipo. Y por eso
pudimos hacer lo
siguiente sin ningún problema. Para aquellos de ustedes que recuerden, x aquí es una
variable local
porque fue declarada
dentro de un bloque de código, solo
está disponible dentro ese bloque de código después de
que fue declarado. decir, podríamos haber dicho
algo así aquí abajo. X es igual a diez, y
luego dijo devuelto X. Y esto funcionaría bien porque en lo que a este bloque de
código se refiere, x aquí no existe. Y en lo que a este
bloque de código se refiere, esta x aquí abajo no existe, y por lo tanto pueden
tener el mismo nombre exacto sin ningún problema. Sólo algo a tener en cuenta. Siempre quieres
hacer las cosas tan disponibles como
absolutamente tienes que hacerlo. Si no tuviéramos que
hacer una x aquí, una variable global, por ejemplo, entonces no
querrías hacer eso. Lo único que quieres es que esté disponible
como necesites. Entonces, para uno,
no tienes problemas donde tienes
nombres de variables superpuestos. Y en segundo lugar, también estás
minimizando el error humano. Estoy haciendo una variable
o lo que sea, solo que esté disponible
como sea necesario, lo cual siempre es algo bueno. Ahora bien, para mostrarte una
última cosa aquí, porque esto puede ser esencialmente cualquier tipo de datos que queramos. Podríamos devolver algo
así como un cool, por cierto, notar que si nuestro
prototipo de función aquí tuviera una declaración
diferente a nuestra función real, obtenemos un error. Así que querrás estar
seguro de que les das a estos dos el mismo tipo de
devolución, así. Y luego dentro de aquí, podríamos decir que algo
así como pool es verdad, igual a verdad, luego volver verdadero. Ahora bien, esto esencialmente
es lo mismo que si no
tuviéramos esto y
solo digamos retorno, cierto. Yo solo voy a seguir adelante
y hacerlo de esta manera, solo para mostrarles
que podríamos simplemente tirar la región variable aquí. Y entonces aquí arriba, podríamos haber tenido una
declaración if, si se devolvía diez. Y probablemente
hubiéramos querido cambiarle el nombre a esto por algo
así como devolver true. Sólo para que quede claro. Esta función lo hace al solo
leer nuestro método principal. Porque no siempre
quieres tener que
preocuparte por el código
dentro del grado de función. Solo quieres poder,
como dije en el pasado, leer tu
función principal y tener una comprensión general
de lo que está pasando. Entonces por aquí,
dijimos f volver verdad. Observe al llamar a
esta función, porque era una condición de
sentencia if, no
necesitábamos poner
punto y coma aquí. Y luego abajo, podemos poner unos
corchetes si devuelve true, ejecutamos este código y
solo diremos C out if declaración o
algo así. Y si ejecutamos nuestro código, puedes ver que esto
funciona bien. Y si hubiéramos cambiado
esto a false por ejemplo y ejecutamos nuestro código, no
se habría corrido. Entonces, al devolver
un valor booleano, realidad
puede
usarlo directamente en su declaración if como la
condición aquí también. Así que eso es bastante ordenado. Así que recuerda, una función está ahí para hacerte la vida más fácil. Y así esto es
esencialmente lo mismo que
solo tener el valor
booleano aquí, ya que devuelve un booleano
y cuando devolvimos un int, era
lo mismo
que solo tener el valor int ahí, ya que devuelve un entero. Entonces ahí lo tienes. Ojalá ahora tengas
una comprensión básica de cómo trabajar
con los tipos de devolución. Si no, siempre puedes
volver a ver el video. De lo contrario, estarás viendo más ejemplos de ello en
los próximos videos. Así que gracias por mirar, y te veré
en la siguiente.
64. Capítulo 12 (funciones): parámetros y argumentos: En este video,
vamos a estar echando un
vistazo a parámetros y argumentos. Ahora, en el pasado,
hemos estado creando algunas funciones básicas
que se veían así. Tenían un tipo de retorno
seguido del nombre, paréntesis
abiertos y cercanos, y luego nuestro bloque de código
y corchetes. Pero dentro de estos paréntesis, en realidad
podemos tener la lista de lo que se llaman parámetros. Entonces podríamos decir
si el parámetro uno, parámetro dos, etcétera. Y podemos tener
tantos como lo queramos. Y cuáles son
nuestros valores que planeamos pasar
a la función. Así que en realidad podemos enviar
datos a la función
así como recuperar datos de la función. Entonces, sigamos adelante y echemos
un vistazo a cómo hacer esto. Entonces aquí abajo
nuestra función principal,
Sigamos adelante y creamos
una función que sume dos números juntos y nos
dé el resultado de eso. Entonces para hacer esto,
vamos a seguir adelante y citarlo en este caso. Y luego diremos
add para nuestro nombre. Y luego entre paréntesis
vamos a decir int x coma y, así como así. Y luego tendremos nuestro bloque de
código y voy a
repasar por qué hicimos esto
aquí en un momento. Y luego dentro de nuestro bloque de
código diremos return x más y Ahora, podríamos haber creado una variable entera llamada result y luego
devolver el resultado. Pero solo quiero
mostrarles que podríamos tener una expresión en nuestra declaración
return aquí, porque
ambos son enteros, va a
devolver un entero. Y así ahora cuando realmente
llamamos a nuestra función, podemos hacer lo siguiente. Entonces primero, sigamos
adelante e
imprimimos el resultado de esta función. Entonces para hacerlo,
solo vamos a decir C out por nuestro nombre de función aquí. Y luego entre paréntesis, se
puede ver que necesitamos arriba
poner en dos valores enteros. Y los valores que ponemos en nuestra función llamada aquí
se llaman argumentos, mientras que estos aquí abajo, llamaremos a los perímetros. Entonces aquí podemos decir
algo así como 510. Y entonces estos números
serán enviados a nuestra función aquí, luego se sumarán juntos y nos
devuelven como un entero. Y luego antes de ejecutar un código, porque nuestro método está abajo por
debajo de nuestra función principal aquí, solo
necesitamos
crear un prototipo. Entonces copiaremos esta línea superior, pegaremos arriba y
pondremos punto y coma. Entonces ahora tenemos un prototipo
de función. Tenemos una llamada de función aquí, y tenemos una declaración de
función y definición aquí
abajo también. Entonces, si ejecutamos nuestro código
aquí muy rápido, puedes ver
que imprime 15. Eso es porque dijimos: Oye, queremos imprimir
este valor entero que recuperemos de aquí. Ese era nuestro tipo de devolución aquí. Luego pasamos en
dos valores enteros como argumentos para
estos parámetros. Y todo lo que hicimos fue que dijimos, oye, devuelve el primero
más el segundo. Y por cierto, los argumentos que pasamos aquí
son los valores que pasamos aquí tienen que estar en el mismo orden que
estos aquí abajo. Entonces este diez nunca
tomará el lugar de x, y este cinco nunca
ocupará el lugar de y. Estarán en orden, y en el mismo orden en que
estaban aquí abajo, necesitaban estar en ese
orden aquí arriba también, razón por la
cual muchas
veces simplemente es más fácil copiar esta
primera línea y luego agregar un punto y coma al final al crear su prototipo de
función. Además, solo para hacerle saber que estos nombres de parámetros son
locales para esta función. Así que aún podrías crear un entero x
aquí arriba y un int
y, y funcionará bien. ¿Bien? Entonces son locales a la
función que fueron creados. Entonces básicamente para
crear un parámetro, todo lo que tienes que hacer es tener el tipo de datos seguido del nombre. Y todo este nombre es como el
nombre
con el que quieres trabajar por el valor pasado
a tu función. Así crearás un perímetro
cada vez que quieras pasar algo
a tu función. Y lo que pasas se
llama argumento, y se asocia con
el mismo parámetro en orden. Entonces tenemos 510 aquí, que estarán asociados
con X e Y respectivamente. Entonces este cinco va por x
y el tiempo fue para ¿por qué? Como dije, tenemos que
nombrarlos como quisiéramos, aunque hubiéramos creado
dos variables aquí arriba. Entonces, si hubiéramos querido, podríamos haber dicho
int x o num uno. Núm dos es igual a diez y luego
pasó en num uno, num dos. Y esto va a funcionar bien. Como dije, este
parámetro nombre aquí, ahí está justo lo que
quieres llamar el valor o el argumento pasado
dentro de tu función. Y podrían haber tenido el
mismo nombre si quisiéramos que así nos
gustara y eso
hubiera funcionado también. Pero como dije, puedes
llamar a esto como quieras. Así que acabamos de tener x e y eran los nombres con los que queremos trabajar
para los valores pasados
para que pudiéramos usarlo en nuestro libro de códigos. Además, otra cosa a tener en cuenta
es que este parámetro es una copia de esta variable y
no de la propia variable. Entonces si y aquí
dije x plus plus, y luego aquí arriba
imprimimos num uno. No se cambiaría el número uno. Entonces imprimimos 16
porque pasamos en 510. Entonces aumentamos x en uno, que era igual a
cinco originalmente. Entonces cinco a 66 más 1016. Y luego imprimimos el num uno, que todavía estaba bien. Y eso es porque, como dije, este perímetro aquí siendo x, solo una copia del
argumento pasado, que era num uno. Y pérdida de caso,
lo que significa que
cambiar x en realidad no cambia la variable, lo que también es por eso que si esto
era una constante, por ejemplo, esto va a funcionar
bien porque
no intentamos cambiar
el constante, solo
cambiamos la
copia del mismo siendo. Entonces ojalá que
todo tuviera sentido. Lo principal que quiero que
le
quites a esto es que
puedas pasar valores a una función creando un parámetro
solo indico el tipo de datos seguido un nombre que quieras trabajar
con dentro de la función. Y entonces el valor
que pasaste se llama el argumento y se copiará para su
uso dentro de tu función. Entonces solo necesitas
asegurarte de que todos los
parámetros que tengas aquí también se coloquen
en tu prototipo, y ahora también se requieren cuando
llamas a la función. Entonces no podríamos haber dicho agregar num uno ya que
obtendríamos un error diciendo,
oye, esto en realidad
requiere más argumentos, ¿
verdad? Entonces ahí lo tienes. Ya sabes
trabajar con parámetros y argumentos en C plus plus. Ahora voy a seguir adelante y
quitar al CEO num uno, y quitarlo para esta
constante aquí, así. Y lo que quiero que
ustedes hagan en realidad es guardar todo lo
que tenemos aquí mismo, porque vamos a usarlo
en el siguiente video De todos modos, gracias por verlo, y los
veré en el siguiente.
65. Capítulo 12 (funciones): argumentos opcionales: En este video, vamos a estar hablando de argumentos
opcionales. Ahora bien, si recuerdas
en el último video, les
pedí a ustedes
que dijeran que todo lo que
tenían para que pudiéramos
usarlo en este video aquí. Ahora bien, si por
alguna razón no viste el último video o
te olvidaste de guardar, siéntete libre de pausar el
video y copiar todo esto. De todos modos, sigamos adelante
y echemos un vistazo a los argumentos
opcionales
y sus casos de uso. Entonces para hacer un argumento opcional, todo lo que tenemos que hacer
es aquí abajo en nuestra declaración de función es establecer el parámetro
igual a algo. Pero cuando hacemos esto, tenemos que empezar por el
más a la derecha y
trabajar nuestro camino a la izquierda. Entonces déjame mostrarte
lo que quiero decir con eso. Entonces puedo dar un valor
por defecto de 0. Entonces vamos a obtener un error aquí. mismo argumento predeterminado, no
al final de la lista de parámetros. Y así es por eso
que siempre hay que
empezar por el más a la derecha. Entonces como pueden ver, si pongo y igual a 0,
esto va a estar bien. Y entonces podemos trabajar
nuestro camino a la izquierda a través de
cualquiera de los parámetros que queremos
tener un valor por defecto. Y esto también los
hará opcionales. Entonces ahora aquí arriba donde
dije agregar num uno, num dos, solo puedo
quitar estos por completo. Entonces tenemos que hacer una
última cosa antes ejecutar nuestro código para que
no obtengamos ningún error. Y eso es que o tenemos que
tomar nuestro método completo aquí y ponerlo en
la parte superior, así. Y esto va a funcionar bien. Entonces, si ejecutamos nuestro código aquí, puedes ver que
imprimimos uno. Y eso es porque tenemos
este x plus plus aquí mismo. Pero si seguimos adelante y
eliminamos ese rápido, puedes ver si
imprimimos 0 y
no tuvimos que pasar
ningún argumento ya los argumentos eran
opcionales porque nuestros parámetros tienen
un valor predeterminado. Ahora la otra opción sería dejar nuestra función
donde la teníamos. Así como esto. Elimine este valor predeterminado para nuestros parámetros en nuestra
declaración de función aquí abajo
y, en su lugar, póngalo en
el prototipo de función. Y no, no se puede
tener en ambos. Entonces, si tienes un prototipo de
función, ahí es donde deben ir tus
valores predeterminados. Y hay diferentes
razones para eso, que realmente no
voy a meterme. Pero solo sepa si quiere
tener argumentos predeterminados, necesita darle a sus
perímetros el valor predeterminado de ayuda, comenzando con el más alejado
a la derecha y trabajando su camino de regreso para tantos predeterminados
argumentos como te gustaría. Y si tienes un prototipo de
función, estos valores predeterminados
necesitan ir ahí y no dentro de nuestra definición de
función. Y ahora si volvemos a deshacernos de
los de aquí
y
ejecutamos nuestro código, podemos ver que
vamos a imprimir 0. Podemos cambiar estos valores
a lo que quisiéramos, como y equivale a cinco, y ahora se imprimirá Hola. Bien, así que echemos un
vistazo a un mejor ejemplo de cuándo es
posible que quieras usarlos. Así que vamos a deshacernos de
nuestra función aquí. Y luego también nos desharemos
de todo lo que hay aquí y eliminaremos nuestro prototipo de
función para comenzar con un lienzo
en blanco, como. Entonces aquí arriba, vamos a crear un
prototipo para esta función. Y lo que vamos a
hacer, digamos vacío,
Texto, abrir y cerrar paréntesis y un
punto y coma al final. Y luego dentro de aquí,
vamos a tomar una cadena como argumento. Entonces necesitamos un
parámetro de cadena y vamos a llamar a
este texto así. Entonces vamos a seguir adelante y crear la declaración de función real y definición abajo. Así que vamos a pegar
eso aquí abajo sin el punto y coma y
crear nuestro bloque de código. Y entonces sólo diremos CL. Y luego sigamos adelante y demos a nuestro texto aquí
un valor por defecto. Y porque tenemos un prototipo de función que
va a tener que ir aquí arriba. Entonces justo después de los textos
dirán iguales, No
enviaste una cadena. La función. Entonces esto nos permitirá llamar
a nuestra función, pero danos una advertencia de que en realidad
no ingresamos ningún texto. Ahora bien, en este caso, podríamos simplemente no haber tenido
un valor predeterminado y
entonces no nos dejaría
llamar a la función en absoluto sin insertar texto. Pero solo lo vamos a hacer de esta manera solo para darte un ejemplo de cómo
podrías usar esos. Y luego aquí abajo, solo
llamaremos a nuestro método. Entonces diremos texto impreso. Y luego sigamos adelante y
en realidad enviemos algo de texto aquí. Entonces diremos imprimir texto, hola,
mundo, punto y coma al
final y ejecutaremos nuestro código. Y como pueden ver, hemos
impreso Hello world. Y si no pusimos nada aquí y alrededor de nuestro código, ahora
va a decir que no
enviaste una cadena a la función. Entonces ahí tienes. Ya sabes cómo crear argumentos
opcionales. Y para resumir,
puedes hacer esto
dando uno o más parámetros,
un valor predeterminado comenzando por dando uno o más parámetros, un valor predeterminado comenzando la derecha y trabajando
tu camino hacia arriba a la izquierda, ya sea en la declaración de
función aquí o si tienes tu prototipo de
función, entonces necesita ir allí. Y por cierto, solo
un aviso la razón por la que
tenemos que empezar
por la derecha y
trabajar nuestro camino a la izquierda fuera
del hecho de que
vamos a obtener un error
y no nos va a dejar ejecutar nuestro código es la siguiente. Entonces digamos que después de esto, seguí adelante y tomé un
entero y solo lo
llamaremos x y lo pondremos igual a 0. Y luego seguiremos adelante y eliminaremos aquí el
valor predeterminado para el texto. Y aquí abajo
diremos x, así. Entonces abajo
diremos C out textos, y también
imprimiremos x así. Y vamos a seguir adelante y
renombrémoslos hasta el final. Y si solo quisiéramos ser
más explícitos aquí, ¿de acuerdo? Y ahora si empezamos a
poner argumentos aquí, automáticamente
va de
izquierda a derecha porque recuerda estos tienen
que estar en orden. Entonces cuando pongo
un texto como bajo. Y así ahora este argumento de
cadena hola aquí irá automáticamente
a nuestro primer parámetro. Pero, ¿cómo
nos permitió hacerlo de esta manera? Bueno, entonces no
tendríamos ninguna manera de darle a x un valor sin
darle un valor al texto. De todos modos, la puesta de sol
se hace en orden. De todos modos, ojalá que todo tuviera
sentido para ustedes chicos. Si no, ustedes siempre
pueden hablar
conmigo abajo en la
sección de discusión a continuación, y de todos modos me pondré en contacto con ustedes tan pronto
como pueda. Gracias por mirar, y te
veré en la siguiente.
66. Capítulo 12 (funciones): funciones sobrecargadas: En este video,
vamos a estar hablando algo llamado sobrecarga de
funciones, que es donde tienes
múltiples funciones bajo el mismo nombre pero
diferentes argumentos. Y te voy a mostrar
por qué querrías hacer eso con un ejemplo aquí. Así que vamos a seguir adelante y crear una función para sumar
números juntos. Entonces abajo aquí,
vamos a decir int. Y luego NR paréntesis, diremos int x coma
y, así como así. Y luego en nuestro bloque de código aquí, diremos return x plus y También sigamos adelante y
pongamos nuestro
prototipo de función en la parte superior. Entonces simplemente copiaremos eso, lo
pegaremos arriba, y
pondremos punto y coma aquí. Y solo recuerda que si quisiéramos
algunos valores predeterminados aquí, tendrían que subir aquí. Entonces solo copiando y
pegando, no funcionaría. Tendríamos que lanzar
algo como x es igual a 0 e y es igual a 0. Ahora, sigamos adelante y sobrecarguemos esta función para tomar un conjunto
diferente de argumentos. Entonces para hacer eso, vamos
a seguir adelante y simplemente copiar este método y pegarlo
abajo, así como así. Entonces diremos coma y z. Recuerden que podríamos llamar a
esto como quisiéramos. Y luego diremos
devuelve x más y más z Luego copiaremos
esta línea superior aquí, pegaremos arriba y pondremos punto y coma al
final. Y ahí tienes. Ahora tenemos dos funciones
separadas y sus respectivos
prototipos de funciones que tienen el mismo nombre pero
diferentes argumentos. Y a esto se le llama sobrecarga de
funciones. Ahora aquí arriba en nuestra función
principal, puedo decir algo como CL, agregar el nombre de nuestra función. Y en Visual Studio
aquí al menos
se puede ver que tengo dos opciones. Y si paso el mouse sobre
esto, dice más dos sobrecargas. Pero sí me advierte
que ninguna instancia de la función sobrecargada llamada add coincide con la lista de argumentos. Y eso es porque no
puse nada aquí. Pero ahora se puede ver
que tengo una función
add que
toma dos en valores, y tengo una segunda
función add que toma, es decir. Podría decir algo
así como cinco coma cinco. Asegúrate de poner un
punto y coma al final aquí y ejecutar mi código. Y se puede ver que
hemos impreso diez, y eso funciona
bien, no hay problema. Pero también podría arrojar un otro valor entero
ahora y mirar eso. Imprimimos 15. Entonces esta función add es un ejemplo perfecto de cuándo es posible que quieras
hacer algo como esto. Y puedo hacer tantos
de estos como quiera. Entonces entonces podría usar
esta función add para agregar tantas variables enteras
como me gustaría. Otra cosa que podríamos
haber hecho es usar un tipo de datos completamente diferente. Así que vamos a seguir adelante y
copiar nuestro método add aquí nuevo y pegarlos a continuación entre los
otros dos, así. Y en vez de decir
entrar en todos estos, vamos a
seguir adelante y decir flotar. Entonces seguiremos adelante
y copiaremos nuestra línea superior. Pégalo aquí arriba para
crear un prototipo. No olvides el
punto y coma al final. Y ahora puedo poner en
flotar variables en esto
funcionaría bien. Como si fuera como una coma 5.5
3.3 o algo así. Y ejecuta nuestro código. Ahora vamos a obtener 8.8,
así como así. Así que eso es bastante ordenado. Y esto es una vez más un ejemplo perfecto de cuándo
querrías usar la sobrecarga de
funciones, porque ahora puedo tener una
función que acaba de llamarse add. No tengo que recordar un montón de nombres de
funciones diferentes. Y puedo lanzar carrozas,
podría lanzar una pulgada. Y también puedo tener
diferentes cantidades de números o variables
que tiraría ahí dentro. Y no voy
a tener
ningún problema siempre y cuando haya creado una declaración y definición para cada conjunto de argumentos
que me gustaría usar. Y si quisiéramos, incluso
podríamos haber
dado uno de estos, como el primero
aquí, los valores predeterminados. Entonces aquí arriba, podría haber dicho
x es igual a 0 e y es igual a 0. Y esto también funcionará bien. Entonces ahora no podría tener
nada aquí, o podría haber creado
otra función add que simplemente no tomara
argumentos en ese caso. Pero sí quieres tener
cuidado cuando haces esto, porque si yo hubiera hecho lo
mismo con este de aquí, entonces podría no
saber de cuál estaba hablando en
primer lugar. Entonces, ¿había hecho algo
así hasta el final? Bueno, ahora ya no es seguro lo que estoy
hablando porque ahora esta
llamada a la función add funcionaría para más de una instancia de
la función sobrecargada. Entonces este es un tema otorgado en este caso, todos
están establecidos en 0. Entonces, ¿a quién le importa si
imprimimos 0? Pero va a obtener un
error obviamente. Entonces nuestro código ya no se ejecutará
hasta que solucionemos ese problema. Así que solo quería
darte un aviso sobre eso. De todos modos, eso es todo
para este video. Ojalá ahora tengas
una comprensión de cómo funcionan las funciones
sobrecargadas y cuándo podrías querer usarlas. Gracias por mirar, y te
veré en la siguiente.
67. Capítulo 12 (funciones): recursión: En este video, vamos a estar hablando de algo
llamado recursión, donde algo básicamente se
invoca a sí mismo. Y vamos a estar haciendo
esto con una función que nos
dará el
factorial de un número. Si no sabes lo que es eso, déjame seguir adelante y
mostrarte rápido. Entonces factorial de un número
es algo así. Entonces digamos que le dimos el
número cinco, E factorial 45. Aquí estaría lo siguiente. Sería cinco veces
el número debajo de él. Entonces cuatro veces el
número por debajo de eso siendo tres por dos por uno. Y esto nos daría
el factorial de cinco. Así que básicamente
vas a multiplicar el número que pones
por ese número, uno por debajo de ese, todo el
camino hasta que obtengas el uno, multiplicar estos por completo
y eso te
daría tu factorial. Y en realidad vamos a seguir adelante
y utilizar cinco en el método va a estar creando
sólo para
que sepas que está funcionando correctamente. Entonces, si seguimos adelante y hacemos esto en una calculadora aquí
y decimos cinco veces, cuatro
veces tres por dos por uno, se
puede ver que obtenemos 120. Bien, así que sigamos
adelante y creamos una función que las haga. Ahora hay algunas formas en que
podríamos replicar esto en código, pero vamos a estar
haciendo esto con recursión donde tenemos
algo llamado sobre sí mismo. Entonces, sigamos adelante y
creemos un ejemplo de esto. Entonces abajo aquí, vamos a seguir adelante y
crear un método que
nos dará el factorial de cualquier
número que insertemos en él. Entonces aquí abajo, diremos entrar y llamaremos a
esto factorial. Y luego entre paréntesis,
diremos número. Entonces en nuestro bloque de código aquí, diremos si el número
es mayor que uno, queremos hacer lo siguiente,
que es el número de retorno veces. Y entonces
vamos a
volver a llamar
al método factorial, así. Aquí, diremos
número de menos uno. Y luego aquí abajo
vamos a crear una declaración else como tal y decir else devolver uno. Ahora bien, esto puede parecer
un poco confuso, pero vamos a crear
otro método que haga lo mismo
sin recursión. Y luego voy a tratar
de
separarlos a ambos lo mejor que pueda. Ojalá todo tenga sentido sobre cómo está funcionando esto en
el fondo ahí. Pero primero, sigamos
adelante y creamos nuestro prototipo de función
antes de que nos olvidemos. Entonces simplemente lo pegaré
arriba y tiré un punto y coma. Ahora abajo, esto creará otro método para
decir, n factorial. Simplemente llamaremos a
este factorial dos, por ejemplo, digamos número int. Y este es un
ejemplo perfecto de cuándo posible que solo quieras
darle una variable del mismo nombre que otra, porque es muy legible. No están conectados en absoluto. El alcance terminado está encerrado dentro
de la función, por lo menor. Y luego dentro de
nuestro bloque de código aquí, vamos a decir el
siguiente factorial. Uno. Entonces vamos a crear un bucle for y decir int I es igual a uno, mientras que escucho es
menor o igual al número I más, más. Y entonces
entre corchetes diré tiempos
factoriales
igual a yo, me gusta. Entonces. Entonces fuera de eso, seguiremos adelante y regresaremos. Esto debería hacer
exactamente lo mismo. Entonces, antes de que me olvide, sigamos adelante y creemos un
prototipo de ello así. Entonces, ahora aquí abajo, sigamos adelante y hagamos
un llamado a ambos métodos. Así lo dicen CL línea factorial. Y luego por debajo de esa media
ACL factorial a la línea N. No olvides los
paréntesis aquí, así. Y luego lanzaremos
cinco por ambos. Bien, entonces voy a
alejar las clínicas aquí, ustedes pueden asegurarse de que
su código coincida con el mío aquí. Y sigamos adelante y ejecutemos esto. Entonces como pueden ver, tenemos 120 para ambos bultos, que fue el factorial para el VIH. Ahora bien, en toda la realidad, ninguna de estas
funciones se ve muy mal, pero esto es solo un
ejemplo del uso de la recursión de
funciones
para completar una tarea. Entonces lo que realmente está pasando
aquí bajo el capó ya esto puede parecer un poco confuso que
esto puede parecer un poco confuso
para alguien bueno, antes que nada, dijimos si el número es
mayor que uno, así que si tuviéramos el
ejemplo de cinco aquí, bueno, ¿cinco es mayor que uno? Y la respuesta es sí, lo es. Entonces lo que vamos a hacer
es devolver el número siendo cinco veces el factorial
del número por debajo de él. Lo que esto va a
devolver un entero. Pero cuando ese corre a través, va a decir que es para
mayor que uno. Sí lo es. Entonces ahora queremos cuatro veces
el número por debajo de eso, y eso va a
seguir sucediendo hasta finalmente lleguemos a un
punto donde el número es uno. Y entonces sólo
va a devolver ¿qué? Hay que asegurarse de que
finalmente tengo esta recursión aquí, nos detendremos y que esto
no sucederá infinitamente. De lo contrario, sin
entrar en demasiado de los detalles aquí se están metiendo
demasiado en las malas hierbas aquí. Te quedarás sin memoria
y vas a tener algunos problemas porque
estás creando una, otra función dentro de una
función, dentro de una función. Y esto simplemente se
acumula y se acumula, y luego eventualmente
te encuentras con problemas. Entonces, sigamos adelante y echemos un
vistazo a lo que está sucediendo. Entonces, para hacer esto,
sigamos adelante y comencemos con el último caso. Entonces al final de todo esto, vamos a tener una
función que diga, bueno, queremos volver dos veces uno, porque eso será lo que
vuelva de la función aquí. Una vez que esto es igual a uno, porque el número
no es mayor que uno, porque sería uno, devolverá uno. Por lo que al final estará
regresando dos veces una. Entonces la función que
estaba tratando de obtener el resultado de esta
ecuación aquí, bueno, tengo tres veces, tres por dos, que luego
bajó a dos, uno. Entonces la función por encima de eso. Tendremos cuatro por
tres, así. Y eventualmente tendremos nuestras cinco veces el
resultado de todo esto. Así que esencialmente ahora tenemos la función que
acaba de devolver una. Entonces tenemos una segunda función
que hizo esto matemático aquí, un tercio que una cuarta
quinta función. Entonces ahora creé cinco funciones solo con solo insertar
estas cinco aquí. Y entonces lo que va a pasar
es esa primera función, sólo
vamos a devolver una. El segundo
devolverá un valor de dos, el siguiente un valor
de seis y luego 24. Y por último, cinco veces
24 nos da 120. Entonces ahí tienes. Así es como obtuvimos
nuestra respuesta final. Ahora, ojalá eso tuviera sentido. Si no, siéntase libre de simplemente ir
en línea y buscar más en la recursión y otros
ejemplos y trabajar con ella y realmente
desglosar lo que está sucediendo. Ahora, como dije, sí
quieres tener
cuidado de que no estés creando demasiadas funciones
cuando haces esto. Y también quieres
asegurarte de que esto
no va a suceder infinitamente por la misma razón que en algún momento te quedarás sin
memoria. Entonces en este caso, este de aquí fue nuestro punto de parada donde una vez el número
ya no era mayor que uno, solo volvimos a uno. Y este punto de parada
aquí se llama tu caso
base cuando se trata de
recursión. Entonces ahí tienes. Ojalá ahora tengas
una comprensión básica de qué función es
la recursión y sabes cómo usarla
y cosas de las que tener cuidado al usarla de todos modos. Entonces eso es todo para este video. Gracias por mirar, y te
veré en la siguiente.
68. Capítulo 12: Arrays como parámetros: En este video,
vamos a estar hablando pasar arrays como argumento. Pero antes de hacer eso, sí
quiero mencionar una cosa. Así que ya hemos hablado de tipos y funciones de
retorno, pero sí quiero hacértelo saber
una vez que tengas esta declaración return
y pases algo de vuelta al color, lo que sea que esté llamando a
tu función, no
se va a ejecutar ninguna contraseña de código. Entonces es como simplemente salir
de la inocencia. Entonces aquí mismo,
voy a decir CL, hola, así,
y ejecutar nuestro código. Ni siquiera va
a leer eso. No va a
imprimirlo porque
ya hemos tenido una declaración de devolución. Entonces, cuando crees una función
que tenga un tipo de retorno, ten en cuenta que una vez que tengas
una sentencia return, va a dejar de leer el código y tu función
y simplemente volver a la persona que llama o al lugar donde llamas a tu función
en primer lugar. Entonces, si tienes múltiples declaraciones
if o
algo así, podrías tener múltiples declaraciones de
devolución y eso funcionará bien. Solo quería
avisarle sobre eso,
que una declaración de retorno también
podría verse como una declaración break
que devuelve un valor. Entonces, sigamos adelante
y echemos un vistazo a cómo se
pasan los arrays como argumentos. Primero, sigamos adelante
y creamos una matriz. Así que vamos a establecer mi matriz
entre corchetes aquí. Simplemente le dará a esto
una talla de cinco. Y vamos a seguir
adelante y darle cinco valores de
inmediato aquí. Entonces diremos 1234. Y luego sigamos
adelante y creamos una función que
imprima una matriz. Entonces vamos a decir void, print array, así, luego ingresamos paréntesis aquí, crearemos un parámetro que tome una matriz como argumento. Así que todavía tendremos que tener
el tipo de datos como normal. Entonces tendremos un nombre
aquí con el que queremos
trabajar dentro de nuestra
función como de costumbre. Y entonces tendremos corchetes abiertos y
cerrados para significar que se trata de una matriz
y no solo de un entero. Y luego abajo, seguiremos adelante y crearemos nuestro bloque de código aquí
para nuestra función. Entonces aquí abajo,
continuaremos e
imprimiremos todos los
elementos de nuestra matriz. Entonces vamos a decir para yo es igual a 0, yo menos de cinco, yo más, más. Y luego
entre corchetes era un CEO. Y entonces nuestro nombre de
parámetro siendo ARR que n
corchetes dirá, voy a crear una nueva línea. Y ahora si aquí arriba en
nuestra función principal, que también podrías
mirar como nuestro color, ya que es lo que va a estar
llamando a nuestra función PrintArray. Podemos decir print array y luego entre paréntesis
solo pasa en mi matriz. Así puedo poner punto y coma. Observe que no
ponemos ningún corchete aquí en nuestro argumento
ni ningún número. Ahora antes de ejecutar un código, simplemente
necesitamos hacer un prototipo de función aquí en la parte superior y seguir
adelante y ejecutarlo. Se puede ver que lo
imprimimos 12345. Ahora bien, fíjate que
seguimos adelante y pusimos el tamaño aquí mismo explícitamente. Y esto no es genial
porque no es muy dinámico. Pero el problema es
que no podíamos poner una talla como nuestro argumento aquí. Entonces, para arreglar esto, lo que querrías hacer es decir coma en tamaño o
algo así. Recuerda, puedes nombrar
esto como quieras
y luego poner
menos de tamaño aquí. Y aquí arriba, queremos
cambiar nuestro prototipo. Y luego ponemos el
tamaño aquí mismo. Y esto funcionaría simplemente alto. Como puedes ver,
imprimimos 12345. Y esta aquí es la
mejor manera de pasar una matriz como argumento,
ya que al tener la
matriz y luego estos dimensionan ya que al tener la
matriz y luego estos dimensionan una variable separada ya esta va a funcionar y
dinámicamente ahora. Entonces ahora si establecemos nuestra
matriz va a tener un tamaño de siete, por ejemplo. Y luego estoy aquí. Tenemos dos elementos más así y los cambiamos aquí. Nuestra función seguirá
funcionando como queremos que funcione. Ahora algo que
puedes hacer es poner una talla aquí mismo, así. Y esto también va
a funcionar bien. El problema es con
hacer esto es que si nuestro tamaño de matriz cambia aquí, no
podrás acceder a estos otros valores porque no
sabrá de qué
estás hablando. Entonces si aquí abajo, dije CL están siendo el
nombre de nuestro parámetro aquí, y luego poner siete, por ejemplo y ejecutar nuestro código. Se puede ver que obtenemos una respuesta realmente
extraña. Y eso es porque en lo que a él
respecta, nuestra matriz tiene un tamaño de cinco. ¿Podemos simplemente pedir
el séptimo elemento y no vamos a entrar
realmente en por qué sucedió esto? Pero solo debes saber que a
pesar de que esto era posible, lo que hicimos antes donde
acabamos de tener un tamaño en blanco aquí. Y entonces una variable de
tamaño separada es la mejor manera de hacerlo. Ahora la otra cosa
interesante usar una matriz
como parámetro ya que en realidad se pasa por referencia y nos
meteremos en referencias más adelante. Pero básicamente, cuando
estábamos trabajando con, con variables como parámetros, se pasaba por valor y
estábamos creando una copia del mismo. Lo demostré en
un video anterior, pero con arreglos,
se pasan por referencia. Y eso es porque N C
plus plus no puedes pasar una matriz por valor y
crear una copia de la misma. Y no vamos a
entrar en por qué es eso, sino esencialmente porque esto
se pasa por referencia, en realidad no
estamos creando
una copia de esta matriz, y esencialmente estamos trabajando
con la matriz directamente. Entonces ahora, si decía ARR
indexado 0 equivale a diez, así al final de
nuestra función aquí, y luego imprimirla. Mi matriz indexa 0, así, y ejecuta nuestro código, puedes ver que
imprimimos diez. Y eso es porque a
pesar de que estábamos trabajando con nuestro nombre de
parámetro aquí, porque las matrices se
pasan por referencia. Como dije, entraremos en
referencias en un futuro video. Esencialmente somos
capaces de trabajar con el original en
lugar de con una copia del mismo. Entonces, si cambiamos algo
aquí con nuestro perímetro, también
estamos cambiando el
original. Entonces básicamente lo principal que
quiero que te lleves
de este video es que si quieres usar una
matriz como parámetro, vas a
hacerlo lo siguiente. Vas a tener
el tipo de datos de arrays seguido de un nombre con el que
quieras trabajar. Y luego solo usa tus
corchetes para significar que es una matriz. Querrás tener una variable
separada para el tamaño real de esa matriz. Y también las matrices se
pasan por referencia, es
decir que cuando cambiemos algo usando nuestro nombre de
parámetro aquí, también vamos a estar
cambiando el original. Entonces haciendo algo de planeación, esto cambia el original
ya que esta aquí no es una copia como esta como cuando se trabaja
con otros tipos de datos. Entonces solo para mostrarte eso otra vez, si dijimos x es igual a siete y luego pasamos x como
nuestra variable entera, y luego cambiamos
el valor de tamaño aquí diciendo tamaño más, más, y luego imprimir
fuera x aquí abajo. Sigamos adelante y echemos eso en una nueva línea para que sea
un poco más obvio. Se puede ver que
todavía tenemos siete. Y eso es porque
otros tipos de datos cuando se usan como argumento
se pasan por valor. Y por lo tanto el tamaño
aquí es solo una copia de ese valor y no tendrá
ningún efecto sobre el original. Pero una carrera específicamente
se pasan por referencia, lo que básicamente significa que
vamos a estar trabajando con el original y no
creando una copia en absoluto. Entonces cuando nos metíamos con
nuestro perímetro aquí, también
estábamos metiendo
con el original. Ojalá eso tuviera sentido. Si no, no te preocupes por ello, en realidad
estaremos hablando referencias en el siguiente video. Entonces, lo único que realmente
necesitas quitar de este video es cómo tomar
una matriz como parámetro. Primero, quiere decir que
está tomando una matriz usando los corchetes junto con el tipo de datos de esa matriz, y le dará ese nombre de
parámetro como de costumbre, luego necesita tener un
variable por el tamaño de la misma porque no puede ser aston
con el argumento aquí. Entonces solo tenemos que
ponerlo por separado. Y por último, solo
sepa que las matrices específicamente se pasan
por referencia, lo que significa que si te metes
con el parámetro aquí, esencialmente
estás
metiendo con el original. De todos modos, espero que hayas disfrutado. Gracias por mirar, y te
veré en la siguiente.
69. Capítulo 13 (Referencias): introducción a las referencias: En este video,
voy a estar dando una breve introducción
a las referencias. Bien, así que
referencié es un alias u otro nombre para otra
cosa. Entonces, por ejemplo, mucha
gente tiene apodos. Entonces digamos que tu
nombre era Jonathan. La gente podría llamarte John, y se están refiriendo
a lo mismo. Entonces en este ejemplo, John estaría en una
referencia a Jonathan, estábamos hablando de
la misma persona. Y eso es básicamente
lo que es una referencia en C plus plus también. Entonces, por ejemplo, podríamos
tener un entero llamado x, y digamos que
es igual a 0. Y entonces podríamos
tener una referencia llamada apodo o
algo así. Apenas como un terrible ejemplo, eso es igual a x. Y ahora solo podemos decir que
x es apodado aquí, y vamos a estar
hablando de lo mismo. Y si establecemos x apodo
igual a cinco más adelante. Entonces si aquí abajo dije
x apodo es igual a cinco. Ahora x equivaldría a
cinco porque me refiero exactamente a lo
mismo. Entonces una referencia es solo un alias u otro
nombre para otra cosa. Y entraremos en
algunos ejemplos, así
como cómo crear uno para sí misma en los próximos
videos y veremos algunos de los diferentes casos de
uso para
referencias para que sepas cómo para utilizarlos en
tus propios programas. modos, espero
que todo esto tenga sentido y como siempre, gracias por verlo y nos
vemos en la siguiente.
70. Capítulo 13 (Referencias): cómo crear una referencia: En este video,
vamos a estar creando una referencia básica. Entonces echemos un
vistazo a cómo ha ido esto. Entonces la sintaxis para nuestra
referencia es la siguiente. Primero vas a
tener el tipo de datos. Otra cosa a la que
estarás haciendo referencia. Entonces vas a dar
seguimiento a eso con el símbolo ampersand como SO, seguido del nombre
de la referencia. Y luego lo pondrás igual
al nombre de referencia, que es una cosa a la que
te estás refiriendo. Bien, así que vamos a seguir adelante y en realidad crear
uno aquí mismo. Diremos int x es igual a cinco. Y luego por debajo de eso, diremos int ampersand. Y a esto le llamaremos X igual a X. ¿Bien? Entonces tenemos el
tipo de datos de la cosa a la que nos
referimos que sostiene
el símbolo ampersand, luego el nombre de nuestra referencia. Y puedes llamar a esto como
quieras, seguido del nombre. Ahora si recuerdas
en el último video, dije una referencia, así que solo hay un alias para hablar
de lo mismo. Entonces ahora podemos usar rayos X
o nuestro nombre de referencia aquí para hacer cualquier cosa con x que pudiéramos simplemente
diciendo x. Y así eso significa aquí abajo, podría
decir algo
como x ref es igual a diez. Y si seguimos adelante
e imprimimos x ahora, así, va a imprimir diez. Y podríamos haber
incluso simplemente
imprimirlo están referenciados directamente. Y esto también
imprimiría diez. Entonces una referencia como solo un alias u otro nombre para lo
que se refiere. Esto y esto son
esencialmente lo mismo. Ahora, también una cosa que
sí quiero mencionar
es que no se puede declarar una referencia y
luego inicializarla después. Se necesita hacer
en la misma línea, similar a cómo funcionan las constantes, por ejemplo,
porque tampoco puedes cambiar tu referencia
posteriormente tampoco. Entonces si dije y es igual a diez, ¿no puedo cambiar x ref
para que sea igual a qué? Bueno, podría decir
extra es igual a y, pero esto en realidad
solo cambiaría x Esto no sería un
apodo para y ahora, y se puede ver eso
por si imprimo x ref y x aquí abajo
en la misma línea, y luego
crearemos una nueva línea. Entonces cambiaremos
y para ser iguales a 15. Y luego aquí abajo diremos C out e imprimiremos extra. ¿Por qué? Al igual que si
ejecuto mi código aquí, se
puede ver que
imprimimos diez porque extra se fijó igual
a x, que era cinco. Y luego establecemos x
básicamente igual a y, ahora x es igual a diez. Entonces imprimimos diez porque extra f y x son
lo mismo. Y luego imprimimos
diez de nuevo, porque una vez más, estos dos son esencialmente exactamente lo
mismo ahora, luego cambiamos la y a 15, pero cuando la imprimimos, X ref o x, básicamente todavía eran
diez y y tenía 15, así que imprimimos 15 después. Entonces ojalá eso tenga sentido. Una vez que dijiste me refería
igual a algo, no
puedes cambiarlo. Después de esta línea, nuestra
referencia está engastada en piedra. Extra siempre será el
equivalente de x y viceversa, que es y, x cambiará el diez cuando cambiemos x ref el tiempo. Bien, entonces ahí tienes. Así es como se crea
una referencia básica. Todo lo que vas a hacer es decir el tipo de datos de la cosa a la
que quieres referirte, seguido del símbolo
ampersand, entonces tendrás el nombre de tu referencia y
podrás llamarlo como sea
que te gustaría. Y entonces tendrás la cosa a la que se va a referir. Y ahí lo tienes de todos modos. Gracias por mirar y te
veré en la siguiente.
71. Capítulo 13 (Referencias): referencias y bucles para foreach: En este video,
vamos a estar
hablando de referencias una vez más, pero vamos a estar
hablando específicamente usar referencias
con para cada loops. Entonces, sigamos adelante y
echemos un vistazo a eso. Primero, vamos a
crear una matriz entera. Así que vamos a decir int mi matriz, entonces vamos a tener algunos
corchetes aquí. Y luego después de eso, vamos a seguir adelante y tirar algunos números. Entonces di uno, coma dos. Bien, entonces tenemos una matriz
int de tamaño cinco con cinco valores diferentes. Recuerda, si quisieras,
podrías ponerlo aquí también. Entonces es más fácil de leer. Cuántos valores
hay en tu matriz, pero no es necesario. A continuación, sigamos adelante e
imprimimos todo a nuestra derecha y nuestro bucle foreach como lo hemos hecho en el pasado. Y me disculpo por usar los mismos ejemplos una y
otra y otra vez en
múltiples videos. Pero el punto es, es solo introducir
una cosa nueva a vez para que ustedes puedan entender
mejor todo. Bien, así que aquí mismo,
vamos a crear un para cada bucle y diremos cuatro. O podríamos decir auto,
si recuerdas, ya que queremos el mismo tipo de datos
de nuestro contenedor de todos modos, y luego diremos x
dos puntos mi matriz, así. Y luego entre corchetes,
pondremos nuestro código, así que digamos CL x, y crearemos una nueva
línea después de igual manera. Ahora bien, si ejecuto nuestro código aquí, se
puede ver que esto
está funcionando bien. 12345. Ahora bien, si quisiéramos cambiar el valor es normalmente
de las cosas en nuestra matriz, no
funcionaría. Y eso es porque X es sólo
una copia de estos valores aquí. No podemos decir algo
así como x es igual a cinco y esperar que cambie los valores reales
de estos índices. Entonces, si ejecutamos nuestro código, se
puede ver que sólo
vamos a imprimir 55 veces. Y luego si volviéramos a
imprimir nuestra matriz, así que si copiamos esto aquí mismo
e imprimimos eso nuevamente, y simplemente eliminaremos
esta x es igual a cinco líneas. Verás que
esto no va a cambiar. Entonces lo imprime 55 veces, luego lo imprime 12345 siendo los valores
almacenados en nuestra matriz. No obstante, si hacemos de
esto una referencia a nuestro array u otro
nombre para nuestra tarifa, si lo hicieras, esto funcionará. Entonces todo lo que tenemos que hacer
es después de auto aquí, vamos a lanzar
el
símbolo ampersand así como así. Y ahora x será una referencia real a estos valores, lo cual
es bastante ordenado. Entonces si ejecutamos nuestro código, de nuevo, se
puede ver que
imprimimos 510 veces porque a medida que recorría, X era en realidad lo mismo que cada una de estas
variables aquí. Y aunque mencioné en el último video que no se puede cambiar una
referencia, lo que realmente está sucediendo aquí es que cada vez que
recorre nuestro código, o para cada bucle está creando
una referencia llamada x, estableciéndolo igual al índice
0 la primera vez. Y luego ejecutando este código, voy a crear
otra referencia llamada x y ponerla igual al índice uno. Y pasa por
orden, así como así, creando una nueva
referencia cada vez que ya no existe
después de nuestro bloque de código. Así que no te preocupes por
nada ahí. Y porque es una referencia, somos capaces de cambiar
los valores originales. Ahora la otra gran
cosa de las referencias es que
debido a que estamos trabajando
con el original, no
estamos creando una copia que
pueda llegar a ser realmente costosa. Entonces, por ejemplo, si acabo de
inicializar cada valor en mi tasa a 0 y luego tuve
una matriz de tamaño mil. Esto va a funcionar bien. Y si corría, esto se imprimiría mil valores. Pero debido a que esto se
pasó por referencia, solo
cambias el valor
y lo imprimiste. Sin embargo, cómo no pasamos
por referencia, como lo hicimos aquí. En realidad, entonces
tuvimos que crear una copia de todos los mil valores
y luego imprimirlo. Y ahora mismo estamos
trabajando con enteros, y esto es
lo único en nuestro programa, así que no estuvo tan mal. Pero cuando se trabaja con tipos de datos
más grandes y
más información, esto puede llegar a ser realmente costoso. Entonces hacer algo como esto
aquí es más eficiente. Entonces hay otro
ejemplo de cuándo usar una referencia y cómo pueden
trabajar con para cada loops. De todos modos, eso es todo
para este video. Gracias por mirar, y te
veré en la siguiente.
72. Capítulo 13 (Referencias): referencias como parámetros: En este video,
vamos a estar
hablando de referencias una vez más, pero específicamente
vamos a estar
hablando de referencias como parámetros. Y si recuerdas
en un video anterior, ya
habíamos trabajado con arreglos que se
pasaban por referencia, pero ahora también vamos
a estar pasando otros tipos de datos por
referencia. Entonces, sigamos adelante y echemos
un vistazo a cómo se hace eso. Primero, seguiremos adelante y crearemos una variable entera aquí. Entonces digamos int num uno es igual a cinco. Y luego debajo de eso,
sigamos adelante e imprimimos el num uno,
así como así. Entonces aquí abajo, crearemos
un método y diremos void, lo que significa que no
necesitamos un tipo de retorno. Y diremos set en
diez, por ejemplo. Y luego entre paréntesis
tomaremos un entero y
solo lo llamaremos x Dentro de aquí,
diremos texto es igual a diez. Y luego crearemos un prototipo
para nuestra función arriba. Así que no olvides el punto y coma. Y entonces todo lo que tenemos que hacer es tener una llamada a nuestra
función aquí. Estamos diciendo set a diez. Los paréntesis abiertos y cerrados
pondrán num uno dentro y un
punto y coma al final. Y si ejecutamos un código, va a imprimir cinco. Y eso es porque
otros tipos de datos fuera de las matrices
se pasan por valor. Es decir, cuando pusimos aquí num
uno como nuestro argumento, x era igual al valor
de num uno siendo cinco. Entonces dijimos esencialmente
cinco es igual a diez. Bueno, eso no
cambió en absoluto al num uno. Entonces es por eso que cuando lo
imprimimos en uno, todavía estaba bien. Pero si pasamos por
referencia poniendo el ampersand delante
del tipo de datos aquí. Y tenemos que hacer eso
en nuestro prototipo también. Bueno, ahora x es un
apodo o un alias, o una preferencia, o como
quieras
llamarlo para num uno. Entonces cuando nuestro código se
ejecutó,
dijimos, bien, vamos a crear una
referencia llamada x y establecerla igual a lo que se
pasa en ser uno entumecido. Entonces esencialmente dijimos que
num uno es igual a diez. Entonces cuando ejecutamos nuestro código
y ahora num uno es diez, y eso es porque x era una referencia a
lo que pasamos adentro. Entonces ahí tienes. Así es como puedes usar
referencias como parámetros. Ahora bien, esto tiene el mismo beneficio que tuvo para
cada loops donde eso, cada vez que esto transcurra, va a crear una
nueva referencia y
ponerla igual a
lo que sea que pasemos. Entonces la próxima vez que llamemos a esto, si dijimos num dos es igual a
tres por ejemplo. Y luego copiamos nuestro método llamar
aquí mismo y poner en dos. Entonces sigamos adelante
e imprimimos un espacio seguido de dos. Ambos se establecerán iguales a. Y eso es porque cada
vez que lo atraviesa, crea una nueva
referencia llamada x y tal igual a cualquier
argumento que pasemos adentro. Entonces x en realidad no se está cambiando a una referencia
diferente. Es una
referencia completamente nueva llamada x, y entonces eso ya no existe
una vez que termina este bloque de código. Entonces por eso eso funciona. Ahora bien, lo que sí quiero
mencionar es que puedes pasar
algo aquí por la eficiencia y te
aseguras de que no
cambies ese valor. Entonces, digamos por ejemplo, estamos pasando en todo un libro de texto y este método
fue imprimirlo. Bueno, no quisiéramos
crear una copia completa de ese libro de textos cada
vez que ejecutamos este método. En cambio,
probablemente querríamos hacer algo como esto
donde solo trabajamos con el mismo libro de texto y luego
asegurarnos de que no
editamos ese texto a través del
error del usuario en nuestro bloque de código aquí, todos nosotros tener que hacer es decir const. Y esto evitará que nos
metamos ahora con esta
variable al decir:
Oye, esto no es modificable. Y así eso solo
evitará cualquier error de usuario de tu parte o cualquier otra persona que pueda editar tu código. Será muy
obvio que oye, solo
quería una referencia
a mi variable, pero no quería realmente
cambiar esa variable en. Entonces no importa lo que ponga
en este bloque de código, eso no me va a dejar
meterme con eso ahora. Entonces puedes usar la palabra clave
const para crear una constante aunque
sea una referencia, solo para asegurarte de que hey, no
puedes modificar esto. Yo solo quiero que esto se
lea solo básicamente. Y eso
esencialmente te permitirá la eficiencia sin la capacidad de
cambiar el original. Entonces eso es genial. De todos modos, eso es todo
para este video. Solo quería
mostrarles cómo pueden usar referencias con parámetros. De todos modos, como siempre,
gracias por mirar, y te veré
en la siguiente.
73. Capítulo 13 (Referencias): referencias como tipos de retorno: En este video, lo siento mucho, pero estamos hablando de
referencias. Una vez más. Sin embargo, esta vez
estamos hablando referencias como tipos de retorno. Entonces, sigamos adelante y echemos
un vistazo a cómo se hace eso, así
como el caso de
uso real para esto. Entonces, lo que vamos a hacer es crear una matriz int para empezar. Vamos a llamar a
esto mi matriz, y pondremos esto igual
a 12345, así como así. Y vamos a seguir adelante
y decir explícitamente, Oye, aquí tenemos altos valores. Bien, ahora abajo de esto, sigamos adelante e imprimimos
todo en nuestra matriz. Dirá para auto x, dos puntos mi matriz, así como así. Y los corchetes de tinta. Seguiremos adelante y X en
una nueva línea cada vez. Así que vamos a crear algún espacio
en blanco entre esos porque vamos a
estar poniendo algo aquí en tan solo un momento. Y luego aquí abajo, sigamos
adelante y creamos nuestra función real o
un método, si así lo harías. Entonces vamos a hacer es decir, seguido del símbolo
ampersand. Y luego diremos establecer el valor así como así para
el nombre de nuestra función. Y luego entre paréntesis aquí, sólo
vamos a tomar
un entero, así secante x Entonces tendremos
algunos corchetes. Y entonces aquí mismo,
vamos a decir que gire mi matriz índice X.
Y sigamos adelante
y en realidad llamemos a eso solo trazo para índice. Ahora, notarás que
obtenemos un error porque nuestra matriz no está definida. Entonces, lo que realmente tenemos
que hacer es tomar nuestra matriz aquí y lo
pondremos fuera
de cualquier función como esa. Entonces también vamos a
copiar nuestro método aquí, o la línea superior del
mismo, debería decir, para nuestro prototipo
así como así. Y ahora lo que vamos a hacer es en realidad vamos a
poner el texto a continuación, estamos imprimiendo aquí y
seguir adelante y copiar nuestro bucle foreach y
pegarlo abajo, así. Y luego entre aquí, realidad
vamos a cambiar
los valores de r, ¿verdad? Entonces, debido a que nuestra función tiene una referencia como
su tipo de retorno, realidad
podemos usarla
en el lado izquierdo de una expresión o una
instrucción de asignación en este caso. Y ya verás a lo que me
refiero aquí en tan solo un segundo. Entonces vamos a decir valor establecido. Y luego entre paréntesis, pondremos el índice
que queremos cambiar. Entonces sigamos adelante y cambiemos
esos segundos de aquí. Entonces diremos uno,
porque recuerden, los índices para contenedores
comienzan en 0. Entonces vamos a estar cambiando
este valor aquí mismo. Y entonces
simplemente podemos decir iguales. Sigamos adelante y cambiemos
otro justo debajo de eso. Entonces diremos algún valor del
índice cuatro igual a cinco. O sigamos adelante y
cambiémoslo a algo así como 33. Así que sigamos adelante y echemos un vistazo a todo
nuestro código aquí. Primero, creamos
una matriz fuera de cualquier función para que estuviera disponible
globalmente en este caso, luego tuvimos nuestro prototipo de
función. Y si bajamos a
nuestra función aquí, lo que hicimos es que teníamos un tipo de retorno de referencia
int y nuestra función se llamaba set value y tomó un entero. Y entonces lo que
hicimos es que devolvimos una referencia entera
del índice especificado para
esta matriz específica. Entonces todo aquí a
la izquierda también puede haber dicho int referencia, llámalo graph por ejemplo, es igual a mi matriz índice uno. Y esto hubiera sido
exactamente lo mismo, y lo veremos en un segundo. Entonces, si ejecutamos nuestro código aquí, lo que vamos a hacer es
imprimir del uno al cinco, y luego imprimimos uno. Nuestro segundo índice se
cambió a 1034, y luego nuestro último índice, o nuestro elemento en el índice 4. Quinto elemento,
sin embargo se quiere mirar se fijó en 33. Entonces ahí lo tienes. Y habría hecho
exactamente lo mismo si hubiéramos seguido
adelante y tomamos esto
aquí mismo y borramos eso. Y luego abajo de eso dicho es igual a diez porque en realidad
necesitamos cambiar el valor aquí
y luego ejecutar nuestro código. ¿Mirarías eso, exactamente
el mismo resultado? Entonces ahí tienes. Déjame seguir adelante y deshacer eso muy rápido. Entonces como pueden ver, diciendo, esto era esencialmente lo
mismo que decir esto, junto con decir
aliento equivale a diez. La única diferencia
aquí es que ya que somos capaces crear una referencia
a él alguna vez índice lo
queremos simplemente devolviendo una referencia e insertando
el índice que queremos. Y luego porque teníamos una
referencia como tipo de retorno, puedes usar
nuestra función aquí en el lado izquierdo
de la expresión. Entonces dijimos, Oye, cambiar mi matriz
esencialmente en el índice 12, que
también podrías haber visto como diciendo mi índice de matriz uno es igual a diez, que en este caso al
menos
habría sido un mucho más simple. Pero solo quería
mostrarte cómo funciona el uso de
referencias como tipos de retorno. Básicamente, solo
te permite devolver
una referencia igual a
lo que pongas en la devolución aquí. Así que nuestra referencia entera era
igual a mi matriz, lo que sea. Entonces ahí tienes. Eso es un uso de referencias
como tipos de retorno. Pondrás el ampersand después
del tipo de datos del tipo de retorno, tanto en tu declaración
como en tu prototipo, y luego devuelves lo que
quieres que sea una referencia. Entonces ahí lo tienes. Entonces termina este video. Déjame mostrarte cómo
acabo de crear una referencia a un entero en
nuestro método aquí. Entonces si seguimos adelante y
quitamos todo esto aquí, y llamaremos a nuestro método renta. Y nosotros haremos lo mismo aquí abajo. Y entonces
en realidad vamos a seguir adelante y quitar el argumento de ambos. Entonces tenemos algo que ahora
se ve así, y luego volveremos x. Y para definir a continuación, vamos a crear una variable
global X. Así que ahora tenemos una variable llamada x, no se establece en nada. Pero si quisiéramos,
podríamos fijarlo en 0. Y aquí, y nuestra función principal, vamos a decir envolviendo el nombre de nuestra función y luego
abrir y cerrar paréntesis, ya que no
tenemos ningún argumento para pasar y ponerla igual a diez. Y luego
abajo, diremos x. Entonces, ¿qué va a hacer esto? Primero, creamos una variable
global llamada x, y luego dentro de
nuestra función principal, tenemos una llamada a nuestra función creada por el usuario
llamada renta por ira. Y lo que esto
va a hacer es devolver una referencia entera a x Ahora ten en cuenta, esto
no tiene nombre, así que no podríamos usarlo más tarde realmente, pero seguirá funcionando
para este caso de uso
. Entonces dijimos que volviéramos
por referencia, lo que nos da una referencia
entera a X. Así que ahora bien podría ser x. Así que esto era lo mismo
que decir x es igual a diez, básicamente porque creamos
un global variable llamada x. Y luego cuando llamamos a
nuestro método aquí, devolvió una
referencia entera a x. Así que esto también puede ser x, y establecemos eso igual a diez. Ahora, cuando lo
imprimimos, x, x tenía diez. Y si ejecutamos nuestro código, se
puede ver que ese es
el caso. Entonces ahí tienes. Ojalá ahora tengas
una comprensión de cómo usar las referencias
como tipos devueltos. Básicamente te permite devolver
directamente una referencia. Y el caso principal para eso es que puedes usar tu método aquí en el lado izquierdo de
una declaración de asignación. Entonces ya has visto cómo
hacerlo tanto con una variable como con un
contenedor como una matriz. De todos modos, eso es todo
para este video. Gracias por mirar, y te
veré en la siguiente.
74. Capítulo 13 (Referencias): direcciones de la memoria: En este video,
voy a estar dando un desglose de lo que
las referencias están haciendo
realmente en
segundo plano como
una especie de introducción
a nuestro siguiente tema en este curso siendo punteros. Y ya verás por qué
hice este video una vez que
nos metamos en eso. Pero por ahora, sigamos
adelante y solo centrémonos en el desglose de lo que
realmente está sucediendo
con las referencias. Entonces para hacer eso, lo que
vamos a hacer es crear una
variable entera llamada x y ponerla igual a
cinco, por ejemplo. Y luego voy a seguir adelante
y añadir algunos comentarios aquí. Entonces esto es solo una variable int. Y luego debajo de eso, vamos a
imprimir la dirección
de memoria de nuestra variable entera. Y podemos hacerlo con
este símbolo ampersand seguido del nombre, nuestra variable, y luego
imprimiremos una nueva línea. Entonces esto de aquí
va a imprimir la dirección de memoria de x. Y si ejecutamos nuestro código aquí, se
puede ver que eso
es lo que sucede. O al menos solo confía en mí, esta es la dirección
de memoria de x. Sé que parece una locura. No te preocupes, no
tienes que
descomponer esto ni nada y
averiguar qué es todo eso. Sólo sé que así
es como podemos obtener la dirección de memoria de
una variable, bien, Ahora bien, si creamos una referencia a x, así que si dije ampersand, y simplemente llamaremos a
este href es igual a x. la dirección de memoria de
una variable, bien, Ahora bien,
si creamos una referencia a x,
así que si dije ampersand,
y simplemente llamaremos a
este href es igual a x.
luego imprima ampersand ref para obtener la dirección de
memoria de rep. Así crearemos
una nueva vida para esa también y
luego ejecutaremos nuestro código. Se puede ver que estos
son exactamente los mismos. ¿Bien? Entonces aquí mismo creamos una x de referencia y luego
imprimimos la dirección de memoria. Nuestra siguiente referencia. Como viste cuando
estábamos en un código, estos son exactamente los mismos. Y eso es porque
como dije antes, una referencia es esencialmente solo otro nombre para
exactamente lo mismo. Nada es diferente. Comparten la misma ubicación
exacta de memoria y comparten el mismo valor. El índice de respiración que imprimió normalmente solo
ambos imprimirían cinco. Y para realmente llevar ese punto a casa que
son lo mismo. Te voy a mostrar
una última cosa aquí con usarlo como argumento. Y sé que hemos hablado de
esto un poco en el pasado, pero sólo voy a mostrarte
una cosa más sobre eso. Entonces, si dijiste x es igual a cinco, y luego por debajo de ese crédito
una referencia a expertos en ampersand, ref es igual a x. luego sigamos adelante y
creamos un método aquí abajo, y diremos void,
cambia int num. Y en nuestro bloque de código aquí, diremos num es igual 22 y necesitamos hacer
un prototipo de esto. Yo sólo lo
pondré aquí, así. Y ahora si seguimos adelante y los métodos de
color no
cambian la ira. Entonces vamos a pasar en
nuestra referencia real a x, c out, breath. Al igual que ¿qué crees que
va a pasar? Bueno, sigamos adelante y veamos si va
a imprimir cinco. Y eso es porque como dije, una referencia y lo a lo que se refiere o a lo que se
refieren son lo mismo. Así podemos pasarlo
así como cortamos la variable original y todavía no se va
a cambiar. Ahora, ¿cómo tomamos una, una referencia como parámetro aquí, como lo hemos hecho en el pasado, entonces sí, cambiaría a 22. E incluso podríamos haber
pasado una x aquí y seguirá cambiando a 22 porque como dije,
son lo mismo. Puedes usarlas del mismo
color blanco. Entonces ahí tienes. Solo que realmente quería
llevar ese punto a casa que una referencia y la referencia
son exactamente lo mismo. Se pueden usar exactamente de
la misma manera, pero es solo un apodo para
lo que sea a lo que se refiera. Incluso comparten
exactamente el mismo valor con nuestra impresión aproximada o x. Es lo
mismo e incluso comparten la misma ubicación en la memoria. Y como dije, el
motivo de este video, aparte de
mostrarte cómo obtener la dirección
de memoria de una variable. Y que podrías simplemente
echar aquí la referencia sin cambiarla porque
te quedaste con la variable, no
hubiera tomado esto esa
referencia era para prepararte para lo que vamos a
estar hablando en la próxima serie de
videos siendo punteros. Entonces ojalá eso tenga
sentido como siempre, gracias por verlo y nos
vemos en la siguiente.
75. Capítulo 14 (Pointers): introducción a los Pointers: En este video, vamos a
estar hablando de punteros. Ahora, un puntero,
como una referencia, se utiliza para almacenar la dirección de una variable en lugar de simplemente almacenar el valor de la misma, como las referencias
que los punteros almacenan la dirección de una variable. Ahora bien, ¿cuál es el
punto de un puntero? Bueno, para uno, te permite
asimilar las llamadas por referencia. Y también son para
crear y manipular estructuras de datos
dinámicas o asignación
dinámica de memoria. Ahora, no vamos a entrar
realmente en crear y manipular estructuras de datos
dinámicas o tratar con la asignación dinámica de
memoria. O lo haría en este curso, sólo porque es un tema mucho
más profundo, entonces quiero sumergirme en, en este curso específicamente. Pero dicho eso, todavía
vamos a estar echando un vistazo a los punteros, cómo usarlos,
cuándo usarlos, y las diferencias
entre eso y las referencias y cuándo
querrías usa uno sobre el otro, ya que no vas a poder ir
a ningún lado en C plus plus programación sin
saber qué son los punteros. Por lo que es importante
saber qué son, cómo usarlos y
cuándo usarlos. De todos modos, eso es todo
para este video. Gracias por mirar, y te
veré en la siguiente.
76. 75: En este video, vamos a estar creando nuestro primer puntero. Entonces la sintaxis para un
puntero es la siguiente. Primero, vas
a tener el tipo de datos
de la variable apuntada. Tan similar a cómo
creamos referencias, donde tenemos el tipo de datos de lo que estábamos planeando
hacer referencia. Vas a tener
el tipo de datos de lo que planeas señalar qué tan fuerte por el símbolo de
asterisco para significar que
este es un puntero similar a como
tenemos el ampersand con referencias para significar que escuchamos crear
una referencia. Entonces vas a
seguir eso con el nombre del puntero, y luego puedes seguir adelante y asignarlo a algo también. No obstante, no
hay que darle un valor inicial de
inmediato, como hicimos con referencias. Y vamos a entrar en
eso un poco más adelante en el curso también. Y cuando lo asignes, le vas a asignar
la dirección de una variable. Ahora, el asterisco
y C plus plus, como hemos visto ahora, se
pueden usar para múltiples cosas
diferentes. Primero, se pueden usar para declarar que estás
creando un puntero. Se puede usar para
desreferenciar un puntero, y se puede usar
en la multiplicación. Y verás algunos ejemplos de desreferenciar un
puntero aquí en un poco. Y luego una cosa que sí
quería
mostrarte con este texto aquí, porque ya sea que
tengas el ampersand hora de crear una
referencia justo
al lado del tipo de datos o justo al
lado del nombre
no importa. Estas dos líneas de texto
son iguales e incluso
podemos crear una
referencia a una referencia, y ahora todas
serán lo mismo. Entonces x, ref y rough hasta aquí son todos ahora esencialmente
lo mismo exactamente. Todos son solo apodos
o alias el uno para el otro. Y si ejecuto mi código aquí, puedes ver que esto
funciona bien. Entonces, no importa si
tienes el ampersand aquí o aquí. Y puedes tener múltiples
referencias a lo mismo, pero eso es suficiente de
referencias por ahora. Yo sólo quería
mostrarte eso muy rápido. Y lo mismo ocurre cuando
estás creando un puntero, el asterisco aquí, o
podrías tenerlo aquí mismo. No hace ninguna diferencia. Personalmente. Me gusta tenerlo aquí, sobre todo porque
cuando estás trabajando con funciones como la vimos con referencias y tienes un tipo de retorno que
se ve así. En realidad no
tienes el nombre ahí, y solo tienes esto
justo al lado del tipo de datos. Entonces solo me gustó esa consistencia también a la hora de crear múltiplo
de la misma variable. Así que déjame seguir adelante y
quitar esto rápido. Si dije x coma y,
y entonces puedo decir x es igual a
cinco e y es igual a cinco. Y cuando tienes
algo como esto, donde creas múltiplo de
una variable en la misma línea. Puedes hacer lo mismo con
referencias donde digas int x referencia
y por qué referencia. algunas personas les gusta
tener el símbolo junto
al nombre por la
consistencia con esto. Pero personalmente, no me gusta
crear múltiples variables
en la misma línea. Creo que solo hace que
tu código sea menos legible. Entonces por eso personalmente lo
puse al lado del tipo de datos. Pero si lo ves al
revés, no te preocupes, es exactamente lo mismo, ya sea un puntero o una
referencia, no importa. Lo mismo. Ahora por fin entremos en todo el
punto de este video, que es crear un puntero
y ver cómo funciona. Entonces dirá int x es igual a diez, y luego abajo, crearemos un puntero. Entonces diremos int asterisco
y luego diremos P, x algunas personas les gusta prefijo allí
nombres de puntero con un par. Entonces aquí mismo, lo estoy
viendo así, solo para que sepas que
es un puntero, pero puedes nombrarlo como
quieras. Entonces lo pondremos igual a
la dirección de x, así, recuerda ampersand antes de
un nombre de variable como este, porque la dirección
de esa variable. Entonces en este caso se podría
mirar el ampersand como la dirección del operador. Entonces creamos un
puntero dando el tipo de datos a lo que
queríamos apuntar, coloreado por el asterisco, luego el nombre del puntero. Entonces dijimos es igual a la
dirección de la variable. Entonces esta fue nuestra declaración e inicialización de un puntero a. Ahora bien, no tienes que
inicializarlo en
la misma línea en la que
lo declaras, a diferencia de las referencias. Así que aquí abajo, voy a seguir
adelante y recrear eso. Y podríamos haber
dicho int asterisco x para nuestro puntero a x, y luego simplemente poner un punto y coma
al final así para simplemente declarar nuestro 23. Y entonces podemos
inicializarlo más tarde diciendo P x es igual a ampersand
x así. Y esto va a funcionar bien. Entonces si ejecuto mi código,
puedes ver que
no obtenemos ningún error
y todo funciona. De todos modos, déjame seguir adelante
y deshacer eso ahora. Bien, vamos a seguir adelante e
imprimir nuestro puntero. Entonces, si recuerdas
en el último video, dije que un puntero es
esencialmente solo una variable que contiene una dirección versus donde una referencia contiene el valor. Si esto hubiera sido una referencia, básicamente
sería
lo mismo que X, pero un puntero contiene la
dirección de la variable. Entonces si imprimimos esto como, como, imprimiremos
la dirección aquí. Y lo puedes ver aquí mismo, y esta es la dirección de x. Y para demostrarlo,
sigamos adelante y también imprimimos
la dirección de x. Así que después de la línea n aquí, imprimiremos el
dirección de x usando la dirección del
operador, si lo desea. Y luego después de eso,
lo cual es genial. Estoy así. Y si
ejecutamos nuestro código aquí, puedes ver, oye, ahí está nuestra dirección y ahí está exactamente
la misma dirección. ¿Bien? Así que apunto
naturalmente sostiene la dirección de lo que
sea que esté apuntando. Entonces por eso acabamos de
imprimir el plano. Imprimimos la dirección. Ahora abajo,
vamos a hacer lo contrario. Así que vamos a hacer aquí
abajo es imprimir el valor, ayudar a abordar. Nuestro puntero está apuntando
al valor de x Y en realidad simplemente pondremos
este código justo debajo de él. Entonces vamos a decir C fuera. Y luego diremos el símbolo
asterisco
seguido de p de x y luego
una nueva línea así, voy a
imprimir x y la luz. Entonces si recuerdas, como
mencioné aquí arriba, un asterisco también es
una de-referencia son, y lo que te permite hacer
es desreferencia y dirección. Entonces nuestro puntero apunta a la dirección de x, eso
es lo que sostiene. Y luego usando este asterisco, podemos desreferenciar eso. Entonces, en lugar de simplemente obtener
la dirección de la variable, podemos obtener el valor
que tenemos en esa dirección. Y luego solo estamos
imprimiendo el valor de x y estos
serán exactamente los mismos. Entonces, como puedes ver
aquí, empezamos sacando nuestro puntero, que solo contiene una dirección, e imprimimos
la dirección de x Y eso fue lo mismo ya que nuestro puntero apunta a x. Entonces aquí abajo, usamos
el símbolo de asterisco para
desreferenciar un puntero y obtener el valor real mantenido
en esa dirección. Ahora no vamos a adentrarnos
demasiado en las direcciones, en cómo se almacena todo. Pero solo tenga en cuenta que
un puntero contiene la dirección de una variable y puede obtener la dirección de una variable con este símbolo de
ampersand. Entonces esta dirección aquí es donde se almacena
nuestro valor de x. Entonces diez, en esos casos, se almacena en esta dirección. Y nuestro puntero sostiene esa misma dirección porque
eso es lo que le dijimos que hiciera. Se. Y luego abajo de eso, imprimimos nuestro puntero, que como dije,
plantean esa dirección. Aquí. Imprimimos
la dirección de x, que debería ser
exactamente lo mismo. Y luego usamos el símbolo de
asterisco para
desreferenciar un puntero
seguido del nombre de nuestro puntero, lo que nos da el
valor real que tenemos en esa dirección. Y luego lo imprimimos x, tal como lo hemos hecho en el pasado. Entonces, ¿qué significa esto todas las variables que
hemos estado creando? Bueno, básicamente significa
que cuando dijimos Hey, vamos a crear
un entero llamado x y ponerlo igual a diez, que estamos creando un entero
que contenga el valor diez. Y esto se almacena en una dirección
o una ubicación en la memoria. Y podemos acceder a este valor. De nuevo, estamos en esa ubicación en memoria si quieres, simplemente
diciendo x. entonces ahí la tienes. Ojalá eso no fuera
demasiado confuso para ti. Todo lo que quiero que le
quites de esto realmente, es que un puntero apunte a
una dirección de una variable. Por eso sostiene. Así que al igual que nuestra variable
aquí igual a este valor, un puntero contiene la dirección de esa variable y también
cómo crear un puntero. Pero vamos a estar recibiendo
un poco más de práctica con esto en los próximos videos. Ahora bien, una última cosa sí
quiero mencionar
es eso porque
no tienes que inicializar un
puntero cuando lo creas. También puedes cambiar
a qué apunta un puntero. Entonces por ejemplo podemos decir y es igual a 15. Y luego aquí abajo, después de imprimir todas
estas cosas, vamos a seguir adelante y copiar todo esto y pegarlo hacia abajo. Y voy a crear algo de
espacio aquí para que
podamos ver las diferencias
entre estos. Entonces seguiremos adelante y
retiraremos la declaración. Entonces este asterisco int aquí abajo, y solo diremos
Px ahora va a apuntar a la dirección de y.
Y luego
volveremos a imprimir la x junto con
la dirección de y.
Y luego aquí abajo, desreferenciaremos
la dirección de y, que solo
imprimirá por qué esencialmente. E imprimiremos y también. Y si ejecutamos un código, se
puede ver que esto funciona bien. Entonces está la dirección de x y ahí está la dirección de y. y luego también
imprimimos el valor junto con el valor de y usando el puntero y
usando nuestra variable directamente. Entonces ahí lo tienes. Así es como usar
un puntero y un poco más sobre
lo que es un puntero. Gracias por mirar, y te
veré en la siguiente.
77. Capítulo 14 (Pointers): los punteros nulos: En este video,
vamos a estar
hablando de punteros y nulos. Y si eres miembro, porque hemos visto
saber en el pasado, null simplemente significa nada o 0. ¿Bien? Entonces, ¿a qué me refiero con
punteros? ¿Y sabes qué? Echemos un vistazo. Así que vamos a seguir adelante y crear una variable entera
aquí llamada Exelon. Simplemente ponlo igual a diez. Y luego seguiremos adelante
y crearemos un puntero. Entonces diremos asterisco p x, nuevamente, como hicimos
en el último video. Y vamos a
poner esto igual a y de hecho saber lo que
tiene que ser en todas las mayúsculas. Sólo para mayor claridad, yo también lo
pondré aquí arriba. Entonces null es lo mismo que 0. Entonces si tenía esto o
esto, no importa. Es lo mismo. Así que adelante y haz eso para
que haya lo mismo que esto. Entonces, ¿qué significa esto? ¿Y por qué querrías hacerlo? Bueno, cada vez que
creas un puntero, no quieres
hacer esto y luego hacer trabajar con este puntero sin
inicializarlo a algo. Es increíblemente
peligroso ya que puedes terminar anulando la
memoria o un bloqueo tu programa y toda una lista de otras cosas malas que
no quieres hacer. Entonces, cuando no vas a tener esto inicializado de
inmediato, siempre
recomendaría
configurarlo igual a así. O como dije,
podrías poner 0 para decir, Oye, no
estoy inicializando
esto ahora mismo, pero no voy a dejar esto en inicializado esencialmente. Entonces básicamente lo que
esto está diciendo es, aquí hay un puntero, pero no apunta a nada en la memoria. Y en realidad no
necesitábamos esta
variable entera llamada x, solo la puse aquí para mostrarte el
mismo ejemplo que teníamos en la última frase. Y ahora lo que puedes hacer antes de usar este puntero es
decir lo siguiente. Aquí abajo. Antes de que hiciéramos
algo con nuestro planeta, en realidad
podemos verificar para ver
si nuestro puntero apunta a algo porque aquí
lo establecemos igual a null. Básicamente es decir
que no está apuntando a nada en estos momentos. Pero como hicimos esto,
podemos hacer lo siguiente. Podemos decir que Px
no es igual a nulo. Entonces corremos, para ejecutar
nuestro código al no tener, están diciendo explícitamente
que no apunta a nada. Podemos comprobar para ver que está apuntando a algo antes
de hacer algo con él. Bien, y esto ayudará a
evitar toneladas de errores el futuro porque
vas a trabajar con un puntero y no
vas a darle un valor inicial, siempre establecerlo en null, y luego revisa para ver si sigue siendo igual a nulo más tarde,
antes de que hayas trabajado con él. Porque como dije,
no quieres hacer trabajo. Si esto se ve así con tu puntero y
es muy peligroso. Entonces, si no lo vas a inicializar,
ponlo siempre en null, básicamente simplemente
decir explícitamente esto no
apunta a ninguna ubicación en la memoria. Y luego al final de la línea, solo
puedes verificar, oye, no
está apuntando
a nada y ejecuta tu código en esto de aquí. Por qué no funcionó correctamente
si acabas de hacer esto, tener este cheque aquí
no funcionará si no lo dices. Bien, así es básicamente como funciona null con punteros. Eso solo
te permite
decir explícitamente que tu puntero
no está apuntando a nada en este momento y te
permite verificar para ver si está apuntando a algo antes de
hacer algo con él. Y si quisieras, siempre
podrías hacer
algo como esto. Tres, di otra cosa, y luego
imprimir un puntero, está apuntando a cualquier cosa solo para advertirte cuando tu código se ejecuta que odiaba mi
declaración if nunca se apagó. Porque cuando tu código
se vuelve mucho más grande, podrías tener una
declaración if como esta. Y podría ser difícil
darse cuenta de que, oye, este código no se ejecutó
si no
te avisas. Entonces ahí tienes. Así es como la naturaleza trabaja
con punteros y la importancia de usar
null con punteros. Y como siempre,
gracias por mirar, y te veré
en la siguiente.
78. Capítulo 14 (Pointers): sugerencias y funciones: En este video, vamos a
estar hablando un poco punteros con funciones. Entonces igual que podríamos
con referencias, tener un tipo de retorno,
ser una referencia y un latido
perimetral al que referencié. Podemos hacer lo mismo
con punteros. Y porque ya lo hemos hablado con referencias. Y porque los punteros
y referencias y muchas formas
funcionan de manera muy similar, solo
voy a
poner todo esto en un solo video en lugar de
tenerlo en dos videos separados. Así que vamos a meternos en ello. Entonces aquí abajo bajo main, sigamos adelante y
creamos una función que tenga un puntero para un parámetro. Entonces lo que vamos a
hacer aquí dice Lloyd, cambiar el valor así. Y luego entre paréntesis
diremos int asterisco, y simplemente llamaremos a
esto x así. Y luego entre corchetes aquí, diremos asterisco x es igual a diez. Y luego aquí arriba, vamos a seguir adelante y
crear una variable entera, digamos x es igual a cinco, así. Y luego aquí abajo, seguiremos adelante y
llamaremos a nuestros métodos dirán valor de cambio, y luego simplemente
insertaremos x así. Y tenemos que asegurarnos de
grado un prototipo aquí. Así que vamos a hacer eso aquí arriba. Y antes de que nuestra función llame, sigamos adelante e imprima x y cree una línea así. Ahora bien, observe que tenemos este error, y eso es porque int
es incompatible con el parámetro de
tipo int pointer. Y si esto hubiera sido una
referencia, así, esta he trabajado
bien porque, bueno, enviaríamos X y aquí, esto crearía una referencia
a que nuestra variable es x. Y podemos nombrarla como sea. Y voy a seguir adelante
y en realidad renombrar este número aquí, así. Bien, entonces tenemos int num, lo
imprimimos, y luego lo enviamos como argumento. Y si esto hubiera sido una referencia, esto habría
funcionado bien. Habríamos creado una
referencia que huevos y cambió x y
como que lo sacamos. Aquí abajo. Acabo de imprimir otra vez. Y ahora qué cambio a diez. Y también tenemos que
cambiarlo aquí arriba en nuestro prototipo por un
momento y ver si lo ejecutamos, funcionaría bien. Sin embargo, un puntero no almacena el valor directamente y
almacena la dirección. Entonces si seguimos adelante y cambiamos
esto de nuevo a un puntero ahora, todavía
podemos hacer lo mismo, excepto que tenemos que enviar la
dirección de la variable. Entonces pondremos nuestro
símbolo ampersand aquí mismo. Y luego aquí abajo, no
podemos decir que x
es igual a diez porque no
queremos cambiar la
dirección del puntero. Y se puede ver que esto nos
da un error en realidad, pero no podemos cambiar el. Entonces, si seguimos adelante y
desreferenciamos
esto, funcionaría bien. Ahora, creamos un entero llamado num,
no es igual a cinco. Entonces lo imprimimos num, que solo
imprimirá cinco, obviamente. Entonces enviamos la dirección de
num a nuestro parámetro aquí. Entonces ahora tenemos un puntero que apunta a la
dirección de num, y luego
desreferenciamos un puntero. Entonces estamos diciendo el valor
que tenemos en la dirección de num, queremos cambiar a diez. Y así esto también
cambiará num a diez. Y si ejecutamos nuestro código aquí, se
puede ver que eso
es lo que sucede. Ahora. ¿Y si hubiéramos
creado primero un puntero? Entonces, si tuviéramos que establecer asterisco, simplemente
llamaremos a
este punto así, y lo pondremos igual a la dirección de num y luego seguiremos
adelante y lo enviaremos. Y ahora si ejecutamos un código, esto, exactamente lo mismo. La única diferencia es que
acabamos de enviar nuestro puntero. Entonces básicamente teníamos un
puntero que señalaba la misma dirección exacta y obtuvimos el valor
que ahí se tenía, luego cambiarlo a diez. Así que eso también funcionó. Y por último, sigamos adelante y tengamos un puntero como tipo de retorno. Así que vamos a seguir adelante
y sin inicializar nuestro puntero aquí y simplemente
establecer esto igual a null. Recuerda que si no lo vas
a inicializar originalmente, quieres establecerlo igual
a nulo. Entonces vamos a hacer eso. Entonces aquí abajo,
vamos a seguir adelante y enviar la dirección de num. Entonces diremos n, entumecido, así. Y lo cambiaremos de void a un tipo de puntero así. Y tenemos que hacer lo
mismo aquí arriba. Entonces aquí abajo, lo que
vamos a hacer es devolver x, como así ahora tenemos un ingreso
ellos que es igual a cinco. Después lo imprimimos. Entonces creamos un puntero llamado punto que actualmente
no apunta a nada. Y dijimos explícitamente que
al establecerlo igual a no, entonces ejecutamos nuestro método aquí
se llaman su método, cual tomó la dirección de num, lo
puso en un puntero
que llamamos x, y luego regresamos eso puntero, que si recuerdas un punto
solo contiene una dirección, y devolvemos la dirección
y un puntero entero, cual será enviado de vuelta aquí. Entonces ahora tenemos un
puntero int que contiene la dirección de num porque
eso es lo que enviamos. Pero queremos seguir adelante
y guardarlo en alguna parte. Recuerda, cada vez que estés
girando algo, debes
guardarlo en algo. De lo contrario lo es. Entonces aquí mismo, lo que
vamos a decir es 0 igual a eso, y esto va a funcionar bien. Ahora bien, lo que podemos hacer después de
un método llamado es decir, queremos desreferenciar. Recuerda, vamos a
poner un puntero de asterisco y ponerlo igual a diez, un
poco como lo hicimos antes. Entonces ahora estamos diciendo que
queremos tomar la dirección de num, básicamente
desreferenciarla. Obtienen el valor real sostenido que ninguno, que actualmente
es cinco, y lo ponen igual a eso, entonces vamos a
imprimir diez aquí abajo. Y sigamos adelante
y echemos un vistazo a eso rápido. Entonces ahí tienes. El top 510 y
¿cómo queremos que lo haga? Podríamos haber puesto esta llamada de
método aquí mismo, nos deshicimos de esto aquí. Y esto también
habría funcionado bien, ya que esto nos está
devolviendo una dirección y necesitamos establecer
esta igual a una dirección. Esto funciona todo bien y dandy. Entonces ahí tienes. Básicamente
funciona de la
misma manera que el tipo de referencia que, salvo que con algunas advertencias, sunset tiene una
dirección en lugar
del valor como nuestro tipo de
referencia que hay. De todos modos, eso es todo
para este video. Gracias por mirar, y te
veré en la siguiente.
79. Capítulo 14 (Pointers): punteros y ensayos: En este video, vamos a estar hablando de
punteros y arreglos, además de repasar algunas de las interesantes similitudes e interacciones entre ellos. Así que comencemos. Primero, sigamos adelante y
creamos una matriz de enteros. Así que vamos a
decir int, mi matriz, entonces voy a abrir y
cerrar corchetes se puso en un número
como tres aquí. Y quiero establecer esto igual
a tres números diferentes. Sigamos adelante y digamos 1025. Y luego abajo aquí, vamos a seguir adelante
y crear un puntero. Entonces vamos a
decir int asterisco, y voy a decir PTR,
abreviatura de puntero. Y entonces sólo
vamos a decir es igual a mi matriz, así como así. Entonces estoy pensando que
quiero mostrarte es este valor aquí solo tiene que ser un continente y no
tienes que poner un número
aquí directamente. Entonces, si decimos tiempos y
luego llamamos a este tamaño de matriz, por ejemplo, establecemos
esto igual a tres. De hecho, podemos poner tamaño de
matriz
aquí mismo en nuestro
tamaño de matriz, si lo desea. Y luego aquí abajo, lo que vamos a hacer es
crear un básico for-loops son necesarios para I es igual a 0, I menos que el
tamaño de matriz I plus plus. Y luego dentro de nuestro for-loop, lo que vamos a hacer es
imprimir un par de cosas
diferentes. vamos a
imprimir las direcciones Aquí vamos a
imprimir las direcciones
de estas variables, así
como los valores
usando nuestro puntero. Entonces, sigamos adelante y echemos un vistazo a algunas formas en las
que podemos hacer esto. El primero
sería el siguiente. Podemos decir algo como C. Y luego entre comillas aquí, podemos decir dirección a mi matriz
en panel abierto corchete cuadrado. Y luego después de esto, podemos dibujar N. Y
luego después de eso, crearemos otro conjunto
de comillas seguidas un corchete cerrado para
decir igual a más así. Entonces a continuación esto seguirá
adelante y dirá CL, siendo
PTR el nombre de
nuestra coartada en mente. Entonces ahora sigamos adelante y copiemos y peguemos esto
abajo también. Ejército cambia este para
que valore así y deje el resto
excepto aquí abajo. Estoy diciendo C out pointer. Vamos a desreferir
un puntero aquí, y esto
imprimirá el valor. Pero ahora, ¿cómo
vamos a iterar e imprimir un
valor tras otro? Bueno,
lo interesante es que esta línea aquí básicamente está
diciendo que fuimos a una dirección de señal de mi matriz en el índice 0 a GTR. Entonces, esencialmente, esto es
como decir puntero igual a mi índice de matriz 0
con un ampersand aquí. Y esto, y esto son
esencialmente equivalentes. La razón por la que esto asigna la dirección de nuestra
matriz en el índice 0, q puntero es porque
nuestro nombre de matriz aquí en realidad contiene
la dirección del primer elemento de la matriz. Y esto actúa como
un puntero constante, lo que significa que la dirección almacenada en nuestro nombre de matriz no se puede cambiar. Y curiosamente, los
punteros en realidad tienen algunos operadores que podemos
usar en esta instancia. Y voy a estar mostrándote
uno justo aquí abajo. Podemos decir puntero más, más. Y a medida que esto se mueve hacia arriba
a través de las direcciones, si se quiere, se va a
mover hacia arriba a lo largo de estos elementos. Y si recuerdas cuando hablamos por
primera vez de arrays, te
dije que estos valores se almacenaban en orden secuencial. Y así, esencialmente, podemos
simplemente mover nuestro puntero hacia arriba en orden
secuencial para movernos hacia
arriba a lo largo de estos valores. Ya que nuestro puntero está comenzando en índice 0 aquí y
cada ejecutar nuestro código, se
puede ver que dijimos
dirección de mi matriz en el índice 0, que solo fue indicado
por este valor I que estábamos aumentando
iguales puntero. Y así está nuestra dirección. Y luego establecemos un valor de mi matriz en el índice 0 es igual a diez. Y eso es porque aquí hemos
desreferenciado esta dirección. Y luego aumentamos
nuestro puntero en uno aquí. Y eso lo movió hacia arriba un elemento en la
matriz, esencialmente. Y somos capaces de
imprimir la siguiente dirección y valorar todo el camino. Ahora, sigamos adelante
y echemos un
vistazo de otra manera porque ya
he hecho esto. Entonces, sigamos adelante y eliminemos
este puntero más, más. Y luego en realidad justo después la palabra puntero C
Plus Plus nos permite usar la misma sintaxis
que haríamos para una matriz cuando nuestro puntero es
igual a una matriz como esta. Así que solo podemos tener corchetes abiertos y
cerrados y ponerlo ahí mismo y
hacer lo mismo aquí abajo. Y esto realmente nos dará el mismo efecto esencialmente. Pero en lugar del
asterisco aquí, vamos a poner el símbolo
ampersand así y ejecutar nuestro código. Y como se puede ver, esto realmente funciona
como una variable ahora, por lo que es opuesto. Entonces, si queremos seguir
adelante y arreglar eso, solo
puedes mover nuestro
ampersand aquí arriba. Y ahora, igual que si
esto fuera una matriz, pondremos
aquí el símbolo ampersand para obtener la dirección
de la variable. Y solo la
usaríamos normalmente para obtener la propia variable. Entonces, si ejecutamos un código, puedes ver que funciona
igual que antes. Sigamos adelante y echemos
un vistazo a una forma más. Podríamos trabajar con
nosotros, y esta no es la última forma en que puedes trabajar
con punteros y arreglos. Es solo el último
que vamos a mostrar aquí y la mayoría de las canchas, así que al seleccionar crear un puntero aquí y
configurarlo igual a mi matriz, entonces en realidad
vamos a hacer esto un matriz de punteros. Pongo
entre corchetes así. Y luego
simplemente pondremos un redimensionamiento justo ahí dentro de esa manera. Entonces aquí abajo, lo que
vamos a hacer es dejar esto como está. Vamos a seguir adelante
y cortar este código ya que podemos usarlo más adelante
aquí en un momento. Y luego dentro de aquí, vamos a decir puntero ampersand mi array index I. Así que ahora nuestra matriz de punteros que está sin inicializar
actualmente se va a asignar las direcciones
de estos variables. ¿Bien? Y luego aquí abajo, sigamos adelante y creemos
un, otro bucle for. Pero se ve
igual que el anterior. I es igual a 0. Yo menos que la talla I más, más. Y lo bueno de
decir tamaño de matriz aquí y usar eso para el tamaño real de la
matriz ya que esto es muy legible
y está muy claro cuándo estamos deteniendo nuestro bucle y cuántas veces estamos
ejecutando a través de él, una vez por elemento en nuestra matriz. Y luego aquí abajo, vamos a seguir adelante y
pegar lo que teníamos antes, excepto que quitaremos
este ampersand y pondremos nuestro asterisco de nuevo en la
parte inferior aquí y ejecutaremos nuestro código. Y ahora funciona de la misma
manera que lo hacía antes. Entonces, lo que hicimos fue crear un entero constante llamado el tamaño de la matriz y
establecerlo igual a tres. Luego creamos una
matriz entera y la configuramos igual al tamaño
del tamaño de la matriz
y le damos tres valores. Luego creamos una matriz de punteros
enteros y
no lo inicializamos. Y luego creamos un bucle básico de
cuatro que se iba a ejecutar una vez por elemento
en nuestra matriz. Y establecemos cada una de las
direcciones para estos punteros aquí igual a la dirección
de los valores en nuestra matriz. Luego creamos
otro for-loop que corrió la misma cantidad de
veces que el de aquí arriba, y simplemente lo imprimimos
nuestras direcciones como normales, igual que estábamos
imprimiendo el valor de una matriz, luego la referencia
a esto una vez más, y sólo para recuperar, o resumimos nuestros ejemplos
anteriores también. Déjeme seguir adelante
y volver aquí. Así que acabamos de crear una matriz
y luego creamos un puntero y establecemos la dirección en ella
igual a esta dirección aquí. Esencialmente, eso es porque
nuestro nombre de matriz aquí realmente contiene la dirección
del primer elemento. Y esto fue lo mismo que si
dijéramos esto aquí mismo. Bien, entonces si ejecuté
mi código así,
eso va a funcionar bien. Ahora, C plus plus
nos permitirá usar realmente
la misma sintaxis. Imprimiríamos los elementos de nuestra matriz
con nuestro puntero aquí. ¿Bien? Y luego si volvemos a nuestro ejemplo original
donde teníamos esto aquí, una vez más, lo mismo cuando un
código aquí para el bin aquí. Y todo funcionará
igual excepto esta vez, en lugar de usar
la sintaxis de matriz, simplemente
aumentamos
la posición de nuestro puntero y simplemente
subió un elemento a la vez. Ahora bien, algo que
podríamos haber hecho para hacer esto a la inversa
como lo siguiente. Podemos asignar el puntero más iguales para moverlo
de aquí a aquí, porque se movió hacia
arriba dos lugares. Así que en vez de estar a las diez y ahora
está apuntando al 50, que es mi matriz en el índice dos. Entonces podríamos haber
dicho puntero menos,
menos aquí y comenzamos nuestro índice a las tres,
y luego dijimos: Bueno, yo es mayor que 0 menos
menos, y ejecuté nuestro código. Y ahora habría
ido en orden inverso. Y en realidad nuestros inductores
están apagados por solo uno. Entonces podemos arreglarlo cambiando
i2 para comenzar y diciendo:
Bueno, yo es
mayor que uno negativo. Y Marina lo otra vez,
y ahí vamos. Entonces la dirección de mi
matriz en el índice dos, porque ahí es donde
empezamos ahora es la siguiente, y el valor es 50, entonces obtenemos la dirección
del índice uno y así sucesivamente. Entonces ahí tienes. Hay algunas de las interacciones interesantes
entre punteros y matrices. Si tienes curiosidad sobre
nuestra matriz Nombre que contiene la dirección del primer
elemento y no solo el valor. Si recuerdas
atrás en el video donde enviamos una matriz como argumento a un perímetro que tomó y se
pasó por referencia. Y eso es porque tiene
la dirección, no el valor. De todos modos,
eso es todo por este video, sé que era
mucha información. Entonces, si no lo conseguiste completamente, siéntete libre de volver a ver
esto o
buscar más información
sobre el tema. De lo contrario, no te preocupes, no
vamos a estar realmente tratando con nosotros a lo largo
del resto del curso. De todos modos, eso
es todo para el video. Gracias por mirar, y te
veré en la siguiente.
80. Capítulo 14 (Pointers): puntos frente a referencias: En este video, vamos a
estar hablando
de algunas de las diferencias
entre punteros y referencias para que
sepas cuándo usar, cuales. Entonces comencemos. En primer lugar, las referencias se
utilizan como alias para las variables existentes, mientras que los punteros se utilizan para almacenar direcciones de variables. Además, las referencias
no pueden tener un valor nulo, pero los punteros pueden, y los punteros se
pueden cambiar más adelante. Además, en una nota más pequeña, ya que los punteros contienen direcciones, necesitan la referenciada
con el símbolo de asterisco. Mientras que las referencias
pueden verse como una constante automáticamente. Por defecto. Vamos a solo una manera de
ver una referencia como un puntero que no se
puede cambiar. Eso por defecto
es la referencia. Y entonces lo tienes. Aquí hay algunas diferencias básicas
entre los dos. E incluso hay mucho
más que puedes hacer con punteros que ni
siquiera tocamos. Por ejemplo, puedes tener
punteros a punteros. Hay varios
otros contenedores que no cubrimos
en este curso que necesitas usar punteros para trabajar y
aritmética de punteros también, puedes usar punteros
al hacer cosas con asignación dinámica de memoria también. Y por eso,
los punteros son mucho más versátiles
y permiten tener un código
mucho más complejo para hacer varias cosas diferentes
en comparación con las referencias. Entonces, en lugar de darte
todos los casos de uso para cada uno, solo te
voy a decir
cuándo deberías
usar generalmente una referencia y
luego como nota general, usarás punteros
para todo lo demás. Entonces, ¿cuándo deberías
usar referencias? Bueno, en
términos generales, querrás
usar referencias cuando trabajes con parámetros de función
y tipos de retorno, como vimos anteriormente. Ahora bien, obviamente esto puede variar dependiendo del
tipo de datos con el que estés trabajando, pero esto es solo una nota general. Ahora, otro buen momento para usarlos es cuando se
quiere trabajar con los elementos originales
en un para cada bucle. Y esto puede cambiar dependiendo
del datos y contenedor con el
que estuvieras trabajando. Entonces estas son solo
algunas reglas generales. Como dije, esto definitivamente puede cambiar
dependiendo de tu situación. Y entonces solo usarías
punteros para otras cosas. Y sólo hemos
tocado la superficie de los punteros y hay mucho
más que puedes hacer con ellos. Entonces, si te
interesa y todo eso, definitivamente sigue adelante y
haz tu investigación sobre eso. De todos modos, eso es todo
para este video. Solo quería
tocar algunas de las diferencias entre
punteros y referencias, así
como
darte una idea general de cuándo usar referencias. que por proxy sepas
cuándo usar punteros en su lugar, así
como tocar a. Otra forma de
ver las referencias en comparación con los punteros
es esto aquí mismo. De todos modos, espero que hayas
disfrutado del video. Gracias por mirar, y te
veré en la siguiente.
81. Capítulo 15: Introducción a la OOP: En este video, vamos a
estar hablando de qué es
exactamente la programación
orientada a objetos, también conocida como o p. Ahora, programación orientada a
objetos se trata de crear
objetos que contengan ambos datos y funciones que representan objetos del mundo real. Este tipo de programación tiene varias ventajas sobre la programación
procedimental, que se trata principalmente de escribir funciones que
realizan operaciones sobre los datos en lugar de
crear objetos o clases. Y no vamos a sumergirnos
demasiado en los detalles
de la programación procesal o
funcional. Pero muy rápido,
sigamos adelante y
hablemos de algunas de las ventajas de la programación
orientada a objetos. Bueno, antes que nada, la Programación
Orientada a Objetos es más rápida y fácil de ejecutar. Proporciona una
estructura clara para tus programas y
evita que tengas que repetirte,
haciendo que el código sea más fácil de
mantener, modificar y depurar. Y la última ventaja que vamos
a mencionar aquí es una programación orientada a objetos que
permite crear aplicaciones
reutilizables que se hacen con menos código
y se desarrollan. Pastor, ahora,
hasta este punto, probablemente
me
hayas escuchado referirme a objetos y clases como lo mismo. Y muchas veces
escucharás a la gente usar la palabra objeto y
clases indistintamente, pero en todo tecnicismo, son cosas diferentes. Así que recuerda cómo dije
que los colapsos representan objetos del mundo
real usando
funciones y datos. Bueno, sigamos adelante y
hablemos de las diferencias
entre clases y objetos y lo que sería una
clase en relación con un
objeto del mundo real como ejemplo, y cuáles serían los objetos de
esa clase. Y ya verás a lo que me
refiero aquí en un segundo. Entonces, para un ejemplo, vamos a seguir adelante
y usar fruta, alguna fruta dulce usada con nuestro ejemplo enum en
un video anterior. Así podemos crear una
clase llamada Pro. Y esta no es la
sintaxis para una clase. Así es como estoy
escribiendo esto aquí. Eso tendría diferentes
conjuntos de datos y funciones. Entonces, por ejemplo, es posible que tengas datos para representar la dulzura, tamaño y tal vez el color de la semilla. Puede tener funciones
para el crecimiento o la vida útil del fruto
como ejemplo aquí. Y entonces tendríamos
objetos son clase fruit o instancias de la misma que heredan estas variables y funciones pero tienen su propia instancia. Entonces, algunos ejemplos de objetos de nuestra clase de frutas que podamos tener serían cosas como una manzana o un plátano,
naranja, uvas, etc. Entonces, esencialmente, nuestra clase de
frutas sería como el plano para todo lo
que hereda de ella. O si a es una instancia de ello. Entonces, por ejemplo, o Apple
tendría un nivel de dulzura de tamaño, un recuento de asientos y una vida útil. Y entonces lo que nuestro plátano
y nuestra naranja, y nuestras uvas, etc. Así que eso es
un poco define lo que es una fruta y son
objetos de nuestra clase, son instancias del plano que se define en nuestra clase. Otra cosa a mencionar aquí, mientras tenemos este
ejemplo escrito como una manzana sería una fruta, y un plátano sería
una fruta, etcétera. Pero una manzana no es
necesariamente un plátano. El plátano no es
necesariamente una naranja, ya que cada uno de estos sería
diferente por derecho propio, sino que todos serían una
fruta en este caso. De todos modos, ojalá
que todo tenga sentido. Sé que fue un poco de información para tomar
en todos a la vez. Pero si no,
vamos a estar creando un trabajo con clases y desglosándolas
pieza por pieza, tal como lo hicimos con las funciones. Así que no te preocupes, mantente atento. Gracias por mirar. Y te veré
en la siguiente.
82. Capítulo 15 (Clases): cómo crear una clase: En este video,
vamos a estar creando nuestra primera clase. Entonces, si recuerdas, una clase es un tipo de datos
definido por el que tiene tanto datos
como funciones, que se llaman miembros. Y estos miembros conforman un blueprint para objetos o
instancias de nuestra clase. Entonces en el video anterior, hablamos de fruta
y luego tener diferentes nombres de frutas
para los objetos. Pero otro ejemplo
sería si tuviéramos una clase llamada autos que tuviera las
variables
como hacen, modelo y año. Y entonces podríamos tener
funciones para impulsar hacia adelante, hacia atrás, entrar en
neutral, etcétera. Y entonces los objetos
de nuestra clase son las instancias de que
serían diferentes vehículos. Cada uno tendría el
suyo y fabricaría modelo y año, y también tendría
sus propias instancias de las funciones para
viajar también. Entonces ojalá eso tuviera sentido. Si no, vamos a estar
creando un ejemplo de una clase aquí
en un momento. Pero antes de hacer eso, tengo algunas enumeraciones aquí, otro tipo definido por el usuario con el
que trabajamos. Y la razón por la que tengo estos aquí como el tipo de
mostrarte las similitudes la sintaxis para crear
estoy trabajando con una clase, que entraremos
aquí en tan solo un momento. Y sólo para mostrarte un par
de cosas extra con enumeraciones, ahora que tienes un poco
más de conocimiento de programación. Entonces, si recuerdas, acabamos de decir suficiente compañero por el
nombre de nuestra enumeración. Y luego entre corchetes, en realidad
teníamos los
diferentes valores de enumeración. Y luego en el pasado, acabamos de
crear diferentes variables de nuestro tipo de enumeración
diciendo nuestro tipo de datos, que era nuestra enumeración, seguido del nombre
de la variable, y luego
configurándola igual a una de nuestros posibles valores ahí. Pero un par de cosas
que no te mostré donde las siguientes para una, en lugar de crear
una variable separada en una nueva línea
aquí abajo, así, podríamos haberla puesto justo
después de los corchetes, pero antes del punto y coma. Así podrás crear tantas variables como
quieras así, solo
separarlas con comas. Y así en este ejemplo aquí, creé una
variable extra llamada sabor uno y luego
otra llamada sabor también. E inicializo el
sabor uno aquí abajo. Y simplemente tengo
la declaración de sabor a aquí mismo. Y éste arriba, hice algo muy parecido, excepto que dejé fuera el
nombre para éste, es
decir, no puedo crear una
variable más adelante así, ya que no tengo forma
de referenciarla y nuestro código en realidad
funcionará bien así. Entonces, para hacer variables
de ésta, tuve que ponerla después
como lo hice aquí abajo. También puedes
inicializarlos aquí arriba, así. Y yo podría haber hecho
lo mismo aquí abajo. De lo contrario, también puedo
inicializarlo aquí abajo como
lo hice con este. De todos modos, solo
quería mostrarte esto rápido. Básicamente las únicas
diferencias son que
podrías quitar el nombre
de tu ENM por completo, pero ten en cuenta que no
podrías hacer referencia a él. Y que puedes
tener las variables declaradas e inicializadas en la misma línea ahí
simplemente
poniéndola después de los corchetes
y antes del punto y coma. De todos modos, sigamos
adelante y eliminemos eso. Y luego seguiremos adelante
y crearemos una clase o simplemente creada de una manera muy
similar. Entonces la sintaxis para una
clase es la siguiente. Primero, vas
a decir clase, seguido del
nombre de la clase. Y luego entre corchetes, tendrás tu código real, o debería decir, los
miembros de esa clase. Y luego después de
los corchetes, puedes tener tus objetos, si lo deseas, separados por comas ahí. Entonces, por último,
vas a cerrar esto con punto y coma. Entonces aquí abajo, sigamos adelante
y creamos una clase básica. Y lo que vamos a hacer es
crear una clase para animales. Entonces diremos animales de clase así en la convención de
nomenclatura normal para nuestra clase como CamelCase, comenzando con una letra mayúscula, abrir y cerrar corchetes. Así dentro
tendremos a nuestros miembros. Entonces podrías tener una
variable entera llamada age. Entonces por debajo de eso, tendremos
una variable llamada height, y simplemente la
dejaremos así por ahora. Entonces ahí lo tienes. Ahora hemos creado una clase muy
básica llamada animales. Tenemos dos miembros de
datos diferentes dentro de él. Entonces tus variables que
están dentro de una clase y tus funciones dentro la clase se llaman miembros de
tu clase. Y a algunas personas les gusta
prefijar a todos sus miembros con
un guion bajo como este. Entonces, hazte saber que
estos son miembros de clase y no solo variables
regulares. Así que sigamos adelante y
en realidad hagamos eso. Y luego, como dije, también
declara diferentes
objetos aquí mismo, después de un corchete y antes de nuestro punto y coma
si lo queremos. Entonces podríamos tener un objeto perro y un objeto gato, por ejemplo. Y si ejecutamos un código aquí, y se puede ver que
esto funciona bien. Ahora, obviamente no
hice nada, pero solo
quería mostrarles que no
teníamos ningún error. Y ahora mismo, esta clase sólo existe dentro de nuestra función principal. Y después de este punto
aquí, sin embargo, en realidad
podemos cortar esto así
y ponerlo fuera de nuestro método para que
ahora su alcance
sea global
más que local aquí. De todos modos, eso
es todo para este video. Pero antes de pasar
al siguiente, lo que quiero que empiecen a
hacer es guardar su código. Porque en la próxima
serie de videos, vamos a ir añadiendo
poco a nuestra clase para
hacerla cada vez más compleja y mirar diferentes ejemplos de
cosas que podemos hacer con ella. Entonces como dije,
asegúrate de guardar tu código para que podamos
usarlo en el siguiente video. De todos modos, gracias por mirar, y te veré
en la siguiente.
83. Capítulo 15: objetos de clase: En este video,
estaremos creando instancias u objetos de nuestra clase. Y antes de hacer eso, en realidad
vamos a seguir
adelante y simplemente eliminar estas dos declaraciones de
objetos, solo para que podamos ver cómo
hacer esto desde cero. Así que sigamos adelante y retiremos
estos objetos de perro y gato. Y en realidad
vamos a seguir adelante y crear dos diferentes objetos o instancias de nuestro
vidrio aquí abajo. Así que recuerda, los objetos son instancias de una clase
o sintaxis de objeto. Lo vamos a hacer es decir el nombre de nuestra clase, seguido del nombre del
objeto, este nombre de mascota ahí. Y por último, un punto y coma. Así que sigamos adelante y creamos
dos instancias de nuestra clase. Y esto es todo lo que va a estar
haciendo en este video. Vamos a decir, es animales siendo el
nombre de nuestra clase. Y luego diremos
perro por ejemplo. Y siga eso
con punto y coma. Y luego también crearemos
otra instancia u objeto, si lo harías, de nuestra
clase llamada gatos animales. Y pondremos punto y coma
al final de eso. Y luego sigamos adelante y hagamos una cosa más antes
de concluir este video. Entonces aquí arriba, en vez de hola, sigamos adelante y pongamos un nombre a
cada animal. Entonces voy a decir nombre de cadena. Y luego solo para
mostrarte algo rápido, e intentamos crear
una instancia de cada una de estas variables
para nuestros objetos aquí. Y podemos hacer eso
haciendo lo siguiente, diciendo nuestro nombre de objeto, perro, en este caso, seguido del nombre de la variable a la que
queremos acceder. Entonces dirías el nombre del punto del perro y
tratarías de establecerlo
igual a una cadena aquí, notas que
obtendremos un error y eso porque el nombre del animal
está en accesible. Y hablaremos de
por qué en el siguiente video. Así que adelante y di que
tienes gracias por ver, y te veré
en la siguiente.
84. 83: En este video,
vamos a estar
hablando de algo
llamado los
especificadores de acceso o venir
de otro idioma. Es posible que también hayas
escuchado esto
referido como modificadores de acceso. Ahora, hay tres
tipos diferentes, cuatro números. En primer lugar, tienes
público y los miembros públicos son accesibles desde
fuera de la clase. Entonces tienes miembros privados
y privados no se
pueden ver ni acceder
desde fuera de la clase. Y por último, has protegido, que sólo se puede acceder y ver por clases heredadas. Y nos meteremos en
herencia en otro video. Pero lo único que
quiero que apuntes aquí, las clases por defecto
tienen miembros privados. Entonces, si queremos poder acceder
a estos miembros, como nuestro nombre de cadena
aquí fuera de la clase, necesitamos hacerlo accesible
cambiando esto de
una variable de miembro privado a un miembro público
y, o una variable. Y recuérdalo porque
estos son parte de la clase, se
les llama miembros. Y voy a seguir adelante y poner un guión bajo antes de
nuestro nombre de cadena aquí, sólo para significar que
es un miembro. Y vamos a seguir adelante y cambiar
esto aquí abajo también. Y si recuerdas,
si pasamos el mouse sobre
esto, dice animales subrayado nombre es accesible y
eso es porque
es privado y
solo se puede ver y acceder desde dentro de la
clase y no desde fuera. Y por cierto, es posible que también escuches a
los miembros de la clase referidos como los atributos de
clase. Ahora bien, ¿cómo seguimos adelante
y hacemos públicos estos? Bueno, es bastante fácil. Entonces todo lo que tenemos que hacer está por encima nuestros miembros aquí que
queremos hacer públicos, públicos, dos puntos, así como así. Y ahí tienes. Estos miembros son ahora públicos. Y si miramos aquí abajo, pueden
ver que
ahora podemos acceder al miembro. Ahora, podemos seguir adelante
y conseguir a nuestro perro. Quiero decir, se puede decir que el nombre
es igual a algo así como spot. Y podemos seguir adelante y
darle a su perro en H también. Entonces se puede decir perro
subrayado edad es igual a dos, entonces podemos hacer lo
mismo por nuestro gato ahora. Entonces podemos decir subrayado,
nombre, algo así como Garfield. Después subrayado la edad es igual a cuatro. Entonces ahora hemos creado una clase
llamada los animales que tiene dos miembros públicos o
atributos, si lo prefieres. Uno es una cadena
llamada underscore name, siendo llamado underscore age. Y esto
en realidad debería haber sido solo un entero, no una cadena. Y luego aquí abajo
creamos dos instancias u objetos de nuestra clase
simplemente diciendo nuestro nombre de clase, Hola por un nombre para ello, el objeto, y un
punto y coma al final. Y entonces cada una de estas tiene su propia instancia
de estas variables, bien, entonces cada una tiene
sus propias versiones. Y para acceder a estos, solo
usamos el operador de
acceso miembro para el símbolo de periodo o el punto ahí si
quieres llamarlo. Dijimos perro punto subrayado
nombre y establecerlo igual a punto y
punto oscuro h igual a dos. Entonces básicamente hicimos lo
mismo
aquí abajo para el gato. De todas formas es para concluir este video. Una cosa más que sí
quiero mencionar es que para estos otros especificadores de
acceso, podríamos ajustarlos, los
deletreamos como se enumeran aquí. Entonces el público o privado o podríamos haber
escrito así como así. Y eso hubiera
funcionado bien. Pero voy a seguir adelante y
cambiar esto de nuevo a público. Entonces ahora mismo tenemos
algunos miembros públicos, pero también podríamos haber creado miembros
privados y protegidos si quisiéramos, simplemente pegando
eso después o antes. Entonces podríamos haber
dicho privado, por ejemplo ,
y luego tener algunos miembros
privados debajo de eso y eso
hubiera funcionado bien. Entonces así es como usar los especificadores de
acceso y
la importancia de los mismos. Y voy a
seguir adelante y tabular en estas variables aquí solo para
que sea un poco más legible. Ahora bien, ¿cómo sabes qué especificador de
acceso usar? Bueno, al igual que cuando se trabaja
con alcance variable, cuando se trabaja con especificadores de
acceso, solo
quieres que las cosas
estén tan disponibles como necesites que estén. Y eso es sólo una vez más para evitar cualquier tipo de error humano. Y normalmente quieres, quieres que tus miembros
sean públicos así. Y nos meteremos en
eso en un video posterior. Pero por ahora, vamos a
seguir adelante y salir del público para que podamos
acceder algún tiempo aquí. De todos modos, eso es todo
para este video. No olvides
guardar lo que tienes. Y como siempre, gracias por mirar y
te veré en la siguiente.
85. 84: En este video,
vamos a estar hablando funciones de
clase o de cómo
crear una función
dentro de una clase. Entonces, en nuestro caso, vamos
a seguir adelante y crear una función para hablar. Está justo aquí
dentro de nuestra clase, vamos a decir
algo así como vacío. Y dirá paréntesis abrir
y cerrar. Y luego en un bloque de código aquí, diremos C out. Así como así. Y crearemos una nueva línea y pondremos punto y coma al final. Y el sonido en realidad
va a ser una
variable de cadena que
tomará como argumento. Tenemos que hacer un
perímetro para ello. Entonces diremos sonido de cuerda. Y esto va a funcionar bien. Y esto es lo que es
la forma básica de
crear una función
dentro de una clase. Pero también se puede definir
fuera de una clase. Y la forma en que se hace esto es muy similar a crear un prototipo de
función. Entonces abajo aquí,
sigamos adelante y copiemos y
peguemos nuestra función actual. Ahora para hacer esto, tenemos
que cambiar algunas cosas. Primero, nos desharemos de la definición de nuestra función
aquí dentro de nuestra clase. Y luego pondremos punto y
coma al final. Y luego aquí abajo
después de nuestro tipo de regreso, tenemos que decir
animales colon, colon. Si recuerdas, este es el operador de resolución de
alcance. Y ahora esta definición de método o definición de función en esta
parte de nuestra clase de animales, y declaramos que
iba a ser una cosa aquí. Entonces, si quieres
definirlo afuera, necesitas el
nombre de clase seguido
del operador de resolución de alcance justo después del tipo de retorno. Y entonces necesitas una declaración muy similar a nuestro prototipo de
función aquí arriba, donde solo tienes el
tipo de retorno seguido del nombre, cualquier parámetro y un
punto y coma al final. Entonces tienes, ahora,
sigamos adelante y
usemos esta función con nuestro perro y gato. Así que aquí abajo, debajo de nuestros
dos objetos. Sigamos adelante y
lanzemos nuestras llamadas a funciones. Entonces di perro, velocidad, y entre paréntesis dirá
arte o lo que quieras, pero realmente
no importan. Y luego Dumbo que dirá
gato, habla entre paréntesis. Vamos a decir, bien, y no olvides el
punto y coma al final. Y si ejecutamos nuestro código aquí, puedes ver que esto
funciona bien. Y podemos
imprimir estas variables tal como
lo haríamos con
cualquier otra variable. Sólo tenemos que especificar a
qué nos estamos refiriendo. Entonces podemos decir algo
como c out, cat, name, la nueva línea, así, y esto correrá. Así que sigamos adelante y agreguemos
algo de código aquí para
imprimir nuestras diferentes variables
animales. Y en realidad podemos crear
una función para hacerlo. Así que sigamos adelante y eliminemos estas
llamadas a funciones también. Y luego aquí abajo vamos a decir
alguien como el animal. Y luego entre paréntesis, tomaremos un animal. Y nuestro nombre de clase
en realidad se llama los animales. Y tal vez para que eso
suene un poco mejor, vamos a seguir adelante y renombrarlo. Y puedes
pasar por muy rápido y simplemente quitar la S, o puedes hacer clic derecho y golpear Renombrar aquí
en Visual Studio, cambiarlo a
animal y vista previa. Así que ahora nuestra función toma un animal y yo sólo voy
a llamar a este animal por ejemplo ,
entonces entre corchetes aquí, vamos a seguir adelante e
imprimir todos los valores dentro de aquí. Debido a que estamos trabajando
con un objeto animal, en realidad
podemos usar
todas las funciones que normalmente podríamos, ¿cómo creamos
un objeto animal? Entonces podemos decir algo como CL, nombre
animal, espacio de dos puntos. Hola, soy mamá. Ese nombre de subrayado así
creará una nueva línea, puede poner un punto y coma al final. Entonces sigamos adelante y copiemos
y peguemos esta vez. Y diremos CL, edad animal. Entonces solo cambiará esto a animal pero subrayará la edad. Y luego, por último,
diremos C out. Entonces imprimiremos
el nombre del animal. Entonces diga
nombre de subrayado animal, así como así. Y luego entre comillas
aquí diremos espacio, dice espacio de dos puntos. Y voy a poner punto y coma aquí. Y luego abajo,
diremos animal, abrir y cerrar paréntesis
y un punto y coma al final. Y luego tomaremos
una cadena de aquí. Entonces vamos a decir cadena aquí
abajo para hablar. Y ahora de vuelta en
nuestra función principal, Sigamos adelante y llamemos a esta función para
cada uno de nuestros animales. Así dicen animal vegetal. Entre paréntesis
dirá coma perro. Después crearemos nuestra cadena. Entonces vamos a decir, bueno, vamos a poner un punto y coma
al final solos, y luego sólo podremos copiar
y pegar los que
harían cambio con el gato. Y di, Sí. Y luego si volvemos a bajar a nuestra función animal aquí, sigamos adelante y
creamos un par de líneas solo para que se vea un poco más limpio para
cada vez que llamamos a esto socializar C out y línea. Entonces sólo vamos a seguir adelante y hacer eso una vez más así. Y ahí vamos. De todos modos, seguiré adelante
y alejaré aquí. Para que ustedes puedan
revisar el código y copiarlo si es necesario. Y luego sólo tenemos que
hacer una última cosa. Y eso es crear un prototipo de
función para nuestra
función animal de impresión aquí. Así que recuerda, tenemos que hacer
es copiar esta línea aquí, pegarla así, y poner
punto y coma al final. Ahora, si ejecutamos nuestro
código, ahí vamos. Dijías nombre de animal como mancha. La edad animal es
detectar a la esposa del hijo. Entonces hicimos lo
mismo aquí abajo. De todos modos, eso está
arriba para este video. No olvides
guardar lo que tienes. Gracias por mirar, y te
veré en la próxima.
86. Capítulo 15 (clases): constructores de clases: En este video, vamos a estar
hablando de constructores. Ahora, un constructor es un método
especial en C plus plus que se
llama automáticamente cuando se crea un objeto, voy a hacer clase. Y seguiremos adelante y echaremos
un vistazo a qué es eso, uno adecuado y
los casos de uso para ello. Ahora, solo para
limpiar un poco las cosas aquí arriba, podría seguir adelante y minimizar nuestro método aquí solo para poder mantener
todo en la pantalla. Y porque ya
sabemos lo que hace esto, realidad no
necesitamos
meternos con eso ahora mismo. Y solo haz zoom aquí. Sólo sé que todavía
tengo todo este código aquí. Y en realidad no me voy
a deshacer de él. Y también voy a simplemente
seguir adelante y crear un espacio
vacío aquí entre nuestra función principal y nuestra clase animal solo para mantener las cosas separadas un
poco. Ahora, sigamos adelante y
creamos un constructor. Y C plus, además, hay tres
tipos diferentes de constructores. Ahora el primer tipo de
constructor del que vamos a hablar es el constructor
predeterminado. Y eso se ve así. Entonces, cuando se califica a un constructor, vas a tener
el nombre de la clase. Así. Entonces vas
a tener un
paréntesis de configuración con perímetros
potenciales y luego tu bloque de código
y corchetes así. Y así es como se ve el
constructor por defecto. Y tu clase va
a tener automáticamente este constructor si no creas un constructor
propio. Pero una vez que creas
tu propio constructor, el constructor predeterminado ya
no existe. Entonces en caso de que me haya confundido, usted está perdido en este punto. Sigamos adelante y solo
creamos un constructor alrededor. Voy a echar un vistazo a
cómo trabajan los constructores. Red Bull o una declaración del
método speak aquí, vamos a seguir adelante y
crear nuestro constructor. Entonces vamos a decir animal
siendo el nombre de nuestra clase, abrir y cerrar paréntesis. Entonces tendremos nuestro bloque de
código debajo de él. Y dentro de aquí, normalmente lo que quieres
tratar con el constructor como inicializar a todos
tus miembros para que no
los uses antes de que se inicialicen de
la forma en que esto es garantizado porque el
constructor se llama automáticamente cuando creas
un objeto de tu clase. Entonces si eso aquí, dijimos
subrayado nombre es igual a 0 y luego subrayado
edad igual a 0, así. Y en realidad porque
nuestro nombre es una cadena, solo
queremos hacer de
eso una cadena vacía. Entonces esto va a funcionar
bien porque no
toma ningún parámetro. No va a afectar
nuestro código aquí abajo cuando
creamos nuestro perro y nuestro objeto
gato, por ejemplo. Entonces, si seguimos adelante y
ejecutamos nuestro código aquí, puedes ver que funciona
igual que antes. Pero ahora lo que vamos a
hacer es seguir adelante y definir nuestro constructor aquí
fuera de nuestra clase, como hicimos con el método. Bien, entonces para hacer esto, lo
vamos a hacer es copiar o constructor y pegarlo
abajo aquí abajo, así. Y entonces sólo hay que hacer
es declararlo arriba. Entonces si quitamos la definición aquí y
solo tenemos lo que hay en esta línea superior y ponemos
un punto y coma así. Y luego aquí abajo, tenemos que hacer
lo mismo que hicimos aquí. Entonces diremos animal, seguido del operador de
resolución de alcance. Entonces
volverá a decir animal siendo el nombre
del constructor y también el nombre de nuestra clase
seguido de nuestros paréntesis. Y por último nuestra definición ahí. Entonces todo lo que tenemos que hacer es básicamente
lo mismo que hicimos aquí, excepto que no
teníamos un tipo de retorno, así que simplemente lo pusimos antes
del nombre del constructor eso, y esto va a funcionar bien. Entonces así es como puedes declarar un constructor ya sea dentro de
tu clase o fuera de ella, tal como podríamos con
nuestra función aquí. Ahora bien, una cosa que sí
quiero mencionar es que un constructor
necesita ser público. Y eso es porque como dije, un constructor es un método
especial que se ejecuta cuando se crea un
objeto de la clase. Y como creamos nuestros objetos de nuestra clase
fuera de la clase, el constructor
necesita ser público. Así que no se olvide de eso.
Ahora bien, ¿y si quisiéramos agregar algunos parámetros
a nuestro constructor? Bueno, tenemos un
par de opciones. Uno, podemos agregarlos a
este constructor aquí, o podemos sobrecargarlo al
igual que podemos sobrecargar
funciones
creando otro
constructor con el mismo nombre exacto que
tome diferentes parámetros. Pero sigamos adelante y solo
cambiemos el que tenemos aquí. Entonces lo que vamos a hacer es decir cadena nombre coma
h, así como así. Y vamos a copiar esto abajo en nuestro
constructor real abajo. Y luego en lugar de
simplemente darles un valor en blanco para comenzar, sigamos adelante y pongamos
lo que hace nuestros parámetros aquí. Entonces vamos a decir guión bajo
nombre es igual a nombre, y guión bajo edad es igual a edad. Recuerde, estos son miembros
reales de la clase. Y estos son los parámetros en los
que nos pasaron. Y esa es otra
razón por la que es agradable prefijar a tus miembros
con un guion bajo. Hazte saber
que es miembro. Cuando trabajas con
él en el futuro, no
tienes que ir a
revisar las cosas. Entonces ahora si bajamos aquí, se
puede ver que
tenemos un error. Y eso es porque el
único constructor ahora para nuestra clase animal
requiere de dos parámetros. Porque si recuerdas, desde que creamos un constructor, el predeterminado que se
hubiera visto así, ya no existe. Y podrías tener lo que sea
Cody, uno de ellos aquí. Entonces podría decir que tal vez imprimir se creó
un nuevo animal
o algo así. Y todo este código se ejecutaría
cada vez que creamos un nuevo animal y usaríamos estos parámetros para llamar específicamente a
este constructor,
ahora mismo solo tenemos uno, pero si lo sobrecargó, entonces tendríamos que tener
estos parámetros para
llamar a éste aquí específicamente, como hemos visto cuando sobrecargamos
funciones y el pasado. Entonces ahora si volvemos aquí abajo, si leemos lo que dice este error, cuanto no haya ningún
constructor predeterminado para animal, es
decir, ahora necesitamos parámetros
y podemos arreglarlo. A mí me gusta lo dije, sobrecargando
esto y teniendo uno que no tome parámetros y se vea igual que los de aquí. O podemos dejar esto y decir, Oye, ahora si quieres
crear un animal, necesitas poner
estos dos valores, y eso es lo que vamos a hacer. Entonces aquí abajo, todo lo que tenemos que
hacer si el perro es tener dos paréntesis y luego
necesitamos insertar nuestros parámetros. Así que en vez de decir lugar aquí, sólo
voy a
ponerlo aquí mismo. En su mayoría coma Minnesota se
hundió hasta aquí. Lo pondremos aquí mismo. Entonces podemos simplemente
deshacernos de esto por completo, ya que ya lo hemos hecho
aquí, cuando se inicialice, va a dar
el nombre del perro, el nombre que ingresamos
en la edad del perro, la edad que nosotros ingresado, y eso va a hacer lo
mismo con nuestro gato. No, esto no es cambiar las
variables en clase aquí. Esto está cambiando tu instancia
específica de estas variables. Entonces hacer algo
así en nuestro caso aquí, es exactamente lo mismo que eso. Entonces sigamos adelante y hagamos lo
mismo por el gato. Entonces voy a tener un
paréntesis abierto para empezar. Y luego si ven aquí, realidad
puedo dar click
sobre estas flechas. Y dirá: Oye, el animal toma un nombre de cadena
h. Así que pondremos un nombre. Pondré una coma R
y pondré una H. Y ahora cuando ejecutemos nuestro código, y va a funcionar
tal como lo hacía antes. Y que en realidad existe nuestro segundo tipo de constructor. Así que ya hemos
hablado de lo es
un constructor predeterminado, que es básicamente solo
un constructor vacío que no toma ningún
parámetro y no ejecuta ningún código en el constructor que creado aquí como en realidad el
segundo tipo de constructor, que se llama constructor
parametrizado. Y un constructor parametrizado es básicamente justo
lo que parece. Tiene un constructor que toma parámetros y no olvides, el propósito principal de un
constructor es generalmente
dar a los miembros de tu clase
aquí un valor inicial. Entonces ahí tienes. Entonces tenemos un último tipo
de constructor, llamar al constructor copy. Qué
es un constructor de copia como una función que inicializa un objeto usando otro objeto de
la misma clase. Entonces, sigamos adelante y echemos un vistazo a cómo es esto. Y no vamos
a echar un vistazo a la versión detallada de
esto bajo el capó. Y no vamos
a estar creando uno nosotros mismos así como
creados por defecto. Eso funciona
bien en la mayoría de los casos. Entonces, ¿cómo funciona esto? Bueno, por ejemplo, tenemos
un animal llamado perro, en un animal llamado gato. Pero también podemos tener una instancia
de nuestra clase animal y simplemente ponerla igual
a otra instancia
que ya existe. Y esto
esencialmente lo copiará. Y ahí es donde entra en juego tu
constructor de copias. Entonces podríamos decir animal,
gato a liberales, gato y cola de gato es
ahora una copia de gato. Y luego aquí abajo, podemos imprimir esto
diciendo print animal. Entonces aquí vamos a decir gato dos
y luego digamos que sí, así, bien,
y ejecutar nuestro código. Y ahí tienes. Ahora lo imprimimos perro con el nombre spot H02 y
dice manchas ¿dice qué? Porque eso es lo que me puse aquí de lo que hizo lo mismo para Garfield que hicimos lo mismo con
el gato dos. Y fíjate que todos los
valores son iguales, pero dice algo
un poco diferente porque enviamos en un argumento diferente con nuestra función print animal que creamos en un pasado video. Entonces ahí tienes. Esos son los tres
tipos diferentes de constructores. Tienes tu constructor
predeterminado, que simplemente está
completamente vacío y no requiere que tengas
ningún parámetro en absoluto. Tienes un
constructor parametrizado, que es un constructor
con parámetros. Y luego tienes tu constructor de
copia, que como dije, hay
uno creado por defecto. Y muchas veces
eso funciona bien, lo que básicamente
te permite tomar una instancia de una clase y crear una copia de la misma. Y no olvides que
los constructores necesitan ser públicos. Y que muchas veces
su principal uso es
inicializar a los
miembros de la clase. Y aquí solo quiero seguir
adelante y eliminar este gato a animal aquí junto con la
función que va con él. No olvides
guardar lo que tienes. Gracias por mirar, y te
veré en la siguiente.
87. Capítulo 15 (clases): inicializadores de la lista: En este video,
vamos a estar
hablando de listas de inicializadores. Pero antes de hacerlo, vamos a seguir adelante y simplemente eliminar parte del código aquí que realmente no necesitamos
para futuros ejemplos. Entonces antes que nada, vamos a
seguir adelante y eliminar nuestro método animal de impresión aquí que toma a un
animal como parámetro. Entonces seguiremos adelante y solo
eliminaremos eso por completo. Luego también eliminaremos las llamadas R2
a esa función. Y por último, eliminará
el prototipo de función. Para. Ahora, solo tenemos nuestras dos instancias u
objetos animales junto con
nuestra clase animal, la función speak y
nuestro constructor animal. Y también te habrás dado cuenta, acabo de agregar algunos comentarios aquí, solo un poco recordaros
chicos qué es todo. Entonces una lista de inicializadores es lo que quieres
usar cuando quieres dar
a
los miembros de datos en tu clase. Por ejemplo, nuestras dos variables
aquí, un valor inicial. Entonces en el último video, seguimos adelante e hicimos esto
con nuestro constructor aquí. Y así también es
como podrías
verlo hecho en otros idiomas, pero en C plus plus, esta no es la forma correcta de inicializar
a tus miembros. Y hay múltiples
razones para ello. Por un lado, ciertos tipos de miembros no se
pueden inicializar de esta manera. Además, es menos
eficiente en términos de desempeño y
varias otras razones. Entonces, sigamos adelante y
echemos un vistazo a la, la forma correcta de hacerlo. Además, si ustedes recuerdan, una forma de crear una
variable es decir, int x. Y luego en lugar de
tener un signo igual seguido de un valor, solo se
puede decir int x. Y luego entre paréntesis
tener el valor, puede poner punto y coma al final. Y esto es exactamente lo
mismo, ¿verdad? La razón por la que quería
recordarte esa opción de sintaxis, es porque vamos a
estar usando algo muy similar cuando inicialicemos los miembros y nuestra clase aquí
usando una lista de inicialización. De todos modos, sigamos adelante y echemos un vistazo
a cómo crear uno. Entonces aquí mismo en
nuestro constructor, todo lo que tenemos que hacer al final
de este paréntesis aquí, digo dos puntos y luego
subrayado nombre, por ejemplo, porque esta es la variable o el miembro que
queremos inicializar. Y luego entre paréntesis, podemos simplemente poner en él el parámetro que vamos
a pasar. Así que lo pondremos igual a
nombre, así como así, entonces cualquier otro miembro era
un separado con una coma, así que digamos coma subrayado edad
y luego entre paréntesis, igual a la edad se quedan en
su parámetro aquí, y eso es más o menos. Así que esto aquí va a hacer
esencialmente lo
mismo que hicimos aquí es que
realmente podemos seguir adelante y eliminar este código y
nuestro bloque de código aquí. Y también esto limpia
las cosas también. Así que ahora digamos que teníamos
un montón de miembros aquí, lugar de tener que
inicializarlos en nuestro bloque de código aquí
y tener x es igual a 0, y es igual a 0, z es igual a 0, y así sucesivamente ahora está todo
aquí fuera del camino . Y todo en nuestro
bloque de código es código real que queremos ejecutar además de la inicialización
de nuestros miembros. Entonces esta es la forma correcta de inicializar miembros
en tus clases. Y deberías hacerlo de esta
manera cada vez. Entonces, ¿no tienes que
pensar en cuándo lo hago esta manera y cuándo lo
hago de otra manera? Siempre lo hago de esta manera. Y recuerda hacer esto. Todo lo que vas a hacer como
después de tus paréntesis y dos puntos seguidos
por el miembro. Y entre paréntesis, tendrás el valor
al que quieres establecerlo igual. Y luego por cada
miembro extra que
quieras inicializar, simplemente
lo separarás por una coma así. Ahora esto no tiene que
tomar un perímetro. Podríamos equipararlo a
lo que quisiéramos. Pero en este caso, ya que
teníamos parámetros y nuestro constructor que se hicieron para inicializar estos valores, seguimos adelante y solo usamos
nuestros nombres de perímetro también. Una última cosa que quiero señalar es que estos deben estar exactamente en el mismo orden que sus miembros están
listados en su clase. Entonces porque nuestro nombre viene
primero y luego tenemos nuestro entero para la edad y
necesita ser inicializado. Mismo orden exacto. Esto es increíblemente
importante ya que son múltiples errores que pueden
surgir si
los hicieras fuera de servicio. Así que asegúrate de hacerlo
siempre en orden tal como lo tienes aquí
de arriba a abajo. Y ahora, si ejecutamos nuestro código, puedes ver que funcionó
bien sin ningún error. Y de hecho en nuestro
constructor aquí, vamos a seguir adelante
y agregar algún código para imprimir cuando se
creó un animal y especificando
las variables dentro de él. Así dicen CL y
animal fue creado. El siguiente. Recuerda atributos como otro
nombre que podrías ver para los miembros o variables
de tu clase. Y luego líneas como esta. Y luego aquí abajo,
diremos nombre, espacio de dos puntos. Lo seguiremos conmigo. Y podríamos haber
puesto también el nombre de subrayado aquí. Realmente no va a
hacer ninguna diferencia. Y crearemos una nueva
línea después de eso también. Y luego por debajo de eso
dirá espacio de página así. Y seguiremos esto con h. Y crearemos una nueva
línea después de eso también. Y sólo para mostrarte
que no hace diferencia, vamos a seguir adelante y poner
subrayado edad para éste. Y si ejecutamos nuestro código aquí, puedes ver que
funcionó bien. Y si quisiéramos
limpiarlo un poco, podemos seguir adelante y
crear un par de líneas en blanco adicionales aquí. Y ahí tienes. Y solo
voy a seguir adelante y poner esto de nuevo a nuestro nombre de
parámetro aquí, siendo la edad. De todos modos, eso es todo
para este video, ahora
sabes la forma correcta de
inicializar miembros
en tu clase, siendo una
lista de inicialización, que para resumir, todo lo que tienes que hacer es al final de tu constructor aquí, justo después del paréntesis, vas a poner dos puntos
seguidos de cada miembro en orden y entre paréntesis,
tendrás el
valor en el que
vas a establecer cada uno de ellos n. Podrías hacer esto por cada constructor
que tengas. Porque si recuerdas, puedes sobrecargar constructores, lo que significa que aquí podemos tener
múltiples diferentes para nuestra clase animal, que todos tendrán
el nombre animal, ya que un constructor tiene el
mismo nombre que la clase. De todos modos, gracias por mirar, y te veré
en la siguiente.
88. Capítulo 15 (Clases): encapsulación, abstracción y propiedades: En este video,
vamos a estar
hablando de un par de cosas
diferentes. El primero es un concepto
llamado encapsulación, que tiene uno de los
cuatro principios principales de la programación orientada a objetos. Pero también estaremos tocando
los otros tres principios principales
más adelante en este curso. Y luego la otra cosa de la que
vamos a estar hablando en este video como
getters y setters, lo que nos ayudará a que podamos poner en acción la encapsulación. Entonces, ¿qué es la encapsulación? La encapsulación en
pocas palabras es básicamente el proceso de
envolver o combinar datos y código que actúa
sobre esos datos juntos
en una sola unidad. Y esta sola unidad
sería algo así como una clase. Y muchas veces a lo que
esto lleva es ocultar tus datos detrás de un código que
pueda interactuar con eso. adelante y echemos un
vistazo a cómo implementarlo adecuadamente
en nuestra clase de animales aquí, así
como el caso de uso para ello. Entonces sabes cuándo y cómo
implementarlo en tus propios programas en el futuro. Así que vamos a meternos en ello. Lo primero que
vamos a hacer aquí es aquí arriba en nuestra clase de animales, vamos a seguir adelante
y crear otro entero llamado salud. Entonces justo por debajo o int edad, sigamos adelante y digamos
M subrayar la salud. Y luego abajo en
nuestro constructor, sigamos adelante y
agreguemos esta variable a nuestra lista de inicializadores. Entonces después de subrayar la
edad con la edad y énfasis ahí, vamos a decir coma
subrayado salud. Entonces entre paréntesis, sólo
vamos a establecer esto igual a un 100. ¿Bien? Entonces esto solo va a
tener un valor por defecto de 100 representa un 100% o como
quiera verlo. Cada animal va a tener
un 100 de salud para empezar. Y ni siquiera vamos a
tomar esto como parámetro. Esto solo será
el valor predeterminado para cada animal ya que
este es nuestro único constructor. Ahora, actualmente, si queremos
cambiar la salud
de nuestro perro aquí, podemos decir algo así. Así que aquí abajo en
nuestra función principal bajo donde creamos a nuestro perro, podemos decir perro punto subrayado
salud menos es igual a 50. Y esto va a funcionar bien. No hay nada que nos impida cambiar esta variable a
lo que queramos que sea. Y si seguimos adelante e
imprimimos salud aquí, entonces diremos C out dark dot health y solo
crearemos una nueva línea. Entonces sigamos adelante y también imprimimos que esta
era la salud del perro. Entonces diremos perros es igual a coartada o salud de los perros
y crearemos una nueva línea. Ahora bien, si ejecutamos un código,
puedes ver oye, y los animales creados con los siguientes atributos,
el nombre es Spot de dos años
y la salud de los perros era F D. Y voy a seguir adelante y agregar algunas líneas en blanco adicionales aquí. Entonces solo diremos la
línea M unas cuantas veces. Solo así cuando
ejecutamos nuestro código aquí, es un poco más legible. ¿Bien? Bien, lo siento, la salud de
los perros es de 50. Bueno, y si seguimos
adelante y le restamos otros 50 de salud a nuestro
perro por cualquier motivo. Pero ahora si ejecutamos nuestro código, se
puede ver que
su salud es 0. Bueno, ¿y si hacemos
esto una vez más? Así que vamos a seguir adelante y
pegarlo abajo, así como así. Bueno, ahora este valor
es negativo 50 y tal vez no queramos
que eso suceda para uno. Y aunque nos olvidamos de
programar en una semana, no
queríamos que nuestra
salud estuviera por debajo de los 50 si queríamos ir a
cambiar eso más tarde. Actualmente, tendríamos que
hacer algo como esto. Primero, tendríamos que encontrar todas las veces que
cambiamos
la salud de los perros. Y entonces tendríamos que
poner esto como una declaración if
o algo así. Dices que f perro punto
subrayado salud es mayor o igual
a 50, por ejemplo. Entonces queremos
hacer lo siguiente. Y entonces podríamos pegar eso en. O podríamos decir algo así como que la salud es menor que 0. Entonces queremos establecer un perro
que la salud sea igual a 0. Así. Y esto funcionaría, pero esto podría llegar a ser
bastante molesto. Y entonces si quisiéramos
hacer
algo más con esto más adelante, ahora tenemos que
volver a encontrar
todos estos spots y cambiarlos todos. Una vez más. Ojalá puedan ver
que esto podría convertirse en un problema realmente grande con el tiempo, especialmente a medida que nuestro programa crece. Y podríamos tener
múltiples secciones de código o se
eliminaría la salud de un perro. O si estamos haciendo un juego aquí, puede
haber múltiples
cosas que afecten salud de
nuestros perros o
algo así. Entonces, ¿qué podemos hacer en su lugar? Bueno, sigamos adelante y
dejemos esto aquí por ahora. Entonces subamos a
nuestra clase de animales aquí. Entonces lo que podemos hacer
es tener un par de funciones para cada uno
de nuestros miembros aquí, para obtener y establecer
los valores respectivamente. Podemos tener todas las
reglas para obtenerlas y establecerlas dentro de
esas funciones. Y si hacemos que estos miembros aquí solo sean accesibles
a través de esas funciones, entonces sabemos que
en ninguna parte de nuestro código
puede haber algo
así que cambie la variable de alguna manera
que no especificamos. Entonces sigamos adelante y hagamos eso. Entonces estas funciones
que vamos a estar creando algo llamado
getters y setters. Y antes de crear estos, lo que vamos a
hacer es hacer que todos nuestros miembros aquí sean privados, por lo que solo son accesibles desde
dentro de las funciones para
nuestros captadores y setters. Entonces, abajo de nuestra
declaración de constructor aquí, vamos a decir dos puntos
privados. Si recuerdas, este era
nuestro especificador de acceso. Ahora tenemos a nuestros miembros públicos y tenemos a nuestros miembros privados. Y lo que vamos a hacer es copiar todos nuestros miembros de aquí arriba. En realidad los vamos
a cortar y
luego los pegaremos aquí abajo. Y ahora son
privados y de carga. Ahora, en lugar de crear
uno para cada uno de estos, solo
diremos que el nombre y la
edad no se pueden cambiar una vez se crea
el objeto usando
estos parámetros aquí. Y así solo
crearemos uno para la salud. Y aunque podríamos haber
creado uno para estos, esto solo nos ahorrará
algo de tiempo y te darás la idea de cómo
funciona esto independientemente. Entonces aquí arriba,
vamos a crear un par de funciones públicas. 1 primer ajuste de salud, y uno para obtener ayuda. Entonces sigamos adelante
y hagamos eso primero. Nosotros diremos ¡Fuera! Y luego entre paréntesis, no
tendremos parámetros seguidos de nuestro
bloque de código, así. Y lo que vamos a decir
es que se devuelve subrayado. Y luego abajo,
esto creará una función para establecer la salud. Entonces diremos conjunto de vacío salud. Y luego entre paréntesis aquí, en realidad
tomaremos un argumento. Entonces tendremos que
crear un parámetro aquí y diremos int. Y entonces en nuestro bloque de código
dirá subrayado salud es igual. Y esta es la sintaxis
más básica para crear un
getter y un setter. Y si vienes de otro lenguaje de
programación, es posible que
los reconozcas como propiedades. Pero de todos modos, este top de aquí es nuestro captador porque esto consigue el valor para nosotros y este de
abajo aquí es nuestro centro. Ahora bien, podrías estar pensando, ¿cómo es esto mejor que
si lo hiciéramos público? Ahora, actualmente no lo es. Pero echaremos un vistazo a
cómo esto puede volverse más complejo y ser útil
en solo un momento. Entonces ahora si volvemos
a bajar a nuestra función principal aquí, puedes ver que tenemos
un error diciendo: Oye, la salud no es accesible y eso es porque la
hicimos privada. Entonces lo que vamos a tener que
hacer ahora es lo siguiente. Así que aquí mismo en cambio ahora
vamos a tener que decir
perro punto set salud. Entonces pondremos un
menos 50 así. Y vamos a seguir adelante
y pegar eso tres veces para replicar
lo que teníamos antes. Y luego aquí mismo, cuando queríamos
imprimir la salud del perro, diremos perro punto obtener salud. Y esto nos devolverá el valor
entero. Y ahora si ejecutamos nuestro código, puedes ver que esto
funcionó bien y
funciona de la
misma manera que lo hacía antes. Y podrías estar
pensando para ti mismo, Bueno, ¿cómo es esto mejor? Bueno, sigamos adelante
y echemos un
vistazo a los beneficios de
lo que acabamos de hacer. Entonces, si volvemos a
nuestra clase de animales aquí, quiero mostrarte
una cosa rápido. En primer lugar, observe que aquí
podemos acceder a la salud de
subrayado antes de que
mencionáramos aquí
podemos acceder a la salud de
subrayado antes de que
mencionáramos qué era la salud de
subrayado. Y por cierto, muy rápido, normalmente cuando
tienes miembros públicos y miembros privados, querrás tener
los públicos primero
querrás tener
los públicos para que cuando alguien
mire tu clase, obtenga toda la información
que necesitan aquí mismo. Como normalmente los miembros privados realmente no son tan importantes si los
van a necesitar en absoluto y
deberían poder contar todo lo que está
pasando desde aquí mismo. Pero de todos modos, volviendo a lo
que estaba hablando, ¿por qué podemos acceder a
esto cuando esto está aquí abajo? Y eso es porque lo que
tenemos aquí actualmente, cuando se trata de clases, en realidad no
es leer
la forma en que se ve y cómo realmente ha
leído es como tal. Entonces, lo que vamos a hacer para
mostrarte cómo
se ve realmente a nuestro programa cuando lee
nuestro código aquí es, vamos a seguir
adelante y copiar estas dos funciones y
pegarlas abajo aquí. Y los vamos a pegar justo en
la parte inferior ahora mismo. Y también sigamos adelante y
movamos nuestra función de hablar ahí
abajo también. Lo siento constructores
en su momento, así. Y ahora vamos a cambiar estos aquí arriba de vuelta en nuestra clase. Déjame alejar un poco para que
puedas ver como que Gran Bretaña cambie estos aquí arriba para que solo
sean prototipos de funciones. Entonces pondremos punto y coma y luego eliminaremos
el bloque de código. Cada una de estas líneas aquí. Y luego aquí abajo
en la parte inferior, vamos a seguir adelante
y agregar nuestro nombre de clase, seguido del operador de
resolución de alcance, como hicimos con
nuestra función de hablar. Así que permítanme simplemente copiar eso y
pegarlo en ambos de estos. Así es como nuestro código se
leía antes. Entonces es por eso que podemos tener
la declaración de la variable después de nuestra definición de método es porque en realidad fue leída. Ahí es donde tenemos
nuestro prototipo o la declaración de
nuestra función aquí, y luego la definición
después del final de la clase. Entonces eso es algo que
no funciona normalmente. Pero cuando se trata de clases, por ejemplo, sí lo hace. Así que solo quería
darte un aviso sobre eso. Ella no estaba súper confundida. ¿Por qué eso estuvo funcionando ya que eso nunca ha funcionado
para nosotros en el pasado? Entonces ahora sigamos adelante
y echemos un vistazo a cómo estos getters y setters
son realmente útiles. Y también lo que hemos hecho aquí al que este miembro de Salud sea privado y tenerlo encapsulado dentro de
estas dos funciones. Aquí hay un excelente ejemplo
de encapsulación. Ahora lo que podemos hacer en nuestra
configuración aquí es lo siguiente. Entonces después de decir
subrayamos la salud. salud de las personas. También
podemos seguir adelante y establecer un valor Min y un
valor máximo para esto. Entonces ahora si quisiéramos, podríamos decir F subrayado salud es mayor que un
100, por ejemplo. Después subrayar
la salud equivale a un 100. Y por debajo de eso podríamos decir f, o simplemente podríamos crear
otra declaración if aquí. Entonces vamos a seguir adelante y decir F subrayado salud
es menor que 0. Entonces subrayar la salud
es igual a 0, así como así. Y ahora cuando algo afecta salud de
nuestros perros o cualquier objeto o instancia
de nuestra clase animal. Entonces otro, ese era
el perro o el gato, u otro animal que pudiéramos crear en cualquier momento que
intentemos afectar la salud, ahora
tenemos que pasar por esta función de salud
establecida y
podemos agregar cualquier código a esto más tarde sin romper
nuestro código aquí abajo. Observe que no tuvimos que
meterse con nada
aquí abajo para agregar un valor mínimo
y máximo ahora, y podemos
imprimir algo en cualquier momento o la salud se configuró para mostrar nuestro nuevo valor de salud si nosotros lo queremos o lo
que quieras hacer. Y no tenemos que
cambiar nada aquí abajo. Entonces porque tenemos estos
getters y setters, nuestro código es mucho más dinámico
y no tenemos que
preocuparnos por todas las veces que
intentamos obtener y
establecer esta variable. Además, no tenemos que
preocuparnos de que nada pase estas funciones
y solo cambie esta variable directamente
porque es privada, es
decir, solo está
disponible dentro de nuestra clase, razón por la
cual nuestra función aquí, que forma parte de
nuestra clase directamente, tiene acceso a ella, pero algo así como esta función
principal no lo haría. Entonces después de estas dos declaraciones
if, solo
voy a decir que la salud
máxima es igual a 100. Y aquí abajo, voy a
decir salud mínima 0, así, solo para
recordarnos lo que estos están haciendo aquí. Ahora, si ejecutamos nuestro código, puedes ver que la
salud del perro solo bajará a 0 ahora debido a esta
funcionalidad extra que agregamos. Y fíjate una vez más, no
tuvimos que cambiar
nada hecho aquí. De todos modos, eso es todo
para este video. Pero sigamos adelante y recapitulemos
lo que hemos aprendido aquí. Por un lado, cuando
se trata de clases, en realidad
puedes tener un método, declaración y
definición antes cualquier declaración de variable
que use ya que en realidad se
lee así. Sin embargo, dicho eso la forma correcta y la forma en que debes
hacerlo de aquí en adelante para escribir una
definición de método es tener tu declaración
dentro de la clase y la definición
fuera de la clase. Por un lado, esto ayuda a abarrotar su código
y en el futuro, si alguna vez separa
esta clase y hace su propio archivo de encabezado y
archivo CPP o archivo C plus. Esto hará
las cosas mucho más fáciles. Por lo que siempre debes tener tus definiciones
fuera de la clase. Entonces, como regla general, tu clase solo debe
tener declaraciones y fuera de la clase
deberían estar tus definiciones. Así que solo tenlo en
mente para el futuro. Ahora, la otra
cosa que aprendimos es cómo crear un
getter y un setter. Y aunque ya sabíamos
cómo crear funciones, ahora
conocemos los casos de uso para crear funciones específicas, para obtener y establecer variables
privadas
dentro de nuestra clase. Y también aprendemos la forma
correcta de enumerar a nuestros miembros públicos frente a
nuestros miembros privados que son públicos en la parte superior y
privados abajo, puedes hacer esto de la
manera que quieras. Pero esta es la forma adecuada y probablemente la más
preferida de hacerlo. Porque como dije,
como alguien
mira a tu clase abajo de
la línea respirando, si miras el
código en tu clase, es bueno tener todas las cosas
públicas arriba aquí porque esto suele ser
todo lo que me importa. Y muchas veces los
miembros actuales son como una cosa de fondo que te puede importar o
no. En realidad echando un vistazo a. Si la clase fuera más grande, puede
haber aún más información
privada para tener que tamizar para llegar a las cosas
que nos importan si estas fueron escritas
al revés. Entonces, como regla general, debes tener a tus miembros
públicos arriba. Y luego aprendimos a
usar nuestro getter y setter y el caso de uso y algunos de los
beneficios de crearlos. Entonces, lo principal
que hay que llevar es cómo utilizar la encapsulación. Entonces tienes todas tus declaraciones
dentro de tu clase y tus definiciones fuera de
ella están escritas fuera de ella. Y entonces cuando puedas, siempre
debes
tener a tus miembros privados para que se pueda acceder a ellos de formas que no
quieras que se
ralenticen la línea. Se quiere cambiar la
forma en que trabajaron con ellos. No tienes que ir buscándolo
por todas partes en tu código y
buscando cómo solucionarlo, sobre todo por un error
o algo así. Todo lo que tienes que hacer
es mirar aquí mismo. Entonces, lo que hemos hecho aquí es
trabajar con dos de los cuatro pilares principales de la programación orientada a
objetos. Una es obstrucción y la
otra es encapsulación. Y hablaremos de estos un poco más de detalle
en un video posterior. Pero rápidamente
resumen cuáles son estos y cómo practicamos o
trabajamos con ambos. La abstracción como método o proceso de ocultación de información
no deseada. Cuando tomamos nuestros miembros
son nuestras variables aquí y los
golpeamos desde el mundo exterior o desde el resto de nuestro código, estábamos practicando la abstracción. Mientras que la encapsulación
fue el proceso real de contener la información. Y así estos dos
trabajan de la mano. Así que abstraymos la información o una oculta del
mundo exterior o del resto de nuestro código haciendo privados a
estos miembros aquí, por ejemplo. Y luego encapsulamos
esta información dentro estos métodos o
funciones también. Entonces ahí lo tienes. De todos modos, eso
es todo para este video. No olvides
guardar lo que tienes. Gracias por mirar, y te
veré en la siguiente.
89. 88: En este video, vamos a estar
hablando de herencia. La herencia
en realidad va a ser nuestro tercer pilar de la programación
orientada a objetos. Ahora bien, estos
no están en un orden específico. Esto simplemente pasa
a ser el tercero del que hemos
hablado hasta ahora. Entonces, ¿qué es la herencia? Bueno, es la capacidad
de una clase para heredar o derivar propiedades junto con características
de otra clase. Y seguiremos adelante
y crearemos y echaremos un vistazo a un ejemplo. Así que comencemos
primero lo primero, adelante y
eliminemos algunas cosas de nuestro código solo para
limpiar un poco las cosas aquí arriba. Entonces lo que vamos a hacer es fuera de crear
nuestro perro y gato, no
vamos a mover las
otras líneas de código y nuestra
función principal así como así. Y entonces también sólo voy
a seguir adelante y minimizar nuestro setter y getter ya que ya
sabemos lo que hacen. Entonces también voy a seguir
adelante y minimizar nuestro constructor de animales también. Entonces voy a seguir adelante y
mover nuestra función de hablar. Así que voy a cortar
ese rápido por debajo de nuestro centro de aquí. Entonces también lo cambiaré aquí arriba donde tenemos nuestra
declaración de ello. Así que voy a poner eso
abajo así. Y ahí vamos. Ahora mismo, este es mucho
menos código para mirar. Entonces lo que vamos a hacer
es en lugar de tener nuestra clase animal y
luego simplemente indicar el nombre de nuestro objeto o una instancia de él
como perro y gato. Marxismo y crear dos subclases
y/o clases derivadas. Uno para un perro, en uno
para un gato que
ambos van a heredar
de la clase animal, pero ambos tienen algo
único en ellos. Y lo que esto hace
por nosotros es permitirnos obtener todo lo que
hemos creado como parte de nuestra
clase animal y
ponerlo en otra clase
sin tener que repetirlo. No sólo puede llevar
al error humano, sino que además solo hace las cosas desordenadas cuando sabemos
algo como, Oye, cada animal va a tener esta funcionalidad
y algo más. Entonces lo que podemos hacer es simplemente crear algunas subclases fueron clases
derivadas que heredan de esto. Así que comencemos por debajo nuestra definición de función aquí, vamos a hacer lo siguiente. Vamos a decir perro de clase. Y luego dentro de
nuestras llaves, tendremos nuestro código
para nuestra clase de perros, pero no solo queremos
crear una clase llamada Dog. Queremos que herede de nuestra clase
animal porque un perro es un animal y ya
hemos creado una definición para lo que
cada animal tiene. Bien, entonces lo que
vamos a hacer para heredar de nuestra clase animal es simplemente después del nombre de nuestra clase, digamos dos puntos, seguido de
un especificador de acceso. En este caso
vamos a decir público. Y voy a llegar a eso
en un momento. Y luego el nombre de la
clase que queremos heredar del animal público,
así como así. Y ahí vamos.
Ahora hemos creado una subclase o una clase derivada. A menudo escuchas estas palabras
usadas indistintamente que hereda de nuestra
clase base o nuestra súper clase. Por lo que es posible que escuches esto
referido como super y sub o base y derivado. Ahora bien, ¿por qué dijimos público aquí? Bueno, déjame decirte. Entonces, si pones público antes que
el nombre de la clase base, esto es lo que
va a pasar. Entonces, si recuerdas, tienes tres especificadores de
acceso diferentes. Público, protegido. Y privado. El público hace que todos los miembros
estén disponibles en todas partes. Protegido, hace que todos
los miembros solo estén disponibles en la clase y cualquier clase
que herede de ella. Y luego privado hace que
todos los miembros solo estén disponibles dentro de
la clase específicamente. Y así sucede aquí es
si dices público aquí, todos los miembros
de animal que somos públicos son públicos
para nuestra clase de perros. Todo lo que estaba protegido está protegido para nuestra clase de perros. Y todo lo que
era privado es privado para nuestra clase de perros. Dicho esto, no se
puede acceder directamente a
los miembros privados de una clase base desde la clase derivada. Mientras que los miembros protegidos pueden, decir, cualquier cosa
que fuera privada, no
será accesible directamente
desde nuestra clase de perros aquí. Entonces, ¿qué pasaría si
en lugar de decir público aquí cambiáramos esto para protegerlo? Bueno, esencialmente,
cualquier cosa que
heredamos que fuera pública
estaría protegida. Cualquier cosa que estuviera protegida
quedaría protegida. Y todo lo que fuera
privado, que se quede privado. Entonces ahora básicamente estamos
cortando cualquier cosa que fuera pública y moviéndola
hacia arriba en producción. Y si dijéramos privados aquí, los miembros que heredamos
serían todos privados. Sin embargo, solo las cosas
que eran privadas en la clase base no serían accesibles directamente
desde nuestra clase de perros. Y todo lo que
se hizo privado de poner privado
aquí ahora
será privado en nuestra clase de perros
y cómo eso nos afecta. Si estás un poco
confundido lo hay, puedes heredar de
una subclase como esta. Podríamos crear una otra
clase que heredó del perro, que hereda del animal. Y podrías hacer esto una
y otra vez si lo quieres. Y al igual que podríamos
tener otras clases que heredan del perro. El perro también puede heredar de
varias clases también. Y para hacer eso, todo lo que tendrías que
hacer es decir coma animal. Y sigue eso con
la otra clase o clases que te gustaría heredar de
cada una separada con una coma. Y luego pondrías primero el especificador de
acceso, una vez más para cada uno y
seguirías eso con el nombre. Entonces, todo lo que tenemos aquí, tendrías que poner
después de esta coma por cada otra clase de la que
fuiste a heredar. Tan bastante simple. Ahora no vamos a estar
sumergiéndonos en todas las diferentes formas de herencia que podrías ver en este curso o con las que trabajas. Pero solo debes saber que puedes
heredar de múltiples clases. E incluso puedes heredar
de las subclases. E incluso podrías heredar de esos también
si quieres, y la lista continúa. Pero para nosotros aquí, lo que vamos a hacer es
simplemente echar un vistazo a la forma más básica
de herencia, siendo tener una clase que hereda de una
sola clase base. Así que de todos modos, sigamos
adelante y sigamos adelante. Ojalá que todo
tuviera sentido para ti. Entonces porque dijimos público escuchar todo lo que era público, habría mantenido público en
nuestra clase de perros porque hereda a todos los miembros de nuestra clase de
animales. Todo lo que estaba protegido, que no teníamos
nada se habría mantenido protegido y cualquier cosa que fuera privada para nuestra
clase de animales no será directamente accesible desde nuestra clase de perros
porque era privado, solo accesible para
esta clase aquí. Y ahora lo que vamos a hacer
es vamos a crear un constructor para nuestra clase de perros. Pero una cosa que
debemos tener en cuenta es que cada vez que se
crea un perro y se
crea un animal en el fondo. Y si recuerdas, en realidad
nos deshicimos de nuestro constructor de animales predeterminado, que no tomó
ningún parámetro,
es decir, actualmente para crear
una instancia de un animal, animal aquí necesita una
cadena para un y un número entero para una edad. Entonces, ¿cómo seguimos adelante
e implementamos eso? Una cosa que podríamos hacer es crear un constructor predeterminado que
no tome ningún parámetro. Y aunque eso
funcionaría y nos permitiría crear un perro
sin tener que tener ningún parámetro puesto para
inicializar nuestro nombre h aquí, no es realmente
lo que queremos ya que esto pasaría por alto la forma en que nosotros, estamos inicializando
nuestro nombre y edad al permitirnos darle un
nombre y edad aquí abajo. Entonces, en cambio,
podríamos seguir adelante y heredar a todos los
constructores de nuestra clase animal diciendo
usando seguido del nombre de la clase siendo animal a Colin siendo nuestra
resolución de alcance operador, seguido de la
palabra animal nuevamente, y un punto y coma al final. Lo que esto haría es heredar a
todos los constructores. Entonces ahora si bajamos aquí
y dijimos algo así como perro, mi perro puede poner nuestros paréntesis. Se puede ver que una de estas
opciones, y por cierto, solo
me desplazo por esas y las teclas de flecha
hacia abajo dice que, oye, necesitamos tener un
nombre y una edad ahora, y podemos simplemente lanzar un nombre y una edad como la que
hemos hecho en el pasado. Esto funcionaría bien, pero no vamos a hacer eso. Y te voy a mostrar por qué
aquí en un segundo. Entonces vamos a seguir adelante
y deshacernos de eso. Pero así es como
puedes heredar a todos los constructores
de tu clase base. En cambio, vamos a
hacer lo siguiente. Vamos a crear
un nuevo constructor para perro diciendo perro, abrir y cerrar paréntesis. Y entonces vamos
a poner punto y coma
al final ya que esta solo
va a ser nuestra declaración. Pero este de aquí
va a tomar los mismos parámetros que hizo
nuestra clase animal. Entonces vamos a decir nombre del perro, coma, int age, así como así. Entonces seguiremos adelante y copiaremos esta línea y la pegaremos
debajo de nuestra clase para
implementar realmente la definición. Entonces nos encontraremos con nuestras
llaves abiertas y cercanas como siempre. Y luego aquí arriba vamos
a usar un inicializador de listas para el constructor
de nuestra clase animal. Entonces diremos colon animal. Y luego entre paréntesis
se insertarán los parámetros que requiere el constructor
animal. Entonces tomaremos este nombre siendo
nuestro nombre de perímetro aquí, y solo insertaremos eso como el nombre o la variable de cadena para
este constructor de aquí arriba, luego diremos coma h, así. Y entonces si recuerdas, tenemos que volver aquí y decir perro siendo el
nombre de nuestra clase, colon colon, para
precisar que esta es la definición para este año. Y ahora todo
va a funcionar bien. Entonces ahora cuando creamos un perro, este es nuestro único constructor
para un perro y toma un nombre y una edad que va a hacer ahora es insertar
este nombre y edad en el nombre y edad
para el constructor para nuestra clase animal. Y vamos a repasar todo
esto aquí al final. Así que no te preocupes, si estás un poco confundido,
solo siguiéndolo. Y luego lo que vamos a hacer dentro de nuestro constructor aquí. Y subamos a donde
tenemos nuestro constructor animal y simplemente eliminemos todo el
código dentro de él así. Vamos a pegarlo aquí. Y luego vamos a decir C fuera. Se creó un perro con
los siguientes atributos, nombre, nombre, edad, edad. Y si quisiéramos, podríamos incluso decir algo
como c out health. Colon espacio 100, ya que
sabemos que nuestra salud siempre
va a ser 100 al inicio ahí. Entonces sólo vamos a seguir adelante
y lanzar un punto y coma. Y entonces lo que vamos a
hacer es copiar las n líneas de
aquí arriba o cortarlas, debería decir,
pegarlas aquí abajo, ¿verdad? Así que ahora cada vez que creamos un perro, y va a decir que se
creó un perro con los
siguientes atributos. El nombre es cualquier nombre que
pongamos cuando creamos un perro, siendo la
edad cualquier edad que pongamos
en cuando creamos un perro en, la salud por defecto será 100. Y eso es porque arriba en
nuestro constructor animal, cuando esto es Ram aquí, la salud se
establece automáticamente en 100. Entonces sigamos adelante y
copiemos todo esto aquí. Entonces todo, desde nuestra clase de perros hasta nuestro constructor de perros
y definición aquí. Y pegarlo abajo. Y vamos a
decir clase, gato, cambiarlo de perros cadena
nombre es Cat, String name. Y aquí abajo va a cambiar ambos
de estos dos, gato también. Yo diría gato en colon, gato, y podemos dejar
el resto como está. Y luego aquí abajo en el bloque de código
real dirá que se creó
un gato con
los siguientes atributos. Y ahí vamos. Ahora aquí abajo, en lugar de crear dos animales y llamar a un
perro y cuando un gato, vamos a crear un perro y un gato. Entonces sigamos adelante
y eliminemos esto. Y vamos a decir gato. Y por ahora solo llamaremos a
esto mi gato. Y luego entre paréntesis, necesitamos una cadena y luego una para el nombre
y otra para la edad. Por lo que llamamos a esto
Garfield una vez más. Y fijaremos la edad en dos comas
faltantes así. No pongas punto y coma
al final. Ahora fíjese aquí mismo, dice
que cat, cat o el constructor para cat es inaccesible
en la línea 81. Y eso es porque no
hicimos público a nuestro constructor. Recuerde, los miembros que salen de clase
son privados por defecto. Los constructores necesitan ser
públicos para que funcionen. Entonces solo diremos público. Entonces en poner dos puntos al final, y yo solo voy a seguir adelante y
sangrar esto para que sea un poco más legible y
haremos lo mismo por nuestro perro. Entonces aquí arriba,
diremos colon público. Entonces voy a seguir adelante
y entrar
en eso solo para que
sea más legible. Y ahí vamos. Ahora el error se ha ido. ¿A quiénes están todos buenos para ir? Entonces abajo de esto, si decía mi punto de gato, nota que puedo obtener
la salud porque
tengo acceso a esa función
pública. Y puedo fijar la
salud porque también
tenemos acceso a esa función
pública. Y también podemos hablar, que es la función que
creamos aquí arriba para simplemente imprimir cualquier
cadena que introduzcas. Así que sigamos adelante y metamos
con eso solo un poquito. Entonces diremos que mi gato murió. Establecer Salud. Y sólo vamos a seguir adelante
y decir algo como diez y poner punto y
coma al final. Y esto pondrá
nuestra salud en diez. Porque si recuerdas de
nuevo en nuestra función aquí, SAT health solo toma la cantidad de
salud que
ingresas y la establece igual a esa. Y si hubiéramos querido, podríamos haber creado
una función para cambiar la salud por
un valor específico. Y vamos a seguir adelante
y hacerlo rápido. Entonces aquí arriba, crearemos una nueva, otra función para
cambiar la salud. Quiero decir vacío, cambiar la salud. Y vamos a tomar en la mano la salud. Así como así. No pongo punto y
coma al final. Esta será una
función de cambiador de ayuda. Bien, sólo voy a añadir un
poco a estos comentarios aquí. Entonces tienes un getter para la salud,
un setter, y un cambiador. Y si copiamos esta
declaración aquí, y luego bajamos aquí, y de hecho voy
a seguir adelante y minimizar nuestra función celular por un
momento así
como nuestra función de hablar. Y básicamente entre nuestra de salud establecida
en la función de R speak. Yo sólo voy a seguir adelante
y pegar eso en. Entonces crearemos una
nueva función así. Y dentro de aquí, voy a seguir adelante y
copiar todo el código de nuestra función set L
y pegarlo aquí. Y ahora vamos a decir subrayado
salud es igual a salud, entonces podemos dejar el resto. Y lo que esto nos
permitirá hacer es decir cambiar la salud y
luego insertar ya sea un valor
positivo o uno negativo y agregarlo directamente a nuestro miembro de salud. Y observe que tenemos
este error a menos que porque todavía
tenemos que agregar esto aquí justo antes de
nuestro nombre de función. Y eso aclarará
ese escrito. Entonces seguiremos adelante
y los minimizaremos. Y ahora si bajamos aquí, podemos decir algo
como mi gato,
conseguir salud, para obtener
nuestro valor para la salud. Y vamos a seguir adelante
e imprimir eso. Entonces di CL salud, entonces podemos seguir adelante y
decir algo como mi gato, cambiar la salud y lo
cambiaremos por negativo 15. Digamos que nuestro gato se
lastimó o algo así. Después volveremos
a imprimir salud. Entonces solo diremos C fuera, mi gato murió. Ninguno. También sigamos adelante
y creamos un perro. Entonces abajo aquí
y vamos a decir perro. Mi perro cambiará
su nombre a manchado. Y sus 23 años. Voy a poner un
punto y coma al final. Y también sigamos adelante y
agreguemos aquí un par de líneas en blanco. Entonces digamos en línea y línea
así y ejecutemos nuestro código. Y como pueden ver, en realidad
se ve un
poco raro. Así que sigamos adelante y
arreglemos eso muy rápido. Entonces aquí arriba dentro de nuestro constructor de
perros y animales, necesitamos poner
una línea N después H y una después de la edad y gato. Ahora bien, si volvemos a ejecutar nuestro
código rápido, podemos ver esa
porción que se arregló. Ahora solo tenemos este
extraño ciento 85 aquí. Y el cambio que
todo lo que tienes que
hacer es agregar en algún texto aquí. Podríamos decir
algo como c out. Garfield. La salud es el espacio del colon. Vamos a añadir en otro operador de
inserción así. Y luego simplemente
copiaremos esto abajo. Y por último, solo
creará una línea en blanco después de que digamos que Garfield es
salud es la primera vez aquí. Entonces al final de la segunda línea y ejecuta un código,
y ahí tienes. Ahora dijo que se creó un gato con los siguientes atributos llamado
Garfield H2, Salud 100. Garfield es salud es 100. Luego lo cambiamos con nuestra función de
cambio de salud, a la
que pudimos acceder simplemente
usando el nombre de nuestra instancia u objeto aquí porque esta
función era pública. Y luego pudimos
meterse con el miembro privado siendo salud de la
clase animal de la que se deriva, porque teníamos a nuestra disposición estos getters
y setters. Y luego imprimimos su
salud, nuevamente siendo 85, ya que acabamos de
sacar 15 de ella, acabamos de crear un perro
que hacía lo mismo. Si imprimimos un perro el
cual creó con los siguientes atributos
nombre irregular edad 300. Entonces ahí tienes. De todos modos, sé que eso fue
mucho lo que probablemente absorba. Así que volvamos y
repasemos todo nuestro
código aquí rápido. Entonces voy a seguir adelante
y alejarme un poco aquí y minimizar todo lo
que tenemos hasta ahora. Entonces sigamos adelante y
tomémoslo desde arriba. Como sé, llevamos bastante tiempo
trabajando con esos códigos como hemos aprendido y
agregarlo paso a paso. Entonces creamos una
clase llamada animal, luego le damos algunos miembros públicos
y privados. Ahora, comencemos
con unos miembros privados. Entonces primero, dijimos esencialmente que cada animal
va a tener un nombre. Vamos a guardar
esto en una cadena. Van a tener
una edad que almacenará un entero y un valor para la salud. También se
almacenará en un entero. Y cada vez que se crea un
animal, vamos a seguir adelante e
inicializar estos valores. Y lo hicimos con
nuestro constructor, que si recuerdas, solo
hay una función a la
que se llamará automáticamente cada vez que
un animal haya creado. Para ello, usamos
nuestro nombre de animal aquí, seguido de algunos parámetros
que queríamos tomar,
en la definición para eso
tenemos aquí abajo. Entonces no ejecuta
ningún código por sí solo, pero toma una cadena
y un entero, uno para nuestra variable de nombre
en uno para la variable de edad. Y usamos una
lista inicializadora aquí mismo con estos dos puntos seguidos cada miembro que
queríamos establecer en orden. Entonces dijo que el nombre
de subrayado es nuestro nombre de miembro, se
van a
establecer igual a name o al argumento que se
pasó para este parámetro. Entonces hicimos lo mismo
para H aquí mismo. Y luego, por último, seguimos
adelante y le dimos salud y valor
inicial de 100 cada vez que no tomamos ninguna entrada
del usuario para este. Aquí. Voy a seguir adelante y
minimizar eso ahora. Luego creamos un
getter para la salud, o simplemente una función
que nos permitió obtener el valor de nuestra variable de
salud privada. Y esto fue para
encapsularlo para que solo
se pueda trabajar con dentro de los
perímetros que decidimos, razón por la
cual tenemos un
getter y setter para ello, así
como este
método de cambio que acabamos de agregar. Así que repasemos
esos ahora mismo. Así que obtener salud no
toma ningún parámetro. Todo lo que hace se
devuelve a la persona que llama o al código que está llamando a
este método AND OR función. Entonces su devuelve
un entero porque nuestro miembro de salud es un entero y
solo devuelve salud. Entonces, si quieres
saber qué es la salud, puedes llamar a esta función
y nosotros te la daremos. Y podríamos haber arrojado cualquier otro código aquí que quisiéramos, pero esto era solo una canaleta básica que decidimos crear. Entonces tenemos otra
función para establecer la salud. Esto permite que el color
inserte cualquier valor de salud que quieran y estableceremos
Salud igual a él. Como nunca arrojamos aquí algún código
extra para decir, Oye, vamos a
tener una salud máxima y una salud mínima. Entonces si la salud, después de
estar configurado a lo que el usuario ingresó aquí
es mayor a 100. Oye, vamos a seguir adelante
y poner eso de vuelta 200. Y si es menor que cero,
seguiremos adelante y lo
pondremos igual a cero. Entonces acabamos de crear esta nueva función
llamada change health, que permite que el color cambie el valor de la salud en cualquier
cantidad que pongan. Entonces mandan nuestra función aquí, un entero y nosotros le agregamos
ese valor a la salud. Y esto podría haber sido un número
negativo o positivo, y se agregaría a. Entonces lo mismo. Dijimos: Oye, si la salud
es ahora mayor que 100, volveremos
a poner en 100 y la salud es menor que cero, la
pondremos en cero. Y podríamos haber arrojado cualquier código extra que
quisiéramos aquí así que
realmente podemos imprimirlo de nuevo
a la salud del usuario fue esto, Andrew fue cambiado a esto
o lo que quisiéramos, pero acabamos de crear
un función básica para cambiar la salud
por lo que sea y luego asegurarnos de que
no pasó el máximo que queremos y la
cantidad mínima que queríamos. Podríamos haber creado
algunos getters y setters para el nombre
y la edad también. Pero acabamos de hacer este
aquí por simplicidad. Y por último, tenemos una última función para
nuestra clase animal, que simplemente permite que cualquier objeto
de animal diga hablar, además de insertar una cuerda. Y ahí sólo va
a imprimir ese sonido. E incluso podríamos
volver a esto y hacer un poco más con él en un video posterior. Así que de todos modos, ojalá, eso
tuviera sentido para ti. Sigamos adelante
y bajemos a nuestra clase de perros. Y sólo vamos a ignorar la clase de gatos ya que será exactamente lo
mismo esencialmente. Entonces dijimos,
perro de clase va a heredar de animal de clase y cualquier miembro
que
heredamos, queríamos dejar a la
misma accesibilidad exacta que estaban antes. Así que cualquier miembro privado
se mantuvo privado. Sin embargo, no tenemos
acceso a ellos porque los miembros
privados solo están disponibles dentro de la
clase que se crean. Pero sí obtuvimos acceso a los
públicos y protegidos, y ellos se quedaron públicos
y protegidos aquí. Y ¿cómo configuramos protegidos? Todo el público
se habría hecho protegido. Y ¿cómo configuramos privado? Todo
se habría hecho antes de eso. Pero solo recuerda que
habríamos tenido acceso a estas variables a
excepción de las que originalmente
eran privadas de animal. Entonces, por ejemplo lo que quiero decir con eso es que
si dijéramos antes de esa función pública de salud
animal, por ejemplo habría estado ahora aquí esencialmente lo que
acaba de hacer privado. Bien. Entonces de todos modos, acabamos de dejar a
los miembros mientras trabajan. Y luego seguimos adelante
y dijimos público aquí y creamos un constructor para perros. Entonces para hacer eso, dijimos perro
seguido de algunos parámetros. Entonces tomamos un nombre y una edad para que coincidan con lo que nuestro animal se llevó aquí. Bien. Eso es porque
cada vez que se crea en dog, también se crea un animal
esencialmente porque
un perro es un animal y porque no
teníamos un constructor predeterminado que
no tome nada. Necesitamos tener un
constructor que coincida con el único
constructor disponible para anima. Y recuerden,
podríamos haber creado múltiples constructores para
animales y múltiples para perros, pero simplemente lo hicimos de esta manera. Puedo asegurarme de que
cada vez que
un Douglas creara un dado sin nombre y se le diera una edad, y podríamos haber puesto
tantas cosas como quisiéramos. Podríamos haber puesto
un nombre y una edad, una raza o algo así en nuestro
constructor animal en Londres. Lo mismo aquí, pero
lo acabamos de hacer de esta manera por simplicidad. Y entonces lo que hicimos fue crear otra lista de inicializadores para llamar
al constructor esencialmente para animal directamente desde aquí. Entonces, cualquiera que sea el nombre y la edad se
insertaron cuando se crea
un perro, ahora se
insertará en el nombre y edad de nuestro constructor animal. Porque como dije, cada
vez que se crea un perro, se crea
un animal y simplemente lo hicimos de
esta manera directamente. Pero en todo tecnicismo,
¿cómo queremos que lo haga? Podríamos haber tomado nada, crear una variable
llamada string,
name, igual a spot, y solo santa en nuestro constructor de animales cada
vez que se creó un perro. Entonces acabamos de
imprimir un montón de cosas. Y esto es bastante
autoexplicativo. Hemos trabajado con
funciones antes, bien, y luego hicimos
exactamente lo mismo para cat. Obviamente esta clase se
llamaba gato y dijimos un sinnúmero calificado en lugar
de un perro, ¿Qué califica? Y luego, por último, si
venimos aquí, creamos un gato llamado mi gato, y le dimos un nombre siendo
Garfield y una edad de dos años. Entonces imprimimos
Garfield is health is, y luego usamos la
función getter, ¿verdad? Y pudimos
acceder a eso directamente desde mi gato porque ese
era un miembro público. Y cuando lo heredamos, seguía siendo públicos que
podían acceder a eso así y
obtener el valor de Salud. Entonces cambiamos esta
salud porque esta
también era una función pública y la imprimimos de nuevo cuando
acabamos de crear una oscuridad
aquí abajo. Entonces ahí tienes. Sólo para mostrarte algo aquí. Si yo fuera a subir a nuestra clase de
gatos aquí y cambiar animal
público para proteger
al animal e
intentar ejecutar nuestro código. Verás que obtenemos un error. Y eso es porque
ahora estas funciones, lo que respecta a un gato, porque esa es la clase con la que estamos trabajando está protegida, es
decir, no va a estar disponible para nada
distinto de sí mismo y cualesquiera clases que hereden
de ella o deriven de ella. En
lo mismo si hubiéramos dicho privado, habría hecho
esas funciones privadas en lo que a
gato se refiere, y no habrían estado
disponibles para nosotros aquí en absoluto. Bien. Entonces solo quería
mostrarte cómo funciona eso ahí, ya que teníamos un
ejemplo razonable disponible para nosotros. Y así ahora vuelvo a poner
eso al público en nuestro código funciona una vez más. No obstante, solo para mostrarte
una cosa más con eso, si yo siguiera adelante
y pusiera eso de nuevo a protegido o incluso
privado para el caso, solo
serían privados en
lo que solo
serían privados respecta a una clase de gatos. Así que aquí abajo, todavía podría decir algo así como
animal, mi animal. Dale un nombre. Llamémoslo como
Jeff o algo
así en una edad de uno. Y nuestro punto y coma al final. Y aún podemos decir mi salud
animal así. En esto va a funcionar bien. Eso es porque en lo que a
un animal se refiere, conseguir salud es pública, ¿verdad? Y si
comento este código aquí momentáneamente y ejecuto nuestro código, se
puede ver que
esto funciona bien. Lo limpiamos un perro, el nombre de manchado, de
tres años y la salud era de 100. Y entonces también
creamos un animal. Tenga en cuenta que no imprimimos
nada sin embargo. Y eso es porque nuestro constructor
Animal ya
no imprime ningún texto. Y la razón principal por la
que lo hicimos es porque de lo contrario, cada vez que creamos
un perro o un gato, no solo como se llamaría nuestro constructor de gatos y
perros, sino que el constructor Animal
habría sido llamado como bien ya que cuando se crea un
perro o un gato, se crea un animal. Bien, y este es nuestro
único constructor disponible. Entonces ahí lo tienes. Y sólo para mostrarles que
esto sí funciona, aquí mismo, puedo decir que mi salud animal
y el valor de pKa es de 100. De todos modos, voy a seguir
adelante y eliminar eso y descomentar estas
líneas de código. Y seguir adelante y cambiar nuestra clase de gato aquí de nuevo a
heredar animal público, no privado. Entonces ahí tienes. Todo está
funcionando una vez más. Y también voy a quitar esta creación
animal aquí abajo. Y sé que muchos de nuestros ejemplos anteriores funcionaban
con algún código muy pequeño. Pero ahora que hemos
aprendido mucho
de lo básico y tenemos
mucho más en nuestro cinturón de herramientas. Quería seguir adelante y crear
un programa más grande contigo lentamente en el transcurso
de un puñado de videos, solo para que puedas ver
cómo se
vería eso en el proceso detrás eso y cómo poner todo junto
pieza por pieza aquí. Así que ojalá los hayas
disfrutado. De todos modos. Ahí
vas. Eso es una especie de resumen de todo lo que tenemos actualmente y
habrá uso en los próximos videos de todos modos, si entendiste todo hasta
ahora, felicidades. No vas a
tener ningún problema
en los videos de ahora en adelante. No obstante, para aquellos de ustedes que están teniendo problemas, no se preocupen. En el siguiente video, voy a estar tomando todo lo de lo que
hemos estado hablando con las clases y
dividiéndolo en una forma o ejemplo más pequeños para
que lo veas y trabajes. De todos modos, eso es todo
para este video. Una vez más, asegúrate de
guardar donde tengas. Gracias por mirar, y te
veré en la siguiente.
90. 89: En este video, voy a
estar tomando todo lo que
hemos aprendido en el
último puñado de videos sobre clases y
desglosándolo pieza por pieza de
una forma más básica. Como sé, pasaban
muchas cosas, en la pantalla. Así que ojalá este video te
ayude si te confundiste un poco con
todo lo
que teníamos pasando, Dicho esto, no borres el código que
tienes porque todavía
lo vamos a estar usando en el próximos videos. Entonces, si quieres
seguir adelante, recomiendo guardar eso en apertura de un nuevo proyecto si
quieres seguir aquí. De lo contrario, puedes simplemente ver lo que tengo en
pantalla y solo
asegurarte de que entiendes
cada tema a medida que avanzamos. De todos modos, comencemos. Bien, antes
que nada, sigamos adelante y volvamos al principio. ¿Cómo creamos una clase? Bueno, déjenme decir clase
seguida del nombre. Entonces podrías decir
algo así como animal, entonces tendremos un conjunto de llaves
abiertas y cerradas y un punto y coma al final. Y ahí tienes. Así es como se crea una clase. Después en el siguiente video, platicamos sobre cómo crear
una instancia de una clase. Y bueno, ¿cómo lo hacemos? Bueno, solo decimos el
nombre de la clase seguido del nombre
del objeto o esta
instancia de la clase. Entonces podría decir animal, mi animal si quisiera. Simplemente ponga un
punto y coma al final. Y ahora hemos creado una
instancia de esta clase aquí. En esta instancia tiene acceso y su propia versión de cualquier miembro y/o
variable de esta clase. Entonces, si dijimos nombre de cadena, así, y por ahora mismo, solo nos daremos un valor
predeterminado como este. Y ahora mi animal aquí, o instancia de nuestra clase
animal aquí, ahora tiene su propia versión o instancia de este miembro
o variable aquí. Y eso es porque es su propio objeto animal como instancia propia o versión de la clase de la
que está conformado. Así que aquí abajo, podríamos decir mi animal siendo el
nombre de esta versión u objeto o instancia o como
quieras llamarlo nombre de punto y ponerla igual a spot o como
lo queramos. Sin embargo, si ustedes recuerdan, cuando se trata de clases, cada miembro o variable o atributo o como
quiera llamarlo de la clase, es por defecto privado, lo que
significa que solo está
disponible a esa clase. Entonces, si queremos ponerlo
a
disposición de los objetos o
instancias de la clase, necesitamos que sea
entidad pública que
simplemente podamos decir espacio público de
dos puntos así. Y ahí vamos. Ahora, todo debajo de aquí
será un miembro público. Y si quisiéramos hacer
algunos miembros privados, solo
diremos algo
como esto y podemos poner lo que queramos ahí abajo. Y estos sólo estarían
disponibles para la clase. Y luego hay un último especificador de
acceso
llamado protected, cuyos miembros protegidos solo
están disponibles para la clase y las subclases o clases que hereden de ella. Y nos meteremos en eso
aquí en solo un minuto. Entonces el nombre es público. Podemos decir mi
nombre de punto animal ahora es igual a spot porque mi animal tiene su propia versión de
esta variable de nombre en, podemos probar que haciendo lo
siguiente y crear otro animal y llamar a
esto mi animal matar. Decir que mi animal significa
es igual a Salomón. Y si te diste cuenta, solo
usamos esto como lo
haríamos con cualquier otra variable, excepto que tenemos que
especificar a cuál nos estamos refiriendo ya que cada
una tiene su propia instancia. Y luego a continuación eso
imprimirá ambos. Entonces di C fuera el nombre de mi dieta
animal. Y luego diremos CL, nueva línea, mi animal para mí. Y como dije, porque cada uno de estos tiene
su propio nombre. El nombre de mi animal es Spot y mi animal 2s se llama Solomon. Entonces ahí tienes. Lo
otro de lo que hablamos fue crear un
método en una clase. Y yo sólo voy a seguir adelante y
mostrarte la forma correcta de hacerlo. Entonces déjame seguir adelante y quitar nuestro segundo animal e
imprimir el nombre aquí. Bien, así que ahora solo tenemos nuestra clase que
creamos sostenida por una cadena pública para que los objetos sean instancias
de esa clase, tengan acceso a esa variable. Ahora recuerda que
cada uno va a tener su propia instancia de ello. Y entonces no tenemos
ninguna variable
o función privada , pero tenemos un espacio
para ello aquí también. Hasta ahora todo lo que hemos hecho es crear un animal llamado mi animal y cambiar su nombre a spot o es instancia de
la variable name. Bien, entonces ahora ¿cómo
creamos el método de clase? Bueno, primero, creamos algo
que se parece mucho a un prototipo de función porque básicamente
es lo mismo. Entonces vamos a decir
algo así como vacío, abrir y cerrar paréntesis
y un punto y coma al final. Así como así, recuerda,
dentro de tu clase, solo
quieres tus declaraciones
y fuera de tu clase, querrás poner
tus definiciones. Esta es la
forma correcta de hacer las cosas. Como dije en el
pasado. Esto ayudará a hora de transferir nuestra clase aquí a un encabezado y archivo CPP. Y solo hace las cosas más limpias y nos meteremos en
eso en un video posterior. Pero ahora mismo, no
te preocupes por ello. Sigamos adelante y pasemos
a crear esta función. Entonces, lo que tenemos aquí mismo, entonces, crearemos
el cuerpo real o definición de la función. Y sólo vamos a decir C fuera. Mi nombre es
espacio de dos puntos así. Dada la línea después. Y luego para especificar
que esta función acabamos de crear como parte de
esta clase animal aquí, simplemente
copiaremos el nombre de la clase y lo pondremos justo antes
del nombre de nuestro método. Y luego insertamos ahí mismo el operador de
resolución de alcance . Ahora hemos declarado y definido
una función en nuestra clase. Y por el público, nuestro objeto de una clase o una instancia de la misma tiene
acceso ahora también a él. Y en realidad aquí arriba, queremos imprimir
el nombre también. Entonces digamos que mi nombre es seguido por nombre y luego como, bien, entonces aquí abajo hemos creado una instancia de nuestra clase animal, versión
cambiada de
la variable name. Y entonces solo diremos mi nombre de
animal print,
así como así. Abrir y cerrar paréntesis
y un punto y coma al final, porque llamamos a esto como lo haríamos con cualquier otra función. Y si ejecutamos nuestro código
aquí, ahí tienes. Mi nombre es Spot. Y otra cosa de la que hemos
hablado es que este tipo de animal funciona
igual que cualquier otro tipo. Así que en realidad puedes tomar
esto como un parámetro. Así que muy rápido,
vamos a seguir adelante y eliminar esta función animal y
calentarla aquí mismo también. Entonces ahora solo tenemos nuestra
única variable aquí otra vez, n, o mover esa línea ahí. Y entonces sólo voy
a decir nombre vacío. Y entre paréntesis
tomará un animal, un animal. Entonces aquí mismo,
voy a tener un bloque de código y voy a decir CL. Mi nombre es un espacio. Voy a imprimir
el nombre del animal. Entonces vamos a decir animal dot name in porque esto es crear una
copia de lo que sea que pasemos, este valor será el
mismo que el que pasemos adentro. Entonces aquí arriba, puedo decir
nombre impreso y luego paréntesis. Puedo insertar a mi animal así así y poner
punto y coma al final. Y sí necesitamos un
prototipo de función arriba. Así que sólo voy a copiar eso. Tomo eso y pongo punto y
coma al final. Y si ejecuto mi código
aquí, y ahí tienes, imprimimos mi nombre es, pero también podrías usar
esto como un tipo de retorno. Podemos pasar esto por
referencia, etcétera. Así que puedes usar esto tal como lo harías con prácticamente
cualquier otro tipo. La única diferencia es que
este tipo está definido por el usuario. Lo creamos, nuestro
yo esencialmente, bien, porque
definimos lo que es un animal. Bien, de todas formas, así que voy a seguir adelante y deshacerme de eso. Uh, sí. Entonces solo tenemos estas
pocas cosas básicas aquí. Después a continuación
hablamos de constructores, que son solo funciones especiales
que se ejecutan automáticamente. Cuando se crea una instancia de
la clase. Por defecto, tienes uno
que se ve así. Y por cierto, todos los constructores deben ser públicos como
recordatorio ahí. Entonces el constructor predeterminado
se ve algo así. Animal siendo el
nombre de la clase, abrir y cerrar
paréntesis y abrir y cerrar corchetes. Y si creas un
constructor propio, este ya no existe. Y puedes tener múltiples
constructores que te permiten
sobrecargarlo de múltiples formas igual que puedes
sobrecargar funciones. Y por solo tener hasta dos constructores,
lo estás sobrecargando. Canta como el nombre es el
mismo que el nombre de la clase. Bien, así que sigamos adelante
y creemos un constructor. Y solo comenzaremos
creando una copia de
la predeterminada. Así que voy a decir
algo como esto. Y ahí tienes. Ahora
tenemos un constructor por defecto. Si quisiéramos
hacer esto correctamente, podríamos declararlo aquí mismo
y luego el encuadernado finito. Bueno, así que no se olvide, tenemos que guardar lo que esta
pequeña parte f. Así que vamos a decir animal sostenido por el alcance operador de
resolución animal, y luego nuestras llaves. Así que aquí está nuestro constructor
predeterminado. Y esto es lo que
nos permite crear un objeto o una versión de un animal sin tener que
tomar ningún parámetro. Y eso es porque
esto no toma ninguno, pero podemos crear otro
constructor que sí. Y luego antes de que me olvide, recuerda cada vez que tengamos una variable que sea
miembro de la clase, solo
queremos
poner un guión bajo antes del nombre ahí,
solo para que sepamos, oye, esto es un miembro de la clase mientras que para cambiarlo aquí
abajo también. Y como dije, podemos seguir adelante y sobrecargar a este
constructor aquí. Acabo de crear
otro constructor. Y éste va a
ser como lo llamarías, un constructor parametrizado. Porque va a
tomar algunos parámetros. Entonces aquí mismo,
vamos a decir el animal. Y luego entre paréntesis, diremos cadena, color. Así. No ponemos
punto y coma al final. Y luego crearemos la
definición para este sobre. Sólo voy a copiar esto
y pegarlo aquí abajo. Entonces tendremos nuestros
corchetes para el bloque de código. Y luego vamos a decir C fuera. Un espacio de conducta de color. El animal espacial fue creado
igual que ese animal. Poner punto y coma al final
y tenemos que especificar dónde
viene este constructor o para qué sirve. Entonces diremos animal antes que él, seguido de nuevo por el operador de
resolución de alcance. Entonces ahí tienes. Ahora
tenemos otro constructor. Y ahora si queremos usar ese en lugar de
los predeterminados, simplemente
voy a seguir adelante
y borrar todo este código. Podemos decir animal. Animal. Entre paréntesis,
pondremos una cadena. Entonces voy a decir personalmente que
puso punto y coma al final. Y si ejecuto el código aquí, y diré que se crea un
animal azul. Y eso es porque
ese es el código que se ejecuta cuando creamos
este animal, ya que estos son los
parámetros que usamos y otro uso para un constructor o uno de
los usos principales para ello es asegúrate de que tu
clase esté lista para usar. Y lo que quiero decir con eso
es que quieres
asegurarte de que todo
tenga un valor inicial. Como normalmente, no
quieres hacer esto aquí mismo, todas tus declaraciones aquí y tus definiciones aquí abajo. Bien, entonces cuál es la
mejor manera de dar nombre y valor inicial
en nuestro constructor. Bueno, justo después de
los paréntesis, vamos a hacer es decir dos puntos, subrayado nombre entre paréntesis
pondrá el valor. Entonces solo diremos comillas dobles y ahí no
pondremos nada. Y vamos a hacer lo mismo aquí abajo, excepto que
aquí abajo, vamos a decir subrayado nombre. Y luego entre paréntesis,
diremos nombre. Y para obtener este valor aquí, solo
agregaremos
otro parámetro. Entonces diremos cadena,
color, cadena. Tenemos que
asegurarnos de agregar eso a nuestra declaración de
este método aquí arriba. Así que ahora hemos creado
otro constructor que toma una cadena para el color
y una cadena para el nombre. Y va a insertar
cualquier nombre que pongamos en nuestra variable de nombre. La razón por la que tuve el
error aquí es porque simplemente no tenía ese
colon ahí mismo. Y ahí lo tienes aquí abajo. Obtuvimos un error porque ya no
tenemos un constructor que solo
toma un parámetro. Y si lo quito y lo
vuelvo a poner entre paréntesis abiertos, voy a ver mis diferentes opciones de
Let's do. Y dice que necesito
un color y un nombre, o simplemente no podría hacer nada ya que tenemos este constructor
por defecto. Entonces como dije, el propósito principal del constructor es hacer que tu clase esté lista para usar
inicializando a todos
los miembros dentro de ella. Y entonces también puedes tener
cualquier código que quieras ejecutar. una instancia de tu clase crea una instancia de tu clase
usando
ese constructor. Como dije, la mejor
manera de
inicializarlo es con una lista de inicialización. Y todo lo que tienes que hacer
es decir dos puntos seguido la variable y el valor que quieres
darle entre paréntesis. Y si tuviéramos más de una
variable, diríamos coma. Y luego ponlo en el nombre de la
otra variable, y luego poner ese
valor y paréntesis. Y recuerda que
necesitan estar en orden de arriba a abajo, y solo tienes que ir de
izquierda a derecha aquí. Entonces solo voy a seguir adelante y eliminar eso ya que solo
tenemos la única variable. Y ahí tienes. Ahora, puedo seguir
adelante y ponerle un color. Entonces podría decir azul otra vez. Y entonces nuestro nombre será spot. Y ahora que lo hemos hecho aquí, podemos decir que se creó un
animal azul, llamado así por el nombre. Y ahí vamos. Si ejecuto mi código aquí, eso debería decir un animal azul creado llamado spot, y
eso es lo que hace. Entonces otra cosa de la que
hablamos fue la encapsulación. Entonces, sigamos adelante y
echemos un vistazo a eso. Básicamente, ahora mismo, puedo ir y meterme con mi variable de
cuerda. Podría decir mi nombre de subrayado de
punto animal y establecer esto igual a
lo que quisiera. Y no hay nada que me detenga. Y eso puede que no parezca
un gran problema aquí, pero créeme, no
quiere que sus miembros sean públicos. Si puedes evitarlo, quieres tener todo dentro de una función getter
y setter, que entraremos aquí en un
momento para
que puedas definir reglas
extra y
poner un código extra cada vez que algo
quiere meterse con una variable. Y si decides hacer
algo con eso más tarde, tu código ahora es
más dinámico porque solo
tienes que
mirar esas dos funciones lugar de
tratar de encontrar en todas partes que esa variable estaba ajustado. Entonces sigamos adelante
y cambiemos esos. Primero, tomaremos
nuestra variable de cadena aquí y la pondremos
en privado aquí. Entonces ahora este es un miembro privado, que es lo que quieres. Y luego aquí arriba crearemos dos funciones para un
getter y un setter. Y antes de hacer eso, solo
voy a seguir adelante y minimizar esto aquí. Entonces no se interpone en nuestro camino. Entonces diremos set name como
el nombre de la función, y pondremos un
punto y coma al final, y esto tomará
un nombre de cadena. Entonces diremos getName
abajo de él. Y esto no tomará nada. Sin embargo,
devolverá una cadena. Y este de aquí arriba no
va a devolver nada. Bien, entonces diremos
void, setName, string name, y String getName. Y eso va a ser ahí. Entonces creará
las definiciones para ambos de estos abajo. Entonces, si copio este aquí
y agrego en nuestro bloque de código, el código más básico para un setter sería
hacer lo siguiente. Yo diría guión bajo
nombre es igual a nombre. Y ahora esto
permitirá que cualquier cosa que llame a esta función cambie
esta variable privada. Entonces haremos lo mismo con
nuestro método getName aquí. O función creará la definición
aquí abajo, así. Y diremos el
término subrayado nombre. Entonces tenemos
que asegurarnos de especificar que ambas funciones son
parte de nuestra clase animal. Entonces diremos animal seguido por el
operador de resolución de alcance en ambos. Y evitar las necesidades de
venir antes de eso. Bien, porque
va a ir justo antes nombre
del método y la cadena
sin fisuras. Así que voy a subir al
otro lado, ¿verdad? Y si ejecutamos nuestro código ahora, entonces los animales azules
crearon el nombre spot, así que todo sigue funcionando. Y luego aquí abajo ahora, si quiero cambiar mi nombre, tengo que decir en mi animal morir setName y luego poner aquí
un valor de cadena,
como Solomon, por ejemplo poner punto y coma al final. Quizás estés pensando, Oye,
¿en qué se diferencia esto? Bueno, actualmente
no es muy diferente aparte de ser la forma
correcta de hacer las cosas. Pero si tuviera esto en 100 lugares diferentes
en mi código donde estaba cambiando el nombre o
cualquier variable esto era una y otra vez. Y yo decido, ¿sabes qué? Voy a seguir adelante
e imprimir, oye, el nombre se cambió cuando llegué a cambiarlo en 100 lugares. Pero debido a que tengo
el centro aquí, sólo
puedo decir CL
underscore name. Se cambió el espacio para seguir esto con un nombre
así y crear una nueva línea. Y luego aquí abajo son
críticos para el avión. Y si ejecuto mi código ahora, ahora va a decir que he aprendido el nombre más creativo
spot y luego Spy, que cambió a Solomon. Bien, entonces ahí tienes. Es por ello que un getter y setter
son útiles e importantes. Sobre todo si tuviera
esto en múltiples lugares. Ahora, no tengo que
lidiar con eso. Puedo simplemente mirar justo aquí y cambiar mi cosa ahí mismo. Entonces, si terminé con algún tipo de error al cambiarlo, todo lo que tengo que hacer es mirar mi código aquí y ver
qué estaba causando eso. En lugar de mirar todos los cien lugares
que me metí con él. Y puedo tener restricciones aquí hay algún código aquí para hacer la primera letra
mayúscula o hacerla así el nombre sólo tiene diez caracteres o
lo que quiera hacer, ¿ verdad? Entonces ahí tienes. Así es como se crea un setter y getter
básico. Y lo que hicimos aquí donde
teníamos la funcionalidad de nuestra variable privada en estas funciones públicas
se llama encapsulación. Y lo último de lo que
hablamos se
llamó herencia. Así que déjame seguir adelante y eliminar
todo aquí muy rápido. Y decir lo siguiente. Digamos animal de clase
en mi bloque de código, y voy a decir nombre de cadena, y también diré
edad, así como así. Entonces cada animal va
a tener un nombre y una edad. Recuerden, estos dos
son privados, así que esto es exactamente lo
mismo que decir en privado. Y eso es porque
los miembros de una clase son privados por defecto. Así que así. Y luego seguiremos adelante
y crearemos una clase que herede de
nuestra clase animal. Entonces esta será la
clase base y la clase que está heredando de
ella será la subclase. Así que aquí abajo, voy a
decir perro de clase, por ejemplo heredar de animal. Y necesito tener aquí un especificador de
acceso. Y en este caso
diremos público. Y básicamente, si
recuerdas, si digo público, escucha todo lo que
era público se transferirá
a perro y será público. Todo lo que estaba protegido
se trasladará a perro y estará protegido y
todo lo que era privado. Bueno, no es accesible
fuera de esto, así que realmente no importa
si dije protegido, todo lo que fuera
público sería transferido y protegido. Todo lo que estaba
protegido sería trasladado para mantenerse protegido
y todo era privado. Bueno, no importa, todos modos no
pude acceder a él. Y entonces si dijera privado, todo lo que no fuera
ya privado se
trasladaría y
se haría privado. De todos modos, sigamos adelante
y pongamos aquí algún código. Y en realidad voy a
seguir adelante y cambiar el especificador de acceso con nosotros para protegerlo para que ese perro tenga
acceso a estas variables. Y obviamente esto es sólo
un ejemplo muy básico. Así que no tomes lo
que estoy haciendo aquí para insistir en cómo crear las cosas. Sólo quiero mostrarte el uso
básico de la herencia. Y recuerda,
podemos heredar de múltiples clases siguiendo
esto con una coma. Podríamos decir público y
luego otro nombre de clase y otras clases que
heredan de perro, ¿verdad? Y luego aquí abajo, sigamos adelante y hagamos
clic derecho y creamos una variable pública
por simplicidad, y agreguemos un breve. Entonces cada animal va a tener un nombre y una variable de edad, y cada perro va a tener una variable de raza junto
con estos aquí. ¿Bien? Y ahora podríamos decir, bien, vamos
a crear un nuevo perro. Mi perro, así como así. Y como estos ambos tienen
un constructor por defecto, no
necesito ningún
parámetro aquí. Y si quieres
saber más sobre eso, solo tienes que volver al
último video donde
hablamos de herencia
e ir más a fondo. Y luego sigamos
adelante y creamos un par de constructores para inicializar todos
estos valores. Y en realidad sólo
voy a configurar este de aquí para privado. Y sí me disculpo. me olvidó
poner un subrayado en todos los nombres de nuestros miembros aquí. Entonces sigamos adelante y
hagámoslo. Bueno, entonces para inicializar esto solo va crear un par de constructores. Entonces diremos animal. Y éste tomará
una cadena, nombre y edad. Y vamos a poner la
definición a continuación. Y vamos a especificar que
esta parte de la clase, vamos a tener nuestro
bloque de código así. Entonces después de nuestros paréntesis aquí, solo
diremos dos puntos
subrayados nombre. Y luego entre paréntesis
se insertará nombre. Digamos coma subrayado edad, y luego los paréntesis
insertarán la edad. Y luego solo
quería agregarlos. Nuestros corchetes
así , solo así
estaba fuera del camino. Y luego podemos crear un constructor muy similar para perro, excepto que le agregaremos. Y no olvides que necesitamos hacer nuestro constructor aquí arriba, público Jose Public
colon así. Y sólo para que se
vea un poco más agradable. Y luego aquí abajo para nuestro perro, va a crear un constructor. Pero antes de hacer eso, diremos moneda privada
así para mantener nuestra cadena. Después crearemos un constructor. Entonces diremos perro
y m paréntesis tomarán una cadena para el nombre, para la edad y una
cadena para el breve. Entonces crearemos la
definición abajo. Y no lo olvides,
necesitamos especificar el frente de Liz
de la clase de perros. Y sólo voy a
rodear algunos brackets así. Después pondremos en nuestra lista de
inicialización. Entonces porque cada vez que se crea
un perro en, se crea
animal, ya que
derivamos de eso, necesitamos seguir adelante y
usar este constructor también cuando usamos nuestro
único constructor de perros aquí. Entonces para ello diremos
animal, colon, colon animal. Y luego entre paréntesis
vamos a decir nombre, coma H más así. Y estamos diciendo, nos estamos refiriendo a ti como parte
de la clase Animal. Entonces queremos al constructor
Animal. Y aquí vamos a insertar
estos dos valores, que es lo que toma nuestro
constructor animal. Y luego podemos agregar
en nuestra raza para ser inicializados por después de esto constructores y coma
subrayado breve. M paréntesis
insertará el resumen, y todo esto va
a funcionar bien. Y entonces todo lo que
tienes que hacer es cambiar nuestra declaración o creación
de nuestro objeto perro. Entonces diremos perro, y luego llamaré a esto mi perro. Y entre paréntesis,
se puede ver que ahora necesitamos un constructor de
tres
valores que cumplan con el nombre. Entonces le llamaremos spot, seguido de su edad. Entonces solo diremos
algo así como dos. Y luego seguiremos
esto con una raza. Entonces podemos decir boxeador o algo así y poner punto y
coma al final. Y todo esto
va a funcionar bien. Y podemos imprimirlo todo
abajo o
incluso podríamos poner el código para
imprimirlo dentro de nuestro constructor de
perros. Y eso también funcionaría. Y no lo olvides,
estos dos constructores están funcionando
cuando creamos esto aquí. Y sólo para
mostrarles que si decía CL, espacio de colon animal, y luego aquí
dentro
si sub c up perro, así y ejecuté el código, así y ejecuté el código, se
puede ver que hemos impreso animal y perro. Y eso es porque
ambos constructores están funcionando. Porque cuando se crea un perro, se crea
un animal. Y solo tenemos
el único constructor aquí
mismo que
toma tres valores. Dos de esos se acostumbran para constructor de
animales y luego también
agregamos en una raza. Bien, así que ahí tienes. Ese es un ejemplo básico de
cómo usar la herencia. Perro ahora esencialmente tiene acceso
a las cosas que animal, así
como a las cosas
dentro del Sur. Y para llevar este punto a
casa muy rápido, un animal creará un método
público llamado grito. Y vamos a crear la
definición abajo. Así que voy a copiar
esos de aquí abajo. Di Chow y especifica que
esto es de un animal. Y dentro de
nuestros brackets aquí, y diremos
anaquel vacío, por cierto. Diremos
refugio de animales vacío, así. Y luego aquí dentro, sólo
vamos a saludar. Y debido a que el perro
deriva del animal, pueden usar esta función, sobre todo porque es pública. Entonces ahora, justo abajo de aquí, podría decir que mi perro murió, grite. Si ejecutamos un código, puedes ver que funciona
bien. Lo gritamos. Hola. Y voy a
seguir adelante y quitar impresión de perro
y animal aquí. Ya. Conseguí ese punto al otro lado. Y lo vuelvo a ejecutar por ti. Y como pueden ver,
solo dice hola. E incluso si nuestro
método los hay, nuestra función estaba protegida. Al igual que así hubiéramos tenido acceso a él dentro de la propia clase. Entonces, si elimino esta
línea de código aquí abajo y dentro de nuestro
constructor, por ejemplo, I. Podría haber usado shell. Entonces el código con interclase
tendrá acceso a esta variable protectora
ya que está disponible para la clase y para cualquier cosa
que se derive de ella. Entonces puedo decir gritar aquí mismo, ahora adelante y muévanse eso
solo para que sea un poco más legible para ustedes
y ejecuten nuestro código. Y ahora cuando creamos
un Perro se grita hola. Y podríamos haber puesto
eso en una función o algo así para nuestro perro también. Y eso hubiera
funcionado igual de bien. Y si tuviéramos otras variables o funciones que estuvieran
protegidas o públicas, hubiéramos tenido
acceso a ellas dentro
del código de nuestra clase de perros. Entonces solo para mostrarte un ejemplo, podría decir x y entonces este no es un gran ejemplo
de cómo usarlos. Pero vas a conseguir el
punto aquí abajo. Podría haber dicho
algo como x es igual a diez y luego
imprimirlo x en la línea. Y si ejecuté mi código, habría funcionado
bien porque nuestra clase aquí tiene
acceso al código. Sin embargo, aunque son
código tiene acceso a un aquí, no
hubiéramos podido
decir algo así como mi perro, x es igual a diez, por ejemplo esto no hubiera funcionado, pero lo hubiera hecho si esto
fuera público. Ahí vas. El código funciona bien, o incluso podemos simplemente
imprimirlo así. Y esto también funcionará. Así que déjame ir de todos modos. Ojalá este
video te ayudara un poco si estabas recibiendo un gran corte y todo el código
extra que
teníamos en pantalla antes. Gracias por mirar, y te
veré en la siguiente.
91. Capítulo 15: palabra clave estática: En este video, vamos
a estar echando un vistazo a la palabra clave static
en C plus plus. Ahora la palabra clave static
se puede aplicar a cosas como variables, funciones
y objetos. Y exactamente lo que
haga va a cambiar dependiendo de a
qué esté conectado. Y será brevemente echando un vistazo a cuatro ejemplos
diferentes de cómo y cuándo y podrían usarse para que si
alguna vez lo vieras en el futuro, no
tuvieras
idea de lo que es ahora general o ampliamente. Si bien puedes pensar
en cuando veas la palabra clave estática como
eso a lo que sea que esté atado ahora es permanente y va a ser la única copia de la misma. Y vamos a seguir adelante
y echar un vistazo a exactamente lo que quiero decir con
eso aquí en un momento. Entonces primero sigamos adelante
y echemos un vistazo a la palabra clave static cuando se usa en variables y funciones. Como puedes ver aquí para la
definición o cómo funciona eso, básicamente
dije que crea una
copia permanente y única de una variable. Así que vamos a seguir adelante y
simplemente crear una función arriba principal aquí para ver
un ejemplo de esto. Entonces lo que vamos a hacer
es decir Boyd, contar tiempo, dram, así, abrir
y cerrar paréntesis. Y vamos a crear el
bloque de código dentro de aquí. Vamos a decir estática. En la universidad, lo puse igual a 0, y luego a continuación eso
dirá yo más, más así. Y luego dentro de aquí, Sigamos también adelante
e imprima. Así que ponlo en una nueva
línea cada vez. Y luego aquí abajo en
nuestra función principal, sólo
vamos a llamar a
este método cinco veces. Entonces solo voy a seguir adelante y comentar nuestro otro código aquí. Por ahora. Sólo vamos
a pasar es lo siguiente. Cuando nuestro método
primero pasa aquí, va a correr a
través y crear una variable entera estática
llamada i y establecerla igual a 0. Y si recuerdas, dije que
esta variable ahora va a ser permanente y la única
copia de esa variable. Y lo que eso significa es esto, cuando lo atraviese por primera vez, lo creará y lo
pondrá igual a 0. Y debido a que es estática, esta será la única copia de nuestra variable entera llamada
i dentro del alcance aquí. Así que todavía no podemos decir
algo como yo igual a diez aquí
mismo sin
obtener un error porque todavía sólo está
dentro de ese alcance. Entonces va a imprimir I, que será 0, y
luego aumentaré yo en uno. Ahora normalmente, si esta no
fuera una variable estática, creará una nueva
variable llamada I. Cada vez que se ejecute este método, print out 0 aumenta en uno. La próxima vez, cree otro entero llamado
Die set igual a 0, impreso y cristal
por uno y así sucesivamente. Y siempre
obtendríamos el mismo resultado. Y si ejecutamos nuestro código sin la
palabra clave estática aquí rápido, puedes ver que
ese es el caso. Entonces ahí mismo,
imprimimos 05 veces ya que llamamos
al método cinco veces. Pero si ponemos estática aquí y recordamos eso es
simplemente todo minúscula ahí. Y antes del tipo de datos, cuando ejecutamos nuestro código ahora y en realidad aumenta
en uno cada vez. Y eso es porque cuando
volvemos a llamar a nuestro método, porque ya fui creado después de la
primera vez a través, simplemente
va a usar
la misma variable. Entonces, esencialmente, la segunda
vez por aquí, esta línea superior será ignorada. L impresión,
la aumento en una. Y luego cuando
vuelva alrededor de L, vuelva
a
ignorar esta línea porque ya estoy creada y
sólo habrá una copia de la misma. Entonces cada vez que llamamos a
este método ahora, esta declaración e
inicialización aquí se ignora y vamos a imprimir i y luego aumentarlo en uno. Entonces ahí tienes. Así es como funciona
la palabra clave static
con variables en funciones. Crea una copia permanente y
única de la variable. Y tal vez te estés preguntando
¿y si hiciéramos algo como esto y ejecutamos un código? Bueno, ahora, porque
solo esta línea superior, se ignorará donde se declaró
esto, me pondré igual
a 0 cada vez, y luego se imprimirá 0. Entonces, si vas a
hacer algo como esto, quieres inicializarlo en
la misma línea para que esto
pueda ser ignorado en el futuro. De cualquier manera podemos seguir adelante y
eliminar esa función ahora, así
como eliminar
las llamadas a ella, y pasar a este segundo caso de
uso para static, que tiene variables en clases. Y lo que esto hace es crear
una variable permanente que sea compartida entre todos los
objetos de esa clase. Entonces lo que voy a hacer
es descomentar nuestro código aquí así como así. Y entonces podríamos
poner esto en clase
perro o gato o animal, y funcionaría de todos modos. Así que vamos a seguir adelante y
ponerlo en nuestra clase de perros aquí. Sólo como ejemplo, lo que vamos a
hacer es decir estática. Voy a poner punto y
coma al final. Y entonces lo que tenemos que hacer para inicializar esto
aquí, digo estático. Y entonces perro siendo el
nombre de la clase,
dos puntos, dos puntos o el operador de
resolución de alcance. Y luego decir, yo, lo puse
igual a 0, por ejemplo. Y en realidad vamos a eliminar la palabra clave estática esta
segunda vez. Entonces solo diremos colon perro,
colon I es igual a 0. Estamos tomando esta variable
entera estática, que ya hemos creado. Y no necesitamos
usar la
palabra clave static después de este punto. Y luego lo estamos inicializando fuera de la clase diciendo int siendo el tipo que tiene el nombre de la clase con operador de
resolución de alcance, luego el nombre de la variable, estableciéndola igual a 0. Entonces solo tenga en cuenta aquí
que después de crear la variable, ya no
necesita usar la palabra clave static cuando se
refiera a ella en el futuro. Y la única razón por la que usamos anterior es solo por cómo se inicializa
esta variable cuando se pone en una clase. Se trata de una variable estática, y esta es la manera de hacerlo. Pero normalmente podemos referirnos
a esto como soy característica. Y solo vamos a
seguir adelante y hacer esto público para que podamos fácilmente echar
un vistazo a cómo funciona esto. Entonces aquí abajo, ya tenemos un objeto o una instancia de
nuestra clase de perros llamado mi perro. Y sigamos adelante
y guardemos mi punto y lo pongamos igual a cinco. Entonces vamos a crear
otro perro, mi perro también. Y solo le daremos a
esto un nombre como sparky y le daremos dos
años, por ejemplo. Entonces vamos a
imprimir a mi perro para ver como mi perro también. Y vamos a poner esto
en una nueva línea, así, nuestro crear una nueva
línea después de ella, debería decir. Y si ejecutamos nuestro código, se
puede ver que aquí abajo, mi perro para morir era cinco. Y eso es porque esta variable
entera estática ,
como se escribe aquí, es una variable permanente
que se comparte entre todos los objetos
de esa clase. Entonces no importa cuántas instancias de la clase hagamos, todas
compartirán
la misma variable. Y así si fuéramos
a decir mi perro a yo más equivale a cinco y
luego imprimir a mi perro. Yo obtendría diez y voy a seguir
adelante y mostrarle eso ahora. Entonces si decía mi perro,
dos puntos más iguales, Bueno, originalmente
dijimos que era igual a cinco y ahora solo aumentamos en cinco. Y porque comparten exactamente
la misma variable, si imprimimos a mi perro, voy a imprimir diez. Bien. Entonces ahí tienes. Como dije, en realidad
podríamos haber puesto, he creado esta
variable estática en animal aquí. Y entonces no sólo
cada instancia de gato ha compartido esa variable
ya que es un animal. Pero cada instancia perro
tendría también
encima de cada instancia de animal que
hubiéramos creado dos. Entonces todo lo que es un animal habría compartido esa variable. Para que tengas, de todos modos, voy a seguir adelante y
quitarle eso al perro de aquí. Y también eliminaremos este código
extra. Sigamos adelante y
echemos un vistazo
al tercer caso de uso para
la variable estática. Entonces, si creo un objeto de clase
estática,
lo que hace es crear una copia
permanente y única de ese objeto. Y probablemente la forma
más fácil de mostrarte esto sería crear
otra función. Entonces aquí mismo diremos vacío, crear objeto, abrir
y cerrar paréntesis. Y entonces vamos a tener
nuestros corchetes así dentro de aquí. Vamos a seguir adelante y crear
un perro llamado mi perro. Bastante triste. Entonces le daremos un nombre. Entonces diremos sparky y
le daremos una edad como a. Y luego después de eso, diremos que mi perro
murió, cambiar de salud. Y diremos menos cinco se consideran
valor de cinco negativos. Y luego imprimiremos que mi
perro se puso de salud, así. Y lo
imprimiremos en ángulo. Mi perro temp dot consigue ayuda. Línea, así como así. Entonces seguiremos adelante y llamaremos a
esta función algunas veces. Y nuestro método principal. Ahora, cuando nuestro código se ejecuta y
llega a esta función, L, crea un perro, mi perro, y dale el nombre
sparky y una edad de dos años. Entonces vamos a decir mi perro temp dot change
health menos cinco, que va a cambiar
su variable de salud, que si recuerdas, tiene un valor predeterminado de 100 y luego
va para imprimir 95. Entonces la próxima vez
que pase, ignorará esto. Si hacemos esto
estático aquí, es decir, decimos que un perro así, entonces la próxima vez a través de
él ignorará esto, igual que lo hizo con
la variable estática que teníamos en una función, porque mi perro
temporal ya ha sido creado
y solo puede haber una copia del mismo y
tiene permanente y luego
bajaremos su salud que he vuelto a
tener e imprimirlo. Entonces, si ejecutamos nuestro código aquí, se
puede ver que un fijarlo a 95 meses porque
empezó un 100 restar 05 impreso y luego va a bajar
a cinco cada vez que lo llamamos. Y luego solo para
mostrarte que eso solo sucedió por
la palabra clave estática, si eliminamos esto y
luego ejecutamos nuestro código, vas a ver es
que nuestro constructor
de perros en realidad va
a correr cuatro veces. Entonces, después de que el cuerpo de nuestro perro fuera
creado esta primera vez aquí, seguimos adelante y ejecutamos
esta función que creó un nuevo perro
llamado sparky H2, imprimió su salud. Y luego aquí abajo, después de que se le resta es
salud y lo imprimió de nuevo. Y luego hicimos
lo mismo por más veces. Así que la próxima vez a través y
lea este código de nuevo, acredite a otro perro llamado sparky H2 Health un 100
impreso de nuevo, y van y simplemente
seguían repitiendo. Entonces cuando agregamos estática aquí, toda
esta línea se ignora. Entonces con esa estática ahí, esto crea una copia permanente
y única de esto. Y cada vez que esta línea
ha vuelto a correr, se pone. Entonces ahí tienes. Los objetos de clase
estática y las variables estáticas en
las funciones funcionan de la misma manera. Ahora repasemos un caso de uso
más para esto. Se trata de
funciones estáticas en clases. Pero antes de hacer eso,
sigamos adelante y eliminemos este código aquí junto con
la propia función. Bien, así que sigamos
adelante y echemos un vistazo ahora a
las funciones y clases estáticas. Entonces si subimos a nuestra
clase animal aquí, por ejemplo, y dentro del público vamos a
crear una función estática. Podemos hacer esto así. Diremos estático, vacío,
print, hello, abrir y cerrar paréntesis
y un punto y coma al final. Y luego lo definiremos
aquí abajo solo por buenas prácticas. Entonces vamos a decir animal, colon, hola, abrir y
cerrar paréntesis. Entonces crearemos el bloque
de código aquí abajo. Entonces antes de animal, todavía
tenemos que
decir evitar eso porque esa
es nuestra declaración de retorno. Una vez más, observe
que no necesitamos volver a usar la palabra clave static. Y luego aquí abajo, yo,
vamos a hacer y saludar
después, así como así. Y ahora cualquier instancia
de nuestra clase animal, sólo
tendremos una
versión de esta función. Y además, debido a que
sólo hay una versión
de esta función, no
se permite acceder a variables
no estáticas. Entonces, por ejemplo, no podemos decir
subrayado la edad es igual a cinco. Si paso el mouse sobre esto,
verá que una
referencia de miembro no estática debe ser relativa a un objeto
específico. Y lo que eso significa
es que porque nuestra función es estática
y que no hay una nueva instancia de la misma para cada objeto de la clase animal que creamos es que no
pueden usar instancias específicas
de esta variable ya que hay una edad de subrayado para
cada objeto de nuestra clase. Sin embargo, puede usar
variables estáticas y funciones. Entonces si tuviéramos algo
como estático, me gusta para que pudiera usar, así que ahí lo tienes. Y también recuerda que al
usar una variable estática, tenemos que decir colon animal, colon, y luego
inicializarla así. Y todavía necesitaríamos decir aquí también.
Entonces ahí tienes. Las funciones y
clases estáticas se comparten entre cada
objeto de esa clase. Y sólo pueden usar variables
estáticas y funciones ya que no es
específica de cada objeto. Ahora bien, si cambiamos esto a
algo como i plus equivale a cinco y luego bajamos aquí y creamos un
par de animales. Entonces, si se trata de un
animal, uno tendrá que
darle nombre y edad. Entonces diremos Jack, de uno años. Y voy a decir animal
para decir que Karl B es uno también. Y entonces podemos decir
animal un kilo, así como así.
Huellas de animales hola. En ambos de esos
va a funcionar bien. Y aquí están compartiendo
la misma función. Y sólo para mostrarte un
par de cosas con eso, podemos decir algo
como x equivale a cinco. Y luego diremos
x plus así. Y luego diremos que
yo más equivale a cinco. E imprimiremos
lo siguiente. Diremos x es igual.
Para imprimir x. En su mayoría Cl I es igual. Y pondremos ambos
en tus líneas también. Ahora, hemos llamado a
esa función dos veces. Recuerda que comparten exactamente la
misma función. Y antes de ejecutar un código, en realidad
necesitamos paréntesis
aquí, así como así, así como lo haríamos con
cualquier llamada a función, por cierto, por si olvidé
mencionarlo antes
en el curso. A veces, cuando la gente habla de
llamar a una función, también
pueden referirse a esto como invocar la función, ¿verdad? Entonces solo un avisar sobre eso. Eso significa que lo mismo invocar en la llamada una
función son lo mismo. Ahora bien, si ejecutamos un código aquí, puedes ver que
imprimió Hello porque x no era
una variable estática. Era lo mismo cada
vez que este código RAM, sin embargo, yo era una variable
estática. Entonces, cada vez que se ejecutaba esta función, estaba trabajando con
la misma variable. Entonces la primera vez que
imprimimos cinco y la segunda vez
imprimimos diez. Y lo básico
a recordar de una función estática es
que cada instancia de la clase comparte
la misma función y que solo puede usar miembros y funciones
estáticos. Y hay una cosa más
importante a tener en cuenta sobre
las funciones estáticas en las clases. Y eso es porque la función es estática
y no hay una nueva versión de la misma por objeto
o instancia de la clase. De hecho, puedes llamar a esa función sin
crear un objeto en absoluto. Entonces, qué podemos hacer
aquí abajo para decir colon animal,
colon o el operador de
resolución de alcance. Y luego solo di hola impreso. Y eso va a funcionar bien. Y ahí tienes. Me volvieron a aumentar
cinco porque era una variable estática y
pudimos usar la función sin tener ningún
objeto en absoluto. Entonces eso es realmente genial. Ahora, estoy seguro que ya
puedes pensar algunos
casos de uso diferentes de cuándo
podrías querer una
variable permanente en una función, así
como cuándo querrías una variable estática en una clase. Por ejemplo, podríamos
usar esto para que una función cuente
cuántas veces se utilizó. Y luego lo mismo para aquí. Podríamos simplemente aumentar
nuestra variable estática uno y cada uno de nuestros diferentes
constructores para una clase. Y entonces
sabríamos cuántos objetos se crearon de esa clase. Y ese es solo un ejemplo ahí para ti, para
cada uno de esos. Y luego ya
vimos un ejemplo de cuándo podrías querer usar
un objeto de clase estática, donde pudimos crear
una función que creó
un objeto dentro de su
alcance específicamente, y fue capaz de hacer algo al objeto
cada vez que corría, sin que estuviera
fuera de ese alcance, y sin crear
uno nuevo cada vez. Después, por último,
funciones estáticas y clases. Uno de los principales casos de uso, razones para usarlos
es este aquí mismo, donde podemos llamar a
esa función sin crear una instancia
de esa clase. Eso puede ser realmente útil. Por ejemplo, si
tuviste algo así como una clase de matemáticas, bueno, probablemente no necesites una
instancia de tu clase de matemáticas. En su lugar, es posible
que solo desee usar toda
la funcionalidad
disponible dentro de él. Y ese sería un caso de
uso perfecto para esto aquí. De todos modos, hay cuatro casos de uso
diferentes de la palabra clave static y
algunos ejemplos para
acompañarla así
como algunos casos de uso. Entonces, si ves
esto en el futuro, ojalá no estés
completamente perdido en lo que es y por qué
ahí, y ¿quién sabe? A lo mejor incluso lo usaremos en uno
de tus propios programas. De todos modos, antes de
concluir este video, solo
voy a
seguir adelante y eliminar estos textos extra que
creamos dentro de este video. Que sea como era cuando lo
iniciamos por primera vez. De todos modos, no llegues
a ver. gracias por ver y te
veré en la siguiente.
92. Capítulo 15 (clases): clase vs estructura: En este video,
vamos a estar
hablando de las diferencias entre estructuras y clases
en C plus plus. Ahora, sé que ni siquiera
hemos
mirado estructuras o estructuras, pero créeme, si
sabes qué clases básicamente sabes
qué estructuras. Entonces, sigamos adelante
y echemos un vistazo a la sintaxis de ambos. Y luego hablaremos sobre
las diferencias reales y por qué deberías usar
una sobre la otra. Entonces primero dos clase de crédito, como sabemos, vas a
decir algo así como clase. Tendrás que abrir y
cerrar llaves y un punto y coma al final. Y un rato para crear una estructura, vas a decir struct, o abren y
cierran llaves y un punto y coma al final. Y ahí tienes. Esa es la sintaxis para una struct. Y esta es la sintaxis una clase. Entonces, ¿cuál es la diferencia? Bueno, en lo que respecta a nuestra
teoría de programas, o al compilador, realmente no
importa. Estos bien podrían ser
exactamente lo mismo que no
sea una diferencia clave. Y no dejes que nadie
te diga nada diferente porque realmente las pequeñas diferencias
menores bajo el capó no
van a hacer ninguna diferencia. Entonces, ¿qué diferencia esta
clave? Bueno, los miembros de la clase,
si recuerdas, por defecto son privados así, y los miembros de struct
default a public. Y ahí tienes. Esa es la diferencia
entre una clase y una estructura. Entonces solo para aclarar
aquí, en pantalla, los miembros de un efecto de
clase acceden. Los miembros de una estructura,
por defecto hacen público. Y por cierto, cuando estoy hablando de la
diferencia entre estos, sólo
me refiero a C plus
plus y a esos otros lenguajes de
programación. Entonces ahí tienes. Esa es realmente la única diferencia
entre una clase y una estructura que no sea que
la palabra clave aquí sea struct o una
clase en consecuencia. Entonces, ¿por qué usarías alguna vez una estructura sobre una
clase o viceversa? Ahora, en todo tecnicismo, puedes usar el
que quieras. Fresco. Como dije,
básicamente son lo mismo que no sea la accesibilidad predeterminada
de sus miembros, que siempre podrías
cambiar de todos modos. Pero en términos generales,
si otro programador o algo fuera a mirar
tu código y ver un trazo, asumirían que esencialmente no vas
a tener nada que
sea privado u oculto
y que prácticamente todo dentro de él
como va a ser público. Entonces, si quieres crear
una clase de algún tipo, tal vez sea una clase para funciones
matemáticas o
algo así. Y todo
va a ser público y disponible y no tienes ninguna
razón para ocultar ninguna información, entonces sigue adelante y usa una estructura. De lo contrario, si
planeas tener algún miembro nuestro
privado o protegido, realmente,
recomendaría usar una clase y eso es como algo de tipo
convencional. Pero como dije, y todo
tecnicismo y C plus plus, son esencialmente
lo mismo, claro que esta única diferencia. Así que usa lo que prefieras, pero esa es solo la
forma convencional en que se usa una estructura, es cuando no
vas a tener nada privado o protegido. De todos modos, eso
es todo para este video. Entonces voy a seguir adelante
y borrar esos abrigos. Gracias por mirar, y te
veré en la siguiente.
93. Capítulo 15 (clases): prevén la creación de clase básica: En este video, vamos a estar hablando de cómo podemos hacer que nuestra clase base sea
instanciada o creíble. Entonces actualmente en nuestro código, podemos crear un Animal Crossing y luego
darle un nombre. Y luego siguiendo eso
con un nombre para el animal como
ejemplo de sparky y dándole una H. Así que esto va a funcionar bien. Pero y si quisiéramos
hacerlo para que solo puedas crear una instancia de un perro o
un gato siendo nuestras clases las
que heredan de animal o las subclases de
la clase base animal. Bueno, es bastante sencillo, pero tenemos que hacer es subir
a nuestra clase de animales aquí. Y si abrimos eso, puedes ver a nuestro
constructor aquí mismo. Y recuerden como
les dije chicos que un constructor necesitaba ser público. Bueno, eso fue para que
pudiéramos crear una instancia de misma ya que el constructor necesita
estar disponible para hacerlo. Pero en este caso,
porque ya tenemos subclases siendo gato y perro con las que queremos trabajar
en lugar de animal directamente, todo lo que tenemos que hacer es cortar nuestra
declaración de constructor aquí. Y luego agregaremos protegido
como especificador de acceso. Entonces diremos mina de
carbón protegida, así como así. Y luego justo debajo de eso, simplemente
pegaremos
nuestro constructor. Y ahora lo único
que tiene acceso a este constructor es
la propia clase y sus subclases o cualquier cosa que
herede de la clase Animal. Y ahora si tratamos de bajar aquí y simplemente crear cualquier animal, obtendremos un error. Y eso es porque ya no
hay un constructor disponible para nosotros. Y así ahí vas.
Así es como se puede hacer una clase sobre creíble. Pero ten en cuenta, realmente no querrías hacer esto
a menos que
tengas una subclase o algo
así con lo que trabajar. En cambio. De todos modos, vamos a seguir adelante y dejar nuestro
código así por ahora. Así que solo sigue adelante y
guarda lo que tienes. Gracias por mirar, y te
veré en la siguiente.
94. Capítulo 15 (clases): operadores de acceso para miembros: En este video,
voy a estar mostrándote una forma diferente del operador de acceso
miembro. Entonces el con
el que hemos
estado trabajando hasta ahora ha sido el punto, pero hay otra
versión del mismo. Y un ejemplo de cuándo
verás esto como cuando trabajas con punteros a
clases o estructuras. Entonces, sigamos adelante y echemos
un vistazo a cómo funciona esto. Y por cierto, el
operador se ve así, que es un guión y un símbolo
mayor que. Entonces, para ver esto, sigamos adelante y creemos
un puntero a una clase. Y en este caso solo vamos a hacer
que apunte a mi gato. Entonces diremos asterisco PTR para planar y lo pondremos
igual a la dirección de a. bien, así que ahora si
imprimimos más limpio, así que así, creamos una nueva línea. Y sabemos que esto va a
imprimir la dirección de mi gato donde sea objeto aquí. Sin embargo, también podemos
usar este puntero para obtener acceso a los miembros
de lo que está apuntando. Y como dije, este
es solo un ejemplo de cuándo podrías
ver a este operador. Y no vamos a meternos en todas las diferentes
épocas que verás esto. Pero si te interesa, siéntete libre de indagarlo. Solo quería estar seguro de
mostrarte un ejemplo de uno. Verás esto, verás
que no estás completamente
desmayado cuando
veas a esos operadores. Y decidí ir con
este ejemplo porque tener punteros a objetos
no es tan infrecuente. Y luego aquí abajo, si decimos PTR y luego tenemos
nuestra flecha aquí, o un operador de acceso miembro, se
puede ver que de inmediato
tengo acceso a todos nuestros miembros de mi gato. Sigamos adelante y usemos
esas habilidades, consigamos ayuda. Y lo que
hace este operador de
acceso miembro fuera de darnos acceso al
miembro es que también
va a de, haga
referencia a esto aquí. Entonces, en lugar de
darnos la dirección ahora, solo
va a correr a buscar ayuda, que como sabemos, solo
devolveremos el valor de
salud de mi gato, que comenzó a las 100 y lo
restamos aquí a las 15. Ya lo hemos impreso
a la pantalla como 85. Por lo que esto de aquí
también va a imprimir 85. Si solo seguimos adelante
y decimos Ver así. Y si ejecutamos un código aquí, puedes ver que
imprimimos la dirección de mi gato. Y ejecutamos esta función
aquí como de costumbre. Y eso es porque este operador de acceso
miembro, cuando usaste con punteros, no sólo nos da
acceso al miembro, sino a las referencias que. Entonces, en lugar de
darnos una dirección, solo
usamos este
miembro normalmente. De todos modos, este es
solo un ejemplo de cuándo
verá a este operador. Y si te
interesa, puedes buscar otros casos de uso para ello. Pero este es el que
repasará en este curso y el que
probablemente verás con más frecuencia. De todos modos, voy a
seguir adelante y eliminar este código extra. No te
olvides de manera segura. Usted tiene. Gracias por mirar y
te veré en la siguiente.
95. Capítulo 15 (Clases): polimorfismo: En este video,
vamos a estar hablando nuestro cuarto y último principio
principal y/o pilar de la
programación orientada a objetos, el polimorfismo. Y lo que significa polimorfismo
es tomar muchas formas. De todos modos, sigamos adelante
y echemos un vistazo a un par de ejemplos
de polimorfismo. Entonces, si subimos a nuestra clase de
animales aquí, ustedes recuerden,
creamos este método de hablar. Y si miramos la
definición de eso, todo lo que hace es que toma un
sonido y lo imprime. Sin embargo, actualmente no tenemos esa versión específica
de esto para nuestro perro y gato o cualquier otra
clase y subclase infantil, podríamos querer
crear esa herencia de nuestra clase animal. Ahora actualmente tener que insertar una cadena específica cada vez que
usamos esta función
y luego poner en el sonido que el animal hace específicamente
cada vez que la usamos no
es muy eficiente. Entonces, sigamos adelante y arreglemos
esto usando polimorfismo. Entonces lo primero que
vamos a hacer es simplemente quitar este
perímetro por completo. ¿Bien? Y es que
sólo va a imprimir sonido animal así como esto. Bien, y entonces la
razón por la que estamos recibiendo este error es porque arriba
en nuestra declaración aquí, también
tenemos que
eliminar el parámetro. Una forma en que podemos solucionar nuestro problema
original ahora con nuestro perro y nuestra
clase de gatos es hacer lo siguiente. Primero, podemos simplemente seguir
adelante y copiar toda
esta función y pegarla en cada una
de ellas, así. Y ahora en ambos, solo
tenemos que quitar esta porción de
animal aquí mismo. Entonces ahora solo dice hablar
vacío y yo
solo voy a seguir adelante y eliminar
esos comentarios también. Recuerda, normalmente
lo que vas a querer hacer. Tener la declaración aquí y la definición
fuera de la clase. Pero
vamos a seguir adelante y dejarlo así
por ahora mismo. Y nuestro ejemplo de todos modos, lo que podemos hacer ahora es
en nuestra clase de perros aquí, solo cambiarlos para que digan
Park y nuestra clase de gatos aquí, solo
podemos cambiar esto para decir, Sí, eso funcionaría bien. Entonces, si bajamos aquí, sigamos adelante e
imprima un par de blancos. Entonces abajo eso
dirá mi gato hablar. Y si recuerdas, antes de
que anuláramos estas funciones, esto simplemente habría usado nuestra definición que
estaba en la clase base. Pero ahora que los tenemos anulados, podemos
hacer lo siguiente. Así que diga mi perro no hable
ahora y ejecute nuestro código aquí. Se puede ver que
imprimimos y ladramos. Y solo para recordarte una representación te cómo
funcionaba antes, si seguimos adelante y simplemente eliminamos nuestra implementación de la misma para la clase cat y volvemos a
ejecutar nuestro código. Se ve que
solo decía que los animales suenan y luego marcan, ¿no? Entonces aunque esto aquí sí funciona, el problema es que realmente
permite el error humano. Porque ahora cada vez que tenemos una clase hijo que tiene
animal como su clase padre, tenemos que recordar tener una implementación
del método speak. De lo contrario, solo va
a decir que los animales hablan, lo cual no es lo ideal en absoluto. Queremos que cada
animal tenga un sonido diferente
incorporado a la clase. Y normalmente, si lo haces
anular una función como esta y tienes la clase
base siendo animal en este caso tiene
su propia implementación. Lo que quieres hacer
es hacer esas implementaciones
una función virtual. Y te voy a mostrar qué es eso y por qué en sólo un segundo aquí. Entonces si bajamos a
nuestro código principal aquí y creamos un puntero
a nuestra clase base. Entonces, si decimos Astros animales, llamaremos a este animal intermitente. Y lo pondremos igual
a la dirección mi gato. La razón por la que esto
funciona por cierto, e incluso puedes
solicitar un animal en un perímetro de función y usar mi gato como argumento es
por lo siguiente. Y esta es otra forma
de polimorfismo en realidad, porque nuestro gato es un animal, entonces sabemos que todo a lo
que ese animal tiene acceso, gato tiene acceso. Entonces, si solicitamos un animal
en una función por ejemplo, y ejecutamos algunas funciones
animales diferentes y trabajamos a través de algunas de las diferentes variables
dentro del animal. Bueno, ya sabemos gato tiene
una implementación de todas estas cosas porque nuestro gato es un animal viendo es que
hereda de animal, y por lo tanto toma
diferentes formas. Un perro no es sólo un perro, sino que es un animal. El gato no es sólo un gato. También es un animal. Pero no podemos usar
animal como implementación
para perro o gato, por
ejemplo, porque no
todos los animales son gatos, sino que todos los gatos son animales. Entonces solo funciona de una manera. Entonces por eso está aquí abajo, estamos diciendo, bien, trabajo, ¿puedo crear un puntero a un animal y una
captura del animal? Entonces eso es obras. Bien, pero el
problema con esto es
que si yo fuera a decir cráter animal, entonces usa nuestro operador de
acceso miembro. Recuerda qué punteros
vas a usar un guión y un símbolo
mayor que. Se ve como una
flecha y luego decir hablar. Y ejecuta nuestro código. Se puede ver que un conjunto
animal sonido animal, algo de corteza, que
tiene sentido a partir de ahora mismo. Pero aunque nuestro gato aquí tuviera
una implementación de hablar. Así que vamos a poner eso
de nuevo en nuestra clase de gatos aquí y
cambiarlo a maullido. Entonces si volvemos a ejecutar nuestro código, puedes ver que obtenemos
un resultado extraño. Y eso es porque nuestro
puntero aquí que accede habla hará referencia realmente a
la versión de la clase base. Mientras que esto aquí abajo, donde usamos nuestros
objetos gato específicamente, usaremos la clase derivada
o nuestra versión de clase hijo, y eso podría no ser
siempre lo que quieres. Entonces, sigamos adelante y echemos un
vistazo a una manera de arreglarlos. Entonces si subimos a
nuestra clase base aquí, siendo animales y vamos a
nuestra función de hablar aquí. Lo que vamos a hacer es poner la palabra clave virtual
delante de ella. Y sólo tenemos que hacer
esto en la declaración. Y lo que esta palabra clave
virtual hace aquí es básicamente decir
explícitamente que
queremos que las subclases de
nuestra clase animal tengan su propia implementación
de esta función. Y todavía podemos dejar aquí nuestra implementación
básica. Sin embargo, estamos dejando
nuestro programa ahora aquí. Oye, queremos que cada
clase que deriva de animal tenga su propia
implementación de esa función, razón por la
cual la
hicimos una función virtual. Entonces eso es lo que hace, es
simplemente decir explícitamente, Hey, queremos que las subclases
de nuestra superclase o clases
secundarias de
nuestra clase padre creen sus propias versiones
de esta función. Entonces ahora si ejecutamos nuestro código, puedes ver que
ahora imprime maullido y nuestro puntero aquí. Y entonces como referenciar
nuestra función de hablar ahora funciona con la
reversión de subclases de la misma. Y eso es porque hemos dicho
explícitamente, Oye, queremos que nuestras subclases tengan su propia implementación
de esta función. Y no voy a entrar en
el meollo de por qué
esto funciona de esta manera. Pero solo debes saber si estás
planeando tener una función en la clase
base que se sobrescriba y tus
subclases que
querrás agregar la palabra clave
virtual. Y recuerden todo lo
que teníamos que lidiar con el
ritual en la declaración
y nuestra clase base, pero no en la
definición aquí abajo. Sólo para mostrarte
esto rápido, FOR cat, por ejemplo, no tenía
su propia implementación. Esto seguiría funcionando bien. Bien, entonces no lo
obliga, pero aún tenemos un problema
en el caso de que quisiéramos que nuestra clase base no tuviera
su propia implementación. Y queríamos obligar a
cada subclase a tener su propia implementación y no tener que preocuparnos de que
nos olvidemos de ella. Esto simplemente no servirá. Tal vez no
siempre sea así. En algunas circunstancias,
es posible que desee que la clase base tenga su propia implementación
como lo hicimos aquí. Pero en el caso en el que no lo hagas, déjame mostrarte cómo
podemos arreglarlo. Entonces, en lugar de tener aquí solo
una función virtual, en realidad
podemos crear una función virtual
pura. Entonces déjame mostrarte
cómo se hace eso. En primer lugar, sólo vamos
a eliminar la definición de
velocidad por completo religiosamente
podemos deshacernos de ella. Entonces aquí arriba en nuestra declaración, vamos a decir después de
los paréntesis cerrados, pero antes del punto y coma, vamos a decir igual a 0. Y ahora esta es una función puramente
virtual. Y ahora que hemos visto una función puramente virtual en
una función virtual regular, solo
hay algunas cosas que
quiero que tengas en cuenta. En primer lugar, las funciones rituales
no pueden ser estáticas, bien, así que esta no puede ser
la única versión de esta función porque
estás diciendo, Oye, quiero que mis subclases tengan
su propia versión de ella, bien, entonces por lo tanto,
no tiene ningún sentido. Además, una función virtual puede ser una función
de amigo de otra clase, y entraremos en funciones y
clases de
Friend en un próximo video.
Sólo algo a tener en cuenta. No te preocupes por eso ahora mismo. Entonces, ¿qué es una función puramente
virtual? Bueno, podemos decir que
queremos fijarlo igual a 0. Estamos diciendo que esta función no
tiene definición. Bien podría no existir. Por lo tanto, cada subclase
necesita tener su propia versión. Y tal vez te estés preguntando, ¿por qué no
nos deshicimos de un vacío, hablamos aquí por completo
y lo tiramos a cada subclase
como nuestro perro, gato? Si creamos otro
como una soga o caballo, etc. Bueno, para uno podríamos olvidar, y entonces cada animal podría
no tener una función de hablar. También, por ejemplo, si
creamos un método o una función que tomara al
animal como perímetro, no
podríamos usar
la función de hablar ya que nuestra función ya no sabe
si cada animal puede hablar, porque eso no está definido dentro de la clase animal, ¿verdad? Entonces por eso
querrías tener esto aquí
en primer lugar. Entonces, como dije,
simplemente quita el vello humano. Entonces ahora si bajamos
a nuestra clase de perros, ya
tenemos una
implementación de la lista. Sin embargo, nuestra clase de gatos no. Y como pueden ver, esto
inmediatamente nos da un error. Este es objeto de un tipo de clase
abstracta. No se permite el gato porque hay una función virtual
pura. Ahora bien, una clase abstracta
es una clase de la que no se puede crear un
objeto directamente. Entonces ya no podemos
decir el animal. Mi curso, por ejemplo, y darle un nombre como Jack. Y una edad. Esto no va a funcionar porque se
trata de una clase abstracta. Y la razón por la que
es abstracta es porque
dentro de ella hay una función que
no tiene definición. Básicamente no existe y las subclases necesitan crear
la definición para eso. Por lo tanto, no podemos
crear objetos en él en una clase abstracta es cualquier clase que tenga
una función virtual pura. Como esa función
no tiene una definición real, entonces no podemos
crear un objeto de esa clase porque ahora tiene una función que no está definida. ¿Bien? Así que tener una función puramente
virtual para uno hace que la
clase on sea creíble, que ya estamos un poco muertos al tener nuestro
constructor animal protegido. Pero aunque esto fuera público, sigue siendo no
sería creable solo por nuestra función puramente
virtual aquí, ahora
se considera abstracta
en una cosa a tener en cuenta, para aquellos de ustedes que vienen de otros
lenguajes de programación, especialmente para ustedes, así
como que si cada
miembro de la clase es puramente virtual y
no tiene implementación de
nada por sí solo. Esa clase ahora se considera una interfaz para otras cosas porque no tiene
definición de nada. Son sólo declaraciones. Entonces tiene lo que se
llama una interfaz son esencialmente solo un
plano para cualquier cosa. Y Haritsa con una función virtual
pura, es una clase abstracta. Y si todo y
era puramente virtual, sería una interfaz, consideran una interfaz de
todos modos, como ustedes vieron, porque tenemos esta función
puramente virtual, no
hay espacio para el error humano al crear diferentes animales. Entonces cuando creamos nuestro perro aquí, que dijimos como animal o nuestro gato que era
un animal, etc. cada animal que creamos ahora
tendrá que
tener una versión de la función
hablar, ¿verdad? Porque no hay
definición por sí sola. Y técnicamente podrías
dejarlo así. Y esto ahora se considera
esencialmente una
clase abstracta porque tiene una
función sin definición. Y entonces se puede tener
una clase que
deriva de gato o hereda de gato. Y eventualmente uno de
ellos necesitaría
tener una definición para hablar, porque no se puede tener un
objeto de una clase que tenga una función o
método puramente virtual porque no nos
deja hacer esto ahora, oradores ahora
implementados correctamente. Entonces dijo, cada
animal tiene que hablar y tener su propia
manera de que hable. Así que aquí abajo en nuestra clase, vamos a seguir adelante y pegar
en nuestro método de hablar. Y sólo para hacer las cosas correctamente, Sigamos adelante y
arreglemos esto ya. Entonces vamos a decir hablar vacío, punto y coma, así como así. Y va a copiar este sobre, una clase de perro, por ejemplo aquí. Entonces para las palabras pico, diremos perro, colon,
colon habla, y ahí al
punto y coma, así como así. Y deshazte de nuestra
definición aquí arriba, tal como lo hemos hecho con
todas nuestras otras funciones, como dije antes, y esa
es la forma correcta de hacerlo. Entonces copiaremos esto nuevamente, punto y coma al final para
crear la declaración. Corta esto y baja la
definición a continuación. Y en realidad
voy a ponerlo
debajo de nuestro constructor aquí. Esto será la
erosión de los gatos del habla. Y por cierto, por si
olvidé mencionarlo antes, en nuestros constructores
aquí donde
teníamos nuestro constructor animal, aquí está el constructor de
clase base. Esto sí tiene que venir
primero antes que cualquier
otra cosa en nuestra lista
inicializarlo aquí. Pero como dije, todo en el inicializador de listas necesita ser un orden de arriba a abajo, y un constructor de clase base
necesita ser lo primero. Entonces solo quería
avisarte sobre eso por si es algo que sí
me olvidé de mencionar. Y luego aquí abajo en nuestra definición de
mayúsculas para velocidad, cambiémosla para ejecutar nuestro código. Ahí tienes, todo
está funcionando correctamente. Ahora, nuestro puntero animal, que está apuntando a nuestro gato, está usando la
versión adecuada del mismo. E incluso podríamos cambiar
nuestro puntero a mi perro, y todo eso
funcionaría bien. Y además de eso, ahora no
es posible para
nosotros crear un nuevo animal o una subclase de animal que no tenga su
propia versión de hablar. Bien, así que eso es fantástico. Todo está arriba y funcionando. Y este fue el último ejemplo de polimorfismo que
vamos a repasar ya ahora nuestra función de hablar tiene múltiples versiones
de la misma, ¿verdad? Recordar polimorfismo significa
que toman muchas formas, por así decirlo, no es sólo
un puramente ritual, una función sin definición, sino que tiene su propia versión
dentro de nuestra clase de perros, y tiene su propia versión
dentro de su clase de gatos. Entonces hay algunos ejemplos
de polimorfismo para ti. ¿Bien? Hemos aprendido lo que es
una función virtual, que es solo una función que has dicho explícitamente que
fuiste a las subclases para tener
su propia versión de eso. También echamos un
vistazo a cómo crear una función puramente virtual, que fue creada estableciendo
esa función igual a 0, básicamente
estamos diciendo
que es igual a nada. No existe en este momento. Y eliminar la definición que no sólo hace que la clase
abstracta automáticamente, sino que si todo fuera puramente
virtual en la clase, sería
lo que se llama una interfaz son básicamente
un blueprint para todo lo que
hereda de ella en una
función puramente virtual en comparación con una función virtual regular, que se vería así, es solo una función
que ahora necesita una definición para ser creado dentro de una clase que
deriva de ella. Y si nuestra clase de perros no
tenía su versión de ella, entonces tampoco podríamos
crear un perro. Necesita una definición
en algún momento. Entonces tendríamos que
tener razas de perros como clases o algo así y
darle una definición ahí. En algún momento
necesita una definición para que puedas crear objetos de cualquier clase que se
derive del animal, ¿verdad? También aprendimos que
cada subclase o clase
hija también se
considera una clase base, pero no todas las
clases padres como clases secundarias. Y solo un recordatorio
en nuestro ejemplo, eso es básicamente como decir que
cada perro es un animal, pero no todos los animales son perros. Y sólo para
mostrarte rápidamente otra manera podríamos tener un
ejemplo de esto. Podemos haber creado
una función así, diciendo animal vacío o
algo así. Y luego como parámetro, porque pueden ser
un animal y un animal. Dentro de aquí, podríamos
haber dicho animal, morir hablar. Como puede ver, tenemos un error. Y eso es sólo porque animal es actualmente una clase abstracta. Así que sigamos adelante y arreglemos ese rápido aquí y
cambiemos esto de una función puramente virtual a solo una función virtual regular. Y le daremos
una definición rápida así, así como así. Ahora bien, si bajamos aquí, déjenme decir mal hablar y pasión, ya sea nuestro gato o nuestro perro. Así que vamos a conseguir gato
apasionado. Y como puedes ver cuando
ejecutamos nuestro código y en realidad no imprime
nada después de ladrar. Y eso es porque esta
en realidad utilizó animales versión de esta función, ya que creamos una copia de los valores de los
gatos y la pusimos en
un animal esencialmente. Pero para arreglar esto, todo lo que tenemos que hacer es tomar una referencia al
animal Peston, y ahora esto va a
funcionar bien. Entonces, si
volvemos a ejecutar nuestro código, ahí tienes. Lo imprime. Sí. Y como dije, porque un perro también es un animal, también
podríamos haber
pasado en mi perro. Y nuestro código y nuestra
función habrían funcionado igual excepto que
ahora imprime corteza. Entonces ahí tienes. Entonces ahí tienes. Ojalá ahora tengas una comprensión básica del polimorfismo en algunas de
las diferentes formas de usarlo, junto con algunas
palabras clave diferentes que lo acompañan. Entonces miramos
clases abstractas e interfaces. También analizamos la creación de funciones
virtuales que tengan su
propia implementación y lo decimos explícitamente de esa manera. Qué subclases para crear
sus propias versiones de esto en funciones puramente
virtuales, que básicamente dicen que no
hay definición y las subclases tienen que crear
su propia versión de la misma. Y las subclases,
nuestras clases base, esas clases base no son
necesariamente subclases. Entonces no podríamos haber
tomado como parámetro a
un gato y
enviarles un animal. De todos modos, eso es todo
para este video. Gracias por mirar, y te
veré en la siguiente.
96. Capítulo 15 (Clases): cuatro principios principales de la OOP: En este video,
vamos a volver a visitar los cuatro pilares principales o principios de la programación
orientada a objetos. Y estos no están en ningún orden en
particular. Y también otra nota
es que no cubrimos todos los aspectos posibles de cada uno
de estos cuatro pilares principales, pero sí cubrimos los conceptos básicos y la esencia principal de ellos divididos, ya
sabes qué son
y cómo y cuándo puede implementarlos en
sus propios programas. Entonces el primero vamos a
hablar de contaminación. Y si recuerdas, la encapsulación es cuando
los datos se ocultan desde el exterior al ser encapsulados dentro de funciones
accesibles. Entonces un ejemplo de
cuando hicimos esto, fue cuando teníamos nuestras funciones
getter y setter que ayudan a todas nuestras variables
privadas
dentro de ellas son variables privadas fueron encapsuladas dentro de nuestro
getter y funciones setter. Bien, así que esa
es la primera. Entonces vamos a
hablar de abstracción. Y básicamente
se puede pensar en esto como casi una extensión
de encapsulación y abstracción es
cuando sólo se muestran al usuario
datos o información relevante. Entonces, por ejemplo,
cuando enciendes tu teléfono o abres
una aplicación, solo
ves la información
relevante. Y un ejemplo de cuando
hicimos esto es una vez más, cuando teníamos nuestro
getter y setter, no
necesitáis saber qué
había en ese bloque de código, cómo afectaba exactamente a
nuestras variables privadas. Todo lo que necesitas saber cuál es
el nombre de la función
y los parámetros. Todo lo demás acaba de
suceder dentro de un segundo plano. Por ejemplo, cuando teníamos
nuestra variable de salud y no te
dejaba ir
más allá de un 100 o menos de 0. El usuario no necesitaba
saber nada de eso. Cuando llamamos al peón
nuestras funciones para cambiar o establecer nuestra variable de
salud, solo
necesitamos denotar el nombre de la función
y lo que el inserto como el perímetro y todo lo demás fue abstraído de nosotros. Estaba escondido en el fondo. Entonces eso fue abstracción. A continuación, tenemos la herencia como básicamente cuando algo
hereda de otra cosa. Entonces, por ejemplo, en la programación, herencia es cuando
heredas miembros de otra cosa, esto te permite encontrar
similitudes en una clase padre. Entonces, por ejemplo,
nuestra clase animal, que definió un poco
lo que es un animal, pudimos tener cosas
como una función de hablar, una variable de salud
llamada variable. Pudimos sentar las bases
de lo que era un animal. Y luego cosas que
podemos heredar
de eso para quedarnos un poco, oye, esto es un animal. Entonces va a tener todo lo
que tienen todos los animales. Y entonces también puede tener su propia identidad,
su propia singularidad. Entonces, por ejemplo, nuestros
animales de gato y perro imprimieron
diferentes cosas. Entonces, cuando nuestro gato habló y cuando la oscuridad
hablaba a ladró, y cuando se creó, había impreso cosas ligeramente
diferentes diciendo o un catalizador creado o un perro que fue creado
específicamente. Pero todos tenían una
cosa en común siendo la clase de padres o la clase de animales que
creamos, ¿verdad? Y ese fue un
ejemplo de tener dos clases heredadas
de una clase base. Y recuerde, hay
un montón de otras cosas que puede ver llamadas clases de niños y
padres, pero muchas veces la clase de
padres e hijos se usa con más frecuencia. Y es sólo una
manera fácil de pensarlo. Porque, por ejemplo, los niños heredan cosas
de sus padres. Entonces esas son una
conexión fácil en la vida real ahí mismo. Y por último,
tenemos polimorfismo. Y lo que significa polimorfismo
es tomar muchas formas. Y acabamos de ver algunos ejemplos de esto
en el último video. Entonces algunos ejemplos de cuando usamos polimorfismo
es sobreescribir funciones. Además, se utilizaron subclases
como clase base. Por ejemplo, usamos un gato
y un perro como sustitutos del perímetro
de un animal porque
sabemos que cualquier cosa
y animal puede hacer. Un gato y un perro
también pueden hacer porque
heredan todos los mismos
miembros y más. Y luego algunos otros ejemplos de esto que echamos
un vistazo a donde nuestras funciones virtuales y a puras
virtuales, que declaraban explícitamente, Oye, si estas van a ser
sobrescritas y va a haber otras implementaciones
de esta función. De todos modos, ahí tienes. Esos son los cuatro
principios o pilares principales, más que una columna de programación orientada a
objetos. Entonces tienes encapsulación, abstracción, herencia
y polimorfismo. Sé que muchos cursos para principiantes no tocan los
cuatro de estos. Pero personalmente,
ver es que estos son los cuatro principios principales de la programación orientada a
objetos. Simplemente no veo dejar estos fuera de ningún curso para principiantes, sobre todo porque
muchas veces, una vez que hayas terminado un
curso de programación para principiantes, vas a salir y
empezar a trabajar con tus propios programas y solo
tratando de hacer todo lo que puedas con lo que sabes y
cómo vas a ir y crear código de buena calidad en un lenguaje de
programación orientado a si ni siquiera sabes los cuatro principios principales de la programación orientada a
objetos , de
todos modos, espero que hayas disfrutado
el video como siempre, gracias por
verlo, y te veré en el siguiente.
97. Capítulo 15: funciones y clases de los amigos: En este video,
vamos a estar hablando funciones y
clases de
Friend en C plus plus. En primer lugar, te voy
a decir lo que es una función de
amigo y
una clase de amigos. Voy a seguir adelante
y mirarlo y crear un ejemplo de ambos. Una función amigo es
una función que puede acceder a los datos privados y
protegidos de una clase. Y una clase amiga puede acceder a datos
privados y protegidos
o miembros de otra clase. De todos modos, sigamos adelante y
creemos y echemos un
vistazo a un ejemplo tanto
de una función
de amigo como de una clase de amigos. Bien, así que arriba de
nuestra función principal, Sigamos adelante y
creamos una clase, y simplemente llamaremos a esta clase. Tendremos nuestro
bloque de código así. Y no olvides el
punto y coma al final. Ahora foo suele ser un nombre genérico que verás
con bastante frecuencia en los ejemplos. Es solo una especie de nombre
común para el titular de un lugar. Así que vamos a seguir adelante
y usarlo solo para
mostrarte un ejemplo de lo
que podrías ver esto como. Ahora mismo, te estoy mostrando
un ejemplo de algo. Diré clase. Y dentro de aquí con
bastante alta la variable. Entonces vamos a decir privado, así como así. Y
luego Dumbo eso. Solo diremos int x y
en realidad vamos a
seguir adelante e inicializar esto. Sé que normalmente quieres
tener esto separado, pero solo para mantener este
ejemplo al grano, no
nos vamos a
preocupar por ello. Y luego fuera
de la clase
crearemos una función
que imprima x. Así que digamos void, print x. Y luego entre paréntesis
aquí vamos a tener un parámetro que toma
un objeto de clase Foo. Así que guarda, y ahí solo
llamaremos a esto minúscula. Entonces dentro de nuestro
bloque de código dirá foo got x Ahora, como sabemos, las variables
privadas y protegidas
no son accesibles
fuera de la clase. Y las funciones de amigo,
así como las clases de amigos
no son miembros de la clase de la
que son amigos, ni son subclases de la misma, están
completamente separadas. Sin embargo, para declarar nuestra
función como función amiga, necesitamos especificarla
dentro de la propia clase. Entonces en nuestra clase Foo aquí, básicamente
vamos
a tener lo que parecería una declaración o un prototipo
de nuestra función print x. Así que simplemente copiaremos toda
esta línea
y la pegaremos aquí mismo. No olvides nuestro punto y coma
aquí al final. Ahora, como se puede ver, a una todavía inaccesible,
para arreglar esto, todo lo que tiene que
hacer es hacer de esto una función de
amigo agregando la palabra clave friend antes de un
vacío aquí, así como así. Y ahora, como pueden ver, esto funciona bien. Entonces si bajamos a nuestra función
principal y luego simplemente recurrimos a nuestra
función
print x, print x e y. tengo que insertar e implementación
de foo aquí. Entonces lo llamaremos. Entonces, sólo le enviaremos eso. Justo aquí. Ahí vamos. Pudimos acceder a este miembro privado con
nuestra función de amigo. Y fíjense que
solo tuvimos que poner Friend y esta línea aquí mismo y no la
declaración de función real ahí. Por cierto, una función de amigo podría tener múltiples amigos. Entonces, para mostrarte esto, sigamos
adelante y eliminemos todo. ¿Tú no? Recuerda nuestra función y nuestra declaración de función de amigo. Entonces cambiemos la
clase foo a clase, cópiala y la peguemos abajo abajo. Y vamos a llamar a esto una clase a, clase B, un entero privado. Simplemente llamaremos a esto y,
sólo por el gusto de hacerlo. Y pondremos esto igual a diez. Luego abajo, crearemos
nuestra función, entonces digamos void, y luego la clase pay un objeto y llamaremos a esta clase ser objeto y la llamaremos b. Entonces haremos de esto un amigo
de ambas clases. Así que simplemente copie esta
línea superior aquí, péguelo, ponga un punto y coma al final y agregue la palabra clave. Entonces podemos simplemente copiar esto
y pegarlo hacia abajo, así. Y luego dentro de
nuestra función aquí, a x más b y, así como así. Ahora fíjate
que esta es inaccesible, y te voy a mostrar por qué
en tan solo un momento. Pero antes de hacerlo abajo
en nuestra función principal, crearemos una instancia
de ambas glosas. Y recuerda que podemos nombrar
esto como quieras. No importa. Nuestros nombres perimetrales
van a estar separados. Entonces podría decir a b y un
poco de color agregar función. Como no es parte de nada. No necesitamos especificar de
dónde es. Y luego solo di, no
pongas punto y coma al final. Y esto funcionaría bien
una vez que arreglemos este error aquí. La razón por la que estamos obteniendo
esto es porque la clase no sabe qué a
no sabe qué es la
clase B cuando lee nuestro código aquí. Y podemos arreglar esto
con algo que se llama una declaración anticipada. Y pondremos esto
aquí en la parte superior derecha encima de nuestra clase a. y todo lo que vamos a
hacer como clase y poner punto y coma al final. Y esto va
a arreglarlo todo. Y como dije, a esto se
le llama declaración anticipada. Hemos visto ejemplos
de esto cuando teníamos un prototipo de función y luego
la definición abajo, excepto que esto era simplemente hacer
lo mismo con una clase. Básicamente estamos diciendo,
oye, va a ser una clase llamada
código B y R y ahora son una
clase que no ha confundido. Como puede ver, el error se
fue y podemos ejecutar nuestro código, imprime 15 porque nuestra función
add y acceso a la variable privada x y
a la variable privada y. podemos llamar a estas dos X. Realmente no habría
importado. Entonces ahí tienes. Hay algunos ejemplos
de funciones de amigos, que son solo funciones
que tienen acceso a miembros
privados y protegidos de la clase o clases de las que
son amigos. Y luego tenemos clases de amigos. Te voy a mostrar eso ahora mismo. Y para ello, subamos
a la clase I, y vamos a eliminar por completo
nuestra función de amigo
aquí, así. Y luego vamos a decir clase de
amigos, así como así. Y ahora la clase B tiene acceso a los
miembros privados y protegidos de la clase. Y vamos a seguir
adelante y simplemente quitar nuestra
función de amigo por completo ahora. Y lo moveremos
aquí abajo en nuestra función principal. Y luego en la clase B aquí, vamos
a crear una función para agregar x e y. Entonces di void add i. Ahora normalmente
no queremos poner la definición dentro
de la clase aquí. Pero para que las cosas sean simples, vamos a seguir adelante y hacerlo. Entonces aquí vamos a decir un color. Voy a decir y más x. y porque Clase B como amiga,
digamos, como aquí se indica. Y una vez más, una clase
puede tener múltiples amigos, igual que cuáles son sus funciones. Tendrá acceso a
variables privadas dentro de clase, así
como protegidas, aunque
no sea una subclase de
clase a o parte de la
clase a en absoluto. Así que creamos una
instancia de clase,
digamos, dentro de la clase B, igual que hicimos con nuestra función de
amigo, básicamente, ya que todavía necesitábamos una instancia
de la clase con la que trabajar. Y ahora en nuestra función principal, podemos seguir adelante y deshacernos
de todo esto aquí y simplemente decir B y llamarlo B
o lo que quieras. Y luego abajo eso
sería así con el
punto y coma al final. Tienes que hacer para arreglar este error aquí estamos
en es inaccesible, es hacer nuestra función opinión
pública, pública. Voy a limpiar eso
un poco y ahí vamos. Nuestra función es
ahora accesible por nuestra instancia de la clase, ya que es pública y podemos
seguir adelante y llamarla. Y ahí tienes.
Sale 15 porque y y cinco se sumaron
porque esos Equipo, todos modos, ahí tienes. Ya sabes lo que funciona un
amigo y un amigo clases y
cómo usarlas. Entonces como siempre, gracias por mirar y
te veré en la siguiente.
98. Capítulo 15 (Clases): espacios de nombres: En este video, vamos a estar
hablando de espacios de nombres. Ahora como algunos de ustedes recordarán, parte de nuestro código proviene
del espacio de nombres estándar, como C y C out. Y la razón por la
que no hemos tenido que ver mucho con ello como porque especificamos o dijimos
explícitamente que vamos a estar usando código del espacio de nombres std. Sin embargo, si esto no estaba aquí, y yo solo voy a seguir adelante y
comentarlo por un minuto e intentamos decir
algo enlaza a C out. No tiene idea de dónde viene el
SEO. Y eso es porque es parte del espacio
de nombres estándar
std aquí para abreviar. Si no quisiéramos tener
esto explícitamente en la parte superior, tendríamos que decir std dos puntos, dos
puntos seguidos de C out, o la pieza de código
que estamos usando de
este espacio de nombres y CN
sin fisuras aquí abajo. Y algunas de las
otras cosas que hemos usado en el pasado también. Number a namespace es básicamente solo un espacio con nombre o una porción de código con nombre para ayudar a especificar de qué
está hablando. Entonces normalmente, si
tuvieras dos funciones con el mismo nombre exacto
y los mismos parámetros, sería
difícil distinguir
cuál estás usando. Sin embargo, si cada uno
formaba parte de su propio espacio de nombres, entonces nuestro compilador sabrá de
cuál estamos
hablando y haciendo referencia a dónde viene
el código. Y un ejemplo que utilicé
en un video anterior, como se puede pensar en esto
como el apellido de alguien. Entonces, si tuviera que
acercarme a ti e iniciara una conversación y yo solo dijera, John, quizá no sepas de
quién estaba hablando. Pero si dijera como John Silver
o algo así, entonces porque
lo he asociado con un apellido, sabrías a quién me
refiero de aquí en adelante. Y eso es un poco similar a nosotros diciendo que vamos a estar
hablando del código de nuestro espacio de nombres estándar
en nuestro código aquí. Bien, así que de todos modos,
si esto no estaba aquí, solo tenga en cuenta que
tenemos que especificar dónde viene este código. A medida que crea
programas más grandes
usted mismo, es posible que desee crear
sus propios espacios de nombres para ayudar a diferenciar de dónde proviene
su código. Y te voy a mostrar cómo
podemos hacerlo ahora. Así que déjame seguir adelante y solo
quitar estas cosas de aquí. De hecho, tengo la sintaxis para crear tu propio espacio de
nombres aquí mismo. Entonces vas a tener la palabra clave
namespace
seguida del nombre de tu espacio de nombres. Y luego dentro de
los corchetes, tendrás el código que
no forma parte de él aquí arriba. Vamos a seguir adelante y
crear dos funciones. Y este va a ser un ejemplo
bastante básico, pero debería entender ese punto
de cómo crear y usar un espacio con nombre
o un espacio de nombres. Entonces diremos vacío. Imprimir hola. Dentro del código para eso. Yo sólo diré escala. Hola. Solo para ayudar a
diferenciarlos porque
vamos a crear otra función con exactamente
el mismo nombre,
el mismo espacio de nombres Hello,. Uno. Así como así. Entonces
solo crearemos una línea en blanco. Entonces sigamos adelante y copiemos todo
esto y lo
peguemos abajo. Y cambiaremos
esta para que diga, quiero decir que ella tiene dos. Y actualmente, si tuviéramos que intentar y simplemente llamar a esta función
enviando hola y ejecutar nuestro código. Se puede ver que
vamos a obtener un error. Eso es porque ya existe la
función que tiene un tipo de retorno void llamado print un tipo de retorno void llamado print
hello y no tiene
parámetros. Entonces no podemos tener dos
de lo mismo. Y a medida que tu código se expande como sea posible
, te encontrarás con el mismo problema donde podrías tener
múltiples funciones que tienen el mismo nombre solo por su legibilidad o
algo así. Y este es un gran
ejemplo de cuándo querrías
crear un espacio de nombres. Aquí arriba, vamos
a decir espacio de nombres. Llame a este espacio de nombres uno
solo por simplicidad. Entonces tendremos
nuestros corchetes abiertos
y cerrados , así. Entonces simplemente cortaremos
esta función superior aquí y la pegaremos
dentro, así como así. Entonces copiaremos todo esto y
lo pegaremos abajo. Y sólo vamos a seguir
adelante y deshacernos de esta función extra y n aquí. Simplemente cambiaremos esto
a Hello namespace a. Y ahora, como pueden ver, no sabe en absoluto de lo que estamos
hablando. Y dice imprimir hola
es completamente indefinido. Y eso es porque al
igual que con nuestro CN o un C out objetos no tiene idea de lo que estamos hablando y
en realidad va a cambiar esto, el espacio de nombres a aquí
abajo también. Entonces tenemos que hacerle saber de dónde viene
esta
función print hello. Y podríamos hacer lo
mismo que podríamos con nuestro espacio de nombres std aquí, donde simplemente
lo pusimos justo antes. Entonces podemos decir espacio de nombres, un dos puntos, dos puntos,
así, imprimir hola. Entonces si copiamos toda esta línea y la pegamos abajo, así, change enumera el espacio de
nombres y ejecutamos un código. Puedes ver que
funciona bien y sabe exactamente
cuál queremos usar porque
especificamos de dónde viene ese
código. Ahora bien, este ejemplo aquí
solo usamos una función básica, pero tienes que tener todo tipo
de código dentro de un espacio de nombres. Y solo recuerda, un espacio de
nombres nos
permite separar nuestro
código y ser más específicos sobre de dónde
viene
ese código para ayudar a prevenir
enfrentamientos y nombres. Entonces, por ejemplo, aquí
tenemos dos funciones con el mismo nombre porque
son parte de un espacio de nombres
diferente, podemos especificar de
dónde viene eso y estos nombres
no chocarán en absoluto . Ahora, al igual que antes
donde dijimos que
estamos usando namespace std. Aquí arriba. Podemos decir algo
así como usarlos. nombres, espacio de nombres. Y no olvides el
punto y coma al final de eso. Y ahora si
quisiera, podría simplemente deshacerme de decir namespace uno y
ejecutar nuestro código aquí. Y esto va a funcionar
bien porque ya he especificado que voy a estar usando código de esos espacios de nombres. Ahora tal vez te estés preguntando, ¿ si hiciéramos lo mismo con el nombres para volver a ejecutar nuestro código? Bueno, como pueden ver, tenemos un error y eso es
porque una vez más, no sabe de lo que estamos
hablando aquí mismo. No obstante, fíjate que aquí abajo no
nos dieron un error. Y eso es porque tenemos dos espacios de nombres que
dijimos que vamos a usar. Y hay un choque en el nombramiento de estas dos
funciones, ¿verdad? Porque tenemos dos
funciones con el mismo nombre en dos espacios de nombres diferentes
que dijimos que estamos usando. Ahora. Otro código dentro de
estos espacios de nombres que no tenían un choque en el nombre o el nombre no
era el mismo. No nos encontraríamos con un error. Seríamos capaces de utilizarlos ambos por separado sin ningún problema. Entonces, por ejemplo, si
solo copiamos esta función aquí y la pegamos por debajo eso y hacemos lo mismo aquí arriba. Simplemente llamaremos a
éste hasta éste. Y este de
aquí abajo, imprimir hola a, bueno, puedo decir imprimir
hola uno, así como así. Y va a saber de
lo que estoy hablando porque ahora solo hay
una función con ese nombre en cualquiera de
los espacios de nombres que
dijimos que estamos usando en
nuestro código en general. Ahora, va a
funcionar bien. Puede pesarlos para
cambiar eso aquí mismo. Así que adelante y haz eso.
Y si lo vuelvo a ejecutar, puedes ver que
lo imprime en el espacio de nombres uno porque de ahí es de donde venía
este código. Entonces, si estás usando múltiples espacios de nombres y lo has dicho
explícitamente
en la parte superior aquí. Y tienes una función que tiene el mismo nombre
que otra función, ya sea en tu código o dentro de
uno de los espacios de nombres aquí, necesitas especificar de
dónde viene eso, como hicimos aquí. Así que imprime hola a, podríamos usar normalmente e imprimir hola uno que podríamos usar normalmente. No obstante, imprime hola ahora, porque tenemos dos de
ellos con el mismo nombre, solo hay que
especificarlo. Así que al igual que hicimos aquí
abajo, aquí arriba, el espacio de nombres, uno, dos
puntos, dos puntos así, ejecuta nuestro código. Como puedes ver, todo
funciona bien. Entonces ahí tienes. Así es
como se crea un espacio de nombres. Simplemente va a decir espacio de
nombres seguido de un nombre, y luego un conjunto de llaves con
su código dentro de él. Entonces si quieres usar
código de ese espacio de nombres, puedes simplemente hacerlo
explícitamente
así o decirle explícitamente
tu código en la parte superior, oye, voy a usar
codificar desde ese espacio de nombres. Y esto solo te
ayudará a ordenar tu código para que sepas exactamente de
dónde viene, así
como evitar choques en nombres con funciones,
variables, etc. así que ahí lo tienes.
De todos modos, gracias por mirar, y te veré
en la siguiente.
99. Capítulo 15 (Clases): Array Of Objects: En este video,
vamos a estar
hablando de crear arreglos de clases y echar un
vistazo a cómo podemos trabajar
con eso también. Entonces primero, arriba aquí arriba,
seguiremos adelante y
crearemos una nueva clase. Y digamos
algo así como clase. Artículo. Dentro de nuestro código aquí va a
decir algo como esto. Vamos a decir cadena, nombre, luego oro, así. Y sigamos adelante y hagamos privadas
ambas variables. Y recuerda que esto
se hizo por defecto. Pero sólo vamos a
seguir adelante y tenerlo. Están explícitamente
porque arriba con nosotros, vamos a crear algunos métodos
públicos con los que trabajar. Entonces vamos a decir público, así. Y luego crearemos
dos funciones, crearemos una llamada item. Y esto no iba a tomar ningún parámetro y
tampoco va a tener un tipo de
retorno. Entonces solo diremos ítem vacío. Entonces para eso diremos vacío. Y tampoco vamos a tener
perímetros para eso. Entonces nuestra clase ahora
se ve así. Y luego crearemos
las definiciones para ambas funciones
abajo de la clase baja. Entonces voy a copiar esto aquí, pegarlo hacia abajo,
y copiar y pegar eso también. Entonces tenemos que decir explícitamente de
dónde vienen. Entonces nombre de réplica,
diremos ítem dos puntos, dos puntos, así como así. Y nosotros haremos lo mismo aquí abajo. Entonces necesitamos los corchetes para la definición
de cada método. Entonces dentro del set item, vamos a ir así. Vamos a decir
CL, nombre del elemento, espacio de
dos puntos así como
ese en ese de ahí. Y luego por debajo de eso,
lo que lo ven. Y luego después de eso creamos
una línea en blanco, así. Y luego imprimiremos espacio
de costo de artículo. Y también pondremos punto y coma
al final de eso. Y luego diremos
C e iremos así. Y luego abajo aquí, vamos a imprimir
ambas variables. Entonces diremos nombre CL, seguido de un espacio. Espacio. Lo
seguiremos con los costos de Coca-Cola. Entonces nuevamente entre comillas, diremos piezas de oro espaciales y pondremos punto y coma al final. Y en realidad va
a seguir adelante y crear una nueva línea al
final de eso también. Hazte bien,
así que asegúrate de que toda
tu clase
coincida con la mía aquí. Y abajo en nuestra función principal, vamos a decir que el tamaño const
int es igual a tres. Entonces abajo eso
creará un bucle for. Entonces digamos para int I es igual a 0, yo menos que talla I plus, plus. Entonces sigamos adelante y en realidad copiemos eso y
peguémoslo abajo. Ahora tenemos 24 bucles aunque. Vamos a pasar por aquí
tres veces. Y luego abajo de
una constante aquí, vamos a crear una
matriz de elementos tipo. Ítem, voy a llamar a esto artículos. Después n corchetes. Diremos tamaño. ¿Qué pone un punto y coma
al final así? Entonces en nuestro primer bucle for, vamos a decir
item en el índice i. Ya que esto
pasará de 0 a dos, que es el mismo índice de
nuestra matriz de ítems actualmente, porque este es un tamaño de tres. Y luego después se cerró
corchete que aquí simplemente
vamos a decir punto, set item, abrir y
cerrar paréntesis, y un punto y coma al final. Así que cada vez que se ejecuta
a través de nuestro bucle for aquí, va a ejecutar a través los diferentes elementos
en nuestra matriz de tipo elemento y ejecutar este código aquí desde
nuestra función set item. Sólo vamos a
pedir un nombre de artículo y luego insertaremos un nombre, y luego voy a pedir un artículo, costos de
oro, y lo
insertaremos también. Entonces en nuestro segundo bucle for, vamos a decir items
en el índice I, print item. Entonces vamos a agregar un poco de texto de contexto en cada uno de
estos bucles for, ¿verdad? Entonces vamos a decir espacio de artículo e imprimimos I más uno. Y
lo seguiré con el espacio. Pasos. Dirá dos puntos y luego creará una
nueva línea después. Entonces solo diremos barras invertidas n. Ok, así que ahora va a funcionar bien. Copia eso y pegarlo en
nuestro otro for-loop también. Entonces si volvemos
a nuestro artículo establecido aquí, solo
vamos a
seguir adelante y eliminar este extra y el mío enviado. Ya va
a bajar una línea después de que pusimos aquí el nombre. Bien, y luego sigamos
adelante y ejecutemos nuestro código. Y como pueden ver, y
eso es para ítem en estadísticas. Y yo sólo voy a llamar a esta manzana. Dale un costo de
artículo de oro para llamarlo naranja. Costo de tres. Y por último, diré algo como coco y
le daré un costo de cinco. Y luego después, puedes ver que imprimimos las estadísticas de
cada elemento. Entonces no quería Stats. Apple cuesta a piezas de oro, artículo a estadísticas, columnas naranjas, tres, artículo a través de estadísticas, coco causa cinco y van. Así es como se puede trabajar
con una matriz de objetos. Vas a crear una matriz
normal con el tipo
siendo el nombre de la clase como ese, como el tipo
con el que queremos trabajar , el nombre de la matriz, igual que de costumbre y tu
tamaño igual que normal. Y entonces todo lo que
tienes que hacer es usar tu
operador de acceso miembro para trabajar con los
miembros disponibles de cada clase. Por cierto, si estás
trabajando con una colección
del tipo de clase base y luego
insertas elementos de un tipo de subclase. Entonces, por ejemplo, si
hubiéramos tenido como un vector de animales antes y luego
insertados objetos de gato y perro. Querrás trabajar con una matriz
real de punteros a esos objetos y no a
los objetos y celdas. Y eso es porque
cada subclase
será de tamaño y memoria variables. Mientras que si solo tuvieras
un puntero a cada uno de esos objetos de subclase
en tu contenedor, todos los punteros
ocuparán la misma cantidad de memoria y no
tendrás ningún problema. Entonces como dije, si estás trabajando
con el contenedor de un tipo de clase base y estaremos teniendo artículos de tus tipos de
subclase. Como eso funcionará, asegura de que estés
trabajando con una serie de punteros a esos objetos, y no solo a esos
objetos en sí mismos. De esa manera, todos
ocupan la misma cantidad de memoria y no
tienes ningún problema. De todos modos. Eso es todo
para este video. Gracias por mirar, y te
veré en la siguiente.
100. Capítulo 15 (clases): separar archivos: En este video, voy a
estar mostrándote cómo puedes separar tus clases
en archivos separados. Uno es un archivo de encabezado y
el otro un archivo CPP, que si
miras aquí arriba, es
con lo que hemos estado trabajando todo este tiempo. Y estos incluyen declaraciones con las que hemos estado trabajando, nos
han permitido acceder también a archivos de
cabecera de otras
clases. Y te estaré mostrando
cómo podemos acceder o incluir nuestros propios archivos de clase. Y esto realmente te
va a permitir organizar tu código y usarlo en múltiples programas ya que
solo
podrás acceder al archivo que no es. Así que comencemos. En primer lugar, aquí en la cima, vamos a decir clase. Y llamemos a
esto mi clase. Y luego dentro de aquí, sólo
vamos a crear una función básica. Entonces vamos a
decir vacío, impresión, trabajando paréntesis abiertos y
cerrados y un punto y coma al final. Y luego vamos a definir esta función fuera
de nuestra clase. Porque si recuerdas,
esa es la forma correcta de
definir funciones
para tus clases. Entonces digamos chico en mi
clase, dos puntos, dos puntos, o el operador de
resolución de alcance, seguido de trabajar paréntesis abiertos
y cerrados. Y entonces tendremos nuestro bloque de
código abajo. Y dentro de aquí,
vamos a decir que CL está funcionando así. Y ahí tienes. Veamos cómo
podemos dividir esto ahora en múltiples
archivos correctamente. Ahora, solo para agregar un
par de comentarios aquí. Entonces tu
declaración de clase va a entrar en algo
llamado archivo de encabezado. Bien, así que esto de aquí
va a entrar en un archivo de cabecera. Y entonces tus definiciones para todo lo que
has declarado van a ir dentro
del archivo cpp. ¿Verdad? Entonces sigamos adelante y hagamos eso. Entonces aquí abajo en
nuestra función principal, Sigamos adelante y
también imprimimos. Antes de imprimir eso, vamos a
crear una nueva línea. Así dicen M9, fin de principal, así. Ahora sólo les voy a estar
enseñando a ustedes cómo
hacer esto en Visual Studio. Pero dicho eso, recomiendo
seguirlo independientemente ya que puedes aprender
algo en el camino, y dependiendo de
qué programa estés usando para escribir tu
código en C plus plus, deberías poder
hacer algo similar ahí también. Y simplemente
tendrás que buscar las pocas diferencias y cómo crear los archivos ellos mismos. Ahora, lo que
vamos a hacer es ir
aquí a nuestro
Explorador de Soluciones a la derecha. Y si no ves esto, puedes subir a la cima
aquí y hacer clic en Ver, y luego hacer clic en Explorador de
soluciones. Así que todo lo que vamos a hacer es hacer
clic derecho sobre aquí y el Explorador de soluciones bajar a Agregar y luego hacer clic en nuevo elemento, luego hacer clic donde
dice punto CPP. Y aquí abajo en la
parte inferior, en lugar de fuente, vamos a escribir el nombre de la clase que queremos crear. En este caso, diremos mi clase y nos aseguraremos de que ahí esté
deletreada igual. Después sigue adelante y pulsa Add. Y ahora puedes ver nuestro nuevo archivo está justo aquí en la parte superior. Luego volveremos a hacer clic derecho en nuestro explorador
de soluciones, bajaremos a Agregar, hacer clic en nuevo elemento e ir a
donde dice archivo de encabezado. Y luego cambiar el nombre
aquí a mi clase punto h. Y una vez más,
asegúrate de que esté escrito correctamente y con la capitalización
correcta. Bueno, vuelvo a agregar. Y ahí vamos. Entonces
si volvemos a nuestro archivo principal aquí y recortamos todo aquí que
iría en nuestro archivo de encabezado. Entonces vamos a volver
a nuestro archivo de encabezado, que se entiende por mi clase
punto h y lo pegaremos ahí. Luego volveremos a
nuestro archivo principal nuevamente y recortaremos nuestras definiciones de
clase. Ve a nuestro archivo CPP y
pégalo ahí también. Y al instante
vas a notar que nuestro archivo CPP aquí no tiene
idea de cuál es mi clase. Y eso es porque al igual que en nuestro archivo principal donde incluimos
estos archivos de encabezado aquí, tenemos que hacer lo mismo
y nuestro archivo CPP. Entonces lo que vamos a
hacer, digo hashtag. Ojalá. Luego, cada vez que esté
trabajando o agregando un archivo de encabezado creado por el usuario y no uno que esté
integrado en C plus plus. En lugar del símbolo menor que
y mayor que, vas a usar comillas
dobles como esa. Entonces vamos a
decir mi clase punto h. Ahora, notarás
que no entiende lo que significa C out. Y eso es porque es parte
de un, otro archivo de encabezado. Y si solo pasamos el mouse sobre eso, puedes ver que puedes presionar Alt Enter para mostrar
posibles correcciones. Y todo lo que quiero hacer es
incluir el archivo iostream. Así que por favor haga clic en eso, se
agregará
ahí mismo en la parte superior. Y aún tenemos que incluir de
dónde viene esto. Entonces, una vez más, podemos golpear Alt, Enter en Visual Studio
y o bien agregar std, seguido del operador de
resolución de alcance y C out. O podemos hacer lo que
hicimos antes y agregar esto usando namespace, std. Podríamos haber escrito
todo esto manualmente, pero solo quería mostrarles a aquellos de ustedes usando Visual Studio. Otra forma en que podemos arreglar
rápidamente nuestro código. Entonces si volvemos
a nuestro archivo principal, podemos seguir adelante e incluir nuestro archivo de encabezado de mi clase. Entonces vamos a decir hashtag include. Recuerda, lo vamos
a poner entre comillas. Y como puedes ver
en Visual Studio en ya aparece
nuestras opciones aquí. Así que podemos simplemente hacer doble clic
donde dice mi clase punto h, y lo imprimiré para nosotros. Entonces aquí abajo, podemos seguir
adelante y crear un objeto o una
instancia de nuestra clase. Así dice mi clase. Esta clase. Y luego para poder acceder a
nuestra función desde mi clase, necesitamos volver
a nuestro archivo de encabezado y hacer esta función. Recuerden que sólo vamos
a decir público seguido dos puntos y luego poner nuestra declaración de
función debajo de eso. Entonces si volvemos ahora a
nuestro archivo principal, podemos guardar esta clase dot print trabajando entre paréntesis cercanos y un punto y coma al final. Y ahora si ejecutamos un código, todo va
a funcionar bien. Como pueden ver, imprimí
como trabajo y fin de principal. Ahora, otra cosa que sí
quería mencionar es que si terminas cerrando con alguno de estos
expedientes por accidente. Así que digamos que
cierro el
archivo de encabezado en su explorador de
soluciones. Debajo de los archivos de encabezado que
puedes ver está aquí mismo. Simplemente haga doble clic en
eso y lo abrirá de inmediato. Y luego tu archivo CPP
está aquí abajo bajo archivos
fuente y
nuestro archivo CPP principal, y también hay bajo archivos
fuente también. Una última cosa que sí quiero
mostrarles es lo siguiente. Si volvemos a nuestro
archivo de cabecera aquí para mi clase, puedes ver que tenemos
esos hashtag pragma una vez. Lo que esto hace
es que se asegure de que nuestro archivo de encabezado solo se
incluya una vez. Y para mostrarte exactamente lo que hace
esto, si volvemos a nuestro archivo principal aquí y copiamos nuestro archivo de
encabezado de inclusión y lo pegamos de
nuevo y ejecutamos nuestro código. Como puedes ver,
funciona bien. Y eso es porque
este hashtag pragma una vez básicamente dice
, cada vez que incluimos
nuestro archivo de encabezado aquí o indicamos que
queremos
incluirlo, se va a comprobar
si ya tiene la declaración para mi clase, que si recuerdas, eso es todo lo que va
en tu archivo de cabecera básicamente es esa
declaración para una clase. Y si lo hace se ignora esta
declaración include. Y si no lo hace,
agregará la declaración. Entonces la primera vez
a través y agregada son mi declaración de clase y la
segunda vez la ignoró. Sin embargo, no todos los
compiladores apoyan este pragma una vez directiva
aquí en la parte superior. Y no voy a meterme en lo que son los directores prácticamente cada vez que veas este símbolo de libra
o hashtag aquí, o con este hashtag
o libra incluyen, es un tipo de directiva. Y como dije, no
voy a meterme en ello, pero esencialmente no todos los
compiladores los soportan. Entonces voy a
mostrarte una alternativa, y también voy a
mostrarte lo que
pasaría si no tuviéramos eso. Entonces ahora si intentamos volver a
ejecutar nuestro programa, puedes ver que
vamos a obtener un error. Eso es porque
intentamos redefinir esta clase. Entonces otra forma en que podemos arreglar esto es con lo que se
llama un modismo de guardia. Y todo lo que tenemos que hacer
es en nuestro archivo de encabezado, vamos a decir
hashtag si N def, y luego a continuación eso
dirá hashtag definir. Y luego abajo al final de nuestro archivo de encabezado,
diremos hashtag. Y al final de nuestra f
y f y definimos aquí, vamos a agregar
nuestro nombre de archivo de encabezado siendo mi clase en todas las mayúsculas. Entonces diré mi
subrayado de clase y luego H.
Y esta es una convención de
nomenclatura común cuando se trabaja con un protector de
cabecera y, o una cosa de modismo de guardia. Lo que tenemos aquí o el pragma
una vez que viste antes. Así que todo lo que vas a hacer es tener nombre de
tu archivo de encabezado en mayúsculas. Y luego en lugar de una dieta, vas a
tener un subrayado. Entonces aquí arriba dice
mi clase punto h aquí tenemos mi clase
subrayado edad y todas las gorras. Como dije, esto es sólo una convención de nomenclatura
muy común. Entonces haremos lo
mismo después de encontrar. Entonces repasemos
lo que esto significa. Ahora bien, si tus compiladores soportan el hashtag pragma una vez
que teníamos antes, ¿verdad? Simplemente puedes dejar
eso en la parte superior. Sin embargo, si no lo hace, este es otro protector de encabezado, el formato que puedes usar el
cual debe ser soportado. Entonces repasemos
lo que significa todo esto. Entonces primero tenemos este
hashtag F y F. Eso significa si no está definido,
y ¿qué estamos comprobando? Si no está definido es este archivo de
encabezado aquí mismo, y ese es el nombre que
le estamos dando a nuestro archivo de encabezado aquí. Esencialmente, se puede ver
todo lo que pasó esta directiva aquí como el
cuerpo de nuestra declaración if. Entonces, si mi
archivo de encabezado de clase no está definido, entonces queremos definirlo. Y aquí abajo, tenemos
que terminar nuestra declaración if. Pero en vez de terminarlo
con un corchete cerrado, vamos a decir
hashtag y ¿verdad? Y recuerda a esto
se le llama un
protector de cabecera si quieres
indagarlo más. Y como dije antes, esos van a hacer
exactamente lo
mismo que el pragma una vez. Entonces, si su sitio de
soporte de compilador, Genial. No solo agrega lo siguiente
a tu archivo de encabezado. Libra si N def
seguido de tu nombre de encabezado, entonces dirás hashtag define con el mismo nombre
justo debajo de eso. Y luego al final,
vas a decir hashtag. Y entonces solo recuerda, tu archivo de encabezado incluye
todas tus declaraciones de clase, razón por la
que he
dicho en el pasado, queremos separar nuestras declaraciones de
nuestras definiciones. Y luego en nuestro archivo CPP, tenemos todas nuestras directivas de
inclusión. Y sé que he estado llamando a estas declaraciones a
lo largo del curso, pero técnicamente se
llaman directivas. Así que vas a tener todas
tus directivas de inclusión, cualquier uso de espacios de nombres que
quieras usar, y luego tus definiciones de clase. Entonces en tu archivo principal, necesitas incluir tu archivo de encabezado de clase si
quieres usar esa clase. Y podemos agregar
tantos archivos de encabezado y archivos CPP como necesitemos para
dividir nuestro código aquí. Y recuerda, todo lo que
tuvimos que hacer para hacer eso es hacer clic en el nombre de nuestro programa
justo debajo de la solución aquí, hacer clic derecho, bajar a
Agregar y luego nuevo elemento. Y luego agregamos cada
archivo individualmente. Y ahora, a pesar de que tenemos dos declaraciones de
nuestro archivo de encabezado, al
igual que cuando teníamos nuestra directiva
pragma una vez, nuestro nuevo protector de cabecera que
acabamos de crear funcionará. Entonces, si lo ejecutamos, se puede ver
que esto funciona bien. Ahora en un programa que es pequeño, es probable que no
estés agregando
accidentalmente tu archivo de encabezado dos veces o
tratando de redefinir la clase
dos veces así. Pero cuando empiezas a trabajar
con programas mucho más grandes, definitivamente
pueden
convertirse en un problema. Así que quieres
asegurarte de
que puedes evitarlo usando protectores de encabezado, ya sea usando el hashtag pragma una vez si tu
compilador admite conjunto, o simplemente puedes usar
el hashtag if y death hashtag define
y hashtag y F, como hicimos aquí. Entonces ahí tienes. Así
es como puedes dividir tus clases en archivos
individuales. Y entonces esto
también te permitirá usar tus clases en otros programas. Y ojalá esto
conduzca un poco a casa por qué hemos estado separando nuestras
declaraciones de clase de nuestras definiciones de clase, ya
que hace que sea realmente fácil cortarlas y pegarlas en los archivos
separados según sea necesario. Y recuerda que todo lo que nuestro protector de
cabecera hizo fue permitirnos accidentalmente esencialmente redeclare nuestra
clase sin ningún problema. Entonces seguiré adelante
y quitaré esto. Ahora bien, hay algunos
casos
específicos en los que en realidad no
quieres su guardia, pero la mayoría de las veces lo harás. Y si quieres indagarte cuando no quieres
eso, siéntete libre de hacerlo. Pero no voy a estar
metiendo en eso en este curso de todos modos,
eso es todo para este video. Gracias por mirar, y te
veré en la siguiente.
101. ¡Felicidades!: Enhorabuena por
completar este curso. Has dado un gran paso adelante en tu viaje de
programación, y deberías estar muy orgulloso de todo lo que has
logrado aquí. Si disfrutaste el curso o te
pareció útil de alguna manera, lo
agradeceríamos mucho. Si pudieras dejarnos
una reseña positiva. Tus comentarios no solo nos
ayudan a mejorar, sino que también animan
a otros a comenzar su
viaje aquí también. Ahora, intenta pensar en
cuando empezaste por primera vez. La idea de codificar probablemente
cayó abrumadora. Ahora mira hasta dónde has llegado. Has dominado
los fundamentos, explorado
temas avanzados y las habilidades para comenzar a
crear tus propios proyectos Ahora que has
completado este curso, tu siguiente paso es poner en práctica
esas habilidades. Una excelente manera de solidificar lo que has aprendido es
abordar un proyecto pequeño y
manejable, algo que
puedas completar en como
dos Y recomiendo encarecidamente
comenzar por clonar una aplicación simple existente con
fines no comerciales, claro. Y al crear algo
que ya existe, puedes enfocarte en aprender
cómo funciona cada función y cómo implementarlas tú mismo en lugar de
diseñarla desde cero. Y luego, una vez
hecho eso, intenta agregar tu propio giro único o expandir el concepto
como un segundo proyecto. Es una manera fantástica de
practicar y flexionar tu creatividad mientras construyes confianza
en tus habilidades. Y luego a partir de ahí,
puedes comenzar a
ramificarte hacia
proyectos más grandes, mejores y más únicos propios Y recuerda, está
perfectamente bien volver
y volver a visitar el material del curso trabajas en
tus propios proyectos La programación se trata de
aprender a medida que avanzas. Incluso los desarrolladores de temporada buscan
constantemente las cosas, ya sea refrescando
su memoria o resolviendo un nuevo problema. Usar recursos como este curso o Internet
no es una debilidad. Es parte de ser
un gran programador. Ahora bien, esto es solo el comienzo. Ya sea que estuvieras trabajando
en tu primer proyecto, regresando para refrescar
tus conocimientos o sumergirte en
otro de nuestros cursos, el conocimiento que hayas
adquirido aquí será tu escalón para lograr logros
aún mayores. Hablando de eso,
asegúrate de revisar nuestro otro contenido para más oportunidades de
aprendizaje. Y si aún no lo has hecho
, considera dejar nuestra vista para compartir tu experiencia. Realmente
hace la diferencia, y nos encantaría saber de usted. De parte de todos nosotros aquí
en Primoris Arts, felicitaciones de nuevo por
este increíble hito No podemos esperar a ver
lo que creas a continuación, seguir aprendiendo, mantente curioso y recuerda que el
cielo es el límite. Bien hecho, y mucha suerte
en tu próxima aventura.