1
00:00:00,960 --> 00:00:02,160
Hola y bienvenido a esta elección.

2
00:00:02,310 --> 00:00:06,500
A continuación vamos a ver cómo mandar a imprimir la dirección de memoria de una variable.

3
00:00:06,570 --> 00:00:07,350
Están listos?

4
00:00:07,440 --> 00:00:07,920
Vamos.

5
00:00:08,950 --> 00:00:09,370
Bien.

6
00:00:09,370 --> 00:00:13,780
Según hemos comentado, una variable también tiene una dirección de memoria asociada.

7
00:00:14,050 --> 00:00:18,850
Así que vamos a ver cómo mandar a imprimir esta dirección de memoria asociada a esta variable.

8
00:00:19,060 --> 00:00:24,610
Por ejemplo, si tenemos una variable llamada mi número y le hemos asignado el valor de diez en memoria,

9
00:00:24,610 --> 00:00:29,710
se crea lo siguiente Se reserva espacio de memoria en alguna de las celdas de nuestra memoria RAM.

10
00:00:29,950 --> 00:00:34,960
Recordemos que esta parte de la memoria donde se crean las variables se conoce como memoria stack.

11
00:00:35,500 --> 00:00:40,210
Así que en alguna parte de nuestra memoria se reserva espacio de memoria para esta variable.

12
00:00:40,480 --> 00:00:46,060
Por ejemplo, en este caso en la dirección de memoria 0X333, que es un valor hexadecimal, es donde

13
00:00:46,060 --> 00:00:49,030
de manera aleatoria se almacena el valor de esta variable.

14
00:00:49,030 --> 00:00:50,740
Mi número el valor de diez.

15
00:00:51,010 --> 00:00:56,050
Sin embargo, si tenemos n cantidad de memoria en nuestra memoria RAM, tanta como tengamos instalada

16
00:00:56,050 --> 00:00:57,160
en nuestro dispositivo.

17
00:00:57,400 --> 00:01:02,920
Ahora, para poder obtener esta dirección de memoria y poder mandarla a imprimir para que sepamos cuál

18
00:01:02,920 --> 00:01:07,540
fue la dirección de memoria asignada a esta variable, en lugar de utilizar simplemente nuestra variable,

19
00:01:07,810 --> 00:01:09,970
tenemos que agregar al principio un ampersand.

20
00:01:10,450 --> 00:01:14,800
Vamos a realizar un ejercicio para poner en práctica esto, pero básicamente con el ampersand.

21
00:01:14,980 --> 00:01:20,650
Al inicio de nuestra variable le estamos indicando al lenguaje que en lugar de recuperar este valor

22
00:01:20,650 --> 00:01:26,200
de texto, al indicar el ampersand antes de nuestra variable, le estamos indicando que queremos recuperar

23
00:01:26,200 --> 00:01:31,570
el valor de la dirección de memoria, el cual es un valor hexadecimal, ya que normalmente así es como

24
00:01:31,570 --> 00:01:34,750
se manejan las direcciones de memoria en la memoria RAM.

25
00:01:35,200 --> 00:01:39,640
Ahora, si queremos mandar a imprimir, por ejemplo esta dirección de memoria, entonces tenemos que

26
00:01:39,640 --> 00:01:45,580
hacer lo siguiente Vamos a mandar a imprimir nuestra dirección de memoria utilizando el ampersand,

27
00:01:45,580 --> 00:01:47,200
según hemos comentado en nuestra variable.

28
00:01:47,380 --> 00:01:51,970
Pero además también tenemos algo nuevo el especificado de formato porcentaje P.

29
00:01:52,330 --> 00:01:58,720
Esta p significa painter o apuntador, así que básicamente lo que significa es que estamos apuntando

30
00:01:58,720 --> 00:02:00,430
a esta dirección de memoria.

31
00:02:00,610 --> 00:02:07,630
Por lo tanto, esta variable apunta a la dirección de memoria 0X333 y su valor es el valor de diez.

32
00:02:07,690 --> 00:02:12,760
Pero si queremos mandar a imprimir la dirección de memoria, entonces en lugar de porcentaje indicamos

33
00:02:12,760 --> 00:02:18,550
porcentaje P Para recuperar precisamente la dirección de memoria a la cual está apuntando esta variable.

34
00:02:18,760 --> 00:02:22,420
Por ello, ese es el concepto básico del manejo de apuntadores en el lenguaje.

35
00:02:22,430 --> 00:02:27,010
C Simplemente es recuperar la dirección de memoria a la cual está apuntando cierta variable.

36
00:02:28,340 --> 00:02:33,740
Y entonces, en resumen, tenemos lo siguiente Al momento de utilizar ampersand antes de nuestra variable

37
00:02:33,740 --> 00:02:40,010
como prefijo, estamos recuperando la dirección de memoria y por lo tanto se mandaría a imprimir 0X33A

38
00:02:40,010 --> 00:02:40,670
la consola.

39
00:02:41,120 --> 00:02:44,000
Y por otro lado, el especificado de formato porcentaje P.

40
00:02:45,050 --> 00:02:49,820
Básicamente, como hemos comentado, es el especificado de formato para mandar a imprimir la dirección

41
00:02:49,820 --> 00:02:53,690
de memoria o también lo que se conoce como apuntador en el lenguaje c.

42
00:02:54,170 --> 00:03:00,740
De ahí el concepto de P, ya que es pointer en inglés o apuntador en español es el concepto básico de

43
00:03:00,740 --> 00:03:01,670
manejo de memoria.

44
00:03:01,850 --> 00:03:06,980
Vamos a crear a continuación nuestro ejercicio precisamente para manejar este concepto y obtener la

45
00:03:06,980 --> 00:03:07,850
dirección de memoria.

46
00:03:07,850 --> 00:03:08,960
Según hemos comentado.

47
00:03:11,290 --> 00:03:16,420
Así que vamos a obtener la dirección de memoria en C o también el concepto básico de apuntadores.

48
00:03:17,740 --> 00:03:20,560
De momento no vamos a utilizar esta librería STD TDT.

49
00:03:20,950 --> 00:03:21,880
Podemos quitarlo.

50
00:03:22,120 --> 00:03:24,370
Y también vamos a quitar todos este código.

51
00:03:24,880 --> 00:03:26,110
Ya no vamos a utilizarlo.

52
00:03:26,740 --> 00:03:28,180
Vamos a hacer un código más simple.

53
00:03:28,870 --> 00:03:32,740
En este momento, solamente vamos a declarar una variable.

54
00:03:35,240 --> 00:03:37,460
Declaramos nuestra variable llamada mi número.

55
00:03:37,730 --> 00:03:40,130
Le asignamos cualquier valor, por ejemplo, el valor de diez.

56
00:03:40,580 --> 00:03:45,530
Y básicamente con esto en memoria se está creando esta variable y además está reservando espacio de

57
00:03:45,530 --> 00:03:47,360
memoria, según hemos comentado.

58
00:03:47,750 --> 00:03:52,310
Ahora vamos a hacer dos cosas vamos a mandar a imprimir en primer lugar el valor de esta variable,

59
00:03:52,310 --> 00:03:56,480
como ya sabemos, imprimir el valor de la variable.

60
00:03:56,840 --> 00:03:58,550
Esto ya no debe de tener ningún problema.

61
00:03:58,910 --> 00:04:05,540
Utilizamos el especificados de formato porcentaje D y utilizamos nuestra variable la variable mi número.

62
00:04:05,810 --> 00:04:07,820
Si ejecutamos hasta aquí no hay nada nuevo.

63
00:04:08,630 --> 00:04:12,020
Solamente se imprime el valor de nuestra variable, el valor de diez.

64
00:04:12,500 --> 00:04:15,050
Pero ahora vamos a mandar a imprimir la dirección de memoria.

65
00:04:15,740 --> 00:04:16,520
Imprimimos.

66
00:04:20,160 --> 00:04:23,370
La dirección donde está almacenada, no nuestra variable de mi número.

67
00:04:23,640 --> 00:04:26,910
Por lo tanto, vamos a ver dónde está apuntando esta variable en memoria.

68
00:04:27,180 --> 00:04:29,910
Para ello volvemos a utilizar nuestro formato printf.

69
00:04:30,870 --> 00:04:37,620
Utilizamos una cadena, un salto de línea y ahora vamos a mandar a imprimir la dirección de memoria

70
00:04:38,430 --> 00:04:40,410
a la cual está apuntando nuestra variable.

71
00:04:40,650 --> 00:04:47,370
Utilizamos el especificados de formato porcentaje P para saber a dónde apunta esta variable y posteriormente

72
00:04:47,370 --> 00:04:53,070
indicamos ampersand antes de nuestra variable para recuperar precisamente la dirección de memoria a

73
00:04:53,070 --> 00:04:59,220
la cual está apuntando esta variable, vamos a ejecutar y podemos observar que la variable que contiene

74
00:04:59,250 --> 00:05:05,010
el valor de diez está apuntando a la dirección de memoria cero cero 61 ff uno C.

75
00:05:05,310 --> 00:05:08,310
Esta es una dirección de memoria en código hexadecimal.

76
00:05:08,520 --> 00:05:13,500
Normalmente este va a ser el sistema de numeración que se va a utilizar para el manejo de la memoria,

77
00:05:13,710 --> 00:05:15,150
el código hexadecimal.

78
00:05:15,570 --> 00:05:20,070
Y también lo interesante es que si volvemos a ejecutar nuestro código, esta dirección de memoria,

79
00:05:20,070 --> 00:05:21,450
lo normal es que cambie.

80
00:05:21,630 --> 00:05:26,250
No necesariamente tiene que cambiar, pero lo normal es que cambie, ya que recordemos que la memoria

81
00:05:26,250 --> 00:05:27,790
RAM es una memoria volátil.

82
00:05:27,810 --> 00:05:32,400
Por lo tanto, cada vez que volvemos a ejecutar nuestro programa se pierde toda la información anterior

83
00:05:32,400 --> 00:05:34,710
y se vuelven a crear nuestras variables en memoria.

84
00:05:35,430 --> 00:05:39,390
Así que si volvemos a ejecutar en este caso, la dirección de memoria es la misma.

85
00:05:39,600 --> 00:05:41,450
Pero esto no tiene que ser necesariamente así.

86
00:05:41,460 --> 00:05:46,770
Como hemos comentado, podrían recrearse estas variables en diferentes posiciones de memoria, ya que

87
00:05:46,770 --> 00:05:51,570
esta es la memoria RAM, una memoria volátil, así que no necesariamente se van a volver a utilizar

88
00:05:51,570 --> 00:05:53,190
las mismas direcciones de memoria.

89
00:05:53,970 --> 00:05:56,250
Y ese es el concepto básico de apuntadores.

90
00:05:56,460 --> 00:06:01,200
Así es como vamos a obtener la dirección de memoria donde se encuentra almacenada una variable, y ese

91
00:06:01,200 --> 00:06:02,790
tema también es bastante importante.

92
00:06:03,060 --> 00:06:06,160
Más adelante vamos a ver a más detalle el concepto de apuntadores.

93
00:06:06,180 --> 00:06:11,070
Con esto solamente estamos obteniendo la dirección de memoria a la cual está apuntando una variable

94
00:06:11,280 --> 00:06:13,320
y esto nos va a servir en ejercicios posteriores.

95
00:06:13,320 --> 00:06:18,510
Por ejemplo, para poder almacenar información que proporciona el usuario en una variable.

96
00:06:18,690 --> 00:06:24,180
Así que para ello vamos a tener que especificar la dirección de memoria donde se encuentra una variable

97
00:06:24,180 --> 00:06:28,860
y entonces de esta forma va a ser más sencillo poder almacenar información que proporcione el usuario

98
00:06:28,860 --> 00:06:31,800
de manera dinámica y almacenarlo en alguna variable.

99
00:06:32,070 --> 00:06:34,250
Pero esto lo vamos a ver en ejercicios posteriores.

100
00:06:34,260 --> 00:06:37,810
Pongan en práctica lo que hemos visto y continuamos en la siguiente lección.

101
00:06:37,830 --> 00:06:38,430
Saludos.
