1
00:00:01,220 --> 00:00:02,090
Hola y bienvenidos.

2
00:00:02,240 --> 00:00:07,400
Vamos a ver a continuación cuántos bits utiliza los tipos de datos que hemos estudiado hasta el momento

3
00:00:07,400 --> 00:00:08,140
en el lenguaje C?

4
00:00:08,360 --> 00:00:09,150
Están listos?

5
00:00:09,260 --> 00:00:09,740
Vamos.

6
00:00:10,640 --> 00:00:12,080
Bien, Vamos a limpiar nuestro código.

7
00:00:12,080 --> 00:00:16,280
Solamente vamos a dejar en include de la librería estándar y nuestro método Main.

8
00:00:16,490 --> 00:00:18,200
Todo lo demás vamos a quitarlo.

9
00:00:18,470 --> 00:00:23,090
Recuerden que cada uno de estos ejercicios lo pueden descargar en la sección de recursos de cada lección

10
00:00:23,090 --> 00:00:24,080
que están estudiando.

11
00:00:24,500 --> 00:00:28,160
En esta nueva lección, lo que vamos a estudiar es la función Size of.

12
00:00:28,280 --> 00:00:33,350
Esta función nos va a permitir saber cuántos bytes contiene el tipo de dato que estamos utilizando.

13
00:00:33,620 --> 00:00:38,690
Esto puede ser muy útil, sobre todo cuando queremos optimizar el uso de los recursos, cuando estamos

14
00:00:38,690 --> 00:00:40,610
desarrollando nuestras soluciones en el lenguaje.

15
00:00:40,610 --> 00:00:46,850
C Así que vamos a revisar esta función seis y vamos a ver algunos tipos de datos que hemos trabajado

16
00:00:46,850 --> 00:00:47,630
hasta el momento.

17
00:00:47,900 --> 00:00:53,720
Vamos a definir algunas variables, por ejemplo, una variable de tipo entero y posteriormente con ayuda

18
00:00:53,720 --> 00:00:58,970
de la función seis, vamos a mandar a imprimir cuantos bytes utiliza este tipo de dato.

19
00:00:59,300 --> 00:01:04,550
En este caso no vamos a asignar ningún valor, ya que solamente queremos saber cuántos bytes utiliza

20
00:01:04,550 --> 00:01:05,540
este tipo de dato.

21
00:01:05,970 --> 00:01:13,400
Bien, posteriormente definimos una variable llamada flotante de tipo float, otra variable llamada

22
00:01:13,400 --> 00:01:19,550
doble de tipo double otra variable de tipo char llamada carácter.

23
00:01:20,390 --> 00:01:23,810
Otra variable que va a ser un arreglo llamada cadena.

24
00:01:24,140 --> 00:01:27,530
Pero esto va a ser una cadena con la cadena de hola mundo.

25
00:01:29,120 --> 00:01:35,990
Y finalmente el tipo bool va a ser una variable llamada lógico y le asignamos, por ejemplo, el valor

26
00:01:35,990 --> 00:01:36,470
de false.

27
00:01:36,830 --> 00:01:42,830
Para poder utilizar este tipo de dato, recordemos que tenemos que agregar la directiva include y posteriormente

28
00:01:42,830 --> 00:01:49,940
importar nuestra librería entre paréntesis std bool punto h, ya que es la extensión de las librerías

29
00:01:49,940 --> 00:01:55,040
en el lenguaje C Bien, hasta aquí únicamente hemos definido nuestras variables con ciertos tipos de

30
00:01:55,040 --> 00:01:55,430
dato.

31
00:01:55,820 --> 00:02:01,130
Ahora, para mandar a imprimir la cantidad de bytes que tiene una variable, vamos a utilizar una específica

32
00:02:01,280 --> 00:02:03,830
de formato que no hemos trabajado hasta el momento.

33
00:02:04,160 --> 00:02:08,300
Resulta que la función size regresa un valor de tipo entero.

34
00:02:08,600 --> 00:02:15,200
Sin embargo, este valor de tipo entero es un valor entero positivo, pero además de tipo long.

35
00:02:15,680 --> 00:02:20,540
Así que un tipo entero, un tipo int, puede almacenar cierta cantidad de dígitos.

36
00:02:20,570 --> 00:02:26,690
Pero si necesitamos un número mayor, entonces de manera similar al tipo float y double en el caso también

37
00:02:26,750 --> 00:02:30,380
del tipo entero, también tenemos un tipo más grande que se llama Long.

38
00:02:30,590 --> 00:02:35,390
Así que para almacenar más dígitos de tipo entero, entonces vamos a utilizar el tipo long.

39
00:02:35,600 --> 00:02:40,010
Pero además, como hemos comentado, la función seis of solamente regresa a valores positivos.

40
00:02:40,220 --> 00:02:47,390
A esto en inglés se le conoce como un sign, es decir, que no maneja valores positivos y negativos,

41
00:02:47,390 --> 00:02:53,060
sino únicamente valores positivos, es decir, que no se agrega un signo, por lo tanto no maneja positivos

42
00:02:53,060 --> 00:02:56,060
o negativos, solamente maneja valores positivos.

43
00:02:56,300 --> 00:03:02,000
En el caso, por ejemplo de los tipos enteros, cuando manejamos por default el tipo entero de manera

44
00:03:02,000 --> 00:03:06,020
normal, este tipo de dato maneja valores tanto positivos y negativos.

45
00:03:07,040 --> 00:03:14,210
A esto se le conoce como valores de tipo sign, es decir, valores positivos y negativos.

46
00:03:14,510 --> 00:03:20,930
Y entonces la abreviatura para este tipo de datos de tipo un sign que no maneja un signo se conoce como

47
00:03:20,930 --> 00:03:26,510
un L, es decir, un sign long, y esto es el específico de formato que vamos a utilizar para mandar

48
00:03:26,510 --> 00:03:27,200
a imprimir.

49
00:03:27,200 --> 00:03:33,920
La cantidad de bytes que tiene un tipo de dato va a ser el especificados de formato porcentaje u l,

50
00:03:34,310 --> 00:03:40,580
es decir, unsigned long, tal como lo hemos especificado, ya que la función de seis solamente regresa

51
00:03:40,580 --> 00:03:46,220
valores positivos que pueden ser números mayores a un tipo entero y además sin considerar el signo,

52
00:03:46,220 --> 00:03:48,880
ya que únicamente son valores positivos como hemos comentado.

53
00:03:49,190 --> 00:03:49,610
Bien.

54
00:03:49,640 --> 00:03:54,290
Así que como siguiente paso vamos a imprimir el tamaño.

55
00:03:56,380 --> 00:04:03,210
En bytes de cada tipo de dato, de cada tipo de dato, de cada variable que hemos especificado Bien.

56
00:04:03,220 --> 00:04:04,600
Para ello hacemos lo siguiente.

57
00:04:06,430 --> 00:04:09,950
En primer lugar mandamos a imprimir el tipo int.

58
00:04:10,660 --> 00:04:12,010
Cuál es su tamaño en bytes?

59
00:04:12,340 --> 00:04:14,430
Y agregamos el especificado de formato L.

60
00:04:14,620 --> 00:04:20,710
Como hemos comentado, utilizamos la función seis off y como información lo que necesita esta función

61
00:04:20,890 --> 00:04:24,790
es la variable de la cual queremos saber la cantidad de bytes que utiliza.

62
00:04:25,000 --> 00:04:28,810
Así que pasamos el argumento de entero a la función de seis of.

63
00:04:29,080 --> 00:04:34,090
Esa es la información que necesita esta función para que regrese la cantidad de bytes, pero ya sabemos

64
00:04:34,090 --> 00:04:35,320
que es un valor positivo.

65
00:04:35,670 --> 00:04:38,200
Bien, y si ejecutamos, entonces nos regresa el valor.

66
00:04:38,380 --> 00:04:44,320
El tamaño en bytes para el tipo entero utiliza cuatro bytes y así podemos continuar con los demás tipos

67
00:04:44,320 --> 00:04:44,920
de datos.

68
00:04:45,640 --> 00:04:50,020
Para el siguiente caso copiamos y pegamos esta línea, pero ahora lo modificamos.

69
00:04:50,020 --> 00:04:55,840
Para el tipo flotante, el tamaño en bytes ya no modificamos nada más y el argumento que vamos a pasar

70
00:04:55,840 --> 00:04:58,270
ahora es la variable de flotante.

71
00:04:59,110 --> 00:05:04,270
Vamos a ejecutar y entonces en este caso para el tipo flotante también utiliza cuatro bytes.

72
00:05:04,570 --> 00:05:10,780
Vamos a agregar un salto de línea al inicio, volvemos a ejecutar y entonces el tamaño para el tipo

73
00:05:10,780 --> 00:05:13,420
flotante en bytes utiliza cuatro bytes.

74
00:05:13,930 --> 00:05:18,100
Sin embargo, ya sabemos que el tipo flotante puede almacenar números mucho más grandes que el tipo

75
00:05:18,100 --> 00:05:23,110
entero debido a que utiliza la notación exponencial, y entonces con esto puede almacenar números mucho

76
00:05:23,110 --> 00:05:23,710
más grandes.

77
00:05:24,370 --> 00:05:26,710
Vamos a ver ahora para el tipo double.

78
00:05:27,760 --> 00:05:32,860
De igual manera agregamos un salto de línea y mandamos a imprimir el tamaño en bytes.

79
00:05:36,540 --> 00:05:38,160
Utilizamos la función size of.

80
00:05:39,580 --> 00:05:41,050
Para la variable doble.

81
00:05:41,290 --> 00:05:45,580
Vamos a mandar a imprimir y entonces para el tipo double utiliza ocho bytes.

82
00:05:45,970 --> 00:05:51,040
Es decir, que utiliza el doble del tipo flotante y por lo tanto, además de la notación científica

83
00:05:51,040 --> 00:05:55,900
que puede utilizar la notación exponencial, entonces puede almacenar valores mucho más grandes en tipo

84
00:05:55,900 --> 00:05:56,530
flotante.

85
00:05:59,340 --> 00:05:59,550
Bien.

86
00:05:59,550 --> 00:06:06,330
Como siguiente dato agregamos un salto de línea y vamos a imprimir la cantidad de bytes que utiliza

87
00:06:06,330 --> 00:06:07,110
el tipo char.

88
00:06:07,530 --> 00:06:11,940
Imprimimos con el especificados de formato L u unsigned.

89
00:06:12,690 --> 00:06:19,230
Utilizamos la función de seis OB y proporcionamos la variable de carácter para saber cuántos bytes utiliza

90
00:06:19,230 --> 00:06:19,950
en memoria.

91
00:06:20,430 --> 00:06:24,810
Esa es la cantidad de bytes que se reservan en memoria para almacenar ese tipo de información.

92
00:06:24,840 --> 00:06:25,650
Un carácter.

93
00:06:25,770 --> 00:06:31,230
Así que por lo tanto, el tipo char en el lenguaje se utiliza solamente un byte en memoria, es decir,

94
00:06:31,230 --> 00:06:31,860
ocho bits.

95
00:06:33,300 --> 00:06:38,490
Bien, como siguiente caso vamos a mandar a imprimir la variable que es nuestra cadena, un arreglo

96
00:06:38,490 --> 00:06:39,270
de caracteres.

97
00:06:40,080 --> 00:06:43,890
Así que la cadena, en este caso el tamaño que utiliza en bytes.

98
00:06:46,760 --> 00:06:48,440
Utilizamos la función size of.

99
00:06:50,980 --> 00:06:56,710
Y mandamos a imprimir cuántos bytes utiliza esta cadena y en este caso el resultado va a depender de

100
00:06:56,710 --> 00:06:59,320
cuantos caracteres esté almacenando nuestra cadena.

101
00:06:59,680 --> 00:07:05,410
En este caso podemos observar la siguiente imagen en la cual tenemos nuestra cadena de Hola mundo.

102
00:07:05,620 --> 00:07:11,170
En este caso la cadena de hola mundo son diez caracteres ya que tenemos los índices desde el inicio

103
00:07:11,170 --> 00:07:16,600
cero hasta el índice nueve, es decir, de 0 a 9 tenemos diez caracteres, pero recordemos que en el

104
00:07:16,600 --> 00:07:22,150
lenguaje tenemos que considerar siempre el carácter de fin de cadena, por lo tanto tenemos que sumar

105
00:07:22,150 --> 00:07:25,540
uno a la cantidad de caracteres que tengan nuestra cadena.

106
00:07:25,750 --> 00:07:31,000
Por lo tanto, en lugar de diez caracteres, podemos observar que nos imprime 11 caracteres y recordemos

107
00:07:31,000 --> 00:07:33,100
que cada caracter utiliza un byte.

108
00:07:33,310 --> 00:07:38,380
Por lo tanto, si tenemos 11 caracteres, al final esta cadena utiliza 11 bytes.

109
00:07:38,920 --> 00:07:44,860
Y así, si modificamos nuestra cadena, por ejemplo Hola mundo y tres espacios, volvemos a ejecutar.

110
00:07:45,070 --> 00:07:50,320
Hemos sumado tres caracteres a esta cadena y entonces en lugar de utilizar 11 caracteres, ahora se

111
00:07:50,320 --> 00:07:56,830
utilizan 14 caracteres respetando siempre el ultimo caracter que es el caracter de fin de cadena o diagonal

112
00:07:56,830 --> 00:07:57,610
inversa cero.

113
00:07:58,570 --> 00:08:00,130
Bien, vamos a quitar estos tres puntos.

114
00:08:00,700 --> 00:08:02,560
Y por último, vamos a mandar a imprimir.

115
00:08:06,500 --> 00:08:07,780
Agregamos un salto de línea.

116
00:08:08,950 --> 00:08:09,910
El tipo lógico.

117
00:08:12,310 --> 00:08:13,450
El tamaño en bytes.

118
00:08:14,290 --> 00:08:16,900
Utilizamos porcentaje, no un signo.

119
00:08:18,270 --> 00:08:23,640
La función seis off y pasamos como argumento como información a esta variable.

120
00:08:24,180 --> 00:08:28,110
La variable de lógico, que es el valor de falso que hemos agregado.

121
00:08:28,350 --> 00:08:33,120
Bien, vamos a mandar a imprimir y podemos llevar en el lenguaje C un tipo de dato lógico.

122
00:08:33,120 --> 00:08:39,630
Solamente utiliza un byte, así que el valor de uno o el valor de cero solamente ocupa un byte o lo

123
00:08:39,630 --> 00:08:40,890
que es lo mismo, ocho bits.

124
00:08:41,340 --> 00:08:44,470
Aquí no tenemos que confundirnos, aunque sea el valor de falso.

125
00:08:44,580 --> 00:08:50,340
Aquí uno imprime el valor de cero, ya que esto estamos imprimiendo la cantidad de bytes que ocupa este

126
00:08:50,340 --> 00:08:50,790
valor.

127
00:08:51,090 --> 00:08:54,300
Estamos imprimiendo la cantidad de bytes que utiliza este tipo de dato.

128
00:08:54,480 --> 00:08:56,220
No tiene nada que ver con este valor.

129
00:08:56,490 --> 00:09:00,570
En este caso, incluso podemos omitir este valor para que no haya confusión.

130
00:09:02,590 --> 00:09:07,690
Solamente estamos definiendo la variable lógica de tipo booleano y podemos saber que el resultado es

131
00:09:07,690 --> 00:09:08,170
el mismo.

132
00:09:08,350 --> 00:09:12,640
El tipo lógico utiliza un byte en memoria, es decir, ocho bits.

133
00:09:13,120 --> 00:09:17,590
En el único caso que tenemos que especificar cuantos caracteres vamos a utilizar es cuando creamos una

134
00:09:17,590 --> 00:09:23,620
cadena o también recordemos que podemos especificar cuántos caracteres va a utilizar nuestra cadena.

135
00:09:23,800 --> 00:09:26,680
Por ejemplo, en este caso podrían ser 20 caracteres.

136
00:09:26,710 --> 00:09:31,510
Volvemos a ejecutar y entonces el tamaño de esta cadena son 20 caracteres.

137
00:09:31,720 --> 00:09:36,340
En este caso, como nosotros hemos especificado la cantidad de caracteres que va a tener nuestra cadena,

138
00:09:36,550 --> 00:09:40,960
entonces se supone que ya estamos considerando el carácter de fin de cadena.

139
00:09:41,080 --> 00:09:43,570
Por lo tanto, aquí ya no se suma ningún otro carácter.

140
00:09:43,570 --> 00:09:47,410
Son 20 caracteres en total, incluyendo el carácter de fin de cadena.

141
00:09:47,710 --> 00:09:53,470
Pero si no especificamos nosotros la cantidad de caracteres, entonces de manera automática en lenguaje

142
00:09:53,470 --> 00:09:57,110
se agrega un carácter más, que es el carácter de fin de cadena.

143
00:09:57,130 --> 00:10:02,860
Al momento de crear esta variable y con esto tenemos ya entonces completo nuestro ejemplo para saber

144
00:10:02,860 --> 00:10:07,600
cuantos bytes utiliza cada uno de los tipos de datos que hemos estudiado hasta el momento, ya que existen

145
00:10:07,600 --> 00:10:12,100
más tipos de datos en el lenguaje C Con eso es suficiente para empezar a desarrollar los ejercicios

146
00:10:12,100 --> 00:10:13,810
que vamos a ver en las siguientes lecciones.

147
00:10:14,020 --> 00:10:17,710
Bien, pongan en práctica lo que hemos visto y continuamos en la siguiente lección.

148
00:10:17,860 --> 00:10:18,430
Saludos.
