2
00:00:00,000 --> 00:00:02,760
>> ಸ್ಪೀಕರ್ 1: ತಂದೆಯ ಪ್ರೋಗ್ರಾಂ ಬರೆಯೋಣ ಎಂದು
ಹೆಸರುಗಳು ಬಳಕೆದಾರ ಮತ್ತು ಅಪೇಕ್ಷಿಸುತ್ತದೆ

3
00:00:02,760 --> 00:00:04,700
ಮೂರು ವಿದ್ಯಾರ್ಥಿಗಳು ಮನೆ.

4
00:00:04,700 --> 00:00:08,840
ಈಗ, ಆ ಹೆಸರುಗಳು ಮತ್ತು ಮನೆ ಶೇಖರಿಸಿಡಲು
ನಾವು, ಏನು, ಆರು ಅಸ್ಥಿರ ಬಳಸಬಹುದಾಗಿತ್ತು.

5
00:00:08,840 --> 00:00:12,260
ಮೂರು ಹೆಸರುಗಳು ತಂತಿಗಳು ಮತ್ತು ಮತ್ತೊಂದು
ಮನೆ ಮೂರು ತಂತಿಗಳು

6
00:00:12,260 --> 00:00:16,560
ಆದರೆ ನಾವು ಈಗಾಗಲೇ ನಾವು ಸ್ವಚ್ಛಗೊಳಿಸಲು ತಿಳಿದಿದೆ
ಬದಲಿಗೆ ಸಾಲುಗಳು ಬಳಸಿಕೊಂಡು ಕೋಡ್,

7
00:00:16,560 --> 00:00:20,220
ಉದಾಹರಣೆಗೆ ಗಾತ್ರ 3 ಒಂದು ಶ್ರೇಣಿಯನ್ನು
ಮೂರು ಹೆಸರುಗಳು, ಮತ್ತು ಇನ್ನೊಂದು ಸರಣಿ

8
00:00:20,220 --> 00:00:22,110
ಮನೆ ಗಾತ್ರ 3.

9
00:00:22,110 --> 00:00:25,870
ಆದರೆ ನಾವು ಈ ಸ್ವಚ್ಛಗೊಳಿಸಲು ತಿರುಗಿದರೆ
ಇನ್ನೂ, ಮತ್ತು ವಾಸ್ತವವಾಗಿ ಆ ಇರಿಸಿಕೊಳ್ಳಲು

10
00:00:25,870 --> 00:00:30,520
ಒಟ್ಟಿಗೆ ಹೆಸರುಗಳು ಮತ್ತು ಮನೆ, ಆದ್ದರಿಂದ ಒಂದು
ವಿದ್ಯಾರ್ಥಿಯ ಹೆಸರು ಮತ್ತು ತನ್ನ ಮನೆ

11
00:00:30,520 --> 00:00:34,940
ಹೇಗಾದರೂ ಆದ್ದರಿಂದ, ಸುತ್ತುವರಿಯುತ್ತದೆ ಮಾಡಲಾಗುತ್ತದೆ
ಅದೇ ವೇರಿಯಬಲ್ ಮಾತನಾಡಲು.

12
00:00:34,940 --> 00:00:39,095
>> ಇದನ್ನು ಮಾಡಲು, ಆದರೂ, ನಾವು ಘೋಷಿಸಲು ಅಗತ್ಯವಿದೆ
ನಮ್ಮ ಮಾಹಿತಿ ಪ್ರಕಾರ, ಸಿ ನಮ್ಮ ಮಾದರಿ,

13
00:00:39,095 --> 00:00:42,660
ಸಿ ಲೇಖಕರು ಅಗತ್ಯವಾಗಿ ಮಾಡಲಿಲ್ಲ
ವರ್ಷಗಳ ಹಿಂದೆ ಭಾವಿಸುತ್ತೇನೆ.

14
00:00:42,660 --> 00:00:45,630
ಇದನ್ನು ಮಾಡಲು ನಾವು ಕೀವರ್ಡ್ ಬಳಸಬಹುದು
typedef, ಜೊತೆಗೆ

15
00:00:45,630 --> 00:00:47,200
ಇತರ ಕೀವರ್ಡ್ struct.

16
00:00:47,200 --> 00:00:48,160
ನ ಅವಲೋಕಿಸೋಣ.

17
00:00:48,160 --> 00:00:50,650
Structs.h ಒಳಗೆ, ನಾನು ಈಗಾಗಲೇ ಬಂದಿದೆ
ಪ್ರಾರಂಭಿಸಿದರು ನೆತ್ತಿಗೇರಿದೆ

18
00:00:50,650 --> 00:00:52,560
CS50 ಗ್ರಂಥಾಲಯದ ಸೇರಿದಂತೆ.

19
00:00:52,560 --> 00:00:57,640
ನಾನು ಮುಂದಿನ, typedef struct ಟೈಪ್ ಪಡೆಯಲಿದ್ದೇನೆ
ಮತ್ತು ನಂತರ ಒಂದು ಸುರುಳಿಯಾದ ಬ್ರೇಸ್.

20
00:00:57,640 --> 00:01:01,370
Struct ಒಳಗೆ, ನಾನು ಪಡೆಯಲಿದ್ದೇನೆ
ವಿದ್ಯಾರ್ಥಿ ಒಳಪಟ್ಟಿರುತ್ತದೆ ಎಂದು ಸೂಚಿಸಲು ಒಂದು

21
00:01:01,370 --> 00:01:04,960
ಹೆಸರು ಸ್ಟ್ರಿಂಗ್ ಎಂಬ, ಮತ್ತು ಮತ್ತೊಂದು
ಸ್ಟ್ರಿಂಗ್ ಮನೆ ಎಂಬ.

22
00:01:04,960 --> 00:01:08,430
ನಾನು ನನ್ನ ಸುರುಳಿಯಾದ ಬ್ರೇಸ್ ಪಡೆಯಲಿದ್ದೇನೆ,
ಮತ್ತು ನಿರ್ದಿಷ್ಟ ಹೆಸರು

23
00:01:08,430 --> 00:01:11,420
ಈ ಹೊಸ ರೀತಿಯ ಮಾಹಿತಿ ವಿದ್ಯಾರ್ಥಿ ಕಂಗೊಳಿಸುತ್ತವೆ.

24
00:01:11,420 --> 00:01:15,550
ಅರ್ಥಾತ್, ಈ ವಾಕ್ಯ ಮೂಲಕ ನಾನು
ನನ್ನ ಹೊಸ ಮಾಹಿತಿ ಪ್ರಕಾರ, ಡಿಕ್ಲೇರ್ಡ್

25
00:01:15,550 --> 00:01:19,910
ಒಂದು ಕ್ಷಣ ಹಿಂದೆ ಅಸ್ತಿತ್ವದಲ್ಲಿ, ಮತ್ತು ಇಲ್ಲ
ಈ ಡೇಟಾವನ್ನು ರೀತಿಯ ಒಳಗೆ ಎರಡು ದಶಮಾಂಶ ಇವೆ

26
00:01:19,910 --> 00:01:24,270
ಜಾಗ ಅಥವಾ ದಶಮಾಂಶ ಸದಸ್ಯರು, ಹೆಸರು ಎಂದು ಒಂದು,
ಒಂದು ಎಂಬ ಮನೆ, ಇವೆರಡೂ

27
00:01:24,270 --> 00:01:25,630
ಕೌಟುಂಬಿಕತೆ ತಂತುವಿನ ಇವೆ.

28
00:01:25,630 --> 00:01:27,690
>> ಈಗ ಈ ರೀತಿಯ ಬಳಸಿ ಲೆಟ್
ನಿಜವಾದ ಕಾರ್ಯಕ್ರಮದಲ್ಲಿ.

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

30
00:01:30,210 --> 00:01:34,090
Structs0.c, ನಾನು ಇದೇ ನೆತ್ತಿಗೇರಿದೆ
ನನ್ನ ಕೆಲವು ಈಗಾಗಲೇ ಪ್ರಾರಂಭಿಸಿದರು

31
00:01:34,090 --> 00:01:36,999
ಬಾಯ್ಲರ್ ಕೋಡ್, ಮತ್ತು ನಾನು ಈಗ ಆಮ್
ಈ ಡೇಟಾವನ್ನು ಬಳಸಲು ಹೋಗುವ

32
00:01:36,999 --> 00:01:39,100
ಕೆಳಗಿನಂತೆ, ವಿದ್ಯಾರ್ಥಿ ಟೈಪ್.

33
00:01:39,100 --> 00:01:42,450
ನಾನು ಮೊದಲ ಒಂದು ಘೋಷಿಸಿದ ಪಡೆಯಲಿದ್ದೇನೆ
ರೀತಿಯ ವಿದ್ಯಾರ್ಥಿ ರಚನೆಯ ನಾನು ಮಾಡುತ್ತೇವೆ

34
00:01:42,450 --> 00:01:43,920
ರಚನೆಯ ವಿದ್ಯಾರ್ಥಿಗಳು ಕರೆ -

35
00:01:43,920 --> 00:01:44,630
ಬಹುವಚನ -

36
00:01:44,630 --> 00:01:49,360
ಮತ್ತು ನಾನು ಅದರ ಗಾತ್ರದ ಎಂದು ಸೂಚಿಸಲು ಮಾಡುತ್ತೇವೆ
ಮೌಲ್ಯವನ್ನು ಇದು, ಸೂಚನೆ, ಮೂರು,

37
00:01:49,360 --> 00:01:50,880
ನಿರಂತರ ವಿದ್ಯಾರ್ಥಿಗಳು -

38
00:01:50,880 --> 00:01:51,890
ಎಲ್ಲಾ ರಾಜಧಾನಿಗಳು -

39
00:01:51,890 --> 00:01:54,930
ನಾನು ಇಲ್ಲಿ ಡಿಕ್ಲೇರ್ಡ್ ಎಂಬುದನ್ನು,
ಹಿಂದಿನ ಕಡತದಲ್ಲಿ.

40
00:01:54,930 --> 00:01:58,280
ಈಗ ಆ ಮೂರು ಮೇಲೆ ತಿರುಗಿ ಲೆಟ್
ವಿದ್ಯಾರ್ಥಿಗಳು, ಮತ್ತು ಬಳಕೆದಾರರು ಪ್ರಾಂಪ್ಟ್

41
00:01:58,280 --> 00:02:00,050
ಅವರ ಹೆಸರುಗಳು ಮತ್ತು ಮನೆ.

42
00:02:00,050 --> 00:02:05,422
>> ನಾನು 0 ಪಡೆಯಲು ಇಂಟ್, ನಾನು ಕಡಿಮೆ
ಎಂದು ನಿರಂತರ ಹೆಚ್ಚು, ನಾನು + +.

43
00:02:05,422 --> 00:02:08,600
ಈಗ ಈ ದೇಹದ ಒಳಗೆ
ಲೂಪ್, ನಾನು ಏನೋ ಮುದ್ರಿಸುತ್ತದೆ ಪಡೆಯಲಿದ್ದೇನೆ

44
00:02:08,600 --> 00:02:11,470
ವಿದ್ಯಾರ್ಥಿಯ ಹೆಸರು ಹಾಗೆ.

45
00:02:11,470 --> 00:02:14,890
ನಾನು ನಿಜವಾಗಿ ಪಡೆಯಲು ಪಡೆಯಲಿದ್ದೇನೆ
ಸೂಚಿಸುವ ಮೂಲಕ ವಿದ್ಯಾರ್ಥಿಯ ಹೆಸರು

46
00:02:14,890 --> 00:02:17,290
ವಿದ್ಯಾರ್ಥಿಗಳು ನಾನು ಆವರಣ.

47
00:02:17,290 --> 00:02:21,550
ಅರ್ಥಾತ್ ನಾನು I-ನೇ ವಿದ್ಯಾರ್ಥಿ ಬಯಸುವ
ಈಗ ವಿದ್ಯಾರ್ಥಿಗಳು ಎಂಬ ರಚನೆಯ, ಆದರೆ

48
00:02:21,550 --> 00:02:25,340
ನಾನು I-ನೇ ವಿದ್ಯಾರ್ಥಿಯ ನಲ್ಲಿ ಸಿಗತ್ತೆ
ಹೆಸರಿಸಲು, ಮತ್ತು ಇದನ್ನು, ನಾನು ಬಳಸಲು ಪಡೆಯಲಿದ್ದೇನೆ

49
00:02:25,340 --> 00:02:30,160
. ಆಯೋಜಕರು, ಒಂದು ನಲ್ಲಿ ಪಡೆಯಬೇಕಾದರೆ
struct ಆಫ್ ನಿರ್ದಿಷ್ಟ ಕ್ಷೇತ್ರದಲ್ಲಿ ಒಳಗೆ.

50
00:02:30,160 --> 00:02:37,100
ಹಾಗಾಗಿ ವಿದ್ಯಾರ್ಥಿಗಳು ನಾನು. ಹೆಸರು ಆವರಣ ಸೂಚಿಸಲು
GetString ಮರಳುವ ಮೌಲ್ಯವನ್ನು ಪಡೆಯುತ್ತದೆ ().

51
00:02:37,100 --> 00:02:40,310
ಏತನ್ಮಧ್ಯೆ, ನಾನು ಮುದ್ರಿಸುತ್ತದೆ ಪಡೆಯಲಿದ್ದೇನೆ
ಇದೇ ಏನೋ, ವಿದ್ಯಾರ್ಥಿಯ ಹೇಳುವ

52
00:02:40,310 --> 00:02:45,410
ಮನೆ, ಮತ್ತು ಈಗ ನಾನು ಸೂಚಿಸಲು ಪಡೆಯಲಿದ್ದೇನೆ
ನಾನು ನೇ ವಿದ್ಯಾರ್ಥಿಗಳು ಮನೆಯ ಕ್ಷೇತ್ರ

53
00:02:45,410 --> 00:02:49,480
ಮರಳುವ ಮೌಲ್ಯವನ್ನು ಪಡೆಯಲು ಹಾಗಿಲ್ಲ
GetString ಗೆ ಮತ್ತೊಂದು ಕರೆ ().

54
00:02:49,480 --> 00:02:52,350
>> ಈಗ ಈ ಮೂರು ಏನಾದರೂ ಮಾಡೋಣ
ವಿದ್ಯಾರ್ಥಿಗಳು ಹೆಸರುಗಳು ಮತ್ತು ಮನೆ,

55
00:02:52,350 --> 00:02:56,230
ಮುದ್ರಣ ರೀತಿಯ ಸರಳ ಏನೋ
ಒಂದು ವಾಕ್ಯದಲ್ಲಿ ಪ್ರತಿ ಔಟ್.

56
00:02:56,230 --> 00:03:07,580
ಇಂಟ್ ನಾನು 0, ಮತ್ತೆ ನಾನು ಕಡಿಮೆ ಪಡೆಯುತ್ತೀರಿ
ವಿದ್ಯಾರ್ಥಿಗಳು, ನಾನು + +, printf "% s ಅನ್ನು% s ಆಗಿದೆ.

57
00:03:07,580 --> 00:03:12,600
ಬ್ಯಾಕ್ಸ್ಲ್ಯಾಷ್ n "ಮತ್ತು ಈಗ ನನಗೆ ಪ್ಲಗ್ ಅವಕಾಶ
ಆ ಎರಡು ಜಾಗ ಮೌಲ್ಯಗಳನ್ನು,

58
00:03:12,600 --> 00:03:19,055
ವಿದ್ಯಾರ್ಥಿಗಳು, ನಾನು. ಹೆಸರು, ಅಲ್ಪವಿರಾಮ ಬ್ರಾಕೆಟ್
ವಿದ್ಯಾರ್ಥಿಗಳು ನಾನು ಬ್ರಾಕೆಟ್. ಮನೆ, ನಿಕಟ

59
00:03:19,055 --> 00:03:21,290
ಆವರಣ, ಅಲ್ಪವಿರಾಮ ಚಿಹ್ನೆಯಿಂದ.

60
00:03:21,290 --> 00:03:23,020
>> ಮತ್ತು ಈಗ ನಾನು ಒಂದು ವಿಷಯವನ್ನು ಅಗತ್ಯವಿದೆ.

61
00:03:23,020 --> 00:03:26,600
ಈ ಕಡತ ಕೆಳಭಾಗದಲ್ಲಿ, ನಾನು ಅಗತ್ಯವಿದೆ
ಹಂಚಲಾಯಿತು ಮೆಮೊರಿ ಮುಕ್ತಗೊಳಿಸಲು

62
00:03:26,600 --> 00:03:30,290
GetSring (), ಮೂಲಕ ತೆರೆಮರೆಯಲ್ಲಿ ಇದು
ಸಹಜವಾಗಿ ಸಲುವಾಗಿ,, malloc ಕರೆಗಳು

63
00:03:30,290 --> 00:03:32,500
ತಂತಿಗಳನ್ನು ಮೆಮೊರಿ ನಿಯೋಜಿಸಿ
ಬಳಕೆದಾರ ರೀತಿಯ.

64
00:03:32,500 --> 00:03:35,720
ಆದರೆ ಈ ಸರಳ.

65
00:03:35,720 --> 00:03:42,610
ನಾನು 0 ಪಡೆಯಲು ಇಂಟ್, ನಾನು ಕಡಿಮೆ
ವಿದ್ಯಾರ್ಥಿಗಳು, ನಾನು + +, ಮತ್ತು ದೇಹದ ಒಳಗೆ

66
00:03:42,610 --> 00:03:48,670
ಈ ಲೂಪ್, ನಾನು ಕೇವಲ ಪಡೆಯಲಿದ್ದೇನೆ
ಉಚಿತ ವಿದ್ಯಾರ್ಥಿಗಳು ಬ್ರಾಕೆಟ್ ನಾನು. ಹೆಸರು ಒದಗಿಸಲು,

67
00:03:48,670 --> 00:03:52,300
ಮತ್ತು ಉಚಿತ ವಿದ್ಯಾರ್ಥಿಗಳು ನಾನು ಬ್ರಾಕೆಟ್. ಮನೆ.

68
00:03:52,300 --> 00:03:55,620
>> ಈಗ, ನಾವು ಸ್ಪಷ್ಟವಾಗಿ ಕುಣಿಕೆಗಳು ಮೂರು ಬಳಸಲಾಗುತ್ತದೆ ಬಂದಿದೆ
ಈ ಕಾರ್ಯಕ್ರಮದಲ್ಲಿ, ನಿಜವಾಗಿಯೂ ನಾನು

69
00:03:55,620 --> 00:03:58,800
ಕೇವಲ ಒಂದು ಬಳಸಲಾಗುತ್ತದೆ, ಆದರೆ ಈ ಸಾಧ್ಯವಾಗಲಿಲ್ಲ
ಕೇವಲ ಪ್ರದರ್ಶನ ಸಲುವಾಗಿ, ಆದ್ದರಿಂದ

70
00:03:58,800 --> 00:04:02,850
ನಾವು ಮೂರು ವಿಭಿನ್ನ ರಲ್ಲಿ ಸೂಚಿಸಬಹುದು
ನಾವು ಮಾಡುತ್ತಿರುವುದು ನಿಖರವಾಗಿ ನಿಲ್ಲುತ್ತಾಳೆ.

71
00:04:02,850 --> 00:04:06,120
ನಾವು ಮೊದಲ ಒಂದು ಹೆಸರು ಮತ್ತು ಒಂದು ಮನೆಯನ್ನು ಬರುತ್ತಿದೆ
ವಿದ್ಯಾರ್ಥಿಗಳು ಪ್ರತಿ, ನಾವು ನಂತರ ಆರ್

72
00:04:06,120 --> 00:04:08,900
ಹೆಸರು ಮತ್ತು ಮನೆಯ ಔಟ್ ಮುದ್ರಣ
ಮೂರು ವಿದ್ಯಾರ್ಥಿಗಳು ಪ್ರತಿ, ಮತ್ತು

73
00:04:08,900 --> 00:04:11,910
ನಂತರ ನಾವು ಮೆಮೊರಿ ಮುಕ್ತಗೊಳಿಸಲು ನೀನು
ವಿದ್ಯಾರ್ಥಿಗಳು ಪ್ರತಿ ಬಳಸುವ.

74
00:04:11,910 --> 00:04:15,310
ಆದರೆ ಖಂಡಿತವಾಗಿ ನಾವು ಈ ಒಗ್ಗೂಡಿ ಬಂದಿದೆ ಎಂದು
ಲೂಪ್ ಒಂದು ದೊಡ್ಡ ಒಳಗೆ.

75
00:04:15,310 --> 00:04:18,650
>> ಕಂಪೈಲ್, ಈಗ ಉಳಿಸಲು ಅವಕಾಶ,
ಮತ್ತು ಈ ಪ್ರೋಗ್ರಾಂ.

76
00:04:18,650 --> 00:04:26,850
ಮಾಡಲು ಸ್ಟ್ರಕ್ಟ್ಸ್ಳ 0. / ಸ್ಟ್ರಕ್ಟ್ಸ್ಳ 0, ವಿದ್ಯಾರ್ಥಿಯ
ಹೆಸರಿಸಲು, ಡೇವಿಡ್ ಒದಗಿಸಲು ಅವಕಾಶ, ಅವರು ಬದುಕುವಿರಿ

77
00:04:26,850 --> 00:04:31,580
ಮ್ಯಾಥರ್ ಹೌಸ್, ವಿದ್ಯಾರ್ಥಿಯ ಹೆಸರು, ತಂದೆಯ ಅವಕಾಶ
ಲಾರೆನ್ ಹೇಳುತ್ತಾರೆ, ಅವಳು Leverett, ವಾಸಿಸುತ್ತಿದ್ದಾರೆ ಮಾಡುತ್ತೇವೆ

78
00:04:31,580 --> 00:04:36,590
ಹೌಸ್, ವಿದ್ಯಾರ್ಥಿಯ ಹೆಸರು, ರಾಬ್, ಅವರು ಮಾಡುತ್ತೇವೆ
ಕಿರ್ಕ್ಲ್ಯಾಂಡ್ ಮನೆಯಲ್ಲಿ ವಾಸಿಸುತ್ತಿದ್ದಾರೆ.

79
00:04:36,590 --> 00:04:39,440
ಮತ್ತು ವಾಸ್ತವವಾಗಿ, ಡೇವಿಡ್, ಮ್ಯಾಥರ್ ನಲ್ಲಿ
ಲಾರೆನ್ Leverett, ಆಗಿದೆ

80
00:04:39,440 --> 00:04:40,810
ಮತ್ತು ರಾಬ್ ಕಿರ್ಕ್ಲ್ಯಾಂಡ್ ಹೊಂದಿದೆ.

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