>> [MUSIC ప్లే]
>> రాబ్ బోడెన్: అన్ని కుడి.
వీడియో మొదటి, మొదటి విషయం, ఒక తెలిసిన ముఖం నుండి.
>> [వీడియో ప్లేబ్యాక్]
>> -అన్ని కుడి.
ఈ CS50, మరియు ఈ ఉంది వారం మూడు ప్రారంభంలో.
నేను మీతో అక్కడ కాదు క్షమించండి నేడు, కానీ నాకు పరిచయం అనుమతిస్తుంది
CS50 యొక్క సొంత రాబ్ బోడెన్.
>> [END వీడియో ప్లేబ్యాక్]
>> [చప్పట్లు మరియు చీర్స్]
>> రాబ్ బోడెన్: లో ఫిల్మోగ్రఫీ వీడియో అద్భుతమైన ఉంది.
అన్ని కుడి.
కాబట్టి మొదటి, మరొక భోజనం ఉంది.
ఇది 1:15 వద్ద రేపటి.
ఈ శుక్రవారం ఏ భోజనం ఉంది.
ఇది కోరా తో ఉంది.
మరియు టామీ ఒక కానీ, ఇంకా ఇక్కడ కాదు మాజీ అధిపతి CF ఉంది ప్రజలు,
టామీ మక్.
అందువలన అతను ఒక ఆహ్లాదకరమైన వ్యక్తి.
మీరు వచ్చి ఉండాలి.
>> అన్ని కుడి.
గత వారం, మేము దూరంగా బద్దలు ప్రారంభించారు ఒక స్ట్రింగ్ నిజంగా ఏమి గురించి.
మేము ప్రారంభం నుంచి తెలిసిన చేసిన ఇది అక్షరాలు ఒక శ్రేణి యొక్క.
అయితే గత వారం, మేము నిజానికి గాధలను ఏమి నిజంగా క్రమం అని
అక్షరాలు, బాగా, మేము ఇప్పుడు అక్షరాలు వ్యూహాలను.
మరియు మేము ఒక స్ట్రింగ్, అది వ్యూహం ఉంది తెలుసు అక్షరాలు, చాలా చివరిలో,
మేము ఈ ప్రత్యేక శూన్య బైట్ కలిగి, ఈ బాక్ స్లాష్ 0, చివరికి యొక్క సూచిస్తుంది
స్ట్రింగ్.
>> కాబట్టి ఒక స్ట్రింగ్ యొక్క వ్యూహం ఉంది అక్షరాలు, కానీ మేము కలిగి కంటే మరింత
కేవలం అక్షరాల యొక్క శ్రేణి, మేము ఏ వ్యూహం ఉండవచ్చు
మేము విషయం రకం.
కాబట్టి, మీరు గత వారం నుండి రీకాల్, డేవిడ్ పరిచయం యుగం కార్యక్రమం
నిజంగా త్వరగా.
మేము చేయబోతున్నామని కాబట్టి మొదటి విషయం , పూర్ణాంకం కోసం వినియోగదారు అడగండి
గదిలో ప్రజల సంఖ్య.
మేము ఆ పూర్ణాంక ఒకసారి, మేము వ్యూహం ప్రకటించారు చేస్తున్నారు.
ఈ బ్రాకెట్ సింటాక్స్ గమనించండి.
మీకు అలవాటుపడతారు చూడాలని.
>> కాబట్టి మేము పూర్ణాంకాల వ్యూహం ప్రకటించారు చేస్తున్నారు వయస్సు అని, మరియు n ఉన్నాయి
ఈ శ్రేణి లో పూర్ణాంకాల.
ఇక్కడే కాబట్టి ఈ నమూనా, ఈ 4 పూర్ణాంకానికి నేను ప్లస్, నేను కంటే తక్కువ n ఉంది, 0 సమానం
ప్లస్, కూడా ఒక నమూనా అని అన్నారు మీరు చాలా ఉపయోగిస్తారు అని.
ఇది చాలా చక్కని మీరు ఎలా ఎందుకంటే ఎల్లప్పుడూ శ్రేణుల మీద iterate వెళ్లి.
కాబట్టి n అని గుర్తుంచుకోండి మా శ్రేణి పొడవు.
మరియు ఇక్కడ, మేము పదేపదే అడుగుతున్నారు గదిలో వ్యక్తి నేను వయస్సు కోసం.
>> ఈ తరువాత, మేము ఓడిపోవుట, మరియు సంసార కోసం అనియత కారణం, మేము అప్పుడు
వారు వెళుతున్న ఎలా పాత ప్రింట్ ఇప్పుడు ఒక సంవత్సరం ఉండాలి.
మరియు ఆ ప్రోగ్రామ్ను అమలు, లెట్స్ , వయస్సు తయారు స్లాష్ వయస్సు డాట్.
కాబట్టి గదిలో ప్రజల సంఖ్య, యొక్క మూడు ఉన్నాయి అని పిలవబడు.
మరియు, మొదటి వ్యక్తి 13, చెప్పడానికి తదుపరి 26, మరియు గత 30.
కాబట్టి అప్పుడు ఆ మూడు పైగా iterate చేస్తాము ప్రజలు, 14 27 మరియు 31 ప్రింట్.
>> కాబట్టి గుర్తు మేము ఒక ప్రకటిస్తాయి పరిమాణం n యొక్క శ్రేణి, ఆ మార్కెట్లు
అర్రే, అర్రే విలువలు మరియు సూచికలు 0, 1, 2, అన్ని మార్గం
అప్ n మైనస్ 1.
కాబట్టి మేము చెప్పాడు మూడు ప్రజలు ఉన్నాయి గదిలో, మరియు మేము ఇక్కడ ఉంచారు
ఈ ద్వారా మొదటి పునరుక్తి లూప్, నేను 0 అన్నారు.
కాబట్టి ఇండెక్స్ 0.
మేము మొదటి కేటాయించి యూజర్ ప్రవేశిస్తుంది వయస్సు.
తరువాత ఒక లో, మేము ఎంటర్ చేస్తున్నారని రెండవ n యూజర్ ప్రవేశిస్తుంది, మరియు లో
రెండు, గత n పక్కన.
>> కాబట్టి గమనించి ఆ పరిమాణం యొక్క వ్యూహం మూడు ఏదైనా లేదు
ఇండెక్స్ మూడు.
ఈ చెల్లదు.
అన్ని కుడి.
కాబట్టి, తిరిగి వెళ్ళటం.
కాబట్టి ఇప్పుడు మేము శ్రేణితో డీల్ చేసిన, మేము కొన్ని పరిచయాన్ని కలిగి.
ఇప్పుడు కమాండ్ వెళ్ళటానికి చూడాలని ఉంటాయని లైన్ వాదనలు,
ఈ సమస్య సెట్ అందంగా సంబంధిత.
>> కాబట్టి ఇప్పుడు వరకు, చేసినప్పుడు మీరు చేసిన మీ ప్రధాన నిర్ధారించారు, ఉన్నాను
Int ప్రధాన గర్జన చెప్పారు.
కాబట్టి గర్జన కేవలం అంటే మేము ఏ ప్రయాణిస్తున్న లేదు
ఈ ఫంక్షన్ కు వాదనలు.
ఇప్పుడు మేము ప్రధాన చూడండి చూడాలని కొన్ని వాదనలు పడుతుంది.
ఇక్కడ మేము argc పూర్ణాంకానికి కాల్ మరియు స్ట్రింగ్ argv బ్రాకెట్లలో.
బ్రాకెట్లలో, మరోసారి, సూచిస్తూ మేము శ్రేణితో వ్యవహరించే చేస్తున్న.
ఇక్కడ, స్ట్రింగ్ argv బ్రాకెట్లలో, మేము తీగలను యొక్క వ్యూహం వ్యవహరించే.
కాబట్టి argc, సూచిస్తున్నాయి వెళుతున్న మేము చేసిన ఎన్ని వాదనలు
ఈ కార్యక్రమం విధించాయి.
మరియు, ఆ ఏమి చూడటానికి యొక్క ఈ దగ్గరగా తెలియజేయండి.
>> OK.
కాబట్టి ఇప్పుడు వరకు, మేము ప్రతి అమలు చేసిన డాట్ స్లాష్ వయస్సు కార్యక్రమం.
మేము కూడా, కమాండ్ లైన్ వద్ద, గత వాదనలను, ఈ పదం, ఆదేశం
పంక్తి వాదనలు.
కాబట్టి మొదటి వాదన, హలో వరల్డ్.
ఇక్కడ, argc మూడు ఉంటుంది.
ఇది వాదనలు జమీందారుల కమాండ్ లైన్ వద్ద.
Argc, కనీసం 1 నుండి డాట్ , జంట మధ్య స్లాష్, ఒకటి గా లెక్కింపబడుతుంది
ఆదేశ పంక్తి వాదనలు.
>> అప్పుడు హలో మొదటి ఉంది.
డాట్ స్లాష్ వయస్సు అప్పుడు, జేరోయేత్ ఉంటే హలో మొదటి, మరియు ప్రపంచ
రెండవ కమాండ్ లైన్ వాదన.
కాబట్టి స్ట్రింగ్ argv, మేము చూడండి చూడాలని, తీగలను, డాట్ స్లాష్ కలిగి
వయస్సు, హలో, మరియు ప్రపంచ.
దావీదు యొక్క అభ్యర్థన, మేము చేయబోతున్నామని ఆ పరిచయం ఒక వీడియో ప్లే.
>> [వీడియో ప్లేబ్యాక్]
>> అప్ ఉన్నాను కార్యక్ ఇప్పుడు వరకు రాసిన, మేము డిక్లేర్ చేసిన
ప్రధాన వంటి Int ప్రధాన గర్జన.
మరియు అన్ని ఈ సమయంలో, శూన్యమైన ఉంది కేవలం పేర్కొనడం జరిగింది అని
కార్యక్రమం ఏ తీసుకోదు ఆదేశ పంక్తి వాదనలు.
ఒక వినియోగదారు ఒక నడుస్తుంది ఇతర మాటలలో, లో కార్యక్రమం, అతను లేదా ఆమె ఆదేశం అందిస్తుంది
అదనపు వ్రాయడం ద్వారా పంక్తి వాదనలు పదాలు లేదా పదబంధాలు కార్యక్రమం యొక్క
ప్రాంప్టులో పేరు.
>> బాగా, మీరు మీ కార్యక్రమాన్ని కావలసిన ఉన్నా ఆదేశ పంక్తి వాదనలు, ఒకటి లేదా పడుతుంది
మరింత పదాలు, మేము స్థానంలో అవసరం వాదనలు ఒక జంట తో రద్దు.
కాబట్టి యొక్క ఆ తెలియజేసేలా.
Cs50.h. ఉన్నాయి
ప్రామాణిక io.h. చేర్చండి
ప్రధాన Int.
ఇప్పుడు, బదులుగా శూన్యము, నేను వెళుతున్న ఒక argc అని Int, మరియు ఒక పేర్కొనండి
argv తీగలను శ్రేణి.
ఇప్పుడు, argc మరియు argv ఉంటాయి కేవలం సమావేశాలు.
>> మేము ఈ వాదనలు అని ఉండవచ్చు మేము అత్యంత ఏదైనా.
కానీ ముఖ్యమో argc ఉంటుంది ఒక Int నిర్వచనం ద్వారా ఇది, ఎందుకంటే
వాదన లెక్కింపు కలిగి అన్నారు, మొత్తం పదాలు సంఖ్య అని
వినియోగదారు అతని లేదా ఆమె ప్రాంప్ట్ వద్ద టైప్ ఉంది.
argv, మరోవైపు, వాదన వెక్టర్, ఉంది నిజానికి నిల్వ వ్యూహం మాత్రం
యూజర్ యొక్క పదాల అన్ని తన ప్రాంప్ట్ వద్ద టైప్.
>> యొక్క ఇప్పుడు ఏదో ముందుకు తెలపండి ఈ ఒకటి లేదా ఎక్కువ తో
ఆదేశ పంక్తి వాదనలు.
ముఖ్యంగా, యొక్క ముందుకు మరియు ముద్రణ వీడలేదు సంసార పదం రకాల
కార్యక్రమం యొక్క పేరు తర్వాత ప్రాంప్టులో.
ఓపెన్ బ్రాకెట్.
Close బ్రాకెట్.
Printf శాతం లు బాక్ స్లాష్ మరియు కామా.
ఇప్పుడు నేను printf ఏ విలువ చెప్పడం అవసరం ఆ హోల్డర్ లోకి ప్రదర్శించాడు.
నేను యూజర్ కలిగి మొదటి పదం మీరు కార్యక్రమం యొక్క పేరు తర్వాత టైప్,
అందువలన నేను తెలుపుటకు వెళుతున్న argv బ్రాకెట్ 1, దగ్గరగా
కుండలీకరణములలో సెమికోలన్.
>> ఇప్పుడు, ఎందుకు బ్రాకెట్ 1 మరియు బ్రాకెట్ 0?
బాగా, అది స్వయంచాలకంగా నిల్వ, అవుతుంది argv లో 0 అన్నారు
కార్యక్రమం యొక్క నిజమైన పేరు.
కాబట్టి మొదటి పదం ఆ యూజర్ రకాల ప్రోగ్రామ్ యొక్క పేరు ద్వారా, తర్వాత
సమావేశం, మాత్రం argv 1 నిల్వ.
యొక్క ఇప్పుడు కంపైల్ లెట్ మరియు ఈ ప్రోగ్రామ్ రన్.
>> Argv 0, డాట్ స్లాష్ argv 0 చేయండి.
ఇప్పుడు ఒక పదం హలో వంటి.
నమోదు చేయండి.
మరియు అక్కడ మేము హలో, అది కలిగి.
>> [END వీడియో ప్లేబ్యాక్]
>> రాబ్ బోడెన్: అన్ని కుడి.
ఆ Close.
ఆ కార్యక్రమం పరిశీలించి తీసుకున్న మేము, బాగా, మాకు కేవలం పరిచయం
మేము 0 argv ప్రింట్ ఇప్పుడు, తయారు,, చూపించడానికి ఇది, argv 0, డాట్ స్లాష్ argv 0 ఏమిటి.
అంచనా కనుక,, అది ముద్రించిన యొక్క argv 0 ఎందుకంటే, ప్రోగ్రామ్ యొక్క పేరు
ఎల్లప్పుడూ మాత్రం కార్యక్రమం పేరు.
కానీ యొక్క ఏదో ఒక తెలియజేసేలా ఆసక్తికరమైన బిట్.
>> కాబట్టి సమస్య సెట్ లో, మీరు ఉంటాం ఈ ఫంక్షన్, atoi పరిచయం.
కాబట్టి మనం కోసం atoi ఉపయోగించగలను?
ఆ మార్చేందుకు జరగబోతోంది ఒక పూర్ణాంకం స్ట్రింగ్.
నేను స్ట్రింగ్ పాస్, రెండు మూడు, atoi కు, ఆ మార్పు వస్తుంది
పూర్ణాంక, ఒక రెండు మూడు.
కాబట్టి మేము మొదటి మార్చేందుకు వెళుతున్న పూర్ణాంకం కమాండ్ లైన్ వాదన,
ఆపై ఆ పూర్ణాంక ప్రింట్.
>> కాబట్టి ప్రాథమికంగా, మేము రకమైన ఉన్నారు కేవలం, GetInt reimplementing
పూర్ణాంక ఆదేశం వద్ద ఎంటర్ ఉంది పంక్తి బదులుగా కార్యక్రమంలో
యింటరాక్టివ్గా.
కాబట్టి అప్పుడు, argv 0 దీనితో యొక్క తెలియజేసేలా ఇక్కడ అది, మరియు ఆ దగ్గరగా.
కాబట్టి argv 0 పరుగు, యొక్క ప్రవేశించే పూర్ణాంక, ఒక రెండు మూడు నాలుగు రెండు.
కనుక ఇది, ఒక పూర్ణాంకం ప్రింట్ చేస్తాము రెండు మూడు నాలుగు రెండు.
ఆ atoi కొన్ని సూక్ష్మబేధాలు ఉన్నాయి ఇది ఏదైనా గురించి caring ఆపడానికి ఉంటాం
ఒక చెల్లుబాటు అయ్యే సంఖ్యా పాత్ర దాటి, కానీ ఆ విషయం కాదు.
>> కాబట్టి మీరు ఏమి ఆలోచిస్తాడు నేను ఇలా చేస్తే?
లోపంగా.
కాబట్టి ఎందుకు అని?
మీరు మా కార్యక్రమంలో వద్ద తిరిగి చూస్తే, మేము argv 1, మొదటి వాదన మార్చడానికి
కార్యక్రమం పేరు తరువాత, పూర్ణాంకం.
కానీ ఆమోదం ఎటువంటి వాదన ఉంది కార్యక్రమం పేరు తరువాత.
ఇక్కడ, మేము ఈ ఒక బగ్గీ అని చూడండి కార్యక్రమం, నుండి, మేము అమలు ప్రయత్నించినట్లయితే
ఏ వాదనలు లేకుండా, ఇది కేవలం క్రాష్ చేస్తుంది.
>> మీరు చూస్తారు కాబట్టి మరొక సాధారణ నమూనా ఏదో వంటి, argc తక్కువ ఉంది ఉంటే
లేదని సూచిస్తూ రెండు, కంటే కనీసం ప్రోగ్రామ్ పేరు మరియు ఒక
మొదటి వాదన, అప్పుడు మేము ఏదో చేస్తాను వంటి printf, తగినంత కాదు
ఆదేశ పంక్తి వాదనలు.
ఆ బహుశా ముద్రించడానికి ఒక మంచి ఒకటి కాదు, ఇది వంటి, బహుశా ఏదో ఉంది
మీరు ఒక పూర్ణాంకం ఎంటర్ చేయాలి కమాండ్ లైన్ వద్ద.
నేను అక్కడ అది అంతం.
ఆపై 1 తిరిగి.
మా చివరిలో గుర్తుంచుకోవాలి కార్యక్రమం, మేము తిరిగి 0, ఆ విధమైన
విజయం సూచిస్తుంది.
మరియు ప్రధాన కూడా స్వయంచాలకంగా మీరు లేకపోతే 0 తిరిగి.
>> ఇక్కడ, మేము సూచించడానికి 1 రీట్యూనింగ్ చేస్తున్నారు ఆ విజయం కాదు.
మరియు మీకు కావలసిన తిరిగి, కేవలం, 0 విజయం సూచిస్తుంది, మరియు
ఏదైనా వైఫల్యం సూచిస్తుంది.
కాబట్టి యొక్క విషయాల ఈ వెర్షన్ అమలు అనుమతిస్తాయి.
కాబట్టి ఇప్పుడు, మేము ఒక కమాండ్ లైన్ ఎంటర్ లేకపోతే వాదన, ఇది సరిగ్గా చెబుతాడని
మాకు, తగినంత కమాండ్ లైన్ కాదు.
వాక్యం పూర్తి చేయని.
ఎల్స్, మేము నిజంగా ఇది ఒక పాస్ ఉంటే, కార్యక్రమం పూర్తి.
కాబట్టి ఈ మీరు argc ఉపయోగించడానికి ఎలా ఉంది సంఖ్య ధ్రువీకరించడానికి
కమాండ్ లైన్ వాదనలు నిజానికి పంపుతారు.
>> కాబట్టి యొక్క ఒక బిట్ మరింత ఈ కార్యక్రమం తెలియజేయండి క్లిష్టమైన, మరియు రెండవ చూడండి
విషయాలు మళ్ళా.
కాబట్టి ఇప్పుడు, మేము ప్రింటింగ్ లేదు మొదటి కమాండ్ లైన్ వాదన.
ఇక్కడ, మేము Int i సమానం నుండి iterating చేస్తున్నారు 0, నేను argc కంటే తక్కువ ప్లస్
ప్లస్, మరియు ముద్రణా argv, ఇండెక్స్ నేను.
కాబట్టి ఈ నమూనా, మళ్ళీ, ఈ అదే బదులుగా తప్ప ముందు నమూనా,
వేరియబుల్ కాల్ n, మేము argc ఉపయోగిస్తున్నారు.
>> కాబట్టి ఈ ప్రతి సూచిక పైగా iterating ఉంది శ్రేణి లో, మరియు ప్రతి ముద్రణ
ఆ శ్రేణి లో మూలకం.
కాబట్టి, మేము ఈ ప్రోగ్రామ్ రన్, బాగా, నేను ఏ ఆదేశ పంక్తి నమోదు చేయలేదు
వాదనలు, కేవలం ప్రింట్లు అది కార్యక్రమం పేరు.
నేను విషయాలు కొంత ఎంటర్, అది చేస్తాము ఒక, తన సొంత లైన్ ప్రతి ప్రింట్.
>> OK.
కాబట్టి మరింత ఈ ఒక అడుగు తీసుకుందాం.
మరియు బదులుగా ప్రతి వాదన ప్రింటింగ్ తన సొంత లైన్ లో, యొక్క ప్రతి ప్రింట్ తెలియజేయండి
ప్రతి వాదన పాత్ర తన సొంత లైన్ లో.
కాబట్టి argv అని గుర్తుంచుకోండి తీగలను యొక్క వ్యూహం.
కాబట్టి ఒక స్ట్రింగ్ ఉంది, కానీ పాత్రల వ్యూహం?
కాబట్టి ఆ argv నిజంగా అర్థం ఒక పాత్రల వ్యూహం శ్రేణి.
కాబట్టి ఆ ప్రయోజనాన్ని తీసుకునే, యొక్క ఇప్పుడు ఈ విస్మరించండి.
యొక్క స్ట్రింగ్ argv 0 పరిశీలిద్దాం.
>> మేము ప్రతి పాత్ర యొక్క తీసుకుని అనుకుంటే argv 0 తన సొంత లైన్ లో, అప్పుడు నేను
మేము ఉపయోగిస్తున్న నమూనా చేయడానికి, నేను ఉంది శ్రేణి యొక్క పొడవు కంటే తక్కువ,
ఇక్కడ, యొక్క strlen ఇది, ఆ నేను చేయాలనుకుంటున్నారా ఏమి లేదు స్ట్రింగ్
లు argv 0 సమానం.
నేను మా యొక్క పొడవు కంటే తక్కువగా ఉంటుంది ఈ సందర్భంలో వ్యూహం ఇది శ్రేణి,
అక్షరాలు, నేను ప్లస్ ప్లస్.
మేము గత వారం చూసిన మరియు కాబట్టి, అది ఆదర్శ ఉంది మేము బయట strlen అని తరలిస్తే
పరిస్థితి, నుండి n జోడించడం ఉంటుంది S యొక్క strlen మేము వెళ్ళి ప్రతి సమయం
లూప్ ద్వారా, మరియు అది ఉంది మారుతున్న కావడం లేదు.
కాబట్టి మేము ఇక్కడ పైగా n సమానంగా సెట్ చేస్తాము.
>> OK.
కాబట్టి ఇప్పుడు, మేము మీద iterating శ్రేణి లో ప్రతి సూచిక.
కాబట్టి, మేము ప్రతి ప్రింట్ అనుకుంటే ఆ శ్రేణి, శాతం సి లో పాత్ర
మేము ఉపయోగించడానికి జెండా అక్షరాలు కోసం.
ఇప్పుడు ఒక బ్రాకెట్ నేను మాత్రం ఉంది స్ట్రింగ్, ఇండెక్స్ పాత్ర నేను, అయితే
స్ట్రింగ్ హలో ఉన్నాయి.
అప్పుడు బ్రాకెట్, 0 h అన్నారు s s 1 కాబట్టి ఇ ఉంటుంది, మరియు.
>> కాబట్టి ఇప్పుడు మేము మిళితం మీరు ఈ రెండు విషయాలు.
మేము ప్రతి పాత్ర ప్రింట్ మీరు ప్రతి కమాండ్ లైన్ వాదన.
కాబట్టి మేము చూడాలని ఒక లూప్ యున్న.
మరియు సంప్రదాయకంగా, మొదటి కౌంటర్ నేను, తదుపరి j మాత్రం, n ఉంది
argv నేను strlen ఉంటుంది, నేను కంటే తక్కువ n, నేను ప్లస్ ప్లస్ ఉంది.
ఇప్పుడు బదులుగా ముద్రణ argv నేను, కాబట్టి నేను ఇండెక్స్ అన్నారు argv బ్రాకెట్ -
ఆ i-th కమాండ్ లైన్ చేస్తాడు వాదన, argv i, j అన్నారు
jth పాత్ర యొక్క ఉంటుంది i-th వాదన.
నేను ఇప్పుడు ఇక్కడ ఈ అప్ వదిలించుకోవటం చేస్తాము మేము ఆ లూప్ ఉంచారు నుండి.
కాబట్టి స్ట్రింగ్ s సమానం సమానం argv నేను, ఆపై లు బ్రాకెట్ j.
>> Well, మేము ప్రకటించాలని అవసరం లేదు ఈ వేరియబుల్ s.
బదులుగా, మేము ఈ మిళితం చేస్తాము మేము ఏ రెండు,, j నేను argv.
>> SPEAKER 1: [వినబడని].
>> రాబ్ బోడెన్: గుడ్ కాల్.
కాబట్టి ఈ విభజించబడింది.
నిజానికి ప్రచురింపబడింది ఉంటే, మనం ఈ గుర్తించాయి.
నేను శ్రద్ధ కాబట్టి కౌంటర్ ఈ ముఖ్యంగా
లూప్ j, ఇటెరేటర్ ఉంది.
కాబట్టి మీరు సమస్యలను రన్ ఉండేది, బహుశా ఒక అనంతమైన లూప్, మేము
స్థిర లేదు.
మేము కూడా మాట్లాడటం ఎందుకు ఆ ఈరోజు డీబగ్గింగ్.
>> OK.
కాబట్టి యొక్క ఈ అమలు అనుమతిస్తాయి.
మరియు యొక్క అసలైన ప్రత్యేక printf జోడించడానికి అనుమతిస్తుంది ఇక్కడే కేవలం ముద్రిస్తుంది ఆ
ఈ అంటే నుండి మరొక లైన్, మేము అమలు, ఒక ఖాళీ అక్కడ ఉంటాం
ప్రతి పాత్ర యొక్క మధ్య లో లైన్ ప్రతి కమాండ్ లైన్ వాదన.
బాగా, మేము అర్థం చూస్తారు.
Oop.
కొన్ని బగ్ వచ్చింది.
లోపం పరిపూర్ణంగా ప్రకటించారు లైబ్రరీ ఫంక్షన్ strlen.
>> కాబట్టి మా కార్యక్రమం తిరిగి వెళ్ళడం, నేను string.h ఉన్నాయి హాష్ మర్చిపోయారు.
కాబట్టి string.h అన్నారు ఉపయోగించడమనేది శీర్షికా ఫైలును
ఫంక్షన్ strlen.
OK, కూర్చింది.
ఇప్పుడు, యొక్క అమలు అనుమతిస్తాయి.
కాబట్టి ఆ.
ఇది ప్రింట్ వెళుతున్న మా కార్యక్రమం పేరు, హలో వరల్డ్.
ఇది ప్రతి, ప్రతి విషయం ముద్రించడానికి జరగబోతోంది తన సొంత లైన్ లో పాత్ర,.
OK.
>> కాబట్టి యొక్క వాస్తవానికి ఈ తీసుకుందాం మరొక్క అడుగు.
మరియు బదులుగా string.h ఉపయోగించి, లెట్స్ మేము మా సొంత అమలు కావలసిన ఎలా గురించి ఆలోచించటం
strlen ఫంక్షన్.
నేను వెంటనే ఇస్తాము ఒక ఫంక్షన్ సంతకం.
కాబట్టి యొక్క my_strlen లో కాల్, మరియు అది ఉంది ఒక వాదన వంటి స్ట్రింగ్ తీసుకుంటున్నానని,
మరియు మేము తిరిగి వచ్చింది ఆ స్ట్రింగ్ యొక్క పొడవు.
కాబట్టి, ఆ వ్యక్తి?
అవును.
OK.
కాబట్టి ముందు స్లయిడ్ నుండి గుర్తున్నది , గత వారం నుండి కూడా అని ఒక
అక్షరాలు శ్రేణి, బాగా, ఒక స్ట్రింగ్, కాబట్టి యొక్క ఈ మా స్ట్రింగ్ s అంటారు.
కాబట్టి s స్ట్రింగ్ ఉంటే, హలో, అప్పుడు, H-E-L-L-O, మెమరీ లో, ఆ చేస్తాడు
ఈ బాక్ స్లాష్, మరియు 0 పాత్ర.
>> కాబట్టి మేము ఎలా s యొక్క పొడవు వస్తుందా?
బాగా, ట్రిక్ ఈ అన్వేషిస్తుంది 0 పాత్ర, ఈ శూన్య ప్రతిక్రియలో
టెర్మినేటర్.
కాబట్టి అల్గోరిథం ఉండబోతుంది కొన్ని లాగ
తగినంత పాత్రలు -
యొక్క ఈ చేతి కొన్ని ప్రాతినిధ్యం వివరించారు కౌంటర్, యొక్క ఈ Int పొడవు కాల్.
కాబట్టి, ఇక్కడ నుండి మొదలు, మేము ఉన్నాము మా స్ట్రింగ్ పైగా iterate వెళ్లి.
>> కాబట్టి, ఇది H మొదటి పాత్ర, మరియు అది తిరిగి కాబట్టి, 0 స్లాష్ కాదు
పొడవు 1 ఉంది.
తదుపరి పాత్ర iterate, E, మరియు అది 0 బ్యాక్స్లాష్ కాదు.
పొడవు 2.
L, 3.
L, 4.
O, 5.
చివరకు, మేము బాక్ స్లాష్ చేరుకోవడానికి 0, అందువలన సాధనాలు, బాగా,
ఈ స్ట్రింగ్ పైగా ఉంది.
కాబట్టి యొక్క 5 తిరిగి తెలియజేయండి.
>> కాబట్టి నిజంగా, మొదటి, ఆ అమలు నా n పొడవు నా కుడి చేతి, 0 సమానం.
మరియు మేము iterate చూడాలని -
>> SPEAKER 1: [వినబడని]
>> రాబ్ బోడెన్: ఓహ్, కాలుస్తారు.
గుడ్ కాల్.
బూమ్.
కాబట్టి n పొడవు 0 సమానం.
కాబట్టి ఇప్పుడు, అయితే లు పొడవు లేదు సమాన మరియు, బాక్ స్లాష్ 0.
కాబట్టి, ఈ బాక్ స్లాష్ 0 గుర్తు, అది ఒక ఉంది అసలు పాత్ర, మరియు అది సూచిస్తుంది
స్ట్రింగ్ ముగింపు.
కేవలం వంటి, కూడా, బాక్ స్లాష్ n అసలు పాత్ర.
బ్యాక్స్లాష్ 0 సూచించడానికి అన్నారు మా స్ట్రింగ్ ముగింపు.
నేను అక్కడ ఉంచారు లేదు.
మరియు పొడవు ద్వారా సూచిక లు కాదు శూన్య టెర్మినేటర్ సమానంగా, అప్పుడు
మేము పొడవు పెంచడం చూడాలని.
కాబట్టి అప్పుడు మా కార్యక్రమం చివరిలో, పొడవు చివరికి అన్నారు
ఈ సందర్భంలో 5 ఉంటుంది.
మరియు మేము పొడవు తిరిగి చేస్తాము.
>> OK.
కాబట్టి ఇప్పుడు డౌన్ ఇక్కడ, నేను లేదు my_strlen చేయండి.
నిర్థారించడానికి కంపైల్ లెట్ అన్నీ సరిగ్గా నడుస్తుంది.
నేను 2 లో చేస్తున్న?
లేదా 1 ఉంది?
ఆ చెయ్యాలి.
అన్ని కుడి.
కాబట్టి ఈ argv 2.
ఊహించిన విధంగానే పనిచేస్తుంది అయితే ఒక నేను దారికొస్తారు
అవును.
OK.
విషయాలు ఈ వెర్షన్ లేదు printf కొత్త తర్వాత పంక్తి, కానీ
ఏ వైవిధ్యం లేదు.
OK.
అంచనా కనుక పని.
>> ఇప్పుడు మేము కూడా ఈ ఒక అడుగు మిళితం చేయవచ్చు మరింత, ఇక్కడ పేరు నోటీసు, బాగా,
మొదటి, మేము argv యొక్క strlen ఈడ్చడం చేస్తున్నారు నేను, ఆపై మేము మీద iterating
ఆ స్ట్రింగ్ లో ప్రతి పాత్ర.
బదులుగా ఆ చేయడం వలన, ఏమి మేము కేవలం వేచి ఈ తర్కం మిళితం
మేము బాక్ స్లాష్ 0 కుడి హిట్ వరకు లూప్ ఈ లోకి?
Argv i, j చేస్తుంది అందువలన iterate సమాన కాదు బాక్ స్లాష్ 0.
కాబట్టి యొక్క మొదటి అమలు అనుమతిస్తాయి.
>> అన్ని కుడి.
ఇక్కడ, ఈ పరిస్థితి అని -
స్పష్టమవుతుంది తెలియజేయండి.
కాబట్టి ఇప్పుడు, ఈ మా argv ఉంచబడుతుంది.
కాబట్టి నేను ముందు ఆ కార్యక్రమం నడిచింది, argv తీగలను యొక్క వ్యూహం ఉంది.
కాబట్టి, నేను డాట్ స్లాష్ argv తో అమలు 2, హలో వరల్డ్, అప్పుడు argv
స్వయంగా argv కోసం, పొడవు 3 సున్నా, హలో, మరియు ప్రపంచ.
>> మరియు ఈ సూచికలు ప్రతి లోపలి, ఉంది స్వయంగా ఈ ఉంటాం పేరు వ్యూహం,
డాట్, ఈ స్లాష్ ఉంటుంది, నేను తెలియదు కుడి దిశలో ఉంటే, నేను
ఇది ఉంది భావించడం లేదు.
A-R-V డాష్, మరింత స్థలం అవసరం.
యొక్క ఈ శ్రేణి లోకి కట్ లెట్.
A-R-V డాష్ 0, ఆపై బాక్ స్లాష్ 0.
ఆపై గందరగోళము హలో ఉంటుంది.
యొక్క, H-E బాక్ స్లాష్ 0 పిలవబడు.
చివరకు, W-O బాక్ స్లాష్ 0.
>> కాబట్టి మేము కేవలం రాసిన అల్గోరిథం, వారు ఏమి ఉచ్చులు, కోసం యున్న
డూయింగ్, మేము మొదటి కలిగి నేను తరువాత j ఎదుర్కోవడానికి.
ఈ న కోడ్ సులభంగా ఉంటుంది స్క్రీన్, యొక్క ఈ వెళదాం.
OK.
నేను ఆ ఇటెరేటర్ అని గమనించవచ్చు ప్రతి ఆదేశం మీద iterating
లైన్ వాదన.
మరియు j ఇటెరేటర్ iterating ఉంది ఆ ప్రతి పాత్ర మీద
కమాండ్ లైన్ వాదన.
కాబట్టి ఈ అంతరాంతర printf చేస్తున్నది , మేము argv 0 0, printf printf చేశారు ఉంది
argv 0 1, printf argv 0 2, 0 3, 0 4, 0 5, 0 6, కానీ ఇప్పుడు, argv 0 7 అన్నారు
సమాన బాక్ స్లాష్ 0.
>> కాబట్టి అప్పుడు మేము లూప్ ఆ నిష్క్రమించడానికి, మరియు ప్రస్తుతం నేను 1 iterates.
ఇప్పుడు మేము ప్రింట్ చూడాలని argv 1 0, argv 1 1 -
బాగా, ఇప్పుడు, నేను చిన్న హలో కట్ నుండి, argv 1 2 మళ్ళీ అన్నారు
బాక్ స్లాష్ 0.
కాబట్టి, నేను పెంచడం మరియు కొనసాగుతుంది, మరియు కాబట్టి, వరకు మేము అన్ని ప్రింట్
ప్రపంచ మరియు ఆ మూడు కమాండ్ లైన్ ఉన్నాయి వాదనలు, మరియు మేము నుండి బయటకు వస్తుంది
అన్నింటి లూప్, మరియు మా కార్యక్రమం పూర్తి.
OK.
>> ఇక్కడ వచ్చి తెలియజేయండి.
కాబట్టి మీరు కొన్ని పరిచయాన్ని పొందుతారు చేస్తాము ఈ ఆదేశ పంక్తి వాదనలు
ప్రత్యేక సమస్య సెట్.
>> ఇప్పుడు, డీబగ్గింగ్.
కాబట్టి మీరు బహుశా ఇప్పటికే వచ్చింది మీ మునుపటి కొన్ని డీబగ్గింగ్
సమస్య సెట్.
మరియు డీబగ్గింగ్ ఒకటి చాలా సులభమైన మార్గం, మొదటి, యొక్క ఒక బగ్గీ కార్యక్రమం చూద్దాం.
, ఈ కార్యక్రమం ద్వారా వాకింగ్ మేము ఒక వినియోగదారుని అభ్యర్థించడం వెళుతున్న
పూర్ణాంక, ఆ పూర్ణాంక సేకరించి, తర్వాత, ఏకపక్ష, మేము ఒక అయితే లూప్ కలిగి
కేవలం తరుగుదల అన్నారు ఇది 10 సమానం నేను వరకు.
లెట్ యొక్క కేవలం నేను ఎంటర్ వెబ్ ఊహించుకోవటం 10 కంటే ఎక్కువ పూర్ణాంకం.
ఇది 10 సమానం వరకు నేను తరుగుదల.
>> మరియు అప్పుడు మేము మరొక సమయంలో లూప్ ఉన్నాయి నేను 0 సమానం కాదు ఉన్నప్పటికీ, మేము, ఆ
3 ద్వారా నేను తరుగుదల అన్నారు.
కాబట్టి మీరు బగ్ ఉద్దేశం చూడండి ఇక్కడ, ఈ నేను తరుగుదల చేస్తాము ఆ
10 మరియు ఈ సమయంలో లూప్ విల్ 1 4 7 10,,, నుండి తరుగుదల నేను,
ప్రతికూల 2, అందువలన న 5 ప్రతికూల, మరియు ప్రతికూల అనంతం రెడీ నుండి
నిజానికి 0 సమానంగా ఎప్పుడూ.
మరియు తర్వాత ఈ కార్యక్రమం చివరిలో, మేము ఇది foo చర్య
ముద్రణ మీద వెళ్ళడం నేను.
>> కాబట్టి ఈ, ఒక చిన్న మరియు అల్పమైన కార్యక్రమం మరియు బగ్ స్పష్టంగా ఉంటుంది,
ముఖ్యంగా తర్వాత నేను బగ్ ఏమి చెప్పారో.
కానీ ఇక్కడ ఉద్దేశం బాగా, ఈ బలం, ఉంది నిజానికి కొన్ని లాగా మీ
గత నుండి అత్యాశ నుండి పరిష్కారాలను సమస్య సెట్, మరియు ఉండవచ్చు మీరు ఉన్నాయి
మీ కార్యక్రమంలో కొన్ని అనంతమైన లూప్, మరియు మీరు ఏ ఆలోచన కలిగి
అది కలిగించే.
కాబట్టి ఒక చాలా ఉపయోగకరంగా డీబగ్గింగ్ టెక్నిక్ కేవలం printfs జోడించడం
అన్ని మీ కోడ్ పైగా.
>> ఇక్కడ నేను బయట ఒక printf కావలసిన అయితే లూప్ మొదటి.
మరియు ఇక్కడ నేను ఒక printf కావలసిన, మరియు నేను నేను ప్రింట్ చేస్తాము.
లూప్ అయితే నేను కూడా నేను, మొదటి చేస్తాను.
వెలుపల, రెండవ లూప్ అయితే.
మరోసారి లోపల ప్రింట్ ఇక్కడ, విలువ నేను.
మరియు యొక్క ఈ అమలు అనుమతిస్తాయి.
>> కాబట్టి డాట్ స్లాష్ డీబగ్.
పూర్ణాంకం ఇవ్వండి.
యొక్క 13 తెలియజేసేలా.
మరియు బూమ్.
మేము అనంతం మళ్ళీ వెతికినా అని చూడండి రెండవ సమయంలో లూప్ లోపల.
కాబట్టి ఇప్పుడు మేము బగ్ ఉంది ఏమి.
కానీ printf డీబగ్గింగ్, సంపూర్ణ బాగుంది కానీ మీ కార్యక్రమాలు ఒకసారి
ఇక మరియు మరింత క్లిష్టంగా, ఉన్నాయి మరింత అధునాతన పరిష్కారాలను
విషయాలు పని విధానం.
కాబట్టి యొక్క ఈ printfs తొలగించడానికి.
మరియు యొక్క ఖచ్చితంగా నేను కాదు తెలియజేయండి తగు.
OK.
>> కాబట్టి మేము చూడాలని కార్యక్రమం పరిచయం అంటారు
GNU డీబగ్గర్ కోసం GDB,.
Well, వాస్తవానికి, యొక్క కోసం డీబగ్ తొలగించడానికి రెండవ, మళ్ళీ డీబగ్ చేయడానికి.
బాగా, నిజానికి మొదటి, మంచి పాఠం ఆదేశ పంక్తి వాదనలు లో.
ఈ గణగణమని ద్వని చేయు ఆదేశం అని గమనించండి ప్రతిదీ ఆమోదించింది ఉంది కంపైల్
కమాండ్ లైన్ వద్ద, ఈ ఆదేశ పంక్తి వాదనలు.
మీరు ఉపయోగిస్తున్న వెళ్తున్నారు కాబట్టి ఎలా ఆదేశ పంక్తి వాదనలు, మేము
ముందు, మరియు మీరు pset లో రెడీ 2, గణగణమని ద్వని చేయు వాటిని ఉపయోగించి ఎలా ఉంది.
>> కాబట్టి గమనించి ఆ ఈ మొదటి జెండా, డాష్ ggdb3, ఆ మాట్లాడుతూ ఏమి, గణగణమని ద్వని చేయు,
మీరు ఈ ఫైలు సిద్ధం చేయాలి ఉద్దేశం మేము చివరికి రెడీ
ఇది డీబగ్ అవసరం.
కాబట్టి కాలం మీరు ఆ జెండా కలిగి, అప్పుడు మేము GDB డీబగ్ చేయవచ్చు.
మరియు అది GNU డీబగ్గర్ ప్రారంభించిన చేస్తాము.
>> కాబట్టి ఆదేశాలను చాలా ఉన్నాయి మీరు అలవాటుపడతారు అవసరమైన.
మొదటివి మీరు బహుశా చేస్తాము వెంటనే అవసరమైన ప్రారంభించేవారు.
కాబట్టి ఏమి ప్రారంభించేవారు?
ఇది మా కార్యక్రమం ఆరంభమవుతుంది.
కాబట్టి, కార్యక్రమం, అమలు పూర్ణాంకం, 13 కోసం మాకు అడుగుతుంది.
అది అనంతం మళ్ళీ వెతికినా వంటి ఉంది నేను తొలగించబడింది తప్ప, అంచనా
printfs, కాబట్టి మేము కూడా ఆ చూడలేదు.
సాధారణంగా ముగిసింది.
ఓహ్.
ఇది చుట్టి అవకాశం ఉంది అన్ని మార్గం చుట్టూ, తిరిగి - ఆ విస్మరించి.
ఇది సాధారణంగా బయటకు లేదు భావించండి.
ఆ ఒక క్లిష్టమైన సమాధానం ఉంది.
>> కాబట్టి ఇప్పుడు, చాలా ఉపయోగకరమైన కాదు.
కాబట్టి కేవలం లోపలి మా ప్రోగ్రామ్ను అమలు ఈ డీబగ్గర్ ఏ మాకు సహాయం లేదు
మేము పూర్తి కాలేదు నుండి మార్గం, డాట్ GDB బయట నుండి డీబగ్ స్లాష్.
కాబట్టి ఒక కమాండ్ అని మీరు బహుశా చేస్తాము -
మరియు నేను ఈ విడిచి చేస్తాము.
కంట్రోల్ డి లేదా, పని రెండు విడిచి.
కాబట్టి యొక్క మళ్ళీ తెరవడం అనుమతిస్తాయి.
>> మరో ఆదేశం అని మీరు బహుశా చేస్తాము వెంటనే కావలసిన
అలవాటుపడతారు బ్రేక్ ఉంది.
కాబట్టి మేము, ఇప్పుడు ప్రధాన బ్రేక్ ఆన్ చేస్తాము ఆపై నేను వివరించడానికి చేస్తాము.
బాగా, ఇక్కడ మనం ఒక బ్రేక్ పాయింట్ సెట్ చూడండి debug.c ఈ లైన్ వద్ద.
కాబట్టి ఏమి విరామం పద్ధతి నేను అమలు టైప్, కార్యక్రమం అన్నారు
వరకు కొనసాగించమని నేను ఒక బ్రేక్ పాయింట్ హిట్.
నేను పరుగుల కొట్టాడు, ప్రోగ్రామ్, మొదలవుతుంది ఆపై వెంటనే దాని వంటి విచ్ఛిన్నం
ప్రధాన విధి ప్రవేశిస్తుంది.
బ్రేక్ ప్రధాన ఏదో అన్నారు మీరు అందంగా సాధారణంగా చేయండి.
>> ఇప్పుడు, మీరు పరిచయం కొన్ని ఎక్కువ ఆదేశాలను.
మేము చెప్పాడు చేసే, ఇక్కడ గమనించవచ్చు ఇది లైన్ 11, వద్ద విరిగింది
printf, పూర్ణాంకం ఇవ్వండి.
కాబట్టి కమాండ్ తదుపరి ఎలా అన్నారు మేము కోడ్ యొక్క తదుపరి లైన్ వెళ్ళండి.
ఈ మాకు అడుగు అనుమతిస్తుంది అన్నారు లైన్ ద్వారా మా కార్యక్రమం లైన్ ద్వారా.
తరువాత.
>> ఇప్పుడు 12, మేము చేయబోతున్నామని పూర్ణ సంఖ్య.
తదుపరి.
మీరు కేవలం మళ్ళీ నొక్కండి ఉంటే, అది చేస్తాము మీరు చేసింది గత విషయం పునరావృత్తం.
నేను టైప్ లేదు ప్రతి సమయం.
కాబట్టి పూర్ణాంకం, 13 ఎంటర్.
కాబట్టి ఇప్పుడు, లైన్ 14, నేను ఎక్కువ ఉంది 10 కంటే, మరియు నేను తరువాత చేస్తాను.
మరియు మేము నేను తరుగుదల చూడాలని చూడండి.
కనుక మనం మళ్ళీ నేను తరుగుదల చూడాలని.
>> కాబట్టి ఇప్పుడు, మరొక ఉపయోగకరమైన కమాండ్ ప్రింట్ ఉంది.
కాబట్టి ప్రింట్ ప్రింట్ అన్నారు వేరియబుల్ విలువ.
యొక్క విలువ తేవలెను నేను వేరియబుల్ యొక్క.
యొక్క నేను ప్రింట్ లెట్.
ఇది నేను 11 ఉంది సే అవకాశముంది.
ఇప్పుడు మేము మళ్ళీ అయితే నేను 10 కంటే ఎక్కువ.
నేను ఇప్పటికీ కంటే ఎక్కువ ఇది 11 నుండి 10,.
నేను మైనస్ మైనస్.
యొక్క మళ్ళీ నేను ప్రింట్ లెట్.
ఊహించిన విధంగా, ఇది 10 ఉంది.
>> కాబట్టి ఇప్పుడు, తదుపరి.
ఇది తిరిగి పరిస్థితి చేస్తాడు, నేను ఉంది 10 కంటే ఎక్కువ, కానీ నేను, ఇప్పుడు 10
ఇది 10 కంటే ఎక్కువ కాదు, కాబట్టి కాదనీ ఇది సమయంలో లూప్ బయటకు వస్తాయి.
ఇప్పుడు మేము కోడ్ యొక్క లైనును క్రింద ఉన్నారు.
మరియు మరొక ఆదేశం, జాబితా, కేవలం అన్నారు మునుపటి మరియు తదుపరి ప్రదర్శించడానికి
లైన్స్ ఆఫ్ కోడ్, లో జంట కేసు మీరే కోల్పోయింది.
కాబట్టి మేము కేవలం, ఈ సమయంలో లూప్ నిష్క్రమించారు మరియు ఇప్పుడు మేము ఈ ప్రవేశించాయి
అయితే లూప్, లైన్ 18.
నేను 0 సమానం కాదు ఉన్నప్పటికీ కాబట్టి.
మరియు, తరువాతి, మనం చేస్తాము నేను మైనస్ 3 సమానం, మరియు గమనించి, ఈ కేవలం కొనసాగించడాన్ని.
మరియు మేము నేను ప్రింట్ చేయవచ్చు.
>> ప్రతి ఆదేశం విధమైన సత్వరమార్గాలు ఉన్నాయి.
కాబట్టి p ప్రింట్ సంక్షిప్తరూపం.
కాబట్టి మేము p నేను '.
కేవలం n పట్టుకుని ఉంచడానికి, లేదా తదుపరి పనిని.
మళ్ళీ నేను ప్రింట్.
మీరు 167 ప్రతికూల ఇప్పుడు చూడండి.
కాబట్టి ఈ దిగాలుగా, కానీ కాదు నిజంగా ఎప్పటికీ, మీరు చూసింది నుండి, ఇది
నిజానికి ఏదో ఒక సమయంలో ముగుస్తుంది.
>> కాబట్టి ఆ GDB ప్రారంభమై ఉంది.
కానీ యొక్క GDB వాసనగాని విషయం తెలియజేసేలా.
ఊ, డీబగ్.
కాబట్టి, ఈ ప్రత్యేక సందర్భంలో, అనంతమైన లూప్ యొక్క లోపల సంభవించింది
ప్రధాన విధి.
ఇప్పుడు కోసం, కేవలం నేను ఉన్నాను అంగీకరించి లోకి అనంతమైన లూప్ వెళ్లి
foo ఫంక్షన్.
ఈ చివరిలో, గుర్తుంచుకోవాలి కార్యక్రమం, బాగా, దీనిని మొదట
కేవలం ఇది foo, కాల్ నేను ప్రింట్ అన్నారు.
అయితే ఇప్పుడు మేము ఇది, foo చేస్తున్నారు అది 0 వరకు నేను తరుగుదల, మరియు అన్నారు
ఆ వేరియబుల్ ప్రింట్.
OK.
ఆ సేవ్.
డీబగ్ చేయండి.
ఇప్పుడు, GDB డీబగ్.
OK.
>> నేను రన్ చేస్తే నేను వెళ్ళడం లేదు నిజానికి ద్వారా అడుగు చేయగలరు నా
కార్యక్రమం లైన్ ద్వారా లైన్.
కాబట్టి యొక్క ప్రధాన వద్ద బ్రేక్ వీలు, ఆపై అమలు టైప్.
కాబట్టి ఈ ద్వారా వెళ్ళి, printf, ఎంటర్ పూర్ణాంకం, పూర్ణాంక, 13 పొందడానికి.
కాబట్టి మేము దానికి వీలు ఉంచడానికి వెళుతున్న ఐ 10 కంటే ఎక్కువ వరకు.
అప్పుడు మేము ద్వారా వస్తాయి చూడాలని సమయంలో లూప్, మరియు లైన్ ను -
యొక్క ఒక ప్రత్యేక విండోలో ఇది తెరుచుకుంటుంది తెలియజేయండి.
ఇకపై నేను వచ్చేవరకు కాబట్టి మేము decremented అప్పుడు 10 కంటే ఎక్కువ, మరియు మేము
foo, విధి అని.
>> సో వాట్ వెంటనే నేను హిట్ జరిగింది ఫంక్షన్ foo, బాగా, నేను foo అని, మరియు
నేను ఇకపై GDB నియంత్రణ కలిగి.
కాబట్టి వెంటనే నేను ఈ లైన్ వద్ద తదుపరి హిట్, ఈ జరిగిన వరకు విషయాలు కొనసాగింది,
అక్కడ కార్యక్రమం నిష్క్రమించారు -
అది చివరికి ఉనికిలో లేదు ఊహించుకోవటం.
మీరు ఒక బిట్ నిలిపివేయి చూసింది.
అందుచే నేను నియంత్రణ తగ్గిపోయింది ఆ సమయంలో కార్యక్రమం?
నేను తరువాత టైప్ చేసినప్పుడు Well, వెళ్తాడు కోడ్ సాహిత్య తదుపరి లైన్ అని
నిర్వర్తిస్తుంది.
కాబట్టి తర్వాత పంక్తి 21, కోడ్ యొక్క తదుపరి లైన్ ఆ, లైన్ 22 ఉంది నిర్వర్తిస్తుంది
ప్రధాన నుండి నిష్క్రమించే, ఇది.
కాబట్టి నేను వెళ్లాలని మీరు లేదు కోడ్ యొక్క తదుపరి లైన్ కు.
నేను ఫంక్షన్, foo లోకి వెళ్లాలని మీరు, ఆపై కూడా ద్వారా అడుగు
కోడ్ యొక్క ఆ పంక్తులు.
>> కాబట్టి ఆ కోసం, మేము ఒక ప్రత్యామ్నాయ కలిగి.
యొక్క ఆ మళ్ళీ విడిచి తెలియజేయండి.
ప్రధాన విడిపోయారు.
ఊ, 1, తర్వాత తర్వాత, 13, తదుపరి, తర్వాత తర్వాత, జాగ్రత్తగా,
మేము లైన్ foo హిట్ ముందు.
OK.
>> కాబట్టి ఇప్పుడు, మేము, లైన్ 21 వద్ద ఉన్నారు మేము foo కాల్.
మేము, తదుపరి టైప్ అనుకుంటారు నుండి కేవలం ఫంక్షన్ foo కాల్, మరియు
కోడ్ తదుపరి లైన్ వెళ్ళండి.
మనం ఉపయోగించడానికి అడుగు.
కాబట్టి దశ మధ్య తేడా ఉంది మరియు దశ లోకి వేసింది పేరు తదుపరి,
పని, మరియు తదుపరి వెళుతుంది ఫంక్షన్ పైగా.
ఇది కేవలం పూర్తిగా అమలు ఫంక్షన్ మరియు ఉంచుతుంది అన్నారు.
>> కాబట్టి దశ మాకు తీసుకుని అన్నారు ఫంక్షన్, foo.
మరియు మేము ఇప్పుడు, మేము తిరిగి ఉన్నారు, ఇక్కడ చూడండి సిద్ధాంతంలో, ఆ ఈ సమయంలో లూప్,
ఎప్పటికీ కొనసాగుతుంది అన్నారు.
మరియు మీరు కూడా లేనప్పుడు దశ, కొట్టినప్పుడు కాల్ ఒక ఫంక్షన్, అది ఉంది
తదుపరి కి.
మీరు ఒక లైన్ వద్ద ఉన్నప్పుడు కాబట్టి ఇది మాత్రమే అని దశ ఒక ఫంక్షన్ కాల్
తదుపరి నుండి తేడా అన్నారు.
కాబట్టి దశ ఇక్కడ మాకు తెస్తుంది.
దశ, అడుగు, అడుగు, అడుగు, అడుగు, అడుగు, మరియు మేము ఎప్పటికీ కేవలం అనంతమైన లూప్ చేస్తాము.
>> కాబట్టి మీరు ఆ అలవాటుపడతారు ఉండవచ్చు మీ అనంత వలయాలు గుర్తించడం విధంగా, ఉంది
ఈ Enter కీ రమణిని మీకు కష్టం ఇక్కడ చూడండి.
అక్కడ అలా మంచి మార్గాలు ఉన్నాయి, కానీ ఇప్పుడు కోసం, ఆ సంపూర్ణ సరిపోతుంది.
మరియు ఆకృతిని, శైలి అనుగుణంగా 50, నేను ఈ వుండాలి.
OK.
>> ఒకనాటి గత ఆదేశం పరిచయం.
సరే, సైన్ డీబగ్ GDB తెలియజేయండి
బదులుగా ప్రధాన వద్ద బద్దలు, నేను foo ఫంక్షన్ కూడా ఉంది
సమస్య, నేను కలిగి కాలేదు కేవలం , బదులుగా, foo వద్ద బ్రేక్.
యొక్క నేను వద్ద బ్రేక్ చెప్పడానికి లెట్ ప్రధాన మరియు foo రెండు.
కాబట్టి మీరు అనేక బ్రేక్ పాయింట్స్ సెట్ చేయవచ్చు మీకు కావలసిన.
నేను పరుగుల టైప్ చేసినప్పుడు, ఏమైందా వద్ద ఆపడానికి -
ooh, నుండి, యొక్క మళ్ళీ కంపైల్ చెయ్యండి లెట్ నేను మార్చివేసింది.
మీరు ఈ లైన్, హెచ్చరిక, మూల చూస్తారు ఫైలు executable కంటే ఇటీవల ఉంది.
కాబట్టి ఆ నేను ఇక్కడ వెళ్లిన అర్థం మరియు శైలి అనుగుణంగా ఈ మారిన
50, కానీ నేను మళ్ళీ కంపైల్ లేదు కార్యక్రమం.
కాబట్టి GDB ఆ యొక్క నాకు తెలుసు చేస్తుంది.
నేను, మళ్ళీ డీబగ్ చేయడానికి, విడిచి చేస్తాము GDB డీబగ్ హిట్.
OK.
>> కాబట్టి ఇప్పుడు, తిరిగి నేను ఏమి చేయడానికి.
ప్రధాన, విరామం foo బ్రేక్.
ఇప్పుడు నేను అమలు, కాబట్టి ఇది ఉంటే హిట్స్ వరకు కొనసాగుతుంది వెళ్లి ఒక
బ్రేక్ పాయింట్.
ఆ బ్రేక్ పాయింట్ నిర్మాణము ప్రధాన వద్ద మొదటి ఒకటిగా.
ఇప్పుడు, బదులుగా తదుపరి చేయడం యొక్క, తర్వాత తర్వాత, తరువాత, తదుపరి, నేను foo హిట్ వరకు నేను
కొనసాగుతుంది, కొనసాగుతుంది టైప్ చెయ్యవచ్చు మీరు తొమ్మిదు హిట్ వరకు.
నేను మొదటి పూర్ణాంక ఎంటర్ ఉంటుంది.
నేను హిట్ వరకు కొనసాగుతుంది కొనసాగించు ఆ ఇది తొమ్మిదు,
foo ఫంక్షన్.
>> మీరు ఒక హిట్ వరకు అమలు అమలు ఉన్నప్పుడు బ్రేక్ పాయింట్, కానీ మీరు మాత్రమే అమలు టైప్
మీరు, అప్పుడు కార్యక్రమం మొదలు, మరియు చేస్తున్నారు అప్పటి నుంచి, కొనసాగుటకు ఉంది.
నేను కేవలం ప్రధాన పోగొట్టుకున్నారు మరియు ఉంటే అప్పుడు నడిచింది, అది విచ్ఛిన్నం చేస్తాము
అప్పుడు ప్రధాన, మరియు కొనసాగుతుంది.
నేను foo ఒక బ్రేక్ పాయింట్ కలిగి, లేదు నుండి పూర్ణాంక ఎంటర్, తరువాత ఇప్పుడు నేను ఉన్నాను
foo వద్ద బ్రేక్ మాత్రం కాదు.
ఇది కేవలం అనంత చేస్తాడు అప్పటిదాకా లూప్.
OK.
>> కాబట్టి ఆ GDB ఉపోద్ఘాతం ఉంది.
మీరు ఉపయోగించడం ప్రారంభిస్తుంది మీ సమస్య లో.
ఇది చాలా సహాయకారిగా ఉంటుంది దోషాలు గుర్తించడానికి.
మీరు నిజంగా కేవలం, లైన్ ద్వారా లైన్, వెళ్ళి ఉంటే మీ కోడ్ ద్వారా, మరియు ఉంది ఏమి పోల్చడానికి
నిజానికి మీరు ఆశించిన ఏమి తో జరుగుతున్న జరిగే, అది అందంగా ఉంది
మీ దోషాలు మిస్ కష్టం.
OK.
>> గత వారం డేవిడ్ ఈ తీసుకువచ్చింది కోసం రహస్య కీ గూఢ లిపి శాస్త్రం stuff
మేము అనుకుంటున్న పేరు మొదటిసారి, పాస్వర్డ్లను కేవలం నిల్వ మా
కొన్ని సాదా టెక్స్ట్ ఫైల్ లో కంప్యూటర్, పేరు ఎవరైనా పైగా మరియు కేవలం రావచ్చు
దానిని తెరిచి వాటిని చదవండి.
ఆదర్శవంతంగా, అవి ఎన్క్రిప్ట్ అవుతుంది కొన్ని విధంగా.
మరియు సమస్య 2 లో, మీరు వ్యవహరించే వస్తుంది ఎన్క్రిప్షన్ యొక్క ఒక పద్దతి తో,
లేదా, బాగా, రెండు పద్ధతులు, కానీ వారు గొప్ప కాదు.
మీరు హ్యాకర్ ఎడిషన్ చేస్తే, మీరు కూడా వ్యవహరించే కావడం
కొన్ని విషయాలు మార్చడంలో.
>> కాబట్టి సమస్య ఇప్పుడు, కూడా, ఉంది మేము శక్తివంతమైన ఎన్క్రిప్షన్ కలిగి
ప్రపంచంలో అల్గోరిథం, మీరు ఒక ఎంచుకోండి ముఖ్యంగా పేద పాస్వర్డ్ను, అది
, చాలా సహాయపడదు నుండి ప్రజలు ఇప్పటికీ అది గుర్తించడానికి చేయగలరు.
ఎన్క్రిప్టెడ్ స్ట్రింగ్ చూసిన కూడా ఇది చెత్త మెస్ కనిపిస్తోంది
ఆ, వాటిని వ్యర్ధము వారు ఇప్పటికీ కేవలం కొన్ని పాస్వర్డ్లను ప్రయత్నించండి అవసరం
మీరు, అది గుర్తించడానికి చాలా సురక్షితం కాని.
కాబట్టి ఒక వీడియో చూడటం ఆ చేస్తుంది.
>> [వీడియో ప్లేబ్యాక్]
>> -హెల్మెట్, మీరు దయ్యము.
ఏం జరుగుతోంది?
మీరు నా కుమార్తె ఏం చేస్తున్నారు?
>> తెలివైన పరిచయం నన్ను అనుమతి యువ ప్లాస్టిక్ సర్జన్, డాక్టర్ ఫిలిప్
Schlotkin, గొప్ప ముక్కు మొత్తం లో ఉద్యోగం మనిషి
విశ్వం మరియు బెవెర్లీ హిల్స్.
>> -ప్యాంటీ.
>> -ముక్కు ఉద్యోగం?
నేను అర్థం లేదు.
ఆమె ఇప్పటికే ముక్కు ఉద్యోగం కనబరచాడు.
ఇది ఒక తీపి పదహారు ఉంది.
>> -సంఖ్య.
మీరు ఏమనుకుంటున్నారో కాదు.
ఇది చాలా చెత్తగా ఉంది.
మీరు నాకు కలయిక ఇవ్వాలని లేదు ఉంటే గాలి షీల్డ్, డాక్టర్ Schlotkin రెడీ
తన పాత ముక్కు మీ కుమార్తె తిరిగి ఇవ్వాలని.
>> -సంఖ్య.
మీరు ఎక్కడ ఆ వచ్చింది?
>> -అన్ని కుడి.
నేను చెబుతాడని.
లేదు, డాడీ.
లేదు, మీరు కాదు తప్పక.
>> -అప్పుడు గుర్తొచ్చింది, నా ప్రియమైన.
నేను మీ కొత్త ముక్కు బాధగా.
ఎట్టిపరిస్థితిలోనూ కలిపి చెప్పదు, ఎవైనా.
>> -చాలా బాగా.
డాక్టర్ Schlotkin, మీ చెత్త చేయండి.
>> ఏదన్న ఆనందం.
>> [TOOLS పదును కావడంతో]
>> -సంఖ్య.
వేచి.
నేను చెబుతాడని.
>> -I ఇది పని చేస్తుంది తెలుసు.
అన్ని కుడి.
నాకు ఇచ్చి.
>> -కలయిక ఒకటి.
>> వన్.
>> టు.
>> మూడు.
>> ఫోర్.
>> -ఐదు.
>> -కాబట్టి కలయిక, ఒకటి రెండు, మూడు, నాలుగు, ఐదు.
ఆ stupidest కలయిక ఉంది నేను ఎప్పుడూ నా జీవితంలో విన్న.
ఆ విషయం రకం ఒక ఇడియట్ ఉంది తన లగేజ్ పై.
>> మీ హైనెస్, మీరు ధన్యవాదాలు.
>> -అంటూ?
>> -I గోడ ఆఫ్ చెయ్యబడింది.
>> -మదు చేశాడు.
మీరు మొత్తం సినిమా ఆఫ్ చెయ్యబడింది.
>> -I తప్పు బటన్ ను నొక్కిన ఉండాలి.
>> -సరే, తిరిగి ఉంచండి.
చిత్రం తిరిగి ఉంచండి.
>> -రామరాజు.
రామరాజు.
>> యొక్క, ఆర్నాల్డ్ Go-లెట్.
, గ్రెట్చెన్ కమ్.
వాస్తవానికి, మీరు నేను ఇప్పటికీ చేస్తాము తెలుసు ఈ కోసం మీరు బిల్లు.
>> [END వీడియో ప్లేబ్యాక్]
>> రాబ్ బోడెన్: అన్ని కుడి.
మేము ఇప్పటికే గురించి మాట్లాడటం కాబట్టి ఇప్పుడు ఆ కొన్ని మార్గాల్లో భద్రత, nice
చిన్న చిత్రం పోస్టర్, కాబట్టి ఇటీవల లో NSA తో రోజుల, ఈ సమస్యలు
ప్రతిదీ పర్యవేక్షణ.
ఇది మీరు భావిస్తాను కష్టం గోప్యత విధమైన కలిగి
ఆన్లైన్ ప్రపంచ, నేను చెప్పడం కాదు అయితే మీరు ప్రిజం యొక్క వివరాలను అత్యంత.
కాబట్టి ప్రిజం దాటి కదిలే, మేము వెళ్ళి లేదు ఇప్పుడు, గురించి మాట్లాడటం చేయడానికి
మీ ల్యాప్టాప్ గురించి ఆలోచించటం.
కాబట్టి ఇక్కడ, నేను మారాలని అనుకుంటున్నారా నా అసలు ఖాతాకు,
నా చిన్న పెంగ్విన్ తో.
నేను ఒక పాస్వర్డ్ను సెట్, మరియు ఆ పాస్వర్డ్ను నేను కావలసినట్లు ఉంది.
>> కానీ గుర్తుంచుకోండి ఏమి నేను కూడాను! , ఈ లాగిన్ లో
ప్రాంప్ట్, కొన్ని కార్యక్రమం.
ఇది కొంత కార్యక్రమం కొన్ని వ్యక్తి రాసిన.
కాబట్టి, ఆ వ్యక్తి, ఉంటే వారు ముఖ్యంగా హానికరమైన, వారు భావించారు
చెప్పారు, అన్ని కుడి, అయితే పాస్వర్డ్ను నేను ఎంటర్ సమానం నా
వాస్తవ పాస్వర్డ్, లేదా అది సమానంగా కొన్ని ప్రత్యేక పాస్వర్డ్ -
డేవిడ్ అద్భుతంగా లేదా విషయం -
అప్పుడు వాటిని అనుమతించడానికి
కాబట్టి ఒక హానికరమైన ప్రోగ్రామర్ కలిగి మీ Macs అన్ని, లేదా యాక్సెస్
Windows, లేదా ఏదైనా.
>> కాబట్టి ఆ, నుండి, గురించి ఎక్కువగా కాదు నేను అర్థం, ఈ లాగిన్ కార్యక్రమం
ఆ OS X, వందలాది రవాణా యొక్క లేదా ప్రజలు వేలాది కలిగి
ఈ కోడ్ సమీక్షించారు.
కాబట్టి, మీరు ఎక్కడా మీ కోడ్ లో, ఉంటే ఈ స్ట్రింగ్ సమానం సమానం చెప్పడానికి
డేవిడ్ అద్భుతం, లాగిన్, అప్పుడు ఒకరి మాత్రం, వంటి, వేచి.
అంతేకాదు.
ఈ ఇక్కడ కాదు.
కాబట్టి మేము విషయాలు ఒక మార్గం రకమైన సురక్షితమైనదిగా.
>> కానీ కూడా కార్యక్రమాలు గురించి ఆలోచించటం మీరు వ్రాసే.
యొక్క లాగిన్ ప్రోగ్రామ్ రాశాడు పిలవబడు.
మీరు రాసిన ఈ లాగిన్ కార్యక్రమం, కాబట్టి సహజంగా, మీరు ఒక మంచి
ప్రోగ్రామర్.
మీరు ఏ హానికరమైన రాణించాలి చేస్తున్నారు x సమానం సమానం డేవిడ్ అద్భుతం
మీ కోడ్ లోకి.
కానీ ఈ ప్రోగ్రామ్, మీరు ఏమి ఈ కార్యక్రమం కంపైల్ ఉపయోగించాలి?
గణగణమని ద్వని చేయు వంటి ఏదో.
కాబట్టి ఏం జరిగింది వ్యక్తి గణగణమని ద్వని చేయు లో కేస్ గల గణగణమని ద్వని చేయు ప్రత్యేక వ్రాయండి
ఏదో, నేను కంపైల్ am ఉంటే కార్యక్రమం లాగిన్, అప్పుడు ఈ కోడ్ ఎంటర్
ఉంటే, ఆ లాగిన్ కార్యక్రమంపై x సమానం డేవిడ్ అద్భుతం సమానం?
కాబట్టి చాలా ఇంకా, కానీ మేము అదే కలిగి ఇక్కడ జారీ, పేరు గణగణమని ద్వని చేయు, బాగా,
వేలాది లేకపోతే పదుల వేలమంది ప్రజలు, కలిగి, గణగణమని ద్వని చేయు చూసారా
కోడ్ దాని పంక్తులు చూస్తూ చెప్పారు, అన్ని కుడి, ఇక్కడ చెడు ఏమీ లేదు.
సహజంగానే, ఎవరూ చేస్తోంది ఈ హానికరమైన ఏదైనా.
>> కానీ, వంటి, కూడా గణగణమని ద్వని చేయు నేను గణగణమని ద్వని చేయు కంపైల్ ఉంటే?
నేను కొన్ని కంపైలర్ ఆ గణగణమని ద్వని చేయు లోకి ఇన్సర్ట్ గణగణమని ద్వని చేయు కూర్చింది
అని ఈ ప్రత్యేక హాక్, అన్ని కుడి, నేను గణగణమని ద్వని చేయు కంపైల్ సమయంలో, అప్పుడు
executable నేను ప్రత్యేకంగా కనిపించాలి చేసుకోగా లాగిన్ ప్రోగ్రామ్ మరియు చొప్పించు లోపలి
ఈ పాస్వర్డ్ను, సమానం సమానం డేవ్ అద్భుతం?
కాబట్టి గుర్తు మీ కంపైలర్ కూడా ఏదో ఒక సమయంలో సంకలనం అవసరం.
కాబట్టి మీరు గణగణమని ద్వని చేయు కంపైల్ ఎంచుకున్న ఉంటే , కూడా మీరు, హానికరమైనది తో
మొత్తం వత్తిడి కాలేదు డౌన్ లైన్.
>> ఇక్కడ, మేము కెన్ థాంప్సన్ కలిగి మరియు డెన్నిస్ రిట్చీ.
కాబట్టి ఈ గుర్తింపు ఫోటో ఉంది.
డెన్నిస్ రిట్చీ కుడివైపున ఉంది.
అతను ఒక ప్రధాన ఉంది -
చాలా చక్కని C. రాశారు కాబట్టి మీరు ఈ తరగతి అతనికి ధన్యవాదాలు.
కెన్ థామ్సన్ ఎడమ ఉంది.
వాటిలో ఈరెండు UNIX రాశారు.
బాగా, వారు ప్రధాన చేయలేకపోయారు UNIX లో.
కొన్ని ఉన్నాయి.
ఏదో ఒక సమయంలో కాబట్టి కెన్ థాంప్సన్,, అతను ట్యూరింగ్ అవార్డు విజేత.
మరియు ట్యూరింగ్ అవార్డు, నేను ఎల్లప్పుడూ విన్న చేసిన ఇది ఈ విధంగా సూచించారు, అది
కంప్యూటర్ సైన్స్ నోబెల్ బహుమతి.
>> కాబట్టి ట్యూరింగ్ అవార్డ్, అతను ఉంటుంది తన ఉపన్యాసంలో ఇవ్వాలని.
మరియు అతను ఈ చాలా ప్రసిద్ధ ప్రసంగం ఇస్తుంది ఇప్పుడు, నమ్ముతూ ప్రతిఫలనాలు అని
మేము లింక్ ఇది ట్రస్ట్, కోర్సు వెబ్సైట్లో పొందాలనే.
మరియు ఈ ప్రసంగంలో, అతను, అన్ని కుడి, చెప్పారు నేను UNIX రాశారు, మరియు ఇప్పుడు అన్ని యొక్క
మీరు ప్రజలు UNIX ఉపయోగిస్తున్నారు.
ఇప్పుడు, Linux అని గుర్తున్నాయి UNIX యొక్క ప్రత్యక్ష వారసుడు.
OS X నేరుగా UNIX ఉపయోగిస్తుంది.
Windows ఎక్కువ చేస్తుంది, కానీ చాలా ఆలోచనలు UNIX నుండి తీసిన.
>> కాబట్టి ఆయన దశ వరకు వెళ్లి చెప్పారు అన్ని కుడి, నేను UNIX రాశారు.
మరియు అందువల్ల మీరు అబ్బాయిలు తెలుసు, నేను ఉన్నాను ప్రతి లోకి లాగిన్ కాలేరు
మీ కంప్యూటర్ల సింగిల్ను.
X ఉంటే నేను ఈ ప్రత్యేక ఒకటి ఉంచారు నుండి సమానం, కెన్ థామ్సన్ అద్భుతం సమానం
అప్పుడు నేను లాగిన్ అనుమతి చేస్తున్నాను.
కాబట్టి ప్రజలు, బాగా, వంటి తెలియక కొంత మీరు అలా?
లాగిన్ కార్యక్రమం చూశారు మరియు ఏమీ లేదు.
అతను, నేను కంపైలర్ చివరి, వంటిది లాగిన్ కార్యక్రమంలో లాగిన్
లాగిన్ ఇప్పుడు ఉంటుంది కాబట్టి ఆ x కెన్ థాంప్సన్ సమానం సమానం
అద్భుతం.
>> మరియు వారు బాగా, నిజమైన కాదు, చెప్పడానికి.
మేము కంపైలర్ చూడటం, మరియు చేస్తున్నారు కంపైలర్ ఏ లక్షణాలను కలిగి లేదు
వలె కోడ్.
ఆయన OK, వంటిది, కానీ మీరు ఏమి ఉన్నాయి కంపైలర్ తో కంపైల్?
మరియు, బాగా, వంటి, వారు, మరియు అతను నేను మీరు కంపైలర్ ఇచ్చిన ఒక ఉన్నాను
మీరు కంపైలర్ కంపైల్ ఉపయోగించి, కాబట్టి చేస్తున్నారు మీరు, ఒక కంపైలర్ కంపైల్ అని
కూడా హానికరమైనది, మరియు రెడీ లాగిన్ కార్యక్రమం బ్రేక్.
కాబట్టి ప్రాథమికంగా, ఆ సమయంలో, ఉంది మీరు సోర్స్ చూడండి అవటానికి మార్గమే
లాగిన్ కార్యక్రమం కోడ్ ఏమి చూడటానికి.
మీరు కూడా లో చూడండి కాదు కంపైలర్ యొక్క సోర్స్ కోడ్
ఏమి చూడటానికి.
>> మీరు యంత్రం చూడండి అవసరం కోడ్, వాస్తవ బైనరీ
ఈ, వేచి, చూడటానికి సంకలనం కంపైలర్ లైన్స్ ఆఫ్ కోడ్ ఇక్కడ కాదు.
కానీ కెన్ థాంప్సన్ ఒక మెట్టు మరింత బాగా, ఉన్నాయి, చెప్పారు
ఈ ప్రత్యేక కార్యక్రమాలు వాస్తవానికి ప్రోగ్రామ్స్ యొక్క బైనరీ చదవండి సహాయం,
అందువలన ఎవరైనా ఆ ప్రోగ్రాంని ఉంటే బైనరీ చదవండి, వారు ఈ చూస్తాము
లైన్స్ ఆఫ్ కోడ్.
అతను అన్ని, చెప్పడానికి ఆ కార్యక్రమాలు చివరి కుడి, మీరు శోధిస్తున్న ఉంటే
కంపైలర్, ఈ ప్రత్యేక చూపవద్దు బైనరీ సమితి.
>> కాబట్టి మీరు తీసుకోవాలని అవసరమైన ఒక అడుగు మరింత మరియు ప్రధానంగా, కలిగి
డొంకతిరుగుడు తీసిన బహుళ స్థాయిలు, మరియు కొన్ని పాయింట్ వద్ద, ఎవరూ నిజానికి
తనిఖీ కావడం.
కాబట్టి కథ యొక్క నైతిక మీరు, ఉంది రాయడం కావడం లేదు
ఈ తరగతి లో గణగణమని ద్వని చేయు.
మీరు పైకి ఉపయోగించి కావడం ఈ తరగతి లో చాలా గణగణమని ద్వని చేయు.
మీకు తెలిసిన అన్ని, గణగణమని ద్వని చేయు ఒక హానికరమైనది ప్రతి sabotaging అని కార్యక్రమం
కార్యక్రమం మీరు సంకలనం చేసిన.
మరియు చాలా అరిష్ట మీరు వదిలి బుధవారం మీరు చూస్తారు, గమనించండి.
>> [అప్లాజ్]
>> SPEAKER 2: తదుపరి CS50 వద్ద.
>> SPEAKER 3: మీరు అని ధైర్యం లేదు.
మీరు చేయవచ్చు.
మీరు ముందు దీనిని పూర్తి చేసిన, మీరు చేయవచ్చు నేడు, రేపు చేయవచ్చు.
మీరు సంవత్సరాలు ఈ చేస్తోంది.
కేవలం అక్కడికి వెళ్లి.
మీరు చేయవచ్చు.
>> [MUSIC ప్లే]