1
00:00:07,260 --> 00:00:09,180
[Powered by Google Translate] ನ ಸ್ಟ್ರಕ್ಟ್ಸ್ಳ ಬಗ್ಗೆ ಮಾತನಾಡೋಣ.

2
00:00:09,180 --> 00:00:12,130
ಸ್ಟ್ರಕ್ಟ್ಸ್ಳ ಒಟ್ಟಿಗೆ ಅಸ್ಥಿರಗಳ ಕನಸುಗಳಿವೆ ಗುಂಪಿಗೆ ಒಂದು ರೀತಿಯಲ್ಲಿ ನಮಗೆ ಒದಗಿಸಿ

3
00:00:12,130 --> 00:00:14,350
ಉತ್ತಮ ಪ್ಯಾಕೇಜ್ ಆಗಿ.

4
00:00:14,350 --> 00:00:17,020
ಇದು ಸರಿಯಾದ ಉದಾಹರಣೆ ನೋಡಿ ಬಹುಶಃ ಸುಲಭವಾದ ಇಲ್ಲಿದೆ

5
00:00:17,020 --> 00:00:20,030
ಆದ್ದರಿಂದ ನಾವು, struct ಹೇಳುತ್ತಾರೆ

6
00:00:20,030 --> 00:00:23,340
ನಂತರ, ಸುರುಳಿಯಾದ ಬ್ರೇಸ್ ತೆರೆಯುವ

7
00:00:23,340 --> 00:00:26,630
ಮತ್ತು ಈ struct ರಲ್ಲಿ, ನಾವು, ಒಂದು int ವಯಸ್ಸು ನಿಮಗಿದೆ

8
00:00:28,920 --> 00:00:31,350
ಒಂದು ಚಾರ್ * ಹೆಸರು

9
00:00:31,350 --> 00:00:34,670
ಮತ್ತು ಅಷ್ಟೇ.

10
00:00:37,350 --> 00:00:40,650
ಇದು, ಒಂದು ಸುರುಳಿಯಾದ ಬ್ರೇಸ್ ನಂತರ ಒಂದು ಅರ್ಧವಿರಾಮ ಚಿಹ್ನೆಯಿಂದ ವಿಲಕ್ಷಣ ಕಾಣಬಹುದು

11
00:00:40,650 --> 00:00:43,620
ಆದರೆ ಸ್ಟ್ರಕ್ಟ್ಸ್ಳ ಅಗತ್ಯ ವಾಸ್ತವವಾಗಿ ಇಲ್ಲಿದೆ.

12
00:00:43,620 --> 00:00:46,270
ಯಾವುದೇ ಮಾನ್ಯ ರೀತಿಯ struct ವಿವರಣೆಗೆ ಹೋಗಬಹುದು.

13
00:00:46,270 --> 00:00:49,530
ಇಲ್ಲಿ, ನಾವು, ಒಂದು int ಮತ್ತು ಚಾರ್ * ಬಳಸಲಾಗುತ್ತದೆ ಮಾಡಿದ

14
00:00:49,530 --> 00:00:52,610
ಆದರೆ ನೀವು, ಅಭಿಪ್ರಾಯಗಳಿಂದಲೇ, 100 ಅಂಶಗಳನ್ನು ಒಂದು ಶ್ರೇಣಿಯನ್ನು ಬಳಸುತ್ತವೆ ಸಾಧ್ಯವಾಗಲಿಲ್ಲ

15
00:00:52,610 --> 00:00:54,910
ಅಥವಾ ಇನ್ನೊಂದು struct.

16
00:00:54,910 --> 00:00:56,960
ನೀವು ಸಿ ಸ್ಟ್ರಕ್ಟ್ಸ್ಳ ಬಳಸಿಕೊಂಡು ನೀವು,

17
00:00:56,960 --> 00:00:58,430
ನೀವು ಹೊಸ ರೀತಿಯ ರಚಿಸುತ್ತಿದೆ

18
00:00:58,430 --> 00:01:00,860
ಇತರ ವಿಧಗಳ ಸಂಗ್ರಹಣೆಗೆ ಔಟ್.

19
00:01:00,860 --> 00:01:02,620
ಇಲ್ಲಿ, ನಾವು ಒಂದು ಹೊಸ ರೀತಿಯ ಮಾಡುತ್ತಿದ್ದೀಯ

20
00:01:02,620 --> 00:01:05,060
ಒಂದು ಪೂರ್ಣಾಂಕ ಮತ್ತು ಚಾರ್ * ಹೊರಗೆ.

21
00:01:05,060 --> 00:01:07,400
ನಾವು ನಂತರ ನೋಡುತ್ತಾರೆ ಎಂದು, ಒಂದು struct ಕೌಟುಂಬಿಕತೆ

22
00:01:07,400 --> 00:01:10,700
ನೀವು ಬಳಸುವ ನೀವು ಯಾವುದೇ ರೀತಿಯ ಸಮಾನ ಹಾದಿಗಳಿವೆ ರಲ್ಲಿ ಆಗಿದೆ.

23
00:01:10,700 --> 00:01:13,310
ಸಾಮಾನ್ಯವಾಗಿ, ನಾನು ಹೇಗೆ struct ರೀತಿಯ ಹೋಲಿಸುವ ಪಡೆದುಕೊಳ್ಳುತ್ತೀರಿ

24
00:01:13,310 --> 00:01:15,790
ಒಂದು ಪೂರ್ಣಾಂಕ ಪ್ರಕಾರವನ್ನು ಹೋಲುತ್ತದೆ.

25
00:01:15,790 --> 00:01:18,520
ನಾವು ಬರೆದ ಕೋಡ್ ಮಾನ್ಯ C ಆಗಿರುತ್ತದೆ, ಆದರೆ

26
00:01:18,520 --> 00:01:20,320
ಇದು ಬಹಳ ಉಪಯುಕ್ತ ಅಲ್ಲ

27
00:01:20,320 --> 00:01:22,340
ಮತ್ತು ಖಣಿಲು ನಮಗೆ ಎಚ್ಚರಿಕೆ ನೀಡುತ್ತದೆ.

28
00:01:22,340 --> 00:01:24,970
ಸ್ಟ್ರಕ್ಟ್ಸ್ಳ ಮತ್ತು ಅದರ ರೀತಿಯ ಎಷ್ಟು ನೆನಪಿಡಿ?

29
00:01:24,970 --> 00:01:26,710
ಹಾಗೆಯೇ, ನಾವು ಮೂಲತಃ ಕೇವಲ ಹೇಳಿದರು

30
00:01:27,840 --> 00:01:30,060
ಇಂಟ್,

31
00:01:30,060 --> 00:01:33,140
ಇದು ಬಹಳ ಉಪಯುಕ್ತ ಸಾಲನ್ನು ಅಲ್ಲ.

32
00:01:33,140 --> 00:01:35,760
ಆದ್ದರಿಂದ ಅವರ ವಾಸ್ತವವಾಗಿ ಆ ರೀತಿಯ ಒಂದು ವೇರಿಯೇಬಲ್ ಘೋಷಿಸಲು ಅವಕಾಶ

33
00:01:35,760 --> 00:01:38,760
ಇದು ಅಲ್ಪ ವಿರಾಮ ಚಿಹ್ನೆಯನ್ನು ಮೊದಲು ಒಂದು ಹೆಸರನ್ನು ನೀಡುವ ಮೂಲಕ.

34
00:01:42,170 --> 00:01:45,000
ನಾವು ವೇರಿಯಬಲ್ ವಿದ್ಯಾರ್ಥಿ ಕರೆ ಮಾಡುತ್ತೇವೆ.

35
00:01:48,190 --> 00:01:51,350
ಈಗ ನಾವು ಒಂದು ವೇರಿಯೇಬಲ್ ಎಂದು ವಿದ್ಯಾರ್ಥಿ ಡಿಕ್ಲೇರ್ಡ್ ಮಾಡಿದ

36
00:01:51,350 --> 00:01:53,980
struct ನೀಡಿದ ರೀತಿಯ.

37
00:01:53,980 --> 00:01:56,730
ಹೇಗೆ ನಾವು struct ಒಳಗೆ ಏರುಪೇರುಗಳಲ್ಲಿ ಸಿಗುತ್ತವೆ?

38
00:01:56,730 --> 00:01:59,040
ಈ ಅಸ್ಥಿರಗಳು ತಾಂತ್ರಿಕವಾಗಿ, ಹೆಸರುಗಳು

39
00:01:59,040 --> 00:02:01,070
ಸದಸ್ಯರು.

40
00:02:01,070 --> 00:02:04,000
ವಿದ್ಯಾರ್ಥಿ struct ಯಾವುದೇ ನಿರ್ದಿಷ್ಟ ಸದಸ್ಯ ಪ್ರವೇಶಿಸಲು,

41
00:02:04,000 --> 00:02:06,440
ನೀವು, ವೇರಿಯಬಲ್ ಹೆಸರಿನ ಒಂದು ಬಿಂದುವನ್ನು ಸೇರಿಸಲು

42
00:02:06,440 --> 00:02:08,860
ನೀವು ಸದಸ್ಯರ ಹೆಸರಿನ ಮೊದಲು.

43
00:02:08,860 --> 00:02:11,690
ಇಲ್ಲಿ, ಕೇವಲ 2 ಮಾನ್ಯ ಸಾಧ್ಯತೆಗಳನ್ನು

44
00:02:11,690 --> 00:02:17,760
student.age ಗಳು

45
00:02:17,760 --> 00:02:24,460
ಮತ್ತು student.name.

46
00:02:24,460 --> 00:02:26,820
ಮತ್ತು ನಾವು ಏನನ್ನಾದರೂ ರೀತಿಯಲ್ಲಿ ಮಾಡಬಹುದು

47
00:02:26,820 --> 00:02:30,320
student.age = 12

48
00:02:30,320 --> 00:02:39,310
ಮತ್ತು student.name = ವಿದ್ಯಾರ್ಥಿ.

49
00:02:39,310 --> 00:02:42,580
ಈಗ ನಾವು ಎರಡನೇ ವಿದ್ಯಾರ್ಥಿ ಮಾಡಲು ಬಯಸಿದರೆ?

50
00:02:42,580 --> 00:02:44,760
ಈ ಸಾಲುಗಳನ್ನು ನಕಲಿಸಿ ಮತ್ತು ಅಂಟಿಸಿ ಯೋಚಿಸುವಿರಾ ಇರಬಹುದು

51
00:02:44,760 --> 00:02:48,110
ಮತ್ತು ವಿದ್ಯಾರ್ಥಿ 2 ಅಥವಾ ಕೆಲಸಕ್ಕೆ ವಿದ್ಯಾರ್ಥಿ ಬದಲಾಯಿಸಲು,

52
00:02:48,110 --> 00:02:50,090
ಮತ್ತು ಕೆಲಸ,

53
00:02:50,090 --> 00:02:52,670
ಆದರೆ ತಾಂತ್ರಿಕವಾಗಿ, ವಿದ್ಯಾರ್ಥಿ ಮತ್ತು ವಿದ್ಯಾರ್ಥಿ 2

54
00:02:52,670 --> 00:02:54,540
ಅದೇ ರೀತಿಯ ಹೊಂದಿಲ್ಲ.

55
00:02:54,540 --> 00:02:56,940
ನೋಡಿ, ನೀವು ಪರಸ್ಪರ ಅವರನ್ನು ನಿಯೋಜಿಸಲು ಸಾಧ್ಯವಿಲ್ಲ.

56
00:02:56,940 --> 00:02:58,560
ಇದು ಏಕೆಂದರೆ, ಇಲ್ಲಿಯವರೆಗೆ ಆಗಿದೆ

57
00:02:58,560 --> 00:03:00,950
ನಿಮ್ಮ struct ಅನಾಮಧೇಯ ಬಂದಿದೆ.

58
00:03:00,950 --> 00:03:02,290
ನಾವು ಒಂದು ಹೆಸರನ್ನು ನೀಡಲು ಅಗತ್ಯವಿದೆ.

59
00:03:02,290 --> 00:03:04,420
ಹಾಗೆ ಮಾಡಲು, ನಾವು struct ಹೆಸರನ್ನು ಸೇರಿಸಲು

60
00:03:04,420 --> 00:03:06,950
ಪದ struct ನಂತರ.

61
00:03:09,440 --> 00:03:11,170
ವಿದ್ಯಾರ್ಥಿ,

62
00:03:11,170 --> 00:03:14,680
ವ್ಯಾಖ್ಯಾನವನ್ನು ಅನುಸರಿಸಿ.

63
00:03:16,500 --> 00:03:18,940
ನಾವು ಇನ್ನೂ ತಕ್ಷಣವೇ ಪ್ರಕಾರದ ವೇರಿಯಬಲ್ ಘೋಷಿಸಬಹುದು

64
00:03:18,940 --> 00:03:21,570
ನಾವು ಮೊದಲು ಮಾಡಿದ ರೀತಿಯಲ್ಲಿ, ವಿದ್ಯಾರ್ಥಿ struct.

65
00:03:24,320 --> 00:03:28,360
ನಾವು S1 ಕರೆ ಮಾಡುತ್ತೇವೆ

66
00:03:28,590 --> 00:03:30,760
Struct ಒಂದು ಹೆಸರನ್ನು ನೀಡುವ ಮೂಲಕ,

67
00:03:30,760 --> 00:03:33,050
ನಾವು ಈಗ struct ವಿದ್ಯಾರ್ಥಿ ಬಳಸಬಹುದು

68
00:03:33,050 --> 00:03:36,950
ಹೆಚ್ಚೂಕಮ್ಮಿ ಅದೇ ರೀತಿಯಲ್ಲಿ ನಾವು ಇಂಟ್ ಬಳಸಬಹುದು.

69
00:03:36,950 --> 00:03:39,580
ಆದ್ದರಿಂದ ನಾವು, ಕೌಟುಂಬಿಕತೆ struct ವಿದ್ಯಾರ್ಥಿ ಒಂದು ವೇರಿಯೇಬಲ್ ಘೋಷಿಸಬಹುದು

70
00:03:39,580 --> 00:03:42,360
ಅಂತಹ

71
00:03:42,360 --> 00:03:49,500
struct ವಿದ್ಯಾರ್ಥಿ ಎಸ್ 2.

72
00:03:51,020 --> 00:03:55,130
ಸರಣಿಗಳ ನಂತಹ ಸ್ಟ್ರಕ್ಟ್ಸ್ಳ, ಒಂದು ಶಾರ್ಟ್ಕಟ್ ಆರಂಭಕ್ಕೆ ವಾಕ್ಯ ಒದಗಿಸಲು

73
00:03:55,130 --> 00:03:58,670
ನಾವು ವಿದ್ಯಾರ್ಥಿ ಎಸ್ 2 struct, ಹೇಳಬಹುದು

74
00:03:58,670 --> 00:04:01,420
ಸಮನಾಗಿರುತ್ತದೆ

75
00:04:01,420 --> 00:04:06,040
ಎಡ ಸುರುಳಿಯಾದ ಬ್ರೇಸ್ 3, ಎಸ್ 2.

76
00:04:09,210 --> 00:04:12,600
ಇಲ್ಲಿ, S2.age, 3 ಆಗಿರುತ್ತದೆ

77
00:04:12,600 --> 00:04:15,910
ಮತ್ತು S2.name S2 ಬೆಟ್ಟು ಕಾಣಿಸುತ್ತದೆ.

78
00:04:15,910 --> 00:04:19,149
ಒಂದು ಇಂಟ್ ರೀತಿಯ ನೀವು ಎಲ್ಲಾ ವಿಷಯಗಳನ್ನು ಥಿಂಕ್

79
00:04:19,149 --> 00:04:22,460
ಮತ್ತು ಅವುಗಳನ್ನು ಅತ್ಯಂತ ನೀವು struct ವಿದ್ಯಾರ್ಥಿ ರೀತಿಯ ಮಾಡಬಹುದು.

80
00:04:22,460 --> 00:04:26,060
ನಾವು ಒಂದು ಕಾರ್ಯ ನಿಯತಾಂಕದ ಒಂದು ರೀತಿಯ ಒಂದು struct ವಿದ್ಯಾರ್ಥಿ ಬಳಸಬಹುದು.

81
00:04:26,060 --> 00:04:28,790
ನಾವು ಹೊಸ struct ಒಳಗೆ struct ವಿದ್ಯಾರ್ಥಿ ಬಳಸಬಹುದು.

82
00:04:28,790 --> 00:04:31,010
ನಾವು struct ವಿದ್ಯಾರ್ಥಿ ಒಂದು ಪಾಯಿಂಟರ್ ಹೊಂದಬಹುದು.

83
00:04:31,010 --> 00:04:33,540
ನಾವು struct ವಿದ್ಯಾರ್ಥಿ ಗಾತ್ರವನ್ನು ಮಾಡಬಹುದು.

84
00:04:33,540 --> 00:04:35,510
Struct ವಿದ್ಯಾರ್ಥಿ ಒಂದು ವಿಧ

85
00:04:35,510 --> 00:04:38,030
ಕೇವಲ ಇಂಟ್ ಒಂದು ವಿಧ.

86
00:04:38,030 --> 00:04:40,540
ನಾವು ಎಸ್ 2 ಗೆ S1 ನಿಯೋಜಿಸಲು ಮಾಡಬಹುದು

87
00:04:40,540 --> 00:04:43,760
ಎರಡೂ ಒಂದೇ ರೀತಿಯ ಕಾರಣ, ಆದ್ದರಿಂದ ನಾವು ಮಾಡಬಹುದು

88
00:04:44,390 --> 00:04:47,540
ಎಸ್ 1 = ಎಸ್ 2.

89
00:04:47,540 --> 00:04:50,430
ನಾವು ಏನಾಗುತ್ತದೆ

90
00:04:50,430 --> 00:04:55,300
S1.age = 10?

91
00:04:56,340 --> 00:04:58,880
ಎಲ್ಲ S2 ಬದಲಾಗಬಹುದು?

92
00:04:58,880 --> 00:05:02,800
ಮತ್ತೆ, ಕೇವಲ ಸಾಮಾನ್ಯ ಪೂರ್ಣಾಂಕಗಳ ಮಾಹಿತಿ ಸ್ಟ್ರಕ್ಟ್ಸ್ಳ ನಗರದ.

93
00:05:02,800 --> 00:05:05,590
ನಾವು ಕೆಲವು ಇಂಟ್ ವೈ ಕೆಲವು ಇಂಟ್ ಎಕ್ಸ್ ನಿಯೋಜಿಸಲು ವೇಳೆ,

94
00:05:05,590 --> 00:05:08,970
x = y ಹಾಗೆ

95
00:05:08,970 --> 00:05:10,850
ತದನಂತರ, ಎಕ್ಸ್ ಬದಲಾಯಿಸಲು

96
00:05:10,850 --> 00:05:14,230
ಎಂದು ಎಕ್ಸ್ + +

97
00:05:14,230 --> 00:05:17,020
ವೈ ಎಲ್ಲಾ ಬದಲಾವಣೆ ಇಲ್ಲ?

98
00:05:17,020 --> 00:05:20,980
ವೈ ಇಲ್ಲಿ ಬದಲಾಯಿಸಬಹುದು, ಮತ್ತು ಆದ್ದರಿಂದ ಎರಡೂ ಮೇಲೆ S2 ಮಾದರಿಯನ್ನು ನೀಡುವುದಿಲ್ಲ.

99
00:05:20,980 --> 00:05:24,120
S2.age ಇನ್ನೂ 3.

100
00:05:24,120 --> 00:05:27,350
ಆದರೆ ಗಮನಿಸಿ ಮತ್ತೊಂದು struct ನಿಯೋಜಿಸುವ ಆ,

101
00:05:27,350 --> 00:05:30,300
ಪಾಯಿಂಟರ್ಸ್ ಎಲ್ಲಾ ಈಗಲೂ ಒಂದೇ ಬೆರಳು

102
00:05:30,300 --> 00:05:32,260
ಅವರು ಕೇವಲ ನಕಲಿಸಲಾಗಿದೆ ರಿಂದ.

103
00:05:32,260 --> 00:05:34,300
ನೀವು ಪಾಯಿಂಟರ್ಸ್ ಹಂಚಿಕೊಳ್ಳಲು ಬಯಸದಿದ್ದರೆ,

104
00:05:34,300 --> 00:05:36,100
ನೀವು ಕೈಯಾರೆ ಎಂದು ನಿರ್ವಹಿಸಲು ಅಗತ್ಯವಿದೆ

105
00:05:36,100 --> 00:05:39,780
ಬಹುಶಃ ಪಾಯಿಂಟರ್ಗಳ ಒಂದು ಮೆಮೊರಿಯ ಒಂದು ಬ್ಲಾಕ್ malicking ಮೂಲಕ ತೋರಿಸಲು

106
00:05:39,780 --> 00:05:42,120
ಮತ್ತು ಡೇಟಾವನ್ನು ನಕಲು.

107
00:05:42,120 --> 00:05:45,540
ಇದು ಎಲ್ಲೆಡೆ struct ವಿದ್ಯಾರ್ಥಿ ಬರೆಯಲು ಹೊಂದಿರುವ ಕಿರಿಕಿರಿ ಇರಬಹುದು.

108
00:05:45,540 --> 00:05:48,730
ಒಂದು ರೀತಿಯ ಡೆಫ್ ಬಳಸಿ, ನಾವು ಮಾಡಬಹುದು

109
00:05:51,630 --> 00:05:55,850
ರೀತಿಯ ಡೆಫ್

110
00:05:55,850 --> 00:05:58,830
struct

111
00:05:58,830 --> 00:06:01,270
ಮತ್ತು ನಾವು ವಿದ್ಯಾರ್ಥಿ ಕರೆ ಮಾಡುತ್ತೇವೆ.

112
00:06:05,620 --> 00:06:08,360
ಈಗ, ನಾವು ಎಲ್ಲೆಡೆ ವಿದ್ಯಾರ್ಥಿ ಬಳಸಬಹುದು

113
00:06:08,360 --> 00:06:11,090
ನಾವು struct ವಿದ್ಯಾರ್ಥಿ ಬಳಸಲು ಬಳಸಿದ.

114
00:06:11,090 --> 00:06:13,410
ಈ ರೀತಿಯ ಡೆಫ್ ಅನಾಮಿಕ struct ಇಲ್ಲಿದೆ

115
00:06:13,410 --> 00:06:15,750
ಮತ್ತು ವಿದ್ಯಾರ್ಥಿ ಕರೆ.

116
00:06:15,750 --> 00:06:18,220
ಆದರೆ ನಾವು ವಿದ್ಯಾರ್ಥಿ ಗುರುತು ಇರಿಸಿಕೊಳ್ಳಲು ವೇಳೆ

117
00:06:18,220 --> 00:06:22,380
ಪದ struct ಮುಂದೆ, typedef struct ವಿದ್ಯಾರ್ಥಿ ಎಂದು,

118
00:06:27,670 --> 00:06:31,590
ನಾವು ಅದಲು ಈಗ struct ವಿದ್ಯಾರ್ಥಿ ಮತ್ತು ವಿದ್ಯಾರ್ಥಿ ಎರಡೂ ಬಳಸಬಹುದಾಗಿತ್ತು.

119
00:06:31,590 --> 00:06:34,060
ಅವರು ಒಂದೇ ಹೆಸರನ್ನು ಹೊಂದಿವೆ ಇಲ್ಲ.

120
00:06:34,060 --> 00:06:36,710
ನಾವು ಬಾಬ್ ಗೆ ಡೆಫ್ struct ವಿದ್ಯಾರ್ಥಿ ಟೈಪ್ ಮಾಡಬಹುದು

121
00:06:36,710 --> 00:06:38,950
ನಂತರ ವಿದ್ಯಾರ್ಥಿ ಮತ್ತು ಬಾಬ್ struct

122
00:06:38,950 --> 00:06:41,270
ಪರಸ್ಪರ ರೀತಿಯ ಎಂದು.

123
00:06:41,270 --> 00:06:44,050
ಹೊರತಾಗಿ ರೀತಿಯ ಡೆಫ್ ನ,

124
00:06:44,050 --> 00:06:46,750
ನಾವು struct ಮುಂದಿನ ಗುರುತು ಅವಶ್ಯಕತೆ

125
00:06:46,750 --> 00:06:48,250
ವೇಳೆ struct ವ್ಯಾಖ್ಯಾನವನ್ನು

126
00:06:48,250 --> 00:06:50,450
ಪುನರಾವರ್ತಿತ ಹೊಂದಿದೆ.

127
00:06:50,450 --> 00:06:52,620
ಉದಾಹರಣೆಗೆ,

128
00:06:52,620 --> 00:06:56,140
ರೀತಿಯ ಡೆಫ್ struct ನೋಡ್

129
00:06:56,140 --> 00:07:01,200
ಮತ್ತು ಇದು ಒಂದು ಇಂಟ್ Val ವ್ಯಾಖ್ಯಾನಿಸಲಾಯಿತು

130
00:07:01,200 --> 00:07:05,420
ಮತ್ತು ಇನ್ನೊಂದು struct ನೋಡ್ ಸೂಚಿತವಾಗಿರುತ್ತದೆ ಒಂದು ಪಾಯಿಂಟರ್ ಹೊಂದಿರುತ್ತದೆ.,

131
00:07:05,420 --> 00:07:09,490
* ಮುಂದಿನ struct ನೋಡ್ನಲ್ಲಿ ಮಾಹಿತಿ.

132
00:07:09,490 --> 00:07:13,670
ನಂತರ ನಾವು ನೋಡ್ ಕರೆ ಮಾಡುತ್ತೇವೆ.

133
00:07:15,490 --> 00:07:18,020
ಈ struct, ಪುನರಾವರ್ತಿತ ಆಗಿದೆ

134
00:07:18,020 --> 00:07:21,450
struct ನೋಡ್ ವ್ಯಾಖ್ಯಾನವನ್ನು ಇದು ಒಳಗೆ ಒಳಗೊಂಡಿರುತ್ತದೆ

135
00:07:21,450 --> 00:07:24,200
ಒಂದು struct ನೋಡ್ಗೆ ಒಂದು ಪಾಯಿಂಟರ್.

136
00:07:24,200 --> 00:07:27,740
ನಾವು struct ನೋಡ್ * ಮುಂದಿನ ಹೇಳಬೇಕೆಂದು ಗಮನಿಸಿ

137
00:07:27,740 --> 00:07:30,690
struct ನೋಡ್ ವ್ಯಾಖ್ಯಾನದ ಒಳಗೆ,

138
00:07:30,690 --> 00:07:33,620
ರೀತಿಯ ಡೆಫ್ ಅವಕಾಶ ಇನ್ನೂ ಮುಗಿದ ಕಾರಣ ಈ ಸರಳಗೊಳಿಸುವ

139
00:07:33,620 --> 00:07:36,210
ಕೇವಲ ನೋಡ್ * ಮುಂದೆ.

140
00:07:36,210 --> 00:07:39,260
ಈ ರೀತಿಯ ಸ್ಟ್ರಕ್ಟ್ಸ್ಳ ಬಗ್ಗೆ ಕಲಿಯೋಣ

141
00:07:39,260 --> 00:07:41,750
ಆಗ ಲಿಂಕ್ ಪಟ್ಟಿಗಳನ್ನು ಮತ್ತು ಮರಗಳು ವ್ಯವಹರಿಸುತ್ತದೆ.

142
00:07:41,750 --> 00:07:44,130
ಒಂದು ಕಾರ್ಯದಲ್ಲಿ ಸ್ಟ್ರಕ್ಟ್ಸ್ಳ ಬಗ್ಗೆ ಏನು?

143
00:07:44,130 --> 00:07:46,800
ಇದು ಸಂಪೂರ್ಣವಾಗಿ ಮಾನ್ಯವಾಗಿಲ್ಲ.

144
00:07:46,800 --> 00:07:49,430
ನಾವು ತೋರಿಸಬಹುದಿತ್ತು

145
00:07:49,430 --> 00:07:53,630
func ಶೂನ್ಯವಾಗುವ

146
00:07:53,630 --> 00:07:55,930
ಇದು, ಒಂದು ಚರ್ಚೆಯಂತೆ ತೆಗೆದುಕೊಳ್ಳುತ್ತದೆ

147
00:07:55,930 --> 00:07:59,590
ವಿದ್ಯಾರ್ಥಿ ರು

148
00:07:59,590 --> 00:08:02,790
ಮತ್ತು ವಿದ್ಯಾರ್ಥಿಗಳ ಜೊತೆ ಏನೋ ಮಾಡುತ್ತದೆ.

149
00:08:05,270 --> 00:08:08,450
ನಂತರ ನಾವು ಹಾಗೆ ವಿದ್ಯಾರ್ಥಿ struct ಮಾಹಿತಿ ಸರಿಸುತ್ತದೆ.

150
00:08:08,450 --> 00:08:12,850
ಮೊದಲು S1 ಆಫ್ Func.

151
00:08:12,850 --> 00:08:15,230
struct ವರ್ತಿಸುತ್ತದೆ

152
00:08:15,230 --> 00:08:18,460
ಒಂದು ಪೂರ್ಣಾಂಕ ಒಂದು ಫಂಕ್ಷನ್ ರವಾನಿಸಲಾಗಿದೆ ಮಾಡುತ್ತವೆ ನಿಖರವಾಗಿ ಮಾಹಿತಿ.

153
00:08:18,460 --> 00:08:21,510
Func S1 ಪ್ರತಿಯನ್ನು ಪಡೆಯುತ್ತದೆ

154
00:08:21,510 --> 00:08:23,690
ಮತ್ತು ಆದ್ದರಿಂದ S1 ಮಾರ್ಪಡಿಸಲು ಸಾಧ್ಯವಿಲ್ಲ;

155
00:08:23,690 --> 00:08:27,110
ಬದಲಿಗೆ, ಎಸ್ ಅದನ್ನು ಕೇವಲ ಪ್ರತಿಯನ್ನು ಸಂಗ್ರಹಿಸಲಾಗಿದೆ ಎಂದು

156
00:08:27,110 --> 00:08:30,010
ನೀವು ಬಯಸಿದರೆ ಕಾರ್ಯ S1 ಮಾರ್ಪಡಿಸಲು ಸಾಧ್ಯವಾಗುತ್ತದೆ, ಗೆ

157
00:08:30,010 --> 00:08:33,000
func, ವಿದ್ಯಾರ್ಥಿ * ಎಸ್ ತೆಗೆದುಕೊಳ್ಳಬಹುದು

158
00:08:33,000 --> 00:08:36,570
ಮತ್ತು ನೀವು ಹಾಗೆ ವಿಳಾಸಕ್ಕೆ ಅದಕ್ಕೆ S1 ಹಾದು ಮಾಡಬೇಕಾಗಬಹುದು.

159
00:08:37,549 --> 00:08:41,100
ವಿದ್ಯಾರ್ಥಿ * ಎಸ್, func & S1.

160
00:08:41,100 --> 00:08:44,760
ಇಲ್ಲಿ ವಿಳಾಸಕ್ಕೆ ಮೂಲಕ ಹಾದು ಮತ್ತೊಂದು ಕಾರಣಗಳಿವೆ.

161
00:08:44,760 --> 00:08:48,030
ನಮ್ಮ struct 100 ಜಾಗ ಹೊಂದಿತ್ತು ಯಾವ ವೇಳೆ?

162
00:08:48,030 --> 00:08:51,250
ನಾವು func ಒಂದು ವಿದ್ಯಾರ್ಥಿ ಪಾಸ್ ಪ್ರತಿಯೊಂದು ಸಮಯ,

163
00:08:51,250 --> 00:08:55,770
ನಮ್ಮ ಪ್ರೋಗ್ರಾಂ, func ವಾದವನ್ನು ಎಸ್ ಇಂತಹ 100 ಜಾಗ ಎಲ್ಲಾ ನಕಲಿಸಿ ಅಗತ್ಯವಿದೆ

164
00:08:55,770 --> 00:08:59,320
ಸಹ ಅದನ್ನು ಅವುಗಳಲ್ಲಿ ಬಹುಪಾಲು ಎಂದಿಗೂ ಬಳಸುವುದಿಲ್ಲ.

165
00:08:59,320 --> 00:09:02,700
Func ವಿದ್ಯಾರ್ಥಿ ಮಾರ್ಪಡಿಸುವ ಯೋಜನೆ ಇಲ್ಲ ಹಾಗಾಗಿ,

166
00:09:02,700 --> 00:09:05,170
ಇನ್ನೂ ವಿಳಾಸಕ್ಕೆ ಮೂಲಕ ಹಾದುಹೋಗಲು ಬೆಲೆಬಾಳುತ್ತದೆ ವೇಳೆ.

167
00:09:05,170 --> 00:09:08,990
ಸರಿ, ನಾವು struct ಒಂದು ಪಾಯಿಂಟರ್ ರಚಿಸಲು ಬಯಸಿದರೆ ಏನು?

168
00:09:08,990 --> 00:09:11,130
ನಾವು ಏನನ್ನಾದರೂ ಮಾಡಬಹುದು

169
00:09:11,130 --> 00:09:17,580
ವಿದ್ಯಾರ್ಥಿ * ಎಸ್

170
00:09:17,580 --> 00:09:20,980
malloc ಸಮನಾಗಿರುತ್ತದೆ

171
00:09:20,980 --> 00:09:26,600
ವಿದ್ಯಾರ್ಥಿ ಗಾತ್ರವನ್ನು.

172
00:09:30,450 --> 00:09:33,590
ಈಗಲೂ ಇಲ್ಲಿ ಕೆಲಸ ಆ ಗಾತ್ರವನ್ನು ಗಮನಿಸಿ.

173
00:09:33,590 --> 00:09:37,260
ಆದ್ದರಿಂದ ನಾವು ಈಗ ವಯಸ್ಸು ಸದಸ್ಯ ಪ್ರವೇಶ ಇಲ್ಲ

174
00:09:37,260 --> 00:09:39,640
ಬ್ಲಾಕ್ನ ಎಸ್ ಅಂಕಗಳನ್ನು ಎಂದು?

175
00:09:39,640 --> 00:09:42,300
ನೀವು ಮೊದಲ ಮಾಡಲು ಭಾವಿಸುತ್ತೇನೆ ಇರಬಹುದು

176
00:09:42,300 --> 00:09:47,970
* S.age = 4,

177
00:09:47,970 --> 00:09:50,220
ಆದರೆ ಈ ಸಾಕಷ್ಟು ಕೆಲಸ ಮಾಡುವುದಿಲ್ಲ.

178
00:09:50,220 --> 00:09:52,940
ಈ ನಿಜವಾಗಿಯೂ ಸೂಚಿಸಲು ಕಾರಣ

179
00:09:52,940 --> 00:09:57,740
ಆವರಣ = 4 * S.age,

180
00:09:57,740 --> 00:10:00,160
ಇದು ಸಹ, ಕಂಪೈಲ್ ಆಗುವುದಿಲ್ಲ

181
00:10:00,160 --> 00:10:03,600
ಎಸ್ ಒಂದು struct ಒಂದು struct ಅಥವಾ ಬದಲಿಗೆ ಪಾಯಿಂಟರ್ ಕಾರಣ,

182
00:10:03,600 --> 00:10:06,270
ಮತ್ತು ಆದ್ದರಿಂದ ಡಾಟ್ ಇಲ್ಲಿ ಕೆಲಸ ಮಾಡುವುದಿಲ್ಲ.

183
00:10:06,270 --> 00:10:08,860
ನಾವು ಮಾಡಬಹುದಾದ

184
00:10:08,860 --> 00:10:13,760
(* ಎಸ್). ವಯಸ್ಸು = 4

185
00:10:13,760 --> 00:10:16,790
ಆದರೆ ಆವರಣ ಕಿರಿಕಿರಿ ಮತ್ತು ಗೊಂದಲಮಯ ಪಡೆಯುವುದು.

186
00:10:16,790 --> 00:10:19,880
Thankfully, ನಾವು ಒಂದು ವಿಶೇಷ ಬಾಣದ ಆಯೋಜಕರು ಹೊಂದಿವೆ

187
00:10:19,880 --> 00:10:22,350
ವಿಷಯ ತೋರುತ್ತಿದೆ

188
00:10:22,350 --> 00:10:28,860
ಎಸ್> ವಯಸ್ಸು = 4.

189
00:10:28,860 --> 00:10:31,600
ವಯಸ್ಸು ಉಲ್ಲೇಖಗಳನ್ನು ಈ 2 ರೀತಿಯಲ್ಲಿ

190
00:10:31,600 --> 00:10:33,270
ಸಮನಾಗಿದೆ

191
00:10:33,270 --> 00:10:36,870
ಮತ್ತು ನಾವು ಎಂದಿಗೂ, ಬಾಣದ ಆಯೋಜಕರು ಅಗತ್ಯವಿಲ್ಲ

192
00:10:36,870 --> 00:10:39,300
ಆದರೆ ವಿಷಯಗಳನ್ನು ಒಳ್ಳೆಯದೆಂದು ಕಾಣುವಂತೆ ಮಾಡುತ್ತದೆ.

193
00:10:39,300 --> 00:10:43,050
ಎಸ್ struct ಹೊಂದಿರುವ ಮೆಮೊರಿ ಕೆಲವು ಬ್ಲಾಕ್ಗೆ ಒಂದು ಪಾಯಿಂಟರ್ ಏಕೆಂದರೆ,

194
00:10:43,050 --> 00:10:47,820
ಪಾಯಿಂಟರ್ ಬಾಣದ ಅನುಸರಿಸಲು ನೀವು ಎಸ್> ವಯಸ್ಸು ನಗರದ

195
00:10:47,820 --> 00:10:50,250
ಮತ್ತು ವಯಸ್ಸಿನ ಸದಸ್ಯ ಕೀಳುತ್ತಾರೆ.

196
00:10:50,250 --> 00:10:53,750
ಆದ್ದರಿಂದ ನಾವು ಸ್ಟ್ರಕ್ಟ್ಸ್ಳ ಬಳಸಬೇಕು?

197
00:10:53,750 --> 00:10:57,560
ಇದು, ಕೇವಲ ಪ್ರಾಚೀನ ಪೂರ್ಣಾಂಕಗಳ ಹೊರಗೆ ಪಡೆಯಲು ಖಂಡಿತವಾಗಿಯೂ ಸಾಧ್ಯತೆಯೂ

198
00:10:57,560 --> 00:10:59,050
ಅಕ್ಷರಗಳು, ಪಾಯಿಂಟರ್ಸ್ ಮತ್ತು ಹಾಗೆ

199
00:10:59,050 --> 00:11:01,550
ನಾವು ಬಳಸುವ ನೀವು;

200
00:11:01,550 --> 00:11:03,340
ಬದಲಿಗೆ ಎಸ್ 1 ಮತ್ತು ಎಸ್ 2 ಮುಂಚೆ,

201
00:11:03,340 --> 00:11:06,290
ನಾವು age1, age2, NAME1, ಮತ್ತು NAME2 ಹೊಂದಿದ್ದವು ಸಾಧ್ಯವಾಗಲಿಲ್ಲ

202
00:11:06,290 --> 00:11:09,120
ಪ್ರತ್ಯೇಕ ಅಸ್ಥಿರ ಎಲ್ಲಾ.

203
00:11:09,120 --> 00:11:11,390
ಇದು ಕೇವಲ 2 ವಿದ್ಯಾರ್ಥಿಗಳು ಉತ್ತಮವಾಗಿದೆ

204
00:11:11,390 --> 00:11:13,310
ಆದರೆ ನಾವು ಅವರಲ್ಲಿ 10 ಹೊಂದಿದ್ದರೆ?

205
00:11:13,310 --> 00:11:15,540
ಮತ್ತು ಯಾವ ವೇಳೆ ಬದಲು ಕೇವಲ 2 ಜಾಗ,

206
00:11:15,540 --> 00:11:17,720
ವಿದ್ಯಾರ್ಥಿ struct 100 ಜಾಗ ಹೊಂದಿತ್ತು?

207
00:11:17,720 --> 00:11:21,240
GPa, ಶಿಕ್ಷಣ, ಕೂದಲು ಬಣ್ಣ, ಲಿಂಗ, ಹೀಗೆ.

208
00:11:21,240 --> 00:11:25,790
ಬದಲಿಗೆ ಕೇವಲ 10 ಸ್ಟ್ರಕ್ಟ್ಸ್ಳ, ನಾವು 1,000 ಪ್ರತ್ಯೇಕ ಅಸ್ಥಿರ ಅಗತ್ಯವಿದೆ.

209
00:11:25,790 --> 00:11:28,360
ಅಲ್ಲದೆ, ಒಂದು ಕಾರ್ಯವನ್ನು ಪರಿಗಣಿಸಿ

210
00:11:28,360 --> 00:11:32,270
ಅದರ ಏಕೈಕ ವಾದವನ್ನು 100 ಜಾಗ ಆ struct ತೆಗೆದುಕೊಳ್ಳುತ್ತದೆ

211
00:11:32,270 --> 00:11:34,350
ಮತ್ತು ಎಲ್ಲಾ ಜಾಗ ಔಟ್ ಮುದ್ರಿಸುತ್ತದೆ.

212
00:11:34,350 --> 00:11:36,320
ನಾವು struct ಬಳಸಲು ಇದ್ದರೆ,

213
00:11:36,320 --> 00:11:38,540
ನಾವು, ಆ ಕ್ರಿಯೆ ಕರೆ ಪ್ರತಿಯೊಂದು ಸಮಯ

214
00:11:38,540 --> 00:11:41,460
ನಾವು, ಎಲ್ಲಾ 100 ಅಸ್ಥಿರ ನಲ್ಲಿ ಪಾಸ್ ಅಗತ್ಯವಿದೆ

215
00:11:41,460 --> 00:11:44,430
ನಾವು ವಿದ್ಯಾರ್ಥಿ 1 100 ಅಸ್ಥಿರ ಹೊಂದಿದ್ದರೆ,

216
00:11:44,430 --> 00:11:47,020
ಮತ್ತು 100 ವಿದ್ಯಾರ್ಥಿ 2 ಚರಾಂಕಗಳ

217
00:11:47,020 --> 00:11:50,540
ನಾವು ಆಕಸ್ಮಿಕವಾಗಿ ವಿದ್ಯಾರ್ಥಿ 1 ಕೆಲವು ಅಸ್ಥಿರ ತೇರ್ಗಡೆಹೊಂದಿಲ್ಲ ಮರೆಯಬೇಡಿ ಅಗತ್ಯವಿದೆ

218
00:11:50,540 --> 00:11:52,910
ಮತ್ತು ವಿದ್ಯಾರ್ಥಿ 2 ಕೆಲವು ಅಸ್ಥಿರ.

219
00:11:52,910 --> 00:11:55,710
ಇದು, ಒಂದು struct ಆ ತಪ್ಪು ಮಾಡಲು ಅಸಾಧ್ಯ

220
00:11:55,710 --> 00:11:59,010
ಎಲ್ಲಾ 100 ಚರಾಂಕಗಳ ಒಂದೇ ಪ್ಯಾಕೇಜ್ ಒಳಗೊಂಡಿರುವ ಕಾರಣ.

221
00:11:59,010 --> 00:12:02,050
ಅಂತಿಮ ಟಿಪ್ಪಣಿಗಳನ್ನು ಕೇವಲ ಒಂದೆರಡು:

222
00:12:02,050 --> 00:12:04,870
ಈ ಹಂತದಲ್ಲಿ ಎಲ್ಲವನ್ನೂ ಅಪ್, ಮಹಾನ್ ಅರ್ಥ ನೀವು.

223
00:12:04,870 --> 00:12:07,900
ವೀಡಿಯೊ ಉಳಿದ ಕೇವಲ ಕಂಪ್ಲೀಟ್ನೆಸ್ 'ಸಲುವಾಗಿಯೇ.

224
00:12:07,900 --> 00:12:11,010
ಸ್ಟ್ರಕ್ಟ್ಸ್ಳ ಪಾಯಿಂಟರ್ ಯಾವುದೇ ರೀತಿಯ ಹಿಡಿಸುತ್ತದೆ ಏಕೆಂದರೆ,

225
00:12:11,010 --> 00:12:14,220
ಅವರು ಕಾರ್ಯ ಪಾಯಿಂಟರ್ಸ್ ಹಿಡಿಸುತ್ತದೆ.

226
00:12:14,220 --> 00:12:17,040
ನೀವು ವಸ್ತು ಆಧಾರಿತ ಪ್ರೊಗ್ರಾಮಿಂಗ್ ಪರಿಚಿತವಾಗಿರುವ ನೀವು,

227
00:12:17,040 --> 00:12:21,790
ಈ ವಸ್ತು ಆಧಾರಿತ ಶೈಲಿಯಲ್ಲಿ ಪ್ರೋಗ್ರಾಂಗೆ ಸ್ಟ್ರಕ್ಟ್ಸ್ಳ ಬಳಸಲು ಒಂದು ರೀತಿಯಲ್ಲಿ ಒದಗಿಸುತ್ತದೆ.

228
00:12:21,790 --> 00:12:24,500
ಮತ್ತೊಂದು ಸಮಯದಲ್ಲಿ ಕಾರ್ಯವನ್ನು ಪಾಯಿಂಟರ್ಸ್ ಹೆಚ್ಚು.

229
00:12:24,500 --> 00:12:27,760
ಕೂಡ, ಕೆಲವೊಮ್ಮೆ ನೀವು 2 ಸ್ಟ್ರಕ್ಟ್ಸ್ಳ ಹೊಂದಿರಬಹುದು

230
00:12:27,760 --> 00:12:30,220
ಇವುಗಳ ವ್ಯಾಖ್ಯಾನಗಳು ಪರಸ್ಪರ ಅವಲಂಬಿಸಿರುತ್ತವೆ.

231
00:12:30,220 --> 00:12:32,320
ಉದಾಹರಣೆಗೆ,

232
00:12:32,320 --> 00:12:35,470
ನಾವು, struct ಎ ತೋರಿಸಬಹುದಿತ್ತು

233
00:12:35,470 --> 00:12:38,580
ಇದು ವ್ಯಾಖ್ಯಾನಿಸಲಾಗಿದೆ

234
00:12:38,580 --> 00:12:41,910
ಒಂದು struct ಬಿ ಒಂದು ಪಾಯಿಂಟರ್,

235
00:12:41,910 --> 00:12:47,180
struct ಬಿ * ಎಕ್ಸ್,

236
00:12:47,180 --> 00:12:50,470
ಮತ್ತು ಈಗ ನಾವು struct ಬಿ ಹೊಂದಬಹುದು

237
00:12:53,890 --> 00:12:56,280
ಒಂದು ಪಾಯಿಂಟರ್ ವ್ಯಾಖ್ಯಾನಿಸಲಾಗಿದೆ

238
00:12:56,280 --> 00:12:59,180
ಒಂದು struct ಎ, ಗೆ

239
00:12:59,180 --> 00:13:03,640
struct ಎ * ವೈ

240
00:13:07,230 --> 00:13:09,060
ಆದರೆ, ಕಂಪೈಲ್ ಆಗುವುದಿಲ್ಲ

241
00:13:09,060 --> 00:13:14,110
struct ಬಿ struct ಒಂದು ಸಂಕಲಿಸಿದ ಎಂದು ಸಮಯದಲ್ಲಿ ಅಸ್ತಿತ್ವದಲ್ಲಿಲ್ಲ ರಿಂದ.

242
00:13:14,110 --> 00:13:17,600
ಮತ್ತು ನಾವು struct ಎ ಮತ್ತು struct ಸ್ವ್ಯಾಪ್ ವೇಳೆ ಬಿ,

243
00:13:17,600 --> 00:13:20,100
ನಂತರ ನಾವು ಅದೇ ಸಮಸ್ಯೆಯನ್ನು ಬಿಟ್ಟು ಎಂದೆನಿಸಿತ್ತು;

244
00:13:20,100 --> 00:13:22,640
ಈ ಸಮಯದಲ್ಲಿ, ಒಂದು ಅಸ್ತಿತ್ವದಲ್ಲಿರುವ ಅಲ್ಲ struct.

245
00:13:22,640 --> 00:13:24,720
ಈ ಪರಿಹರಿಸಲು ನಾವು ಬರೆಯಬಹುದು

246
00:13:24,720 --> 00:13:29,290
struct ಬಿ;

247
00:13:29,290 --> 00:13:32,460
struct ಎ ವ್ಯಾಖ್ಯಾನವನ್ನು ಮೊದಲು

248
00:13:32,460 --> 00:13:35,590
ಇದು ಮುಂದೆ ಘೋಷಣೆ ಕರೆಯಲಾಗುತ್ತದೆ.

249
00:13:35,590 --> 00:13:38,590
ಈ ಕೇವಲ ಕಂಪೈಲರ್ ತಿಳಿದಿರುವ ಅನುಮತಿಸುತ್ತದೆ

250
00:13:38,590 --> 00:13:42,040
struct ಬಿ ಸಂಪೂರ್ಣವಾಗಿ ನಂತರ ಅಥವಾ ಬೇರೆ ಕಡೆ ವ್ಯಾಖ್ಯಾನಿಸಲಾಗಿದೆ ಎಂದು ಮಾನ್ಯ ವಿಧ.

251
00:13:42,040 --> 00:13:45,980
ನನ್ನ ಹೆಸರನ್ನು ರಾಬ್ ಬೌಡೆನ್ ಆಗಿದೆ, ಮತ್ತು ಈ CS50 ಹೊಂದಿದೆ.

252
00:13:45,980 --> 00:13:48,980
[CS50.TV]