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
તેથી, અમે કહીએ છીએ સ્ટ્રક્ટ,

6
00:00:20,030 --> 00:00:23,340
પછી સર્પાકાર તાણવું ખોલીને,

7
00:00:23,340 --> 00:00:26,630
અને આ સ્ટ્રક્ટ માં, અમે પૂર્ણાંક વય પડશે,

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
કોઈપણ માન્ય પ્રકાર સ્ટ્રક્ટ વ્યાખ્યા અંદર જઈ શકો છો.

13
00:00:46,270 --> 00:00:49,530
અહીં, અમે પૂર્ણાંક અને કોલસો બનાવો * ઉપયોગ કર્યો છે,

14
00:00:49,530 --> 00:00:52,610
પરંતુ તમે પણ એરે ઉપયોગ કરી શકે કહે છે, 100 તત્વો

15
00:00:52,610 --> 00:00:54,910
અથવા તો અન્ય સ્ટ્રક્ટ.

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
આપણે પાછળથી જોશો, એક સ્ટ્રક્ટ પ્રકાર

22
00:01:07,400 --> 00:01:10,700
બીજા કોઈપણ પ્રકારની તમે ઉપયોગ કરી રહ્યાં છો સમકક્ષ ઘણી બધી રીતે છે.

23
00:01:10,700 --> 00:01:13,310
સામાન્ય રીતે, હું સ્ટ્રક્ટ કેવી રીતે પ્રકાર તુલના કરવામાં આવશે

24
00:01:13,310 --> 00:01:15,790
પૂર્ણાંક પ્રકાર જેવી જ છે.

25
00:01:15,790 --> 00:01:18,520
જ્યારે કોડ અમે લખ્યું માન્ય સી છે,

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
આ સ્ટ્રક્ટ દ્વારા આપવામાં પ્રકાર છે.

37
00:01:53,980 --> 00:01:56,730
અમે સ્ટ્રક્ટ અંદર ચલો સાથે કેવી રીતે મેળવી શકું?

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
એક વિદ્યાર્થી સ્ટ્રક્ટ કોઈપણ ચોક્કસ સભ્ય ઍક્સેસ કરવા માટે,

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
તમારા સ્ટ્રક્ટ અનામિક રહી છે.

58
00:03:00,950 --> 00:03:02,290
અમે તેને એક નામ આપો જરૂર છે.

59
00:03:02,290 --> 00:03:04,420
કે કરવા માટે, અમે સ્ટ્રક્ટ નું નામ દાખલ કરો

60
00:03:04,420 --> 00:03:06,950
શબ્દ સ્ટ્રક્ટ પછી.

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
વિદ્યાર્થી સ્ટ્રક્ટ, જેમ કે અમારી પહેલાં હતી.

65
00:03:24,320 --> 00:03:28,360
અમે તેના એસ 1 કૉલ પડશે

66
00:03:28,590 --> 00:03:30,760
આ સ્ટ્રક્ટ એક નામ આપીને,

67
00:03:30,760 --> 00:03:33,050
આપણે હવે સ્ટ્રક્ટ વિદ્યાર્થી ઉપયોગ કરી શકો છો

68
00:03:33,050 --> 00:03:36,950
લગભગ ચોક્કસ જ રીતે અમે પૂર્ણાંક ઉપયોગ કરશે.

69
00:03:36,950 --> 00:03:39,580
તેથી અમે પ્રકાર સ્ટ્રક્ટ વિદ્યાર્થી ચલ જાહેર કરી શકે છે,

70
00:03:39,580 --> 00:03:42,360
સમાન

71
00:03:42,360 --> 00:03:49,500
સ્ટ્રક્ટ વિદ્યાર્થી S2.

72
00:03:51,020 --> 00:03:55,130
એરે જેમ, સ્ટ્ર્ક્ટ્સ એક શૉર્ટકટ આરંભ વાક્યરચના પૂરી પાડે છે,

73
00:03:55,130 --> 00:03:58,670
તેથી, અમે કહીએ છીએ, વિદ્યાર્થી S2 સ્ટ્રક્ટ કરી શકો છો

74
00:03:58,670 --> 00:04:01,420
સમકક્ષ

75
00:04:01,420 --> 00:04:06,040
ડાબી સર્પાકાર 3 તાણવું, S2.

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
અને તેમાંના મોટા ભાગના તમે સ્ટ્રક્ટ વિદ્યાર્થી પ્રકાર સાથે કરી શકો છો.

80
00:04:22,460 --> 00:04:26,060
અમે કાર્ય પરિમાણ એક પ્રકાર તરીકે સ્ટ્રક્ટ વિદ્યાર્થી વાપરી શકો છો.

81
00:04:26,060 --> 00:04:28,790
અમે હવે એક નવો સ્ટ્રક્ટ ની અંદર સ્ટ્રક્ટ વિદ્યાર્થી વાપરી શકો છો.

82
00:04:28,790 --> 00:04:31,010
અમે સ્ટ્રક્ટ વિદ્યાર્થી માટે નિર્દેશક હોઈ શકે છે.

83
00:04:31,010 --> 00:04:33,540
અમે સ્ટ્રક્ટ વિદ્યાર્થી કદ કરી શકો છો.

84
00:04:33,540 --> 00:04:35,510
સ્ટ્રક્ટ વિદ્યાર્થી એક પ્રકાર છે

85
00:04:35,510 --> 00:04:38,030
પૂર્ણાંક જેમ જ એક પ્રકાર છે.

86
00:04:38,030 --> 00:04:40,540
અમે પણ S2 માટે S1 સોંપી શકો છો

87
00:04:40,540 --> 00:04:43,760
કારણ કે બંને એક જ પ્રકારનો હોય છે, તેથી અમે શું કરી શકો છો

88
00:04:44,390 --> 00:04:47,540
S1 = S2.

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
જો અમે કેટલીક પૂર્ણાંક વાય કેટલાક પૂર્ણાંક X સોંપવા માટે,

94
00:05:05,590 --> 00:05:08,970
X = વાય જેમ

95
00:05:08,970 --> 00:05:10,850
અને પછી X બદલવા માટે,

96
00:05:10,850 --> 00:05:14,230
માં X + +,

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
પરંતુ નોંધ જ્યારે અન્ય એક સ્ટ્રક્ટ સોંપણી કે,

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
તે માટે સ્ટ્રક્ટ વિદ્યાર્થી સર્વત્ર લખી છે નકામી હોઈ શકે છે.

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
સ્ટ્રક્ટ

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
કે અમે સ્ટ્રક્ટ વિદ્યાર્થી ઉપયોગ વપરાય છે.

114
00:06:11,090 --> 00:06:13,410
આ પ્રકારની ડેફ એક અનામી સ્ટ્રક્ટ છે

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
આગામી શબ્દ સ્ટ્રક્ટ છે, typedef સ્ટ્રક્ટ વિદ્યાર્થી છે,

118
00:06:27,670 --> 00:06:31,590
અમે બંને સ્ટ્રક્ટ વિદ્યાર્થી અને વિદ્યાર્થી એકબીજાના હવે ઉપયોગ કરી શકે છે.

119
00:06:31,590 --> 00:06:34,060
તેઓ પણ આ જ નામ છે નથી.

120
00:06:34,060 --> 00:06:36,710
અમે બોબ ડેફ સ્ટ્રક્ટ વિદ્યાર્થી લખો શકે

121
00:06:36,710 --> 00:06:38,950
અને પછી વિદ્યાર્થી અને બોબ સ્ટ્રક્ટ

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
અમે આગામી ઓળખનારનો સ્ટ્રક્ટ જરૂર

125
00:06:46,750 --> 00:06:48,250
જો સ્ટ્રક્ટ ની વ્યાખ્યા

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
પ્રકાર ડેફ સ્ટ્રક્ટ નોડ

129
00:06:56,140 --> 00:07:01,200
અને તે પૂર્ણાંક Val તરીકે વ્યાખ્યાયિત કરવામાં આવશે

130
00:07:01,200 --> 00:07:05,420
અને તે નિર્દેશક કે અન્ય સ્ટ્રક્ટ નોડ નિર્દેશ હોય છે.,

131
00:07:05,420 --> 00:07:09,490
તરીકે સ્ટ્રક્ટ * આગામી નોડ છે.

132
00:07:09,490 --> 00:07:13,670
અને પછી અમે તેને નોડ કહી શકશો.

133
00:07:15,490 --> 00:07:18,020
આ સ્ટ્રક્ટ ફરી યાદ આવવું છે,

134
00:07:18,020 --> 00:07:21,450
ત્યારથી સ્ટ્રક્ટ નોડ વ્યાખ્યા તેની અંદર સમાવે છે

135
00:07:21,450 --> 00:07:24,200
એક સ્ટ્રક્ટ નોડ માટે નિર્દેશક.

136
00:07:24,200 --> 00:07:27,740
નોંધ કરો કે અમે સ્ટ્રક્ટ નોડ આગામી * કહે છે

137
00:07:27,740 --> 00:07:30,690
અંદર સ્ટ્રક્ટ નોડ વ્યાખ્યા છે,

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
અને પછી અમે આની જેમ વિદ્યાર્થી સ્ટ્રક્ટ તરીકે તેને પસાર કરી શકે છે.

150
00:08:08,450 --> 00:08:12,850
પહેલાં S1 ઓફ Func.

151
00:08:12,850 --> 00:08:15,230
આ સ્ટ્રક્ટ વર્તે

152
00:08:15,230 --> 00:08:18,460
બરાબર એક પૂર્ણાંક જ્યારે કાર્ય પસાર કરશે.

153
00:08:18,460 --> 00:08:21,510
Func એસ 1 નકલ મેળવે છે

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
જો તમે ઇચ્છો તો કાર્ય કરવા માટે એસ 1 સંશોધિત કરવાનો પ્રયત્ન કરવા માટે,

157
00:08:30,010 --> 00:08:33,000
func એક વિદ્યાર્થી * એસ લેવાની જરૂર પડશે,

158
00:08:33,000 --> 00:08:36,570
અને તમે આની જેમ સરનામા દ્વારા એસ 1, પાસ હશે.

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
તો શું અમારી સ્ટ્રક્ટ 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
ઠીક છે, જો આપણે એક સ્ટ્રક્ટ માટે નિર્દેશક બનાવવા માંગો છો?

168
00:09:08,990 --> 00:09:11,130
અમે કંઈક જેમ કરી શકે

169
00:09:11,130 --> 00:09:17,580
વિદ્યાર્થી * S

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
કારણ કે એસ એક જગ્યાએ અથવા સ્ટ્રક્ટ એક સ્ટ્રક્ટ માટે નિર્દેશક નથી,

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
પરંતુ તે બનાવે વસ્તુઓ NICER જુઓ.

193
00:10:39,300 --> 00:10:43,050
ત્યારથી એસ મેમરી કેટલાક બ્લોક કે સ્ટ્રક્ટ સમાવે છે એક નિર્દેશક છે,

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 અને S2 પહેલાં એક,

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
વિદ્યાર્થી સ્ટ્રક્ટ 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 ક્ષેત્રો સાથે તેના માત્ર દલીલ સાથે સ્ટ્રક્ટ લે છે

211
00:11:32,270 --> 00:11:34,350
અને બહાર બધા ક્ષેત્રો છાપે છે.

212
00:11:34,350 --> 00:11:36,320
જો આપણે એક સ્ટ્રક્ટ ઉપયોગ નથી કર્યો,

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
અને 2 વિદ્યાર્થી માટે 100 ચલો,

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
તે અશક્ય છે એક સ્ટ્રક્ટ સાથે ભૂલ કરી,

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
અમે સ્ટ્રક્ટ એક હોઇ શકે છે,

233
00:12:35,470 --> 00:12:38,580
જે તરીકે ઓળખવામાં આવે છે

234
00:12:38,580 --> 00:12:41,910
એક સ્ટ્રક્ટ બી એક નિર્દેશક,

235
00:12:41,910 --> 00:12:47,180
સ્ટ્રક્ટ બી * એક્સ,

236
00:12:47,180 --> 00:12:50,470
અને હવે અમે એક સ્ટ્રક્ટ બી હોઈ શકે છે

237
00:12:53,890 --> 00:12:56,280
જે નિર્દેશક તરીકે વ્યાખ્યાયિત કરવામાં આવે છે

238
00:12:56,280 --> 00:12:59,180
એક સ્ટ્રક્ટ એ,

239
00:12:59,180 --> 00:13:03,640
સ્ટ્રક્ટ A * વાય

240
00:13:07,230 --> 00:13:09,060
પરંતુ આ કમ્પાઇલ કરવામાં આવશે,

241
00:13:09,060 --> 00:13:14,110
ત્યારથી સ્ટ્રક્ટ બી સમય કે સ્ટ્રક્ટ એક સંકલિત કરવામાં આવી રહી છે અસ્તિત્વમાં નથી.

242
00:13:14,110 --> 00:13:17,600
અને જો આપણે સ્ટ્રક્ટ એ અને સ્ટ્રક્ટ સ્વેપ બી,

243
00:13:17,600 --> 00:13:20,100
તો પછી અમે માત્ર એ જ સમસ્યા સાથે છોડી હો શકાય છે;

244
00:13:20,100 --> 00:13:22,640
આ સમય સાથે હાલના નથી એ સ્ટ્રક્ટ.

245
00:13:22,640 --> 00:13:24,720
આ ઉકેલવા માટે, અમે લખી શકો છો

246
00:13:24,720 --> 00:13:29,290
સ્ટ્રક્ટ બી;

247
00:13:29,290 --> 00:13:32,460
સ્ટ્રક્ટ એ વ્યાખ્યા પહેલા

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
સ્ટ્રક્ટ બી માન્ય પ્રકાર છે કે જે પૂર્ણપણે પાછળથી અથવા અન્યત્ર વ્યાખ્યાયિત છે.

251
00:13:42,040 --> 00:13:45,980
મારું નામ રોબ બોડેન છે, અને આ CS50 છે.

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