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 struct टाइप करने के लिए जा रहा हूँ
और फिर एक घुंघराले ब्रेस.

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 मिल int के लिए, मैं कम है
कि निरंतर से, मैं + +.

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
दूसरे शब्दों में मैं मैं वें छात्र चाहते हैं
में अब छात्रों को बुलाया सरणी, लेकिन

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
घर, और अब मैं निर्दिष्ट करने के लिए जा रहा हूँ
कि मैं वें छात्रों घर क्षेत्र

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
int के लिए मैं 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 मिल int के लिए, मैं की तुलना में कम है
छात्रों, मैं + +, और शरीर के अंदर

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
बनाने structs 0. / structs 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