>> సల యొక్క ఒక ప్రోగ్రామ్ను రాయడం లెట్ రెండు తీగలు మరియు కోసం ప్రాంప్టుచేస్తుంది
అప్పుడు నివేదికలు ఆ తీగలను అని అదే అదే లేదా కాదు.
నేను ఇప్పటికే ఇక్కడ మాకు ఆఫ్ మొదలుపెట్టారు చేసిన రెండుసార్లు printf కాల్ మరియు కాలింగ్
తిరిగి నిల్వ, రెండుసార్లు GetString s మరియు t విలువలు, వరుసగా.
>> ఇప్పుడు, నా ప్రవృత్తులు ఈ రెండు పోల్చడానికి తీగలను తెలిసిన ఉపయోగించడానికి ఉంటుంది
సమానత్వం ఆపరేటర్లు -
లు సమానం t సమానం.
నేను ముందుకు మరియు ముద్రణ వెళ్ళండి వెళుతున్న అవుట్ "మీరు అదే పని టైప్!
నిజమైన కాదు ఎల్స్, నేను కేవలం ఉన్నాను printf టైప్ అన్నారు ("మీరు టైప్
వివిధ విషయాలు!
>> చాలా సులభంగా -
నేను కేవలం వ్యతిరేకంగా లు పోల్చడం వెబ్ t, మరియు వారు సమాన అయితే,
చాలా ముద్రించిన.
ఈ ప్రోగ్రామ్ కంపైల్ మరియు అమలు లెట్.
0 పోల్చి తయారు. / సరిపోల్చండి 0,, హలో, ఏదో చెప్పటానికి
హలో, ఏదో చెప్పటానికి.
>> అయినప్పటికీ, ఈ కార్యక్రమం నేను చేసిన భావిస్తున్నారు , వివిధ విషయాలను టైప్ అయినప్పటికీ నేను
స్పష్టంగా "హలో" టైప్ అదే విధంగా రెండు సార్లు.
ఇప్పుడు, ఎందుకు అని ఉంటుంది?
>> సరే, ఆ అవుతుంది ఈ అన్ని సమయం, తీగలను ఒక బిట్ మరింత ఉన్నాయి
అక్షరాలు క్రమం కంటే క్లిష్టమైన హుడ్ కింద.
వాస్తవంలో, ఒక స్ట్రింగ్ ఒక పాయింటర్ లేదా ఒక ఉంది చిరునామా, ప్రత్యేకంగా చిరునామా
ఆ మొదటి పాత్ర యొక్క అక్షరాలు క్రమం.
>> కాబట్టి మేము T వ్యతిరేకంగా లు పోల్చి సమాన సమానంగా సైన్, మేము
నిజానికి అడుగుతూ, ఈ చిరునామా ఉంది ఈ చిరునామాకు సమాన సమాన?
మరియు ఆ సందర్భంలో మాత్రం కాదు ఉంటే యూజర్ వివిధ రెండు టైప్ చేసారు
తీగలను మరియు మేము రెండుసార్లు GetString అని చేసిన వాటిని పొందడానికి, మెమరీ
ఆ GetString మొదటి నిల్వ ఉపయోగించే స్ట్రింగ్ RAM లో ఇక్కడ, కానీ ఉండవచ్చు
GetString నిల్వ ఉపయోగించే మెమరీ రెండవ స్ట్రింగ్ అన్నారు
ఇక్కడ RAM ఉండాలి.
మరియు కోర్సు యొక్క, అప్పుడు, ఆ రెండు భాగాలుగా మెమరీ వివిధ చిరునామాలు కోసం కలిగి
వారి మొదటి అక్షరాలు.
>> కాబట్టి సమాన లు T కు సమానం?
బాగా, ఏ.
S మరియు t వివిధ సూచించే ఉంటే వారు ద్వారా ఉంటుంది వంటి మెమరీ భాగాలుగా,
రెండుసార్లు GetString కాల్, వారు, లేదు నిజానికి, అదే చేస్తాడు.
కనుక ఇది కేసు ఉంది ఆ సహజమైన రెండు తీగలను పోల్చడం
కాదనీ ఆ విధంగా, కోసం పాత్ర పాత్ర, మేము మరొక టెక్నిక్ అవసరం
పూర్తిగా.