1
00:00:00,000 --> 00:00:00,520

2
00:00:00,520 --> 00:00:03,530
>> காண்க: ஒரு நிரல் எழுத அனுமதி என்று
இரண்டு சரங்களை மற்றும் பயனர் கேட்கிறது

3
00:00:03,530 --> 00:00:07,170
பின்னர் அறிக்கையிடகிறது அந்த சரங்களை என்பதை
அதே அதே அல்லது இல்லை.

4
00:00:07,170 --> 00:00:10,290
நான் ஏற்கனவே எங்களை இங்கு தொடங்கியது
இரண்டு முறை printf அழைப்பு மற்றும் அழைப்பு

5
00:00:10,290 --> 00:00:14,520
திரும்பி சேமித்து, இரண்டு முறை GetString
கள் மற்றும் t மதிப்புகள் முறையே.

6
00:00:14,520 --> 00:00:17,960
>> இப்போது, என் உணர்வுகளை இந்த இரண்டு ஒப்பிட்டு
சரங்களை தெரிந்திருந்தால் பயன்படுத்த வேண்டும்

7
00:00:17,960 --> 00:00:19,160
சமத்துவ ஆபரேட்டர் -

8
00:00:19,160 --> 00:00:22,070
கள் சமம் என்றால் T சமம்.

9
00:00:22,070 --> 00:00:28,120
பின்னர் நான் மேலே மற்றும் அச்சு செல்ல போகிறேன்
வெளியே "நீங்கள் அதே விஷயத்தை தட்டச்சு!

10
00:00:28,120 --> 00:00:35,190
அது உண்மை இல்லை என்றால் வேறு, நான் வெறுமனே இருக்கிறேன்
printf தட்டச்சு போகிறேன் ("நீங்கள் தட்டச்சு

11
00:00:35,190 --> 00:00:37,880
பல்வேறு விஷயங்கள்!

12
00:00:37,880 --> 00:00:38,850
>> மிகவும் நேரடியான -

13
00:00:38,850 --> 00:00:41,820
நான் வெறுமனே எதிராக கள் ஒப்பிட்டு நான்
டி, மற்றும் அவர்கள் சம என்றால்,

14
00:00:41,820 --> 00:00:43,250
எவ்வளவு அச்சிடுகிறது.

15
00:00:43,250 --> 00:00:45,450
இந்த திட்டம் தொகுக்க மற்றும் இயக்க வேண்டும்.

16
00:00:45,450 --> 00:00:51,950
0 ஒப்பிட்டு கொள்ளுங்கள். / ஒப்பிட்டு
0, ஹலோ, ஏதாவது சொல்ல

17
00:00:51,950 --> 00:00:54,200
ஹலோ, ஏதாவது சொல்ல.

18
00:00:54,200 --> 00:00:56,870
>> துரதிருஷ்டவசமாக, திட்டம் நான் நினைக்கிறது
, வேறு விஷயங்களை தட்டச்சு கூட நான்

19
00:00:56,870 --> 00:00:59,530
தெளிவாக "ஹலோ" தட்டச்சு
அதே வழியில் இரண்டு முறை.

20
00:00:59,530 --> 00:01:00,850
இப்போது, ஏன் என்று இருக்கும்?

21
00:01:00,850 --> 00:01:03,750
>> சரி, அது மாறிவிடும் இந்த அனைத்து
நேரம், சரங்களை ஒரு பிட் மேலும் இருந்திருக்கும்

22
00:01:03,750 --> 00:01:06,780
கதாபாத்திரங்கள் ஒரு வரிசை விட சிக்கலான
பேட்டை அடியில்.

23
00:01:06,780 --> 00:01:11,450
உண்மையில், ஒரு சரம் ஒரு சுட்டிக்காட்டி அல்லது ஒரு ஆகிறது
முகவரி, குறிப்பாக முகவரி

24
00:01:11,450 --> 00:01:14,640
என்று முதல் எழுத்து
என்ற தொடர்.

25
00:01:14,640 --> 00:01:18,640
>> எனவே நாம் T எதிராக கள் ஒப்பிடும் போது
சம சம அடையாளம், நாம் இருக்கிறோம்

26
00:01:18,640 --> 00:01:23,200
உண்மையில் கேட்டு, இந்த முகவரி
இந்த முகவரிக்கு சம சம?

27
00:01:23,200 --> 00:01:26,850
அந்த வழக்கை போவதில்லை என்றால்
பயனர் இரு வேறுபட்ட தட்டச்சு

28
00:01:26,850 --> 00:01:30,370
சரங்களை மற்றும் நாம் இரண்டு முறை GetString அழைத்தேன்
அவற்றை பெற, ஏனெனில் நினைவக

29
00:01:30,370 --> 00:01:34,480
என்று GetString முதல் சேமிக்க பயன்படுத்துகிறது
சரம் ரேம் இங்கே இருக்கலாம், ஆனால்

30
00:01:34,480 --> 00:01:37,120
GetString சேமிக்க பயன்படுத்தும் மெமரி
இரண்டாவது சரம் போகிறது

31
00:01:37,120 --> 00:01:38,760
இங்கே ரேம் இருக்கும்.

32
00:01:38,760 --> 00:01:42,380
நிச்சயமாக, பின்னர், அந்த இரண்டு துண்டுகளாக்கி
நினைவகம் வெவ்வேறு முகவரிகளை வேண்டும்

33
00:01:42,380 --> 00:01:44,220
அவர்களது முதல் எழுத்துக்கள்.

34
00:01:44,220 --> 00:01:46,120
>> எனவே சம S T சமமாக இருக்கும்?

35
00:01:46,120 --> 00:01:46,885
சரி, இல்லை.

36
00:01:46,885 --> 00:01:50,510
கள் மற்றும் t வெவ்வேறு சுட்டி என்றால்
அவர்கள் மூலம் இருக்கும் என நினைவகம் துண்டுகளாக்கி,

37
00:01:50,510 --> 00:01:54,140
இரண்டு முறை GetString அழைப்பு, அவர்கள், இல்லை
உண்மையில், அதே இருக்க போகிறது.

38
00:01:54,140 --> 00:01:57,700
எனவே இது விஷயத்தில் தெரிகிறது என்று
உள்ளுணர்வு இரண்டு சரங்களை ஒப்பிட்டு

39
00:01:57,700 --> 00:02:01,050
நாம் எதிர்பார்க்கும் வழியில், எழுத்து
பாத்திரம், நாம் மற்றொரு நுட்பம் தேவை

40
00:02:01,050 --> 00:02:02,300
முற்றிலும்.

41
00:02:02,300 --> 00:02:03,902