[Powered by Google Translate] [విభాగం 5 - అత్యంత సౌకర్యవంతమైన]
[రాబ్ బౌడెన్ - హార్వర్డ్ యూనివర్శిటీ]
[ఈ CS50 ఉంది. - CS50.TV]
>> నా ఇమెయిల్ లో చెప్పినట్టూ, మీరు ఉపయోగించవచ్చు విషయాలు చాలా ఉన్నాయి
వాస్తవానికి సమస్య సెట్లు చేయడానికి ఉపకరణం కంటే ఇతర.
మేము అప్పుడు మేము సులభంగా మీరు సహాయం చెయ్యవచ్చు కనుక మీరు పరికరంలోని దీనిని సిఫార్సు
మరియు మేము ప్రతిదీ వెళ్లాలని ఎలా తెలుసు.
కానీ చెప్పడానికి, మీరు చేయవచ్చు పేరు ఒక ఉదాహరణ, మీరు ప్రాప్యత లేదు
ఒక ఉపకరణం లేదా మీరు సైన్స్ సెంటర్ నేలమాళిగలో పని -
ఇది వాస్తవానికి వారు చాలా ఉపకరణం కలిగి -
మీరు ఎక్కడైనా పని చేయండి.
ఒక ఉదాహరణ మీరు చూసిన / SSH యొక్క విన్న ఉంది?
SSH కేవలం ఏదో కనెక్ట్ వంటి రప్పించింది.
అసలైన, ప్రస్తుతం నేను ఉపకరణం లోకి SSHed చేస్తున్నాను.
నేను పరికరంలోని పని ఎప్పుడూ.
ఇక్కడ ఉపకరణం, మరియు మీరు ఇక్కడ క్రిందికి చూడండి మీరు ఈ IP చిరునామా చూడండి.
నేను ఉపకరణం కూడా పని లేదు;
నేను ఎల్లప్పుడూ ఒక iTerm2 విండో / టెర్మినల్ విండో కి వచ్చారు.
ఆ IP చిరునామా, ssh jharvard@192.168.129.128 కు SSH చెయ్యవచ్చు.
అది ఒక nice నమూనా ఎందుకంటే నేను చాలా సులభంగా ఆ సంఖ్యను గుర్తుంచుకోండి.
కానీ నా పాస్వర్డ్ను కోసం అడుగుతుంది, మరియు ఇప్పుడు నేను ఉపకరణం ఉన్నాను.
సాధారణంగా, ఈ సమయంలో, మీరు, ఉపకరణం యొక్క లోపల టెర్మినల్ ప్రారంభించబడ్డాయి
ఈ ఇంటర్ఫేస్, అయితే మీరు దానిని ఉపయోగించే, అదే ఉంది
ఇంటర్ఫేస్ను నేను ఇక్కడ ఉపయోగించి నేను ఇప్పుడు మీరు SSHed చేస్తున్నారు.
మీరు ఉపకరణం కు SSH లేదు.
మీరు చేయగల SSH మరొక స్థలం యొక్క ఒక ఉదాహరణ నేను సిద్ధంగా ఉన్నాయి అందంగా ఖచ్చితంగా ఉన్నాను ఉంది -
ఓహ్. పెద్దది.
మీరు అన్ని FAS సర్వర్లపై డిఫాల్ట్ FAS ఖాతాల ద్వారా ఉండాలి.
నా కోసం నేను SSH rbowden@nice.fas.harvard.edu నియమిస్తున్నట్లు.
మీరు మొదటిసారి అడగండి అవకాశముంది, మరియు మీరు అవును అంటున్నారు.
నా పాస్వర్డ్ను నా FAS పాస్వర్డ్ను అని అన్నారు.
కాబట్టి ఇప్పుడు, నేను మంచి సర్వర్లకు SSHed చేస్తున్నాను, నేను ఇక్కడ న మీరు ఏదైనా సాధ్యమే.
మీరు 124 వంటి పడుతుంది తరగతులు చాలా, మీరు ఇక్కడ అంశాన్ని అప్లోడ్ పొందబోతున్నారు
నిజానికి మీ సమస్య సెట్లు సమర్పించడానికి.
కానీ మీరు మీ ఉపకరణం యాక్సెస్ లేదు చెప్పారు.
అప్పుడు మీరు, చేయవచ్చు ఇక్కడ లాంటి స్టేట్మెంట్లు చదివితే, అది -
ఇది ప్రశ్నలు మా విభాగం ఉంది.
ఇది పరికరంలోని దీన్ని మీరు అడుగుతాము.
బదులుగా నేను సర్వర్లో చేయును.
నేను ఆ అన్జిప్ వెళుతున్న.
సమస్య మీరు gedit లాగ ఉపయోగించి ఉపయోగిస్తారు చేస్తున్న అవతరిస్తుంది
ఉపకరణం లేదా ఏ లోపల.
మీరు FAS సర్వర్లో ఆ కొనసాగుతుందని లేదు.
ఇది అన్ని కేవలం ఈ పాఠ్య అంతర్ముఖాన్ని చేస్తాడు.
కాబట్టి మీరు, వారు లేదని టెక్స్ట్ ఎడిటర్ తెలుసుకోవడానికి గాని ఒక ప్రయత్నించండి.
వారు నానో ఉన్నాయి.
నానో సాధారణంగా ఉపయోగించడానికి చాలా సులభం.
మీరు మీ బాణాలు ఉపయోగించండి మరియు సాధారణంగా టైప్ చెయ్యవచ్చు.
కాబట్టి ఆ హార్డు కాదు.
మీరు నిజంగా ఫాన్సీ పొందడానికి అనుకుంటే మీరు, Emacs ఉపయోగించవచ్చు
నేను కూడా Emacs దగ్గరగా ఎలా తెలియదు ఎందుకంటే ఇది నేను బహుశా తెరిచారు లేదు.
కంట్రోల్ X, కంట్రోల్ సి? అవును.
లేదా మీరు నేను ఉపయోగం ఉంది Vim, ఉపయోగించవచ్చు.
కాబట్టి ఆ మీ ఎంపికలు ఉన్నాయి.
మీరు అలా చేయకూడదని, మీరు కూడా, మీరు చూడండి ఉంటే manual.cs50.net -
ఓహ్.
ఒక PC లో, మీరు SSH, పుట్టీ ఉపయోగించి
ప్రత్యేకంగా మీరు డౌన్లోడ్ చూడాలని ఇది.
ఒక Mac, మీరు కేవలం డిఫాల్ట్ ఉపయోగించు టెర్మినల్ ద్వారా లేదా మీరు, iTerm2 డౌన్లోడ్ చేసుకోగలరు
ఒక nice, ఫాన్సీ టెర్మినల్ ఉంటుంది.
మీరు manual.cs50.net వెళ్ళండి ఉంటే మీరు నోట్ప్యాడ్లో ఒక లింక్ను చూస్తారు + +,
మీరు ఒక PC లో ఉపయోగించే ఏమిటి.
ఇది నోట్ప్యాడ్లో మీరు SFTP అనుమతిస్తుంది + +, ఇది ప్రాథమికంగా SSH ఉంది.
ఈ మీరు అనుమతిస్తుంది, స్థానికంగా మీ ఫైళ్ళను ఎడిట్ ఉంది
మరియు మీరు వాటిని సేవ్ చేయాలనుకుంటున్నారా చేసినా, అది, nice.fas సేవ్ చేస్తుంది
మీరు వాటిని అమలు చేయగల.
మరియు ఒక Mac న సమానమైన TextWrangler అని అన్నారు.
కాబట్టి మీరు కూడా ఇదే అనుమతిస్తుంది.
ఇది మీరు స్థానికంగా ఫైళ్ళను ఎడిట్ మరియు nice.fas వాటిని సేవ్ అనుమతిస్తుంది
మీరు వాటిని అమలు చేయగల.
మీరు ఒక ఉపకరణం లేకుండా ఇరుక్కుపోయి ఉన్నాం చేస్తే, మీరు ఈ ఎంపికలు ఉన్నాయి
మీ సమస్య సెట్లు చేయండి ఇప్పటికీ కు.
ఒక సమస్య మీరు CS50 లైబ్రరీ ఏమీ ఉండదని చేస్తున్న అవతరిస్తుంది
nice.fas సిద్ధంగా ఆ లేవు.
మీరు CS50 లైబ్రరీ డౌన్లోడ్ చేసుకోవచ్చు -
నేను ఈ సమయంలో ఆ అవసరం భావించడం లేదు.
మీరు, CS50 లైబ్రరీ డౌన్లోడ్ మరియు nice.fas దానిని పైగా కాపీ చేసుకోవచ్చు
లేదా నేను ఈ సమయంలో మేము ఏ విధంగా అయినా ఇకపై దీన్ని ఉపయోగించకండి భావిస్తున్నాను.
మేము ఉంటే లేదా, మీరు సారి భర్తీ చేస్తున్న చేయవచ్చు
ఏమైనప్పటికీ CS50 లైబ్రరీలో విధులు అమలు.
కాబట్టి ఒక పరిమితి యొక్క ఎక్కువ ఉండకూడదు.
మరియు ఆ ఆ.
>> నేను ఇప్పుడు ఉపకరణం తిరిగి వెళ్తారో; మేము పరికరంలోని ప్రతిదీ చేస్తాను.
నా ఇమెయిల్ మాట్లాడుతూ వంటి ప్రారంభంలో, ప్రశ్నలు మా విభాగం వద్ద గురించి,
మీరు చూడటానికి నిర్ణయించుకున్నాయి చిన్న గురించి మాట్లాడటానికి ఉన్నాయి.
మేము మళ్లిస్తోంది & పైప్స్ మరియు ఈ మూడు ప్రశ్నలు.
>> ఏ స్ట్రీమ్ వంటి విధులను printf సిద్ధంగా వ్రాస్తారా?
స్ట్రీమ్ కాబట్టి. ప్రవాహం ఏమిటి?
అది కేవలం కొన్ని మాదిరిగా ప్రవాహం రప్పించింది -
ఇది కూడా 1s మరియు 0 సె ఒక మూల కాదు.
అది ఇక్కడ కోరుతూ యొక్క స్ట్రీమ్లో ప్రామాణిక ముగిసింది.
కాబట్టి ప్రామాణిక అవుట్ ఒక ప్రవాహం మీరు, అది వ్రాసే సమయంలో
అది తెరపై కనిపిస్తుంది.
ప్రామాణిక అవ్ట్, ప్రవాహం ద్వారా, అది మీకు 1s మరియు దానికి వ్రాసి 0 సె అర్థం
మరియు ప్రామాణిక అవుట్ ఇతర ముగింపు ఆ ప్రవాహం నుంచి చదువుతుంది.
ఇది కేవలం 1s మరియు 0 సె ఒక స్ట్రింగ్ ఉంది.
మీరు ప్రవాహాలు వ్రాయగలరు లేదా మీరు కాలువల నుండి చదువుకోవచ్చు
స్ట్రీమ్ అసలు ఆధారపడి.
ఇతర రెండు డిఫాల్ట్ ప్రవాహాలు మరియు ప్రామాణిక తప్పు ప్రామాణికమైన.
మీరు GetString లేదు చేసినప్పుడు లో ప్రామాణిక ఉంటే, మీరు కోసం ఇన్పుట్ అంశం వేచి యొక్క.
కాబట్టి మీరు వేచి, ఇది నిజానికి, ప్రామాణిక న వేచి యొక్క
మీరు కీబోర్డ్ వద్ద టైప్ మీరు పొందుతారు నిజంగా ఉంది.
మీరు ప్రామాణిక టైప్ చేస్తున్నారు
ప్రామాణిక లోపం, ప్రామాణిక అవుట్ ప్రధానంగా సమానం
మీరు ప్రామాణిక లోపం ప్రింట్ చేసినప్పుడు కానీ, ఆ ప్రత్యేక ఉంది
మీరు మాత్రమే ఆ లోపం సందేశాలు ప్రింట్ కోరుకుంటున్నాము చేస్తున్నారు
కాబట్టి మీరు స్క్రీన్ ముద్రించబడుతుంది సాధారణ సందేశాలను మధ్య తేడా చేయవచ్చు
వారు ప్రామాణిక అవుట్ లేదా ప్రామాణిక లోపం జరిగింది అనే దానిపై ఆధారపడి దోష సందేశాలు వర్సెస్.
చాలా ఫైళ్ళను.
ప్రామాణిక అవ్ట్, ప్రామాణిక, మరియు ప్రామాణిక తప్పు, కేవలం ప్రత్యేక ప్రసారాలు ఉంటాయి
కానీ నిజంగా ఏ ఫైలు, మీరు ఒక ఫైల్ను తెరవడం, అది బైట్లు ప్రవాహం అవుతుంది
మీరు ఆ స్ట్రీమ్ నుండి చదువుకోవచ్చు.
మీరు చాలా భాగం కేవలం బైట్లు ప్రవాహం వంటి ఫైల్ యొక్క ఆలోచించవచ్చు.
సో వాట్ ప్రవాహాలు వారు సిద్ధంగా కు వ్రాస్తారా? ప్రామాణిక అవుట్.
>> > మరియు >> మధ్య తేడా ఏమిటి?
ఎవరైనా ముందుగానే వీడియోను తెలుసా? సరే.
> మీరు ఫైల్ గా దారిమార్పు ఎలా ఉండబోతుంది
మరియు >> కూడా, ఫైల్ గా అవుట్పుట్ మళ్ళింపు అన్నారు
కానీ బదులుగా ఫైలుకు జోడించే జరగబోతోంది.
ఉదాహరణకు, లెట్స్ నేను ఇక్కడే నిఘం కలిగి జరిగే సే
మరియు నిఘం లోపలి మాత్రమే stuff పిల్లి, పిల్లి, కుక్క, చేపలు, కుక్క ఉంది.
మీరు కమాండ్ లైన్ వద్ద కలిగి ఒక ఆదేశం, పిల్లి
ఇది ఫైల్ లో ఏమి ప్రింట్ అన్నారు.
నేను పిల్లి నిఘం సే, అది పిల్లి, పిల్లి, కుక్క, చేపలు, కుక్క ముద్రించడానికి జరగబోతోంది. అన్ని పిల్లి చేస్తుంది ఉంది.
అది పిల్లి, పిల్లి, కుక్క, చేపలు, కుక్క అవుట్ ప్రామాణిక ముద్రించబడుతుంది అర్థం.
నేను బదులుగా ఒక ఫైల్ను మళ్ళిస్తుంది చేయాలనుకుంటే, నేను ఉపయోగించే> మరియు ఫైలు ఏ దానిని దారిమార్పు చేయవచ్చు.
నేను ఫైలు పిలుస్తాను.
నేను ls చేస్తే ఇప్పుడు, నేను ఫైలు అనే కొత్త ఫైలుని కలిగి చూస్తారు.
నేను దానిని తెరిచి ఉంటే, అది పిల్లి కమాండ్ లైన్ వద్ద ఉంచారు సరిగ్గా అదే కలిగి జరగబోతోంది.
నేను మళ్ళీ అలా చేస్తే ఇప్పుడు, అది, ఫైల్లోకి అవుట్పుట్ మళ్ళించడం జరగబోతోంది
మరియు నేను అదే ఖచ్చితమైన విషయం కలిగి వెళుతున్న.
కాబట్టి సాంకేతికంగా ఇది పూర్తిగా మేము ఏ overrode.
నేను నిఘం మార్చడానికి మేము చూస్తారు, నేను కుక్క తీసుకున్నారు.
ఇప్పుడు మళ్ళీ ఫైల్లోకి మేము పిల్లి నిఘం ఉంటే, మేము కుక్క తొలగించబడుతుంది కొత్త వెర్షన్ చూడాలని.
కనుక ఇది పూర్తిగా భర్తీ చేయబడుతుంది.
మేము >> ఉపయోగిస్తే బదులుగా, ఫైలు జోడించే జరగబోతోంది.
ఇప్పుడు, తెరుస్తోంది, మేము రెండుసార్లు ముద్రించబడిన ఇదే చూడండి
ఒకప్పుడు ఉంది ఎందుకంటే, అప్పుడు మేము అసలు చేర్చబడుతుంది.
కాబట్టి యొక్క ఏ> మరియు >> లేదు.
తదుపరి అడుగుతుంది - ఇది దాని గురించి అడగండి లేదు.
>> మనం ఇతర ఒక ప్రామాణిక అవుట్ దారిమార్పులను <ఉంటే ఇది,> ఉంది
<ప్రామాణిక సైన్ మళ్ళింపు అవతరిస్తుంది
మేము ఒక ఉదాహరణ ఉంటే యొక్క చూసేలా.
నేను ఒక నిజమైన త్వరగా రాయడం.
యొక్క ఏ ఫైలు, hello.c తీసుకుందాం.
సాపేక్షంగా సూటిగా ఫైలు.
నేను కేవలం ఎంటర్ స్ట్రింగ్ అది ఏమైనప్పటికీ "హలో" ప్రింటింగ్ అప్పుడు స్ట్రింగ్ పొందడానికి మరియు వెబ్.
కాబట్టి హలో హలో మరియు తరువాత చేయండి. /.
ఇప్పుడు అది, ఏదైనా ఎంటర్ నాకు ప్రాంప్ట్ యొక్క
అది సైన్ ప్రామాణిక నమోదు వస్తువుల మీద వేచి యొక్క అర్థం
కాబట్టి మేము రాబ్, హలో చెప్పండి చూడాలని సైన్ నేను ప్రామాణిక లోకి కావలసిన ఎంటర్!
అప్పుడు, హలో అవుట్ ప్రామాణిక రాబ్ ప్రింటింగ్ కాదు!
నేను. / హలో మరియు తరువాత మళ్ళింపు, ఇలా చేస్తే
ఇప్పుడు కోసం మీరు ఒక ఫైల్ నుండి దారిమార్పు చేయవచ్చు.
నేను కొన్ని ఫైలు, టిఎక్స్ టి ఉంచారు, మరియు నేను, రాబ్ ఉంచండి అయితే
నేను హలో అమలు మరియు తరువాత ఫైలు టిఎక్స్ టి మళ్ళింపు ఉంటే. / హలో, అది రాబ్, హలో చెప్పండి వెళుతున్న! వెంటనే.
అది మొదటి GetString చేసుకుంటాడు మరియు ఇది ప్రామాణిక న వేచి ఉన్నప్పుడు
ప్రామాణిక ఎంటర్ చెయ్యండి డేటా కోసం కీబోర్డు మీద వేచి లేదు.
బదులుగా, ఫైలు టిఎక్స్ నుండి చదవడానికి ప్రామాణిక మళ్ళించబడింది చేశారు.
మరియు అందువలన, కేవలం లైన్ రాబ్ ఇది ఫైల్ టిఎక్స్ టి, నుండి చదవడానికి జరగబోతోంది
మరియు తర్వాత ఇది హలో, రాబ్ ముద్రించడానికి జరగబోతోంది!
నేను కోరుకుంటే, నేను కూడా పని చేయడు. / హలో <టిఎక్స్
తరువాత ప్రామాణిక ఆ హలో ఇది దాని ముద్రణ, రాబ్!
నేను దాని స్వంత ఫైల్ లోకి మళ్ళిస్తుంది చేయవచ్చు.
నేను హలో ఫైలు పిలుస్తాను - లేదు, నేను కాదు, ఆ executable ఎందుకంటే - txt2.
ఇప్పుడు, txt2 హలో మాత్రం ఇది. / హలో <టిఎక్స్ టి, రాబ్ యొక్క అవుట్పుట్ కలిగి అన్నారు!
>> ప్రశ్నలు?
>> సరే. కాబట్టి ఇక్కడ మేము పైప్లైన్ ఉన్నాయి.
పైప్స్ దారి మళ్లింపును చివరి యూనిట్ ఉన్నాయి.
>> ఓహ్. నేను దారి మళ్లింపును యొక్క మరొక యూనిట్ ఉంటే బదులుగా ఉంటుంది ఊహించడం> మీరు 2 చేయండి>
ప్రామాణిక దోషం రీడైరెక్ట్ యొక్క.
ఏదో ప్రామాణిక లోపం జరిగింది కాబట్టి, అది txt2 ఉంచి get కాదు.
కానీ నేను 2> లేకపోతే గమనించి, అది ఇప్పటికీ రాబ్, హలో ప్రింటింగ్ కాదు! కమాండ్ లైన్ కు
నేను మాత్రమే ప్రామాణిక తప్పు దారి మళ్ళించడం నేను ఎందుకంటే, నేను ప్రామాణిక అవుట్ రీడైరెక్ట్ లేదు.
ప్రామాణిక దోషం మరియు ప్రామాణిక అవుట్ భిన్నంగా ఉంటాయి.
మీరు నిజంగా ప్రామాణిక లోపం రాయడానికి కోరుకున్నాడు ఉంటే
అప్పుడు నేను stderr కు fprintf అని ఈ మారిపోవచ్చు.
కాబట్టి printf, డిఫాల్ట్గా, ప్రామాణిక అవుట్ ముద్రిస్తుంది.
నేను మానవీయంగా ప్రామాణిక లోపం ప్రింట్ చెయ్యడానికి, అప్పుడు నేను fprintf ఉపయోగించాలి
మరియు నేను ముద్రించడానికి ఏమి తెలుపుము.
బదులుగా నేను fprintf stdout చేశాడు, అప్పుడు ఆ printf ప్రాథమికంగా సమానమైన ఉంది.
కానీ fprintf ప్రామాణిక లోపం.
కాబట్టి ఇప్పుడు, నేను txt2 ఈ మళ్ళింపు ఉంటే, హలో, రాబ్! ఇప్పటికీ ఆదేశ పంక్తి వద్ద ముద్రించిన సంతరించుకుంటున్నది
ఇది ప్రామాణిక లోపం ముద్రించిన సంతరించుకోనుంది మరియు నేను మాత్రమే ప్రామాణిక అవుట్ రీడైరెక్ట్ చేస్తున్నాను నుండి.
నేను ఇప్పుడు ప్రామాణిక మళ్ళింపు లోపం ఉంటే, ఇప్పుడు అది ముద్రించబడిన కాలేదు, మరియు txt2, హలో రాబ్ ఉండబోతుంది?
కాబట్టి ఇప్పుడు, మీరు ప్రామాణిక లోపం మీ వాస్తవ దోషాలు ముద్రించవచ్చు
మరియు ప్రామాణిక అవుట్ మీ సాధారణ సందేశాలను ప్రింట్.
మరియు మీరు మీ ప్రోగ్రామ్ రన్, అప్పుడు మీరు 2 హలో ఈ రకం గా అమలు. / చేయవచ్చు>
మీ ప్రోగ్రామ్, సాధారణంగా అమలు అన్నారు కాబట్టి
కానీ మీరు పొందుతారు ఏ దోష సందేశాలు, మీ లోపం లాగ్ తరువాత తనిఖీ చేయవచ్చు
లోపాలను కాబట్టి, తర్వాత చూసి మీ లోపాలు ఫైలు జరిగిన ఏ లోపాలు ఉంటుంది.
>> ప్రశ్నలు?
>> చివరి మీరు ఒక ఆదేశం నుండి ప్రామాణిక తీసుకున్న భావిస్తున్నది ఇది PIPE ఉంది
మరియు తదుపరి ఆదేశాన్ని యొక్క ప్రామాణిక అయింది.
ఒక ఉదాహరణ ఇక్కడ echo ఒక కమాండ్ లైన్ విషయం ఉంది
కేవలం నేను దాని వాదన వంటి ఉంచారు ఏ ప్రతిధ్వని అన్నారు. నేను కోట్లు పెట్టి లేదు.
ఎకో బ్లా, బ్లా, బ్లా బ్లా కేవలం, బ్లా, బ్లా ప్రింట్ అన్నారు.
ముందు, నేను అన్నాడు నేను ఒక టిఎక్స్ టి ఫైల్లోకి రాబ్ ఉంచారు వచ్చింది
నేను మాత్రమే టిఎక్స్ టి ఫైళ్లను మళ్ళింపు, బదులుగా ఎందుకంటే, / నేను రాబ్ ప్రతిధ్వని ఉంటే
తరువాత పైపు దీనిని. / హలో, ఆ విషయం కూడా అదే రకం చేస్తుంది.
ఈ ఆదేశం యొక్క అవుట్పుట్, echo రాబ్, తీసుకుంటోంది
మరియు ఇన్పుట్ గా ఉపయోగించి. / హలో.
మీరు మొదటి ఫైలు లోకి echo రాబ్ మళ్ళింపు ఆలోచించి చేయవచ్చు
మరియు తర్వాత. / హలో ఫైల్ లోకి ఇన్పుట్ కేవలం outputted అని.
కానీ చిత్రం తాత్కాలిక ఫైల్ తీస్తాడు.
>> ఆ ప్రశ్నలకు?
>> తదుపరి ప్రశ్నకు ఈ కలిగి అన్నారు.
ఏ పైప్లైన్ మీరు names.txt గా పిలువబడే ఒక ఫైల్ లో ఏకైక పేర్లు సంఖ్య కనుగొనేందుకు వాడేవారు?
మేము ఇక్కడ ఉపయోగించాలనుకుంటున్నాను చూడాలని ఆదేశాలు ఏకైక, కాబట్టి uniq, ఆపై WC ఉంటాయి.
మీరు నిజంగా ఆ ఏమి కు వ్యక్తి uniq చేయవచ్చు
అది ఇన్పుట్ నుండి ప్రక్కన సరిపోలే పంక్తులు ఫిల్టర్ చెప్పారు.
మరియు మనిషి WC NEWLINE, పదం, మరియు ప్రతి ఫైల్ కోసం బైట్ గణనలు ప్రింట్ అన్నారు.
మరియు మేము ఉపయోగించాలనుకుంటున్నాను చూడాలని చివరి, క్రమీకరించు ఉంది
ఇది కేవలం టిఎక్స్ టి ఫైలు రేఖలు క్రమం అన్నారు.
నేను కొన్ని టిఎక్స్ టి ఫైలు, names.txt, తయారుచేస్తాయి మరియు దాన్ని రాబ్, టామీ, జోసెఫ్, టామీ, జోసెఫ్, RJ, రాబ్, అయితే
నేను ఇక్కడ చేయాలనుకుంటున్నారా ఈ ఫైలులో ఏకైక పేర్లు సంఖ్య కనుగొనేందుకు ఉంది.
కాబట్టి సమాధానం ఉండాలి? >> [విద్యార్థి] 4. >> అవును.
ఇది రోబ్, టామీ, జోసెఫ్ నుండి 4 ఉండాలి, RJ ఈ ఫైలులో మాత్రమే ఏకైక పేర్లు.
మొదటి దశ, నేను names.txt న పద గణన ఉన్నట్లయితే,
ఈ నిజానికి నాకు ప్రతిదీ చెప్తుంటాడు.
ఈ నిజానికి ముద్రణ ఉంది - న్యూ లైన్, పదాలు, మరియు బైట్ COUNT - మనిషి WC, చూద్దాం.
నేను మాత్రమే పంక్తులు శ్రద్ధ, అప్పుడు నేను WC-l names.txt చేయవచ్చు.
కాబట్టి ఆ దశ 1 ఉంది.
Names.txt అన్ని పేర్లు ఉన్నందున కానీ, WC-l names.txt చేయకూడదని
మరియు నేను ఏదైనా ఏకైక వాటిని ఫిల్టర్ చెయ్యడానికి మీరు.
నేను uniq names.txt లేకపోతే కనుక, నేను ఏమి నాకు ఇవ్వండి లేదు
నకిలీ పేర్లు ఇప్పటికీ ఎందుకంటే.
ఎందుకు అని? ఎందుకు uniq నేను ఏమి చేయడం లేదు?
[విద్యార్థి] నకిలీలను కాదు [వినబడని] >> అవును.
Uniq కోసం మనిషి పేజీ గుర్తుంచుకో ఫిల్టర్ ప్రక్కన మ్యాచింగ్ పంక్తులు చెప్పారు.
వారు ప్రక్కన లేదు, కనుక ఫిల్టర్ చేస్తుంది.
నేను మొదటి క్రమం ఉంటే, క్రమీకరించు names.txt కలిసి అన్ని నకిలీ పంక్తులు ఉంచారు అన్నారు.
కాబట్టి ఇప్పుడు విధమైన names.txt ఉంది.
Uniq | నేను ఇది uniq, ఇన్పుట్ ఆ ఉపయోగించాలనుకుంటున్నాను వెళుతున్న.
అది నాకు జోసెఫ్, RJ, రాబ్, టామీ, ఇస్తుంది
మరియు నేను, WC-l ఇన్పుట్ ఆ ఉపయోగించాలనుకుంటున్నాను
ఇది నాకు 4 ఇవ్వాలని అన్నారు.
అది ఇక్కడ చెప్పారు వలె, మీరు ఏమి పైప్లైన్ ఉపయోగించవచ్చు?
మీరు ఆదేశాలను సీరీస్ ను వంటి వాటిని చాలా చేయవచ్చు
మీరు తదుపరి ఆదేశానికి ఇన్పుట్ ఒక ఆదేశం నుండి అవుట్పుట్ ఉపయోగిస్తారు.
మీరు విషయాలు చాలా, తెలివైన విషయాలు చాలా చేయవచ్చు.
>> ప్రశ్నలు?
సరే.
గొట్టాలు మరియు దారిమళ్ళింపు అది పేర్కొంది.
>> ఇప్పుడు మేము అసలు విషయం, కోడింగ్ స్టఫ్ సాగుతుంది.
ఈ PDF లోపలి మీరు, ఈ ఆదేశం చూస్తారు
మరియు మీరు మీ ఉపకరణం ఈ ఆదేశాన్ని చెయ్యవచ్చును.
wget, ప్రధానంగా, కేవలం ఇంటర్నెట్ నుండి ఏదో పొందడానికి ఆదేశాలు
కాబట్టి wget మరియు ఈ URL.
మీరు మీ బ్రౌజర్ లో ఈ URL వెళ్ళాడు, అది ఆ ఫైల్ డౌన్లోడ్ అవుతుంది.
నేను దాని మీద క్లిక్, కాబట్టి ఇది నాకు ఫైల్ డౌన్లోడ్.
కానీ టెర్మినల్ యొక్క లోపల విషయం యొక్క wget రాయడం
మీ టెర్మినల్ లో డౌన్లోడ్ అన్నారు.
నేను section5.zip కలిగి, మరియు మీరు section5.zip అన్జిప్ చెయ్యవచ్చును
ఇది మీరు section5 అనే ఫోల్డర్ ఇవ్వాలని అన్నారు
మనం లోపల నేడు ఉపయోగిస్తున్న చూడాలని ఫైళ్లు అన్ని అన్నారు ఇది.
ఈ కార్యక్రమాలు 'ఫైలు పేర్లను సూచిస్తుంది, అవి ఒక బిట్ బగ్గీ ఉన్నాము,
మీ మిషన్ GDB ఉపయోగించి ఎందుకు గుర్తించడానికి ఉంది.
వాటిని ప్రతి ఒక్కరూ డౌన్లోడ్ / వాటిని డౌన్లోడ్ ఎలా పొందాలో మాకు కలిగి
వారి ఉపకరణం వలె? సరే.
>> ./buggy1 రన్నింగ్, ఇది విభజన లోపంగా (ముడి వేసారు) యున్నది
మీరు ఒక segfault పొందండి ఏ సమయంలో, అది మంచిది.
ఏ పరిస్థితులలో మీరు ఒక segfault వస్తుందా?
[విద్యార్థి] ఒక నల్ పాయింటర్ Dereferencing. >> అవును. కాబట్టి ఒక ఉదాహరణ.
మీరు ఒక segfault పొందడానికి వెళుతున్న ఒక నల్ పాయింటర్ Dereferencing.
మీరు మెమరీ తాకిన ఏమి సాధనంగా segfault మీరు తాకడం లేదు.
కాబట్టి ఒక నల్ పాయింటర్ dereferencing, చిరునామా 0 తాకినప్పటికీ అది లోపలే
మరియు ప్రధానంగా, అన్ని కంప్యూటర్లలో రోజుల్లో చిరునామా 0 మీరు తాకడం లేదు మెమరీ చెపుతారు.
ఒక segfault ఒక నల్ పాయింటర్ ఫలితాలు dereferencing వై సో ఆ.
మీరు ఒక పాయింటర్ ప్రారంభించడం సాధ్యం సంభవించినప్పుడు పూర్తి, అది, ఒక చెత్త విలువ
మరియు మీరు dereference ప్రయత్నించినప్పుడు అది, అన్ని సంభావ్యత లో మీరు మెమరీ తాకిన చేస్తున్నారు
ఆ ఎక్కడా మధ్యలో ఉంది.
మీరు లక్కీ మరియు చెత్త విలువ పొందడానికి జరిగితే
స్టాక్ లేదా ఏదైనా ఎక్కడో సూచించడానికి జరిగిన,
అప్పుడు మీరు పాయింటర్ initialized కాని మీరు dereference,
ఏమీ తప్పు వెళ్తుంది.
అది సూచించే యొక్క అయితే, ఎక్కడో స్టాక్ మరియు కుప్ప మధ్య, సే
లేదా అది కేవలం ఎక్కడో ఇంకా మీ ప్రోగ్రామ్ ద్వారా ఉపయోగంలో లేని ఆ పై యొక్క
మీరు తాకడం లేదు మెమరీ తాకిన చేసిన మరియు మీరు segfault.
మీరు ఒక పునరావృత ఫంక్షన్ వ్రాసి చాలా సార్లు recurses చేసినప్పుడు
మరియు మీ స్టాక్ విషయాలు లోకి చాలా పెద్ద మరియు స్టాక్ గుద్దు పెరుగుతుంది
మీరు తాకడం లేదు అది గుద్దుకునే కూడదు, మీరు మెమరీ తాకిన చేస్తున్నారు,
కాబట్టి మీరు segfault.
ఏ ఒక segfault ఉంది.
>> ఇది కూడా అదే కారణం అని మీరు వంటి స్ట్రింగ్ కలిగి ఉంటే -
గత కార్యక్రమం తిరిగి వదలి వేస్తారు.
లో hello.c--I'm కేవలం ఏదో సిధ్ధంగా.
చార్ * s = "హలో వరల్డ్!";
నేను ఉపయోగిస్తే * s = ఏదో లేదా s [0] = 'X';
కాబట్టి హలో తయారు. / హలో, ఎందుకు ఆ segfault చేశారు?
ఎందుకు ఈ segfault చేశారు?
మీరు ఏమి ఊహించిన దాని?
నేను printf పొతే ("% s \ n", s); మీకు ముద్రించబడిన ఊహించిన దాని?
[విద్యార్థి] X హలో. >> అవును.
సమస్య, మీరు ఈ స్ట్రింగ్ ఉన్నప్పుడు డిక్లేర్ ఉంది
s, స్టాక్ మీద బయటకు వెళ్లి ఒక పాయింటర్ గా
ఏ s కు సూచిస్తుంది రీడ్ ఓన్లీ మెమరీ పొందుపర్చి ఉన్న ఈ స్ట్రింగ్.
కేవలం పేరు, రీడ్ ఓన్లీ మెమరీ, అందువల్ల మీరు ఆలోచన కావాలి
మీరు రీడ్ ఓన్లీ మెమరీ లో ఏమి మార్చడానికి ప్రయత్నించండి ఉంటే,
మీరు మెమరీ తో చేయడం లేదు ఏదో చేస్తున్నా మరియు మీరు segfault.
ఈ నిజానికి చార్ * s మరియు చార్ లు [] మధ్య ఒక పెద్ద తేడా ఉంది.
కాబట్టి చార్ లు [], ఇప్పుడు ఈ స్ట్రింగ్ స్టాక్ లో పెట్టడానికి అన్నారు,
మరియు స్టాక్ ఈ ఖచ్చితంగా బాగా పని చేయాలి అంటే, చదవడానికి మాత్రమే కాదు.
మరియు అది.
గుర్తుంచుకో నేను చార్ చేసినప్పుడు * s = "హలో వరల్డ్!", S కూడా స్టాక్ ఉంది
కానీ s ఎక్కడైనా కు పాయింట్లు, మరియు ఆ ఎక్కడైనా చదవడానికి మాత్రమే నిర్మాణము.
కానీ చార్ లు [] కేవలం స్టాక్ మీద ఏదో ఉంది.
కాబట్టి ఒక segfault జరుగుతున్న మరొక ఉదాహరణ ఉంది.
>> మేము ./buggy1 ఒక segfault ఫలితంగా చూసింది.
సిద్ధాంతంలో, మీరు వెంటనే buggy1.c వద్ద చూడరాదని.
బదులుగా, GDB ద్వారా వద్ద పరిశీలిస్తాము.
మీరు విభజన లోపంగా (ముడి వేసారు) వచ్చిన ప్రకటనలో,
మీరు ఇక్కడ అని కోర్ ఈ ఫైల్.
మేము ls-l, ఆ కోర్ సాధారణంగా చాలా పెద్ద ఫైలు చూస్తారు.
ఈ ఫైలు యొక్క బైట్లు యొక్క సంఖ్య, కాబట్టి ఇది 250 ఏదో లు ఉన్నట్లు కనిపిస్తోంది.
ఈ కారణం కోర్ డంప్ వాస్తవానికి ఏ ఉంటుంది
ఉన్నప్పుడు మీ ప్రోగ్రామ్ క్రాష్, మీ ప్రోగ్రామ్ యొక్క మెమరీ రాష్ట్ర
కేవలం కాపీ మరియు ఈ ఫైలు లోకి అతికించబడింది తీర్చుకుంటాడు.
ఇది ఫైల్ లోకి తిరస్కరించబడుతుంది.
ఈ కార్యక్రమం అమలు అవుతున్నప్పుడు, అది,, దాదాపు 250 ల మెమొరీ వాడుక కలిగి జరిగిన
అందువలన, ఈ ఫైల్ పోస్తారు ఏం జరిగింది ఉంది.
మేము GDB buggy1 కోర్ లేకపోతే ఇప్పుడు మీరు ఆ ఫైల్ చూడవచ్చు.
మేము GDB buggy1 చేయవచ్చు, మరియు కేవలం, క్రమం తప్పకుండా GDB అప్ మొదలవుతుంది
దాని ఇన్పుట్ ఫైల్గా buggy1 ఉపయోగించి.
మీరు GDB buggy1 కోర్ చేయండి అయితే, అది ప్రత్యేకంగా GDB అప్ ఆరంభమవుతుంది
ప్రధాన ఫైలు చూడటం ద్వారా.
మరియు మీరు buggy1 అంటే GDB చెప్పడం ప్రధాన ఫైలు buggy1 కార్యక్రమం నుంచి వచ్చింది తెలుసు.
కాబట్టి GDB buggy1 కోర్ వెంటనే మాకు చేసేందుకు ప్రయత్నిస్తుంది
కార్యక్రమం రద్దు జరిగింది ఎక్కడ.
మేము ప్రోగ్రామ్ సిగ్నల్ 11, విభజన లోపంగా తో రద్దు ఇక్కడ చూడండి.
మేము బహుశా చాలా సహాయకారిగా కాదు అసెంబ్లీ, ఒక లైన్ చూడటానికి పొందుతున్నారు.
మీరు BT లేదా వెనుకకు టైప్ అయితే, ఆ ఫంక్షన్ చేస్తాడు
మాకు మా ప్రస్తుత స్టాక్ ఫ్రేములు జాబితా ఇస్తుంది.
కాబట్టి వెనుకకు. మేము కేవలం రెండు స్టాక్ ఫ్రేమ్లను కలిగి ఉన్నట్లు తెలుస్తుంది.
మొదటి, మా ప్రధాన స్టాక్ ఫ్రేమ్
మరియు రెండవ, మేము ఉండాలి జరిగే ఈ వేడుకలో స్టాక్ ఫ్రేమ్
మేము మాత్రమే అసెంబ్లీ కోడ్ ఉన్నట్లు ఇది కనిపిస్తోంది.
కాబట్టి యొక్క మా ప్రధాన విధి తిరిగి వీడలేదు,
మరియు మేము ఫ్రేమ్ 1 చేయవచ్చు అలా, మరియు మనం కూడా డౌన్ చేయవచ్చు ఆలోచించడం,
అప్ లేదా - కాని నేను దాదాపు అధిగమించుట ఎప్పుడూ. అవును.
పైకి క్రిందికి. అప్ మీరు ఒక స్టాక్ ఫ్రేమ్ మీరు డౌన్ తెస్తుంది డౌన్, ఒక స్టాక్ ఫ్రేమ్ వస్తుంది.
నేను ఆ ఉపయోగించడానికి ఎప్పుడూ ఉంటాయి.
నేను ప్రత్యేకంగా 1 లేబుల్ ఫ్రేమ్ వెళ్ళండి ఇది ఫ్రేమ్ 1 చెబుతారు.
Frame 1, ప్రధాన స్టాక్ ఫ్రేమ్ లోకి మాకు చేసేందుకు ప్రయత్నిస్తుంది
మరియు అది ఇక్కడే మేము వద్ద కావడం కోడ్ వాక్యాన్ని చెబుతుంది.
మేము కోడ్ యొక్క ఒక జంట మరిన్ని పంక్తులు అనుకుంటే, మేము, జాబితా చెప్పగలదు
మరియు మాకు ఇది చుట్టూ కోడ్ అన్ని లైన్లు ఇవ్వడానికి జరగబోతోంది.
మేము వద్ద segfaulted లైన్ 6 ఉంది:
ఉంటే (strcmp ("CS50 రాళ్ళు", argv [1]) == 0).
అది ఇంకా స్పష్టంగా ఉంటే, మీరు దాన్ని segfaulted ఎందుకు ఆలోచించడం ద్వారా ఇక్కడ నుండి దానిని నేరుగా పొందవచ్చు.
కానీ మేము ఒక అడుగు ముందుకు తీసుకెళ్ళవచ్చు మరియు చెప్పడానికి, "ఎందుకు argv [1] segfault అనుకుంటున్నారు?" చేయవచ్చు
లెట్స్ print argv [1], మరియు అది నల్ పాయింటర్ ఇది దాని 0x0, కనిపిస్తోంది.
మేము segfault వెళుతున్న తద్వారా CS50 రాళ్ళు మరియు శూన్య strcmping, మరియు చేస్తున్నారు.
మరియు ఎందుకు argv [1] శూన్య?
[విద్యార్థి] మేము ఏ ఆదేశ పంక్తి వాదనలు ఇవ్వని కారణంగా.
అవును. మేము ఏ ఆదేశ పంక్తి వాదనలు ఇవ్వలేదని.
కాబట్టి ./buggy1 మాత్రమే argv [0] ./buggy1 అయి ఉంటాయి అన్నారు.
ఇది ఒక argv [1] కలిగి మాత్రం కాదు, segfault వెళుతున్న తద్వారా.
బదులుగా, నేను CS50 చేయండి, అయితే, మీరు D పొందండి చెప్పడానికి జరగబోతోంది
ఆ అది ఏమి చేయాలో ఏమి ఎందుకంటే.
Buggy1.c వద్ద గురించి, ప్రింట్ కోరుకుంటున్నాము యొక్క "మీరు ఒక D పొందండి" -
Argv [1] "CS50 రాళ్ళు", లేకపోతే, "మీరు ఒక D పొందండి" చెయ్యకపోతే "మీరు ఒక ఒక పొందండి!"
మేము ఒక ఒక అనుకుంటే, మేము, నిజం పోల్చడానికి ఈ అవసరం
అది 0 పోలిస్తే అర్థం.
కాబట్టి argv [1] "CS50 రాళ్ళు" ఉండాలి.
మీరు ఆదేశ ఆ విధంగా చేయడానికి, మీరు ఖాళీ తప్పించుకోవడానికి \ ఉపయోగించాలి.
కాబట్టి CS50 \ రాళ్ళు మరియు మీరు ఒక ఒక పొందండి!
మీరు బాక్ స్లాష్ చేయకపోతే, ఎందుకు ఈ పని లేదు?
[విద్యార్థి] ఇది రెండు వేర్వేరు వాదనలు ఉంది. >> అవును.
Argv [1] CS50 ఉండబోతుంది, మరియు argv [2] రాళ్ళు అని అన్నారు. సరే.
>> ఇప్పుడు మళ్ళీ ./buggy2 segfault అన్నారు.
దాని కోర్ ఫైల్ తో ప్రారంభమైన, మేము నేరుగా buggy2 ప్రారంభం చేస్తాము
GDB buggy2 కాబట్టి.
మేము మా కార్యక్రమం అమలు చేస్తే ఇప్పుడు, అది, ప్రోగ్రామ్ సిగ్నల్ SIGSEGV పొందింది చెప్పడానికి జరగబోతోంది
ఇది సిగ్నల్ segfault, మరియు జరిగి జరిగిన పేరు ఉంటుంది.
మా వెనుకకు వద్ద గురించి, మేము, మేము ఫంక్షన్ oh_no ఉన్నాయి చూడండి
ఇది ఫంక్షన్ binky ఏర్పాటు చేశారు ఫంక్షన్ పరిశుభ్రంగా, అనే
ప్రధాన ద్వారా పిలుస్తారు.
మేము కూడా ఈ విధులకు వాదనలు చూడగలరు.
పరిశుభ్రంగా మరియు binky కు వాదన 1 ఉంది.
మేము ఫంక్షన్ oh_no జాబితా ఉంటే, మేము oh_no కేవలం చార్ ** s = NULL చేస్తున్న ఆ చూడండి;
* S = "బూమ్";
ఎందుకు ఆ వైఫల్యం?
[విద్యార్థి] మీరు dereference నల్ పాయింటర్ కాదు? >> అవును.
ఒక చార్ ** నిర్మాణము ఈ కేవలం, సంబంధం లేకుండా, s NULL ఉంది అని
మీరు దానిని వ్యాఖ్యానిస్తారు ఆధారపడి, అది స్త్రింగ్ కి ఒక పాయింటర్ ఒక పాయింటర్ చేసే ఆ,
లేదా తీగలను యొక్క వ్యూహం.
ఇది s NULL ఉంది, కనుక * s, ఒక నల్ పాయింటర్ dereferencing ఉంది
మరియు ఈ క్రాష్ అన్నారు.
మీరు బహుశా segfault చేయవచ్చు శీఘ్రమైన ఒకటి.
ఇది కేవలం నల్ పాయింటర్ ప్రకటించారు మరియు తక్షణమే segfaulting యొక్క.
ఆ oh_no ఏమి ఉంది.
మేము ఒక ఫ్రేమ్ పెరుగుతుంది, అప్పుడు మేము oh_no అని ఆ ఫంక్షన్ పొందడానికి వెళుతున్న.
నేను క్రింద ఆ చేయాలి.
మీరు ఒక ఆదేశమును ప్రవేశపెట్టుము మరియు మీరు కేవలం, మళ్ళీ ఎంటర్ నొక్కండి
ఇది మీరు సాగిన మునుపటి ఆదేశం పునరావృతం.
మేము ఫ్రేమ్ 1 ఉన్నాయి.
ఈ ఫ్రేమ్ లిస్టింగ్, మేము ఇక్కడ మా విధి చూడండి.
మీరు మళ్ళీ జాబితా నొక్కండి, లేదా మీరు జాబితా 20 చేయవచ్చు మరియు మరింత జాబితా చేస్తుంది.
ఫంక్షన్ పరిశుభ్రంగా నేను 1 ఉంటే, అప్పుడు, oh_no ఫంక్షన్ కి వెళ్ళండి అన్నారు
ఇంకా slinky కు వెళ్ళండి.
మరియు మేము ఇక్కడ చూడటానికి ఏమి ఎందుకంటే నేను 1 తెలుసు
ఆ పరిశుభ్రంగా వాదన 1 తో పిలుస్తారు.
లేదా మీరు నేను ప్రింట్ చెయ్యాలి మరియు ఇది నేను 1 యున్నది.
మేము పరిశుభ్రంగా ఉంది, మరియు మేము మరొక ఫ్రేమ్ పెరుగుతుంది ఉంటే, మేము binky లో ముగుస్తుంది చేస్తాము తెలుసు.
అప్. ఇప్పుడు మేము binky లో ఉన్నాము.
సగం నాకు నరికి ముందు నుండి జాబితా - - ఈ ఫంక్షన్ లిస్టింగ్
నేను 0 ఉంటే అది ప్రారంభమైనది, అప్పుడు మేము దాన్ని oh_no కాల్ చూడాలని, లేకపోతే పరిశుభ్రంగా కాల్.
మేము నాకు 1 విషయం, కాబట్టి ఇది పరిశుభ్రంగా అని.
ఇప్పుడు మేము ప్రధాన తిరిగి వచ్చాక, మరియు ప్రధాన కేవలం Int i = RAND ()% 3 అన్నారు;
అది మీరు 0, 1, లేదా 2 ఒక యాదృచ్చిక సంఖ్య ఇవ్వాలని అన్నారు.
ఇది ఆ సంఖ్య binky కాల్ అవకాశముంది, మరియు అది 0 చూపిస్తుంది.
ఈ చూడటం,
కేవలం, తక్షణమే అమలు లేకుండా మానవీయంగా కార్యక్రమం ద్వారా వాకింగ్
మీరు ప్రధాన వద్ద ఒక బ్రేక్ పాయింట్ సెట్ చేస్తుంది, ఇది మేము అమలు చేసేటప్పుడు అర్థం
అది ఒక బ్రేక్ పాయింట్ హిట్స్ వరకు మీ ప్రోగ్రామ్ అప్ నడుస్తుంది.
ప్రోగ్రామ్ను అమలు కాబట్టి, అమలు చేస్తుంది మరియు అప్పుడు ప్రధాన విధి హిట్ మరియు అమలు చేయవు.
ఇప్పుడు మేము ప్రధాన లోపలి ఉన్నాము, మరియు దశ లేదా తదుపరి కోడ్ తదుపరి లైన్ మాకు చేసేందుకు ప్రయత్నిస్తుంది.
మీరు దశ లేదా తదుపరి చేయవచ్చు.
తదుపరి, హిట్టింగ్ ఇప్పుడు నేను RAND ()% 3, కాబట్టి మేము i యొక్క విలువ ముద్రించవచ్చు, సెట్ చెయ్యబడింది
మరియు నేను 1 యున్నది.
ఇప్పుడు అది రాబోయే లేదా దశను ఉపయోగిస్తున్నాయి లేదో అవసరం.
నేను ముందు లో ముఖ్యమని అంచనా, కానీ రాబోయే ఉపయోగించడానికి కావాలో.
మేము అడుగు ఉపయోగిస్తే, మేము ఫంక్షన్ లో అడుగు, వాస్తవ విషయం చూడు అర్థం
ఆ binky లోపలి జరుగుతున్నది.
రాబోయే ఉపయోగిస్తే, అప్పుడు అది ఫంక్షన్ వెళ్ళి అర్థం
మరియు మా ప్రధాన ఫంక్షన్ కోడ్ తదుపరి లైన్ వెళ్ళండి.
ఇక్కడే పై, నేను RAND ()% 3 చెప్పబడిన వద్ద ఉంది;
నేను అడుగు, ఇది RAND అమలు కానుందని
మరియు అక్కడ ఏం చూడండి, మరియు నేను RAND చర్య ద్వారా అడుగు కాలేదు.
కానీ నేను RAND ఫంక్షన్ గురించి పట్టించుకోను.
నేను ప్రధాన కోడ్ తదుపరి లైన్ కు వెళ్లాలని మీరు అనుకుంటున్నారా, నేను తరువాత ఉపయోగించండి.
కానీ ఇప్పుడు నేను binky ఫంక్షన్ గురించి జాగ్రత్త, అందుచే నేను చేయడానికి కావలసిన.
ఇప్పుడు నేను binky ఉన్నాను.
కోడ్ యొక్క మొదటి లైన్ (i == 0), నేను ఒక దశకు ఉంటే చెప్పండి అన్నారు,
మేము పరిశుభ్రంగా వద్ద ముగుస్తుంది చూడండి.
మేము జాబితా విషయాలు, మేము అది తనిఖీ ఉందని నేను = 0.
నేను 0 సమానం కాదు, కాబట్టి ఇది ఇంకా పరిస్థితి వెళ్ళాడు
ఇది పరిశుభ్రంగా (i) కాల్ అన్నారు.
మీరు అయోమయం get ఉండవచ్చు.
మీరు నేరుగా ఈ పంక్తులు చూడండి, మీరు భావిస్తే ఉండవచ్చు, (i == 0) ఉంటే
సరే,, అప్పుడు నేను ఒక అడుగు తీసుకుంది మరియు ఇప్పుడు నేను పరిశుభ్రంగా (i) వద్ద ఉన్నాను
మీరు ఆ i = 0 లేదా ఏదో ఒకటి ఉండాలి అనుకుంటున్నాను ఉండవచ్చు.
నం ఇది కేవలం అది లైన్ పరిశుభ్రంగా (i) నేరుగా అతుక్కుపోగలవు తెలుసని అర్థం.
నేను 0 కాబట్టి, తదుపరి దశలో మిగిలిన వద్ద ముగిసింది వెళ్ళడం లేదు.
ఎల్స్ ఇది వద్ద ఆపడానికి జరగబోతోంది ఒక లైన్ కాదు.
ఇది కేవలం నిజానికి ఇది (i) పరిశుభ్రంగా ఉంది, అమలు చెయ్యవచ్చు తదుపరి లైన్ వెళ్ళడానికి జరగబోతోంది.
పరిశుభ్రంగా (i) లోకి అడుగు పెట్టటం, మేము చూడండి (i == 1) ఉంటే.
దీనితో మేము అడుగు, మాకు oh_no వదులుకోవడానికి వెళుతున్న తెలుసు, నేను = 1 తెలుసు
i = 1 మీరు అడుగు ఇది ఫంక్షన్ oh_no, కాల్స్ ఎందుకంటే
సెట్ అన్నారు ఇది చార్ ** s = శూన్య వెంటనే "బూమ్" కు.
మరియు తర్వాత వాస్తవానికి, buggy2 అమలు చూడటం
0, 1, లేదా 2 - - కాలింగ్ binky, ఈ, నేను యాదృచ్ఛిక సంఖ్య పెరిగిపోతుంది
నేను 0 ఉంటే అది oh_no పిలిచే, లేకపోతే అది పరిశుభ్రంగా కాల్స్, ఇది ఇక్కడ వస్తుంది.
నేను, కాల్ oh_no 1 ఉంటే, వేరే ఇక్కడ వస్తున్న ఇది slinky కాల్
నేను 2 ఉంటే, oh_no కాల్.
నేను కూడా ఒక మార్గం ఉంది భావించడం లేదు -
ఎవరైనా ఈ segfault లేదు ప్రోగ్రామ్ మేకింగ్ ఒక మార్గం చూడండి లేదు?
నేను ఏదో మిస్ నేను తప్ప 0 ఉంటే, మీరు వెంటనే segfault చేస్తాము కాబట్టి,
ఇంకా మీరు, నేను మీరు segfault 1 ఉంటే ఒక ఫంక్షన్ కు వెళ్ళండి
ఇంకా మీరు నేను ఉంటే 2 మీరు segfault పేరు ఒక ఫంక్షన్ కు వెళ్ళండి.
ఏ మీరు ఏమి చేసినా కాబట్టి, మీరు segfault.
>> నేను, అది బదులుగా చార్ ** s = NULL చేయడం ఉంటుందని ఫిక్సింగ్ యొక్క ఒక మార్గం అంచనా
మీరు ఆ స్ట్రింగ్ స్థలాన్ని malloc కాలేదు.
Sizeof ఏ - మేము malloc (sizeof) చేయగల?
[విద్యార్థి] (చార్) * 5? >> ఈ కుడి అనిపించడం లేదు?
నేను నిజానికి ఇది నడిచింది, ఇది పనిచేస్తుంది ఊహించి నేను, కానీ నేను చూస్తున్నాను ఏమి కాదు.
S రకం వద్ద చూడండి. యొక్క Int * జోడించడానికి అనుమతిస్తుంది, అందువలన Int * x.
నేను (sizeof (Int)) malloc చేయరు.
లేదా నేను 5 యొక్క వ్యూహం కోరుకుంటే, I (sizeof (Int) * 5) అని;
నేను ఒక పూర్ణాంకానికి ** ఉంటే?
నేను malloc ఏమైంది?
పాయింటర్ యొక్క [విద్యార్థి] సైజు. >> అవును. (Sizeof (Int *));
డౌన్ ఇక్కడ ఇదే.
నేను (sizeof (చార్ *)) కావలసిన;
ఈ "బూమ్" పాయింతు ఆ పాయింటర్ స్థలాన్ని కేటాయించాలని అన్నారు.
నేను "బూమ్" దాని కొరకు ఖాళీ కేటాయించాల్సిన అవసరం లేదు
ఈ నేను ముందు మాట్లాడుతూ ప్రాథమికంగా సమానమైన ఎందుకంటే
చార్ యొక్క * x = "బూమ్".
"బూమ్" ఇప్పటికే ఉనికిలో ఉంది. ఇది మెమరీ యొక్క చదవడానికి మాత్రమే ఈ ప్రాంతంలో ఉన్నాయి నిర్మాణము.
S ఒక చార్ ** ఉంటే కానీ ఇప్పటికే, కోడ్ యొక్క ఈ లైన్ అంటే, ఉంది
అప్పుడు * s ఒక చార్ * మరియు మీరు "బూమ్" సూచించడానికి ఈ చార్ * సెట్ చేస్తున్నాము.
నేను s లోకి "బూమ్" కాపీ అనుకుంటే, అప్పుడు నేను s స్థలాన్ని కేటాయించే అవసరం.
నేను చేస్తాను * s = malloc (sizeof (చార్) * 5);
ఎందుకు 5?
ఎందుకు లేదు 4? "బూమ్" 4 అక్షరాలు ఉన్నట్లు తెలుస్తుంది. >> [విద్యార్థి] శూన్య పాత్ర.
అవును. మీ తీగల యొక్క అన్ని శూన్య పాత్ర అవసరం వెళ్తున్నారు.
ఇప్పుడు నేను strcat వంటి ఏదో ఒకటి చెయ్యాలి - స్ట్రింగ్ కాపీ కోసం కర్తవ్యం ఏమిటి?
[విద్యార్థి] cpy? >> Strcpy.
మనిషి strcpy.
కాబట్టి strcpy లేదా strncpy.
మీరు పేర్కొనవచ్చు నుండి strncpy ఒక బిట్ సురక్షితమైన ఎలా అనేక అక్షరాలు,
మేము తెలిసిన కారణంగా ఇక్కడ అది పెద్ద విషయం కాదు.
కాబట్టి strcpy మరియు వాదనలు చూడండి.
మొదటి వాదన మా గమ్యం.
రెండవ వాదన మా ఆధారం.
మేము మా గమ్యం * లోకి కాపీ చూడాలని పాయింటర్ "బూమ్" s.
ఎందుకు మీరు ముందు బదులుగా మేము కలిగి ఇప్పుడే ఏమి ఒక strcpy తో దీన్ని చేయాలనుకుంటున్నారా ఉండవచ్చు
* s యొక్క = "బూమ్"?
అక్కడ మీరు దీన్ని చేయాలనుకుంటున్నారా ఉండవచ్చు ఒక కారణం, కానీ ఆ కారణం ఏమిటి?
[విద్యార్థి] మీరు "బూమ్" కొంత మార్పు చేయండి. >> అవును.
ఇప్పుడు నేను s వంటి ఏదో ఒకటి చెయ్యాలి [0] = 'X';
s పాయింట్లు కుప్ప మీద నిండుగా మరియు space కి s కు సూచిస్తుంది ఎందుకంటే
"బూమ్" నిల్వ ఉన్న కుప్ప, మరింత స్థలం ఒక పాయింటర్ ఉంది.
కాబట్టి "బూమ్" ఈ కాపీని కుప్ప నిల్వ ఉంది.
మా కార్యక్రమంలో "బూమ్" యొక్క రెండు కాపీలు సాంకేతికంగా ఉన్నాయి.
ఈ "బూమ్" స్ట్రింగ్ స్థిరంగా ఇచ్చిన చేసే మొదటి ఒకటి, ఉంది
మరియు "బూమ్" యొక్క రెండవ కాపీ, strcpy "బూమ్" యొక్క కాపీని సృష్టించింది.
కానీ "బూమ్" యొక్క కాపీని కుప్ప నిల్వ, మరియు కుప్ప మీరు మార్చడానికి ఉచిత ఉన్నారు ఉంది.
కుప్ప చదవడానికి మాత్రమే కాదు, కాబట్టి అని s [0]
మీరు "బూమ్" యొక్క విలువను మార్చడానికి అనుమతిస్తుంది అన్నారు.
ఇది ఆ అక్షరాలు మార్చుకోవడానికి అనుమతించే జరగబోతోంది.
>> ప్రశ్నలు?
సరే.
>> , Buggy3 కు లెట్స్ GDB buggy3 వెళ్లడానికి.
మేము దానిని అమలు మరియు మేము ఒక segfault పొందండి చూడండి.
మేము వెనుకకు ఉంటే, కేవలం రెండు విధులు ఉన్నాయి.
మేము మా ప్రధాన విధి విభజించవచ్చు వెళ్ళి ఉంటే, మేము ఈ లైన్ వద్ద segfaulted ఆ చూడండి.
కాబట్టి కేవలం (కోసం, ఈ లైన్ చూడటం Int లైన్ = 0; fgets ఈ విషయాన్ని సమానం కాదు NULL చేస్తుంది;
లైన్ + +).
మా గత ఫ్రేమ్ _IO_fgets అని పిలిచేవారు.
ఆ అంతర్నిర్మిత సి విధులు చాలా, చూస్తారు
మీరు segfault వచ్చిన, నిజంగా గుప్తమైన ఫంక్షన్ పేర్లు ఉంటుందని
ఈ _IO_fgets ఇష్టపడుతున్నారు.
కానీ ఈ fgets కాల్ సంబంధం జరగబోతోంది.
ఎక్కడో ఇక్కడ లోపల, మేము segfaulting ఉంటాయి.
మేము fgets వాదనలు చేయడానికి విషయంలో చూస్తే, మేము బఫర్ ముద్రించవచ్చు.
యొక్క ప్రింట్ లెట్ ఒక - అరెరె.
ప్రింట్ నేను అది మీరు వెళ్లాలని లేదు.
యొక్క నిజమైన కార్యక్రమం చూద్దాం.
బఫర్ ఒక పాత్ర శ్రేణి. ఇది 128 అక్షరాలు ఒక పాత్ర శ్రేణి ఉంది.
నేను ప్రింట్ బఫర్ సే, అది, ఆ 128 అక్షరాలు ముద్రించడానికి జరగబోతోంది
ఇది నేను ఊహిస్తున్నాను అంచనా ఏమిటి.
నేను వెతుకుతున్న, బఫర్ యొక్క చిరునామా ప్రింట్ ఉంది
కానీ ఆ నన్ను చాలా చెప్పడు.
నేను ఇక్కడ x బఫర్ అప్ చెప్పడానికి జరిగే సమయంలో ఇది నన్ను 0xbffff090 చూపిస్తుంది
మీరు ముందు లేదా కొన్ని పాయింట్ నుండి గుర్తుంచుకుంటే, Oxbffff ఒక స్టాక్-ish ప్రాంతం ఉంటుంది, ఇది.
స్టాక్ కేవలం 0xc000 కింద ఎక్కడో మొదలు ఉంటుంది.
ఈ చిరునామా చూడటం ద్వారా, నేను బఫర్ స్టాక్ లో సంభవించే మనకు తెలుసు.
స్వీకరించేందుకు, అప్, అమలు, నా ప్రోగ్రామ్ పునఃప్రారంభం మేము ఉండేది అక్షరాలు ఈ క్రమంలో చూసిన
ఇది చాలా అర్థరహితమని.
అప్పుడు ఫైలు ప్రింటింగ్, ఏ ఫైలు ఎలా చేస్తుంది?
[విద్యార్థి] నల్. >> అవును.
, ఫైలు రకమైన ఫైల్ * యొక్క ఒక ఉంటుంది, అందువలన ఇది పాయింటర్ గా
మరియు ఆ పాయింటర్ విలువ NULL.
కాబట్టి fgets, ఒక పరోక్ష విధంగా ఆ పాయింటర్ నుండి చదవడానికి ప్రయత్నించండి అన్నారు
కానీ ఆ పాయింటర్ ప్రాప్యత చేయడానికి, అది dereference ఇది ఉంటుంది.
లేదా, అది dereferences ఇది సూచించే ఏ ప్రాప్యత చేయడానికి.
కాబట్టి దీనిని నల్ పాయింటర్ మరియు segfaults dereferencing యొక్క.
నేను అక్కడ అది పునఃప్రారంభం ఉండవచ్చు.
మేము మా ప్రధాన పాయింట్ వద్ద బ్రేక్ మరియు అమలు చేస్తే,
కోడ్ యొక్క మొదటి లైన్ చార్ * ఫైల్ = "nonexistent.txt" ఉంది;
ఈ కార్యక్రమం విఫలమైతే ఎందుకు ఒక అందమైన పెద్ద సూచనను ఇస్తుంది.
నేను ఈ ఫైల్ను తెరవడం పేరు తదుపరి టైప్, తర్వాత లైన్ నాకు తెస్తుంది
మరియు నేను వెంటనే ఒకసారి నేను తరువాత నొక్కండి పేరు మా లైన్, పొందడానికి, అది segfault చెప్పారు.
ఎవరైనా మేము segfaulting ఉండవచ్చు కారణాన్ని అవుట్ త్రో అనుకుంటుంది?
[విద్యార్థి] ఫైల్ ఉనికిలో లేదు. >> అవును.
ఈ సూచనను భావించబడేది
మీరు ఒక తెరుస్తోంది చేసినపుడు ఫైల్ వాస్తవానికి ఉందని అవసరమైన.
ఇక్కడ, "nonexistent.txt";
మేము చదవడానికి fopen FILENAME, మేము అప్పుడు చెప్పడానికి అవసరమైనప్పుడు
ఉంటే (ఫైలు == NULL) మరియు printf ("ఫైల్ ఉనికిలో లేదు!" అని
లేదా - ఇంకా బాగా - ఫైల్ పేరు); తిరిగి 1;
కాబట్టి ఇప్పుడు మేము ఇది NULL అని తెలుసుకోవడానికి కు చెక్
ముందు వాస్తవానికి నిరంతర మరియు ఫైల్ నుండి చదవడానికి ప్రయత్నించడంలో.
మేము ఆ పనులు చూడడానికి అది రీమేక్ చేయవచ్చు.
నేను ఒక కొత్త లైన్ ఉన్నాయి ఉద్దేశించబడింది.
కాబట్టి ఇప్పుడు nonexistent.txt లేదు.
మీరు ఎల్లప్పుడూ విషయం ఈ విధమైన కోసం తనిఖీ చేయాలి.
మీరు ఎల్లప్పుడూ fopen NULL తిరిగి ఉంటే చూడటానికి తనిఖీ చేయాలి.
మీరు ఎల్లప్పుడూ malloc NULL తిరిగి లేదు నిర్ధారించుకోండి ఉండాలి
లేదంటే segfault.
>> ఇప్పుడు buggy4.c.
రన్నింగ్. నేను ఇన్పుట్ లేదా బహుశా అనంతం మళ్ళీ వెతికినా కోసం వేచి ఉంది ఈ ఊహించడం చేస్తున్నాను.
అవును, ఇది అనంతమైన మళ్ళీ వెతికినా ఉంది.
Buggy4 కాబట్టి. మేము అనంతం మళ్ళీ వెతికినా కనిపిస్తుంది.
మేము ప్రధాన వద్ద విరిగిపోతాయి, మా ప్రోగ్రామ్ రన్.
GDB లో, కాలం మీరు ఉపయోగించే సంక్షిప్త నిర్ద్వంద్వంగా ఉంది
లేదా వారు మీ కోసం అందించే ప్రత్యేక నిర్వచనాలలో
అప్పుడు మీరు బదులుగా తర్వాత అన్ని వే అవుట్ టైప్ చేయడానికి తదుపరి ఉపయోగించడానికి n ఉపయోగించవచ్చు.
ఇప్పుడు నేను ఒకసారి నొక్కండి n చేసిన, నేను తర్వాతి కొనసాగించడాన్ని ఎంటర్ నొక్కండి
బదులుగా హిట్ n ఎంటర్ n ఎంటర్ n నమోదు చేయండి కలిగి.
నేను [i] 0 to శ్రేణి సెట్ చేసే లూప్ ఒకరకమైన ఉన్నాను కనిపిస్తుంది.
నేను లూప్ ఈ యొక్క బద్దలు ఎప్పుడూ am కనిపిస్తోంది.
నేను ప్రింట్ నేను 2 ఉంటే, అప్పుడు నేను తరువాత వెళ్తారో.
నేను తరువాత వెళ్తారో తర్వాత, నేను 3, నేను ప్రింట్ చేస్తాము.
నేను ప్రింట్ చేస్తాము మరియు నేను 3. తరువాత, నేను ప్రింట్ నేను 4 ఉంటుంది.
అసలైన, ముద్రణ sizeof (శ్రేణి), కాబట్టి శ్రేణి యొక్క పరిమాణం 20.
కొన్ని ప్రత్యేక GDB ఆదేశం ఏదో జరుగుతుంది వరకు వెళ్లి కోసం ఉన్నట్లు కానీ కనిపిస్తోంది.
ఇది వేరియబుల్ విలువ పరిస్థితిని సెట్ వంటిది. కానీ నేను అది గుర్తు లేదు.
- మేము కొనసాగించడాన్ని అయితే
మీరు ఏమి అంటున్నారు చేశారు? మీరు ఏ తీసుకురావటానికి చేశారు?
[విద్యార్థి] ప్రదర్శించు జత చేస్తుంది - >> అవును. నేను సహాయపడుతుంది ప్రదర్శిస్తాయి.
మేము కేవలం నేను ప్రదర్శించడానికి, అది నేను విలువ ఏమిటి ఇక్కడ ప్రదర్శించాలి
నేను ప్రతిసారీ దాన్ని ముద్రించడానికి లేదు.
మేము తర్వాతి వెళ్ళి ఉంటే, మేము 0, 1, 2, 3, 4, 5, 0, 1, 2, 3, 4, 5, 0, 1, 2, 3, 4, 5 చూడండి.
ఏదో భయంకరమైన తప్పు అంటే, నేను 0 రీసెట్ చేయబడుతుంది.
Buggy4.c వద్ద గురించి, మేము జరిగినప్పుడు అన్ని Int శ్రేణి [5] చూడండి;
(; i <= sizeof (శ్రేణి); i + + i = 0) కోసం
అర్రే [i] = 0;
మేము ఇక్కడ తప్పు ఏమి చూస్తారు?
ఒక సూచన, నేను GDB buggy4 చేస్తున్న సమయంలో - ప్రధాన, రన్ బ్రేక్ యొక్క Let -
నేను ప్రింట్ sizeof (శ్రేణి) కేవలం చివరికి నేను బయటకు ఎక్కడ పరిస్థితి చూడటానికి లేదు.
నేను ఎక్కడ వున్నాను? నేను అయిపోయాయా?
నేను ఇంకా డిక్లేర్ లేదు.
కాబట్టి, sizeof (శ్రేణి) ముద్రించడానికి మరియు 20 ల
ఇది నా అర్రే పరిమాణం 5 యొక్క ఎందుకంటే అంచనా మరియు ఇది 5 పూర్ణాంకాల అని
కాబట్టి మొత్తం విషయం sizeof (Int) 4 ఉంటుంది పేరు 5 * sizeof (Int) బైట్లు ఉండాలి.
కాబట్టి sizeof (శ్రేణి) 20.
ఈ ఉండాలి?
[విద్యార్థి] sizeof (Int) ద్వారా విభజించబడింది. >> అవును, / sizeof (Int).
ఒక సమస్య ఇక్కడ ఇప్పటికీ ఉన్నట్లు కనిపిస్తోంది. నేను ఈ కేవలం ఉండాలి అనుకుంటున్నాను <
ఇది ఎల్లప్పుడూ ల నాటినుండి <మరియు ఎప్పుడూ <=.
ఇప్పుడు ఈ వాస్తవానికి ఉల్లంఘించబడింది ఎందుకు భావిస్తున్నాను తెలియజేయండి.
ఎవరైనా నేను లూప్ యొక్క ప్రతి పునరావృతం ద్వారా 0 to అంచనాలు రీసెట్ జరిగినది ఉంటాయా?
ఇక్కడ జరుగుతున్నది ఆ లోపలి మాత్రమే విషయం [i] 0 సెట్ చేయబడుతుంది శ్రేణి.
కాబట్టి ఏదో, కోడ్ యొక్క ఈ లైన్ నేను 0 కు సెట్ మా Int చేస్తుంది.
నేను ఈ భాగాన్ని మెమరీ భర్తీ ఎందుకంటే [విద్యార్థి] ఎంత
అది యెరే యొక్క తదుపరి ఎలిమెంట్? ఆలోచించినప్పుడు >> [బౌడెన్] అవును.
మేము మా శ్రేణి ముగింపు దాటుకొని చేసిన తర్వాత,
మేము భర్తీ చేస్తున్న ఎలానో ఆ స్థలం నేను విలువ భర్తీ చేయబడుతుంది.
మేము buggy4 పరిశీలిస్తాము ఉంటే కనుక, ప్రధాన, రన్ బ్రేక్
యొక్క నేను యొక్క చిరునామా ప్రింట్ తెలియజేయండి.
అది bffff124 యొక్క కనిపిస్తుంది.
ఇప్పుడు యొక్క శ్రేణి యొక్క చిరునామా ప్రింట్ వీలు [0]. 110.
ఏమి [1] గురించి? 114.
[2], 118.
11C సంఖ్య కలవి, 120. అర్రే [5] bfff124 ఉంది.
అర్రే కాబట్టి [5] నేను, ఆ శ్రేణి [5] ఐ అంటే అదే చిరునామాను కలిగి ఉంటుంది.
వారు అదే చిరునామా ఉంటే, వారు ఇదే ఉంటాయి.
కాబట్టి మేము శ్రేణి [5] పెట్టినప్పుడు 0, మేము 0 నేను సెట్ చేస్తారు.
మరియు మీరు స్టాక్ పరంగా ఈ గురించి అనుకుంటే,
Int నేను స్టాక్ కొన్ని అంతరిక్ష అవుతుందని అర్ధం, ఇది మొదటి ప్రకటిస్తారు.
అప్పుడు శ్రేణి [5] అందువలన 20 బైట్లు స్టాక్ న కేటాయించబడతాయి, కేటాయించబడుతుంది.
నేను అప్పుడు ఈ 20 బైట్లు కేటాయించింది get, మొదటి కేటాయించింది తీర్చుకుంటాడు.
నేను, కుడి అమరిక ముందు జరుగుతుంది
మరియు పద్ధతి కారణంగా, నేను, సాంకేతికంగా స్టాక్ డౌన్ పెరుగుతుంది, గత వారం చెప్పారు
వ్యూహం లోకి మీరు ఇండెక్స్, మేము హామీ పరిధిలో 0th స్థానం
ఎల్లప్పుడూ యెరే నందలి మొదటి స్థానం ముందు జరుగుతుంది.
ఈ నేను గత వారం ఇది ఆకర్షించింది ఎలా రకం.
దిగువన మేము చిరునామా 0 కలిగి మరియు ఎగువన మేము చిరునామా మాక్స్ మేము గుర్తించాము.
స్టాక్ ఎల్లప్పుడూ డౌన్ పెరుగుతోంది.
లెట్ యొక్క మేము నేను కేటాయించాలని చెప్పారు.
మేము పూర్ణాంక కేటాయించాలని నేను, లెట్స్ కేవలం ఇక్కడ పూర్ణాంకం నేను కేటాయించింది అవుతుంది అప్ సే అంటే.
అప్పుడు ఆ కింద అంటే 5 పూర్ణాంకాల మా అర్రే,, కేటాయించాలని
స్టాక్ డౌన్ పెరుగుతోంది నుండి, ఆ 5 పూర్ణాంకాల కేటాయించింది కలుగుతుంది.
కానీ శ్రేణుల పని ఎలా ఎందుకంటే, మేము హామీ చేస్తున్న యెరే నందలి మొదటి స్థానం
ఎల్లప్పుడూ శ్రేణి రెండవ విషయం కంటే తక్కువ ఒక చిరునామాను కలిగి ఉంటుంది.
కాబట్టి శ్రేణి స్థానం 0 ఎప్పుడూ మెమరీలో మొదటి జరిగే ఉంది
అర్రే స్థానం 1 ఆ తర్వాత జరిగే ఉంది అయితే
యెరే స్థానం 2, ఆ తర్వాత జరిగే ఉంది
ఇది ఆ శ్రేణి స్థానం 0, డౌన్ ఇక్కడ ఎక్కడో జరుగుతుంది అంటే
అర్రే స్థానం 1 ఆ పైన జరుగుతుంది
పైకి కదలడం గరిష్ట చిరునామా ఇక్కడ నుంచి అధిక చిరునామాలను అర్థం. ఎందుకంటే
డౌన్ ఇక్కడ శ్రేణి [0] కాబట్టి, అర్రే [1] ఇక్కడ, అర్రే [2] ఇక్కడ, అర్రే [3] వరకు ఇక్కడ.
మేము ఇక్కడ నేను అన్ని మార్గం అప్, పూర్ణాంక కేటాయించింది ఎలా ముందు గమనించండి
మేము మా శ్రేణి మరింత మరియు మరింత ప్రయాణంలో, మేము దగ్గరగా మరియు దగ్గరగా మా పూర్ణాంక నేను అందుకుంటున్నారు.
ఇది కేవలం కాబట్టి, ఇది మా శ్రేణి మించి ఒక స్థానం, ఆ శ్రేణి [5] జరిగినప్పుడు
నేను కేటాయించింది సంభవించింది పేరు పూర్ణ సంఖ్య.
కాబట్టి మేము స్టాక్ న స్పేస్ కొట్టడం కావడం పేరు పాయింట్
ఆ పూర్ణాంక నేను కోసం కేటాయించారు, మరియు మేము ఆ 0 to సెట్ చేస్తున్నాము.
>> ఆ పని ఎలా. ప్రశ్నలు? అవును.
[విద్యార్థి] ఫరవాలేదు. సరే.
[విద్యార్థి] ఎలా మీరు లోపాలు ఈ రకమైన తప్పించాలి?
లోపాలు ఈ రకమైన? మీ ప్రోగ్రామింగ్ భాష వంటి C ఉపయోగించకండి.
తనిఖీ శ్రేణి హద్దులు లేని ఒక భాష ఉపయోగించండి.
కాలం మీరు జాగ్రత్తగా చేస్తున్నపుడు, మీరు మీ శ్రేణి యొక్క సరిహద్దులు గత వెళ్లి దూరంగా ఉండాలి.
[విద్యార్థి] ఇక్కడ మేము మీ శ్రేణి యొక్క సరిహద్దులు గత వెళ్లిన -
[బౌడెన్] విషయాలను తప్పు వెళ్ళి మొదలు పేర్కొంది. >> [విద్యార్థి] ఓహ్, ఓకే.
కాలం మీరు మీ శ్రేణి కోసం కేటాయించిన మెమొరీ లో ఉండడానికి, మీరు జరిమానా ఉన్నారు.
కానీ సి ఏ దోష పరిశీలన చేస్తుంది. నేను శ్రేణి చేస్తే [1000], ఇది కేవలం సంతోషముగా ఏది సవరించడానికి కనిపిస్తుంది -
ఇది అర్రే ప్రారంభంలో వెళుతుంది, అప్పుడు అది తర్వాత 1000 స్థానాలు వెళుతుంది మరియు 0 కు అమర్చుతుంది.
ఇది OH ఇది నిజానికి అది 1000 విషయాలు లేదు ఏ తనిఖీని విధంగా లేదు.
1000, వే ఐ మార్పులు ఏ మించిన
జావా లేదా ఏదో మీరు హద్దులు ఇండెక్స్ యొక్క శ్రేణి అవుట్ పొందుతారు అయితే
లేదా హద్దులు మినహాయింపు యొక్క సూచిక.
ఉన్నత స్థాయి భాషల చాలా విషయాలు ఈ ఎందుకు ఆ
మీరు శ్రేణి యొక్క సరిహద్దులు దాటి వెళ్ళండి ఉంటే, అక్కడ మీరు విఫలం
మీరు క్రింద నుండి అంశాలను మార్చలేరు కాబట్టి
మరియు తర్వాత విషయాలు కేవలం ఒక మినహాయింపు పొందడానికి కంటే చెత్తగా వెళ్ళి
మీరు శ్రేణి ముగింపు మించి జరిగింది చెప్పాడు.
[విద్యార్థి] అందువలన మేము మార్చబడింది ఉండాలి <= కేవలం <? >> [బౌడెన్] అవును.
ఇది <sizeof (శ్రేణి) / sizeof (Int) ఉండాలి;
sizeof (శ్రేణి) 20, కానీ మేము కేవలం 5 కావలసిన నుండి. >> [విద్యార్థి] రైట్.
మరిన్ని ప్రశ్నలు? సరే.
>> [విద్యార్థి] నేను ఒక ప్రశ్న కలిగి ఉంటాయి. >> అవును.
[విద్యార్థి] వాస్తవ శ్రేణి వేరియబుల్ ఏమిటి?
[బౌడెన్] ఇలా శ్రేణి ఏమిటి?
అర్రే కూడా గుర్తు.
ఇది కేవలం మేము సూచిస్తూ ఉంటాయి 20 బైట్లు ప్రారంభంలో యొక్క చిరునామా.
మీరు ఒక పాయింటర్ గా భావిస్తారు, కానీ అది స్థిరమైన పాయింటర్ ఉంది.
వెంటనే విషయాలు సంకలనం కొద్ది వేరియబుల్ శ్రేణి ఇకపై ఉనికిలో లేదు.
[విద్యార్థి] కాబట్టి ఎలా శ్రేణి యొక్క పరిమాణం కనుగొనేందుకు లేదు?
అర్రే పరిమాణం ఆ గుర్తు సూచిస్తుంది ఆ బ్లాక్ యొక్క పరిమాణం సూచిస్తుంది.
నేను printf లాగ ("% p \ n", అర్రే) చేసినప్పుడు;
యొక్క అమలు అనుమతిస్తాయి.
నేను ఏం తప్పు చేసావ్?
అర్రే 'శ్రేణి' ఇక్కడ ప్రకటించింది.
ఓహ్, ఇక్కడ.
గణగణమని ద్వని చేయు తెలివైన, మరియు ఇది నేను 5 అంశాలు వంటి శ్రేణి ప్రకటించింది అని గుర్తించలేకపోతే జరుగుతుంది
కానీ నేను స్థానం 1000 లో సూచి నేను.
ఈ కేవలం స్థిరాంకాలు ఉంటాయి ఎందుకంటే ఇది ఆ చేయవచ్చు.
ఇది మాత్రమే నేను శ్రేణి యొక్క సరిహద్దులు దాటి వెళుతున్న ఆ గమనిస్తున్నారు ఇప్పటివరకు వెళ్ళవచ్చు.
కానీ, మేము నేను సరైనది ఉన్నప్పుడు ముందు గమనించి
అది, నేను పడుతుంది ఎన్ని విలువలు కనుగొనలేదు
కాబట్టి నేను శ్రేణి ముగింపు దాటుకొని ఆ కనుగొనలేదు.
అది తెలివైన ఉండటం గణగణమని ద్వని చేయు ఉంది.
>> కానీ ఇప్పుడు buggy4 చేయండి. నేను తప్పు ఏమి చేస్తున్న?
నిస్సందేహంగా లైబ్రరీ ఫంక్షన్ 'printf' ప్రకటించారు.
నేను # చేర్చాలనుకుంటే వెళుతున్న.
సరే. ఇప్పుడు buggy4 అమలు.
వంటి శ్రేణి యొక్క విలువ ముద్రణ నేను పాయింటర్ గా ప్రింటింగ్, ఇక్కడ చేసింది
ఈ కనిపించే ప్రింట్లు ఏదో - bfb8805c - కొన్ని చిరునామా ఇది
ఆ స్టాక్-ish ప్రాంతంలో ఉంది.
, అర్రే కూడా ఒక పాయింటర్ వలె ఉంటుంది, కాని అది అసలైన పాయింటర్ కాదు
ఒక సాధారణ పాయింటర్ నుండి మేము మార్చవచ్చు.
అర్రే కొన్ని స్థిరాంకం. మెమరీ యొక్క 20 బ్లాక్లను చిరునామా 0xbfb8805c వద్ద ప్రారంభించండి.
ఈ చిరునామా ద్వారా కాబట్టి bfb8805c +20- లేదా నేను -20 అంచనా -
ఈ శ్రేణి కోసం కేటాయించిన మెమొరీ యొక్క అన్ని ఉంటుంది.
అర్రే, వేరియబుల్ కూడా ఎక్కడైనా నిల్వ చెయ్యబడదు.
మీరు కంపైల్ చేసినప్పుడు, కంపైలర్ - ఇది వద్ద చేతి అల -
అది యెరే అని తెలుసు కానీ పేరు కంపైలర్ కేవలం ఉపయోగిస్తారు.
ఆ శ్రేణి ప్రారంభిస్తారు ఇది తెలుసు
మరియు కనుక ఇది ఎల్లప్పుడూ ఆ ప్రారంభం నుండి ఆఫ్సెట్లు పరంగా చేయవచ్చు.
ఇది అర్రే ప్రాతినిధ్యం ఒక వేరియబుల్ కూడా అవసరం లేదు.
కానీ నేను Int * p = శ్రేణి వంటి ఏదో చేసినప్పుడు; ఇప్పుడు p, ఆ శ్రేణి చూపాడు ఒక పాయింటర్ గా
మరియు ఇప్పుడు p నిజానికి స్టాక్ మీద ఉందా.
నేను p మార్చడానికి ఉచిత ఉన్నాను. నేను p = malloc చేయవచ్చు.
కాబట్టి ఇది శ్రేణి సూచించాడు; ఇప్పుడు కుప్ప మీద కొన్ని అంతరిక్ష సూచిస్తుంది.
నేను శ్రేణి = malloc చెయ్యలేరు.
గణగణమని ద్వని చేయు తెలివైన ఉంటే, అది కుడి బ్యాట్ ఆఫ్ నాకు అరుస్తుంటారు కనిపిస్తుంది.
అసలైన, నేను gcc చాలా ఈ చేయరు అందంగా ఖచ్చితంగా అనుకుంటున్నాను.
కాబట్టి శ్రేణి రకం 'Int [5]' కేటాయించలేని కాదు.
మీరు ఒక అర్రే రకం ఏదైనా కేటాయించి కాదు
అర్రే ఒక స్థిరమైన ఎందుకంటే.
ఇది సూచనలు ఆ 20 బైట్లు గుర్తు. నేను మార్చలేరు.
>> [విద్యార్థి] యెరే యొక్క పరిమాణం పేరు నిల్వ చేయబడుతుంది?
[బౌడెన్] ఇది ఎక్కడైనా నిల్వ లేదు. ఇది కంపైల్ ఎప్పుడు ఇది.
కాబట్టి శ్రేణి యొక్క పరిమాణం పేరు నిల్వ చేయబడుతుంది?
మీరు శ్రేణి కూడా ప్రకటిస్తారు ఆ ఫంక్షన్ యొక్క లోపల sizeof (శ్రేణి) ఉపయోగించవచ్చు.
నేను కొన్ని ఫంక్షన్, foo, ఏమి మరియు నేను అలా అయితే (Int శ్రేణి [])
printf ("% d \ n", sizeof (శ్రేణి));
ఆపై డౌన్ ఇక్కడ నేను foo (శ్రేణి) కాల్;
ఈ చర్యను లోపల - యొక్క అమలు అనుమతిస్తాయి.
మళ్ళీ తెలివైన ఉండటం గణగణమని ద్వని చేయు ఉంది.
ఇది నాకు చెప్పుచున్నారు ఆ శ్రేణి ఫంక్షన్ పారామీటర్ sizeof
'Int *' యొక్క పరిమాణం తిరిగి కనిపిస్తుంది.
అది ఏమి అనుకున్నవే కాదు ఈ లోపం ఉంటుంది.
యొక్క వాస్తవానికి Werror ఆఫ్ లెట్.
హెచ్చరిక. హెచ్చరికలు జరిమానా ఉంటాయి.
అది ఒక హెచ్చరిక ఉంది ఇది ఇప్పటికీ కాలం కంపైల్ కనిపిస్తుంది.
. / A.out 4 ప్రింట్ అన్నారు.
ఉత్పత్తి చేసే హెచ్చరిక వాట్ వెంట్ రాంగ్ యొక్క స్పష్టమైన సూచనగా చెప్పవచ్చు.
ఈ Int శ్రేణి కేవలం sizeof (Int *) ముద్రించడానికి అన్నారు.
నేను ఇక్కడ శ్రేణి [5] ఉంచండి ఒకవేళ, ఇది కేవలం sizeof (Int *) ముద్రించడానికి జరగబోతోంది.
కాబట్టి వెంటనే మీరు ఒక ఫంక్షన్ లో పాస్ వంటి శ్రేణుల మరియు గమనికలు మధ్య వ్యత్యాసం
లేని ఉంది.
ఇది స్టాక్ న ప్రకటించబడింది ఒక అర్రే నిర్మాణము
కానీ త్వరలో ఆ విలువలను పాటిస్తూ ఆ 0xbf బ్లా, బ్లా, ఈ ఫంక్షన్ కు బ్లా,
ఈ పాయింటర్ స్టాక్ ఆ శ్రేణి చూపాడు.
Sizeof మాత్రమే శ్రేణి ప్రకటించబడింది ఆ ఫంక్షన్ లో వర్తిస్తుంది అంటే, అందువలన
అంటే మీరు, ఈ ఫంక్షన్ కంపైల్ చేసినప్పుడు
గణగణమని ద్వని చేయు ఈ చర్య ద్వారా వెళుతుంది, ఇది అర్రే పరిమాణం 5 యొక్క ఒక పూర్ణాంకానికి శ్రేణి చూస్తాడు.
కాబట్టి అప్పుడు sizeof (శ్రేణి) చూస్తాడు. అయితే, అది 20 ల.
ఆ sizeof ప్రధానంగా దాదాపు అన్ని సందర్భాలలో ఎలా పనిచేస్తుంది నిజానికి ఉంది.
Sizeof ఒక క్రియ కాదు; ఇది ఒక ఆపరేటర్లు ఉంది.
మీరు sizeof ఫంక్షన్ కాల్ లేదు.
Sizeof (Int), కంపైలర్ ఆ 4 అనువదిస్తుంది.
అర్థమైంది? సరే.
>> [విద్యార్థి] కాబట్టి ప్రధాన మరియు foo లో sizeof (శ్రేణి) మధ్య తేడా ఏమిటి?
మేము రకం Int * చెప్పవచ్చు sizeof (శ్రేణి), ఈ విధంగా చేసిన ఎందుకంటే
అర్రే డౌన్ ఇక్కడ కాదు రకం Int * యొక్క అయితే, అది ఒక పూర్ణాంకానికి శ్రేణి ఉంది.
>> [విద్యార్థి] కాబట్టి మీరు శ్రేణి [] బదులుగా Int * శ్రేణి లో పారామితి కలిగి ఉంటే,
ఇప్పుడు అది ఒక పాయింటర్ ఎందుకంటే మీరు ఇప్పటికీ శ్రేణి మార్చుకునేది అర్థం?
[బౌడెన్] ఈ నచ్చిందా? >> [విద్యార్థి] అవును. మీరు ఇప్పుడు ఫంక్షన్ లో అర్రే మార్చవచ్చు?
[బౌడెన్] మీరు రెండు సందర్భాలలో శ్రేణి మారిపోవచ్చు.
ఈ కేసుల్లో రెండు మీరు శ్రేణి [4] = 0 చెప్పడానికి ఉచితం.
[విద్యార్థి] కానీ మీరు ఏదో కు శ్రేణి పాయింట్ చేయవచ్చు?
[బౌడెన్] ఓహ్. అవును. ఏ సందర్భంలో - >> [విద్యార్థి] అవును.
[బౌడెన్] శ్రేణి [] మరియు ఒక పూర్ణాంకానికి * శ్రేణి మధ్య వ్యత్యాసం, ఏదీ.
మీరు ఇక్కడ కొన్ని బహుమితీయ శ్రేణి పొందవచ్చు
కొన్ని అనుకూలమైన సింటాక్స్ కోసం, కాని ఇప్పటికీ ఒక పాయింటర్ ఉంది.
ఈ నేను శ్రేణి చేయడానికి ఉచిత am అంటే = malloc (sizeof (Int)); మరియు ఇప్పుడు ఎక్కడైనా అభిప్రాయపడుతున్నారు.
కానీ, ఈ ఎప్పటికీ మరియు ఎల్లప్పుడూ ఎలా పనిచేస్తుంది ఇష్టం
అది ద్వారా ఈ శ్రేణి మారుతున్న ఏదో సూచించడానికి
అది, వాదన యొక్క ఒక కాపీని ఎందుకంటే ఇక్కడ ఈ శ్రేణి డౌన్ మారదు
ఆ వాదన ఒక పాయింటర్ కాదు.
మరియు వాస్తవానికి, దీనిని అదే అని మరింత సూచన వంటి -
మేము ఇప్పటికే ముద్రణ అమరిక ప్రింట్లు చూసిన -
మనం శ్రేణి యొక్క చిరునామా లేదా శ్రేణి యొక్క చిరునామా చిరునామా ప్రింట్ ఉంటే
వారిలో ను?
యొక్క ఈ ఒక విస్మరించండి లెట్.
సరే. ఈ ఉత్తమంగా ఉంటుంది. ఇది ఇప్పుడు. / A.out నడుస్తున్న యొక్క.
ప్రింటింగ్ అర్రే, అప్పుడు శ్రేణి యొక్క చిరునామా ప్రింటింగ్, ఇదే ఉంటాయి.
అర్రే కేవలం లేదు.
మీరు శ్రేణి ప్రింటింగ్ చేసినప్పుడు, మీరు ఆ 20 బైట్లు సూచిస్తుంది గుర్తు ప్రింటింగ్ చేసిన తెలుసు.
యెరే యొక్క చిరునామా ముద్రణ, అలాగే, అర్రే లేదు.
ఇది ఒక చిరునామా లేదు, కాబట్టి అది కేవలం ఆ 20 బైట్లు యొక్క చిరునామా ముద్రిస్తుంది.
వెంటనే మీకు డౌన్ కంపైల్ వంటి, మీ సంకలనం buggy4 లాగే. / A.out
అర్రే లేని ఉంది.
గమనికలు ఉన్నాయి. వ్యూహాలను లేదు.
అర్రే ప్రాతినిధ్యం మెమరీ బ్లాక్లు ఇప్పటికీ ఉనికిలో
కానీ వేరియబుల్ శ్రేణి మరియు ఆ రకమైన వేరియబుల్స్ లేవు.
ఆ శ్రేణుల మరియు గమనికలు మధ్య ప్రధాన తేడాలు లాగా ఉంటాయి
వెంటనే మీకు ఫంక్షన్ కాల్స్ వంటి, ఏ తేడా ఉంటాయి.
కానీ లోపల శ్రేణి కూడా ప్రకటిస్తారు ఆ ఫంక్షన్ యొక్క, sizeof విభిన్నంగా పని చేస్తుంది
మీరు బదులుగా రకం పరిమాణం బ్లాక్లు పరిమాణం ప్రింటింగ్ ఉన్నందున,
అది ఒక గుర్తు ఎందుకంటే మరియు మీరు మార్చలేరు.
విషయం యొక్క విషయం మరియు చిరునామా ముద్రణ ఇదే ముద్రిస్తుంది.
అంతే అందంగా ఎక్కువ.
[విద్యార్థి] మీరు ఆ మరొకసారి చెప్పండి కాలేదు?
నేను ఏదో తాకలేదని.
యెరే యొక్క ప్రింటింగ్ శ్రేణి మరియు చిరునామా, ఇదే ముద్రిస్తుంది
మీరు పాయింటర్ యొక్క చిరునామా వర్సెస్ ఒక పాయింటర్ ప్రింట్ ఉంటే అయితే,
ఒక విషయం మీరు సూచించే ఏమి యొక్క చిరునామా ముద్రిస్తుంది,
ఇతర స్టాక్ పాయింటర్కు యొక్క చిరునామా ముద్రిస్తుంది.
మీరు ఒక పాయింటర్ మార్చవచ్చు; మీరు వ్యూహం గుర్తు మార్చలేరు.
మరియు sizeof పాయింటర్ ఆ పాయింటర్ రకం పరిమాణం ప్రింట్ అన్నారు.
కాబట్టి Int * p sizeof (p), 4 ప్రింట్ అన్నారు
కానీ Int శ్రేణి [5] ముద్రణ sizeof (శ్రేణి) 20 ప్రింట్ అన్నారు.
[విద్యార్థి] కాబట్టి Int శ్రేణి [5] 20 ముద్రిస్తుంది? >> అవును.
ఎందుకు లోపల buggy4 ఇది sizeof (శ్రేణి) గా వాడినప్పుడు ఆ
ఈ i <20 చేస్తున్న, ఇది మేము అనుకున్నవే కాదు.
మేము i <5 కావలసిన. >> [విద్యార్థి] సరే.
[బౌడెన్] మరియు తరువాత వెంటనే మీకు విధులు అక్కడ మొదలు వంటి,
మేము ఉంటే Int * p = శ్రేణి;
ఈ చర్యను లోపల, మేము సాధారణంగా, అదే విధాలుగా p మరియు యెరే ఉపయోగించవచ్చు
sizeof సమస్య మరియు మారుతున్న సమస్య తప్ప.
కానీ పే [0] = 1; శ్రేణి [0] = 1 మాట్లాడుతూ ఒకటే;
మరియు సాధ్యమైనంత త్వరలో foo (శ్రేణి) చెప్పగలను; లేదా foo (p);
foo ఫంక్షన్ లోపలి ఈ రెండుసార్లు అదే పిలుపు.
ఈ రెండు కాల్స్ మధ్య తేడా ఉంది.
>> ఆ మంచి అందరూ? సరే.
మేము 10 నిమిషాలు.
>> మేము, ఈ హ్యాకర్ Typer కార్యక్రమం ద్వారా పొందండి ప్రయత్నిస్తాము
గత ఏడాది లేదా ఏదో బయటకు వచ్చిన ఈ వెబ్సైట్.
మీరు యాదృచ్ఛికంగా టైప్ మరియు దీనిని ముద్రిస్తుంది వంటి అది రావలసిన ఉంటాడు -
ఏమైనప్పటికీ ఫైలు అది లోడ్ చేసిన జరిగినప్పుడు మీరు టైప్ కనిపిస్తుంది ఏమిటి.
ఇది ఆపరేటింగ్ సిస్టమ్ కోడ్ రకమైన కనిపిస్తోంది.
అంటే అమలు చేయడానికి ఏమి ఉంది.
మీరు hacker_typer అనే బైనరీ ఎక్సిక్యూటబుల్ ఉండాలి
ఆ ఫైల్, ఒక వాదన లో పడుతుంది "హ్యాకర్ రకం."
Executable రన్నింగ్ స్క్రీన్ క్లియర్ చేయాలి
మరియు తరువాత వినియోగదారు ఒత్తిడి పరికరాలు కీ ప్రతి కాలం లో ఫైల్ నుండి ఒక పాత్రను ప్రింట్.
మీరు నొక్కండి ఏ కీ కాబట్టి, త్రో ఇట్ అవే మరియు బదులుగా ఫైల్ నుండి ఒక పాత్ర ప్రింట్ ఉండాలి
ఆ వాదన ఉంది.
నేను చాలా చక్కని మేము తెలుసుకోవాలి చూడాలని విషయాలు మీకు చెబుతాడని.
కానీ మేము termios లైబ్రరీ తనిఖీ మీరు.
నా జీవితకాలంలో ఈ లైబ్రరీ వాడలేదు, కాబట్టి అది చాలా తక్కువ ఉద్దేశాలు.
కానీ ఈ మీరు హిట్ పాత్ర తీసివేసినట్లు ఉపయోగించవచ్చు లైబ్రరీ అని అన్నారు
మీరు ప్రామాణిక టైప్ చేసినప్పుడు
కాబట్టి hacker_typer.c, మరియు మేము # చేర్చాలనుకుంటే చూడాలని.
Termios కోసం మనిషి పేజీ వద్ద గురించి - I'm అది యొక్క టెర్మినల్ OS లేదా ఏదో ఊహించడం -
నేను చదవడానికి నాకు తెలియదు.
ఈ వద్ద గురించి, ఈ 2 ఫైల్స్ కు చెప్పారు, కాబట్టి మేము ఆ పని చేస్తాము.
>> మొదటి విషయం మొదటి, మేము తెరిచి ఉండాలి ఫైలు ఇది ఒక వాదన, లో తీసుకొవాలనుకోవటము.
నేను ఏమి అనుకుంటున్నారు? నేను ఒక వాదన కలిగి చూడటానికి తనిఖీ చెయ్యాలి?
[విద్యార్థి] argc అది సమానం ఉంటే. >> [బౌడెన్] అవును.
అయితే (argc = 2!) Printf ("ఉపయోగం:% s [ఫైలు తెరవడానికి]").
నేను రెండవ వాదన అందించకుండా ఈ అమలు చేస్తే ఇప్పుడు - ఓహ్, నేను కొత్త లైన్ అవసరం -
మీరు చెప్పింది వాడుక చూస్తారు:. / hacker_typer,
తరువాత రెండవ వాదన నేను తెరిచి మీరు ఫైల్ ఉండాలి.
ఇప్పుడు నేను ఏమి చేస్తారు?
నేను ఈ ఫైలు నుండి చదవాలనుకుంటున్న. నేను ఒక ఫైల్ నుండి చదివే?
[విద్యార్థి] దాన్ని తెరవండి. >> అవును.
కాబట్టి fopen. Fopen ఏమిటి ఎలా చేస్తుంది?
[విద్యార్థి] పేరు. >> [బౌడెన్] పేరు argv [1] అని అన్నారు.
[విద్యార్థి] మరియు తరువాత మీరు దానిని చేయాలనుకుంటున్నారా, కాబట్టి - >> [బౌడెన్] అవును.
మీరు గుర్తు లేదు కనుక, మీరు, మనిషి fopen లాగే కాలేదు
ఇది మార్గం ఫైల్ ఉన్న ఒక కాన్స్ట్ చార్ * మార్గం చేస్తాడు పేరు,
కాన్స్ట్ చార్ * మోడ్.
మీరు రీతి గుర్తు లేదు జరిగితే, అప్పుడు మీరు మోడ్ కోసం చూడవచ్చు.
మనిషి పేజీల ఇన్సైడ్, స్లాష్ పాత్ర మీరు విషయాలు శోది ఉపయోగించవచ్చు ఏమిటి.
నేను మోడ్ శోది / మోడ్ టైప్ చేయండి.
n మరియు N మీరు శోధన మ్యాచ్ ద్వారా చక్రం ఉపయోగించే ఉపయోగించలేరు.
ఇక్కడ ఇది ఒక స్ట్రింగ్ కు వాదన మోడ్ పాయింట్లు చెప్పారు
క్రింది వరుస క్రమాల యొక్క ఒక పరిగణిస్తారు.
పఠనం కోసం r కాబట్టి, ఓపెన్ టెక్స్ట్ ఫైల్. అంటే మీరు ఏమి ఉంది.
చదవడం, మరియు ఆ నిల్వ మీరు కోసం.
విషయం ఫైలు * అని అన్నారు. ఇప్పుడు నేను చెయ్యాలనుకుంటున్నారు ఏమి?
నాకు రెండవ ఇవ్వండి.
సరే. ఇప్పుడు నేను చెయ్యాలనుకుంటున్నారు ఏమి?
[విద్యార్థి] ఇది NULL అయితే తనిఖీ. >> [బౌడెన్] అవును.
మీరు ఒక ఫైల్ను తెరవడం ఏ సమయంలో, మీరు విజయవంతంగా దీన్ని తెరిచేందుకు చూడగలరని నిర్ధారించుకోండి.
>> నేను మొదటి నా ప్రస్తుత అమరికలను చదవడానికి ఎక్కడ ఇప్పుడు నేను ఆ termios stuff చేయాలనుకుంటున్నారా
మరియు దానిని ఆ సేవ్, అప్పుడు నా సెట్టింగులను మార్చడానికి కావలసిన
నేను టైప్ ఏ పాత్ర తీసివేసినట్లు
మరియు నేను ఆ సెట్టింగులను నవీకరించాలనుకున్న.
ఆపై ప్రోగ్రామ్ యొక్క ముగింపులో, నా అసలు అమర్పులను మార్చవచ్చు మీరు.
కాబట్టి struct రకం termios అని అన్నారు, మరియు నేను ఆ రెండు కావలసిన వెళుతున్న.
మొదటి ఒకటి, నా current_settings అవతరిస్తుంది
మరియు తర్వాత వారు నా hacker_settings మాత్రం చేస్తున్నారు.
మొదటి, నేను, నా ప్రస్తుత సెట్టింగులను సేవ్ చేయాలనుకుంటున్నారా వెళుతున్న
అప్పుడు నేను, hacker_settings నవీకరించాలనుకున్న వెళుతున్న
అప్పుడు నా ప్రోగ్రామ్ చివరిలో మార్గం, I ప్రస్తుత అమరికలను తిరిగి వెళ్లాలని.
అందుకే, ఈ మనిషి termios పనిచేసే విధంగా, ప్రస్తుత సెట్టింగ్లను సేవ్.
మేము ఈ Int tcsetattr, Int tcgetattr కలిగి చూడండి.
నేను దాని పాయింటర్ ఒక termios struct లో పాస్.
ఈ కనిపిస్తుంది మార్గం - I've ఇప్పటికే ఫంక్షన్ అని పిలిచారు మర్చిపోయి.
దాన్ని కాపీ చేసి.
Tcgetattr కాబట్టి, నేను, నేను సమాచారాన్ని సేవ్ కాబట్టి struct లో పాస్ కావలసిన
ఇది current_settings అవతరిస్తుంది
మరియు మొదటి వాదన నేను యొక్క లక్షణాలను సేవ్ చేయాలనుకుంటున్నారా విషయం కోసం ఫైల్ వర్ణన.
ఏ ఫైల్ వర్ణన మీరు ఒక ఫైల్ను తెరవడం ఏ సమయంలో ఉంటుంది, ఇది ఒక ఫైలు వివరణ పొందుతాడు.
నేను fopen argv [1], ఇది మీరు సూచిస్తూ ఉంటాయి ఫైలు వివరణ గెట్స్
మీరు చదివి లేదా వ్రాయడానికి కావలసినప్పుడు.
నేను ఇక్కడ ఉపయోగించాలనుకుంటున్నాను ఫైలు వివరణ కాదు.
మీరు సిద్ధంగా కలిగి మూడు ఫైలు సూచికలు ఉన్నాయి
ఇది ప్రామాణిక అవ్ట్, మరియు ప్రామాణిక తప్పు ప్రామాణిక ఉంటాయి.
అప్రమేయంగా, నేను 0, ప్రామాణిక అవుట్ 1, మరియు ప్రామాణిక తప్పు 2 ఉంది ప్రామాణిక అని.
కాబట్టి నేను ఏ యొక్క సెట్టింగులను మార్చు అనుకుంటున్నారు?
నేను ఒక పాత్ర హిట్ చేసినప్పుడు యొక్క సెట్టింగులు మార్చడానికి మీరు
నేను బదులుగా స్క్రీన్ కు ప్రింటింగ్ యొక్క దూరంగా పాత్ర త్రో అనుకుంటున్నారా.
ఏ స్ట్రీమ్ - - ప్రామాణిక అవ్ట్, లేదా ప్రామాణిక తప్పు, ప్రామాణిక
నేను కీబోర్డ్ వద్ద టైప్ చేసినప్పుడు విషయాలు స్పందిస్తుంది? >> >> అవును సైన్ [విద్యార్థి] ప్రామాణిక.
నేను గాని 0 చేయవచ్చు లేదా నేను stdin చేయవచ్చు.
నేను సైన్ ప్రామాణిక యొక్క current_settings పొందుతున్నాను
>> ఇప్పుడు నేను, ఆ సెట్టింగులను నవీకరించాలనుకున్న
కాబట్టి మొదటి నా current_settings ఏమిటో hacker_settings లోకి కాపీ చేస్తాము.
మరియు structs పని ఎంత ఇది కాపీ చేస్తుంది.
మీరు ఊహించిన దాని ఇది అన్ని రంగాల్లో ప్రతులు.
>> ఇప్పుడు నేను రంగాలలో కొన్ని నవీకరించాలనుకున్న.
Termios వద్ద గురించి, మీరు ఈ చాలా ద్వారా రీడ్ వుంటుంది
మీ కోసం చూడవచ్చు ఏ చూడటానికి,
మీరు చూడవచ్చు, చూడాలని జెండాలు, echo ఉంటాయి
కాబట్టి ఎకో అక్షరాలను ఇన్పుట్ ఎకో.
మొదటి నేను సెట్ చేయాలనుకుంటున్నారా - క్షేత్రాలు ఏ ఇప్పటికే మర్చిపోయి I've.
ఈ struct ఎలా ఉంది.
ఇన్పుట్ విధానాలను నేను మేము మార్చడానికి కావలసిన భావిస్తున్నాను.
మేము ఆ మనము చేయడానికి ఏమి ఉందో లేదో నిర్ధారించడానికి పరిష్కారం వద్ద పరిశీలిస్తాము.
మేము ఈ ద్వారా చూడండి అవసరం నిరోధించడానికి lflag మార్చడానికి కావలసిన.
మేము స్థానిక మోడ్లు మార్చడానికి కావలసిన.
మీరు ప్రతి చెందిన పేరు అర్థం ఈ మొత్తం విషయం ద్వారా రీడ్ వుంటుంది
మేము మార్చడానికి కావలసిన.
కానీ మేము ఆ మార్పు చేయండి వెళుతున్న స్థానిక రీతుల్లో లోపల.
కాబట్టి hacker_settings.cc_lmode దీనిని ఏమి ఉంది.
c_lflag.
మేము bitwise ఆపరేటర్లు పొందడానికి ఇది ఉంది.
మేము సమయాల్లో రకం, కానీ మాకు అది నిజమైన శీఘ్ర ద్వారా వెళ్తారో.
మేము bitwise ఆపరేటర్లు పొందడానికి ఇది ఉంది
నేను అనుకుంటున్నాను నేను ఎక్కడ ఒకసారి కాలం క్రితం చెప్పారు మీరు జెండాలు వ్యవహరించే ప్రారంభించిన ప్రతిసారీ,
మీరు bitwise ఆపరేటర్లు చాలా ఉపయోగించి చూడాలని.
జెండా ప్రతి బిట్ ప్రవర్తన విధమైన సూచించదు.
ఇక్కడ, ఈ జెండా వారి అన్ని విరుద్ధంగా అర్థాన్ని వేర్వేరు విషయాలు, కొంత ఉంది.
కానీ నేను మీరు ఏమి కేవలం ఎకో అనుగుణంగా ఉండే బిట్ ఆఫ్ ఉంది.
కాబట్టి చెయ్యడానికి ఆ నేను ఆఫ్ & = ¬ ECHO.
అసలైన, నేను tECHO లేదా ఏదో వంటి అని. నేను మళ్ళీ తనిఖీ వెళుతున్న.
నేను termios చేయవచ్చు. ఇది కేవలం ఎకో యొక్క.
ECHO ఒక బిట్ ఉంటుంది అన్నారు.
¬ ECHO అన్ని జెండాలు ఒప్పుకు సెట్ అంటే, అన్ని బిట్స్ 1 కు సెట్ అర్థం అన్నారు
ECHO బిట్ మినహా.
ఈ నా స్థానిక జెండాలు ముగింపు నాటికి, ప్రస్తుతం ఒప్పుకు సెట్ అన్ని జెండాలు అర్థం
ఇప్పటికీ నిజమైన అమర్చబడుతుంది.
నా ECHO జెండా నిజమైన సెట్ చేయబడి ఉంటే, అప్పుడు ఈ తప్పనిసరిగా ECHO జెండా పై తప్పుడు కు సెట్.
కాబట్టి కోడ్ ఈ రేఖను కేవలం ECHO జెండా ఆఫ్ అవుతుంది.
కోడ్ ఇతర పంక్తులు నేను వాటిని సమయం ఆసక్తి కాపీ మరియు తరువాత వాటిని వివరించటానికి ఉంటాం.
పరిష్కారం లో, అతను 0 చెప్పారు.
ఇది స్పష్టంగా stdin చెప్పడానికి బహుశా ఉత్తమం.
>> ఇక్కడ ICANON | నేను కూడా ECHO చేస్తున్నదాన్ని గమనించాలి.
ICANON కానానికల్ మోడ్ అంటే ప్రత్యేక ఏదో, సూచిస్తుంది.
మీరు కమాండ్ లైన్ అవ్ట్ టైప్ చేస్తున్నప్పుడు ఏమి కానానికల్ మోడ్ అంటే, సాధారణంగా
మీరు NEWLINE హిట్ వరకు ప్రామాణిక ఏదైనా ప్రాసెస్ లేదు.
కాబట్టి మీరు GetString చేసినప్పుడు, మీరు NEWLINE హిట్ తర్వాత, విషయాలు కొంత టైప్ చేయండి.
ఇది సైన్ ప్రామాణిక కు పంపిన ఉన్నప్పుడు ఆ
డిఫాల్ట్ ఉంది.
నేను, మీరు నొక్కండి ఇప్పుడు ప్రతి పాత్ర కానానికల్ మోడ్ ఆఫ్ చేసినప్పుడు
ఏ, ఈ విషయాలు ప్రాసెస్ నెమ్మదిగా ఎందుకంటే సాధారణంగా చెడు రకం, ఇది ప్రాసెస్ అవుతుంది ఉంది
ఇది మొత్తం పంక్తులు లో స్వీకరించేందుకు మంచి వై ఇది.
కానీ నేను ప్రతి పాత్ర ప్రాసెస్ చెయ్యడానికి మీరు
నా NEWLINE నొక్కండి కోసం వేచి అనుకుంటున్న నుండి
అన్ని అక్షరాలు ప్రాసెస్ ముందు నేను టైప్ చేసిన.
ఈ కానానికల్ మోడ్ ఆఫ్ అవుతుంది.
నిజానికి అక్షరాలు ప్రాసెస్ ఈ అంశాలు అర్థం.
, వెంటనే నేను టైప్ ఆమ్ వాటిని ప్రాసెస్; ఈ వెంటనే వాటిని ప్రాసెస్ అర్థం.
మరియు ఈ, ప్రామాణిక నా సెట్టింగ్లను నవీకరించడంలో ఇది విధి
మరియు TCSA అంటే ప్రస్తుతం చేస్తున్నాయి.
స్ట్రీమ్లో ప్రస్తుతం ప్రతిదీ ప్రాసెస్ వరకు ఇతర ఎంపికలు వేచి ఉన్నాయి.
ఇది నిజంగా పట్టింపు లేదు.
ప్రస్తుతం నా సెట్టింగులు hacker_typer_settings ప్రస్తుతం ఏ గా మార్చండి.
నేను hacker_settings అని అంచనా, కాబట్టి యొక్క మార్చే వీలు.
Hacker_settings ప్రతిదీ మార్చండి.
>> ఇప్పుడు మా కార్యక్రమం చివరిలో మేము తిరిగి మీరు చూడాలని
normal_settings లోపలి ప్రస్తుతం ఏమి,
ఇది కేవలం & normal_settings ఎలా అన్నారు.
నేను మొదట దాన్ని పొందడం నుండి నా normal_settings ఏ మారలేదు గమనించండి.
వాటిని తిరిగి మార్చడానికి, నేను ముగింపు వాటిని మళ్ళీ పాస్.
ఈ నవీకరణ ఉంది. సరే.
>> లోపల ఇక్కడ ఇప్పుడు నేను సమయం ఆసక్తి కోడ్ వివరించడానికి చేస్తాము.
ఇది చాలా కోడ్ కాదు.
మేము ఫైల్ నుండి ఒక పాత్ర చదవండి చూడండి. మేము F అని.
ఇప్పుడు మీరు మనిషి fgetc చేయగలరు, కానీ ఎలా fgetc పని అన్నారు
దీనిని మీరు చదివి లేదా EOF పాత్ర తిరిగి వెళుతున్న ఉంది,
ఏ ఫైల్ లేదా కొన్ని లోపం జరిగిందని చివర ఉంటుంది.
మేము, ఫైలు నుండి ఒక పాత్ర చదవడానికి నిరంతర, మళ్ళీ వెతికినా ఉంటాయి
మేము చదవడానికి అక్షరాలు యొక్క రన్నవుట్ చేసిన వరకు.
మేము ఆ చేస్తున్నా సమయంలో, మేము సైన్ ప్రామాణిక నుండి ఒక పాత్ర వేచి
ప్రతి మీరు, కమాండ్ లైన్ వద్ద ఏదో టైప్
సైన్ ప్రామాణిక నుండి ఒక పాత్ర లో చదివిన చేసే
అప్పుడు putchar కేవలం మేము ఫైల్ నుండి ప్రామాణిక అవుట్ ఇక్కడ చదవండి చార్ ఉంచారు అన్నారు.
మీరు మనిషి putchar, కాని, ఇది కేవలం ప్రమాణ ఉంచడం, అది ఆ పాత్ర ప్రింటింగ్ అన్నారు.
ఇదే ఆలోచన; మీరు కేవలం printf ("% సి", సి) పని చేయడు.
మా పని అత్యధిక చేయడానికి జరగబోతోంది.
>> మేము చేయాలనుకుంటున్నారా చూడాలని లాస్ట్ థింగ్ మా ఫైలు fclose ఉంది.
మీరు fclose లేకపోతే, ఆ మెమొరీ లీక్ ఉంది.
మేము నిజానికి తెరుచుకున్న ఫైల్ fclose మీరు, నేను దాన్ని ఉంటుంది.
మేము ఆ చేస్తే, నేను ఇప్పటికే సమస్యలు వచ్చింది.
యొక్క చూసేలా.
అంటే ఫిర్యాదు చేశారు?
ఊహించినది 'Int' కానీ వాదన రకం 'struct _IO_FILE *' ఉంటుంది.
ఆ పని మేము చూస్తారు.
మాత్రమే C99 లో అనుమతించింది. Augh. సరే, hacker_typer చేయండి.
ఇప్పుడు మేము మరింత ఉపయోగకరమైన వివరణలను పొందండి.
కాబట్టి ప్రకటించనివారు ఐడెంటిఫైయర్ 'normal_settings' యొక్క ఉపయోగించండి.
నేను normal_settings కాల్ లేదు. నేను current_settings అని.
కాబట్టి యొక్క ఆ అన్ని మార్చుకోవడానికి అనుమతించే.
ఇప్పుడు వాదన వెళుతుంది.
నేను ఇప్పుడు ఈ 0 చేస్తాము.
సరే. . / Hacker_typer cp.c.
నేను కూడా ప్రారంభంలో స్క్రీన్ క్లియర్ లేదు.
కానీ మీరు స్క్రీన్ క్లియర్ ఎలా చివరి సమస్య సెట్ తిరిగి చూడవచ్చు.
ఇది కేవలం కొన్ని అక్షరాలు ప్రింటింగ్ యొక్క
ఈ నేను మీరు ఏమి చేయడం ఉంది.
సరే.
మరియు ఈ బదులుగా stdin 0 ఉండాలి ఎందుకు ఆలోచించకుండా,
ఇది # 0 నిర్వచించే చేయాలి
ఈ ఫిర్యాదు ఉంది -
నేను ఫైలు సూచికలు లేదు, అయితే మీరు కూడా మీ ఫైల్ * ఉన్నప్పుడు ముందు,
ఫైలు వివరణ, కేవలం ఒకే పూర్ణ సంఖ్య
ఫైలు * ఇది సంబంధం stuff యొక్క మొత్తం బంచ్ అదే.
మేము బదులుగా stdin 0 చెప్పడానికి అవసరం కారణం
ఆ stdin ఫైలు వివరణ 0 సూచిస్తూ ఆ విషయం సూచిస్తుంది ఉన్న ఒక ఫైల్ * ఉంది.
కాబట్టి కూడా ఇక్కడ నేను fopen చేసినప్పుడు (argv [1], నేను తిరిగి ఫైల్ * పొందుతున్నాను.
కానీ ఎక్కడో ఆ ఫైల్ * లో ఫైల్ కోసం ఫైలు వివరణ సంబంధించి ఒక విషయం.
మీరు ఓపెన్ కోసం మనిషి పేజీ చూడండి ఉంటే, నేను మీరు మనిషి 3 ఓపెన్ లేదు భావిస్తున్నాము - వద్దు -
మనిషి 2 ఓపెన్ - అవును.
మీరు ఓపెన్ కోసం పేజీ చూడండి ఉంటే, ఓపెన్, తక్కువ స్థాయి fopen వంటిది
మరియు అది వాస్తవ ఫైలు వివరణ తిరిగి ఉంది.
fopen ఓపెన్ పైన stuff ఒక సమూహం చేస్తుంది,
బదులుగా ఫైల్ వివరణ మొత్తం FILE * పాయింటర్ తిరిగి ఆ తిరిగి ఏ
లోపల ఇది మా చిన్న ఫైల్ వర్ణన.
FILE * విషయం సూచిస్తుంది అలా ప్రామాణిక,
0 కూడా కేవలం ఫైల్ వివరణ ప్రామాణిక సూచిస్తుంది అయితే.
>> ప్రశ్నలు?
[నవ్విన] ఆ ద్వారా బ్ల్యూ.
అన్ని కుడి. మేము పూర్తి చేసిన. [నవ్విన]
>> [CS50.TV]