﻿1
00:00:04,410 --> 00:00:05,340
‫Hola y bienvenido.

2
00:00:05,340 --> 00:00:10,290
‫En esta lección, vamos a aprender sobre un fenómeno extraño llamado parámetro externo.

3
00:00:10,290 --> 00:00:17,400
‫Este es un parámetro que en lugar de pasar el valor en C++, tendemos a pasar el valor fuera de una

4
00:00:17,400 --> 00:00:18,000
‫función.

5
00:00:18,450 --> 00:00:23,340
‫Y también vamos a ver algo llamado referencia constante y cómo estos dos

6
00:00:23,340 --> 00:00:25,380
‫conceptos se entrelazan entre sí.

7
00:00:25,740 --> 00:00:27,720
‫Vamos a sumergirnos y resolver esto.

8
00:00:28,880 --> 00:00:29,150
‫Ahora.

9
00:00:29,150 --> 00:00:36,890
‫El lugar real donde las referencias brillan es en los parámetros de las funciones, porque cada vez que

10
00:00:36,890 --> 00:00:45,740
‫creamos un tiempo delta flotante como este en nuestro componente, lo que estamos haciendo es tomar una copia de ese

11
00:00:45,740 --> 00:00:49,520
‫flotador original y lo estamos pasando al función.

12
00:00:49,520 --> 00:00:55,760
‫Entonces, en lugar de hacer eso, lo que podríamos querer hacer es tomar una referencia y pasar eso en su lugar.

13
00:00:56,240 --> 00:01:02,660
‫Así que imaginemos que tuviéramos que crear una función para agarrarla, cada una llamada daño de impresión.

14
00:01:03,140 --> 00:01:09,200
‫Y como argumento para esta función, queremos pasar un daño flotante.

15
00:01:09,470 --> 00:01:14,720
‫Ahora, esto, como dije, va a hacer una copia de lo que sea que le pasemos y lo copiará en esa variable.

16
00:01:14,720 --> 00:01:18,740
‫Cree esta variable de parámetro dentro de la función de daño de impresión.

17
00:01:19,930 --> 00:01:24,370
‫Y necesitamos tener un valor de retorno de vacío aquí también para completarlo y un punto y coma al final.

18
00:01:24,730 --> 00:01:28,590
‫Vayamos a C++ y continuemos esta conversación.

19
00:01:28,600 --> 00:01:30,790
‫Vamos a crear el daño de impresión aquí.

20
00:01:31,390 --> 00:01:39,250
‫Ponga el que toma una clase delante de él y pongamos algunas llaves en lugar del punto y coma.

21
00:01:39,820 --> 00:01:48,280
‫Así que tenemos una copia en la variable del parámetro de daño y es seguro porque si tuviera que hacer daño

22
00:01:48,280 --> 00:01:53,950
‫igual a cinco, solo estoy cambiando esta variable aquí dentro de daño de impresión.

23
00:01:53,950 --> 00:01:55,390
‫Tengo una copia propia.

24
00:01:55,630 --> 00:01:57,910
‫No puedo estropearlo por accidente.

25
00:01:58,180 --> 00:02:01,400
‫Ahora, ¿y si no quisiera hacer una copia?

26
00:02:01,420 --> 00:02:04,330
‫Mi alternativa sería tomar una referencia.

27
00:02:04,630 --> 00:02:10,780
‫Entonces, lo que puedo hacer aquí es poner una referencia flotante que entra en daño de impresión,

28
00:02:10,780 --> 00:02:14,260
‫y también necesito actualizar eso en el archivo C++.

29
00:02:14,740 --> 00:02:20,230
‫Y luego podría tener este mensaje de registro de que estamos usando la referencia para ir y eliminar esto

30
00:02:20,470 --> 00:02:22,540
‫y ponerlo en daño de impresión.

31
00:02:22,750 --> 00:02:29,200
‫Así que ahora tomamos nuestro daño e imprimimos las actualizaciones de los puntos de venta, las declaraciones de registro dicen que el daño es este caso

32
00:02:29,470 --> 00:02:30,940
‫de daño, es este daño.

33
00:02:31,300 --> 00:02:40,060
‫Y en nuestro componente tick, lo que podemos hacer es imprimir daño y pasar la variable de daño y poner un punto y

34
00:02:40,060 --> 00:02:41,230
‫coma al final.

35
00:02:41,590 --> 00:02:48,670
‫Y podemos deshacernos de nuestra referencia de daño por ahora, porque lo que tenemos ahora es un flotador dañado

36
00:02:48,670 --> 00:02:51,010
‫que se crea en tecnología.

37
00:02:51,010 --> 00:03:00,100
‫La memoria para esto se ha creado aquí en tomar y luego vamos y se la damos a esta función de daño de impresión.

38
00:03:00,100 --> 00:03:06,640
‫Pero debido a que el parámetro es una referencia, en realidad no estamos copiando este daño.

39
00:03:06,640 --> 00:03:13,300
‫Estamos tomando su dirección y almacenándola en la referencia, de modo que cuando usemos esta referencia más

40
00:03:13,300 --> 00:03:18,130
‫adelante, en realidad estemos accediendo a la pieza de memoria original.

41
00:03:18,130 --> 00:03:21,930
‫Así que no ha tenido que ocurrir ninguna copia para que esto imprima el daño.

42
00:03:21,940 --> 00:03:25,240
‫Ahora solo verifiquemos que esto realmente esté haciendo lo que esperaríamos que hiciera.

43
00:03:25,240 --> 00:03:34,000
‫Si cambio el valor de daño a cinco, por ejemplo, y luego vuelvo a compilar y presiono reproducir, luego voy y miro el registro

44
00:03:34,000 --> 00:03:38,410
‫de salida y la impresión de que el daño es cinco.

45
00:03:38,560 --> 00:03:42,880
‫Pero como tenemos una referencia, sabemos que podemos actualizar ese valor.

46
00:03:42,880 --> 00:03:48,880
‫Entonces, lo que puedo hacer es decir dentro de esta función que podría hacer, oye, el daño debería ser igual a

47
00:03:48,940 --> 00:03:49,750
‫dos así.

48
00:03:50,320 --> 00:03:55,300
‫Y si no tuviera cuidado, si pensara que tengo mi propia copia, podría pensar que está bien.

49
00:03:55,630 --> 00:04:01,540
‫Pero en realidad en el componente de marca, lo que hemos hecho es que hemos cambiado las variables A originales.

50
00:04:01,560 --> 00:04:09,580
‫Si pongo un pequeño registro aquí para inspeccionar esa variable de daño original y ponemos un porcentaje F y pasamos el

51
00:04:09,580 --> 00:04:15,670
‫daño aquí, vamos a codificar en vivo y compilar eso y vamos a presionar reproducir.

52
00:04:15,910 --> 00:04:21,850
‫Eche un vistazo a nuestro registro de salida y podrá ver que ahora tanto el daño como el daño original

53
00:04:21,850 --> 00:04:22,960
‫se han modificado.

54
00:04:22,960 --> 00:04:27,400
‫Ambos han sido cambiados al número dos, lo cual no es genial.

55
00:04:27,430 --> 00:04:33,100
‫Sabes, accidentalmente podrías hacer mucho daño, si me disculpas el juego de palabras, al cambiar

56
00:04:33,100 --> 00:04:35,500
‫variables que no esperabas cambiar.

57
00:04:36,010 --> 00:04:41,170
‫Y aquí viene otro uso de esa palabra clave const que hemos visto en el pasado.

58
00:04:41,620 --> 00:04:49,570
‫Si coloco const delante de mi referencia flotante, entonces lo que estoy diciendo aquí es que esta debería ser

59
00:04:49,570 --> 00:04:52,510
‫una referencia que no se puede cambiar.

60
00:04:52,510 --> 00:04:56,290
‫No puede llamar a ninguna función sin contacto en él, no puede configurarlo.

61
00:04:56,500 --> 00:05:00,370
‫De ninguna manera puede cambiar el contenido de esta variable.

62
00:05:00,370 --> 00:05:04,360
‫Solo puedes usarlo, solo puedes leerlo, solo puedes ver lo que hay allí.

63
00:05:04,450 --> 00:05:10,540
‫Entonces, si volvemos a tomar una copia, debemos asegurarnos de que también colocamos Const aquí en los

64
00:05:10,540 --> 00:05:17,170
‫parámetros y podemos continuar y compilar y verá que tenemos una falla de compilación y el error dice que

65
00:05:17,170 --> 00:05:21,850
‫el daño no puede ser se le asigna porque es una variable constante.

66
00:05:22,270 --> 00:05:25,000
‫Eso nos da la protección que necesitamos.

67
00:05:25,390 --> 00:05:32,890
‫Entonces, en general, si estamos tratando de pasar una variable, de una manera eficiente donde no queremos tomar

68
00:05:32,890 --> 00:05:38,770
‫una copia, siempre, siempre usaremos la palabra clave de contacto además de usar

69
00:05:39,010 --> 00:05:43,630
‫una referencia porque esto nos impide cambiando accidentalmente ese contenido.

70
00:05:44,290 --> 00:05:50,350
‫Ahora, sin embargo, a veces quieres usarlo para cambiar ese valor.

71
00:05:50,680 --> 00:05:58,750
‫Y lo que podríamos tener como ejemplo, podríamos tener un valor de retorno booleano y podríamos querer decir que tiene

72
00:05:58,750 --> 00:06:06,580
‫daño, pero también podríamos, como lo hicimos en Blueprint en el pasado, querer tener un segundo valor de retorno.

73
00:06:06,580 --> 00:06:10,640
‫Así que podríamos decir, ¿tenemos algún daño y cuál es ese daño?

74
00:06:10,780 --> 00:06:19,060
‫Bueno, en este caso, tiene sentido usar una referencia simple sin contacto, una referencia flotante.

75
00:06:19,530 --> 00:06:26,580
‫El daño, y normalmente lo llamaríamos daño solo para que sea realmente visible que esto es lo que se

76
00:06:26,580 --> 00:06:29,280
‫conoce como un parámetro de salida.

77
00:06:29,310 --> 00:06:31,110
‫No es un parámetro para pasar cosas.

78
00:06:31,140 --> 00:06:33,360
‫Es un parámetro para pasar cosas.

79
00:06:33,630 --> 00:06:38,190
‫Ahora, puede ser una peculiaridad un poco rara de C++ y puede ser difícil de detectar.

80
00:06:38,490 --> 00:06:44,250
‫Pero, en términos generales, si ve algún parámetro que sea una referencia pero que no esté

81
00:06:44,520 --> 00:06:50,700
‫marcado como contacto, entonces puede suponer que alguien tuvo la intención de usarlo como un parámetro de salida.

82
00:06:51,090 --> 00:06:52,530
‫Así que eso es lo que tenemos aquí.

83
00:06:52,530 --> 00:06:53,750
‫Tenemos daños.

84
00:06:53,760 --> 00:07:01,380
‫Y si tuviéramos que ir e implementar esto en el CPP, entonces podemos poner la clase "usted toma una clase"

85
00:07:01,380 --> 00:07:05,700
‫al frente aquí y podemos poner nuestros paréntesis de llaves aquí.

86
00:07:06,120 --> 00:07:10,620
‫Vamos a comentar el daño de impresión de impresión de línea donde no está contento porque estamos tratando

87
00:07:10,620 --> 00:07:12,170
‫de establecer una referencia de contacto.

88
00:07:12,780 --> 00:07:19,680
‫Y esencialmente lo que podríamos hacer aquí es algo de código, podríamos ver si tenemos algún daño

89
00:07:19,680 --> 00:07:22,170
‫y luego imprimiríamos, sí, está bien.

90
00:07:22,200 --> 00:07:25,430
‫El daño de salida es igual a cinco.

91
00:07:25,440 --> 00:07:29,610
‫Así que ese es el daño que se ha hecho y podemos regresar.

92
00:07:29,760 --> 00:07:36,480
‫Cierto, porque tenemos algunos daños que se han hecho y esto ahora podemos usarlo en algún lugar

93
00:07:36,510 --> 00:07:39,870
‫como los componentes TEC para controlar el daño.

94
00:07:40,470 --> 00:07:46,020
‫Así que aquí, en lugar de establecer el daño cinco, podemos obtener el daño e

95
00:07:46,020 --> 00:07:53,790
‫imprimirlo si hay algún daño para que podamos decir algo similar si tiene daño y luego pasamos la variable que queremos

96
00:07:53,790 --> 00:07:56,490
‫que se complete con el daño. .

97
00:07:56,760 --> 00:08:04,980
‫Entonces, daño, por ejemplo, y luego podemos tener el cuerpo de nuestra declaración y solo podemos llamar daño de impresión,

98
00:08:04,980 --> 00:08:11,700
‫por ejemplo, si hay algún daño para mostrar y podemos eliminarlo, lo registra por completo.

99
00:08:12,150 --> 00:08:19,320
‫Entonces, esta es la forma en que usamos referencias sin contacto como parámetros de salida, una forma de obtener múltiples valores

100
00:08:19,320 --> 00:08:21,240
‫de retorno de una función.

101
00:08:21,540 --> 00:08:27,450
‫Y típicamente cuando hacemos esto, cuando llamamos a esta función, crearemos la variable, pero no

102
00:08:27,450 --> 00:08:29,640
‫le daremos un valor inicial.

103
00:08:29,940 --> 00:08:34,260
‫Entonces, en la línea 39, básicamente tengo definido un daño flotante.

104
00:08:34,560 --> 00:08:36,990
‫Lo paso de inmediato en la siguiente línea.

105
00:08:36,990 --> 00:08:41,590
‫Y esta es otra señal reveladora de que está utilizando un parámetro de salida.

106
00:08:42,120 --> 00:08:48,390
‫No he dado ningún valor justo antes de pasarlo a una función, lo que significa que espero

107
00:08:48,390 --> 00:08:51,390
‫que esa función introduzca el valor por mí.

108
00:08:51,690 --> 00:08:55,350
‫Así que esto puede ser difícil de detectar al principio y puede ser un poco confuso.

109
00:08:55,560 --> 00:08:58,200
‫Pero estas son las dos reglas que me gustaría que recordaras.

110
00:08:58,200 --> 00:09:04,290
‫Si ve una variable declarada y no se le da un valor y se pasa instantáneamente a una función, pregúntese si ese

111
00:09:04,380 --> 00:09:05,880
‫es un parámetro de salida.

112
00:09:05,880 --> 00:09:12,390
‫Y la otra regla es que si ve una referencia como un parámetro, pero no está contenido, eso también podría ser una

113
00:09:12,390 --> 00:09:15,420
‫pista de que se trata de un parámetro de salida.

114
00:09:15,720 --> 00:09:21,780
‫Y, por supuesto, si la variable o el parámetro se nombra como algo, entonces eso es un claro indicativo de que esta cosa

115
00:09:21,780 --> 00:09:23,940
‫está destinada a ser un parámetro de salida.

116
00:09:24,360 --> 00:09:24,890
‫Buena cosa.

117
00:09:24,900 --> 00:09:28,850
‫Creo que eso nos ha preparado muy bien para poder hacer un barrido.

118
00:09:28,860 --> 00:09:30,750
‫Así que te veré en la próxima conferencia.

