>> [సంగీతాన్ని]
>> డేవిడ్ J. మలన్: అన్ని కుడి.
ఈ CS50 మరియు ఈ 2 వ వారం ప్రారంభంలో ఉంది.
మరియు మీరు ఆ పై గుర్తుకు వస్తుంది వారాల గత జంట,
మేము కంప్యూటర్ పరిచయం చేసిన సైన్స్ మరియు, క్రమంగా, ప్రోగ్రామింగ్.
>> మరియు మేము ద్వారా కథ ఎలాగా మొదలయింది స్క్రాచ్, ఆ గ్రాఫికల్ భాష
MIT యొక్క మీడియా ల్యాబ్ నుంచి.
ఆపై ఇటీవల గత వారం, మేము
ఒక higher-- ఒక పరిచయం తక్కువ స్థాయి భాష తెలిసిన
సి, పూర్తిగా పాఠ్య ఏదో వంటి.
మరియు, నిజానికి, చివరిసారి మేము ఆ సందర్భంలోనే అన్వేషించారు
అనేక భావాలు.
>> ఈ రీకాల్, చాలా ఉంది మొదటి కార్యక్రమం మేము చూసాము.
ఈ కార్యక్రమం చాలా సరళంగా, బయటకు ముద్రిస్తుంది "హలో, ప్రపంచం."
కానీ చాలా ఉంది కనిపించేవాటిని మేజిక్ జరగబోతోంది.
ఈ # ఉన్నాయి ఉంది ఈ బ్రాకెట్లు తో.
పూర్ణాంకానికి ఉంది.
ఉంది (తప్ప).
బ్రాకెట్లు గిరజాల జంట కలుపులు ఉంది, సెమీ కోలన్, మరియు మరింత.
>> కాబట్టి, ఆ గుర్తు మేము స్క్రాచ్ పరిచయం
కాబట్టి మనం ఆదర్శంగా గత చూడండి వాక్యనిర్మాణం, నిజంగా కాదు ఆ విషయాన్ని
అన్ని మేధస్సును ఆసక్తికరమైన కానీ ప్రారంభ
ఖచ్చితంగా, ఒక బిట్ గమ్మత్తైన మీ మనస్సు చుట్టూ.
మరియు, నిజానికి, అత్యంత సాధారణమైన ప్రారంభంలో ఒక ప్రోగ్రామింగ్ తరగతి లో విషయాలు
ముఖ్యంగా ఆ తక్కువ కోసం సౌకర్యవంతమైన, వేదన చేసుకోవాలని ఉంది
మరియు కొన్ని వాక్యనిర్మాణ ద్వారా జారారు లోపాలు, తార్కిక లోపాలు చెప్పలేదు.
కాబట్టి మా లక్ష్యాలలో ఒకటిగా నేడు, నిజానికి, రెడీ
కొన్ని మీకు యంత్రాంగ ఉండాలి ఎలా సమస్యా పూరణం పద్ధతులు
మంచి సమస్యలు వారే పరిష్కరించడానికి డీబగ్గింగ్ రూపంలో.
మరియు మీరు చాలా, గుర్తుకు వస్తుంది అని, మన పరిచయం వాతావరణంలో
చివరిసారి CS50 IDE అని పిలిచేవారు.
ఈ వెబ్ ఆధారిత సాఫ్ట్వేర్ అని మీరు క్లౌడ్ కార్యక్రమానికి అనుమతిస్తుంది,
అన్ని ఉంచుతూ, మాట్లాడటానికి మీ మేము మళ్ళీ నేడు, కలిసి ఫైళ్లు.
మరియు ఆ మేము గుర్తు ఇక్కడ ఈ విషయాలు గుర్తుచేసుకున్నాడు,
వాటిలో విధులు, మరియు ఉచ్చులు, మరియు వేరియబుల్స్ మరియు బూలియన్ వ్యక్తీకరణలు,
మరియు పరిస్థితులు.
మరియు మేము నిజానికి మరికొన్ని స్క్రాచ్ ప్రపంచం అనువాదం
సి ప్రపంచానికి
>> కానీ ప్రాథమిక భవనం బ్లాక్స్, మాట్లాడటానికి,
నిజంగా ఇప్పటికీ అదే చివరి వారం ఉన్నాయి.
నిజానికి, మేము నిజంగా కేవలం ఒక కలిగి వివిధ పజిల్ ముక్క, మీరు రెడీ ఉంటే.
బదులుగా ఆ ఊదా బ్లాక్ సేవ్ మేము బదులుగా
ఇది printf చేసింది సి లో ఈ ఫంక్షన్
మీరు ఏదో ప్రింట్ అనుమతిస్తుంది మరియు తెరపై దానిని ఫార్మాట్.
మేము CS50 పరిచయం లైబ్రరీ, ఇక్కడ మీరు
మీ పారవేయడం get_char ఇప్పుడు కలిగి, మరియు get_int, మరియు get_string,
మరియు కొన్ని ఇతర విధులు బాగా, ఇది ద్వారా మీరు ఇన్పుట్ పొందవచ్చు
యూజర్ యొక్క సొంత కీబోర్డ్ నుండి.
మరియు మేము కూడా విషయాలను పరిశీలించి పట్టింది these- bool, మరియు చార్ వంటి
మరియు డబుల్, ఫ్లోట్, Int, long_long స్ట్రింగ్.
C. మరియు ఇతర డేటా రకాలు వార్తలు
>> ఇతర మాటలలో, మీరు ప్రకటిస్తాయి కొన్ని విలువ నిల్వ వేరియబుల్,
లేదా మీరు ఒక ఫంక్షన్ అమలు చేసినప్పుడు కొన్ని విలువ తిరిగి
మీరు ఏమి పేర్కొనవచ్చు అని విలువ రకం.
ఒక వంటి, ఒక స్ట్రింగ్ ఉంది అక్షరాలు క్రమం?
పూర్ణాంకం వంటి, అది ఒక సంఖ్య ఉంది?
అది ఒక ఫ్లోటింగ్ పాయింట్ ఉంది విలువ, లేదా వంటి?
కాబట్టి సి లో, స్క్రాచ్ కాకుండా, మేము నిజానికి ఏ రకమైన డేటా తెలుపుటకు ప్రారంభమైంది
మనం తిరిగి లేదా ఉపయోగించి చేయబడ్డాయి.
>> కానీ, వాస్తవానికి, మేము కూడా పడింది కంప్యూటింగ్ యొక్క కొన్ని ప్రాథమిక పరిమితులు.
మరియు ముఖ్యంగా, ఈ భాష సి, రీకాల్
మేము వద్ద ఒక లుక్ పట్టింది పూర్ణాంక ఓవర్ఫ్లో, రియాలిటీ
మీరు మాత్రమే ఒక కలిగి ఉంటే మెమరీ పరిమిత మొత్తం
లేదా, ప్రత్యేకంగా, ఒక పరిమిత సంఖ్య బిట్స్, మీరు మాత్రమే చాలా ఎక్కువగా పరిగణించవచ్చు.
కాబట్టి మేము ఇక్కడ ఈ ఉదాహరణ చూశారు దీనిద్వారా ఒక విమానం లో ఒక కౌంటర్,
నిజానికి దీర్ఘకాలం నడుస్తున్న ఉంటే అవుతుంది ఓవర్ఫ్లో మరియు ఒక సాఫ్ట్వేర్ ఫలితంగా
యదార్ధ భౌతిక సంభావ్య లోపం.
>> మేము కూడా ఫ్లోటింగ్ చూశారు పాయింట్ ఖచ్చితంగా చెప్పలేని, రియాలిటీ
ఆ కేవలం పరిమిత సంఖ్యలో బిట్స్, ఇది 32 లేదా 64 కావచ్చు
మీరు మాత్రమే చాలా సంఖ్యలు పేర్కొనవచ్చు ఒక దశాంశ బిందువు తర్వాత తర్వాత మీరు
అస్పష్టమైన పొందడానికి ప్రారంభం.
కాబట్టి ఉదాహరణకు, ఒక వంతు ఇక్కడ ప్రపంచ, మా మానవ ప్రపంచంలో,
మేము కేవలం ఒక అనంతమైన ఉంది తెలుసు దశాంశ బిందువు తర్వాత 3S యొక్క.
కానీ ఒక కంప్యూటర్ తప్పనిసరిగా కాదు సంఖ్యలు అనంతమైన సంఖ్య ప్రాతినిధ్యం
మీరు మాత్రమే అనుమతిస్తాయి ఉంటే కొన్ని సమాచార పరిమిత మొత్తం.
>> సో మాత్రమే మేము మీరు సిద్ధం చేయలేదు పరంగా ఎక్కువ శక్తి తో
యొక్క మీరు మీ వ్యక్తం ఎలా ప్రోగ్రామింగ్ పరంగా ఒక కీబోర్డ్,
మేము కూడా పరిమితం ఏమి మీరు దీన్ని చేయవచ్చు.
నిజానికి, దోషాలు మరియు తప్పులు చెయ్యవచ్చు సమస్యలు కొన్ని రకాల నుండి తలెత్తుతాయి.
నిజానికి, విషయాలు మధ్య నేడు డీబగ్గింగ్ వంటి అంశాలపై ఉంటాయని
మరియు వాస్తవానికి హుడ్ కింద చూస్తున్న గత వారం విషయాలు పరిచయం చూసి
వాస్తవానికి అమలు చేస్తారు మీరు మంచి తద్వారా
అర్థం రెండు సంస్థల సామర్ధ్యాలు మరియు సి వంటి భాష యొక్క పరిమితుల
>> నిజానికి, మేము తిరిగి చర్మము పొరలు చేస్తాము డేటా నిర్మాణం సరళమైన,
వ్యూహం అని ఏదో, ఇది స్క్రాచ్ ఒక కాల్ ఏమవుతుంది "జాబితాలో."
ఇది కొద్దిగా ఆ సందర్భంలో వివిధ.
మరియు తర్వాత మేము కూడా ఒకటి పరిచయం చేస్తాము మొదటి మా డొమైన్ నిర్దిష్ట సమస్యలను
CS50 లో, ప్రపంచంలో గూఢ లిపి శాస్త్రం, స్క్రాంబ్లింగ్ యొక్క కళ
లేదా సమాచారాన్ని ciphering లో మీరు రహస్య సందేశాలను పంపగల
మరియు రహస్య సందేశాలను డీకోడ్ రెండు వ్యక్తులు, A మరియు B ల మధ్య
>> కాబట్టి మార్పుని ముందు కొత్త ప్రపంచానికి,
యొక్క కొన్ని మీకు యంత్రాంగ ప్రయత్నించండి తెలపండి ఇది పద్ధతులను తీసివేయవచ్చు
లేదా కనీసం కొన్ని తగ్గించడానికి నిస్పృహతో
మీరు బహుశా ఎదుర్కొన్నాము ఒంటరిగా గత వారం కంటే.
నిజానికి, ముందుకు మీరు కొన్ని such-- ఉంటాయి సి అసమానత మీ మొదటి సమస్యలు ఉన్నాయి
మీరు నా లాంటి అయితే, మొదటి సారి మీరు ఒక ప్రోగ్రామ్ టైప్ చేయడానికి ప్రయత్నించండి,
మీరు తార్కికంగా ఆలోచించడం కూడా కార్యక్రమం, అందంగా సులభం
మీరు చాలా బాగా ఒక గోడ హిట్, మరియు ఉండవచ్చు కంపైలర్ సహకరించిన ఉండదని.
తయారు లేదా గణగణమని ద్వని చేయు ఉండదని నిజానికి మీ బిడ్డింగ్ చేయడానికి.
>> ఎందుకు అని ఉంటుంది?
సరే, పరిశీలించి వీలు, బహుశా, ఒక సాధారణ ప్రోగ్రామ్.
నేను ముందుకు వెళ్లి ఈ సేవ్ వెళుతున్న ఉద్దేశపూర్వకంగా buggy0.c పిలువబడే ఒక ఫైల్,
నేను దానిని తెలుసు ఎందుకంటే ముందుగానే దోషపూరిత ఉంటుంది.
కానీ నేను గుర్తించడం లేదు ఉండవచ్చు ఉంటే ఈ మొదటి లేదా రెండవ లేదా మూడవ ప్రోగ్రామ్ ఉంది
నేను నిజానికి నాకు తయారు చేస్తున్నాను అని.
నేను ముందుకు వెళ్ళడానికి వెళుతున్న మరియు టైప్, Int ప్రధాన (తప్ప).
నా గిరజాల జంట కలుపులు లోపలి అప్పుడు, ఒక బాగా తెలిసిన ( "హలో, ప్రపంచం
బాక్ స్లాష్, n ") - మరియు ఒక సెమీ కోలన్.
>> నేను ఫైలు సేవ్ చేసిన.
ఇప్పుడు నేను డౌన్ వెళ్ళి వెళుతున్న నా టెర్మినల్ విండో
మరియు రకం తయారు buggy0, ఎందుకంటే, మళ్లీ, నేటి ఫైలు పేరు buggy0.c ఉంది.
నేను, buggy0 చేయడానికి ఎంటర్ టైప్ చేయండి.
>> మరియు, OH, అబ్బా, చివరిసారి నుండి గుర్తు ఏ లోపం సందేశాలు ఒక మంచి విషయం.
అందువలన అవుట్పుట్ ఒక మంచి విషయం.
కానీ ఇక్కడ నేను స్పష్టంగా పొరపాట్లు కొన్ని సంఖ్య.
>> అవుట్పుట్ మొదటి రేఖ కాబట్టి buggy0 చేయడానికి టైప్ తర్వాత, రీకాల్,
గణగణమని ద్వని చేయు యొక్క బొత్తిగా వాచాల అవుట్పుట్ ఉంది.
హుడ్ కింద, CS50 IDE కన్ఫిగర్
యొక్క మొత్తం బంచ్ ఉపయోగించడానికి ఈ కంపైలర్ తో ఎంపికలు
కాబట్టి మీరు లేని వాటి గురించి ఆలోచించాలి.
మరియు అన్ని మొదటి రేఖ వార్తలు గణగణమని ద్వని చేయు తో ప్రారంభమయ్యే అంటే.
>> అయితే ఆ తర్వాత సమస్యలు వారి ప్రదర్శన ప్రారంభం.
లైన్ 3, పాత్ర Buggy0.c 5, ఒక పెద్ద, ఎరుపు లోపం ఉంది.
అది ఏమిటి?
నిస్సందేహంగా లైబ్రరీ ఫంక్షన్ ప్రకటించారు రకం Int (కాన్స్ట్ చార్ * తో printf,
...) [-Werror].
నేను చాలా త్వరగా అర్థం, అది చాలా మర్మమైన పొందుతాడు.
మరియు ఖచ్చితంగా, వద్ద మొదటి చూపులో, మేము కాదు
మీరు అర్థం ఆశించే ఆ సందేశం యొక్క సంపూర్ణంగా.
కాబట్టి పాఠాలు ఒకటి నేటి అన్నారు
గమనించే ప్రయత్నించండి ఉండాలి నమూనాలను, లేదా ఇలాంటి విషయాలు,
లోపాలకు మీరు కలిగి ఉండవచ్చు గతంలో ఎదుర్కొంది.
కాబట్టి యొక్క మాత్రమే కాకుండా బాధించటం తెలియజేయండి తెలిసిన చూడండి ఆ ఆ పదాలు.
పెద్ద, ఎరుపు లోపం స్పష్టంగా ఏదో ప్రతీకగా తప్పు ఉండటం.
>> పరిపూర్ణంగా ప్రకటించారు printf లైబ్రరీ ఫంక్షన్.
కాబట్టి నేను చాలా అర్థం చేయకున్నా ఏమి పరిపూర్ణంగా ప్రకటించారు లైబ్రరీ ఫంక్షన్
అంటే, తప్పనిసరిగా సమస్యను ఏదో printf సంబంధించినది.
మరియు ఆ సమస్య యొక్క మూలాన్ని ప్రకటించుకున్నారు సంబంధం కలిగి.
>> ప్రకటించుకున్నారు ఒక ఫంక్షన్ ఉంది మొదటి సారి అది ప్రస్తుతించారు.
మరియు మేము గత వారం పదజాలాన్ని ఉపయోగించారు ఒక ఫంక్షన్ యొక్క నమూనా ప్రకటించే,
గాని ఎగువన ఒక లైన్ తో మీ స్వంత ఫైల్ లేదా ఒక అని పిలవబడే శీర్షిక ఫైలులో.
ఏ లో ఫైలు మేము చెప్పటానికి లేదు గత వారం printf కోట్ అని,
unquote, ప్రకటించింది?
ఏమి ఫైలు దాని నమూనా ఉంది?
>> కాబట్టి మీరు గుర్తు, మొట్టమొదటి విషయం నేను టైప్ చేసిన దాదాపు ప్రతి కార్యక్రమం చివరిసారి
మరియు అనుకోకుండా ఒక క్షణం క్రితం ప్రారంభమైంది myself-- టైప్ ఈ ఒక ఇక్కడ ఉంది
హాష్ # ఉన్నాయి <కోసం stio-- ఇన్పుట్ / output-- డాట్ h నిజానికి,
నేను ఇప్పుడు ఈ ఫైలు సేవ్ ఉంటే, నేను వెళుతున్న ముందుకు వెళ్లి నా స్క్రీన్ క్లియర్,
మీరు టైప్ ద్వారా చేయవచ్చు ఇది ప్రశాంతంగా, లేదా మీరు కంట్రోల్ L జరపవచ్చని,
మీ టెర్మినల్ విండో క్లియర్ కొన్ని అయోమయ తొలగించడానికి.
>> నేను ముందుకు వెళ్ళడానికి వెళుతున్న మరియు రీ-రకం తయారు buggy0 నమోదు చేయండి.
మరియు voila, నేను ఇప్పటికీ ఆ చూడండి గణగణమని ద్వని చేయు నుండి దీర్ఘ ఆదేశం,
కానీ ఏ దోష సందేశం ఈ సమయం లేదు.
నిజానికి, నేను ./buggy0 లేకపోతే, కేవలం చివరిసారి వంటి,
పేరు డాట్ దీనర్థం డైరెక్టరీ స్లాష్ కేవలం, అనగా
ఇక్కడ కార్యక్రమం పేరు వచ్చి కార్యక్రమం ఆ పేరు buggy0 ఉంది,
ఎంటర్, "హలో, ప్రపంచం."
>> ఇప్పుడు, ఎలా మీరు కలిగి ఉండవచ్చు ఈ పరిష్కారం తీసుకోబడ్డాయి
లేకుండా తప్పనిసరిగా అనేక పదాలు గుర్తించడం
నేను చేసిన విధంగా, ఖచ్చితంగా, కలిగి చాలా సంవత్సరాలు ఈ పని?
బాగా, మొదటి సమస్య శాతం తెలుసుకుంటారు సెట్, మేము మీరు పరిచయం ఒక ఆదేశానికి
CS50 యొక్క సొంత సిబ్బంది ఆ help50 అని రాశారు.
నిజానికి, సి కోసం వివరణ చేస్తుంది సమస్యను ఎలా ఈ ఉపయోగించడానికి సెట్ చేయబడింది.
>> కానీ help50 తప్పనిసరిగా ఉంది ఒక కార్యక్రమం ఆ CS50 యొక్క సిబ్బంది
మీరు అమలు అనుమతించే రాశారు ఒక ఆదేశం లేదా, ఒక ప్రోగ్రామ్ అమలు
మరియు మీరు అర్థం లేదు ఉంటే దాని అవుట్పుట్, help50 దాని అవుట్పుట్ పాస్,
ఇది ఒక సాఫ్టువేరు చూపుతూ కోర్సు యొక్క సిబ్బంది రాశాడు
మీ ప్రోగ్రామ్ యొక్క అవుట్పుట్ వద్ద కనిపిస్తాయని లైన్ ద్వారా లైన్, పాత్ర పాత్ర.
మరియు మేము, సిబ్బంది గుర్తించి మీరు అనుభవిస్తున్న ఆ లోపం సందేశం,
మేము కొన్ని మీకు రేకెత్తించి ప్రయత్నించండి అలంకారిక ప్రశ్నలు, కొన్ని సలహా తో,
TF లేదా సిఏ లేదా నాకు చాలా ఇష్టం కార్యాలయం గంటల వద్ద వ్యక్తి చేయరు.
>> మీరు లేకపోతే సో help50 చూడాల్సి తప్పనిసరిగా ఒక సమస్య గుర్తించి.
కానీ అది ఆధారపడి లేదు ఒక ఊతకర్ర వలె చాలా.
ఖచ్చితంగా అర్థం ప్రయత్నించండి దాని అవుట్పుట్ మరియు అప్పుడు అది నేర్చుకుని
కాబట్టి ఒకసారి లేదా రెండుసార్లు మాత్రమే మీరు చేసే ఎప్పుడైనా ఒక దోష కోసం help50 అమలు
సందేశం.
ఆ తరువాత, మీరు ఉండాలి మీరే అమర్చారు
దొరుకుతుందని నిజానికి ఏమిటి.
>> యొక్క ఇక్కడ ఇతర ఏమి చూద్దాం.
నాకు ముందుకు వెళ్లి, మరో లెట్ ఫైలు మేము ఈ buggy1.c పిలుస్తాను.
మరియు ఈ ఫైలులో నేను deliberately-- అన్నారు
కానీ నేను లేదు నటిస్తారు నేను చేసిన ఏమి తప్పు అర్థం.
>> నేను ముందుకు వెళ్లి దీన్ని చేయ బోతున్నాను # ఉన్నాయి, నేను చేసిన నుండి
ఒక క్షణం క్రితం నుండి నా పాఠం నేర్చుకున్నాడు.
Int ప్రధాన (తప్ప), ముందు.
ఆపై ఇక్కడ నేను వెళ్తున్నాను స్ట్రింగ్ s చేయడానికి - get_string.
మరియు చివరిసారి నుండి గుర్తు ఈ మార్గాల, హే, కంప్యూటర్,
నాకు ఒక వేరియబుల్ ఇవ్వండి దీనిని లు కాల్, మరియు ఆ వేరియబుల్ ఒక స్ట్రింగ్ యొక్క రకం
కాబట్టి నేను ఒకటి లేదా ఎక్కువ పదాలు నిల్వ చేయవచ్చు.
>> ఆపై కుడి వైపు సమాన సైన్ వైపు
ఒక ఇది, get_string ఉంది CS50 లైబ్రరీ ఫంక్షన్
సరిగ్గా ఆ చేస్తుంది.
అది ఒక ఫంక్షన్ మరియు గెట్స్ కుడి నుండి చేతులు ఇది.
కాబట్టి ఈ సమాన సైన్ కాదు మేము గణిత అనుకుంటున్నాను ఉండవచ్చు వంటి "సమానం".
ఇది కుడి నుండి అప్పగించిన అర్థం.
కాబట్టి ఈ అర్థం, నుండి స్ట్రింగ్ పడుతుంది వినియోగదారు మరియు లు లోపలి నిల్వ.
>> ఇప్పుడు అది ఉపయోగించడానికి అనుమతిస్తున్నట్లు.
నాకు రెండవ ఇప్పుడు మరియు ముందుకు వెళ్ళి తెలపండి పంక్తి, నాకు ముందుకు వెళ్లి "హలో" అని పిలవబడు -
కాదు "ప్రపంచ", కానీ "హలో,% s-- ఇది మన హోల్డర్, కామా s,
ఇది మా వేరియబుల్, ఆపై ఒక సెమీ కోలన్.
కాబట్టి నేను చాలా అప్ మేకు లేదు ఉంటే ఇక్కడ, ఈ సరైన కోడ్ కనిపిస్తోంది.
>> నా ప్రవృత్తులు ఇప్పుడు అది కంపైల్ ఉన్నాయి.
ఫైలు buggy1.c అని ఉంది.
నేను buggy1 తయారు ఎంటర్ చేయ బోతున్నాను.
మరియు రంధ్రాన్ని సరి చేయు ఇది, అక్కడ లేకపోతే ముందు కంటే మరింత లోపాలు.
నా ఉద్దేశ్యం ఎక్కువ ఉంది దోష సందేశాలు వచ్చే కాలం
ఈ కార్యక్రమం లో వాస్తవ మార్గాల కన్నా కనిపిస్తుంది.
>> కానీ తాత్కాలిక ఇక్కడ ఉంది మీరు నిమగ్నం ఉన్నాము అయినా
రెండు లేదా మూడు లేదా తో నాలుగు కంటే దోష సందేశాలు,
చాలా ఎల్లప్పుడూ దృష్టి మొదటి ఆ సందేశాలను.
టాప్ అత్యంత ఒకటి చూడటం, తిరిగి అవసరం అప్ స్క్రోలింగ్ ఉంటుంది.
ఇక్కడ నేను తయారు buggy1 టైప్.
ఇక్కడ అనుకున్న గణగణమని ద్వని చేయు అవుట్పుట్ ఉంది.
>> మరియు ఇక్కడ మొదటి ఎరుపు లోపం.
అస్పష్టమైన గుర్తింపు స్ట్రింగ్, నేను ప్రామాణిక ఉద్దేశమేమిటి?
కాబట్టి ప్రామాణిక ఉంది నిజానికి ఏదో.
ఇది వినియోగదారు యొక్క సూచిస్తుంది కీబోర్డ్, ముఖ్యంగా.
>> కానీ నేను అర్థం కాదు.
నేను స్ట్రింగ్ అర్ధం, మరియు నేను get_string అర్థం.
కనుక ఇది ఏమిటి నేను ఈ సమయంలో మర్చిపోయారు?
ఈ సమయంలో వెలితి?
నా # ఉన్నాయి కలిగి, కాబట్టి నేను printf ప్రాప్తి.
>> కానీ నేను ఏమి లేదు ఇంకా యాక్సెస్?
అయితే, నువ్వు చివరిసారి వంటి, నేను కంపైలర్ చెప్పడానికి అవసరం
ఏమి ఈ క్రియలు గణగణమని ద్వని చేయు.
Get_string రాదు C. తో మరియు ముఖ్యంగా, ఇది
లో రాదు , ఫైలు శీర్షిక.
ఇది బదులుగా వస్తుంది ఏదో సిబ్బంది రాశాడు,
ఇది వేరే ఫైల్ పేరు కానీ సముచితంగా పేరు.
>> కాబట్టి కేవలం ఒక లైన్ జోడించడం ద్వారా ఆ చివరిసారి నుండి ఉంటుంది కోడ్ రీకాల్
గణగణమని ద్వని చేయు నడుస్తుంది ఉన్నప్పుడు, అది జరగబోతోంది దిగువ నా కోడ్ ఎగువన చూడండి,
ఎడమ.
ఇది గమనించవచ్చు జరగబోతోంది ఓహ్, మీకు కావలసిన.
నాకు వెళ్ళి ఆ కనుగొనేందుకు లెట్, ఇది సర్వర్లో ఎక్కడ,
తప్పనిసరిగా కాపీ మరియు పేస్ట్, మీ స్వంత ఫైల్ యొక్క పైభాగములో
కాబట్టి కథ ఈ సమయంలో, పంక్తి 1, ప్రోగ్రామ్ యొక్క మిగిలిన
చేయవచ్చు, నిజానికి, ఫంక్షన్స్ ఏ ఉపయోగించడానికి అందులో, వాటిలో get_string.
నేను విస్మరించండి వెళుతున్న ఆ లోపాలు మిగిలిన
నేను, నిజానికి, మాత్రమే అనుమానిస్తున్నారు మొదటి ఒకటి ఏమిటంటే ముఖ్యమని.
మరియు నేను ముందుకు మరియు గణగణమని వెళ్ళి వెళుతున్న నా ఫైలు సేవ్ తర్వాత buggy1 తయారు.
మరియు voila, అది పని చేసింది.
నేను ./buggy1 చేయండి మరియు ఉంటే, టైపు ఉదాహరణకు, Zamyla, నేను ఇప్పుడు హలో, పొందుతారు
Zamyla, హలో బదులుగా, ప్రపంచం.
>> అయితే సరే.
కాబట్టి ఇక్కడ అవేలు అప్పుడు ఉన్నాయి, ఒకటి, ఎక్కువ మీరు చెయ్యగలరు గా కొద్ది కొద్దిగా ప్రయత్నించండి
ఒంటరిగా లోపం సందేశాలను నుండి చూస్తున్న గుర్తించదగిన పదాలు కొన్ని.
ఆ నిషేధిత ప్రకారం help50 ఉపయోగించడానికి సమస్య సెట్.
కానీ ఆ నిషేధిత, చాలా, ఎల్లప్పుడూ చూడండి టాప్ లోపం మాత్రమే, కనీసం
ప్రారంభంలో, చూడటానికి ఏ సమాచారం నిజానికి ఇచ్చు ఉండవచ్చు.
కానీ అది ఉంది అది మారుతుంది మరింత కార్యాచరణను నిర్మించారు
CS50 లైబ్రరీ లోకి సహాయం సెమిస్టర్ ప్రారంభంలో మీరు
ప్రారంభ ప్రోగ్రామింగ్ విషయమేనా తప్పు జరగబోతోంది.
కాబట్టి యొక్క ఇక్కడ మరొక ఉదాహరణ తెలియజేసేలా.
నేను, ఈ buggy2 కాల్ వెళుతున్న, మళ్ళీ, బయటకు పొరపాట్లు కావడం
గేట్, డిజైన్ ద్వారా.
>> మరియు నేను ముందుకు వెళ్ళడానికి వెళుతున్న మరియు # ఉన్నాయి చేయండి.
ఆపై నేను Int ప్రధాన (తప్ప) చేయ బోతున్నాను.
ఆపై నేను లూప్ ఒక చేయ బోతున్నాను.
కోసం (Int i _ 0.
నేను కంటే తక్కువ లేదా 10 సమానం.
నేను ++, మరియు అప్పుడు గిరజాల జంట కలుపులు, నేను వెళుతున్న ఇక్కడ కేవలం ఒక హాష్ ట్యాగ్ చిహ్నం ముద్రించాలా
మరియు ఒక కొత్త లైన్ పాత్ర.
>> ఈ నా ఉద్దేశం కాబట్టి కార్యక్రమం చాలా సాధారణంగా
10 సార్లు iterate ఎలా మరియు ప్రతి మళ్ళా న
ఆ లూప్ ప్రతి సమయం చక్రం ద్వారా,
ఒక హాష్ ట్యాగ్ ప్రింట్, ఒక హాష్ ట్యాగ్ ఒక హాష్ ట్యాగ్.
నేను ఎందుకంటే ఒక పంక్తికి అక్కడ కొత్త లైన్ ఉంది.
మరియు ఆ కోసం గుర్తుకు లూప్ గత వారం శాతం,
మరియు మీరు మరింత పొందుతారు వాక్యనిర్మాణం తెలిసిన
ఆచరణలో అది ఉపయోగించి లాంగ్ ముందు ఈ నాకు ఇస్తుంది
ఒక వేరియబుల్ నేను అని మరియు అది 0 అమర్చుతుంది.
>> ఈ i న ఇంక్రిమెంట్ 1 ప్రతి మళ్ళా.
నేను 3 1 వెళ్తాడు 2.
ఆపై ఈ స్థితిలో సెమీ కోలన్ మధ్య మధ్యలో
చేయడానికి ప్రతి మళ్ళా న తనిఖీ తీర్చుకుంటాడు మేము పరిధిలో పరిధిలో ఉన్నాయి నిర్ధారించుకోండి.
కాబట్టి నేను 10 సార్లు iterate మీరు, నేను చాలా విధమైన అకారణంగా కేవలం
నా ఎగువ బంధం 10 ఉంచండి.
>> మరియు ఇంకా, నేను ఈ అమలు తర్వాత, తయారు ఇది కంపైల్ buggy2--
మరియు అది సరే కంపైల్ లేదు.
నేను ఒక లేదు వాక్యనిర్మాణ దోషం ఈ సమయంలో.
నాకు ఇప్పుడు ముందుకు వెళ్ళి తెలపండి మరియు buggy2 అమలు నమోదు.
ఇప్పుడు వరకు స్క్రోల్.
మరియు నాకు పెంచడానికి వీలు విండో యొక్క పరిమాణం.
>> నేను కలిగి అనిపించడం 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11.
కాబట్టి 11 హ్యాష్ట్యాగ్ల ఉంది అయినప్పటికీ, నేను స్పష్టంగా ఈ లూప్ యొక్క లోపల 10 ఉంచండి.
ఇప్పుడు, మీరు కొన్ని వెంటనే చూడవచ్చు ఏ లోపం ఎందుకంటే, నిజానికి, ఈ
చేయడానికి ఒక చాలా హార్డ్ లోపం కాదు.
కానీ ఇది చాలా సాధారణంగా ఉంది చాలా ప్రారంభ చేసింది.
>> నేను అభిప్రాయపడుతున్నారు మీరు, అయితే, ఉంది, నేను ఎలా దొరుకుతుందని ఉండవచ్చు?
సరే, ఆ అవుతుంది CS50 లైబ్రరీ వస్తుంది
మాత్రమే get_string మరియు get_int తో మరియు get_float మరియు ఇతర విధులు.
ఇది కూడా ఒక ప్రత్యేక ఫంక్షన్ తో వస్తుంది eprintf అని, లేదా, లోపం printf.
మరియు అది సంపాదించడానికి మాత్రమే ఉంది మీరు కోసం కొద్దిగా సులభంగా
కేవలం మీ కోడ్ డీబగ్గింగ్ చేసేటప్పుడు తెరపై ఒక దోష సందేశం ప్రింట్
ఎక్కడ నుండి వచ్చి తెలుసు.
>> కాబట్టి ఉదాహరణకు, ఒక విషయం నేను వాటిని ఇక్కడ ఏమి ఈ ఫంక్షన్ దీన్ని ఉంది
eprintf, మరియు అప్పుడు నేను ముందుకు వెళ్ళడానికి వెళుతున్న మరియు నేను ఇప్పుడు% నేను, బాక్ స్లాష్ n, అని చెబుతారు.
నేను నేను విలువ లో ప్లగ్ వెళుతున్న.
మరియు టాప్, ఈ ఎందుకంటే , CS50 లైబ్రరీలో
నేను ముందుకు వెళ్ళడానికి వెళుతున్న మరియు ఉన్నాయి
కాబట్టి నేను ఈ ఫంక్షన్ యాక్సెస్.
కానీ యొక్క పరిశీలిద్దాం ఏ లైన్ 9 చేస్తూ కోరుకుంటున్నాము.
నేను చివరికి ఈ తొలగించండి వెళుతున్న.
ఈ ఏమీ ఉంది నా ప్రబలమైన లక్ష్యంతో.
కానీ eprintf, లోపం printf, కేవలం అర్థం నాకు కొన్ని విశ్లేషణ సమాచారం ఇవ్వాలని.
నా ప్రోగ్రామ్ రన్, నాకిష్టమే తాత్కాలికంగా తెరపై ఈ చూడండి
అలాగే, కేవలం అర్థం ఏం జరుగుతోంది.
>> మరియు, నిజానికి, ప్రతి న ఇక్కడ లైన్ 9 మళ్ళా
నేను చూడాలనుకుంటే, నేను విలువ ఏమిటి?
నేను విలువ ఏమిటి?
మరియు, ఆశాజనక, నేను మాత్రమే ఉండాలి ఆ సందేశం, కూడా, 10 సార్లు చూడండి.
>> నాలో ముందుకు వెళ్లి నా ప్రోగ్రామ్ మళ్ళీ కంపైల్ చెయ్యండి
నేను ఏ సమయంలో ఏమి కలిగి నేను ఒక మార్పు. ./buggy2.
మరియు ఇప్పుడు సరి.
అక్కడ ఎక్కువ జరగబోతోంది చాలా ఉంది.
నాలో స్క్రోల్ వీలు ఇంకా పెద్ద విండో.
>> మీలో ప్రతి చూస్తారు హ్యాష్ట్యాగ్ల ఇప్పటికీ ప్రింటింగ్ ఉంది.
కానీ మధ్య వాటిని ప్రతి ఇప్పుడు ఈ ఈ క్రింది విధంగా విశ్లేషణ అవుట్పుట్ ఫార్మాట్.
ఇక్కడ నా ప్రోగ్రామ్ యొక్క పేరు buggy2 ఉంది.
ఫైలు పేరు buggy2.c ఉంది.
లైన్ నెంబర్ ఇది నుండి ఈ ముద్రించారు లైన్ 9.
మరియు ఆ కుడి ఉంది నేను ఆశించే వెబ్ ఆ దోష సందేశం.
>> మరియు nice గురించి ఆ ఇది ఏమిటి ఇప్పుడు నేను తప్పనిసరిగా లెక్కించాలి లేదు
నా తల లో నా ప్రోగ్రామ్ ఏమి చేస్తోంది.
నేను చూడగలరు నేను 0 మొదటి మళ్ళా,
తరువాత 1, 2, 3, 4, అప్పుడు 5 అయితే అప్పుడు 6, 7, 8, అప్పుడు 9, అప్పుడు
10.
కాబట్టి ఒక నిమిషం ఆగండి.
ఏమి జరుగుతుంది ఇక్కడ?
నేను ఇప్పటికీ లెక్కింపు అనిపించడం 10 వరకు ఉద్దేశించబడింది.
>> కానీ నేను ఎక్కడ ఎప్పటి?
0, 1, 2, 3, 4, 5, 6, 7, 8, 9 10.
కాబట్టి 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10-- 11 వేలు
సమస్య సూచన ఉంది.
నేను లెక్కిస్తారు కనిపిస్తుంది తప్పుగా నా లూప్ లో.
వెళ్ళి 10 నిద్రావస్థ కాకుండా, నేను 0 వద్ద ప్రారంభమై వెబ్
నేను మరియు 10 ద్వారా ముగించాడు చేస్తున్నాను.
కానీ ఎందుకంటే, ఒక కంప్యూటర్ వంటి, నేను 0 వద్ద లెక్కింపు మొదలు వెబ్,
నేను లెక్కింపు చేయాలి , కానీ 10 వ.
>> కాబట్టి పరిష్కారము, నేను చివరికి ఇక్కడ గ్రహించారు, రెండు విషయాలు ఒకటి.
నేను చాలా కేవలం చెప్పగల్గినవి కంటే తక్కువ 10 వరకు కౌంట్.
కాబట్టి 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, సరైన, నిజానికి,
కూడా కొద్దిగా తప్పు ధ్వనులు అయితే.
లేదా నేను చేయగల కంటే లేదా సమానం 9 వరకు చాలా కాలం నేను 0 వద్ద మొదలు.
లేదా మీరు నిజంగా అది ఇష్టం లేకపోతే, మీరు 10 ద్వారా కూడుట కానీ 1 ప్రారంభించవచ్చు.
కానీ మళ్ళీ, ఈ కేవలం ఉండటం సాధారణంగా కనిపిస్తుంది.
programming-- అయినప్పటికీ లో లో Scratch-- చాలా కాదు
కానీ ప్రోగ్రామింగ్ లో సి మరియు ఇతర భాషలు,
JavaScript మరియు వంటి పైథాన్ మరియు ఇతరులు, అంతే
కేవలం చాలా సాధారణ బైనరీ మా చర్చ
కేవలం వద్ద లెక్కింపు ప్రారంభం 0, ఇది మీరు, అతి తక్కువ.
అయితే సరే.
కాబట్టి ఆ eprintf వార్తలు.
మరియు తిరిగి, ఇప్పుడు నేను కనుగొన్నారు చేసిన నా సమస్య, మరియు నేను 0 తిరిగి వెళ్ళడానికి వెళుతున్న
10 కంటే తక్కువ ద్వారా, నేను వెళుతున్న వెళ్ళి eprintf తొలగించడానికి.
>> ఇది నేను అక్కడ ఉండకూడదు నా కోడ్ రవాణా లేదా నా కోడ్ submit
లేదంటే ఎవరైనా దానిని చూపించడానికి.
ఇది నిజంగా కేవలం ఉద్దేశించబడినదిగా తాత్కాలికంగా ఉపయోగిస్తారు.
కానీ ఇప్పుడు నేను ఈ పరిష్కరించబడింది చేసిన అలాగే ప్రత్యేక సమస్య.
>> సరే, ఇక్కడ ఒకటి కంటే ఉదాహరణ తెలియజేసేలా నేను ఈ క్రింది విధంగా అప్ రెచ్చిపోయినప్పుడు వెళుతున్న.
నేను ముందుకు వెళ్ళడానికి వెళుతున్న మరియు # ఉన్నాయి. $ 50
మరియు నేను ముందుకు వెళ్ళడానికి వెళుతున్న మరియు # ఉన్నాయి.
>> నేను సేవ్ వెళుతున్న ఈ ఫైలు buggy3.c వంటి.
మరియు నేను ముందుకు వెళ్ళడానికి వెళుతున్న డిక్లేర్ Int ప్రధాన (తప్ప).
ఆపై అక్కడ లోపల నేను Int ఐ చేయ బోతున్నాను _ -
నేను ఒక కార్యక్రమం అమలు చేయదలిచిన ఒక get_negative_int తో.
ఈ ఇంకా ఉనికిలో ఉన్న ఒక క్రియ కాదు.
కాబట్టి మేము అమలు చేయబోతున్నామని అది కేవలం ఒక క్షణం లో.
కానీ మేము ఎందుకు చూడాలని ఇది మొదటి పాస్ వద్ద బగ్గీ వార్తలు.
మరియు నేను సంపాదించిన చేసిన తర్వాత వినియోగదారు నుండి ఒక Int,
నేను% నేను ప్రింట్ వెళుతున్న ప్రతికూల పూర్ణాంక, బాక్ స్లాష్ n, కామా i.
ఇతర మాటలలో, నేను ఏమి ఈ కార్యక్రమం మీరు
నుండి ప్రతికూల పూర్ణాంకానికి పొందండి యూజర్ ఆపై ప్రింట్
అలాంటి మరియు ఒక ప్రతికూల పూర్ణాంకానికి ఉంది.
>> ఇప్పుడు నేను ఈ ఫంక్షన్ అమలు చేయాలి.
సో తరువాత నా ఫైలు లో, నేను వెళ్ళడానికి వెళుతున్న ముందుకు మరియు అని ఒక ఫంక్షన్ ప్రకటించాలని
get_negative_int (తప్ప) - మరియు మేము చేస్తాము ఆ లైన్ మళ్ళీ అర్థం ఏమి తిరిగి వచ్చి
ఒక క్షణం పూర్ణాంకానికి n లో; అలా పనుల కింది printf n ఉంది :.
, Get_int - ఆపై నేను n చేయ బోతున్నాను మరియు ఈ సమయంలో N 0 కన్నా ఎక్కువ ఉంది.
ఆపై n తిరిగి ;.
>> కాబట్టి జరగబోతోంది చాలా ఉంది మేము అది ఈ కానీ ఏదీ
కనీసం కొంతకాలం, గత వారం చూడండి.
కాబట్టి ఇక్కడ లైన్ 10 న నేను డిక్లేర్డ్ చేసిన get_negative_int అని ఫంక్షన్,
మరియు నేను ఉంచాము (తప్ప), బ్రాకెట్లు కారణం ఈ ఉండటం
ఒక ఇన్పుట్ తీసుకోదు.
నేను ఏదైనా అక్కడ లేదు ఈ ఫంక్షన్ కు.
నేను అది తిరిగి ఏదో పొందుతున్నాను.
>> మరియు నేను ఆశతో చేస్తున్నాను తిరిగి పొందడానికి ఒక పూర్ణ సంఖ్య.
ఏ డేటా రకం ఉంది సి negative_int అని.
ఇది కేవలం Int, కాబట్టి అది జరగబోతోంది ఖచ్చితంగా చేయడానికి మాకు ఉండాల్సిందే
నిజానికి ఆ విలువ రిటర్న్డ్ మాత్రమే ఒక పూర్ణాంకానికి ఉంది
కానీ కూడా ప్రతికూలంగా ఉంటుంది.
>> లైన్ 12 న, నేను ఒక వేరియబుల్ ప్రకటించారు చేస్తున్నాను n మరియు రకం Int చేరుకొని అని.
ఆపై 18 ద్వారా లైన్ 13 లో నేను రెడీ ఏదో చేస్తూ ఏదో నిజం.
నేను ముందుకు ముద్రణ వెళుతున్న N, కొలన్ మరియు తరువాత ఒక స్పేస్,
వినియోగదారు కోసం ఒక ప్రాంప్ట్ వంటి.
>> నేను అప్పుడు get_int కాల్ చేస్తున్నాను మరియు దాని పిలవబడే తిరిగి విలువ నిల్వ
ఆ వేరియబుల్ n లో.
కానీ నేను చేస్తున్న ఉంచడానికి వెళుతున్న ఈ సమయంలో N 0 కన్నా ఎక్కువ.
ఇతర మాటలలో, యూజర్ నాకు ఒక ఇస్తుంది Int మరియు ఆ సంఖ్యను 0 కంటే ఎక్కువ,
అప్పుడు, సానుకూల, నేను వెళుతున్న కేవలం యూజర్ reprompting ఉంచేందుకు,
వాటిని బలవంతంగా ద్వారా, reprompting ఉంచడానికి సహకరించాలని నాకు ప్రతికూల పూర్ణాంకానికి ఇవ్వండి.
>> మరియు ఒకసారి n నిజానికి negative-- ఉంది వినియోగదారు ఉన్నప్పుడు చివరకు రకాల -50 అనుకుందాం,
అప్పుడు ఈ సమయంలో లూప్ ఇకపై నిజం -50 0 కంటే ఎక్కువ కాదు ఎందుకంటే.
కాబట్టి మేము ఆ బయటకు లూప్ తార్కికంగా మరియు n తిరిగి.
>> కానీ ఇతర ఒక ఉంది విషయం నేను చేయాల్సిందల్లా.
మరియు నేను కేవలం ఈ చేయవచ్చు కాపీ మరియు పేస్ట్ ద్వారా
ఫైలు ఎగువన కోడ్ ఒకటి లైన్.
నేను గణగణమని ద్వని చేయు బోధించడానికి అవసరం, లేదా గణగణమని ద్వని చేయు వాగ్దానం
నడిపేవారిని నేను రెడీ ఆ, నిజానికి, వెళ్ళి అమలు
ఈ ఫంక్షన్ get_negative_int.
ఇది కేవలం ఫైల్ లో తక్కువ కావచ్చు.
మళ్ళీ, ఆ గుర్తు గణగణమని ద్వని చేయు పైనుంచి విషయాలు చదివి,
ఎడమ నుండి కుడికి, కాబట్టి మీరు కాదు గణగణమని ద్వని చేయు ఉంటే ఒక ఫంక్షన్ కాల్
అది ఉనికిలో జరగబోతోంది తెలియదు.
>> ఇప్పుడు, దురదృష్టవశాత్తు, ఈ కార్యక్రమం, మీరు కొన్ని గమనించి ఉండవచ్చు
ఇప్పటికే బగ్గీ ఉంది.
నాకు ముందుకు వెళ్లి buggy3 తయారు చేద్దాము.
నా సమస్య ఇప్పుడు కాదు, కాబట్టి ఇది కూర్చింది వాక్యనిర్మాణ దోషం, ఒక పాఠ్య లోపం,
ఇది నిజానికి ఒక తార్కిక చేస్తాడు నేను ఉద్దేశపూర్వకంగా చేసిన లోపం
అవకాశంగా తయారు ఏం జరగబోతోంది ద్వారా అడుగు.
>> నేను ముందుకు వెళ్ళడానికి వెళుతున్న ఇప్పుడు, Buggy3 అమలు.
నేను వెళ్ళి వెళుతున్న ముందుకు మరియు సహకరించాయి.
నేను సంఖ్య 1 ఇవ్వాలని వెళుతున్న.
ఇది ఇష్టం లేదు కనుక అది నాకు మళ్ళీ ప్రాంప్ట్ యొక్క.
>> ఎలా 2?
3?
50?
ఆ ఒక్కటి పనిచేస్తున్నారు.
ఎలా -50 గురించి?
మరియు కార్యక్రమం పని ఉంది.
>> మరోసారి నాకు ఇది ప్రయత్నించండి లెట్.
నాకు -1 ప్రయత్నించండి లెట్, పని ఉంది.
నాకు -2 ప్రయత్నించండి లెట్, పని ఉంది.
నాకు ప్రయత్నించండి 0 లెట్.
అహ్, ఆ తప్పు.
ఇప్పుడు, మేము ఇక్కడ ఒక చిన్న పాండిత్య ప్రకర్ష ఉండటం చేస్తున్నాం.
కానీ నిజానికి, వార్తలు, కేసు ఆ 0 అనుకూల లేదా ప్రతికూల కాదు.
అందువలన నిజానికి నా కార్యక్రమం , 0 ప్రతికూల పూర్ణాంక అని అంటున్నారు
సాంకేతికంగా సరైన కాదు.
>> ఇప్పుడు, ఎందుకు ఈ చేస్తోంది?
బాగా, అది స్పష్టమైన కావచ్చు.
మరియు, నిజానికి, కార్యక్రమం నిరాడంబర అని అర్థం
కాబట్టి మేము అన్వేషించడానికి ఏదైనా కలిగి.
>> కానీ యొక్క మూడవ డీబగ్గింగ్ పరిచయం తెలియజేయండి టెక్నిక్ ఇక్కడ debug50 అని.
కాబట్టి ఈ ప్రోగ్రామ్ ఉంది మేము కేవలం సృష్టించిన
ఈ అంటారు సంవత్సరం debug50 మీరు అనుమతిస్తుంది
ఒక అంతర్నిర్మిత అని ఏమి ఉపయోగించడానికి CS50 IDE లో గ్రాఫికల్ డీబగ్గర్.
మరియు ఒక డీబగ్గర్ కేవలం ఒక కార్యక్రమం అని సాధారణంగా మీరు మీ కార్యక్రమాన్ని అమలు చేయనిస్తుంది
కానీ దశ, లైన్ బై స్టెప్ బై స్టెప్ లైన్ ద్వారా లైన్ ద్వారా, విరామం చేసే poking
చుట్టూ వేరియబుల్స్ చూడటం కాబట్టి కార్యక్రమం కేవలం మీరు గత చెదరగొట్టి లేదు
మరియు త్వరగా ఏదో ప్రింట్ లేదా ఏదో ప్రింట్ లేదు.
ఇది, మీరు ఒక అవకాశం ఇస్తుంది మానవ వేగం, ఇది సంకర్షణ.
>> మరియు దీన్ని మీరు కేవలం క్రింది వాటిని.
మీ కోడ్ కంపైల్ తరువాత, ఇది నేను ఇప్పటికే చేశాడు, buggy3,
మీరు ముందుకు వెళ్లి debug50 ./buggy అమలు.
ఎంతగా help50 మీరు అమలు ఉన్నట్లు help50 ఆపై ఆదేశం,
debug50 మీరు debug50 అమలు మరియు ఆదేశ పేరు.
>> ఇప్పుడు నా తెరపై ఏమి జరుగుతుందో చూడటానికి, ముఖ్యంగా కుడి చేతి వైపు.
నేను రన్, అన్ని కొట్టాడు ఆకస్మిక ఈ కుడి చేతి ప్యానెల్
తెరపై తెరుచుకోవడంతో.
మరియు వెళుతున్న చాలా ఉంది మొదటి చూపులో న.
కానీ అక్కడ చాలా కాదు ఇంకా గురించి ఆందోళన ఎక్కువ.
>> ఈ నాకు ప్రతిదీ చూపిస్తూ నా ప్రోగ్రామ్ యొక్క లోపల ఏం జరగబోతోంది
ప్రస్తుతం ఈ ద్వారా బటన్లు టాప్ అప్పుడు అప్
నా కోడ్ను ద్వారా దశను అనుమతిస్తుంది చివరికి స్టెప్ బై స్టెప్ బై స్టెప్.
కానీ ఇంకా లేదు.
ఏమి గమనించండి.
నా టెర్మినల్ విండో వద్ద నేను n కోసం ప్రాంప్ట్ అయామ్.
మరియు నేను ముందుకు వెళ్ళడానికి వెళుతున్న మరియు -1 ఈసారి మరియు రకం సహకరించాయి.
మరియు అయితే కొద్దిగా నిగూఢమైన, -1 అనుకున్న, ఒక ప్రతికూల పూర్ణాంక ఉంది.
>> ఆపై పిల్లల తో నిష్క్రమించారు స్థితి 0 gdbserver నిష్క్రమించే.
GDB గ్నూ డీబగ్గర్ పేరు అంతర్లీన సాఫ్ట్వేర్
ఈ డీబగ్గర్ అమలు.
కానీ అన్ని ఈ నిజంగా అర్థం, డీబగ్గర్ నా ప్రోగ్రామ్ విడిచి ఎందుకంటే దూరంగా వెళ్ళాడు
మరియు అన్ని బాగా ఉంది.
నేను నిజంగా నా ప్రోగ్రామ్ డీబగ్ చేయాలనుకుంటే, నేను preemptively debug50 చెప్పడానికి కలిగి,
నేను ఎక్కడ మొదలు అనుకుంటున్నారు నా కోడ్ ద్వారా పునాది?
>> మరియు బహుశా సరళమైన మార్గం ఈ కింది విధంగా ఉంది ఏమి.
నేను హోవర్ ఉంటే ఇక్కడ నా ఎడిటర్ గట్టర్,
కాబట్టి నిజంగా కేవలం సైడ్బార్లో ఇక్కడ, లైన్ నెంబర్ ఎడమ
గమనించవచ్చు నేను క్లిక్ చేస్తే ఆ ఒకసారి నేను కొద్దిగా ఎరుపు బిందువు చాలు.
మరియు ఆ చిన్న ఎరుపు బిందువు, ఒక స్టాప్ సైన్ వంటి, హే,
debug50, నా కోడ్ విరామం అమలు అక్కడే నేను ఈ ప్రోగ్రామ్ రన్.
>> కాబట్టి యొక్క ఆ తెలియజేసేలా.
నాకు ముందుకు వెళ్లి నా ప్రోగ్రామ్ రన్ మళ్ళీ debug50 ./buggy3 తో నమోదు చేయండి.
మరియు ఇప్పుడు, నోటీసు, ఏదో వివిధ జరిగింది.
నేను అడుగకుండా కాదు ఇంకా నా టెర్మినల్ విండో లో
ఏదైనా, నేను ఎందుకంటే నా కార్యక్రమంలో ఇంకా అక్కడ సంపాదించిన.
పంక్తి 8 న గమనించవచ్చు ఇప్పుడు హైలైట్ ఇది
మరియు ఒక చిన్న బాణం ఉంది ఎడమ నానుడి, మీరు ఇక్కడ పాజ్ ఉంటాయి.
కోడ్, లైన్ యొక్క ఈ లైన్ 8, ఇంకా అమలు కాలేదు.
>> మరియు నేను చూస్తే, ఆసక్తికరమైన కుడి వైపు ఇక్కడ పైగా,
నేను ఒక స్థానిక ఉంది అని గుర్తించలేకపోతే వేరియబుల్, భావంలో స్థానిక
అది ప్రస్తుత ఫంక్షన్ లోపల.
మరియు దాని విలువ, స్పష్టంగా అప్రమేయంగా, మరియు సౌకర్యవంతంగా విధమైన, 0 ఉంది.
కానీ నేను టైప్ 0 లేదు.
కేవలం నిర్మాణము దాని క్షణం వద్ద డిఫాల్ట్ విలువ.
>> నాలో ముందుకు వెళ్లి ఇప్పుడు దీన్ని చూద్దాం.
నాకు ముందుకు వెళ్లి వెళ్ళి తెలపండి ఇక్కడే ఎగువన, నేను ఉన్నాను
ముందుకు వెళ్లి ఈ మొదటి చిహ్నాన్ని క్లిక్ ఇది
ఇది స్టెప్ ఓవర్ అర్థం skip లేదు అంటే అది కాని కోడ్ యొక్క ఈ లైన్ అతిక్రమించి,
మార్గం వెంట అది అమలు.
>> మరియు ఇప్పుడు నోటీసు, నా ప్రాంప్ట్ కేవలం మార్చబడింది.
ఎందుకు అని?
నేను debug50 చెప్పారు చేసిన, కోడ్ యొక్క ఈ లైన్ అమలు.
కోడ్ యొక్క ఈ లైన్ ఏమి చేస్తుంది?
ఒక Int కోసం నాకు ప్రాంప్ట్ వస్తుంది.
అలాగే.
నాకు సహకరించిన లెట్.
నాకు ఇప్పుడు ముందుకు వెళ్లి టైప్ -1 ఎంటర్ లెట్.
ఇప్పుడు మార్చబడింది గమనిస్తారు.
కుడి వైపు, నా స్థానిక వేరియబుల్ నేను
ఉండటం -1 ఇప్పుడు తెలిసింది.
మరియు అది రకం Int ఇప్పటికీ.
>> మరియు నోటీసు, చాలా, నా పిలవబడే స్టాక్ కాల్, నేను ఎక్కడ విరామం వచ్చింది?
మనం గురించి మరింత మాట్లాడదాము భవిష్యత్తులో ఈ.
అయితే కాల్ స్టాక్ కేవలం సూచిస్తుంది ఏమి విధులు ప్రస్తుతం కదలికలో.
ప్రస్తుతం ఇది ప్రధాన వార్తలు.
మరియు ప్రస్తుతం కేవలం స్థానిక వేరియబుల్ 1 విలువతో i ఉంది.
>> నేను చివరకు ఈ అతిక్రమించి ఉన్నప్పుడు ఇక్కడ, కుడి ఎగువ అదే చిహ్నం,
-1 ప్రతికూల పూర్ణ సంఖ్య.
ఇప్పుడు అది వంకర కలుపు పైగా విరామం చేసే లో.
యొక్క దాని పనిని లెట్.
నేను ఆ లైన్, మరియు voila అతిక్రమించి.
>> ఐతే అన్ని భయంకరమైన ప్రకాశాన్ని ఇంకా,
కానీ అది నాకు విరామం వీలు మరియు తార్కికంగా ఆలోచించడం
ఈ కార్యక్రమం ఏమి చేస్తోంది.
కానీ ఆ తప్పుడు కేసు కాదు.
ఈ క్రింది విధంగా మళ్ళీ తెలియజేసేలా.
>> నేను ఆ బ్రేక్పాయింట్ వదిలి వెళుతున్న ఎరుపు బిందువు లైన్ 8 న.
నేను debug50 తిరిగి వెళుతున్న.
ఇది స్వయంచాలకంగా ఇక్కడ పాజ్ లో.
కానీ ఈ సమయంలో, బదులుగా ఈ లైన్ పైన అడుగు పెట్టటం,
నాకు నిజంగా లోపలి వీలు get_negative_int మరియు బయటకు దొరుకుతుందని,
ఎందుకు అది చెల్లని సమాధానం గా 0 అంగీకరించడం?
>> కాబట్టి దశ ఓవర్ చేయడం బదులుగా.
నేను ముందుకు వెళ్ళడానికి వెళుతున్న మరియు క్లిక్ లోకి అడుగు.
మరియు పంక్తి 8 అని గమనించవచ్చు ఇప్పుడు హఠాత్తుగా ఇప్పుడు హైలైట్
లైన్ 17 అవుతుంది.
>> ఇప్పుడు, డీబగ్గర్ అని కాదు పంక్తులు 14 మరియు 15 మరియు 16 దిగింది చేసింది.
ఇది కేవలం ఏమీ ఉంది లో అక్కడ మీరు చూపించడానికి.
ఆ వేరియబుల్స్ ప్రకటించుకున్నారు, ఆపై పదం చేయదగినవి
ఆపై ఒక బహిరంగ వంకర కలుపు.
అని మాత్రమే ఫంక్షనల్ లైన్ జూసీ నిజంగా ఇక్కడ ఈ ఒక, 17 ఉంది.
మేము చేసిన మరియు ఆ స్వయంచాలకంగా పాజ్.
>> కాబట్టి printf ( "n.is:") ;, కాబట్టి ఇంకా సంభవించదని.
కాబట్టి యొక్క ముందుకు వెళ్లి అతిక్రమించి క్లిక్ చేయండి.
ఇప్పుడు నా ప్రాంప్ట్, నిజానికి, మార్చబడింది ( "n- ఉంది:").
ఇప్పుడు నేను వెళుతున్న కాదు, get_int పునాది ఇబ్బంది,
ఆ ఫంక్షన్ ఎందుకంటే లైబ్రరీ లో CS50 చేసిన.
ఇది బహుశా సరైన అని.
>> నేను ముందుకు వెళ్ళడానికి వెళుతున్న మరియు విధమైన ఇవ్వడం ద్వారా సహకరించిన
ఒక Int, కానీ ఒక ప్రతికూల Int.
నాలో ముందుకు వెళ్లి హిట్ 0 వీలు.
ఇప్పుడు ఇక్కడ ఏమి 21 వరుసలో నేను డౌన్ వచ్చినప్పుడు?
నేను మళ్ళీ iterated చెయ్యలేదు.
నేను ఆ లూప్ లో కష్టం కనిపిస్తుంది లేదు.
ఇతర మాటలలో, ఈ పసుపు బార్ చుట్టూ కొనసాగించడాన్ని లేదు,
మరియు చుట్టూ, మరియు చుట్టూ.
>> ఇప్పుడు, ఎందుకు అని?
బాగా, n, ఏమి ప్రస్తుతం ఉన్న n ఉంది?
నేను స్థానిక చూడవచ్చు డీబగర్లో వేరియబుల్స్.
N 0 ఉంది.
అన్ని కుడి, నా పరిస్థితి ఏమిటి?
>> 20-- లైన్ 20, ఉంది, 0 0 కంటే ఎక్కువ.
అది నిజం కాదు.
0 0 కంటే ఎక్కువ కాదు.
కాబట్టి నేను ఈ బయటపడిన.
>> అందువలన ఎందుకు లైన్లో వార్తలు 21, నేను నిజానికి కొనసాగితే,
నేను కూడా, 0 తిరిగి వెళుతున్న నేను తిరస్కరించారు ఉండాలి అయితే 0
వాస్తవానికి నెగటివ్ గా కాదు.
కాబట్టి ఇప్పుడు, నేను నిజంగా కూడా లేదు డీబగ్గర్ పట్టించుకోనట్లు.
అది నేను అవసరం లేదు గాట్ జరుగుతుందో మరింత తెలుసు.
>> నేను ముందుకు వెళ్ళడానికి వెళుతున్న మరియు కేవలం ప్లే బటన్ క్లిక్ చేయండి,
మరియు ఈ ముగింపు అప్ తెలియజేయండి.
ఇప్పుడు, నేను గ్రహించారు చేసిన నా బగ్ లైన్ 20 న కానేకాదు.
ఆ నా తార్కిక లోపం.
>> కాబట్టి ఏమి నేను అనుకుంటున్నారు ఈ మార్చడానికి ఏమి?
సమస్య ఉంటే నేను ఉన్నాను అని కాదు పట్టుకోవడంలో 0, అది కేవలం ఒక తార్కిక లోపం.
నేను n ఏది అయితే చెప్పగలను కంటే ఎక్కువ లేదా 0 సమానంగా,
మళ్లీ మళ్లీ వినియోగదారు ప్రాంప్ట్ ఉంచండి.
>> సో, మళ్ళీ, సాధారణ తప్పు, బహుశా మీరు నాకు చూసింది కూడా స్పష్టంగా
కేవలం కొన్ని నిమిషాల క్రితం వ్రాయండి.
కానీ ఇక్కడ takeaway డీబగ్ 50 అని,
మరియు డీబగ్గింగ్ తో సాఫ్ట్వేర్ మరింత సాధారణంగా,
మీరు ఈ కొత్త దొరకలేదు శక్తి కలిగి , మీ స్వంత కోడ్ నడవడానికి చూడండి
ఆ కుడి చేతి ప్యానెల్ ద్వారా ఏమి మీ వేరియబుల్స్ విలువలు.
కాబట్టి మీరు తప్పనిసరిగా లేదు ఏదో ఉపయోగించడానికి కలిగి
వంటి ఆ విలువలను ప్రింట్ eprintf.
మీరు నిజంగా వాటిని చూడగలరు దృశ్యపరంగా తెరపై.
>> ఇప్పుడు, ఈ దాటి, అది పేర్కొంది ఉపయోగకరమని వార్తలు మరొక టెక్నిక్ ఉందని
నిజానికి సూపర్ సాధారణ.
మరియు మీరు ఎందుకు ఈ చిన్న ఆశ్చర్యానికి ఉండవచ్చు ఇక్కడ వ్యక్తి వేదికపై కూర్చొనివుంది.
కనుక సాధారణంగా ఈ పద్ధతిని వార్తలు, రబ్బరు డక్ డీబగ్గింగ్ అని పిలుస్తారు,
ఇది నిజంగా కేవలం ఒక ఉంది నిజానికి నిబంధన
తరచుగా ఉన్నప్పుడు ప్రోగ్రామర్లు కోడ్ వ్రాస్తున్న
వారు అవసరం లేదు ఉన్నాము ఇతరులతో కలిసి,
లేదా ఒక షేర్డ్ వాతావరణంలో పని.
>> వారు ఇంట్లో విధమైన ఉన్నారు.
బహుశా అది రాత్రి ఆలస్యం.
వారు ఆశించాను వారి కోడ్ లో కొన్ని బగ్.
మరియు వారు కేవలం అది చూసిన కాదు.
>> మరియు ఏ రూమ్మేట్ ఉంది.
ఏ TF ఉంది.
చుట్టూ CA ఉంది.
వారు వారి షెల్ఫ్ న అన్ని ఈ చిన్న రబ్బరు డక్కి ఉంది.
>> కాబట్టి రబ్బరు డక్ డీబగ్గింగ్ ఈ ఆహ్వానం
వెర్రి ఏదో అనుకుంటున్నారో ఈ నిజమైన జీవి వలె
మరియు నిజానికి మీ కోడ్ ద్వారా నడిచి మాటలతో ఈ జీవం లేని వస్తువు.
కాబట్టి, ఉదాహరణకు, ఉంటే ఈ నా ఉదాహరణ ఇక్కడ
మరియు ఆ ముందు గుర్తుకు సమస్య ఈ ఉంది,
నేను కోడ్ యొక్క ఈ మొదటి రేఖ తొలగిస్తే, మరియు నేను ముందుకు వెళ్లి మళ్లీ బగ్గీ 0 చేస్తాము,
నేను ఈ ఉందని గుర్తు ఇక్కడ లోపం సందేశాలు.
కాబట్టి ఇక్కడ ఆలోచన, నేను అయితే హాస్యాస్పదంగా బహిరంగంగా ఈ చేయడం సమయంలో అనుభూతి,
ఆ లోపం ఉంది.
>> సరే, నా సమస్య ఏమిటంటే నేను చేసిన ఉంది పరిపూర్ణంగా ఒక లైబ్రరీ ఫంక్షన్ ప్రకటించింది.
మరియు ఆ printf లైబ్రరీ ఫంక్షన్ ఉంది.
సరే డిక్లేర్, డిక్లేర్ నమూనాలను నాకు గుర్తుచేస్తుంది.
>> నేను నిజంగా అవసరం అంటే ముందుగానే కంపైలర్ చెప్పడానికి ఏమి
ఫంక్షన్ ఎలా.
ఒక నిమిషం ఆగు.
నేను ప్రామాణిక io.h. లేదు
చాలా ధన్యవాదాలు.
>> కాబట్టి కేవలం ఈ ప్రక్రియ మీరు of-- నిజానికి ఒక డక్ కలిగి అవసరం లేదు.
కానీ వాకింగ్ ఈ ఆలోచన మీ స్వంత కోడ్ ద్వారా మీ
కాబట్టి మీరు కూడా వినే మీ, కాబట్టి మీరు
మీ స్వంత లో లోపాల తెలుసుకోవటం స్టర్ సాధారణంగా ఆలోచన.
>> మరియు, బహుశా మరింత తార్కికంగా, చాలా ఒక కానీ ఎక్కువ పాల్గొంటుంది ఎక్కువ
ఉదాహరణకు మనం కేవలం బగ్గీ 3.సి లో చేసాడు, మీరు ద్వారా మిమ్మల్ని నడిచిన ఉండవచ్చు
వంటి అనుసరిస్తుంది.
కాబట్టి అన్ని కుడి, రబ్బరు డక్కి, DDB, మీరు రెడీ ఉంటే.
ఇక్కడ మేము నా ప్రధాన ఫంక్షన్ కలిగి, నేను ప్రతికూల పూర్ణాంకానికి పొందుతారు కాల్ చేస్తున్నాను.
>> నేను తిరిగి విలువ పొందడానికి చేస్తున్నాను.
నేను ఎడమ వైపు దీన్ని నిల్వ చేస్తున్నాను ఒక వేరియబుల్ లైన్ 8 న నేను అనే.
సరే, కానీ వేచి, ఎలా చేసాడు ఆ విలువ పొందడానికి?
నాకు లైన్ 12 లో ఫంక్షన్ చూద్దాం.
>> లైన్ 12 లో, మేము ప్రతికూల పూర్ణాంకానికి పొందుతారు కలిగి.
ఏ ఇన్పుట్లను తీసుకోదు, సరే, ఒక పూర్ణాంకానికి తిరిగి లేదు.
నేను లైన్ 14 ఆ వేరియబుల్ n న ప్రకటిస్తుంది.
ఇది పూర్ణాంకం నిల్వ జరగబోతోంది.
ఆ నేను మీరు ఏమి ఉంది.
>> n మాదిరిగా వీలు అందువలన ఈ క్రింది వాటిని ఇప్పటికే నాకు చేసిన ఏమి పరిష్కారము నేను దిద్దుబాటు రద్దుచెయ్యి.
కాబట్టి n కంటే ఎక్కువ ఉంది 0, సరే, n ప్రింట్.
ఆపై పూర్ణాంకానికి n లో నిల్వ కాల్.
ఆపై n 0 ఉంటే తనిఖీ, n not-- అక్కడ ఉంది.
సో, మళ్ళీ, మీరు లేదు అసలు డక్ అవసరం.
కానీ మీరే ద్వారా వాకింగ్ ఒక మేధో వ్యాయామం మీ కోడ్
తరచుగా మీరు సహాయం చేస్తుంది ఏం జరగబోతోంది తెలుసుకోవటం,
కేవలం ఏదో చేయడం వ్యతిరేకంగా ఈ వంటి, తెర ఉంటె,
మరియు మీరే ద్వారా మాట్లాడటం లేదు నిజాయితీగా కాదు అది
దాదాపు సమర్థవంతమైన పద్ధతిని వంటి.
సో అక్కడ మీరు కలిగి, ఒక వివిధ పద్ధతులు సంఖ్య
నిజానికి మీ కోడ్ డీబగ్గింగ్ కోసం మరియు తప్పులను వెతకటం, ఇవన్నీ
మీ సంచిలో టూల్స్ ఉండాలి మీరు అర్థరాత్రి కాదు ఉన్నాము కాబట్టి,
ముఖ్యంగా, మీరు భోజనాల ఉన్నారని మందిరాలు, లేదా కార్యాలయం గంటల వద్ద,
మీ తల banging గోడ, కొన్ని సమస్యను పరిష్కరించడానికి ప్రయత్నిస్తున్న.
సాఫ్ట్వేర్ టూల్స్ ఉన్నాయి అని తెలుసుకోవటం.
రబ్బరు డక్ టూల్స్ ఉన్నాయి.
మరియు యొక్క మొత్తం సిబ్బంది ఉంది ఒక చేతి అప్పిచ్చు వేచి మద్దతు.
>> కాబట్టి ఇప్పుడు, ఒక సమస్య పదం సెట్లు, మరియు మేము మీరు ఆశతో ఏమి
వాటిని పొందడానికి, మరియు ఎలా మన మూల్యాంకనం గురించి వెళ్ళండి.
కోర్సు యొక్క సిలబస్ ప్రకారం, CS50 యొక్క సమస్య సెట్లు
నాలుగు ప్రాధమిక అక్షాలు విశ్లేషించబడుతుంది కాబట్టి, పరిధిని మాట్లాడటానికి, కచ్చితత్వం, డిజైన్
మరియు శైలి.
మరియు పరిధిని ఎంత సూచిస్తుంది ముక్క మీరు ఆఫ్ కరిచింది?
ఎలా మీరు ఒక సమస్య ప్రయత్నించారు?
కృషి ఏ స్థాయిలో మీరు వ్యక్తం చేశారు?
>> సరి, కార్యక్రమం పని కూడా చేస్తుంది అది CS50 వివరణ ప్రకారం రావలసిన
మీరు కొన్ని ఇన్పుట్లను అందించినప్పుడు లేదా కొన్ని ప్రతిఫలాన్ని తిరిగి వస్తున్నారా?
డిజైన్ వాటిలో చాలా ఆత్మాశ్రయ ఉంది.
మరియు అది ఒక విల్ వార్తలు తెలుసుకోవడానికి పొడవైన పడుతుంది
మరియు నేర్పిన పొడవైన, ఇప్పటివరకు అది boils గా,
మీ కోడ్ రాసిన ఎలా బాగా ఉంది?
>> ఇది కేవలం సరైన ప్రింట్ ఒక విషయం ప్రతిఫలాన్ని లేదా కుడి విలువలు తిరిగి.
కానీ మీరు చేయట్లేదు సమర్ధవంతంగా సాధ్యమైనంత?
మీరు విభజన చేస్తున్నారా జయించటానికి లేదా బైనరీ
మేము వెంటనే మేము ఆ చూస్తారు వంటి శోధన రెండు వారాల క్రితం ఫోన్ బుక్ తో?
పరిష్కరించడానికి మంచి మార్గాలు ఉన్నాయి సమస్య మీరు ప్రస్తుతం ఇక్కడ కంటే?
ఆ మంచి డిజైన్ కోసం ఒక అవకాశం.
>> ఆపై శైలి అందంగా మీ స్మృతి?
మీరు నేను అందంగా ఉన్నాను గమనిస్తారు నా కోడ్ ఇండెంటింగ్ గురించి,
మరియు ఖచ్చితంగా నా వేరియబుల్స్ మేకింగ్ సహేతుక పెట్టబడింది. n,
కొంతకాలం ఒక మంచి పేరు సంఖ్య, ఒక లెక్కింపు పూర్ణాంక కోసం నేను,
ఒక స్ట్రింగ్ కోసం s.
మరియు మేము ఇకపై కలిగి వేరియబుల్ పేర్లు శైలి.
శైలి ఎంత మంచి మీ కోడ్ చూడండి లేదు?
మరియు అది ఎలా చదవగలిగే?
>> కాలాంతరంలో మీ TAS మరియు TFS, కోర్సు లో చేస్తాను
మీకు అందించడానికి గుణాత్మక అభిప్రాయంతో రకం
మీరు మంచి పొందుటకు కనుక ఆ వివిధ కోణాలను.
మరియు మేము ఎలా పరంగా ఈ గొడ్డలి ప్రతి విశ్లేషించడానికి,
ఇది అతికొద్ది సాధారణంగా మీరు ఆ బకెట్లు, సాధారణంగా,
మీరు చేస్తున్న ఎంతవరకు వేసేందుకై.
మరియు, నిజానికి, మీరు ఒక స్కోరు స్వీకరిస్తే ఆ axes-- సరి, డిజైన్ ఏ
మరియు శైలి ఆ సంఖ్యను especially-- సాధారణంగా 1 మరియు 5 మధ్య ఉంటుంది.
మరియు, వాచ్యంగా, మీరు పొందుతుంటే 3 ప్రారంభంలో సెమిస్టర్ యొక్క,
ఇది చాలా మంచి విషయం.
ఇది ఇప్పటికీ ఉంది అంటే అభివృద్ధి కోసం గది,
మీరు కోసం ఆశిస్తున్నాము ఇది మొదటి సారి ఒక తరగతి తీసుకొని.
సీలింగ్ కొన్ని బిట్ ఆశాజనక ఉంది ఇది మిమ్మల్ని చేరే ఆశపడు చేస్తున్నారు.
అందువలన 3 యొక్క పొందడానికి ప్రారంభ రచనల్లో,
లేకపోతే కొన్ని 2 మరియు 4 యొక్క, ఒక మంచి విషయం, నిజానికి, ఉంది.
ఇది పరిధిలోని లోపల బాగా, అంచనాలను పరిధిలోనే.
>> మరియు మీ మనస్సు రేసింగ్ ఉంది ఉంటే, వేచి ఒక నిమిషం, ఐదు నుండి మూడు.
ఆ నిజంగా 10 6 కోల్పోయాడు.
60% ఉంది.
ఒక ఎఫ్ అని నా దేవుడు,
>> ఇది కాదు.
నిజానికి అది కాదు, వార్తలు.
అయితే, దాన్ని మెరుగుపరచడానికి ఒక అవకాశం సెమిస్టర్ క్రమంలో.
మరియు మీరు కొన్ని పొందుతుంటే పేదలకు, ఈ అవకాశాన్ని ఉంటాయి
ఆఫీసు గంటల, ప్రయోజనాన్ని ఖచ్చితంగా విభాగాలు మరియు ఇతర వనరులను కలిగివుంటుంది.
>> ఉత్తమ నిజంగా, ఒక అవకాశం, మీరు చేసిన ఎంత వరకు గర్వపడాల్సిన
సెమిస్టర్ క్రమంలో వస్తాయి.
కాబట్టి, తెలుసుకుంటారు లేకపోతే, ఏమీ వేరే మూడు మంచిది.
మరియు కాలానుగుణంగా అభివృద్ధి కోసం గది అనుమతిస్తుంది.
>> ఆ పొడవులు ఎలా అధిక వాస్తవికంగా మీరు
పొందడానికి మీ సమయం చాలా ఖర్చు కానుంది పని విషయాలు సరిగ్గా విడదీసి.
కాబట్టి సవ్యత కావాలనుకుంటాడు తో, చాలా ప్రాధాన్యత
మూడు ఈ గుణకార కారకం.
డిజైన్ కూడా ముఖ్యం, కానీ మీరు తప్పనిసరిగా చేయలేని ఏదో
ఆ గంటల అన్ని ఖర్చు విషయాలు కేవలం పని పొందుటకు ప్రయత్నిస్తున్న.
>> మరియు కనుక ఇది బరువు వార్తలు కొంచెం తేలికగా.
మరియు అప్పుడు శైలి కనీసం ప్రాధాన్యత ఉంది.
కూడా అది తక్కువ అయితే ప్రాధమికంగా ముఖ్యమైన,
ఇది కేవలం, బహుశా, కుడి దీన్ని సులువైన విషయం
ఉదాహరణలు మనం అనే ఉపన్యాసం మరియు విభాగంలో,
చక్కగా విషయాలు ఇండెంట్ మరియు వ్యాఖ్యానించారు,
మొదలగునవి సులభమయిన ఒకటిగా ఉంది చేయండి మరియు కుడి పొందుటకు విషయాలు.
కాబట్టి వంటి, తెలుసుకోవటం ఆ పాయింట్లు ఉన్నాయి
అని గ్రహించి చాలా సులభం.
>> ఇప్పుడు పదంపై విద్యా నిజాయితీ దీన్ని.
కాబట్టి కోర్సు యొక్క శాతం సిలబస్, మీరు చూస్తారు
కోర్సు కూడా ఉంది అని చాలా ఈ చుట్టూ భాష యొక్క బిట్.
అంతే కాకుండా సమస్యను తీసుకుని చాలా తీవ్రంగా విద్యా నిజాయితీ.
>> మేము వ్యత్యాసం కలిగి, మంచి కోసం లేదా చెడుకో,
ఆఫ్ పంపిన కలిగి ప్రతి సంవత్సరం క్రమశిక్షణా చర్య విద్యార్థులను
అత్యంత ఏదైనా ఇతర కంటే కోర్సు యొక్క, నేను తెలుసు అని.
ఇది అవసరమైన కాదు నిజానికి చిహ్నం
ఆ CS విద్యార్థులు, లేదా CS50 విద్యార్థులు, ఉన్నాయి ఏ తక్కువ మీ తోటి విద్యార్థుల కంటే నిజాయితీ.
కానీ వాస్తవంలో ఆ ఈ ప్రపంచ, ఎలక్ట్రానిక్, మేము కేవలం
సాంకేతిక కలిగి ఈ గుర్తించే అర్థం.
>> దాని కోసం మాకు ముఖ్యం తరగతి అంతటా న్యాయంగా
ఈ కనుగొనాలి మరియు పెంచడానికి మనం చేసే సమస్య మేము విషయాలు చూసినప్పుడు.
మరియు కేవలం ఒక చిత్రాన్ని చిత్రించడానికి, మరియు నిజంగా ఈ సింక్ వంటి ఏదో సహాయం,
వీటిలో సంఖ్యలు గత 10 సంవత్సరాలుగా విద్యార్థులు
కొన్ని ప్రమేయం చేసిన విద్యా నిజాయితీ అటువంటి సమస్యలు,
కొన్ని 32 మంది విద్యార్ధులతో పతనం 2015, నుండి
మేము పడుతుంది లేదు అని చెప్పబడినది విషయం చాలా తీవ్రంగా.
మరియు, చివరికి, ఈ సంఖ్యలు కంపోజ్, ఇటీవల సుమారు 3%, 4% లేదా
తరగతి.
>> కాబట్టి విద్యార్థులు సూపర్ మెజారిటీ కోసం ఇది పంక్తులు స్పష్టంగా తెలుస్తుంది.
కానీ ఈ వస్తున్నాను మనస్సు, ముఖ్యంగా చివరి
పోరాడుతున్న రాత్రి సమస్య సెట్ కొన్ని పరిష్కారం,
విధానాల ఉన్నాయి మీరే పొందడానికి
మీరు కంటే మద్దతు ఉండవచ్చు కూడా ఆ గంట వద్ద, నేను భావిస్తున్నాను.
మనం అందుకున్నప్పుడు రియలైజ్ విద్యార్ధి సమర్పణలు మనం అడ్డగించి
ఈ సంవత్సరం ప్రతి సమర్పణ సరిపోల్చండి ప్రతి సమర్పణ గత ఏడాది,
2007 నుండి ప్రతి సమర్పణ వ్యతిరేకంగా, మరియు అలాగే, చూడటం, నుండి,
కోడ్ నిక్షేప ఆన్లైన్, చర్చావేదికలు, ఉద్యోగ ప్రదేశాలు.
మరియు మేము ఈ మైల్, నిజంగా, మాట కోసం అన్ని
పూర్తి బహిర్గతం యొక్క, ఆ ఉంటే ఎవరో ఆన్లైన్ కనుగొంటారు,
ఖచ్చితంగా, కాబట్టి మేము కోర్సు చేయవచ్చు.
కానీ, నిజంగా, ఆత్మ కోర్సు డౌన్ దిమ్మల
సిలబస్ లో ఈ నిబంధన ఉంది.
ఇది నిజంగా కేవలం సహేతుకమైన ఉండాలి.
>> మరియు మేము ఉన్నట్లయితే వివరించడానికి కేవలం ఒక బిట్ మరింత భాషతో,
తెలుసుకుంటారు అన్ని యొక్క సారాంశం మీరు ఈ కోర్సు సమర్పించే పని
మీ సొంత ఉండాలి.
కానీ ఆ లోపల, ఖచ్చితంగా అవకాశాలు, మరియు ప్రోత్సాహం
తిరగడం మరియు బోధనకు విలువ నాకు others--, TFS, కాస్,
టాస్, మరియు తరగతి లో ఇతరులు మద్దతు కోసం, ఒంటరిగా స్నేహితులు
మరియు రూమ్మేట్స్ ఎవరు అధ్యయనం ముందు CS మరియు ప్రోగ్రామింగ్.
మరియు అందువలన కోసం ఒక భత్యం ఉంది.
మరియు thumb సాధారణ నియమం సహాయం కోసం దీన్ని అడుగుతూ ఉన్నప్పుడు,
మీరు ఇతరులకు మీ కోడ్ చూపవచ్చు, కానీ వారి వీక్షించడానికి పోవచ్చు.
కాబట్టి మీరు ఆఫీసు గంటల వద్ద ఉన్నప్పుడు కూడా, లేదా D హాల్, లేదంటే ఎక్కడో
కొన్ని ముక్క సెట్ పైన పని, ఒక స్నేహితుడు, కలిసి పని ఇది
వద్ద పూర్తిగా ఉత్తమంగా ఉంటుంది రోజు మీ పని యొక్క చివరి
చివరికి ప్రతి చెందిన ఉండాలి మీరు వరుసగా, మరియు
కొన్ని సహకార ప్రయత్నమని, చివరి ప్రాజెక్ట్ సందర్భం మినహా
అది అనుమతి మరియు ప్రోత్సహించింది లో.
>> మీరు ఉంటే రియలైజ్ ఏదో తో పోరాడుతున్న
మరియు మీ స్నేహితుడు కేవలం జరుగుతుంది అప్పుడు ఈ వద్ద మంచి మీరు
లేదా మీరు కంటే ఆ సమస్య వద్ద మంచి, లేదా మీరు కంటే దూరంగా ముందుకు కొద్దిగా,
అది తిరుగులేని పూర్తిగా సహేతుకమైన వార్తలు మీ స్నేహితుడికి మరియు హే అని,
మీరు ఇక్కడ నా కోడ్ చూడటం పట్టించుకోవడం లేదు, నాకు నా సమస్య ఏమిటి గుర్తించడం సహాయం?
మరియు, ఆశాజనక, లో బోధనకు విలువ వడ్డీ
ఆ స్నేహితుడు కేవలం చేస్తుంది చెప్పేది OH, దీన్ని, కానీ,
ఏమి మీరు లైన్ తప్పిపోయాయి 6, లేదా అలాంటిదే?
కానీ పరిష్కారం కాదు మీరు పక్కన స్నేహితుడు కోసం
చెప్పటానికి, OH, బాగా, ఇక్కడ, నాకు పుల్ వీలు ఈ అప్, మరియు మీరు నా పరిష్కారం చూపించు.
కాబట్టి ఆ లైన్.
మీరు మీ కోడ్ చూపించు ఇతరులు, కానీ మీరు చేయకపోవచ్చు
వారిది వీక్షించడానికి ఇతర లోబడి కోర్సు యొక్క సిలబస్ లో అడ్డంకులు.
>> సో మనస్సు ఈ ఉంచేందుకు లేదు విచారం నిబంధన అని పిలవబడే
అలాగే కోర్సు యొక్క సిలబస్ లో, మీరు కొన్ని చర్య కమిట్ ఉంటే
సమంజసం కాదు, కానీ దానిని తీసుకుని కోర్సు యొక్క తలలు దృష్టిని
72 గంటల్లో, కోర్సు స్థానిక ఆంక్షలు విధించే ఉండవచ్చు
ఒక అసంతృప్తికర కలిగి ఉండవచ్చు లేదా సమర్పించిన పని కోసం విఫలమయ్యాడు గ్రేడ్.
కానీ కోర్సు చూడండి కాదు మరింత క్రమశిక్షణా చర్య కోసం పట్టింపు,
పునరావృతం చర్యలు సందర్భాలలో తప్ప.
ఇతర మాటలలో, కొన్ని చేయడానికి మీరు లేకపోతే స్టుపిడ్, ముఖ్యంగా అర్థరాత్రి, నిర్ణయం
ఆ మరుసటి రోజు లేదా రెండు రోజులు తరువాత, మీరు మేల్కొలపడానికి మరియు గ్రహించడం,
నేను ఏమి ఆలోచిస్తున్నాడు?
మీరు ఒక అవుట్లెట్ కలిగి CS50 లో ఏమి ఆ సమస్య పరిష్కారానికి
తద్వారా ఇది వరకు సొంతం, మేము సగం మీరు అనుగుణంగా మరియు వ్యవహరించే
అది ఒక విషయంలో ఆ రెండు ఉంది విద్యా మరియు మీరు కోసం విలువైన,
కానీ కొన్ని విధంగా ఇప్పటికీ శిక్షాత్మక.
ఇప్పుడు అంచు బయట ఈ తీసుకోవాలని,.
>> [వీడియో ప్లేబ్యాక్]
>> [సంగీతాన్ని]
>> [END ప్లేబ్యాక్]
డేవిడ్ J. మలన్: అన్ని కుడి, మేము తిరిగి ఉంటాయి.
మరియు ఇప్పుడు మేము ఒక చూడండి మొదటి మా వాస్తవ ప్రపంచంలో డొమెయిన్ల
CS50 లో, గూఢ లిపి శాస్త్రం యొక్క కళ, పంపడం మరియు స్వీకరించడం కళ
రహస్య సందేశాలు, ఎన్క్రిప్టెడ్ మీరు రెడీ ఉంటే సందేశాలు,
మీరు కలిగి ఉంటే మాత్రమే అవగతం చేసుకోవచ్చు పంపినవారు ఉంది కొన్ని కీలక అంశం
అలాగే.
మేము తీసుకుంటాము కాబట్టి ఈ చైతన్యపరచటంలో ఇక్కడ ఈ విషయం చూడండి,
ఇది ఒక ఒక ఉదాహరణ రహస్య డికోడర్ రింగ్ అని
గుర్తించడానికి క్రమంలో ఉపయోగించవచ్చు ఒక రహస్య సందేశం నిజంగానే ఏమిటి.
నిజానికి, వెనుక గ్రేడ్ పాఠశాల లో రోజు,
మీరు ఎప్పుడైనా రహస్య సందేశాలు పంపిన ఉంటే కొన్ని స్నేహితుడు లేదా తరగతి లో కొన్ని ప్రేమను,
మీరు భావించి ఉంటారు మీరు తెలివైన పొందారు
కాగితం మారుతున్న మీ భాగాన్ని, వంటి ఒక B, మరియు B సి, మరియు సి D కు,
మొదలగునవి.
కానీ మీరు నిజంగా ఎన్క్రిప్ట్ చేశారు మీ సమాచారాన్ని కూడా
అది ఒక చిన్న చిన్నవైన, ఒకవేళ కాదు గ్రహించడం ఉపాధ్యాయునికి ఆ హార్డు,
బాగా, మీరు మార్చుకుంటే బి మరియు సి బి,
మీరు నిజంగా దొరుకుతుందని సందేశం, ఏమిటి
కానీ మీరు సమాచారాన్ని ciphering ఉన్నాయి.
>> మీరు కేవలం చేస్తున్న కేవలం చాలా ఇక్కడ Ralphie వంటి
పోషించే ఒక ప్రసిద్ధ చిత్రం లో చాలా చక్కని ప్రకటన nauseum ప్రతి శీతాకాలంలో.
[వీడియో ప్లేబ్యాక్]
ఇది అన్ని ఆ తెలిసిన-ఉండండి రాల్ఫ్ పార్కర్ దీన్ని ఉంది
లిటిల్ సభ్యునిగా నియమించారు ఆర్ఫన్ అన్నీ సీక్రెట్ సర్కిల్
మరియు అన్ని గౌరవాలు అర్హత ఉంది మరియు ప్రయోజనాలు అందుకు సంభవించే.
>> ఒప్పందం కుదుర్చుకున్నాడు, లిటిల్ ఆర్ఫన్ అన్నీ, కౌంటర్ సంతకం సిరా, పియరీ ఆండ్రీ.
గౌరవాలు మరియు ప్రయోజనాలు తొమ్మిదేళ్ళ వయసులో ఇప్పటికే.
>> [అరవటం]
పై -Come.
అది తో పొందండి లెట్.
నేను ఆ జాజ్ అవసరం లేదు రవాణాదారులు మరియు పైరేట్స్ గురించి.
>> రేపు రాత్రి వినండి ముగింపు సాహస
బ్లాక్ పైరేట్ నౌక.
ఇప్పుడు, అది యొక్క సమయం అన్నీ యొక్క రహస్య సందేశాన్ని
సీక్రెట్ సర్కిల్ మీరు సభ్యులు.
గుర్తుంచుకో, పిల్లలు, సభ్యులు మాత్రమే అన్నీ యొక్క సీక్రెట్ సర్కిల్
అన్నీ యొక్క రహస్య సందేశం డీకోడ్ చేయవచ్చు.
>> గుర్తుంచుకోండి, అన్నీ మీరు ఆధారపడి ఉంటుంది.
B2 మీ పిన్స్ సెట్.
ఇక్కడ సందేశం.
12, 11--
>> -I, నా మొదటి రహస్య సమావేశం am.
>> -14, 11, 18, 16.
>> -Pierre గొప్ప వాయిస్ టునైట్ లో.
నేను ఆ రాత్రి యొక్క తెలియజేయగలరా సందేశం నిజంగా ముఖ్యమైనది.
>> -3, 25, ఒక సందేశం అన్నీ తనకు నుండి.
గుర్తుంచుకోండి, ఎవరికీ లేదు.
>> -90 సెకన్ల తరువాత, నేను మాత్రమే ఉన్నాను ఇంట్లో గదిలో ఉన్న తొమ్మిది ఒక బాలుడు
గోప్యతా మరియు డీకోడ్ లో కూర్చుని.
ఆహా, బి!
నేను తరువాత, ఇ వెళ్లిన
>> మొదటి పదం ఉంటుంది ఉంది.
ఎస్, అది ఇప్పుడు సులభంగా దాగి ఉంది, U, 25--
>> -ఓహ్, Ralphie వస్తాయి, నేను వెళ్ళి చూడాలి!
>> కుడి డౌన్ -I'll, మా!
గీ whiz!
>> -T, ఓ, ఆలోచన ఏమి తప్పకుండా తప్పకుండా?
లిటిల్ ఆర్ఫన్ ఏమిటి అన్నీ చెప్పటానికి ప్రయత్నిస్తున్న?
ఏమి నిర్ధారించుకోండి?
>> -Ralphie, ఆండీ కలిగియున్నది వెళ్ళి, మీరు రండి ఉంటుంది?
>> -అన్ని కుడి, మా!
నేను బయట ఉంటాము!
>> -I ఇప్పుడు దగ్గరగా.
ఉద్రిక్తత భయంకరమైన ఉంది.
అదేమిటి?
గ్రహం యొక్క విధి సంతులనం లో ఆగిపోవచ్చు.
>> -Ralphie!
ఆండీ యొక్క వెళ్ళాలి!
>> బిగ్గరగా ఏడవడం కోసం, కుడి అవుట్ -I'll!
>> అక్కడ -Almost, నా వేళ్ళు వెళ్లింది, నా మనసు ఉక్కు ఉచ్చు ఉంది, ప్రతి చిన్న రంధ్రము కంపింపజేశాయి.
అవును, అవును, అవును అది దాదాపు స్పష్టమైన ఉంది.
>> మీ Ovaltine త్రాగటానికి ఖచ్చితంగా-ఉండండి.
Ovaltine?
ఒక crummy వాణిజ్య?
ఒక బిచ్ కుమారుడు.
[END ప్లేబ్యాక్]
డేవిడ్ J. మలన్: సరే, అని ఒక చాలా మార్గం
గూఢ లిపి శాస్త్రం పరిచయం, మరియు కూడా Ovaltine.
నిజానికి, ఈ పాత ప్రకటన నుండి ఇక్కడ ప్రశ్న, ఎందుకు Ovaltine కాబట్టి మంచి?
ఇది పక్వత యొక్క దృష్టి సంగ్రహం బార్లీ, స్వచ్ఛమైన సంపన్న ఆవు పాలు,
మరియు ప్రత్యేకంగా కలిసి, కోకో సిద్ధం సహజ phosphatides మరియు విటమిన్లు తో.
ఇది మరింత తో బలోపేతం అదనపు విటమిన్లు B మరియు D, yum.
మీరు ఇప్పటికీ స్పష్టంగా, అది పొందవచ్చు, అమెజాన్ న, మేము ఇక్కడ వలె.
>> కానీ ప్రేరణ ఇక్కడ ఉంది ప్రత్యేకంగా, గూఢ పరిచయం
తెలిసిన నిగూఢ రకం రహస్య కీ గూఢ లిపి శాస్త్రం.
పేరు సూచించినట్లు, మొత్తం ఒక రహస్య కీని క్రిప్టో వ్యవస్థ భద్రతే
మీరు, ఒక పద్దతి ఉంటే కేవలం స్క్రాంబ్లింగ్ కోసం
ఇద్దరు వ్యక్తుల మధ్య సమాచారం, అంటే మాత్రమే పంపినవారు మరియు మాత్రమే గ్రహీత
ఒక రహస్య key-- కొన్ని విలువ తెలుసా, కొన్ని రహస్య పదబంధాన్ని కొన్ని రహస్య సంఖ్యలో,
వాటిని రెండు గుప్తీకరించడానికి అనుమతిస్తుంది మరియు వ్యక్తీకరించడానికి సమాచారం.
గూఢ లిపి శాస్త్రం, నిజంగా, వారం 0 నుండి కేవలం ఈ ఉంది.
>> అది ఇన్పుట్లను ఇక్కడ ఒక సమస్య, ఇంగ్లీష్ వాస్తవ సందేశం వంటి
లేదా సంసార భాషలో మీరు ఆ తరగతి లో ఒకరికి పంపాలని,
లేదా ఇంటర్నెట్ అంతటా.
అన్నారు ఇది కొన్ని అవుట్పుట్ ఉంది గిలకొట్టిన సందేశం మీరు ఆ
గ్రహీత పొందాలనుకుంటున్నారా.
మరియు కూడా లో ఎవరైనా మధ్య చాలా అందుకునే,
మీరు వాటిని వద్దు తప్పనిసరిగా దానిని వ్యక్తీకరించడానికి చెయ్యగలరు,
ఈ లోపల ఎందుకంటే బ్లాక్ బాక్స్, లేదా యాంత్రిక పద్ధతి
కొంత యంత్రాంగం, స్టెప్ ద్వారా కొన్ని అడుగు ఆ ఇన్పుట్ తీసుకున్నందుకు సూచనలను,
మరియు మార్చే అవుట్పుట్ ఆశాజనక ఒక సురక్షిత విధంగా.
>> కొన్ని మరియు, నిజానికి, ఉంది ఈ ప్రపంచంలో పదజాలం అనుసరిస్తుంది.
సాదా టెక్స్ట్ పదం ఉంది కంప్యూటర్ శాస్త్రవేత్త చేస్తాను
ఇన్పుట్ వివరించడానికి ఉపయోగించే సందేశం, ఇంగ్లీష్ వంటి
లేదా సంసార భాషలో మీరు నిజంగా కొన్ని ఇతర మానవ పంపాలని.
ఆపై సాంకేతికపాఠం పెనుగులాట ఉంది enciphered, లేదా ఎన్క్రిప్టెడ్,
దాని వెర్షన్.
>> కానీ ఇక్కడ ఒక ఇతర వస్తువుల ఉంది.
మరొకరు ఇన్పుట్ అక్కడ రహస్య కీ గూఢ లిపి శాస్త్రం.
మరియు ఆ కీ అనేది, ఇది సాధారణంగా ఉంది,
మేము చూస్తారు వంటి, ఒక సంఖ్య, లేదా లేఖ, లేదా పదం, సంసార
వాస్తవానికి ఇది అల్గోరిథం ఆశించారు.
>> ఎలా మీరు వ్యక్తీకరించడానికి సమాచారం లేదు?
ఎలా మీరు Unscramble చెయ్యాలి?
బాగా, మీరు కేవలం రివర్స్ ఉద్గాతాలు మరియు ఇన్పుట్లను.
>> ఇతర మాటలలో, ఎవరైనా ఒకసారి మీ గుప్తీకరించిన సందేశాన్ని అందుకుంటుంది,
అతను లేదా ఆమె కేవలం ఉంది అదే కీ తెలుసుకోవటానికి.
వారు సాంకేతికపాఠం అందింది.
మరియు ఆ రెండు పూరించే ద్వారా క్రిప్టో వ్యవస్థ ఇన్పుట్లను,
అల్గోరిథం, ఈ బ్లాక్ బాక్స్ బయటకు అసలు సాదా రావాల్సిందే.
కాబట్టి చాలా అధిక స్థాయి గూఢ లిపి శాస్త్రం అసలు దృష్టిలో
అన్ని గురించి.
>> కాబట్టి యొక్క పొందండి తెలియజేయండి.
ఇప్పుడు క్రింద చూద్దాం ఏదో హుడ్
మేము మంజూరు కోసం తీసుకొని చేసిన గత వారం, మరియు ఈ సెషన్
స్ట్రింగ్ ఇక్కడ.
రోజు చివరిలో ఒక స్ట్రింగ్ కేవలం అక్షరాలు క్రమం.
>> అది హలో ప్రపంచ, లేదా హలో, Zamyla, లేదా సంసార.
అయితే అది అర్థం ఏమిటి అక్షరాలు క్రమం ఉంటుంది?
నిజానికి, CS50 లైబ్రరీ ఇస్తుంది మాకు స్ట్రింగ్ అనే డేటా రకం.
>> కానీ నిజానికి ఉండదు C. లో ఒక స్ట్రింగ్ వంటి విషయం
ఇది నిజంగా కేవలం ఒక వరుస క్రమం పాత్ర, పాత్ర, పాత్ర,
పాత్ర, తిరిగి, కు, వెనుకకు తిరిగి, వెనుకకు లోపల వెనుకకు
మీ కంప్యూటర్ యొక్క మెమరీ, లేదా RAM యొక్క.
మరియు మనము ఆ లోతుగా పరిశీలిస్తాము భవిష్యత్తులో మేము శ్రేణితో చూస్తున్నప్పుడు
మరియు వినియోగం, మరియు ఉన్నట్టుగా బెదిరింపులు.
>> కానీ యొక్క స్ట్రింగ్ Zamyla పరిశీలిద్దాం.
కాబట్టి కేవలం పేరు ఇక్కడ మానవ, Zamyla,
ఆ వరుస క్రమం అక్షరాలు, Z- ఒక-M- వై ఎల్ ఎ.
ఇప్పుడు యొక్క అనుకుందాం తెలియజేయండి అని, Zamyla యొక్క పేరు కంప్యూటర్ లోపల నిల్వ ఉంది
ప్రోగ్రామ్.
>> సరే, మేము తప్పక కారణం ఉంది ఆ అక్షరాలు చూడండి చెయ్యగలరు
వ్యక్తిగతంగా.
నేను కొంచెం డ్రా వెళుతున్న ఇక్కడ Zamyla యొక్క పేరు చుట్టూ బాక్స్.
మరియు అది సి లో కేసు ఉన్నప్పుడు మీరు ఆ Zamyla-- మరియు ఉండవచ్చు వంటి, ఒక స్ట్రింగ్ కలిగి
ఆ స్ట్రింగ్ నుండి తిరిగి వచ్చిన స్ట్రింగ్ వంటి ఫంక్షన్,
మీరు నిజంగా చేయవచ్చు పాత్ర ద్వారా అది పాత్ర.
>> ఇప్పుడు, ఈ కోసం సంబంధించి ఉంది చేతిలో, ఎందుకంటే సంభాషణ
నిఘూడ లేఖనంలో మీరు మార్చడానికి అనుకుంటే B కి, మరియు B C వరకు, మరియు D సి ఎ,
మొదలగునవి, మీరు చెయ్యగలరు అవసరం వ్యక్తిగత అక్షరాలు చూడండి
ఒక స్ట్రింగ్ లో.
మీరు మార్చడానికి ఉండాలి ఏదో, ఒక Z కు
ఏదో అధికారి M వేరే, మరియు అందువలన న ఏదో.
అందువలన మేము ఒక మార్గం అవసరం, programmatically, కాబట్టి
సి లో, మాట్లాడటం మార్చగలరు ఉండాలి మరియు వ్యక్తిగత అక్షరాలు చూడండి.
క్రింది విధంగా మేము చేయవచ్చు.
>> నాకు CS50 IDE లో తిరిగి తల వెళ్ళి తెలపండి.
మరియు నాకు ముందుకు తెలియజేయండి ఒక కొత్త ఫైలు సృష్టించవచ్చు
నేను ఈ సమయంలో string0 పిలుస్తాను, మా మొదటి అలాంటి ఉదాహరణగా, డాట్ సి.
మరియు నేను ముందుకు వెళ్ళడానికి వెళుతున్న ఉద్యమాలపై దానిని విప్.
>> కనుక cs50.h ఉన్నాయి, మరియు అప్పుడు ప్రామాణిక io.h ఉన్నాయి,
ఇది నేను దాదాపు ఎల్లప్పుడూ వెళుతున్న కనీసం, నా కార్యక్రమాలు ఉపయోగించి
ప్రారంభంలో.
ప్రధాన గర్జన Int, మరియు అప్పుడు ఇక్కడ నేను ఉన్నాను తీగలను చేయబోవడం స్ట్రింగ్ పొందండి పొందుతాడు.
ఆపై నేను వెళుతున్న ముందుకు వెళ్ళి దీన్ని.
నేను ముందుకు వెళ్లాలని మీరు మరియు, ఒక తెలివి తనిఖీ,
కేవలం చెప్పటానికి, హలో, శాతం లు, సెమీ కోలన్, స్ట్రింగ్ 0 చేస్తుంది.
అయ్యో, నేను ఇక్కడ ఏం చేసావ్?
ఓహ్, నేను దానిని ప్రదర్శించాడు లేదు.
కాబట్టి పాఠం, నేర్చుకునే కావాలని కాదు.
>> కాబట్టి లోపం, మరింత శాతం డేటా వాదనలు కంటే మార్పిడులు.
మరియు ఈ లో, పేరు లైన్ 7-- సరే, నేను కలిగి,
కోట్ unquote, ఆ printf నా స్ట్రింగ్.
నేను ఒక శాతం సైన్ పొందారు.
కానీ నేను మిస్ చేస్తున్నాను రెండవ వాదన.
>> నేను కామా లు, మిస్ చేస్తున్నాను ఇది నేను గత ఉదాహరణలు ఉన్నాయి.
కనుక ఒక మంచి అవకాశం పరిష్కరించడానికి ఒకటి కంటే తప్పు, అనుకోకుండా.
ఇప్పుడు నాకు అమలు అనుమతిస్తాయి string0 లో, Zamyla రకం.
Zamyla హలో, సరే.
>> కాబట్టి మేము ఈ రకమైన కార్యక్రమం అమలు చేసిన ఇప్పుడు కొన్ని వేర్వేరు సమయాల్లో.
కానీ యొక్క ఏదో ఒక తెలియజేసేలా కొద్దిగా భిన్నంగా ఈ సమయంలో.
బదులుగా కేవలం Zamyla యొక్క ముద్రణ printf తో బయటకు మొత్తం పేరు,
పాత్ర అది పాత్ర తెలియజేసేలా.
>> నేను లూప్ ఒక ఉపయోగించడానికి వెళుతున్న.
మరియు నేను ఇవ్వాలని వెళుతున్న ఒక లెక్కించే వేరియబుల్, నేను అని.
నేను iterating ఉంచడానికి వెళుతున్న కాబట్టి, నేను s యొక్క పొడవు కంటే తక్కువ కాలం.
>> ఇది అవుతుంది, మేము కాదు ఈ చివరిసారి చేయండి,
సి ఒక వస్తుంది ఫంక్షన్ స్టిర్లింగ్ అని.
తిరిగి రోజు, మరియు సాధారణంగా విధులు అమలు ఇప్పటికీ ఉన్నప్పుడు,
మానవులు తరచుగా చాలా ఎన్నుకుంటుంది సంక్షిప్తమైన పేర్లను ధ్వని ఆ రకమైన
మీరు ఏమి, అది అయినప్పటికీ వంటి కొన్ని అచ్చులు లేదా లేఖలు లేదు.
కాబట్టి స్టిర్లింగ్ ఉంది ఒక ఫంక్షన్ యొక్క పేరు అని
మధ్య ఒక వాదన పడుతుంది ఒక స్ట్రింగ్ ఉండాలి కుండలీకరణాలు.
మరియు అది కేవలం ఒక పూర్ణాంకం తిరిగి, ఆ స్ట్రింగ్ యొక్క పొడవు.
>> లైన్ 7 న ఈ లూప్ కాబట్టి అన్నారు నేను 0 సమానం లెక్కింపు మొదలు.
దాన్ని పెంచడం జరగబోతోంది ప్రతి పునరావృతం న నేను
1, మేము కొన్ని సార్లు చేయడం చేసిన.
కానీ ఇది కేవలం చేయాలని జరగబోతోంది ఈ అప్ అప్పటివరకూ
నేను పొడవు ఉన్నప్పుడు స్ట్రింగ్ యొక్క.
>> సో ఈ చివరకు ఒక మార్గం, అక్షరాల కంటే iterating
స్ట్రింగ్ లో యధాతథంగా అనుసరిస్తుంది.
నేను ఒక నాటౌట్ ప్రింట్ వెళుతున్న మొత్తం స్ట్రింగ్, కానీ శాతం సి,
ఒక పాత్ర ఒక కొత్త పంక్తి తర్వాత.
ఆపై నేను వెళుతున్న ముందుకు వెళ్ళి, మరియు నేను అవసరం
నేను ప్రింట్ అనుకుందాం s యొక్క ith పాత్ర.
>> నేను సూచిస్తుంది వేరియబుల్ ఉంటే స్ట్రింగ్, పేరు యొక్క ఇండెక్స్
మీరు వీటిని, నేను చెయ్యగలరు అవసరం నాకు s యొక్క ith పాత్ర ఇవ్వాలని, చెప్పగలను.
మరియు సి చేయడం ఒక మార్గం ఉంది చదరపు బ్రాకెట్లలో ఈ.
మీరు కేవలం పేరు చెప్పండి స్ట్రింగ్, ఈ సందర్భంలో లు ఉంది.
అప్పుడు మీరు ఇది చదరపు బ్రాకెట్లలో ఉపయోగించడానికి సాధారణంగా మీ తిరుగు ప్రయాణ లేదా Enter పైన
కీబోర్డ్ మీద కీ.
ఆపై మీరు ఇండెక్స్ చాలు మీరు ముద్రించడానికి కావలసిన పాత్ర.
కాబట్టి ఇండెక్స్ ఒక అవతరిస్తుంది సంఖ్య 0 లేదా 1, లేదా 2, లేదా 3, లేదా డాట్,
డాట్, డాట్, కొన్ని ఇతర సంఖ్య.
>> మరియు మేము అది జరగబోతోంది ఉండేలా కుడి సంఖ్య ఉంటుంది నేను
0 వద్ద లెక్కింపు మొదలు.
సిద్ధ మొదటి మూర్తి ఒక స్ట్రింగ్ లో దీనిపై 0 ద్వారా ఉంది.
మరియు రెండవ పాత్ర బ్రాకెట్ 1 ఉంది.
మరియు మూడవ పాత్ర బ్రాకెట్ 2.
మరియు మీరు చాలా వెళ్లాలనుకుంటే లేదు ఇప్పటివరకు, కాని మేము ఉన్నాము ఎందుకంటే
మాత్రమే అది వరకు నేను పెంచడం అన్నారు స్ట్రింగ్ యొక్క పొడవు సమానం.
మరియు అప్పుడు, లూప్ ఈ ఆగిపోతుంది.
>> నాలో ముందుకు వెళ్లి ఈ అపహసించిరి కార్యక్రమం, మరియు రన్ స్ట్రింగ్ 0 చేస్తాము.
కానీ నేను ఇరుక్కొనిపోయింది.
నిస్సందేహంగా లైబ్రరీ ఫంక్షన్ ప్రకటించారు రకం ఇటువంటి తో స్టిర్లింగ్ మరియు ఇప్పుడు such--,
ఈ తెలిసిన ధ్వనులు.
కానీ అది printf కాదు.
మరియు అది స్ట్రింగ్ పొందండి కాదు.
>> నేను సైన్ అప్ మేకు లేదు అదే విధంగా ఈ సమయం.
అయితే దీనిని ఇక్కడ కొంచెం డౌన్ గమనించవచ్చు మరింత శీర్షిక string.h ఉన్నాయి,
నడిపేవారిని అందించడానికి స్టిర్లింగ్ వాంగ్మూలము.
సో అక్కడ నిజానికి అక్కడ ఒక క్లూ ఉంది.
>> నిజానికి దాన్ని మారుతుంది మరో శీర్షికా ఫైలును ఉంది
మనం ఉపయోగించని చేసిన తరగతి లో ఇంకా, కానీ అది
అందుబాటులో వారిలో మీకు, string.h అని.
మరియు ఆ ఫైలు, string.h లో స్టిర్లింగ్ ప్రకటిస్తారు.
నాలో ముందుకు వెళ్లి ఈ సేవ్ స్ట్రింగ్ చేయడానికి
0 ఉంది నైస్, ఏ లోపం సందేశాలు ఈ సమయంలో.
>> ./string0 Zamyla, మరియు నేను ఎంటర్ నొక్కండి గురించి ఉన్నాను,
ఈ దశలో GetString అన్నారు స్ట్రింగ్ తిరిగి s లో అది చాలు.
లూప్ iterate అన్నారు ఆ ఒక సమయంలో ఒకటి కంటే S యొక్క అక్షరాలు,
మరియు వాటిని, పంక్తికి ఒకటి ప్రింట్ ఎందుకంటే నేను చివరిలో ఆ బాక్ స్లాష్ n వచ్చింది.
నేను ఆ బాక్ స్లాష్ వదిలివేయు కాలేదు n, మరియు కేవలం Zamyla ప్రింట్
అదే లైన్ లో, సమర్థవంతంగా reimplementing
printf అన్ని ఆ ఉపయోగకరంగా ఉంది.
కానీ ఈ సందర్భంలో, నేను ఆ పని చెయ్యలేదు.
నేను నిజానికి ఒక ముద్రిత చేసిన ఒక సమయంలో పాత్ర, లైన్కి
కాబట్టి మేము నిజానికి ప్రభావం చూసే.
>> కానీ నేను ఇక్కడ ఒక విషయం గమనించాలి.
మరియు మేము తిరిగి వచ్చి ఉంటుంది భవిష్యత్ వారంలో ఈ.
ఈ హాజరవుతారు కోడ్ సమర్థవంతంగా బగ్గీ ఉంది.
>> ఇది ఆ స్ట్రింగ్ పొందండి అవుతుంది మరియు జీవితం లో కొన్ని ఇతర విధులు
తప్పనిసరిగా ఎల్లప్పుడూ లేదు మీరు ఆశించే ఏమి తిరిగి.
మేము గత తరగతి నుండి తెలుసు పొందిన ఈ సమయం
స్ట్రింగ్ ఒక స్ట్రింగ్ తిరిగి కోరుకుంటున్నాము.
కానీ ఏమి యూజర్ రకాలైన బయటకు ఉంటే దీర్ఘ పదం లేదా పేరాగ్రాఫ్, లేదా వ్యాసంలో
తగినంత కేవలం ఉందని కంప్యూటర్ లో మెమరీ సరిపోయే.
>> ఇలా, ఏమి ఏదో పోతే హుడ్ కింద తప్పు?
ఇది తరచుగా ఏమి కాదు, కానీ ఒకప్పుడు జరిగి
ఒక సమయంలో, చాలా అరుదుగా.
కాబట్టి ఆ స్ట్రింగ్ అవుతుంది మరియు అది వంటి విధులు అవసరం లేదు
ఎల్లప్పుడూ తీగలను తిరిగి.
వారు కొన్ని లోపం విలువ తిరిగి ఉండవచ్చు, కొన్ని సెంటినెల్ విలువ మాట్లాడటానికి,
ఆ సూచిస్తుంది ఏదో సమస్య ఉంది.
మరియు మీరు మాత్రమే ఈ తెలుసు అని ఇప్పుడు తరగతి లో చదివి వుండడం వల్ల
లేదా కొన్ని మరింత డాక్యుమెంటేషన్ చదవండి కలిగి.
ఇది ఆ స్ట్రింగ్ పొందండి అవుతుంది శూన్య అనే విలువ తిరిగి.
శూన్య మేము చేస్తాము ఒక ప్రత్యేక విలువ భవిష్యత్ వారంలో తిరిగి వస్తారు.
కానీ ఇప్పుడు కోసం, కేవలం నేను అనుకుంటే తెలుసు ముందుకు వెళ్లడానికి నిజంగా సరైన ఉండాలి
స్ట్రింగ్ ఉపయోగించి, నేను కేవలం కాల్ కాదు,
మరియు గుడ్డిగా తిరిగి విలువ ఉపయోగించడానికి, అది ఒక స్ట్రింగ్ ఉంది నమ్ముతూ.
>> నేను మొదటి, చెప్పాలి హే, మాత్రమే, ఒక నిమిషం వేచి
లు సమానం కాదు ఉంటే వెళ్లండి శూన్య పేరు శూన్య, మళ్ళీ,
కేవలం కొన్ని ప్రత్యేక విలువ.
మరియు అది మాత్రమే ప్రత్యేక విలువ వార్తలు మీరు స్ట్రింగ్ గురించి ఆందోళన అవసరం.
స్ట్రింగ్ గాని అన్నారు పొందండి ఒక స్ట్రింగ్ లేదా శూన్య తిరిగి.
>> మరియు ఈ ఆశ్చర్యార్థకం పాయింట్ సైన్ సమానం మీరు బహుశా గణిత తరగతి నుండి తెలిసిన
మీతో సమాన సైన్ డ్రా ఉండవచ్చు ద్వారా లైన్ సమానం కాదు సూచించడానికి.
ఆ సాధారణంగా ఒక పాత్ర కాదు మీరు మీ కీబోర్డు మీద టైప్ చేయవచ్చు.
అందుకనే ప్రోగ్రామింగ్ భాషల్లో, మీరు సమానంగా కాదు చెప్పే,
మీరు ఒక ఆశ్చర్యార్థకం పాయింట్ ఉపయోగించండి, లేకపోతే బ్యాంగ్ అని పిలుస్తారు.
సో మీరు బ్యాంగ్ సమానం చెప్పవు న్యాయంగా, సమానం అర్థం.
ఇది ఒక గొప్ప అక్కడ కాదు కేవలం వంటిది కంటే, లేదా కంటే తక్కువ సమానంగా, లేదా
లేదా మీ కీబోర్డు మీద కీ సమానంగా ఒక చిహ్నంగా అది అన్ని చేస్తుంది.
కాబట్టి ఆ వై గత ఉదాహరణలలో, మీరు ఒక ఓపెన్ బ్రాకెట్, ఆపై
సమాన సైన్, క్రమంలో చేయాలి కంటే ఎక్కువ లేదా, చెప్పటానికి కంటే తక్కువ.
>> సో వాట్ ఇక్కడ takeaway ఏమిటి?
ఈ సాధారణంగా ఇప్పుడు ఒక మార్గం ఈ వాక్యనిర్మాణం పరిచయం, ఈ ఫీచర్
వ్యక్తిగత పైగా iterating ఒక స్ట్రింగ్ లో అక్షరాలు.
మరియు కేవలం ఆ చదరపు బ్రాకెట్లలో, మీరు వాటిని పొందడానికి అనుమతిస్తుంది
ఆ చదరపు బ్రాకెట్లలో పరిగణలోకి రకమైన ఈ అంతర్లీన తెలుపుతున్న ఈ నిక్షిప్త
డిజైన్, ఇందులో ప్రతి ఒక స్ట్రింగ్ లోపల పాత్ర
రకమైన కింద ఎక్కడో లో బాక్స్డ్ ఉంది మీ కంప్యూటర్ యొక్క మెమరీ లో హుడ్.
>> కానీ యొక్క ఈ యొక్క ఒక వైవిధ్యం తయారు చేద్దాము.
ఈ హాజరవుతారు ప్రోగ్రామ్ సరైనది.
కాబట్టి CS50 యొక్క అక్షాలు శాతం లెక్కించడంలో కోడ్, ఈ ఇప్పుడు సరైనది.
ముఖ్యంగా ఇప్పుడు నేను తనిఖీ చేస్తున్నాను అని శూన్య, ఈ కార్యక్రమం క్రాష్ ఎప్పుడూ.
మరియు నేను అనుభవం నుండి తెలుసు.
కానీ వేరే ఏదీ లేదు మేము నిజంగా ఇక్కడ తప్పు వెళ్ళవచ్చు.
కానీ అది చాలా బాగా రూపకల్పన లేదు, యొక్క బేసిక్స్ తిరిగి వెళ్ళి తెలపండి ఎందుకంటే.
>> మొదటి, principles-- లూప్ ఒక ఏమి చేస్తుంది?
లూప్ ఒక మూడు పనులు.
ఇది కొన్ని ప్రారంభించటానికి విలువ, మీరు దానిని అడిగితే.
ఇది ఒక పరిస్థితి వెతుకుతుంది.
మరియు ప్రతి తర్వాత మళ్ళా, ప్రతి చక్రం తర్వాత,
అది కొన్ని ఇంక్రిమెంట్ విలువ, లేదా విలువల ఇక్కడ.
>> కాబట్టి ఆ అర్థం ఏమిటి?
మేము నేను 0 ప్రారంభించడం.
మేము తనిఖీ నిర్ధారించుకోండి నేను కంటే తక్కువ ఉంది ఇది Z-A-M- వై ఎల్-A గా s యొక్క పొడవు,
కాబట్టి 6 కంటే తక్కువ.
మరియు, నిజానికి, 0 6 కంటే తక్కువగా.
>> మేము Zamyla యొక్క పేరు నుండి Z ప్రింట్.
అప్పుడు మేము i పెంచడం 0 నుండి 1 కు.
మేము అప్పుడు, తనిఖీ 1 తక్కువ ఉంది s యొక్క పొడవు కంటే?
లు పొడవు 6.
అవును, అది ఉంది.
>> కాబట్టి మేము Zamyla యొక్క పేరు, ZA ఒక ప్రింట్.
మేము i 0, 1, 2 వరకు పెంచడం.
మేము అప్పుడు, తనిఖీ కంటే 2 తక్కువ Zamyla యొక్క పేరు యొక్క పొడవు.
6- కాబట్టి 2 6 కంటే తక్కువగా ఉంటుంది.
అవును, యొక్క ఎం ఇప్పుడు ప్రింట్ తెలియజేయండి Zamyla యొక్క పేరు, మూడవ పాత్ర.
>> ఇక్కడ కీ ప్రతి చెప్పును కథ మళ్ళా, నేను తనిఖీ చేస్తున్నాను,
నేను Zamyla యొక్క పొడవు కంటే తక్కువ?
కానీ క్యాచ్ ఉంది స్టిర్లింగ్ స్వభావము కాదు.
ప్రోగ్రాం చేశారు ఎవరు మీరు యొక్క ఆ జావా లేదా ఇతర భాషలలో ముందు
ఒక స్ట్రింగ్ యొక్క పొడవు తెలిసిన ఒక ఆస్తి, కేవలం కొన్ని మాత్రమే విలువ చదవండి.
>> ఈ విషయంలో సి లో, ఉంటే ఈ ఉంది అక్షరాలా అని ఒక ఫంక్షన్
సంఖ్యపై ప్రతిసారీ Zamyla అక్షరాలు
మేము ఆ ఫంక్షన్ కాల్.
మీరు ఉపయోగించడానికి కంప్యూటర్లో అడగండి ప్రతిసారీ స్టిర్లింగ్, అది Zamyla పరిశీలించి తీసుకొని
మరియు మాట్లాడుతూ Z-A-M- వై ఎల్-ఎ, 6.
మరియు అది 6 తిరిగి.
మీరు కాల్ తదుపరి సమయం లూప్ ఆ లోపలి,
ఇది Zamyla చూడండి జరగబోతోంది మళ్ళీ, చెప్పటానికి Z-A-M- వై ఎల్-ఎ, 6.
మరియు అది 6 తిరిగి వెళుతున్న.
కాబట్టి ఈ డిజైన్ గురించి స్టుపిడ్?
>> ఎందుకు నా ఒక 5 బయటకు 5 కోడ్ ప్రస్తుతం రూపకల్పనకు, మాట్లాడటానికి?
Well, నేను అడగడం నేను ఒక అనవసరంగా ప్రశ్న.
నేను అవసరం కంటే నేను ఎక్కువ పని చేస్తున్నాను.
>> కాబట్టి అయినప్పటికీ సమాధానం నేను సరైనది
కంప్యూటర్ అడుగుతూ, ఏమిటి మళ్ళీ, Zamyla యొక్క పొడవు,
మళ్ళీ, మళ్ళీ, మళ్ళీ?
మరియు ఆ సమాధానం మార్చడానికి ఎప్పుడూ వెళుతున్న.
ఇది ఎల్లప్పుడూ 6 చేస్తాడు.
>> ఈ కంటే సో ఒక మంచి పరిష్కారం ఈ తదుపరి వెర్షన్ అని.
నాకు ముందుకు వెళ్లి ఒక లో ఉంచండి string1.c అని ప్రత్యేక ఫైలు,
కేవలం అది వేరుగా ఉంచడానికి.
మరియు అది ఒక హాజరవుతారు లూప్, మీరు వాస్తవానికి
ఒకేసారి బహుళ వేరియబుల్స్ డిక్లేర్.
>> నేను నేను ఉంచడానికి మరియు 0 దాన్ని సెట్ వెళుతున్న.
కానీ నేను కూడా వెళుతున్న ఒక కామా జోడించడానికి, మరియు సే
నాకు n అనే వేరియబుల్, దీని ఇవ్వాలని విలువ స్ట్రింగ్ s యొక్క పొడవు సమానం.
మరియు ఇప్పుడు, నా పరిస్థితి దయచేసి కాబట్టి నేను కంటే తక్కువ n వంటి.
>> కాబట్టి ఈ విధంగా, తర్కం రోజు చివరిలో ఒకేలా.
కానీ నేను గుర్తు చేస్తున్నాను విలువ 6, ఈ విషయంలో.
Zamyla యొక్క పేరు యొక్క పొడవు ఏమిటి?
మరియు నేను n ఉంచారు చేస్తున్నాను.
>> మరియు నేను ఇప్పటికీ తనిఖీ చేస్తున్నాను పరిస్థితి ప్రతిసారీ.
0 6 కంటే తక్కువ?
1 6 కంటే తక్కువ?
6 కంటే 2 తక్కువ, మొదలగునవి?
>> కానీ నేను కంప్యూటర్ అడగడం లేదు మళ్ళీ, మళ్ళీ, ఏమిటి
Zamyla యొక్క పేరు యొక్క పొడవు?
Zamyla యొక్క పేరు యొక్క పొడవు ఏమిటి?
ఈ Zamyla యొక్క పేరు యొక్క పొడవు ఏమిటి?
నేను వాచ్యంగా గుర్తు చేస్తున్నాను మొదటి మరియు ఈ రెండవ వేరియబుల్ n లో మాత్రమే సమాధానం.
కాబట్టి ఈ ఇప్పుడు మాత్రమే అవుతుంది సరి, కానీ కూడా బాగా రూపకల్పన.
>> ఇప్పుడు, శైలి గురించి ఏమి?
నేను నా వేరియబుల్స్ అనే చేసిన అందంగా బాగా, నేను చెబుతా.
వారు ప్రస్తుతం సూపర్ క్లుప్తమైన.
మరియు ఆ పూర్తిగా మంచిది.
>> మీరు కేవలం ఒక కలిగి ఉంటే ఒక కార్యక్రమం లో స్ట్రింగ్
మీరు అలాగే అది స్ట్రింగ్ కోసం s కాల్ ఉండవచ్చు.
మీరు మాత్రమే ఒక వేరియబుల్ కలిగి ఉంటే ఒక కార్యక్రమంలో లెక్కింపు కోసం,
మీరు అలాగే నేను కాల్ ఉండవచ్చు.
మీరు ఒక పొడవు కలిగి ఉంటే, n అలాగే సూపర్ సాధారణం.
కానీ నేను నా కోడ్ ఏ వ్యాఖ్యానించాడు.
>> నేను reader-- తెలియజేయలేదని చేసిన నా TF, టిఎ అయినా,
లేదా కేవలం కోరుకుంటున్నాము ఏమి colleague-- ఈ కార్యక్రమంలో లో వెళ్ళడం.
కాబట్టి మంచి శైలి పొందడానికి, నేను చేయాలనుకుంటున్నారా ఏమి
దీన్ని విషయం వంటి ఇన్పుట్ కోసం వినియోగదారు అడగండి.
నేను తిరిగి భావిస్తున్నారు మార్గాల్లో సంఖ్య ఈ.
>> చేయండి s-- ఖచ్చితంగా పొందండి నిర్ధారించుకోండి స్ట్రింగ్ ఒక స్ట్రింగ్ తిరిగి.
మరియు ఇక్కడ అప్పుడు మరియు ఈ బహుశా ఉంది అతి ముఖ్యమైన comment-- iterate
ఒక సమయంలో ఒక దానివెంట ఒకటి లో అక్షరాల కంటే.
నేను ఏ వాడవచ్చు ఇంగ్లీష్ భాష యొక్క ఎంపిక
ఇక్కడ ప్రతి వివరించడానికి కోడ్ యొక్క ఈ రాళ్లను.
>> నేను ఒక పెట్టలేదు గమనించవచ్చు కోడ్ యొక్క ప్రతి లైన్ మీద మీరే,
నిజంగా కేవలం ఆసక్తికరమైన న వాటిని, వాటిని ఆ
కొన్ని అర్థం కలిగి నేను వాటిని ఎవరైనా సూపర్ స్పష్టంగా అనుకుంటున్నారా
నా కోడ్ చదవడం.
ఎందుకు మీరు పొందుటకు పిలుపునిస్తున్నాయి స్ట్రింగ్ ఇన్పుట్ వినియోగదారుని అభ్యర్థించడం?
కూడా ఒక అవసరం లేదు అన్ని వివరణాత్మక.
కానీ అది ఒక కథను సహాయపడుతుంది ఎందుకంటే కథలో రెండవ లైన్ నిర్ధారించుకోండి
స్ట్రింగ్ పొందండి ఒక స్ట్రింగ్ తిరిగి.
>> కథలోని మూడవ లైన్ ఉంది ఏడాదిన్నరలో లో అక్షరాల కంటే iterate
ఒక సమయంలో.
ఇప్పుడు కేవలం మంచి కొలత కోసం, నేను ముందుకు వెళ్లి జోడించండి వెళుతున్న
ఒకటి కంటే వ్యాఖ్యను కేవలం s లో ప్రింట్ నేను-వ పాత్ర అన్నారు.
ఇప్పుడు, ఏమి నేను చేసిన రోజు చివరిలో?
>> నేను కొన్ని ఆంగ్ల చేర్చారు వ్యాఖ్యలు రూపంలో పదాలు.
స్లాష్ స్లాష్ చిహ్నం, హే, కంప్యూటర్ ఈ మానవ కోసం,
మీరు కోసం కాదు, కంప్యూటర్.
కాబట్టి అవి తార్కికంగా నిర్లక్ష్యం చేస్తున్నారు.
వారు అక్కడే ఉన్నారు.
>> మరియు, నిజానికి, CS50 IDE వాటిని చూపిస్తుంది బూడిద, ఉపయోగకరమైన, కానీ కీ ఉండటం వంటి
కార్యక్రమానికి.
మీరు ఇప్పుడు ఏమి గమనించి.
మీరు C తెలుసు అని ప్రోగ్రామింగ్ లేదా, మీకు
ఈ వద్ద తిరిగి నిలవదు కార్యక్రమం మరియు వ్యాఖ్యల చెడిపోయిన.
నిర్ధారించుకోండి, ఇన్పుట్ యూజర్ అడగండి స్ట్రింగ్ ఒక స్ట్రింగ్ తిరిగి పొందడానికి,
లు లో అక్షరాల కంటే iterate ఒక సమయంలో ఒక పాత్ర ప్రింట్
i-th పాత్ర s-- మీరు లేదు కూడా కోడ్ చూడటానికి కలిగి
ఈ కార్యక్రమం ఏమి అర్థం.
మరియు, మంచి ఇంకా, మీరే చూడండి ఒక వారం లేదా రెండు ఈ కార్యక్రమం,
లేదా ఒక నెల, లేదా ఒక సంవత్సరం, మీరు చాలా లేదు
కోడ్ తీక్షణముగా, గుర్తు ప్రయత్నిస్తున్న,
నేను ఈ కోడ్ తో ప్రయత్నిస్తున్న?
>> మీకు మీరే తెలిపియున్నాను.
మీరు మీ కోసం ఇది వివరించిన చేసిన, లేదా కొన్ని సహోద్యోగి, లేదా TA లేదా TF.
కాబట్టి ఈ ఇప్పుడు ఉంటుంది సరైన, మరియు మంచి డిజైన్,
మరియు చివరికి మంచి శైలి అలాగే.
కాబట్టి గుర్తుంచుకోండి లేదు.
>> కాబట్టి ఇతర ఒక ఉంది విషయం నేను ఇక్కడ చేయ బోతున్నాను
ఇప్పుడు సరిగ్గా ఏమిటి చాటుతుంది హుడ్ కింద జరగబోతోంది.
కాబట్టి ఈ ఫీచర్ C, మరియు ఇతర భాషలలో,
ఒకే రకం పాత్రలు చేయడం అనే గాని పరిపూర్ణంగా
లేదా స్పష్టంగా మీరు మార్చేందుకు అనుమతిస్తుంది ఒక డేటా రకాన్ని మరొక నుండి.
కాబట్టి మేము వ్యవహరించే చేసిన తీగలను ఇప్పటివరకు నేడు.
>> మరియు తీగలను పాత్రలు.
కానీ వారం నుండి రీకాల్ 0, అక్షరాలు ఏవి?
పాత్రలు కేవలం ఒక సంగ్రహణం ఉన్నాయి సంఖ్యల దశాంశ సంఖ్యలు పైన,
మరియు దశాంశ సంఖ్యలు కేవలం ఒక నిజంగా ఉన్నాయి ద్వియాంశ సంఖ్యల యొక్క పైన నైరూప్యత,
మేము అది నిర్వచించిన.
>> కాబట్టి అక్షరాలు నంబర్లు.
మరియు సంఖ్యలను అక్షరాలు ఉంటాయి, కేవలం సందర్భం బట్టి.
మరియు అది లోపల అవుతుంది ఒక కంప్యూటర్ ప్రోగ్రామ్ యొక్క,
మీరు చూడవచ్చు ఎలా పేర్కొనవచ్చు ఆ ప్రోగ్రాం యొక్క లోపల బిట్స్?
>> వారం 0 మేము ఉందని నుండి రీకాల్ ఇది కేవలం ఈ కోడ్ చేసిన ASCII,
సంఖ్యలు మ్యాపింగ్ అక్షరాలు.
మరియు మేము రాజధాని 65, అన్నాడు.
రాజధాని B మొదలగునవి 66, మరియు.
>> మరియు నోటీసు, మేము తప్పనిసరిగా అక్షరాలు కలిగి ఇక్కడ పై వరుస, సి వాటిని అంటారని వంటి,
అక్షరాలు, ఆపై రెండవ వరుసలో మీద ints.
మరియు మీరు మార్చగలదు అవుతుంది seamlessly రెండు, సాధారణంగా మధ్య.
మరియు మేము అలా అనుకుంటే ఉద్దేశపూర్వకంగా, మేము
అధిగమించేందుకు అనుకోవచ్చు ఇలాంటిది ఏదైనా.
>> మేము మార్చే కావలసిన ఉండవచ్చు తగ్గుతాయని అప్పర్ కేస్
కేసు, లేదా అప్పర్ కేస్ తక్కువ కేసు.
మరియు అది ఉంది హాజరవుతారు ఇక్కడ నిజానికి ఒక నమూనా
మేము కేవలం ఒక క్షణం లో స్వీకరించి.
కానీ యొక్క ఒక వద్ద మొదటి చూద్దాం ప్రత్యేకంగా ఈ చేయడం ఉదాహరణ.
>> నేను CS50 IDE తిరిగి వెళ్ళడానికి వెళుతున్న.
నేను ఒక సృష్టించడానికి వెళుతున్న ASCII 0.c. అనే ఫైల్
మరియు నేను ముందుకు వెళ్లి జోడించండి వెళుతున్న నా ఎగువన ప్రామాణిక io.h, Int ప్రధాన గర్జన
నా ఫంక్షన్ ఎగువన.
మరియు తర్వాత నేను చేయ బోతున్నాను నేను సమానం నుండి లూప్ ఒక కింది,
సే, 65 వీలు.
>> ఆపై నేను కంటే తక్కువ అవతరిస్తుంది వర్ణమాలలో 65, ప్లస్ 26 అక్షరాలు.
కాబట్టి నేను కంప్యూటర్ తెలియజేస్తాము అక్కడ నాకు గణిత చేయండి.
మరియు ఈ లూప్ లోపల, నేను ప్రింట్ వెళ్తున్నాను?
>> % సి ఐ బ్యాక్స్లాష్ n% ఉంది.
ఇప్పుడు నేను రెండు విలువలు ప్లగ్ అనుకుంటున్నారా.
నేను తాత్కాలికంగా ప్రశ్న ఉంచాము ప్రశ్న ఆహ్వానించడానికి ఉంది సూచిస్తుంది.
>> నేను తరువాత 65 నుండి iterate మీరు వర్ణమాల యొక్క 26 అక్షరాలు కోసం,
ప్రతి పునరావృతం న ముద్రించి ఆ పాత్ర యొక్క సమగ్ర సమానమైన.
ఇతర మాటలలో, నేను కావలసిన పైగా 26 సంఖ్యలు ముద్రణ iterate
ASCII అక్షరాల ఏమిటి, లేఖ, మరియు సంబంధిత సంఖ్య మాదిరిగా ఏమి
నిజంగా కేవలం పునః స్లయిడ్ నుండి చార్ట్.
కాబట్టి అయితే ఈ ప్రశ్నార్థకాలుగా ఉండాలి?
>> సరే, రెండవ హాజరవుతారు ఒక కేవలం వేరియబుల్ నేను ఉండాలి.
నేను అనేక ఆ చూడాలనుకుంటే.
మరియు మధ్య వాదన ఇక్కడ, నేను కంప్యూటర్ తెలియజేయవచ్చు
ఆ పూర్ణాంక చికిత్స నేను ఒక పాత్రగా ఉంటుంది కాబట్టి
శాతం సి కోసం ఇక్కడ ప్రత్యామ్నాయంగా
>> ఇతర మాటలలో, నేను, మానవ ప్రోగ్రామర్, తెలిసిన
ఈ కేవలం సంఖ్యలు రోజు చివరిలో.
నేను 65 తప్పక తెలుసు కొన్ని పాత్ర మ్యాప్.
ఈ స్పష్టమైన తారాగణం తో ఒక కుండలీకరణములలో తో,
మీకు కావలసిన డేటా రకం పేరు మార్చుకునేందుకు, మరియు ఒక సంవృత కుండలీకరణములలో
మీకు చెప్తాను కంప్యూటర్, హే, కంప్యూటర్,
ఒక చార్ ఈ పూర్ణాంక మారుస్తాయి.
>> నేను ఈ అమలు ప్రోగ్రాం కంపైల్ తర్వాత,
యొక్క నేను ASCII 0 చేస్తాము పొందుతారు ఏమి చూద్దాం.
అది రంధ్రాన్ని సరి చేయు, నేను ఇక్కడ ఏమి చేస్తారు?
అస్పష్టమైన గుర్తింపు, అన్ని కుడి, కావాలని కాదు,
కానీ యొక్క చూసేలా ఉంటే మేము కాదు ఈ ద్వారా కారణం.
>> కాబట్టి లైన్ నేను రాలేదు five-- చాలా దూరం అప్ screwing ముందు.
పరవాలేదు.
నేను లైన్ 5 సమానం 65-- నేను చూడండి.
కాబట్టి కొన్ని వలె, సి లో గుర్తు మీరు ముందు ప్రోగ్రామింగ్ కలిగి ఉంటే భాషలు
అనుభవం, మీరు కంప్యూటర్ చెప్పడం,
స్క్రాచ్ కాకుండా, ఏమి వేరియబుల్ రకం ఇది.
>> నేను ఇక్కడ ఒక ముఖ్యమైన పదబంధం మర్చిపోయారు.
లైన్ ఐదు, నేను ఉపయోగించడం ప్రారంభించాను.
కానీ నేను సి చెప్పారు లేదు ఏమి డేటా రకం ఇది.
సో నేను ఇక్కడ వెళ్ళండి వెళుతున్న మరియు చెప్పేది అబ్బా, అది ఒక పూర్ణాంకం చేస్తాయి.
>> ఇప్పుడు నేను ముందుకు వెళ్లి మళ్ళీ కంపైల్ వెళుతున్న.
ఆ పరిష్కరించబడింది.
./ascii0 Enter, చల్లని రకంగా.
అది సూపర్ ఫాస్ట్ ఉంది కంప్యూటర్ ఈ ప్రశ్న అడగండి
బదులుగా ఒక స్లయిడ్ లో దానిని చూడటం కంటే , పంక్తికి ఒకటి ముద్రించిన 65 ఉంది,
B అప్పటినుండి down-- 66, అన్ని మార్గం అక్షరాలు z ఈ 26 times-- చేసింది,
ఇది 90 ఉంది.
మరియు, నిజానికి, కొద్దిగా మరింత తెలివైన చేస్తాను
నాకు ఉన్నాయి ఆధారపడేవారు కాదు కంప్యూటర్లో 26 జోడించడానికి.
నేను పూర్తి కాలేదు 90 అలాగే, చాలా కాలం
నేను రెండుసార్లు అదే తప్పు లేదు.
నేను గుండా వెళ్లాలనుకుంటే z, కేవలం వై ద్వారా.
>> కాబట్టి ఒక స్పష్టమైన తారాగణం వార్తలు.
ఈ హాజరవుతారు కూడా అవసరం లేదు.
నాకు ముందుకు వెళ్లి ఈ తిరిగి లెట్ కంపైలర్, మరియు గణగణమని ASCII 0.
ఇది సి అందంగా స్మార్ట్ అని హాజరవుతారు.
>> మరియు printf, ముఖ్యంగా, చాలా స్మార్ట్ ఉంది.
మీరు కేవలం రెండుసార్లు ఒక నేను పాస్ ఉంటే రెండు placeholders, printf
, గ్రహిస్తారు OH, బాగా నేను మీకు తెలుసా నాకు ఒక కొన్ని సంఖ్య పూర్ణాంకం కలిగించింది,
65 లేదా 90 లేదా సంసార వంటి.
కానీ, నేను మీరు నాకు కావలసిన చూడండి ఒక పాత్ర వలె ఆ సంఖ్యను ఫార్మాట్.
కాబట్టి printf పరిపూర్ణంగా తారాగణం ది అలాగే మీరు ఒక చార్ Int.
సో అన్ని వద్ద ఒక సమస్య కాదు.
>> కాని ఈ ఈక్వివాలన్స్ యొక్క, గమనించి మేము నిజంగా అదే చేయవచ్చు.
నాకు ముందుకు వెళ్లి ఒక తయారు చేద్దాము దీన్ని ASCII 1.c. ఇతర వెర్షన్
మరియు బదులుగా పైగా iterating పూర్ణ సంఖ్యలు, నిజంగా మీ మనసును రగిలించు చేయవచ్చు
అక్షరాల కంటే iterating ద్వారా.
ఒక చార్ సి రాజధాని గెట్స్ ఉంటే, నేను ముందుకు వెళ్లి ఈ చేయాలనుకుంటున్నారా,
చాలా కాలం C కంటే తక్కువ లేదా సమానం గా రాజధాని జడ్ మరియు ప్రతి మళ్ళా న
నేను సి పెంచడం అనుకుంటున్నారు, నేను ఇప్పుడు నా printf లైన్ లో ఇక్కడ
సే, శాతం సి శాతం నేను మళ్ళీ, కామా సి
>> మరియు ఇప్పుడు, నేను ఇతర దిశలో వెళ్ళవచ్చు, నడిపేవారిని పాత్ర కాస్టింగ్
పూర్ణాంకం.
సో, మళ్ళీ, ఎందుకు మీరు ఈ చేస్తారు?
ఇది యొక్క క్రమం కొద్దిగా అదృష్టము వార్తలు అక్షరాలు పరంగా చేర్చుకోవడం.
>> కానీ మీరు ఏమి అర్థం ఉంటే హుడ్ కింద జరగబోతోంది,
ఎలాంటి మాయాజాలం నిజంగా ఉంది.
మీరు కేవలం hey, కంప్యూటర్ ఇవ్వాలని, చెబుతున్న నాకు ఒక వేరియబుల్ రకం చార్ సి అని.
రాజధాని A. దాన్ని ప్రారంభించును మరియు సింగిల్ కోట్స్ విషయం గమనించవచ్చు.
>> సి లో పాత్రలకు నుండి గుర్తుకు గత వారం, మీరు సింగిల్ కోట్స్ ఉపయోగించడానికి.
తీగల పదాలతో మాటలను, మీరు డబుల్ కోట్స్ ఉపయోగించడానికి.
సరే, కంప్యూటర్, కాబట్టి ఈ పనిని, పాత్ర కాలం కంటే తక్కువ
లేదా z సమానం.
నేను నా ASCII టేబుల్ నుండి తెలిసిన అన్ని ఈ ASCII సంకేతాలు ఆనుకొని ఉన్నాయి.
>> ఏ అంతరాలను ఉంది.
కనుక ఇది కేవలం ఒక Z ద్వారా వార్తలు, ఒక సంఖ్య ప్రతి వేరు.
ఆపై నేను పెంచడం చేయవచ్చు ఒక చార్, నేను నిజంగా అనుకుంటే.
రోజు చివరిలో, అది కేవలం ఒక సంఖ్య.
ఇది నాకు తెలుసు.
సో నేను దానికి 1 జోడించడానికి భావించడం చేయవచ్చు.
>> ఆపై ఈ సమయంలో, నేను సి ప్రింట్ ఆపై సమగ్ర సమానమైన.
ద్విజులు స్పష్టమైన తారాగణం అవసరం లేదు.
నేను printf వీలు కంప్యూటర్ ఫిగర్ విషయాలను,
కాబట్టి ఇప్పుడు నేను అమలు చేస్తే Ascii1./ascii1, తయారు
నేను అలాగే ఖచ్చితమైన ఇదే పొందడానికి.
>> పనికిరాని కార్యక్రమం, ఎవరూ, అయితే నిజానికి సాఫ్ట్వేర్ వ్రాయడానికి అన్నారు
దొరుకుతుందని క్రమంలో, ఏమిటి Z B A పటాలను ఆ సంఖ్య, లేదా, లేక?
మీరు కేవలం అది గూగుల్ చూడాలని, లేదా దానిని చూసి ఆన్లైన్, లేదా అది వెతుక్కోవాల్సిన
ఒక స్లయిడ్, లేదా ఇష్టం.
సో ఇక్కడ ఈ నిజానికి ఉపయోగకరంగా పొందండి లేదు?
>> బాగా, ఆ మాట్లాడే స్లయిడ్, ఉంది గమనించవచ్చు
పెద్దబడి మధ్య ఇక్కడ ఒక వాస్తవ నమూనా మరియు ఆ యాదృచ్ఛికం అని చిన్నబడి.
రాజధాని అని 65 గమనించండి.
చిన్న ఒక 97 ఉంది.
మరియు ఎలా దూరంగా తక్కువ సందర్భంలో?
>> కాబట్టి 65 97 నుండి ఎన్ని దశలను దూరంగా ఉంది?
కాబట్టి 97 మైనస్ 65 32 ఉంది.
కాబట్టి రాజధాని ఒక 65 ఉంది.
మీరు ఆ 32 జోడిస్తే, మీరు ఒక చిన్న పొందండి.
మరియు, సమానమైన, మీరు 32 వ్యవకలనం ఉంటే, మీరు B అదే రాజధానికి తిరిగి పొందడానికి ఫంక్షన్
చిన్న బి, కొద్దిగా సి బిగ్ సి.
>> ఈ అంతరాలను మొత్తం 32 దూరంగా ఉన్నాయి.
ఇప్పుడు, ఈ మమ్మల్ని అనుమతించడం అగుపిస్తుంది మైక్రోసాఫ్ట్ వర్డ్ వంటి ఏదో,
లేదా Google డాక్స్, ఇక్కడ మీరు చూపించిన ప్రతిదీ ఎంచుకోండి మరియు అప్పుడు చెప్పడానికి,
చిన్నబడి అన్ని మార్చడానికి, లేదా ఎగువ కేసు అన్ని మార్చడానికి,
లేదా మొదటి పదం మార్పు అప్పర్ కేస్ శిక్ష.
మేము నిజానికి ఏదో ఒకటి చెయ్యాలి మమ్మల్ని ఆ ఇష్టం.
>> నాకు ముందుకు వెళ్లి ఒక ఫైల్ సేవ్ ఇక్కడ 0.c. చూపడంలో అని
యొక్క ముందుకు వెళ్లి ఒక కార్యక్రమం అప్ రెచ్చిపోయినప్పుడు తెలియజేయండి సరిగ్గా ఈ కింది విధంగా ఆ చేస్తుంది.
కాబట్టి CS50 లైబ్రరీ ఉన్నాయి.
మరియు ప్రామాణిక I / O ఉన్నాయి.
>> నేను ఈ త్వరలోనే తెలుసు.
కాబట్టి నేను అది చాలు వెళుతున్న ఇప్పటికే, string.h,
నేను యాక్సెస్ స్టిర్లింగ్ వంటి విషయాలు,
ఆ తరువాత యధావిధిగా, ప్రధాన గర్జన Int.
ఆపై నేను ముందుకు వెళ్ళడానికి వెళుతున్న మరియు స్ట్రింగ్ పొందండి గెట్స్ తీగలను చేయండి,
కేవలం యూజర్ నుండి ఒక స్ట్రింగ్ పొందండి.
ఆపై నేను వెళుతున్న నా తెలివి తనిఖీ.
స్ట్రింగ్ సమాన శూన్య కాకపోతే, అప్పుడు అది ముందుకు భద్రంగా ఉంది.
నేను ఏమి అనుకుంటున్నారు?
నేను, నేను నుండి 0 సమానం iterate వెళుతున్న మరియు n s యొక్క స్ట్రింగ్ పొడవు.
>> నేను చాలా కాలం ఈ చేయ బోతున్నాను నేను ప్లస్ ప్లస్ n కంటే తక్కువ, మరియు.
ఇప్పటివరకు, నేను నిజంగా కేవలం ఉన్నాను యెదుటనుండి ఆలోచనలను అప్పు.
ఇప్పుడు నేను ఒక శాఖ పరిచయం వెళుతున్న.
>> సో స్క్రాచ్ పేరు తిరిగి అనుకుంటున్నాను మేము రోడ్ లో ఆ ఫోర్కులు కలిగి,
మరియు గత వారం C. లో నేను వెళుతున్న చెపుతాను, స్ i-th పాత్ర
కంటే ఎక్కువ లేదా కేసు తగ్గుతాయని సమాన,
and-- స్క్రాచ్ లో మీరు వాచ్యంగా చేస్తాను మరియు, కానీ సి లో మీరు ఏంపర్సెండ్ చెప్పటానికి,
ampersand-- మరియు s i-th పాత్ర కంటే తక్కువ లేదా కేసు z తగ్గుతాయని సమానం
ఇంట్రెస్టింగ్ ఏదో ఒకటి చూద్దాం.
యొక్క నిజానికి ప్రింట్ ఒక లెట్ ఏ న్యూ లైన్ తో పాత్ర
ఆ స్ట్రింగ్ లో పాత్ర, స్ట్రింగ్ లో i-th పాత్ర.
>> కానీ యొక్క ముందుకు వెళ్లి దాని నుండి 32 వ్యవకలనం.
ఎల్స్ ఉంటే పాత్ర మేము వెతికే స్ట్రింగ్
చిన్న మధ్యే కాదు మరియు చిన్న z, ముందుకు వెళ్ళి
మరియు కేవలం దాన్ని మారకుండా ముద్రించబడింది.
కాబట్టి మేము పరిచయం చేసాము ఈ bracketed సంజ్ఞామానం
వద్ద పొందడానికి మా తీగలను కోసం నేను-వ స్ట్రింగ్ లో పాత్ర.
>> నేను వంటి, కొన్ని నియత తర్కం జోడించిన గత వారం యొక్క వారం ఒకటి, ఇక్కడ మొదటి
నేను నా ప్రాథమిక ఉపయోగించి వెబ్ ఏది అవగాహన
హుడ్ కింద జరగబోతోంది.
యొక్క i-th పాత్ర ఒక కంటే ఎక్కువ లేదా సమాన?
వలె, ఇది 97, లేదా 98 ఉంది, లేదా 99, మొదలగునవి?
>> కానీ అది కూడా తక్కువ లేదా సమానం చిన్న z విలువకు?
మరియు అలా అయితే, ఈ లైన్ అర్థం ఏమిటి?
14, ఈ విధమైన ఉంది మొత్తం ఆలోచన యొక్క బీజ,
తన లేఖలో చూపడంలో కేవలం దాని నుండి 32 తీసివేయడం,
ఈ సందర్భంలో, నేను తెలుసు ఎందుకంటే, ఆ ప్రకారం చార్ట్ ఎలా నా సంఖ్యలు ప్రాతినిధ్యం వహిస్తున్నారు.
కాబట్టి యొక్క ముందుకు వెళ్లి ఈ అమలు అనుమతిస్తాయి, 0.c చూపడంలో కంపైల్ తర్వాత,
మరియు రన్ చూపడంలో 0.
>> యొక్క లాగ టైప్ లెట్ అన్ని చిన్న లో, Zamyla ఎంటర్.
ఇప్పుడు మేము అన్ని పెద్ద Zamyla ఉన్నాయి.
యొక్క అన్ని చిన్న లో రాబ్ లో టైప్ లెట్.
యొక్క అన్ని చిన్న లో జాసన్ ప్రయత్నించండి లెట్.
మరియు మేము తరచుగా వస్తున్నట్లయితే బలవంతంగా క్యాపిటలైజేషన్.
ఒక చిన్న బగ్ ఉందని నేను రకమైన ముందుగా లేదు.
నా కొత్త ప్రాంప్ట్ ముగించాడు గమనించవచ్చు వారి పేర్లు అదే లైన్ లో,
ఇది ఒక చిన్న దారుణంగా అనిపిస్తుంది.
>> నేను ఇక్కడ వెళ్ళండి వెళుతున్న మరియు నిజానికి ఈ కార్యక్రమం చివరిలో
ఒక NEWLINE పాత్రను ప్రింట్.
అంతే.
printf తో, మీరు అవసరం లేదు చరరాశులు లేదా ఫార్మాట్ కోడ్ పాస్.
మీరు వాచ్యంగా కేవలం ముద్రించవచ్చు ఒక NEWLINE అలాంటిదే.
>> కాబట్టి యొక్క ముందుకు వెళ్లి తయారు చేద్దాము మళ్ళీ చూపడంలో 0, అయినప్పుడు తిరిగి, Zamyla.
ఇప్పుడు అది కొద్దిగా prettier ఉంది.
ఇప్పుడు, నా ప్రాంప్ట్ తన సొంత కొత్త లైన్ ఉంది.
కాబట్టి అన్ని జరిమానా మరియు మంచి.
కాబట్టి ఒక మంచి ఉదాహరణ.
కానీ నేను కూడా తప్పనిసరిగా లేదు హార్డ్ కోడ్ 32 అవసరం.
నీకు తెలుసా?
నేను అలా చెప్పడానికి కాలేదు తేడా ఏమిటి గుర్తుంచుకోవాలి.
>> కానీ నాకు తెలుసు ఉంటే నేను తక్కువ కేసు లేఖ,
నేను తప్పనిసరిగా వ్యవకలనం కావలసిన సంసార దూరం చిన్న మధ్య
ఒక పెద్ద ఒక, నేను భావించేందుకు ఉంటే ఎందుకంటే ఇతర అక్షరాల అన్ని ఒకటే
ఆ పని ఉద్యోగం పొందాలి.
కానీ అలా కాకుండా, మీరు ఏమి?
ఇప్పటికీ మరొక విధంగా ఉన్నాయి.
>> నేను ఉన్నట్లయితే ఆ 1.c-- చూపడంలో చెయ్యబడితే ఒక ప్రత్యేక ఫైలు లోకి ఉంచాలి.
యొక్క ఈ క్రింది విధంగా 2.c చూపడంలో తెలియజేసేలా.
నేనిక్కడ ఈ శుభ్రం చేయడానికి వెళుతున్న.
మరియు బదులుగా కూడా కలిగి తెలిసిన లేదా ఆ తక్కువ స్థాయి పట్టించుకోనట్లు
అమలు వివరాలు, నేను బదులుగా రెడీ కేవలం ఒక పాత్ర ప్రింట్ అన్నారు
కోట్ unquote, శాతం సి, మరియు అప్పుడు మరొక ఫంక్షన్ కాల్
ఒక వాదన పడుతుంది ఉనికిలో ఉంది, ఒక పాత్ర, ఈ వంటిది.
>> ఇది ఉంది, సి హాజరవుతారు మరొక ఫంక్షన్ కాల్
, ఎగువ ఇది దాని పేరు సూచిస్తుంది ఒక పాత్ర పడుతుంది
మరియు దాని ఎగువ కేసు చేస్తుంది సమానమైన, మరియు అప్పుడు అది తిరిగి
కాబట్టి printf అని అక్కడ ప్రదర్శించాడు చేయవచ్చు.
అందువలన అయితే, దీన్ని నేను మరొక ఫైల్ పరిచయం అవసరం.
మరొక ఫైల్ ఉంది బయటకు ఇది మారుతుంది మీరు మాత్రమే తరగతి నుండి తెలుసు అని,
ఒక పాఠ్య పుస్తకం, లేదా ఒక ఆన్లైన్ లేదా సూచన, సి type.h. అని
>> నా శీర్షిక మధ్య వరకు జోడించవచ్చు చేస్తే ఫైళ్లు, మరియు ఇప్పుడు తిరిగి కంపైల్ ఈ కార్యక్రమం
capitalize2, ఎంటర్ ./capitalize2.
యొక్క అన్ని లో, Zamyla టైప్ లెట్ చిన్న, ఇప్పటికీ అదే పనిచేస్తుంది.
కానీ మీరు ఏమి?
ఇది ఎగువ కు హాజరవుతారు కొన్ని ఇతర కార్యాచరణను కలిగి ఉంది.
>> మరియు నాకు ఈ పరిచయం తెలియజేయండి వికారంగా విధమైన, ఇక్కడ ఆదేశం
ప్రకటించుకున్నాడు, అయితే మాన్యువల్ మనిషి.
ఇది ఆ చాలా Linux కంప్యూటర్లలో అవుతుంది మనం లినక్స్ ఆపరేటింగ్ ఇక్కడ ఉపయోగిస్తున్నారు వంటి
ఒక ఆదేశాన్ని సిస్టమ్ చెప్పారు ఇది వ్యక్తి అని,
హే, కంప్యూటర్, నాకు ఇవ్వండి కంప్యూటర్ యొక్క మాన్యువల్.
మీరు ఏమి అనుకుంటున్నారు మాన్యువల్ వెతకండి?
>> నేను ఫంక్షన్ చూసేందుకు కావలసిన ఎగువ అని నమోదు చేయండి.
మరియు అది ఒక చిన్న గుప్తమైన కొన్నిసార్లు చదవడానికి.
కానీ మేము ఉన్నాము గమనించవచ్చు లినక్స్ ప్రోగ్రామర్ యొక్క మాన్యువల్.
మరియు అది అన్ని టెక్స్ట్ యొక్క.
మరియు అక్కడ గమనిస్తారు ఇక్కడ ఫంక్షన్ యొక్క పేరు.
ఇది అనే బంధువు ఉంది హాజరవుతారు వ్యతిరేక లేదు ఇది తగ్గించటం జరిగింది.
మరియు సంగ్రహం క్రింద నోటీసు, ఈ ఉపయోగించడానికి మాట్లాడటానికి, man పేజీ పని,
నాకు నేను చెబుతున్నది సి type.h. ఉన్నాయి అవసరం
మరియు నేను ఆచరణలో నుండి తెలుసు.
>> ఇక్కడ, అది నాకు రెండు చూపుతోందని ఫంక్షన్ కోసం నమూనా,
కాబట్టి నేను ఎప్పుడూ ఈ ఉపయోగించడానికి కావాలా నేను వారు ఇన్పుట్గా తీసుకుని ఏమి తెలుసు,
మరియు వారు అవుట్పుట్ తిరిగి ఏమిటి.
ఆపై నేను చదివితే వివరణ, నేను చూడండి
మరింత వివరంగా ఫంక్షన్ ఏమి.
మరింత ముఖ్యంగా, ఉంటే నేను తిరిగి విలువ క్రింద చూడండి,
అది తిరిగి విలువ చెప్పారు మార్పిడి లేఖ ఆ,
లేదా C అసలు ఇన్పుట్ ఉంటే మార్పిడి సాధ్యం కాదు.
>> ఇతర మాటలలో, ఎగువ ప్రయత్నించండి చేస్తాము అప్పర్ కేస్ ఒక లేఖ మార్చేందుకు.
మరియు అలా అయితే, అది తిరిగి వెళుతున్న.
కానీ కొన్ని కారణం అది పోతే బహుశా ఇది ఇప్పటికే ఎగువ కేస్,
దీనికి ఆశ్చర్యార్థకం పాయింట్ లేదా కొన్ని ఇతర punctuation--
అది కేవలం జరగబోతోంది యదార్థ C తిరిగి,
ఇది నేను నా కోడ్ చేయవచ్చు అర్థం మంచి క్రింది విధంగా రూపొందించబడింది.
>> నేను అన్ని అవసరం లేదు కోడ్ యొక్క ఈ రంధ్రాన్ని సరి చేయు పంక్తులు.
నేను చేసిన రేఖల అన్ని కేవలం హైలైట్ చెయ్యవచ్చు
కేవలం ఒక సాధారణ కూలిపోయింది దీన్ని printf శాతం ఇది లైన్,
ఎగువ ఎస్ బ్రాకెట్ నేను సి.
మరియు ఈ ఒక ఉంటుంది మంచి డిజైన్ యొక్క ఉదాహరణకు.
>> ఎందుకు 7 లేదా 8 పంక్తులు అమలు కోడ్ యొక్క, సంసార నేను కేవలం ఉంది
మీరు బదులుగా కూలిపోతుంది ఉన్నప్పుడు, తొలగించిన తర్కానికి మరియు నిర్ణయం తీసుకోవటంలో అన్ని
ఒక్క లైన్, 13 ఇప్పుడు ఆ ఒక లైబ్రరీ ఆధారపడుతుంది ఫంక్షన్
C తో పాటు వచ్చే ఒక విధి, కానీ ఆ మీరు దీన్ని ఖచ్చితంగా ఏమి చేస్తుంది.
మరియు, స్పష్టముగా, కూడా అది సి తో రాలేదు,
మీరు మీరుగా అమలు అవకాశమున్నందున, మేము పొందుటకు ప్రతికూల Int తో చూసిన
మరియు అలాగే అనుకూల Int గత వారం పొందండి.
>> ఈ కోడ్ ఇప్పుడు చాలా చదవదగ్గ.
మరియు, నిజానికి, మేము అప్ స్క్రోల్ చేయండి, ఎంత ఎక్కువ కాంపాక్ట్ చూడండి
నా కార్యక్రమం ఈ వెర్షన్.
అది ఇప్పుడు చిన్న టాప్ హెవీ, ఈ కలిగి తో.
కానీ ఇప్పుడు నేను నిలబడి నేను ఎందుకంటే సరే ప్రోగ్రామర్లు భుజాల మీద
నా ముందు.
మరియు అది ఎవరైతే అయిన నిజంగా ఉన్నత అమలు
చాలా వంటి నాకు అనుకూలంగా ఎవరైతే అతడ్ని అమలు స్టిర్లింగ్ నిజంగా
కొంతకాలం క్రితం నాకు ఒక అనుకూలంగా లేదు.
కాబట్టి ఇప్పుడు మేము ఒక కలిగి మంచి డిజైన్ ప్రోగ్రామ్
ఖచ్చితమైన అదే తర్కం అమలు.
>> స్టిర్లింగ్ మాట్లాడుతూ, వీలు నాకు ముందుకు వెళ్లి ఇలా.
నాకు ముందుకు వెళ్లి సేవ్ చేసేలా ఈ ఫైలు stirling.c వంటి.
మరియు అది అవుతుంది, మేము తిరిగి రాలిపోవడం చేయవచ్చు అందంగా కేవలం ఇప్పుడు మరొక పొర.
నేను ముందుకు విప్ వెళ్ళి వెళుతున్న ప్రధాన మరొక కార్యక్రమం
ఇక్కడ కేవలం తిరిగి అమలుచేసే ఈ క్రింది విధంగా స్ట్రింగ్ పొడవు.
కాబట్టి ఇక్కడ కోడ్ ఒక లైన్ అని నాకు వినియోగదారు నుండి ఒక స్ట్రింగ్ గెట్స్.
మేము మళ్ళీ మళ్ళీ ఈ ఉపయోగించి ఉన్నాను.
నాకు నేనే ఒక వేరియబుల్ అని ఇవ్వాలని లెట్ అనేక నిల్వ రకం Int n.
>> మరియు నాకు ముందుకు వెళ్లి క్రింది తర్కం.
లు n-th పాత్ర ఉన్నప్పటికీ సమాన బాక్ స్లాష్ 0, ముందుకు వెళ్ళి
మరియు n పెంచుతాయి.
ఆపై printf శాతం నేను n ప్రింట్.
నేను ఇక్కడ ఈ కార్యక్రమం క్లెయిమ్, స్ట్రింగ్ పొడవు కాల్ లేకుండా,
ఒక స్ట్రింగ్ యొక్క పొడవు సంఖ్యలు.
>> మరియు మేజిక్ పూర్తిగా లైన్ 8 లో కప్పబడుతుంది
కొత్త వాక్యనిర్మాణం కనిపిస్తుంది ఏమి తో ఇక్కడ, ఈ బాక్ స్లాష్ 0 సింగిల్ కోట్స్ లో.
కాని ఎందుకు అని?
బాగా, అయ్యింది ఏమి పరిగణలోకి అన్ని ఈ సమయంలో జరగబోతోంది.
>> మరియు జనాంతికంగా నేను మర్చిపోతే ముందు, తెలుసుకోవటం చాలా, ఆ వ్యక్తి పేజీల పాటు
ఒక విలక్షణ తో వస్తాయి CS50 IDE వంటి లైనక్స్ సిస్టమ్,
తెలుసుకుంటారు మేము కోర్సు యొక్క సిబ్బంది, కూడా
ఒక వెబ్సైట్ వెర్షన్ చేసిన అని ఈ అదే ఆలోచన
కలిగిన reference.cs50.net, ఆ అదే మనిషి పేజీల అన్ని
అదే అన్ని డాక్యుమెంటేషన్, అలాగే
అనుమతించే ఎగువన ఒక చిన్న బాక్స్ మీరు బొత్తిగా అన్ని మార్చేందుకు
తక్కువ సౌకర్యవంతమైన లోకి మర్మమైన భాష మోడ్, మేము, బోధన సిబ్బంది,
ద్వారా పోయిందో మరియు సరళీకృతం చేయడానికి ప్రయత్నించారు విషయాలను భాషపై కొంత
ఆలోచనల మీద దృష్టి, మరియు technicalities కొన్ని.
సో గుర్తుంచుకోండి, reference.cs50.net అదే విధంగా మరో వనరుగా.
>> కానీ ఎందుకు స్ట్రింగ్ పొడవు పని చేస్తుంది నేను ఒక క్షణం క్రితం ప్రతిపాదించారు మార్గం?
ఇక్కడ Zamyla యొక్క పేరు తిరిగి ఉంది.
మరియు ఇక్కడ, Zamyla యొక్క పేరు నేను చేస్తున్న ఉంచేందుకు వంటి, లో బాక్స్,
ఇది అనే ఒక చిత్రాన్ని చిత్రించటానికి నిజంగా, కేవలం అక్షరాలు క్రమం.
కానీ, Zamyla ఉనికిలో లేదు ఒక కార్యక్రమంలో ఒంటరిగా.
>> మీరు వ్రాయడానికి మరియు ఒక అమలు చేసేటప్పుడు, మీరు మీ Mac లేదా మీ PC ఉపయోగించి చేస్తున్నారు
మెమొరీ లేదా RAM అని మాట్లాడటానికి.
మరియు మీరు ఆలోచించవచ్చు కలిగి గా మీ కంప్యూటర్
మెమరీ గిగాబైట్ల ఈ రోజుల్లో మా.
మరియు ఒక గిగ్ బిలియన్ల అంటే, బైట్లు కనుక బిలియన్ల.
>> కానీ యొక్క సమయం లో రివైండ్ తెలియజేయండి.
మరియు మేము ఆ ఉపయోగిస్తున్నారు అనుకుందాం ఒక నిజంగా పాత కంప్యూటర్
ఓన్లీ మెమరీ 32 బైట్లు ఉంది.
నేను అనుకొనుట, నా కంప్యూటర్ తెరపై, ఈ క్రింది విధంగా కేవలం ఈ అవ్ట్ డ్రా.
>> నేను కేవలం ఆ చెప్పగల్గినవి నా కంప్యూటర్ ఈ మెమరీ అన్ని ఉంది.
మరియు ఈ ఉంటే, మెమరీ స్టిక్ వంటిది మీరు చివరిసారి నుండి మా చిత్రాన్ని గుర్తు.
మరియు నేను తిరగడానికి తగినంత కాలంలో ఈ
నేను 32 బైట్లు కలిగి క్లెయిమ్ స్క్రీన్ మీద మెమరీ.
>> మాత్రమే ఇప్పుడు, వాస్తవానికి, నేను ఇప్పటివరకు ఇక్కడ తెరమీద డ్రా.
నేను ముందుకు వెళ్ళడానికి వెళుతున్న మరియు కేవలం కన్వెన్షన్ ద్వారా,
గా నా కంప్యూటర్ యొక్క మెమరీ డ్రా గ్రిడ్, కాదు కేవలం సరళ రేఖ.
ముఖ్యంగా, నేను ఇప్పుడు ఆ దావా ఈ గ్రిడ్, ఈ 8 4 గ్రిడ్,
అన్ని 32 బైట్లు సూచిస్తుంది నా Mac లో లభ్య స్మృతి యొక్క,
లేదా నా PC లో అందుబాటులో.
వారు చుట్టడం చేస్తున్నారు పై రెండు లైన్లు, కేవలం
అది తెరపై మరింత సరిపోయే ఎందుకంటే.
కానీ ఈ మొదటి బైట్.
ఈ రెండవ బైట్ ఉంది.
ఈ మూడవ బైట్ ఉంది.
>> మరియు ఈ 32 వ బైట్ ఉంది.
లేదా, మేము ఒక కంప్యూటర్ వంటి అనుకుంటే శాస్త్రవేత్త, ఈ బైట్ 0, 1, 2, 3, 31 ఉంది.
సో మీరు 31 0 కలిగి, ఉంటే మీరు 0 వద్ద లెక్కింపు మొదలు.
>> మేము ఒక కార్యక్రమం ఉపయోగించడానికి చేస్తే కాల్స్ స్ట్రింగ్ పొందండి,
మనిషి నుండి ఒక స్ట్రింగ్ పొందండి వంటి నేను Zamyla అని, Z-A-M- వై ఎల్-ఎ
ఎలా ప్రపంచంలో చేస్తుంది కంప్యూటర్ ఉంచేందుకు ట్రాక్ను బైట్ యొక్క,
మెమరీ ఏ భాగం, స్ట్రింగ్ చెందిన ఏ?
ఇతర మాటల్లో చెప్పాలంటే, కు కొనసాగితే కంప్యూటర్ లోకి మరో పేరును టైప్
ఈ అండీ వంటి, కాల్ స్ట్రింగ్ రెండవసారి పొందడానికి,
ఒక-ఎన్-D- నేను వదులుకోవడానికి ఉంది కంప్యూటర్ యొక్క మెమరీ అలాగే.
కానీ ఎలా?
>> బాగా, అది కింద హాజరవుతారు హుడ్, ఏమి సి తీగలను నిల్వ చేసేటప్పుడు చేస్తుంది
మానవ రకాల, లేదా ఆ కొన్ని ఇతర మూలం నుండి వచ్చి అది
వాటిని ముగింపు పూరించే ఒక ప్రత్యేక పాత్ర బాక్ స్లాష్
కేవలం ఒక ప్రత్యేక మార్గం ఇది 0, వరుసగా 80 బిట్స్ మాట్లాడుతూ.
>> కాబట్టి ఫంక్షన్ ఈ సంఖ్య 97 రీకాల్ ఉంది.
కాబట్టి 8 బిట్స్ కొన్ని నమూనా దశాంశ సంఖ్య 97 సూచిస్తుంది.
ఈ బాక్ స్లాష్ 0 వాచ్యంగా సంఖ్య 0 అ.కే.అ nul, ఎన్ యు-L, ముందు కాకుండా,
ఎన్ యు-ఎల్-L, మేము గురించి మాట్లాడారు, దీనిలో.
కానీ ఇప్పుడు కోసం, కేవలం ఈ తెలుసు బాక్ స్లాష్ 0 వరుసగా కేవలం 80 బిట్స్ ఉంది.
>> మరియు అది కేవలం ఈ లైన్ ఎడమ ఏదైనా చెప్పారు ఇసుక
ఒక స్ట్రింగ్ లేదా ఒక డేటా రకాన్ని చెందినది.
మరియు కుడి ఏదైనా ఏదో చెందినది.
అండీ యొక్క పేరు, మరోవైపు, ఇది కేవలం దృష్టి
ఇతర లైన్ లో వ్రాప్ ఏమవుతుంది కానీ కేవలం ఒక సౌందర్య వివరాలు,
అదేవిధంగా nul ముగిస్తారు.
>> ఇది ఒక ఒక-ఎన్-D- నేను అక్షరాల స్ట్రింగ్ ఉంది ప్లస్ ఐదవ రహస్య పాత్ర,
అన్ని 0 బిట్స్ కేవలం కొలతను గుర్తించడము కొరకు పెట్టబడిన అండీ యొక్క పేరు యొక్క చివరకు అలాగే.
మరియు మేము కాల్ ఉంటే స్ట్రింగ్ మూడోసారి పొందండి కంప్యూటర్ లో వంటి స్ట్రింగ్ పొందడానికి
మరియా, ఎం-ఎ-ఆర్-ఐ-ఎ, అదేవిధంగా మరియా ఉంది పేరు nul బాక్ స్లాష్ 0 తో రద్దు.
>> ఈ తీరుకి భిన్నంగా ఉంటుంది ఎలా నుండి ఒక కంప్యూటర్ సాధారణంగా చేస్తాను
పూర్ణాంకం, లేదా ఫ్లోట్ లేదా ఇతర నిల్వ ఇప్పటికీ డేటా రకాలు, రీకాల్, ఎందుకంటే
పూర్ణాంకం సాధారణంగా 32 బిట్స్ ఉంది, లేదా 4 బైట్లు, లేదా ఉండవచ్చు కూడా 64 బిట్స్
లేదా ఎనిమిది బైట్లు.
కానీ ఒక కంప్యూటర్ లో అనేక ధాతువులు ఒక ప్రోగ్రామింగ్ భాషలో
ఒక స్థిర సంఖ్యలో hood-- కింద బైట్లు
బహుశా 1, బహుశా 2, బహుశా 4, బహుశా 8.
>> కానీ తీగలను, డిజైన్ ద్వారా, ఒక కలిగి అక్షరాలు డైనమిక్ సంఖ్య.
మీరు వరకూ ముందుగానే తెలియదు Z-A-M- వై ఎల్-A లో మానవ రకాల
లేదా M-ఎ-ఆర్-ఐ-ఎ, లేదా ఒక-ఎన్-D- నేను. మీకు తెలియదు ఎన్ని సార్లు యూజర్ హిట్ అన్నారు
కీబోర్డు.
అందువలన, మీరు ఎలా తెలియదు ముందుగానే అనేక పాత్రలు
మీరు అవసరం చూడాలని.
>> కాబట్టి సి కేవలం రకమైన ఒక వంటి ఆకులు హుడ్ కింద రహస్య బ్రెడ్క్రంబ్ను
స్ట్రింగ్ చివరిలో.
మెమరీ Z-ఎ-M- వై ఎల్-ఎ నిల్వ తర్వాత, అది కూడా కేవలం రెండు సమానం ఉంచుతుంది
కాలం.
ఒక వాక్యం చివరలో, అది 80 బిట్స్ ఉంచుతుంది కాబట్టి
పేరు గుర్తుంచుకోవడం Zamyla మొదలై ముగుస్తుంది.
>> కాబట్టి కనెక్షన్ ఏమిటి, అప్పుడు, ఈ కార్యక్రమం ఎలా?
ఇక్కడ ఈ కార్యక్రమం, స్టిర్లింగ్, కేవలం ఒక విధానం ఉంది
ఒక స్ట్రింగ్ పొందడానికి వినియోగదారు నుండి, లైన్ 6.
లైన్ 7, నేను ఒక వేరియబుల్ డిక్లేర్ n అని మరియు అది 0 సమానంగా సెట్.
>> ఆపై లైన్ 8 లో, నేను కేవలం కోరారు ప్రశ్న, ఎన్-th పాత్ర ఉన్నప్పటికీ
సమాన అన్ని 0 బిట్స్ ఇతర మాటలలో, కాదు
ఈ ప్రత్యేక సమాన పాత్ర, బాక్ స్లాష్ 0, ఇది
ప్రత్యేకమైన nul పాత్ర ఉంది ముందుకు వెళ్ళి కేవలం n పెంచుతాయి.
>> అది పనిని, మరియు ఉంచడానికి అది చేయడం, అది పనిని.
కాబట్టి కూడా అయితే మేము i ఉపయోగించిన గత
అది ఖచ్చితంగా మంచిది n ఉపయోగించడానికి అర్థ,
మీరు ప్రయత్నిస్తున్న ఉంటే ఉద్దేశపూర్వకంగా ఈ సమయం లెక్కలోనికి,
మరియు కేవలం n కాల్ అనుకుంటున్నారా.
ఈ కేవలం అడిగి ఉంచుతుంది, లు అన్ని 0 సె యొక్క n-th పాత్ర?
లేకపోతే, తదుపరి రూపానికి చూడండి, తదుపరి చూడాల్సి తదుపరి చూడండి,
తదుపరి చూడండి.
>> కానీ వెంటనే మీరు బాక్ స్లాష్ 0 చూడండి, ఈ లూప్ లైన్ 9 11-- ద్వారా స్టాప్ల.
మీరు అయితే లూప్ బయటకు ఆ వేరియబుల్ n లోపలి వదిలి
అన్ని యొక్క మొత్తం లెక్కింపు మీరు చూసిన స్ట్రింగ్ లో అక్షరాలు,
తద్వారా అది ముద్రించిన.
కాబట్టి యొక్క ఈ ప్రయత్నించండి తెలియజేయండి.
>> లేకుండా, మరియు నాకు ముందుకు తెలియజేయండి స్టిర్లింగ్ ఫంక్షన్ ఉపయోగించి,
కాని ఆ నా స్వంత స్వదేశ వెర్షన్ ఉపయోగించి ఇక్కడ స్టిర్లింగ్ అని, నాకు ముందుకు తెలియజేయండి
మరియు రన్ ఫర్ స్టిర్లింగ్, ఏదో రకం Zamyla, నేను ముందుగానే తెలుసు ఇది వంటి
ఆరు అక్షరాలు.
అది పని లేదో యొక్క చూసేలా.
నిజానికి, ఇది ఆరు వార్తలు.
యొక్క రాబ్ తో ప్రయత్నించండి లెట్, పాత్రలైన మూడు అక్షరాలు అలాగే, మొదలగునవి.
కాబట్టి ఆ మాత్రం అంతే హుడ్ కింద.
మరియు కనెక్షన్లు గమనించవచ్చు, అప్పుడు, మొదటి వారం
తరగతి యొక్క, మేము గురించి మాట్లాడారు నైరూప్యత, అలాంటిదే
ఇది ఆలోచనలు కేవలం ఈ పొరను ఉంది, లేదా సంక్లిష్టత, ప్రాథమిక సూత్రాలు పైన.
ఇక్కడ, మేము విధమైన చూస్తున్నారా స్టిర్లింగ్ యొక్క హుడ్ కింద,
దొరుకుతుందని, మాట్లాడటానికి, అది ఎలా అమలుపరచాలి అవుతుంది?
>> మరియు మేము కాలేదు అది మేమే తిరిగి అమలు.
కానీ మేము ఎప్పుడూ మళ్ళీ చూడాలని తిరిగి ప్రవేశపెట్టాలని స్టిర్లింగ్.
మేము కేవలం చూడాలని క్రమంలో స్టిర్లింగ్ ఉపయోగించడానికి
నిజానికి కొన్ని తీగలను పొడవు పొందడానికి.
>> కాని ఏ మేజిక్ ఉంది హుడ్ కింద.
మీకు తెలిస్తే కింద ఆ హుడ్, ఒక స్ట్రింగ్
కేవలం అక్షరాలు క్రమం.
మరియు అక్షరాలు ఆ క్రమం అన్ని సంఖ్యాపరంగా ప్రసంగించారు చేయవచ్చు
బ్రాకెట్ 0, బ్రాకెట్ తో 1, బ్రాకెట్ 2, మరియు మీరు
ఒక స్ట్రింగ్ చివరిలో ఒక అని తెలుసు ప్రత్యేక పాత్ర, మీరు గుర్తించడానికి
ఒక అత్యంత ఏదైనా ఎలా కార్యక్రమం, ఎందుకంటే అది boils
చదవడం మరియు మెమరీ రాస్తుంటే.
మారుతున్న మరియు చూస్తున్నాయి ఉంది మెమరీ వద్ద, లేదా విషయాలు కదిలే
మెమరీలో చుట్టూ ముద్రణ విషయాలు స్క్రీన్, మొదలగునవి.
>> కాబట్టి యొక్క ఇప్పుడు ఈ నూతనంగా ఉపయోగించడానికి అనుమతిస్తున్నట్లు నిజానికి తీగలను ఏమి అవగాహన
హుడ్ కింద, మరియు మరొక తిరిగి పొర పీల్
ఇప్పుడు వరకు మేము చేసిన ఆ మొత్తంగా విస్మరిస్తూ జరిగింది.
ముఖ్యంగా, ఏ సమయంలో మేము ఒక కార్యక్రమం అమలు చేసిన,
మేము కోడ్ యొక్క ఈ లైన్ కలిగింది టాప్ సమీపంగా ప్రధాన ప్రకటించారు.
మరియు మేము Int ప్రధాన గర్జన పేర్కొన్న.
>> మరియు శూన్యమైన వక్ర లోపల ప్రధాన అన్ని ఈ సమయంలో చెప్పడం జరిగింది ఉంది
కూడా ఏ వాదనలు తీసుకోదు.
ప్రధాన ఉంది, ఏదైనా ఇన్పుట్ వినియోగదారు నుండి పొందగలిగిన
కొన్ని ఇతర నుండి వచ్చి విధానం వంటి ప్రధానంగా,
లేదా ఫ్లోట్ పొందుటకు, లేదా స్ట్రింగ్ పొందండి, లేదా కొన్ని ఇతర చర్య.
కానీ ఆ అవుతుంది మీరు ఒక ప్రోగ్రామ్ వ్రాస్తున్నప్పుడు,
మీరు నిజంగా పేర్కొనవచ్చు ఈ కార్యక్రమం వలెను అని
మానవ నుండి ఇన్పుట్లను పడుతుంది కమాండ్ లైన్ చూసుకుంటాడు.
>> ఇతర మాటలలో, అయినప్పటికీ మేము ఇప్పటివరకు కేవలం హలో నడుస్తున్న చెయ్యబడింది హలో కలిగి
లేదా ఇలాంటి కార్యక్రమాలు, అన్ని మేము ఉపయోగించి పరిష్కరించగలుగుతున్నాము ఇతర కార్యక్రమాలు,
మనం వ్రాసే లేదని, , అవలంబిస్తున్నాయి అది కనిపిస్తుంది,
కమాండ్ లైన్ arguments-- తయారు వంటి విషయాలు.
మీరు తయారు వంటి ఏదో చెప్పే, మరియు రెండవ పదం.
లేదా గణగణమని ద్వని మీరు గణగణమని ద్వని చేయు సే మరియు తరువాత రెండవ పదం, ఒక ఫైల్ యొక్క పేరు.
>> లేదా ఆర్ఎం లేదా CP, మీరు బలం గా చూసిన లేదా ఇప్పటికే ఉపయోగించిన
తొలగించండి లేదా కాపీ ఫైళ్లకు.
ఆ అన్ని పేరొందిన పడుతుంది కమాండ్ లైన్ arguments--
టెర్మినల్ ప్రాంప్ట్ వద్ద అదనపు పదాలు.
అయితే ఇప్పటి వరకు, మేము మమ్మల్ని కలిగి లేరు
నుండి ఇన్ పుట్ తీసుకోవటం ఈ లగ్జరీ వినియోగదారు అతను లేదా ఆమె నిజానికి నడుస్తుంది ఉన్నప్పుడు
కమాండ్ లైన్ వద్ద కార్యక్రమం కూడా.
>> కానీ మేము తిరిగి ప్రకటిస్తూ ఆ చేయవచ్చు ప్రధాన కలిగి లేదు కాబట్టి, ముందుకు వెళ్లడానికి
కుండలీకరణాల్లో రద్దు, కానీ ఈ రెండు వాదనలు
మొదటి పూర్ణాంకం instead--, మరియు రెండవ ఏదో
కొత్త, మేము కాల్ చూడాలని ఏదో వ్యూహం, ఆత్మ లో పోలి ఏదో
మేము ఒక జాబితా స్క్రాచ్ చూసిన, కానీ తీగలను యొక్క వ్యూహం, మేము వెంటనే చూస్తారు వంటి.
కానీ యొక్క ఈ చూద్దాం ఉదాహరణకు చూస్తే, మేము ముందు
ఆ అర్ధమేమిటో వేరు.
>> నేను CS50 IDE వెళ్ళాలని కాబట్టి ఇక్కడ, నేను ముందుకు మారారు
మరియు అని ఒక ఫైల్ లో ప్రకటించింది క్రింది టెంప్లేట్ argv0.c.
మరియు మాత్రమే విషయం గమనించవచ్చు ఇప్పటివరకు విభిన్నమైనది
నేను పూర్ణాంకానికి గర్జన మార్పుచేసేలా ఉంది argc స్ట్రింగ్, ఓపెన్ బ్రాకెట్ argv దగ్గరి
బ్రాకెట్.
ఇప్పుడు కోసం గుర్తించరు ఉంది, ఆ పరిధుల లోపల ఏమీ.
>> ఎటువంటి సంఖ్య ఉంది.
మరియు ఏ నేను లేదు, లేదా n, లేదా ఏ ఇతర లేఖ.
నేను ఉపయోగించి వెబ్ ఇప్పుడు చదరపు బ్రాకెట్లలో,
కారణాల మేము వచ్చి చేస్తాము తిరిగి ఒక క్షణం లో.
>> ఇప్పుడు నేను చేయ బోతున్నాను ఈ ఉంది.
సమానం argc సమానం ఉంటే 2 చేర్చాలని కోరుతున్నాయి మరియు ఆ సమానం సమానం గుర్తు
సమానత్వం ఆపరేటర్లు పోల్చడం ఇది ఎడమ మరియు సమానత్వం కోసం కుడి.
ఇది అప్పగించిన కాదు ఇది ఆపరేటర్లు,
కాపీని అంటే ఒకే సమాన సైన్, కుడి నుండి కొన్ని విలువ మిగిల్చింది.
>> argc సమానం 2 సమానం ఉంటే, నేను కావలసిన సే, printf, హలో, శాతాలు, కొత్త లైన్
ఆపై in-- ప్లగ్ మరియు ఇక్కడ కొత్త వార్తలు ట్రిక్ argv బ్రాకెట్ 1, కారణాల
మేము ఒక క్షణం లో తిరిగి వచ్చి మేము.
argc లేనప్పుడు ఎల్స్ సమానంగా 2, మీరు ఏమి?
మరియు, యొక్క కేవలం ముందుకు వెళ్ళి తెలపండి సాధారణ, ముద్రణ వంటి ఏ ప్రత్యామ్నాయం తో ప్రపంచ హలో.
>> కాబట్టి ఇది ఆ argc, ఇది ఉంటే వాదన లెక్కింపు ఉన్నచో 2 సమానం,
నేను ప్రింట్ వెళుతున్న హలో ఏదో లేదా ఇతర.
లేకపోతే, అప్రమేయంగా, నేను ఉన్నాను ప్రపంచ హలో ప్రింట్ వెళుతున్న.
కాబట్టి దీని అర్థం ఏమిటి?
>> బాగా, నాకు ముందుకు వెళ్లి సేవ్ చేసేలా ఈ ఫైలు, ఆపై argv0 ఉందని,
ఆపై ./argv0 నమోదు చేయండి.
మరియు అది హలో ప్రపంచ చెప్పారు.
ఇప్పుడు, ఎందుకు అని?
>> సరే, మీరు ఎప్పుడైనా అవుతుంది కమాండ్ లైన్ వద్ద ఒక కార్యక్రమం అమలు,
మీరు మేము ఏమి చేస్తాము పూరించి సాధారణంగా ఒక వాదన వెక్టర్ కాల్.
ఇతర మాటలలో, స్వయంచాలకంగా కంప్యూటర్, ఆపరేటింగ్ సిస్టమ్,
మీ ప్రోగ్రామ్ చేతితో అన్నారు కూడా అన్నీ జాబితా
మానవ వద్ద టైప్ చేసే ప్రాంప్ట్, ఒకవేళ మీరు
ప్రోగ్రామర్ చేయాలనుకుంటున్నారా ఆ సమాచారాన్ని కావొచ్చు.
మరియు ఈ సందర్భంలో, మాత్రమే పదం నేను ప్రాంప్ట్ వద్ద టైప్ చేసిన ./argv0 ఉంది.
>> కాబట్టి అని వాదనలు సంఖ్య నా ప్రోగ్రామ్ జారీ చేస్తున్నారు ఒకటి.
ఇతర మాటలలో, వాదన లేకపోతే argc అని పిలుస్తారు, కౌంట్
ఇక్కడ పూర్ణాంకం వంటి, కేవలం ఒకటి.
ఒకటి, కోర్సు యొక్క, సమాన ఇద్దరు లేదు.
కాబట్టి ఈ hello, ముద్రిస్తుంది ఏమి ప్రపంచం.
>> కానీ నాకు ఈ ఎక్కడా తీసుకుందాం.
, నాకు చెప్పటానికి argv0 లెట్.
ఆపై మరియా గురించి?
Enter ని అప్పుడు.
>> మరియు అద్భుతంగా ఇక్కడ ఏమి గమనిస్తారు.
ఇప్పుడు, బదులుగా హలో వరల్డ్, నేను కలిగి ఈ కార్యక్రమం యొక్క ప్రవర్తనను మార్చినది
పొందండి నుండి ఇన్పుట్ తీసుకోవడం ద్వారా స్ట్రింగ్ లేదా కొన్ని ఇతర చర్య,
కానీ, స్పష్టంగా, నా కమాండ్ నుండి కూడా, నేను నిజానికి టైప్ చేసిన ఏమి.
మరియు నేను ద్వారా మళ్లీ ఈ గేమ్ ప్లే చేయవచ్చు ఉదాహరణకు, కు Stelios ఇది మారుతున్న.
>> మరియు ఇప్పుడు నేను ఇప్పటికీ మరొక పేరు చూడండి.
మరియు ఇక్కడ, నేను అండీ అనవచ్చు.
నేను Zamyla అనవచ్చు.
మరియు దినమెల్ల మేము ఈ గేమ్ ప్లే చేయవచ్చు, కేవలం వివిధ విలువలు పూరించే,
నేను ఖచ్చితంగా అందించడానికి ఉన్నంతకాలం ప్రాంప్ట్ వద్ద రెండు పదాలు,
argc, నా వాదన లెక్కింపు ఇటువంటి, 2.
>> నేను పేరు ప్లగ్ చూస్తారు printf, ఇక్కడ ఈ పరిస్థితిలో చెల్లించాలి?
కాబట్టి మేము ఇప్పుడు కనిపించడం వ్యక్తీకరణ సామర్ధ్యం
మరో యాంత్రికత ఇన్పుట్ తీసుకొనే, అని పిలవబడే కమాండ్ లైన్ నుండి,
వేచి ఉండటం కంటే వినియోగదారు ప్రోగ్రామ్ నడుస్తుంది వరకు,
ఆపై అతనిని లేదా ఆమెను ప్రాంప్ట్ స్ట్రింగ్ పొందండి లాగ ఉపయోగించి.
>> కాబట్టి ఈ ఏమి ఉంది?
Argc, మళ్ళీ, కేవలం ఒక పూర్ణ సంఖ్య, words-- arguments-- సంఖ్య
ఆ యూజర్ వద్ద అందించబడింది ప్రాంప్ట్, టెర్మినల్ విండో వద్ద,
కార్యక్రమం యొక్క పేరు సహా.
సో మా ./argv0 సమర్థవంతంగా ఉంది, కార్యక్రమం యొక్క పేరు,
లేదా నేను అమలు ఎలా.
>> ఒక పదం గా లెక్కింపబడుతుంది.
కాబట్టి argc 1 ఉంటుంది.
కానీ నేను Stelios వ్రాస్తున్నప్పుడు, లేదా Andi, లేదా Zamyla, లేదా మరియా,
ఆ వాదన లెక్కింపు ఇద్దరు అర్థం.
అందువలన ఇప్పుడు ఆమోదించబడ్డాయి రెండు పదాలు ఉన్నాయి అనిపిస్తుంది.
>> మరియు నోటీసు, మేము ఈ తర్కం కొనసాగించవచ్చు.
నేను నిజానికి చెబితే Zamyla చాన్ అలాంటిదే
పూర్తి పేరు, తద్వారా ప్రయాణిస్తున్న మొత్తం మూడు రకాల వాదనలు
ప్రస్తుతం మళ్లీ డిఫాల్ట్ చెప్పారు, ఎందుకంటే, కోర్సు, 3 సమాన 2 చేస్తుంది.
>> కాబట్టి ఈ విధంగా, నేను ఉన్నాయి argv ఈ కొత్త వాదన ద్వారా ప్రవేశించి
మేము సాంకేతికంగా అని మేము కావలసిన ఏదైనా కాల్.
కానీ సాంప్రదాయకంగా, అంతే argv మరియు argc, వరుసగా.
Argv, వాదన వెక్టర్, రకం ఒక కార్యక్రమాలకు పర్యాయపదంగా
సి లో ఫీచర్ వ్యూహం అని.
>> ఒక అమరిక ఇదే విలువలు జాబితా తిరిగి, తిరిగి, తిరిగి, తిరిగి.
ఇతర మాటలలో, ఒక ఇక్కడే ఉంది ర్యామ్, తదుపరి కుడి అది పక్కన ఉంది,
మరియు కుడి అది ప్రక్కన.
వారు అన్ని చోట్ల లేదు.
మరియు ఆ తరువాతి ఘట్టానికి ఇక్కడ విషయాలు అన్ని మెమరీలో చోట్ల ఉన్నాయి,
నిజానికి ఒక శక్తివంతమైన ఫీచర్ ఉంటుంది.
కానీ మేము మేము ఆ వచ్చి చేస్తాము ఫ్యాన్సియెర్స్ డేటా నిర్మాణాలు గురించి మాట్లాడటానికి.
ఇప్పుడు కోసం, ఒక అర్రే ఒక ఉంది పక్కపక్క మెమరీ భాగం,
దీని అంశాలు ప్రతి తిరిగి, తిరిగి, తిరిగి తిరిగి,
మరియు సాధారణంగా అదే రకం.
>> సో మీరు ఒక నుండి గురించి అనుకుంటే క్షణం క్రితం, ఒక స్ట్రింగ్ ఏమిటి?
Well, ఒక స్ట్రింగ్, Zamyla వంటి, Z-A-M- వై ఎల్-ఎ, సాంకేతికంగా, ఉంది,
కేవలం ఒక శ్రేణి.
ఇది అక్షరాలు యొక్క వ్యూహం ఉంది.
>> కాబట్టి మేము నిజంగా ఈ వంటి డ్రా అయితే నేను మెమరీ భాగం గా, ఇంతకు ముందు,
వీటిల్లో ప్రతి అవుతుంది అక్షరాలు ఒక బైట్ తీసుకుంటుంది.
ఆపై ప్రత్యేక వార్తలు కాపలాదారుడు పాత్ర, బాక్ స్లాష్ 0,
లేదా అన్ని ఎనిమిది 0 బిట్స్ ఆ స్ట్రింగ్ ముగింపు కొలతను గుర్తించడము.
సో ఒక స్ట్రింగ్, అది మారుతుంది బయటకు, unquote స్ట్రింగ్ కోట్
కేవలం chara-- యొక్క వ్యూహం ఉంది ఒక వాస్తవ డేటా రకం ఉండటం చార్.
>> ఇప్పుడు argv, meanwhile-- యొక్క తిరిగి కార్యక్రమానికి వీడలేదు.
Argv, మేము పదం అయినప్పటికీ స్ట్రింగ్ ఇక్కడ, ఒక స్ట్రింగ్ కూడా ఉంది.
Argv, వాదన వెక్టర్, తీగలను యొక్క వ్యూహం ఉంది.
>> మీరు వ్యూహం ఉండవచ్చు కాబట్టి కేవలం అక్షరాలు, మీరు అధిక స్థాయి కలిగి ఉంటుంది,
strings-- యొక్క వ్యూహం కాబట్టి, ఉదాహరణకు, నేను ఒక క్షణం క్రితం టైప్ చేసినప్పుడు ./argv0
argv0, స్పేస్ Z-A-M- వై-L- ఒక, నేను పేర్కొన్నారు argv దానిని ./argv0 రెండు తీగలను కలిగిఉండగా,
మరియు Z-ఎ-M- వై ఎల్ ఎ. లో ఇతర మాటలలో, argc 2 ఉంది.
ఎందుకు అని?
>> బాగా, సమర్థవంతంగా, ఏం జరగబోతోంది ఉంది ఈ తీగలు ప్రతి యొక్క
అక్షరాలు యొక్క వ్యూహం, కోర్సు యొక్క, ఉంది ముందు, దీని ప్రతి అక్షరాలు
ఒక బైట్ తీసుకుంటుంది.
మరియు వాస్తవ 0 తికమక లేదు 0 కార్యక్రమం యొక్క పేరు లో,
అన్ని 80 బిట్స్ అర్థం.
మరియు Zamyla, మరోవైపు, ఇప్పటికీ ఉంది కూడా అక్షరాలు యొక్క వ్యూహం.
>> కాబట్టి రోజు చివరిలో, అది నిజంగా హుడ్ కింద ఈ కనిపిస్తోంది.
కానీ ఎలా ప్రధాన స్వభావం ద్వారా, argv రచనలు, నాకు ఈ అన్ని వ్రాప్ అనుమతిస్తుంది
లోకి, మీరు రెడీ ఉంటే, ఒక పెద్ద శ్రేణి మేము కొద్దిగా పైగా సులభతరం, ఆ
చిత్రాన్ని వంటి మరియు లేదు కనిపిస్తుంది ఏమి చాలా ఉన్నాయి స్కేల్ గీసి,
ఈ శ్రేణి మొదటి, కేవలం పరిమాణం 2 యొక్క ఒక స్ట్రింగ్ కలిగి మూలకం
రెండవ మూలకం ఇది ఒక స్ట్రింగ్ కలిగి.
మరియు, క్రమంగా, మీరు రకమైన ప్రతి లో జూమ్
ఆ తీగలను యొక్క ఏమి మీరు హుడ్ కింద చూడండి
ప్రతి స్ట్రింగ్ కేవలం ఉంది అక్షరాలు యొక్క వ్యూహం.
>> ఇప్పుడు, కేవలం తీగలను వంటి, మేము ప్రాప్యత పొందుటకు పోయారు
ఒక స్ట్రింగ్ లో i-th పాత్ర ఆ చదరపు బ్రాకెట్ సంజ్ఞామానం.
అదేవిధంగా, శ్రేణితో సాధారణంగా, మేము
పొందుటకు చదరపు బ్రాకెట్ సంజ్ఞామానం వ్యూహంలో తీగలను ఎన్ని వద్ద?
ఉదాహరణకు, నాకు తెలియజేయండి ముందుకు వెళ్ళి దీన్ని.
>> నాకు ముందుకు వెళ్లి argv1.c సృష్టించడానికి లెట్, ఇది కొద్దిగా భిన్నంగా ఈ సమయంలో ఉంది.
బదులుగా argc2 కోసం తనిఖీ యొక్క, నేను బదులుగా దీన్ని వెళుతున్న.
నేను 0 పొందుటకు Int కోసం, నేను తక్కువ argc కంటే, నేను ప్లస్ ప్లస్,
ఆపై ఈ లోపల బయటకు ప్రింట్, శాతం లు, కొత్త లైన్, మరియు అప్పుడు
argv బ్రాకెట్ i.
>> కాబట్టి ఇతర మాటలలో, నేను వ్యవహరించే కాదు క్షణం వద్ద వ్యక్తిగత అక్షరాలు.
Argv, ఈ ఖాళీ చదరపు సూచించినట్లు పేరు argv యొక్క కుడి జంట కలుపులు,
తీగలను యొక్క వ్యూహం ఉంది argv అర్థం.
మరియు argc కేవలం ఒక పూర్ణాంకానికి ఉంది.
>> ఇక్కడ ఈ లైన్, 6, ఉంది సెట్ మాట్లాడుతూ నేను 0 సమం.
అన్ని మార్గం కౌంట్, కానీ argc మినహాయించి.
ఆపై ప్రతి మళ్ళా న, ఒక స్ట్రింగ్ ప్రింట్.
స్ట్రింగ్?
>> argv లో నేను-వ స్ట్రింగ్.
కాబట్టి నేను ముందు అయితే చదరపు బ్రాకెట్ ఉపయోగించి
ith వద్ద పొందడానికి సంజ్ఞామానం ఒక స్ట్రింగ్ లో పాత్ర ఇప్పుడు
నేను చదరపు బ్రాకెట్ సంజ్ఞామానం ఉపయోగించి వెబ్ ఒక యెరే నందలి ith స్ట్రింగ్ వద్ద పొందడానికి.
కనుక ఇది ఒక పొర రకంగా పైన, సంభావితంగా.
>> కాబట్టి ఈ ఏమి గురించి చక్కగా ఉంది ఇప్పుడు కార్యక్రమం, నేను ఇది argv1 కంపైల్ ఉంటే,
ఆపై ./argv1 చేయండి, తరువాత టైప్ foo బార్ బాజ్ లాగ,
మూడు డిఫాల్ట్ పదాలు ఒక ఉన్నాయి కంప్యూటర్ శాస్త్రవేత్త ఏ సమయంలో చేరుకుంటుంది
అతను లేదా ఆమె కొన్ని హోల్డర్ పదాలు అవసరం, ఎంటర్ నొక్కండి, ఆ పదాల్లోని,
కార్యక్రమం యొక్క పేరు, సహా మొదటి స్థానంలో argv లో ఉంది
ఒక సమయంలో ఒక ముద్రించబడ్డాయి ముగుస్తుంది.
నేను దీన్ని మార్చి, నేను చెప్పుకోవాలంటే ఇది argv1 Zamyla చాన్ అలాంటిదే
మేము ఆ మూడు పొందడానికి argv0 ఇది మాటలు,
ఇది argv1, argv2, ఈ ఎందుకంటే కేసు argc, లెక్కింపు, 3.
>> కానీ ఏమి చక్కగా ఉంది మీరు అర్థం ఉంటే ఆ argv కేవలం తీగలను యొక్క వ్యూహం ఉంది,
మరియు మీరు ఒక స్ట్రింగ్ అర్థం అక్షరాలు యొక్క వ్యూహం ఉంది,
మేము నిజంగా రకమైన ఈ ఉపయోగించవచ్చు చదరపు బ్రాకెట్ సంజ్ఞామానం అనేకసార్లు
ఒక స్ట్రింగ్ ఎంచుకోండి, ఆపై ఎంచుకోండి స్ట్రింగ్ లోపల ఒక పాత్ర,
ఈ క్రింది విధంగా లోతైన లో డైవింగ్.
ఈ ఉదాహరణలో, నాకు వీడలేదు ముందుకు మరియు ఈ argv2.c కాల్.
మరియు ఈ ఉదాహరణలో, నాకు ముందుకు తెలియజేయండి మరియు నేను 0 పొందుటకు Int కోసం కింది చేయండి,
నేను, argc కంటే తక్కువ i ప్లస్ ప్లస్, ముందు వలె.
కాబట్టి ఇతర words-- మరియు ఇప్పుడు ఈ తగినంత క్లిష్టమైన పెరిగిపోతుంది.
అప్పుడు నేను చెప్పాను వెళుతున్న argv తీగలను పైగా iterate,
నాకు వ్యాఖ్యగా.
ఆపై నేను ఒక కలిగి వెళుతున్న లూప్ యున్న, బహుశా మీరు
చేసిన, లేదా భావిస్తారు స్క్రాచ్ లో, చేయడం పేరు,
నేను ఉన్నాను పూర్ణాంకానికి చెప్పడానికి వెళుతున్నాను మళ్ళీ నేను ఉపయోగించడానికి వెళ్ళడం లేదు,
నేను షాడో వద్దు ఎందుకంటే, లేదా విధమైన ఇప్పటికే నేను తిరిగి రాస్తుంది.
>> నేను ఎందుకంటే, బదులుగా, j చెప్పే వెళుతున్న ఆ i తరువాత వేరియబుల్ నా ప్రయాణంలో వార్తలు,
నేను దీనికై సాధారణ సంఖ్యలు కౌంట్.
j గెట్స్ 0 ఉంది మరియు కూడా, n అన్నారు argv బ్రాకెట్ i యొక్క దృఢమైన పొడవు పొందడానికి,
చాలా కాలం జె ఎం కంటే తక్కువ, j ప్లస్ ప్లస్, క్రింది వాటిని.
మరియు ఇక్కడ ఆసక్తికరమైన భాగం.
>> ఒక పాత్ర మరియు ఒక కొత్త లైన్ ప్రింట్ argv బ్రాకెట్ నేను, బ్రాకెట్ j పూరించే.
OK, కాబట్టి నాకు ఇక్కడ కొన్ని వ్యాఖ్యలు జోడించడానికి అనుమతిస్తుంది.
అక్షరాలు మీద iterate ప్రస్తుత స్ట్రింగ్ లో
నేను-వ స్ట్రింగ్ లో ముద్రణ జె-th పాత్ర.
కాబట్టి ఇప్పుడు, యొక్క పరిశీలిద్దాం ఏమి ఈ వ్యాఖ్యలు అర్థం.
>> తీగలను పైగా iterate argv-- ఎన్ని
తీగలను ఒక అర్రే, argv ఉన్నాయి?
Argc అనేక, కాబట్టి నేను iterating ఉన్నాను నుండి నేను argc వరకు సమం 0.
ఇంతలో, ఎన్ని అక్షరాలు argv లో నేను-వ స్ట్రింగ్ లో?
>> Well, ఆ సమాధానం పొందడానికి నేను స్ట్రింగ్ పొడవు కాల్
ప్రస్తుత స్ట్రింగ్ నేను సంరక్షణకు argv బ్రాకెట్ i ఉంది, ఇది గురించి.
నేను తాత్కాలికంగా ఆ నిల్వ వెళుతున్న విలువ n, కేవలం చేజింగ్ ప్రయోజనాల కోసం,
సామర్థ్యం కోసం అది గుర్తుంచుకోవడానికి.
ఆపై నేను 0 j ప్రారంభించడం వెళుతున్న j కంటే తక్కువ ఉన్నంతకాలం కొనసాగించడాన్ని,
మరియు ప్రతి మళ్ళా పెంపు j న.
>> ఆపై ఇక్కడ, పర్ లైన్ 12 లో నా వ్యాఖ్య,
ఒక పాత్రను ప్రింట్, ఒక కొత్త పంక్తి తర్వాత,
ప్రత్యేకంగా argv బ్రాకెట్ నేను నాకు నేను-వ స్ట్రింగ్ ఇస్తుంది
argv-- కాబట్టి మొదటి పదం లో, రెండవ పదం, మూడవ పదం సంసార.
లోతైన లో తరువాత j పడిపోవడంతో, మరియు గెట్స్ నాకు ఆ పదం యొక్క j-th పాత్ర.
అందువలన, ప్రభావం లో, మీరు చికిత్స చేయవచ్చు argv ఒక బహుళ పరిమాణాల వంటి,
ద్విమితీయ, వ్యూహం, అనగా కనిపిస్తోంది ప్రతి పదం రకమైన
మీ మనస్సు యొక్క ఈ వంటి కన్ను, ప్రతి పాత్ర
రకమైన కూడి ఉంది ఒక కాలమ్, ఆ సహాయం చేస్తుంది.
>> వాస్తవంలో, మేము బాధించటం భవిష్యత్తులో వారాల్లో ఈ వేరుగా,
అది కొద్దిగా చేస్తాడు కంటే మరింత అధునాతన.
కానీ మీరు నిజంగా చెయ్యవచ్చు ఇప్పుడు కోసం, ఆ భావిస్తారు,
ఈ రెండు డైమెన్షనల్ గా అర్రే, అనగా ఒక వ్యక్తి దాని స్థాయి
తీగలను అన్ని ఉంది.
ఆపై మీరు లోతైన, మీరు ఈత కొట్టడానికి ఉంటే వ్యక్తిగత దొరకని అక్షరాలు
ఇక్కడ ఈ సంజ్ఞామానం ఉపయోగించి అందులో.
>> కాబట్టి నికర ప్రభావం ఏమిటి?
నాకు ముందుకు వెళ్లి argv2-- అది రంధ్రాన్ని సరి చేయు చేయడానికి.
నేను ఇక్కడ పొరపాటు.
పరిపూర్ణంగా ప్రకటించారు లైబ్రరీ ఫంక్షన్ స్టిర్లింగ్.
కాబట్టి ఈ సమయం, అది బహుశా తగిన
మేము విధమైన పూర్తి చేస్తున్న ఖచ్చితంగా మేము ప్రారంభించారు.
>> నేను ఇరుక్కొనిపోయింది పరిపూర్ణంగా ప్రకటించారు లైబ్రరీ ఫంక్షన్ స్టిర్లింగ్.
సరే, ఒక నిమిషం వేచి.
నేను ముఖ్యంగా, గుర్తుంచుకోవాలి నుండి అది ఇక్కడే ఉంది.
నేను string.h ఉన్నాయి అవసరం కార్యక్రమం యొక్క ఈ వెర్షన్.
>> నాకు ముందుకు వెళ్లి ఉన్నాయి లెట్ string.h, సేవ్, ముందుకు వెళ్ళి
మరియు argv2 కంపైల్ చెయ్యండి.
ఇప్పుడు, ఇక్కడ మనం, argv2 చేయడానికి ఎంటర్ వెళ్ళండి.
మరియు అది ఒక చిన్న అయితే మొదటి చూపులో గుప్తమైన,
నిజానికి, నోటీసు, ఏమి ముద్రించబడుతుంది డాట్ argv2 ఉంది.
>> కానీ నేను తరువాత కొన్ని పదాలు టైప్ చేస్తే ప్రాంప్ట్, argv2 Zamyla చాన్ వంటి,
కూడా కొద్దిగా, ఎంటర్ మొదటి చూపులో గుప్తమైన.
కానీ మేము తిరిగి అప్ స్క్రోల్ చేయండి, ./argv2 Z-A-M- వై ఎల్ ఎ సి హెచ్ ఎ-ఎన్.
కాబట్టి మేము ప్రతి పదం మీద iterated చేసిన.
మరియు, క్రమంగా, మేము పైగా iterated చేసిన ఒక పదం లోపల ప్రతి పాత్ర.
>> ఇప్పుడు, ఈ అన్ని తర్వాత, అక్కడ తెలుసుకుంటారు
ఒక ఇతర వివరాలు మేము రకమైన ఉన్నాను ఈ మొత్తం సమయం విస్మరిస్తూ.
మేము కేవలం దూరంగా ఆటపట్టించాడు ఏమి ప్రధాన యొక్క ఇన్పుట్లను ఉంటుంది?
ఏ ప్రధాన యొక్క అవుట్పుట్ గురించి?
>> ఈ సమయంలో అన్ని, మేము పరిష్కరించగలుగుతున్నాము కేవలం కాపీ మరియు పేస్ట్
ప్రధాన ముందు పదం Int, మీరు చూడవచ్చు అయితే ఆన్లైన్,
కొన్నిసార్లు తప్పుగా పాత సంస్కరణల్లో C మరియు కంపైలర్లు యొక్క, వారు గర్జన చెబుతారు,
లేదా అన్ని వద్ద ఏమీ.
కానీ, నిజానికి, వెర్షన్ కోసం సి మనం ఉపయోగిస్తున్న చేస్తున్న,
సి 11, లేదా 2011, తెలుసుకోవటం అది పూర్ణాంకానికి ఉండాలి.
మరియు అది గాని ఉండాలి తప్ప లేదా argc మరియు ఇక్కడ argv.
>> కానీ ఎందుకు Int ప్రధాన?
నిజానికి ఏమి తిరిగి?
సరే, ఈ సమయంలో అన్ని అవుతుంది ఏ సమయంలో మీరు ఒక ప్రోగ్రామ్ ప్రధాన వ్రాయలేదు
ఎప్పుడూ ఏదో తిరిగి.
కానీ అది చాలా రహస్యంగా చేస్తోంది.
>> ఒక విషయం ఉంది Int, లైన్ గా 5 సూచిస్తుంది.
కానీ ఏమి పూర్ణాంకానికి?
Well, ఈ ఉంది ప్రోగ్రామింగ్ సమావేశం,
ఏమీ కలిగి ఉంటే అనగా తప్పు పోయింది మరియు అన్ని బాగా ఉంటుంది,
కార్యక్రమాలు మరియు విధులు సాధారణంగా return-- కొంతవరకు counterintuitively--
0.
0 సాధారణంగా అన్ని బాగా సూచిస్తుంది.
మీరు ఆలోచించవచ్చు కాబట్టి అయినప్పటికీ పలు సందర్భాల్లో తప్పుడు అది
నిజానికి సాధారణంగా ఒక మంచి విషయం అర్థం
>> ఇంతలో, ఒక ప్రోగ్రామ్ 1 తిరిగి ఉంటే, లేదా ప్రతికూల 1, లేదా 5, లేదా ప్రతికూల 42,
లేదా ఏ కాని 0 విలువ, సాధారణంగా సూచిస్తుంది
ఏదో తప్పు పోయిందో.
నిజానికి, మీ స్వంత Mac లేదా PC లో, మీరు నిజంగా చూసిన ఉండవచ్చు
ఒక దోష సందేశం అనగా ఇది ఏదో లేదా ఇతర, లోపం చెప్పారు
కోడ్ ప్రతికూల 42, లేదా లోపం కోడ్ 23, లేదా అలాంటిదే.
ఆ సంఖ్యను సాధారణంగా కేవలం ఒక సూచనను ఉంది ప్రోగ్రామర్, లేదా కంపెనీకి
సాఫ్ట్వేర్ తయారు ఏమి తప్పు జరిగింది మరియు ఎందుకు
వారు ద్వారా చూడండి తద్వారా వారి పత్రరచన లేక కోడ్,
మరియు బయటకు దొరుకుతుందని ఏమి లోపం వాస్తవానికి అర్థం.
ఇది సాధారణంగా కాదు మాకు ఉపయోగపడుతుంది అంతం వినియోగదారులు.
>> కానీ ప్రధాన రాబడి 0, అన్ని బాగా ఉన్నప్పుడు.
మరియు మీరు పేర్కొన్న లేకపోతే ప్రధాన తిరిగి ఉండాలి ఏమి,
అది కేవలం స్వయంచాలకంగా రెడీ మీరు కోసం 0 తిరిగి.
కానీ ఏదో తిరిగి వేరే వాస్తవానికి ఉపయోగపడుతుంది.
>> ఈ చివరి కార్యక్రమంలో, నాకు తెలియజేయండి ముందుకు వెళ్లి ఈ exit.c కాల్,
నేటి చివరి పరిచయం లోపం కోడ్ అంటారు విషయాలు.
నాకు ముందుకు వెళ్లి ఉన్నాయి లెట్ మా తెలిసిన ఫైళ్లు టాప్, Int ప్రధాన.
మరియు ఈ సమయంలో, యొక్క Int argc, తెలియజేసేలా స్ట్రింగ్ argv, మరియు నా బ్రాకెట్స్
అది యెరే నందలి అని చెప్పేందుకు.
ఆపై నాకు కేవలం ఒక తెలివి తనిఖీ.
ఈ సమయంలో, argc లేనప్పుడు సమానంగా 2, అప్పుడు మీరు ఏమి?
మర్చిపోండి.
నేను ఆ చెప్పటానికి వెళ్ళిపోతున్నాను, హే, వినియోగదారు, మీరు లేని కమాండ్ లైన్ వాదన
బాక్ స్లాష్ n.
>> ఆపై అంతే.
నేను నిష్క్రమించడానికి కావలసిన.
నేను preemptively వెళ్ళిపోతున్నాను, మరియు ముందుగానే నిజంగా, తిరిగి
సంఖ్య 1 కంటే ఇతర ఏదైనా.
మొదటి కోసం విలువ వెళ్ళండి ఇదే లోపం 1 ఉంది.
మీరు కొన్ని ఇతర తప్పుడు ఉంటే జరగవచ్చు ఆ పరిస్థితిలో,
మీరు తిరిగి 2 చెబుతున్నారు లేదా 3 తిరిగి ఉండవచ్చు, లేదా ఇంకా ప్రతికూల 1 లేదా ప్రతికూల 2.
>> ఈ నిష్క్రమణ కోడ్లు ఆ ఉంటాయి, సాధారణంగా,
లేదా ప్రోగ్రామర్ ఉపయోగపడుతుంది, సాఫ్ట్వేర్ షిప్పింగ్ చేసే సంస్థ.
అయితే వాస్తవానికి అంతే 0 కానప్పుడు ముఖ్యం ఏమిటి.
కాబట్టి ఈ ప్రోగ్రామ్ లో ఉంటే, నేను మీరు హామీ ఈ కార్యక్రమం మాత్రమే
యూజర్ నాకు అందిస్తుంది పనిచేస్తుంది రెండు యొక్క ఒక వాదన లెక్కింపు తో,
కార్యక్రమం యొక్క పేరు, మరియు కొన్ని ఇతర పదం, నేను ఈ క్రింది విధంగా ఎక్కువ అమలు చేయవచ్చు
printf నానుడి వినియోగదారు మీద అరుస్తుంటారు, తప్పిపోయిన కమాండ్ లైన్ వాదన,
1 తిరిగి.
కేవలం వెంటనే రెడీ కార్యక్రమం నిష్క్రమించాడు.
>> argc సమానం చేస్తేనే 2 మేము డౌన్ పొందుతారు ఇక్కడ, నేను చెప్పడానికి వెళుతున్న సమయంలో,
హలో శాతం లు, బాక్ స్లాష్ n, ఇది argv1.
ఇతర మాటలలో, నేను రెడీ argv 0 తర్వాత వెళ్ళడం లేదు,
ప్రోగ్రామ్కు కేవలం పేరు.
నేను కామా, హలో ప్రింట్ మీరు, మానవ టైప్ రెండవ పదం.
మరియు ఈ సందర్భంలో లో లైన్ 13, అన్ని బాగా ఉంటుంది.
>> నేను argc 2 అని తెలుసు తార్కికంగా ఈ కార్యక్రమం నుండి.
నేను ముందుకు వెళ్లి 0 తిరిగి వెళుతున్న.
జనాంతికంగా, గుర్తుంచుకోండి ఈ అలాగే స్క్రాచ్ లో నిజం.
>> తార్కికంగా, నేను ఈ పని చేయడు మరియు ఈ పంక్తులు టూకీగా
ఇక్కడ ఈ వేరే నిబంధన లో కోడ్.
కానీ ఆ విధమైన వార్తలు అనవసరంగా నా కోడ్ ఇండెంటింగ్.
మరియు నేను సూపర్ అనుకున్న స్పష్టమైన ఉన్నా ఏమి ఆ,
అప్రమేయంగా, హలో ఏదో, ముద్రిత అందుకుంటారని
యూజర్ సహకరిస్తుంది ఉన్నంతకాలం.
>> కనుక ఇది ఉపయోగించడానికి చాలా సాధారణ వార్తలు ఒక పరిస్థితి, ఒక ఉంటే,
కొన్ని తప్పుడు క్యాచ్ పరిస్థితి, మరియు అప్పుడు నిష్క్రమణ.
ఆపై, చాలా కాలం ఉంది బాగా, వేరే లేదా,
కానీ కేవలం కోడ్ కలిగి బయట, అది ఎందుకంటే
ఈ సమానం ప్రత్యేక సందర్భంలో, తార్కికంగా.
నేను కేవలం, తిరిగి నేను 0 నడిపేవారిని అన్ని బాగా సూచిస్తాయి.
>> నేను తిరిగి 0 తొలగించిన ఉంటే, అది చేస్తాను స్వయంచాలకంగా నాకు భావించలేము.
కానీ ఇప్పుడు నేను తిరిగి నేను కనీసం ఈ సందర్భంలో ఒకటి,
నేను మంచి కొలత కోసం, వెళుతున్న మరియు స్పష్టత, ఈ సందర్భంలో 0 తిరిగి.
కాబట్టి ఇప్పుడు నాకు ముందుకు వెళ్లి నిష్క్రమణ చేయడానికి వీలు, ఇది కేవలం వదిలి ఒక పరిపూర్ణ segue ఉంది.
>> కానీ నిష్క్రమణ తయారు, మరియు నాకు వీడలేదు ముందుకు ./exit చేయండి నమోదు చేయండి.
మరియు ప్రోగ్రామ్ నాకు కోప్పడ్డాడు తప్పిపోయిన కమాండ్ లైన్ వాదన.
సరే, నాకు సహకరించిన లెట్.
>> నాకు బదులుగా ./exit తెలియజేసేలా, డేవిడ్, ఇవ్వండి.
ఇప్పుడు దాని చెప్పారు డేవిడ్ హలో.
మరియు మీరు సాధారణంగా ఈ చూడండి కాదు.
>> కానీ అది ఒక ఉంది హాజరవుతారు Linux లో ప్రత్యేక మార్గం నిజానికి చూడటానికి
ఏమి నిష్క్రమణ కోడ్ తో ఒక కార్యక్రమం ముగిసింది.
కొన్నిసార్లు ఒక గ్రాఫికల్ లో Mac OS లేదా Windows వంటి ప్రపంచ,
మీరు మాత్రమే ఈ సంఖ్యలు ఉన్నప్పుడు ఒక చూడండి దోష సందేశం తెరపై బయటకు
మరియు ప్రోగ్రామర్ మీరు ఆ సంఖ్యను చూపిస్తుంది.
కానీ మేము ఏ లోపం చూడాలనుకుంటే సందేశం మేము అది ఇక్కడ ఏమి, ఉంది
కాబట్టి ./exit, Enter, ముద్రణ తప్పిపోయిన కమాండ్ లైన్ వాదన.
>> నేను ఇప్పుడు echo $ ?, చేస్తే ఇది హాస్యాస్పదమైన గుప్తమైన చూస్తున్న.
కానీ $?
మాయా అవతారంలో భాగం ఆ చెప్పారు హే, కంప్యూటర్,
చెప్పు ఏమి మునుపటి కార్యక్రమం యొక్క నిష్క్రమణ కోడ్ ఉంది.
నేను ఎంటర్ కొట్టాడు.
ఆ ఎందుకంటే నేను, 1 చూసే నేను తిరిగి నా ప్రధాన విధి చెప్పారు.
>> ఇంతలో, నేను డేవిడ్ ./exit లేకపోతే, ఎంటర్ నొక్కండి నేను చూస్తాను, డేవిడ్ హలో.
మరియు నేను ఇప్పుడు echo $ లేకపోతే ?, నేను హలో చూడండి 0.
కాబట్టి ఈ వాస్తవానికి విలువైన సమాచారం ఉంటుంది
అంత డీబగ్గర్ సందర్భంలో, మీరు మానవ, ఆసక్తి చూపేవారు ఎక్కువ.
కానీ డీబగ్గర్ మరియు ఇతర కార్యక్రమాలు మేము ఈ సెమిస్టర్ ఉపయోగిస్తాము
తరచూ ఆ సంఖ్యను పరిశీలిస్తారు, ఇది విధమైన మరుగునపడుతోంది అయినప్పటికీ
మీరు దాని కోసం, చూస్తుంది తప్ప గుర్తించడానికి లేదో ఒక ప్రోగ్రామ్ యొక్క
అమలు సరైన లేదా తప్పు.
>> కాబట్టి ఆ వచ్చాము ఈ రోజు చివరిలో.
మేము చూడటం ద్వారా నేడు ప్రారంభించండి డీబగ్గింగ్, మరియు కోర్సు మలుపు
కూడా, మరియు అప్పుడు మరింత ఆసక్తికరంగా, సాంకేతికంగా హుడ్ కింద
ఏమి వద్ద తీగలను కొనసాగుతుంది, ఉన్నాయి వారం మేము కేవలం మంజూరు కోసం పట్టింది,
మరియు ఖచ్చితంగా తీసుకువెళ్ళాడు స్క్రాచ్ లో మంజూరు చేసింది.
>> మేము అప్పుడు మేము యాక్సెస్ ఎలా చూశారు ఒక స్ట్రింగ్ లో విడివిడి అక్షరాలను,
మళ్ళీ ఒక ఉన్నత స్థాయి పట్టింది ఎలా well-- చూస్తూ, విషయాలు చూడండి
మేము వ్యక్తిగత వద్ద పొందడానికి అనుకుంటే నిర్మాణం వంటి జాబితాలో అంశాలను,
మేము బహుళ తీగలను అలా కాదు?
మరియు మేము ఆదేశ పంక్తి వాదనలు తో చేయవచ్చు.
కానీ ఇక్కడ కేవలం బాక్సులను ఈ చిత్రాన్ని ఈ సాధారణ ఆలోచన తావు
వ్యూహం, లేదా ఒక జాబితా, లేదా ఒక సదిశ యొక్క.
మీద ఆధారపడి సందర్భంలో, ఈ పదాలు అన్ని
కొద్దిగా అర్ధాలున్నాయి.
కాబట్టి సి లో, మేము మాత్రమే చూడాలని వ్యూహం గురించి మాట్లాడటానికి.
మరియు ఒక అర్రే ఒక భాగం ఉంది మెమొరీ, వీరిలో ప్రతి వార్తలు
అంశాలు తిరిగి, పక్కనే, తిరిగి, తిరిగి, తిరిగి.
>> మరియు ఆ అంశాలు సాధారణంగా ఉంటాయి, అదే రకం, పాత్ర,
పాత్ర, పాత్ర, పాత్ర, లేదా స్ట్రింగ్, స్ట్రింగ్, స్ట్రింగ్, స్ట్రింగ్ లేదా Int,
పూర్ణాంకానికి Int, ఇది ఏమైనా మేము స్టోర్ ప్రయత్నిస్తున్న.
కానీ రోజు చివరిలో, ఈ దానిని సంభావితంగా అనిపిస్తోంది.
మీరు వేస్తున్నాము మీ కంప్యూటర్ యొక్క మెమరీ లేదా RAM.
మరియు మీరు లోకి చెక్కటానికి చేస్తున్నారు ఒకే తరహా బాక్సులను, ఇవన్నీ
తిరిగి ఉంటాయి, వెనుకకు తిరిగి, ఈ విధంగా వెనుకకు.
>> మరియు గురించి nice ఏది ఈ ఆలోచన, మరియు నిజానికి
మేము ఈ విధంగా విలువలు వ్యక్తం చేసే మా డేటా నిర్మాణాలు మొదటి
తరగతి లో, మేము ప్రారంభించవచ్చు అంటే కోడ్ తో సమస్యలను పరిష్కరించటానికి
ఆ వారం 0 లో అలా అకారణంగా వచ్చింది.
మీరు ఫోన్ గుర్తుకు వస్తుంది పుస్తక ఉదాహరణకు,
మేము ఒక విభజన ఉపయోగిస్తారు జయించటానికి లేదా ఒక బైనరీ శోధన అల్గోరిథం
మొత్తం ద్వారా జల్లెడ పట్టు పేర్లు మరియు సంఖ్యలను యొక్క ఒక సమూహం.
కానీ మేము భావించబడుతుంది, రీకాల్, ఆ ఫోన్ బుక్ అప్పటికే క్రమబద్ధీకరించబడింది జరిగినది
ఎవరో ఇప్పటికే ఉందని అవ్ట్ పేర్ల జాబితా ఇచ్చారు చిత్రవిచిత్రమైన
మరియు వాటిని alphabetize ఎలా సంఖ్యల.
మరియు ఇప్పుడు C లో మేము, చాలా సామర్థ్యాన్ని కలిగి ఉంటాయి
విషయాలు బయటకు వేయడానికి, భౌతికంగా ఒక ఫోన్ బుక్ లో
కాని వాస్తవంగా ఒక కంప్యూటర్ యొక్క జ్ఞాపకశక్తి, ఇవ్వగల తదుపరి వారం ఉంటుంది
తొలి దీన్ని మళ్ళీ పరిచయం ఒక శ్రేణి మా డేటా నిర్మాణాలు
కానీ ముఖ్యంగా, అసలు కంప్యూటర్ సైన్స్ అల్గోరిథంలు అమలు
కోడ్ లో, ఇది మేము నిల్వ చేయవచ్చు ఈ వంటి నిర్మాణాలలో డేటా,
ఆపై ఇది రెట్టింపు మొదలు, మరియు నిజానికి అది తో సమస్యలు పరిష్కరించడంలో,
మరియు ఆ పైన నిర్మించడానికి, చివరికి, సి లో కార్యక్రమాలు,
పైథాన్, JavaScript, SQL డేటాబేస్ విచారణను?
>> మరియు మేము ఈ అన్ని చూస్తారు ఇరికించు వివిధ ఆలోచనలు.
కానీ ఇప్పుడు కోసం, గుర్తుచేసుకున్నారు మేము నేడు పరిచయం డొమైన్
ఈ విషయం ఇక్కడ ఉంది, మరియు గూఢ లిపి శాస్త్రం యొక్క ప్రపంచ.
మరుసటి సమస్యలు మీరే మధ్య గూఢ లిపి శాస్త్రం యొక్క కళ పరిష్కరించే,
స్క్రాంబ్లింగ్ మరియు డి-స్క్రాంబ్లింగ్ సమాచారం, మరియు ciphering
మరియు టెక్స్ట్ తెలుసుకొని, మరియు చివరికి ఊహిస్తూ
మీరు ఇప్పుడు తెలిసిన ఏమి హుడ్ కింద ఉంది
కాబట్టి మీరు చూడండి లేదా అందుకున్నప్పుడు ఈ సందేశం మీరు
అది మిమ్మల్ని అర్థమును.
అన్ని ఈ, మరియు మరింత తదుపరి సమయంలో.
>> [వీడియో ప్లేబ్యాక్]
>> -Mover కేవలం వచ్చారు.
నేను సందర్శన వెళ్ళి వెళుతున్న తన కాలేజీ ప్రొఫెసర్.
YEP.
హాయ్.
ఇది నీవు.
వేచి!
డేవిడ్.
నేను దొరుకుతుందని దీనికై మీరు ఏమి జరిగిందో.
దయచేసి, ఏదైనా సహాయం కాలేదు.
మీరు తన కళాశాల ఉన్నాయి సహవాసి మీరు కాదు?
మీరు అతన్ని ఉన్నప్పుడు ఉన్నాయి అతను CS50 ప్రాజెక్ట్ పూర్తి?
>> [సంగీతాన్ని]
>> -ఆ CS50 ఉంది.
>> నేను ఈ స్థానంలో ప్రేమ.
>> -తినెయ్యి.
మేము వ్యాపార వెళుతున్న చేస్తున్నాం.
>> [END ప్లేబ్యాక్]