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
s మరియు 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
నేను కేవలం వ్యతిరేకంగా లు పోల్చడం వెబ్
t, మరియు వారు సమాన అయితే,

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 మొదటి నిల్వ ఉపయోగించే
స్ట్రింగ్ RAM లో ఇక్కడ, కానీ ఉండవచ్చు

30
00:01:34,480 --> 00:01:37,120
GetString నిల్వ ఉపయోగించే మెమరీ
రెండవ స్ట్రింగ్ అన్నారు

31
00:01:37,120 --> 00:01:38,760
ఇక్కడ RAM ఉండాలి.

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
>> కాబట్టి సమాన లు T కు సమానం?

35
00:01:46,120 --> 00:01:46,885
బాగా, ఏ.

36
00:01:46,885 --> 00:01:50,510
S మరియు 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