2
00:00:00,000 --> 00:00:02,760
>> ALTAVOZ 1: Vamos a escribir un programa que
solicita al usuario los nombres y

3
00:00:02,760 --> 00:00:04,700
casas de tres estudiantes.

4
00:00:04,700 --> 00:00:08,840
Ahora, para almacenar los nombres y casas
podríamos utilizar, qué, seis variables.

5
00:00:08,840 --> 00:00:12,260
Tres cadenas para los nombres, y otro
tres cadenas para las casas,

6
00:00:12,260 --> 00:00:16,560
pero ya sabemos que podemos limpiar
que el código mediante el uso de matrices lugar,

7
00:00:16,560 --> 00:00:20,220
por ejemplo, una matriz de tamaño 3 para el
tres nombres, y otra serie de

8
00:00:20,220 --> 00:00:22,110
tamaño 3 para las casas.

9
00:00:22,110 --> 00:00:25,870
Pero resulta que podemos limpiar esto
aún más lejos, y en realidad mantener a los

10
00:00:25,870 --> 00:00:30,520
nombres y casas juntas, de modo que una
el nombre del estudiante y de su casa

11
00:00:30,520 --> 00:00:34,940
son de alguna manera encapsulada, por así
hablar, en la misma variable.

12
00:00:34,940 --> 00:00:39,095
>> Para ello, sin embargo, tenemos que declarar
nuestro propio tipo de datos, nuestro propio tipo en C,

13
00:00:39,095 --> 00:00:42,660
que los autores de C no necesariamente
pensar en hace años.

14
00:00:42,660 --> 00:00:45,630
Para ello podemos utilizar la palabra clave
typedef, junto con la

15
00:00:45,630 --> 00:00:47,200
otra estructura de palabras clave.

16
00:00:47,200 --> 00:00:48,160
Vamos a echar un vistazo.

17
00:00:48,160 --> 00:00:50,650
Dentro de structs.h, ya he
hecho más que empezar por

18
00:00:50,650 --> 00:00:52,560
incluyendo la biblioteca CS50.

19
00:00:52,560 --> 00:00:57,640
Estoy al lado va a escribir typedef struct,
y luego una llave.

20
00:00:57,640 --> 00:01:01,370
En el interior de la estructura, que voy a
especificar que un estudiante debe tener un

21
00:01:01,370 --> 00:01:04,960
cadena llamado nombre, y otra
string llamado casa.

22
00:01:04,960 --> 00:01:08,430
Voy a continuación, cierre mis llaves,
y especificar que el nombre de

23
00:01:08,430 --> 00:01:11,420
este nuevo tipo de datos debe ser estudiante.

24
00:01:11,420 --> 00:01:15,550
En otras palabras, a través de esta sintaxis he
declarado un nuevo tipo de datos de mi propia

25
00:01:15,550 --> 00:01:19,910
que no existían hace un momento, y
dentro de este tipo de datos son dos datos

26
00:01:19,910 --> 00:01:24,270
campos o miembros de datos, uno llamado nombre,
uno llamado casa, ambos de los cuales

27
00:01:24,270 --> 00:01:25,630
son de tipo cadena.

28
00:01:25,630 --> 00:01:27,690
>> Ahora vamos a utilizar este tipo
en un programa real.

29
00:01:27,690 --> 00:01:30,210

30
00:01:30,210 --> 00:01:34,090
En structs0.c, me he metido de manera similar
yo ya comenzó con algunos

31
00:01:34,090 --> 00:01:36,999
código repetitivo, y estoy ahora
vamos a utilizar estos datos

32
00:01:36,999 --> 00:01:39,100
escriba estudiante, de la siguiente manera.

33
00:01:39,100 --> 00:01:42,450
Estoy primero va a declarar una
matriz de tipo estudiante, voy a

34
00:01:42,450 --> 00:01:43,920
llamar a los estudiantes de la matriz -

35
00:01:43,920 --> 00:01:44,630
plural -

36
00:01:44,630 --> 00:01:49,360
y voy a especificar que su tamaño será
tres, que, aviso, es el valor de

37
00:01:49,360 --> 00:01:50,880
las constantes ESTUDIANTES -

38
00:01:50,880 --> 00:01:51,890
en todas las capitales -

39
00:01:51,890 --> 00:01:54,930
que yo he declarado aquí,
anteriormente en el archivo.

40
00:01:54,930 --> 00:01:58,280
Ahora vamos a iterar sobre los tres
estudiantes, y solicitar al usuario

41
00:01:58,280 --> 00:02:00,050
sus nombres y casas.

42
00:02:00,050 --> 00:02:05,422
>> para int i obtener 0, i es menor
que la constante, i + +.

43
00:02:05,422 --> 00:02:08,600
Y ahora en el interior del cuerpo de esta para
lazo, voy a imprimir algo

44
00:02:08,600 --> 00:02:11,470
como el nombre del estudiante.

45
00:02:11,470 --> 00:02:14,890
Entonces voy a conseguir realmente que
nombre del estudiante especificando

46
00:02:14,890 --> 00:02:17,290
estudiantes ménsula.

47
00:02:17,290 --> 00:02:21,550
En otras palabras, quiero que el estudiante i-ésimo
en la matriz denominada estudiantes, pero ahora

48
00:02:21,550 --> 00:02:25,340
Quiero llegar a ese número i estudiantil
nombre, y para hacer esto, voy a utilizar

49
00:02:25,340 --> 00:02:30,160
el. operador, con el fin de llegar a un
dentro del campo específico de la estructura.

50
00:02:30,160 --> 00:02:37,100
Así que yo indique estudiantes ménsula. Nombre
obtiene el valor de retorno de GetString ().

51
00:02:37,100 --> 00:02:40,310
Mientras tanto, voy a imprimir
algo similar, diciendo que los estudiantes de

52
00:02:40,310 --> 00:02:45,410
casa, y ahora me voy a especificar
que el campo de los estudiantes la casa número i

53
00:02:45,410 --> 00:02:49,480
deberá obtener el valor de retorno de
otra llamada a GetString ().

54
00:02:49,480 --> 00:02:52,350
>> Ahora vamos a hacer algo con estos tres
nombres y las casas de los estudiantes,

55
00:02:52,350 --> 00:02:56,230
algo tan simple como la impresión
cada uno en una frase.

56
00:02:56,230 --> 00:03:07,580
para int i get 0, de nuevo i es menor que
estudiantes, i + +, printf "% s está en% s.

57
00:03:07,580 --> 00:03:12,600
barra invertida n ", y ahora déjame enchufo
los valores de esos dos campos,

58
00:03:12,600 --> 00:03:19,055
estudiantes ménsula. nombre, coma,
estudiantes ménsula. casa, cerca

59
00:03:19,055 --> 00:03:21,290
paren, punto y coma.

60
00:03:21,290 --> 00:03:23,020
>> Y ahora tengo que hacer una cosa más.

61
00:03:23,020 --> 00:03:26,600
En el fondo de este archivo, necesito
liberar la memoria que se asignó

62
00:03:26,600 --> 00:03:30,290
detrás de las escenas de GetSring (), que
pide, por supuesto, malloc, con el fin de

63
00:03:30,290 --> 00:03:32,500
asignar memoria para las cadenas
los tipos de usuarios.

64
00:03:32,500 --> 00:03:35,720
Pero esto es simple.

65
00:03:35,720 --> 00:03:42,610
para int i obtener 0, i es menor que
estudiantes, i + +, y el interior del cuerpo de

66
00:03:42,610 --> 00:03:48,670
este bucle, estoy simplemente va a
proporcionar a los estudiantes sin soporte de i. nombre,

67
00:03:48,670 --> 00:03:52,300
y los estudiantes libres ménsula. casa.

68
00:03:52,300 --> 00:03:55,620
>> Ahora, hemos utilizado claramente tres bucles for
en este programa, cuando realmente

69
00:03:55,620 --> 00:03:58,800
podría haber utilizado sólo uno, pero esto es
simplemente por el amor de la demostración, por lo que

70
00:03:58,800 --> 00:04:02,850
podemos especificar en tres canales distintos
Pasos qué es exactamente lo que estamos haciendo.

71
00:04:02,850 --> 00:04:06,120
Estamos obteniendo primero un nombre y una casa
para cada uno de los estudiantes, estamos entonces

72
00:04:06,120 --> 00:04:08,900
imprimir el nombre y la casa de
cada uno de los tres estudiantes, y

73
00:04:08,900 --> 00:04:11,910
a continuación, vamos a liberar la memoria
utilizado por cada uno de los estudiantes.

74
00:04:11,910 --> 00:04:15,310
Pero seguro que podríamos haber combinar este
en uno más grande para bucle.

75
00:04:15,310 --> 00:04:18,650
>> Ahora vamos a guardar, compilar,
y ejecutar este programa.

76
00:04:18,650 --> 00:04:26,850
hacer estructuras 0. 0 / estructuras, estudiante de
nombre, vamos a proporcionar David, vivirá

77
00:04:26,850 --> 00:04:31,580
en Mather House, el nombre del estudiante, vamos a
decir Lauren, ella vive en Leverett

78
00:04:31,580 --> 00:04:36,590
Casa, nombre del estudiante, Rob, él
vivir en Kirkland House.

79
00:04:36,590 --> 00:04:39,440
Y, de hecho, David está en Mather,
Lauren está en Leverett,

80
00:04:39,440 --> 00:04:40,810
y Rob se encuentra en Kirkland.

81
00:04:40,810 --> 00:04:43,425