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
અન્ય ચાવીરૂપ શબ્દ સ્ટ્રક્ટ.

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 સ્ટ્રક્ટ લખો જાઉં છું
અને પછી એક સર્પાકાર તાણવું.

20
00:00:57,640 --> 00:01:01,370
સ્ટ્રક્ટ અંદર, હું જાઉં છું
એક વિદ્યાર્થી રહેશે કે સ્પષ્ટ કરવા માટે

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
boilerplate કોડ છે, અને હવે હું છું
આ માહિતી ઉપયોગ જઈ

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
હું કે હું મી વિદ્યાર્થી પર વિચાર કરવા માંગો છો
નામ આપો, અને આ કરવા માટે, હું વાપરવા માટે જાઉં છું

49
00:02:25,340 --> 00:02:30,160
પાંચ. ઓપરેટર, એક પર વિચાર કરવા માટે
સ્ટ્રક્ટ ચોક્કસ ક્ષેત્ર અંદર.

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
ઘર, અને હવે હું સ્પષ્ટ કરવા માટે જઈ રહ્યો છું
કે-i મી વિદ્યાર્થીઓ ઘર ક્ષેત્ર

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 માં છે.

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