1
00:00:00,000 --> 00:00:03,250
>> स्पीकर 1: चलो अब एक प्रोग्राम लिखने दो.
वे सही मायने में दो तार तुलना

2
00:00:03,250 --> 00:00:04,245
चरित्र के लिए चरित्र.

3
00:00:04,245 --> 00:00:06,830
के रूप में 0 तुलना का उपयोग करें
हमारे प्रारंभिक बिंदु.

4
00:00:06,830 --> 00:00:11,550
लेकिन परत वापस की पहली छील कि चलो
स्ट्रिंग प्रकार है और इसे फिर से लिखना

5
00:00:11,550 --> 00:00:14,120
क्या यह सच है के लिए, जो
एक चार सितारा है.

6
00:00:14,120 --> 00:00:17,740
यह एक चरित्र का पता है,
एक में विशेष रूप से पहले चरित्र

7
00:00:17,740 --> 00:00:21,010
हम अधिक था कि पात्रों के अनुक्रम
आम तौर पर एक स्ट्रिंग के रूप में जानते हैं.

8
00:00:21,010 --> 00:00:21,880
>> टी के लिए भी.

9
00:00:21,880 --> 00:00:25,660
चलो कि स्ट्रिंग घोषणा को फिर से लिखना करने दें
चार स्टार के रूप में.

10
00:00:25,660 --> 00:00:28,690
और अब हम जरूरत के लिए अब और नहीं
ऐसा न हो कि, टी के खिलाफ की तुलना

11
00:00:28,690 --> 00:00:30,150
हम दो पते की तुलना करें.

12
00:00:30,150 --> 00:00:33,180
हम वास्तव में तुलना करना चाहते हैं
दो तार खुद को.

13
00:00:33,180 --> 00:00:37,520
ऐसा करने के लिए, हम एक समारोह का उपयोग कर सकते हैं
string.h में घोषित कर दिया.

14
00:00:37,520 --> 00:00:40,920
इसलिए मुझे लगता है कि शामिल जोड़ देंगे
मेरी फ़ाइल के शीर्ष पर.

15
00:00:40,920 --> 00:00:43,130
>> और फिर मैं परिवर्तन करने जा रहा हूँ
यहां इस लाइन.

16
00:00:43,130 --> 00:00:47,920
टी के खिलाफ की तुलना करने के बजाय, मैं हूँ
एक समारोह हलचल कंप्यूटर अनुप्रयोग कॉल करने के लिए जा रहे हैं,

17
00:00:47,920 --> 00:00:52,290
स्ट्रिंग के लिए की तुलना, और पारित
तर्क है और टी के रूप में.

18
00:00:52,290 --> 00:00:56,480
हम करने के लिए तुलना स्ट्रिंग के लिए फिर स्थगित कर देंगे
एस और टी वास्तव में बराबर कर रहे हैं अगर यह पता लगाने

19
00:00:56,480 --> 00:00:59,870
और यह तुलना करने के लिए बाहर आंकड़ा कैसे करते हैं
किरदार के लिए उन्हें चरित्र.

20
00:00:59,870 --> 00:01:02,410
>> अब, प्रलेखन के अनुसार
स्ट्रिंग तुलना के लिए, यह वास्तव में है

21
00:01:02,410 --> 00:01:06,920
0 वापसी करने जा रही है यदि दो स्ट्रिंग्स
एस और टी वही कर रहे हैं के द्वारा पर बताया.

22
00:01:06,920 --> 00:01:09,490
यह एक नकारात्मक संख्या में वापसी करने जा रहा है
एस टी से पहले आ जाना चाहिए अगर

23
00:01:09,490 --> 00:01:13,740
वर्णानुक्रम या एक सकारात्मक संख्या अगर
एस वर्णानुक्रम टी के बाद आना चाहिए.

24
00:01:13,740 --> 00:01:16,090
>> लेकिन अब के लिए, हम केवल परवाह
समानता के बारे में.

25
00:01:16,090 --> 00:01:19,270
तो मैं बस का परीक्षण करने जा रहा हूँ अगर
स्ट्रिंग की वापसी मूल्य तुलना

26
00:01:19,270 --> 00:01:21,450
एस और टी में गुजर, 0 के बराबर होती है.

27
00:01:21,450 --> 00:01:24,940
और अगर ऐसा है, मैं दावा करने के लिए जा रहा हूँ कि
दो स्ट्रिंग्स समान हैं.

28
00:01:24,940 --> 00:01:26,820
>> लेकिन मैं एक बनाने के लिए जा रहा हूँ
अन्य परिवर्तन के रूप में अच्छी तरह से.

29
00:01:26,820 --> 00:01:30,410
यह अपने प्रति, उस पाने स्ट्रिंग पता चला है
प्रलेखन, कभी कभी लौट सकते हैं

30
00:01:30,410 --> 00:01:34,320
अनुसार कि, अशक्त, एक प्रहरी मूल्य
तार प्रलेखन, साधन प्राप्त करने के लिए

31
00:01:34,320 --> 00:01:35,450
कुछ बुरा हुआ.

32
00:01:35,450 --> 00:01:38,830
उदाहरण के लिए, हम स्मृति से बाहर भाग गया या
उपयोगकर्ता किसी भी तरह से सहयोग नहीं मिला.

33
00:01:38,830 --> 00:01:41,080
>> स्ट्रिंग, इस बीच तुलना
एक छोटी सी कमजोर है.

34
00:01:41,080 --> 00:01:44,730
आप यह शून्य या तो अपने लिए पारित
पहले या उसके दूसरा तर्क, बुरा

35
00:01:44,730 --> 00:01:45,650
बातें हो सकता है.

36
00:01:45,650 --> 00:01:47,970
आमतौर पर शामिल बुरी बातें
विभाजन दोष.

37
00:01:47,970 --> 00:01:52,210
तो कुल मिलाकर कि संभावित से बचने के लिए,
मैं पहली बार इस प्रयोग की रैप करने के लिए जा रहा हूँ

38
00:01:52,210 --> 00:01:56,350
इस पूरे इंडेंट करके तुलना स्ट्रिंग
कोड और पहले ही कर के ब्लॉक

39
00:01:56,350 --> 00:02:03,140
कि अशक्त करने के बराबर नहीं है
और टी अशक्त करने के बराबर नहीं है.

40
00:02:03,140 --> 00:02:08,280
>> और अगर है कि मैं निर्माण कि रैपिंग
घुंघराले ब्रेसिज़ के रूप में साथ पहले टाइप किया

41
00:02:08,280 --> 00:02:12,270
ठीक है, मैं इतना है कि केवल स्पर्श इस समय
एस और टी मैं निश्चित है कि हूँ अगर

42
00:02:12,270 --> 00:02:13,450
वे रिक्त नहीं हैं.

43
00:02:13,450 --> 00:02:17,220
चलो अब, को बचाने के संकलन करते हैं, और
इस कार्यक्रम को फिर से चलाने.

44
00:02:17,220 --> 00:02:22,240
>> 1 तुलना 1 डॉट स्लेश तुलना करें.

45
00:02:22,240 --> 00:02:23,950
मैं फिर से नमस्कार कहता हूँ.

46
00:02:23,950 --> 00:02:25,890
नमस्ते एक बार फिर से पालन किया.

47
00:02:25,890 --> 00:02:28,110
और इस बार, मैं वास्तव में
एक ही बात लिखें.

48
00:02:28,110 --> 00:02:30,255