[Powered by Google Translate] [వీక్ 4]
[డేవిడ్ J. మలన్] [హార్వర్డ్ విశ్వవిద్యాలయం]
[ఈ CS50 ఉంది.] [CS50.TV]
>> ఆల్ ది రైట్, ఈ CS50, మరియు ఈ వారం 4 ప్రారంభంలో ఉంది
మరియు ఈ నెమ్మదిగా సాధ్యం సార్టింగ్ అల్గోరిథంలు ఒకటి.
ఏ మేము అక్కడే వీక్షించారు అదేమిటో?
ఆ, (n ^ 2) + మొత్తం పెద్ద O క్రమంలో, బబుల్ సార్ట్ ఉంది
నిజానికి మేము అనాలో అతనికి ఈ ప్రపంచంలో మాత్రమే వాటిని కాదు
ఏ బబుల్ సార్ట్ లేదా దాని అమలు సమయం.
నిజానికి, ఈ Google యొక్క ఎరిక్ ష్మిత్ ఒక ఇంటర్వ్యూలో
మరియు మాజీ సెనేటర్ బరాక్ ఒబామా కేవలం కొన్ని సంవత్సరాల క్రితం.
>> ఇప్పుడు, సెనేటర్, మీరు, Google వద్ద ఇక్కడ ఉన్నాము
మరియు నేను ఒక ఉద్యోగ ఇంటర్వ్యూ వంటి అధ్యక్ష ఆలోచించడానికి ఇష్టపడతాను.
ఇప్పుడు, అధ్యక్షుడు గా ఉద్యోగంలో పొందడానికి కష్టం, మరియు మీరు ఇప్పుడు వాతావరణాన్ని ద్వారా వెళుతున్న.
ఇది Google ఒక ఉద్యోగం పొందడానికి కూడా కష్టం.
, మేము ప్రశ్నలు, మరియు మేము మా అభ్యర్ధులు ప్రశ్నలు అడగండి
మరియు ఈ ఒక లారీ స్క్విమ్మర్ నుండి.
మీరు అబ్బాయిలు నేను తమాషా థింక్ అయామ్? ఇది కుడి ఇక్కడ ఉన్నారు.
ఒక మిలియన్ 32-bit పూర్ణాంకాల క్రమం అత్యంత ప్రభావవంతమైన మార్గం ఏమిటి?
[నవ్వు]
బాగా
క్షమించండి. >> లేదు, లేదు, లేదు, లేదు.
నేను బబుల్ సార్ట్ వెళ్ళడానికి తప్పు మార్గంలో ఉంటుందని భావిస్తున్నాను.
>> అతనికి ఈ చెప్పారు ఎవరు, న వస్తాయి?
గత వారం, మేము కనీసం ఒక రోజు, కోడ్ విరామం తీసుకుంది రీకాల్
మరియు సాధారణంగా పరిష్కార కొన్ని ఉన్నత స్థాయి ఆలోచనలను మరియు సమస్య దృష్టి సారించడం ప్రారంభించారు
శోధించడం మరియు క్రమబద్ధీకరించేందుకు సందర్భంలో,
మరియు మేము, మేము గత వారం ఈ పేరు చరుస్తారు లేదని ఏదో పరిచయం
కానీ asymptotic సంజ్ఞామానం, బిగ్ O, బిగ్ ఒమేగా,
మరియు కొన్నిసార్లు బిగ్ తీటా సంజ్ఞామానం, మరియు ఈ కేవలం మార్గాలు ఉన్నాయి
అల్గోరిథంలు యొక్క రన్నింగ్ సమయం వివరించే,
ఇది అమలు చేయడానికి ఒక అల్గోరిథం పట్టే ఎంత సమయం.
>> మరియు మీరు పరిమాణం పరంగా మీరు నడుస్తున్న సమయంలో గురించి మాట్లాడారు గుర్తుచేసుకున్నారు ఉండవచ్చు
మేము సాధారణంగా సమస్య ఉండవచ్చు ఏ, n కాల్ ఇన్పుట్, యొక్క,
పేరు n, గది లో ప్రజల సంఖ్య
ఒక ఫోన్ బుక్ లోని పేజీల సంఖ్య, మరియు మేము విషయాలను రాయడం మొదలు
O వంటి (n ^ 2) లేదా O (n) లేదా O (N log N),
మరియు గణిత చాలా ఖచ్చితంగా పని చెయ్యలేదు కూడా
మరియు అది n ఉంది ² - n / 2 లేదా అలాంటిదే
మేము బదులుగా కేవలం, లోయర్ ఆర్డర్ నిబంధనలు కొన్ని తీసివేసినట్లు చేస్తుంది
మరియు ప్రేరణ మేము నిజంగా ఒక కావలసిన ఉంది
విశ్లేషించే లక్ష్యం మార్గం విధమైన
కార్యక్రమాలు యొక్క పనితీరు లేదా అల్గోరిథంలు యొక్క ప్రదర్శన
ఆ రోజు చివరిలో, ఉదాహరణకు, లేదు
మీ కంప్యూటర్ యొక్క వేగాన్ని రోజు.
>> ఉదాహరణకు, మీరు బబుల్ సార్ట్ అమలు ఉంటే,
లేదా మీరు, నేటి కంప్యూటర్లో విధమైన లేదా ఎంపిక విధమైన విలీనం అమలు
ఒక 2 GHz కంప్యూటర్, మరియు మీరు, అమలు
మరియు అది ఒక 3 GHz ఉంది తరువాత సంవత్సరం, సెకన్లు కొన్ని సంఖ్య పడుతుంది
లేదా ఒక 4 GHz కంప్యూటర్, మరియు మీరు ఆ "వావ్, నా అల్గోరిథం దావా ఉండవచ్చు
వాస్తవానికి ఆ సందర్భంలో ఖచ్చితంగా కాదు ఉన్నప్పుడు ", రెండుసార్లు వేగంగా ఉంది.
ఇది కేవలం హార్డ్వేర్ వేగంగా సంపాదించిన చేసింది, కానీ మీ కంప్యూటర్
, అందువలన మేము నిజంగా వంటి వాటిని తీసివేసినట్లు కావలసిన లేదు
2 యొక్క గుణిజాలను లేదా 3 యొక్క గుణిజాలను దానిని వివరించేటప్పుడు విషయానికి వస్తే
ఎంత వేగంగా లేదా నెమ్మదిగా వెళుతున్నా ఒక అల్గోరిథం మరియు నిజంగా కేవలం దృష్టి
n లేదా దాని కొన్ని అంశం, న
కొన్ని శక్తి దాని గత వారం నుండి రకాల సందర్భంలో.
, విలీనం విధమైన సహాయంతో గుర్తుచేసుకున్నారు
మేము బబుల్ సార్ట్ మరియు ఎంపిక విధమైన కంటే ఎక్కువ చేస్తామని ఉన్నాయి
మరియు కూడా ప్రవేశాన్ని విధమైన.
>> మేము మళ్లీ n లాగ్ n మొదలుపెట్టాను, మరియు
లాగ్ n సాధారణంగా పెరిగే ఏదో సూచిస్తుంది గుర్తుచేసుకున్నారు
నెమ్మదిగా తరువాత n, కాబట్టి N log N ఇప్పటివరకు మంచి ఉంది
అది n ² కంటే తక్కువ ఎందుకంటే.
కానీ విలీనంతో విధమైన తో n సాధించడానికి n లాగిన్
మేము పరపతి వచ్చింది ఒక ఆలోచన యొక్క ప్రాధమిక క్రిమి ఏమిటి
మేము కూడా వారం 0 లో తిరిగి కొనుగోలు చేసే?
మేము ఎలా విలీనంతో విధమైన తో తెలివిగా క్రమబద్ధీకరించేందుకు సమస్య పరిష్కరించడానికి వచ్చింది?
బహుశా, కీ అంతర్దృష్టి ఏమిటి?
ఎవరైనా అన్ని వద్ద.
సరే, యొక్క ఒక అడుగు వెనక్కు తీసుకుందాం.
మీ సొంత మాటలలో ది విధమైన విలీనం వివరించండి.
అది ఎలా పని చేశారు?
సరే, మేము వారం 0 తిరిగి వరుస చేస్తాము.
సరే, అవును.
[వినబడని-విద్యార్థి]
మంచి, సరే, మేము 2 ముక్కలుగా సంఖ్యల శ్రేణి విభజించబడింది.
, మేము ఆ ముక్కలు ప్రతి క్రమబద్ధీకరించబడతాయి, ఆపై మేము వాటిని విలీనం
ఈ పెద్ద అని ఒక సమస్యను యొక్క ముందు మరియు మేము ఈ ఆలోచన చూసిన
మరియు ఈ పెద్ద లేదా ఈ పెద్దది ఒక సమస్య గా అప్ వేరుచేయడానికి.
>> ఫోన్ బుక్ ఉదాహరణ గుర్తు.
, క్రితం వారాల నుండి స్వీయ లెక్కింపు అల్గోరిథం రీకాల్
కాబట్టి విలీనం విధమైన ఇక్కడ ఈ pseudocode సంగ్రహించబడిన జరిగినది.
మీరు n మూలకాలు ఇచ్చిన చేసినప్పుడు, మొదటి అది తెలివి తనిఖీ ఉంది.
N <2 అప్పుడు అన్ని వద్ద ఏమీ లేకపోతే
n <2 అప్పుడు n స్పష్టంగా 0 లేదా 1 ఉంటే ఎందుకంటే,
అది గాని ఉంటే మరియు కనుక 0 లేదా 1 క్రమం ఏమీ లేదు.
మీరు పూర్తి చేసిన.
మీ జాబితా ఇప్పటికే తేలికగా క్రమబద్ధీకరించబడింది.
కానీ మీరు 2 లేదా ఎక్కువ అంశాలను పొందారు లేకపోతే ఉంటే కొనసాగి, వాటిని విభజించడానికి
2 భాగాలుగా విడదీస్తుంది, ఎడమ మరియు కుడి.
ఆ చొక్కాలను ప్రతి క్రమీకరించు, ఆపై క్రమబద్ధీకరించబడతాయి విభజించటం విలీనం.
కానీ ఇక్కడ సమస్య మేము punting చేస్తున్నట్లు మొదటి చూపులో ఈ భావం ఉంటుంది.
నేను ఈ n మూలకాలు క్రమం చేయడానికి మీరు అడిగారు ఈ ఆ ఒక వృత్తాకార నిర్వచనం
మరియు మీరు "ఆల్ ది రైట్, జరిమానా, మేము ఆ n / 2 మరియు ఆ n / 2 అంశాలు క్రమం చేస్తాము" నాకు చెప్పుకుంటున్నారు
నా తదుపరి ప్రశ్నకు ఉండబోతుంది "ఎలా మీరు n / 2 అంశాలు క్రమబద్ధీకరించాలి, ఫైన్?"
>> కాని ఈ ప్రోగ్రామ్ యొక్క విధానం యొక్క,
ఈ బేస్ ఆధారాలున్నాయి కాబట్టి, మాట్లాడుతున్నారు,
n వెంటనే 2 తిరిగి వంటి కొన్ని నిర్దిష్ట విలువను <ఉంటే అని ఈ ప్రత్యేక సందర్భంలో.
అదే వృత్తాకార సమాధానం తో ప్రతిస్పందించము.
ఈ ప్రక్రియ, ఈ cyclicity చివరికి ముగుస్తుంది.
నేను "క్రమీకరించు ఈ n మూలకాలు," మీరు అడగండి మీరు, చెప్పినట్టైతే "ఫైన్, ఈ n / 2 క్రమం"
అప్పుడు మీరు "ఫైన్, క్రమీకరించు ఈ n / 4, n / 8, n/16," సే
చివరకు మీరు ఒక పెద్ద తగినంత సంఖ్యలో తిరగడానికి చేస్తాము
మీరు, మీరు చెప్పగలదు సమయంలో, కేవలం 1 మూలకం ఎడమ ఉండాలని
"ఇక్కడ, ఇక్కడ ఒక క్రమబద్ధీకరించబడతాయి ఒకే అంశం."
ఈ అల్గోరిథం యొక్క మెరుపులో అప్ ఇక్కడ నిజానికి నుంచి ఉద్భవించిందని ఉంది
ఒకసారి మీరు ఈ వ్యక్తిగతంగా క్రమబద్ధీకరించబడతాయి జాబితాలు అన్ని,
పనికిరాని కనబడే పరిమాణం 1, మాత్రమే ఉంటాయి అన్ని
మీరు వాటిని విలీనం మరియు వాటిని విలీనం ప్రారంభించిన తర్వాత
రాబ్ వీడియో చివరకు క్రమబద్ధీకరించబడతాయి జాబితా వచ్చింది మీరు చివరకు నిర్మించే.
>> కానీ ఈ ఆలోచన చాలా సార్టింగ్ దాటి.
సూత్రం పిలిచే ఈ కార్యక్రమంలో పొందుపర్చిన ఈ ఆలోచన ఉంది
మీరు ఒక ప్రోగ్రామ్ వస్తే ఆలోచన,
మరియు మీరు మీరే కాల్ కొన్ని సమస్యను పరిష్కరించడానికి,
లేదా, మీరు ఒక పనిచేస్తాయి ప్రోగ్రామింగ్ భాషలు సందర్భంలో ఉంచండి
మరియు ఒక సమస్యను పరిష్కరించడానికి, మీరు ఫంక్షన్ మీరే కాల్
మళ్ళీ, మళ్ళీ, మళ్ళీ, కానీ మీరు చర్య
మీరే అనంతమైన అనేక సార్లు కాల్ చెయ్యలేరు.
చివరికి మీరు, మాట్లాడటానికి, క్రింద అవుట్ ఉంటుంది
మరియు అని కొన్ని హార్డ్ కోడెడ్ బేస్ పరిస్థితిని
ఈ సమయంలో అలా మీరే అని పిలవడం ఆపివేయండి అని మొత్తం ప్రక్రియ
చివరకు నిజానికి ఆగుతుంది.
ఇది నిజంగా recurse కు, శతకము
>> మేము సే,, తో ఉన్న ఒక సరళమైన, అల్పమైన ఉదాహరణ చేయవచ్చు ఉంటే, యొక్క చూసేలా
ఇక్కడ వేదికపై నాతో 3 ప్రజలు, ఎవరైనా సౌకర్యవంతమైన ఉంటే.
అప్, 2 మరియు 3 న 1, వస్తాయి.
మీరు 3 ఇక్కడ వచ్చి చేయండి.
మీరు ఒక లైన్ లో ఇక్కడ నాకు కుడి ప్రక్కన నిలబడి చేయాలనుకుంటే, అనుకుందాం ఆ చేతిలో సమస్య
చాలా తేలికగా ఇక్కడ ఉన్నారు వ్యక్తుల గణన.
కానీ స్పష్టముగా, నేను ఈ లెక్కింపు ఉదాహరణ అలసిన ఉన్నాను.
ఇది కొంత సమయం, 1, 2, మరియు డాట్, డాట్, డాట్ తీసుకోవాలని అన్నారు.
ఇది ఎప్పటికీ తీసుకోవాలని చెప్పారు.
నేను సహాయంతో పూర్తిగా రౌడీ ఈ సమస్య యొక్క మీ పేరు ఏమిటి? కాకుండా మీరు
సారా. >> సారా, అన్ని కుడి.
కెల్లీ. >> కెల్లీ మరియు?
>> విల్లీ. >> విల్లీ, సారా, కెల్లీ, మరియు విల్లీ.
ప్రస్తుతం నేను ఎవరో ప్రశ్న కోరారు
ఎంత మంది ఈ వేదికపై వరకు, మరియు నేను సంఖ్య ఆలోచన ఉంది.
ఈ ఒక నిజంగా పొడవైన జాబితా, కావున బదులుగా నేను ఈ ట్రిక్ చేయ బోతున్నాను.
నేను, కృతి యొక్క అత్యంత చేయడానికి నా ప్రక్కన వ్యక్తి అడగండి వెళుతున్న
మరియు ఒకసారి ఆమె పని చాలా చేయడం జరుగుతుంది
నేను సాధ్యం పని కనీసం మొత్తం చేయబోవడం మరియు కేవలం 1 జోడించండి నేను
, కాబట్టి ఇక్కడ వెళ్ళండి ఏమైనా ఆమె సమాధానం కు.
నేను వేదిక పై ఎన్ని ప్రజలు కోరారు చేసిన.
ఎంత మంది మీరు ఎడమ వైపున వేదికపై ఉన్నాయి?
సరే >>? నా ఎడమ, కానీ మోసం లేదు.
ఆ సరైన అని, మంచి, కానీ మేము ఈ తర్కం కొనసాగించాలని మీరు ఉంటే
మీరు అదేవిధంగా మీరు ఎడమ వైపున రౌడీ ఈ సమస్య చేయదలిచిన యొక్క ఊహించుకోవటం తెలియజేయండి
కాబట్టి కాకుండా సమాధానం కంటే నేరుగా ముందుకు మరియు కేవలం బక్ పాస్.
ఓహ్, నా ఎడమ ఎన్ని ప్రజలు?
ఎడమవైపు ఎంత మంది ఉన్నారు?
1.
[నవ్వు]
సరే, 0, కనుక ఇప్పుడు విల్లీ చేశారు
మీ సమాధానం 0 మాట్లాడుతూ ఈ దిశలో తిరిగి చేసిన ఉంది.
ఇప్పుడు, మీరు ఏమి చెయ్యాలి? >> 1.
సరే, మీరు 1, కాబట్టి మీరు చెప్పిన "అన్ని కుడి, నేను 1 జోడించండి వెళుతున్న
కు ఏ విల్లీ యొక్క లెక్కింపు జరిగింది, "కాబట్టి 1 + 0.
కుడివైపు మీ సమాధానం మీరు ఇప్పుడు 1 ఉన్నాము ఇప్పుడు
1. >> ఆ గని 2 ఉంటుంది.
, కాబట్టి మీరు, 1 మునుపటి సమాధానం గుడ్ వేస్తున్నాము
మీరు చేయాలనుకుంటున్నారా పని తక్కువగా జోడించడం, ఇది +1 ఉంది.
మీరు ఇప్పుడు 2 కలిగి, మరియు మీరు నాకు ఏ విలువ చేతితో?
3, నేను, క్షమించాలి, 2 అర్ధం.
గుడ్.
>> Well, మేము ఎడమ 0 వచ్చింది.
, అప్పుడు మేము 1, మరియు ఆ తరువాత మేము 2 జోడించండి
ఇప్పుడు మీరు నాకు సంఖ్య 2 ఇవ్వడానికి మీరు
మరియు నేను 3, +1, సరే, చెప్పడం నేను.
ఈ వేదికపై నా ప్రక్కన నిలబడి 3 ప్రజలు నిజానికి ఉంది
కాబట్టి మేము సహజంగా, చాలా సరళంగా ఈ చేసి
స్పష్టమైన పద్ధతిలో చాలా, కాని మేము నిజంగా ఏం చేసావ్?
మేము మొదట పరిమాణం 3 యొక్క ఒక సమస్య పట్టింది.
మేము అప్పుడు, పరిమాణం 2 యొక్క ఒక సమస్య గా విఫలమయ్యాయి
అప్పుడు 1 పరిమాణం సమస్య, మరియు అప్పుడు మూల కేసు చివరకు
నిజానికి, OH, అక్కడ ఎవరూ ఉన్నది
ఈ దశలో విల్లీ, ఒక హార్డ్ కోడెడ్ సమాధానం సార్లు రెండు సమర్థవంతంగా తిరిగి
మరియు రెండవది తర్వాత, bubbled, అప్ bubbled, అప్ bubbled జరిగినది
మరియు ఈ ఒక అదనపు 1 లో జోడించడం ద్వారా
మేము సూత్రం ఈ ప్రాథమిక ఆలోచన అమలు చేసిన.
>> ఇప్పుడు, ఈ సందర్భంలో ఇది నిజంగా ఒక సమస్యను పరిష్కరించడానికి లేదు
ఏ మరింత సమర్థవంతంగా అప్పుడు మేము ఇప్పటివరకు చూసిన.
కానీ మేము ఇప్పటివరకు వేదిక చేసిన అల్గోరిథంలు గురించి ఆలోచించటం.
మేము, సుద్ద బోర్డ్ పత్రిక యొక్క 8 ముక్కలు కలిగి
వీడియో మీద సీన్ సంఖ్య 7 కోసం చూస్తున్నాడు, మరియు అతను నిజంగా ఏం చేసావ్ ఉన్నప్పుడు?
Well, అతను విభజన ఎలాంటి చేయండి మరియు ఆక్రమించేందుకు లేదు.
ఆయన సూత్రం ఎలాంటి ఆడలేదు.
అయితే అతను ఈ సరళ అల్గోరిథం చేశాడు.
కానీ మేము వేదిక పైన విభజించిన సంఖ్యల ఆలోచన పరిచయం చేసినప్పుడు గత వారం నివసిస్తున్నారు
అప్పుడు మేము, మధ్య వెళ్ళి ఈ స్వభావం కలిగి
ఈ సమయంలో మేము, పరిమాణం 4 లేదా పరిమాణం 4 యొక్క మరొక జాబితా యొక్క ఒక చిన్న జాబితా కలిగి
మరియు తర్వాత మేము ఖచ్చితమైన సమస్య ఉంది, అందుచే మేము పునరావృతం, పునరావృతం, పునరావృతం.
ఇతర మాటల్లో చెప్పాలంటే, recursed.
మాతో సూత్రం ప్రదర్శించినందుకు ఇక్కడ మా 3 స్వచ్ఛంద సేవకుల చాలా ధన్యవాదాలు.
>> మేము ఇప్పుడు కొంచెం కాంక్రీటు ఈ చేయలేరు లేదో యొక్క చూసేలా,
మళ్ళీ మేము చాలా సులభంగా చేయగల ఒక సమస్యలను పరిష్కరించటం,
కానీ మేము ఈ ప్రాథమిక ఆలోచన అమలు ఒక పునాది రాయి గా ఉపయోగించండి.
నేను, సంఖ్యల సమూహాన్ని సమ్మషన్ గణించడం చేయాలనుకుంటే
ఉదాహరణకు, మీరు సంఖ్య 3 లో పాస్ ఉంటే,
నేను, మీరు సిగ్మా 3 యొక్క విలువ ఇవ్వాలని
కాబట్టి 3 మొత్తం + 2 + 1 + 0.
నేను, సమాధానం 6 తిరిగి పొందడానికి కావలసిన
కాబట్టి మేము ఈ సిగ్మా ఫంక్షన్, ఈ సమ్మషన్ ఫంక్షన్ అమలు ఉంటాం
ఆ, మళ్ళీ, ఇన్పుట్ లో పడుతుంది, మరియు అప్పుడు సమ్మషన్ తిరిగి
డౌన్ 0 ఆ సంఖ్య అన్ని మార్గం.
మేము కుడి, అందంగా కేవలం ఈ చేయగల?
మేము, మళ్ళీ వెతికినా నిర్మాణం ఏదో ఈ చేయగల
కాబట్టి నన్ను ముందుకు వెళ్లి ఈ ప్రారంభించడానికి అనుమతిస్తాయి.
>> Stdio.h చేర్చండి.
ఇక్కడ పని నాకు ప్రధాన లోకి నాకు పొందండి లెట్.
లెట్ యొక్క sigma.c ఈ సేవ్.
అప్పుడు నేను ఇక్కడ వెళ్ళండి వెళుతున్న మరియు నేను, ఒక పూర్ణాంకానికి n డిక్లేర్ వెళుతున్న
మరియు నేను యూజర్ సహకారం లేదు, అయితే క్రింది వాటిని వెళుతున్న.
యూజర్ me సానుకూల నంబర్ ఇవ్వలేదు అయితే
నాకు ముందుకు వెళ్లి n = GetInt కోసం ప్రాంప్ట్ తెలియజేయండి
మరియు, వారిని ఏమి కొన్ని సూచనలు కల్పించడానికి అనుమతిస్తాయి
కాబట్టి printf ("సానుకూల పూర్ణాంక దయచేసి").
సమయానికి మేము లైన్ 14 కొట్టిన ఈ వంటి సులభమైన జస్ట్ ఏదో
మేము ఇప్పుడు n బహుశా ఒక సానుకూల పూర్ణాంక ఉన్నాయి.
>> ఇప్పుడు అది ఏదో ఒకటి చూద్దాం.
నాకు ముందుకు వెళ్లి సమ్మషన్ గణించడం తెలియజేయండి, కనుక Int మొత్తం = సిగ్మా (n).
సిగ్మా కేవలం సమ్మషన్ ఉంది, కాబట్టి నేను ఫ్యాన్సియెర్స్ విధంగా అది వ్రాసే నేను.
మేము అక్కడే అది సిగ్మా పిలుస్తాను.
ఆ మొత్తాన్ని, మరియు ఇప్పుడు నేను, ఫలితంగా ముద్రించాలా వెళుతున్న
printf (మొత్తం "మొత్తం d, \ n% ఉంది").
మరియు నేను మంచి కొలత కోసం 0 తిరిగి పొందుతారు.
మేము, ఆసక్తికరమైన భాగంగా తప్ప ఈ కార్యక్రమం అవసరం ప్రతిదీ చేసిన
ఇది వాస్తవానికి సిగ్మా ఫంక్షన్ అమలు ఉంది.
>> నాకు క్రింద ఇక్కడ డౌన్ వెళ్ళి, నాకు ఫంక్షన్ సిగ్మా డిక్లేర్ తెలియజేయండి లెట్.
ఇది రకం పూర్ణాంకం యొక్క అని ఒక వేరియబుల్ తీసుకోవాలని సంపాదించి
ఏ డేటా రకం సిగ్మా నుండి బహుశా తిరిగి అనుకుంటున్నారు?
Int, నేను లైన్ 15 నా అంచనాలను మ్యాచ్ మీరు ఎందుకంటే.
ఇక్కడ నాకు ముందుకు వెళ్లి ఈ అమలు తెలియజేయండి
ఒక అందమైన సూటిగా విధంగా.
>> యొక్క ముందుకు వెళ్లి Int మొత్తం = 0 అని పిలవబడు,
మరియు ఇప్పుడు నేను ఇక్కడ లూప్ కొద్దిగా కలిగి వెళ్ళి వెళుతున్న
ఆ, ఈ వంటి ఏదో చెప్పడానికి జరగబోతోంది
మొత్తం + = i (; నేను <= సంఖ్య i + + Int i = 0) కోసం.
మరియు నేను మొత్తం తిరిగి వెళుతున్న.
నేను మార్గాల్లో సంఖ్య ఈ అమలు చేశారు.
నేను కొంత లూప్ ఉపయోగించారు కాలేదు.
నేను నిజంగా కోరుకుంటే మొత్తం వేరియబుల్ను వుపయోగిస్తూ దాటవేయబడింది ఉండవచ్చు
కానీ చిన్న లో, మేము నిజంగా కాదు ఉంటే మందమతి మొత్తం 0 ప్రకటించే ఒక చర్య.
అప్పుడు, సంఖ్య ద్వారా మీద 0 నుంచి iterates
మరియు ప్రతి పునరావృతం మీద మొత్తానికి ప్రస్తుత విలువ జతచేస్తుంది మరియు తరువాత మొత్తం తిరిగి.
>> ఇప్పుడు, ఇక్కడ కొంచెం ఆప్టిమైజేషన్ ఉంది.
ఈ బహుశా ఒక వృధా దశ, కానీ అందువలన ఇది. ఇప్పుడు ఆ మంచిది.
మేము కనీసం ఉన్నారు పరిపూర్ణమైన ఉండటం మరియు న 0 గోయింగ్ ఆల్ ది వే.
చాలా హార్డ్ మరియు చాలా సూటిగా లేదు,
కానీ సిగ్మా ఫంక్షన్ తో మేము అదే అవకాశం అవుతుంది
మేము వేదిక పైన ఇక్కడ వలె.
వేదికపై మేము, నా ప్రక్కన ఎంత మంది మంది పౌరులు
కానీ బదులుగా మేము సంఖ్య 3 + 2 + 1 లెక్కించడానికి కోరుకుంటే
క్రిందికి 0 లో మేము ఒక ఫంక్షన్ వలె రౌడీ అనుకొనుట
నేను బదులుగా పునరావృత గా వివరించడానికి మేము.
ఇక్కడ శీఘ్ర తెలివి తనిఖీ మరియు నేను మందమతి పడరాదని మనం.
>> నేను తప్పు అని ఈ కార్యక్రమంలో కనీసం ఒక్క విషయము తెలుసు.
నేను ఎంటర్ నొక్కండి నేను నా పదాన్ని ఎలాంటి పొందడానికి వెళ్తున్నాను?
నేను కోప్పడ్డాడు చేయడానికి ఏం వెళ్తున్నాను?
అవును, నేను మర్చిపోయాను నమూనా, నేను లైన్ 15 సిగ్మా అనే చర్యను ఉపయోగించటం నేను అలా
కానీ 22 వ వరుస వరకు డిక్లేర్డ్, నేను ఉత్తమ ముందుగా ఇక్కడ వెళ్ళండి కాదు
మరియు ఒక నమూనా, మరియు నేను Int సిగ్మా (Int సంఖ్య) చెప్పడానికి చేస్తాము, అంతే.
ఇది దిగువన అమలు ఉంది.
>> లేదా నేను ఈ పరిష్కరించేందుకు కాలేదు మరొక విధంగా,
నేను, ఇది చెడు కాదు, అక్కడ అప్ ఫంక్షన్ తరలించడానికి కాలేదు
కానీ కనీసం మీ కార్యక్రమాలు, స్పష్టముగా, దీర్ఘ పొందడానికి ప్రారంభించిన
నేను ఎల్లప్పుడూ ఎగువన ప్రధాన కలిగి కొన్ని విలువ ఉందని నేను అనుకుంటున్నాను
మీరు రీడర్ లో ఫైల్ను తెరవడం వెంటనే చూడగలరు ఆ
ప్రోగ్రామ్ ద్వారా అన్వేషణ చేయకుండా ఏమి
ప్రధాన విధి వెతుకుతున్న.
యొక్క ఇక్కడ నా టెర్మినల్ విండో క్రిందికి వెళ్ళి తెలపండి, సిగ్మా సిగ్మా తయారు చేయడం ప్రయత్నించండి
మరియు నేను చాలా ఇక్కడ చిత్తు చేశాడు.
ఫంక్షన్ GetInt యొక్క పరిపూర్ణమైన ప్రకటన ఏమి else చేయడానికి ను మర్చిపోతే అంటే?
[వినబడని-విద్యార్థి]
గుడ్, కాబట్టి స్పష్టంగా సాధారణ తప్పు, కాబట్టి, ఇక్కడ యొక్క ఈ ఏర్పాటు తెలియజేయండి
cs50.h, మరియు ఇప్పుడు నా టెర్మినల్ విండో తిరిగి వదలి వేస్తారు.
>> నేను తెర క్లియర్ చేస్తాము, మరియు నేను సిగ్మా తయారు తిరిగి పొందుతారు.
ఇది సంకలనం తెలుస్తోంది. నాకు ఇప్పుడు సిగ్మా అమలు అయ్యేలా అనుమతించండి.
నేను సంఖ్య 3 టైప్ చేస్తాము, మరియు నేను 6 పొందండి, కనుక ఒక కఠినమైన చెక్
కానీ కనీసం అది మొదటి చూపులో పని తెలుస్తోంది, కానీ ఇప్పుడు లెట్స్ అది వేరుగా రిప్
మరియు లెట్స్ వాస్తవానికి, మళ్ళీ, సూత్రం యొక్క ఆలోచన పరపతి
చాలా సులభమైన సందర్భంలో కాబట్టి కొన్ని వారాల సమయం లో
మేము శ్రేణుల కంటే ఫ్యాన్సియెర్స్ డేటా నిర్మాణాలు అన్వేషించడం ప్రారంభించిన
మేము ఇది తో సంచిలో మరొక సాధనం కలిగి
మేము చూస్తారు ఆ డేటా నిర్మాణాలు సర్దుబాటు.
ఈ పద్దతి విధానం, లూప్ ఆధారిత విధానం.
>> ఇప్పుడు దీన్ని బదులుగా నాకు లెట్.
బదులుగా ఏమంటారంటే నాకు లెట్ ఆ సంఖ్యను సమ్మషన్
నిజంగా అదే విషయం 0 క్రిందికి ఉంది
సంఖ్య + సిగ్మా (సంఖ్య - 1).
ఇతర మాటలలో, కేవలం వేదికపై నేను, నా ప్రక్కన ప్రజలు ప్రతి punted
మరియు అవి, మనం చివరికి విల్లీ వద్ద అవుట్ పడిపోవటంతో వరకు punting ఉంచిన
ఎవరు 0 వంటి హార్డ్ కోడెడ్ సమాధానం తిరిగి వచ్చింది.
ఇక్కడ ఇప్పుడు మేము అదేవిధంగా సిగ్మా కొరకు punting చేస్తున్నారు
అదే ఫంక్షన్ అసలు, కాని కీ అంతర్దృష్టి ఇక్కడ జరిగినది
మేము సమంగా సిగ్మా కాల్ చేస్తున్నట్లు ఉంది.
మేము n అక్కడ లేదు.
మనం స్పష్టంగా సంఖ్య అక్కడ ఉన్నాం - 1,
కాబట్టి కొద్దిగా చిన్న సమస్య, కొద్దిగా చిన్న సమస్య.
>> దురదృష్టవశాత్తు, ఈ ఇంకా చాలా పరిష్కారం కాదు, మరియు మేము పరిష్కరించడానికి ముందు
మీరు కొన్ని వద్ద స్పష్టమైన వంటి ఏమిటో జంపింగ్ ఉండవచ్చు
నాకు ముందుకు వెళ్లి తయారు తిరిగి తెలియజేయండి.
ఇది సరే కంపైల్ తెలుస్తోంది.
నాకు 6 తో సిగ్మా తిరిగి లెట్.
అయ్యో, నాకు 6 తో సిగ్మా తిరిగి తెలియజేయండి.
మేము అదే అనుకోకుండా చివరిసారి అయితే ముందు ఈ చూసిన.
నేను ఈ గుప్తమైన విభజన లోపంగా వచ్చింది? అవును.
[వినబడని-విద్యార్థి]
మరింత ప్రత్యేకంగా ఎటువంటి ఆధారం కేస్, మరియు, బహుశా ఏ జరిగింది?
ఇది ఏమిటి ప్రవర్తన యొక్క ఒక లక్షణం?
కొద్దిగా గట్టిగా చెప్పాను.
[వినబడని-విద్యార్థి]
ఇది ప్రభావవంతంగా ఒక అనంతమైన లూప్, మరియు అనంత వలయాలు తో సమస్య
వారు ఈ విషయంలో సూత్రం కలిగి ఉన్నప్పుడు, ఒక ఫంక్షన్ కూడా కాల్
మీరు ఒక ఫంక్షన్ కాల్ ప్రతిసారీ జరుగుతుంది?
Well, మేము ఒక కంప్యూటర్ లో మెమొరీ సిద్ధం ఎలా తిరిగి అనుకుంటున్నాను.
మేము, క్రింద ఉన్న స్టాక్ అనే మెమరీ ఈ భాగం ఉంది అన్నారు
మరియు మీరు కొంచెం మెమరీ ఒక ఫంక్షన్ కాల్ ప్రతిసారీ ఉంచే
ఆ ఫంక్షన్ యొక్క స్థానిక చరరాశులు లేదా పారామితులు కలిగిన ఈ అని పిలవబడే స్టాక్ న,
సిగ్మా సిగ్మా కాల్స్ కాల్స్ అయితే సిగ్మా సిగ్మా కాల్స్
సిగ్మా కాల్స్ పేరు ఈ కథ ముగింపు చేస్తుంది?
>> సరే, చివరికి కారణంతో మొత్తం
మీరు మీ కంప్యూటర్ అందుబాటులో కలిగి మెమరీ.
మీరు లోపల ఉండాలని కోరుకుంటున్నాము చేస్తున్న విభాగంలో, ఆక్రమిత
మరియు మీరు ఈ విభజన లోపంగా పొందండి, కోర్, కురిపించింది
మరియు కురిపించింది ఏ కోర్ అంటే నేను ఇప్పుడు కోర్ అనే ఫైల్ కలిగి ఉంటుంది
ఇది సున్నాలు మరియు వాటిని కలిగి ఫైలు
వాస్తవానికి భవిష్యత్తులో diagnostically ఉపయోగకరంగా ఉంటుంది.
మీ బగ్ ఉన్న ఇది మీకు స్పష్టమైన కాకపోతే
మీరు నిజంగా, మాట్లాడటానికి, ఫోరెన్సిక్ విశ్లేషణ యొక్క ఒక బిట్ చేయవచ్చు
ఈ కోర్ డంప్ ఫైలు న, ఇది మళ్ళీ, కేవలం సున్నాలు మరియు వాటిని పూర్తి బంచ్ ఉంది
ఆ ముఖ్యంగా మెమరీ మీ ప్రోగ్రామ్ యొక్క స్థితి సూచిస్తుంది
క్షణం ఈ విధంగా కుప్పకూలింది.
>> ఇక్కడ పరిష్కారం మేము గుడ్డిగా, సిగ్మా తిరిగి కాదు
సంఖ్య + కొద్దిగా చిన్న సమస్య యొక్క సిగ్మా.
మేము ఇక్కడ బేస్ కేసులో రకమైన కలిగి ఉండాలి
మరియు బేస్ కేసు బహుశా ఉండాలి?
[వినబడని-విద్యార్థి]
సరే కాలం సంఖ్య సానుకూల మనం నిజంగా, ఈ తిరిగి ఉండాలి
లేదా మరొక విధంగా చెప్పాలంటే, సంఖ్య ఉంటే, సే, <= 0 కు
మీరు, నేను ముందుకు వెళ్లి 0 తిరిగి ఉంటాం ఏ, తెలిసిన
విల్లీ చేశాడు అనే మరియు మిగిలినవి, నేను ముందుకు వెళుతున్న
మరియు ఈ తిరిగి, కాబట్టి ఇది చాలా తక్కువ కాదు
మేము మొదటి లూప్ ఒక ఉపయోగించి కొరడాతో ఆ పునరుత్థాన వెర్షన్,
కానీ దానికి గాంభీర్యం, ఈ విధమైన అక్కడ గమనిస్తారు.
బదులుగా కొన్ని సంఖ్య తిరిగి మరియు అన్ని ఈ గణిత ప్రదర్శన యొక్క
మరియు స్థానిక వేరియబుల్స్ తో సంగతులకు జోడించడం
మీరు బదులుగా చెబుతున్న దాన్ని "సరే, ఈ ఒక సూపర్ సులభంగా సమస్య ఉంటే,
సంఖ్య <0 వలె నాకు వెంటనే 0 తిరిగి ఉంచబడుతుంది. "
>> మేము, సహాయక ప్రతికూల సంఖ్యలు ఇబ్బంది వెళ్ళి లేదు
నేను హార్డ్ కోడ్ కు 0 విలువ వెళుతున్న.
అయితే, సంక్షిప్తం ఈ ఆలోచన అమలు
ఈ సంఖ్యల అన్ని కలిసి మీరు సమర్థవంతంగా ఒక చిన్న కాటు పడుతుంది
సమస్య నుండి, అనే మేము, వేదికపై ఇక్కడ చేశాడు
అప్పుడు రౌడీ తదుపరి వ్యక్తికి సమస్య మిగిలిన,
కానీ ఈ విషయంలో తదుపరి వ్యక్తి మీరే ఉంది.
ఇది ఒక గుర్తింపు అనే ఫంక్షన్ ఉంది.
జస్ట్ ఒక చిన్న మరియు చిన్నది సమస్య ప్రతి టైం పాస్
మరియు మేము ఇక్కడ కోడ్ చెప్పుకోదగ్గ అధికారికంగా విషయాల్లో కూడా
ఈ ఫోన్ బుక్ తో వారం 0 లో జరగబోతోంది సరిగ్గా అదే ఉంది.
ఈ సీన్ తో గత వారాల్లో జరగబోతోంది సరిగ్గా ఏమిటి
మరియు సంఖ్యలు కోసం శోధించే మా ప్రదర్శనలతో.
ఇది ఒక సమస్యను మళ్ళీ మళ్ళీ విభజన మాత్రమే.
>> ఇతర మాటలలో, అనువదించడం ఇప్పుడు ఒక మార్గం ఉందని
ఇది నిజమైన ప్రపంచం నిర్మాణం, ఈ ఉన్నత స్థాయి నిర్మాణం
విభజించి జయించటానికి మరియు మళ్లీ మళ్లీ దానిని చేయడం యొక్క
కోడ్ లో, ఈ మేము సమయంలో మళ్ళీ చూస్తారు విషయం.
మీరు సూత్రం కొత్త అయితే ఇప్పుడు, ఒక పక్కన, మీరు కనీసం ఇప్పుడు అర్థం చేసుకోవాలి
ఎందుకు ఈ ఫన్నీ ఉంది.
నేను, google.com వెళ్ళండి వెళుతున్న
మరియు నేను సూత్రం మీద కొన్ని చిట్కాలు మరియు ట్రిక్స్ కోసం అన్వేషణ వెళుతున్న, ఇవ్వండి.
అవి ఇప్పుడు నవ్వుతూ ఉండకపోతే మీరు పక్కన వ్యక్తి చెప్పండి.
మీరు సూత్రం అడిగారా?
మీరు తెలుసా అర్థం-AH, అక్కడ మేము వెళ్ళి.
సరే, ఇప్పుడు ప్రతి ఒక్కరూ మిగిలిన ఉంది.
ఒక చిన్న ఈస్టర్ గుడ్డు Google ఎక్కడో అక్కడ పొందుపరిచారు.
ఒక పక్కన, మేము కోర్సు యొక్క వెబ్ సైట్ లో ఉంచారు లింకులు ఒకటిగా
నేడు వివిధ సార్టింగ్ అల్గోరిథంలు యొక్క ఈ గ్రిడ్, ఉంది
మేము గత వారం చూశారు, కానీ ఈ భావన గురించి మంచిది కొన్ని
మీరు అల్గోరిథంలు సంబంధించిన వివిధ విషయాలను చుట్టూ మీ మనస్సు మూసివేయాలని ప్రయత్నించండి వంటి
మీరు చాలా సులభంగా ఇప్పుడు ఇన్పుట్లను వివిధ రకాల మొదలుపెట్టవచ్చు తెలుసు.
ఇన్పుట్లను అన్ని ఇన్పుట్లను యాదృచ్ఛిక మొదలైనవి, ఇన్పుట్లను ఎక్కువగా క్రమబద్ధీకరించిన తోసిపుచ్చింది.
మీరు మళ్ళీ, ప్రయత్నించండి, మీ మనస్సులో ఈ విషయాలను వేరు
గ్రహించే ఆ ఉపన్యాసాలు పేజీలో కోర్సు యొక్క వెబ్ సైట్ లో ఈ URL
ఆ కొన్ని ద్వారా కారణం సహాయం ఉండవచ్చు.
>> ఈ రోజు మనం చివరికి, తిరిగి కొంత నుండి ఈ సమస్యను పరిష్కరించడానికి పొందండి
ఇది ఈ swap ఫంక్షన్ కేవలం పని చేయలేదు ఆ
మరియు, ఈ ఫంక్షన్ స్వాప్ తో సమస్యను ఏమిటి
ఇక్కడ మరియు ఇక్కడ ఒక విలువ మార్పిడి, మళ్ళీ, ఈ లక్ష్యం ఇది యొక్క
ఇది జరిగినప్పుడు అలాంటి?
ఈ నిజానికి పని చేయలేదు. ఎందుకు?
అవును.
[వినబడని-విద్యార్థి]
ఈ bugginess కోసం ఖచ్చితంగా వివరణ
మీరు C లో కాల్ ప్రమేయాలు ఉన్నప్పుడు ఎందుకంటే కేవలం ఉంది
మరియు ఆ విధులు, a మరియు b ఇక్కడ వంటి వాదనలు పడుతుంది
మీరు ఆ ఫంక్షన్ కు అందించే ఏ చేస్తున్నారు విలువ యొక్క కాపీలు అక్కడ ఉంటాయి.
మీరు, అసలు విలువలు తాము లభిస్తుంది
కాబట్టి మేము, buggyc సందర్భంలో చూసిన
ఈ వంటి కొంత కనిపించింది ఇది buggy3.c.
>> మేము x మరియు y వరుసగా 1, 2 నుండి initialized కలిగి గుర్తుచేసుకున్నారు.
మేము అప్పుడు వారు ఏమి ముద్రించిన.
నేను అప్పుడు నేను x, y యొక్క స్వాప్ కాల్ వాటిని ఇచ్చిపుచ్చుకోవడంతో అని వాదించాడు.
కానీ సమస్య, ఇచ్చిపుచ్చుకోవడంతో పని చేసారు, ఆ
కానీ స్వాప్ పరిధిని కూడా పని.
మేము లైన్ 40 ఆ మార్చుకున్నారు విలువలు హిట్ వెంటనే
దూరంగా విసిరి, మరియు ఏదీ
అసలు ఫంక్షన్ లో ముఖ్య వాస్తవానికి, అన్ని వద్ద మార్చబడింది
మీరు ఈ మా మెమరీ పరంగా కనిపిస్తోంది ఏమి అప్పుడు భావిస్తున్నాను అయితే
బోర్డు ఈ ఎడమ వైపు సూచిస్తుంది-ఉంటే
మరియు నేను చూడండి అందరి కోసం నా వంతు కృషి చేస్తాము ఈ-ఉంటే బోర్డు ఈ ఎడమ వైపు
సూచిస్తుంది, మీ RAM, మరియు స్టాక్ ఈ విధంగా మీద పెరుగుతాయి అన్నారు
మరియు మేము ప్రధాన వంటి ఫంక్షన్ కాల్, మరియు ప్రధాన 2 స్థానిక వేరియబుల్స్, x మరియు y, ఉంది
యొక్క ఇక్కడ x ఆ వివరించడానికి వీలు, మరియు లెట్స్ ఇక్కడ y ఈ వివరించడానికి,
మరియు యొక్క విలువలు 1 మరియు 2 ఉంచారు కదా,, ఈ ఇక్కడ ప్రధాన కనుక
మరియు ప్రధాన swap ఫంక్షన్ ఆపరేటింగ్ వ్యవస్థ కాల్స్ ఉన్నప్పుడు
, స్టాక్ న swap ఫంక్షన్ మెమరీ దాని స్వంత సమూహం ఇస్తుంది
స్టాక్ దాని స్వంత ఫ్రేమ్, మాట్లాడటానికి.
ఇది కూడా ఈ ints కోసం 32 బిట్స్ కేటాయించుకునే.
ఇది వాటిని ఒక అండ్ బి కాల్ ఏమవుతుంది కానీ పూర్తిగా ఏకపక్షంగా ఉంది.
ఇది కావాలి ఏ వారిని అని ఉండవచ్చు, కాని ప్రధాన ఏమి జరుగుతుందనే
కాల్స్ swap ఇది ఈ 1 పడుతుంది అక్కడ కాపీని ఉంచుతుంది, అక్కడ ఒక కాపీని ఉంచుతుంది ఉంది.
>> స్వాప్ లో 1 ఇతర స్థానిక వేరియబుల్ ఉంది, అయితే పిలిచేవారు? >> Tmp.
Tmp, కాబట్టి, నాకు నేనే ఇక్కడ మరొక 32 బిట్స్ కల్పించడానికి అనుమతిస్తాయి
మరియు నేను ఈ ఫంక్షన్ లో ఏం చేస్తారు?
నేను Int tmp ఒక కాబట్టి, ఒక 1 ఉంది గెట్స్ చెప్పారు, కాబట్టి మేము గత ఈ ఉదాహరణ ఆడి నేను ఈ చేశాడు.
అప్పుడు ఒక బి చేస్తారు, దీని వలన బి 2, కాబట్టి ఇప్పుడు ఈ 2 అవుతుంది,
మరియు ఇప్పుడు, బి టెంప్ చేస్తారు, దీని వలన తాత్కాలిక 1
కాబట్టి ఇప్పుడు బి ఈ అవుతుంది.
ఆ గొప్ప పని. ఇది పని.
కానీ వెంటనే తిరిగి వచ్చే చర్యలు వంటి
swap యొక్క మెమరీ సమర్థవంతంగా దానిని తిరిగి వాడతారు కనుక అదృశ్యమవుతుంది
భవిష్యత్తులో కొన్ని ఇతర చర్య ద్వారా, మరియు ప్రధాన స్పష్టంగా పూర్తిగా మారదు.
మేము ప్రధానంగా ఈ సమస్య పరిష్కరించేందుకు ఒక మార్గం అవసరం
మరియు ఈ రోజు మేము చివరకు వస్తే ఇలా ఒక మార్గం ఉంటుంది
మేము ఒక పాయింటర్ అనే కలిగిస్తాయి.
ఇది మేము ఈ సమస్య పరిష్కరించగల అవుతుంది
x మరియు y యొక్క కాపీలు అక్కడ లేదు ద్వారా
కానీ బదులుగా ఏమి లో గుండా, మీరు swap కు, ఆలోచిస్తాడు?
అవును, చిరునామా గురించి ఏమి?
మమ్మల్ని, చాలా వివరాలు చిరునామాలు గురించి మాట్లాడారు లేదు
కానీ ఈ రాత బల్ల నా కంప్యూటర్ యొక్క మెమరీ సూచిస్తుంది ఉంటే
మేము ఖచ్చితంగా నా RAM లో బైట్లు సంఖ్యలో ప్రారంభం కాలేదు
మరియు ఈ బైట్ # 1 అంటారు, ఈ బైట్ # 3, # 2 బైట్ ఉంది
బైట్ # 4, బైట్ # ... 2 బిలియన్ నేను RAM యొక్క 2 గిగాబైట్ల ఉంటే,
కాబట్టి మేము ఖచ్చితంగా స్వేచ్ఛా అంకెల పథకాన్ని తో వస్తుంది
నా కంప్యూటర్ యొక్క మెమరీ అన్ని వ్యక్తిగత బైట్లు కోసం.
>> నేను swap ఏం బదులుగా కాల్ చేసినప్పుడు
x మరియు y యొక్క కాపీలు కాకుండా పాస్
నేను బదులుగా, ఇక్కడ x యొక్క చిరునామా లో అనుమతించబడవు
ఇక్కడ y యొక్క చిరునామా, ముఖ్యంగా పోస్టల్ చిరునామా
అతను సమాచారం ఉన్నట్లయితే x మరియు y యొక్క ఎందుకంటే అప్పుడు, స్వాప్
x మరియు y యొక్క మెమరీలో చిరునామా,
మేము అతనికి కొద్దిగా శిక్షణ అప్పుడు, స్వాప్
అతను శక్తివంతంగా, మాట్లాడటానికి, ఆ చిరునామాకు డ్రైవ్ కాలేదు
x, అక్కడ మార్చడానికి, అప్పుడు, Y యొక్క చిరునామాకు డ్రైవ్
నిజానికి ఆ విలువలు తనను కాపీలు పొందడానికి కాదు కూడా, అక్కడ మార్చడానికి,
మేము ప్రధాన యొక్క మెమరీ గా ఈ మాట్లాడారు కాబట్టి అయినప్పటికీ
మరియు ఈ వంటి ఉండటం swap యొక్క మెమరీ శక్తివంతమైన మరియు C యొక్క ప్రమాదకరమైన భాగంగా
ఏదైనా ఫంక్షన్, ఎక్కడైనా కంప్యూటర్ మెమొరీ ప్రభావితం చేయవచ్చని ఉంది
మరియు ఈ మీరు C. లో కంప్యూటర్ ప్రోగ్రాములు చాలా ఫాన్సీ పనులు చేయగలనని లో శక్తివంతమైన
మీరు కూడా చాలా సులభంగా అప్ మేకు ఎందుకంటే ఈ ప్రమాదకరం.
నిజానికి, కార్యక్రమాలు అత్యంత సాధారణ మార్గాలు ఈ రోజుల్లో ఒక చేజిక్కించుకోవడానికి కు
ఒక ప్రోగ్రామర్ గ్రహించడం కాదు కోసం ఇంకా
అతను లేదా ఆమె ఒక డేటా అనుమతిస్తుంది అని
ఉద్దేశించబడింది అని మెమరీలో స్థానం లో రాసిన.
>> ఉదాహరణకు, అతను లేదా ఆమె పరిమాణం 10 యొక్క వ్యూహం ప్రకటించాడు
కానీ అప్పుడు అనుకోకుండా, మెమరీ ఆ శ్రేణి లో 11 బైట్లు ఉంచేందుకు ప్రయత్నిస్తుంది
మరియు మీరు ఏ చెల్లని మెమరీ భాగాలను తాకుతూ ప్రారంభించండి.
జస్ట్ సందర్భోచిత ఈ, మీరు కొన్ని తెలిసిన ఆ
సాఫ్ట్వేర్ తరచుగా, సీరియల్ సంఖ్యలు లేదా నమోదు కొరకు కీస్ అడుగుతుంది
Photoshop మరియు పద మరియు ఈ వంటి ప్రోగ్రామ్లు.
, మీరు కొద్దిగా అమలు చేయవచ్చు ఆన్లైన్ పేరు, మీరు కొన్ని తెలిసిన, పగుళ్ళు ఉన్నాయి
మరియు voila, ఒక క్రమ సంఖ్య కోసం no more అభ్యర్థన.
ఎంత పని ఉంది?
అనేక సందర్భాల్లో ఈ విషయాలు కేవలం కంప్యూటర్లలో కనుగొంటారు
కంప్యూటర్ యొక్క నిజమైన సున్నాలు మరియు వాటిని టెక్స్ట్ విభాగాలు
క్రమ సంఖ్య అభ్యర్థించిన కౌంటీ ఆ ఫంక్షన్, ఎక్కడ ఉంది
కార్యక్రమం అమలులో ఉన్నప్పుడు మరియు ఆ స్థలాన్ని తిరిగి రాస్తుంది, లేదా
కీ నిజానికి నిల్వ మీరు కనుగొనడానికి చేయవచ్చు
ఏదో ఉపయోగించి ఒక డీబగ్గర్ అని, మరియు మీరు సాఫ్ట్వేర్ విధంగా పగుళ్లు ఏర్పడవచ్చు.
ఈ, తదుపరి రెండు రోజుల్లో ఈ మా లక్ష్యం అని చెప్పడానికి కాదు
కానీ చాలా వాస్తవ ప్రపంచ శాఖల కలిగి ఉంది.
ఒక, సాఫ్ట్వేర్ దొంగతనం కలిగి చేసేట్టు
కానీ మొత్తం యంత్రాల రాజీ కూడా ఉంది.
>> నిజానికి, వెబ్సైట్లలో ఈ రోజుల్లో దోచుకున్నారు
మరియు రాజీ డేటా బహిర్గతమైంది మరియు పాస్వర్డ్లను దొంగిలించబడతున్నాయి
ఈ చాలా తరచుగా ఒక మెమరీ పేద నిర్వహణకు సంబంధించినది,
లేదా, డేటాబేస్ విషయంలో వైఫల్యం, ఊహించడానికి
రాబోయే వారాల్లో ఆ ఎక్కువ పటిష్టమయిన ఇన్పుట్,
కానీ ఇప్పుడు కోసం మీరు చేసే నష్టం విధమైన ఒక స్నీక్ ప్రివ్యూ
చాలా విషయాలు హుడ్ కింద పని ఎలా అర్థం కాదు ద్వారా.
యొక్క ఈ విభజించబడింది ఎందుకు అవగాహనలతో వెళ్ళి తెలపండి
ఒక సాధనం ఆ మరింత ఉపయోగకరంగా మారుతుంది
మా కార్యక్రమాలు మరింత క్లిష్టంగా వంటి.
మీరు మీ కార్యక్రమంలో ఒక బగ్ కలిగింది ఇంతవరకు ఉన్నప్పుడు
ఎలా మీరు డీబగ్గింగ్ గురించి గాన్?
మీ పద్ధతులు మీ TF బోధించారు లేదో ఇప్పటివరకు ఉన్నాయి
లేదా స్వీయ శిక్షణ?
[స్టూడెంట్] Printf.
మీరు చూడాలనుకుంటే Printf, కాబట్టి printf బహుశా ఆ మీ స్నేహితుడు ఉంది
మీ ప్రోగ్రామ్ యొక్క లోపల ఏం జరగబోతోంది
మీరు printf ఇక్కడ, printf ఇక్కడ, printf ఇక్కడ ఉంచండి.
అప్పుడు మీరు దీన్ని అమలు, మరియు మీరు తెరపై అంశాలను పూర్తి బంచ్ పొందండి
మీరు నిజంగా మీ కార్యక్రమంలో తప్పు అన్నారు ఏమి రాబట్టడానికి ఉపయోగించే.
>> Printf, ఒక శక్తివంతమైన విషయం ఉంటుంది
కానీ చాలా మాన్యువల్ ప్రాసెస్ ఉంది.
మీరు printf ఇక్కడ, ఇక్కడ ఒక printf ఉంచాలి
మరియు మీరు ఒక లూప్ యొక్క లోపల ఉంచండి మీరు 100 పంక్తులు పొందండి ఉండవచ్చు
మీరు ద్వారా జల్లెడ పట్టు కలిగి ఆ అవుట్పుట్ యొక్క.
ఇది డీబగ్గింగ్ కార్యక్రమాలు చాలా యూజర్ ఫ్రెండ్లీ లేదా పరస్పర విధానం కాదు
కానీ కృతజ్ఞతగా ప్రత్యామ్నాయాలు అందుబాటులో ఉన్నాయి.
GDB అని ఉదాహరణకు ఒక కార్యక్రమం,, GNU డీబగ్గర్ ఉంటుంది
ఇది మీరు ఎలా ఉపయోగిస్తున్నారో చిన్న రహస్య ఉంది.
ఇది స్పష్టముగా కొద్దిగా క్లిష్టమైన, కానీ
ఈ మీరు ఈ వారంలో ఉంచితే పొందిన అంశాల్లో ఒకటిగా మరియు తదుపరి
GDB వంటి ఏదో అర్థం గంట
ఇది దీర్ఘకాలంలో మీరు గంటల బహుశా పదుల సేవ్ చేస్తుంది
కాబట్టి తో, మీరు ఈ విషయం ఎలా పనిచేస్తుంది అనే టీజర్ కల్పించడానికి అనుమతిస్తాయి.
>> నా టెర్మినల్ విండో ఉన్నాను.
నాకు ముందుకు వెళ్లి ఈ కార్యక్రమం buggy3 కంపైల్ లెట్.
ఇది తాజాగా ఇప్పటికే.
మేము ఒక అయితే తిరిగి, మరియు నిజానికి అది విభజించబడినట్లు యొక్క అప్పుడే నన్ను అమలు లెట్.
కానీ ఎందుకు ఉంది? బహుశా నేను swap ఫంక్షన్ అప్ చిత్తు చేశాడు.
దీనికి ఒక అండ్ బి ఉంది. నేను చాలా సరిగ్గా చుట్టూ కదిలే లేదు.
నాకు ముందుకు వెళ్లి మనం.
కంటే, నాకు బదులుగా ఈ కార్యక్రమం GDB అమలు అనుమతిస్తాయి buggy3 అమలు
మరియు నేను, buggy3 అమలు చేయడానికి చెప్పాలి వెళుతున్న
మరియు నేను కమాండ్ లైన్ వాదన,-టుయ్ ఉన్నాయి వెళుతున్న
మరియు మేము గుర్తు స్పెక్ వద్ద భవిష్యత్తు సమస్యలు ఈ ఉంచుతాము.
ఇప్పుడు ఈ నలుపు మరియు తెలుపు ఇంటర్ఫేస్, మళ్ళీ, ఆ అప్ popped
ఈ ఉంది ఎందుకంటే మొదటి వద్ద కొద్దిగా అధిక ఉంది
ఇక్కడ డౌన్ వారంటీ సమాచారం, కానీ కనీసం తెలిసిన విషయం ఏదైనా.
విండో ఎగువన నా నిజమైన కోడ్ ఉంది
మరియు నేను ఇక్కడ స్క్రోల్ చేయండి, నా ఫైలు యొక్క చాలా పైకి స్క్రోల్ అనుమతిస్తుంది
నిజానికి, ఈ విండో దిగువన buggy3.c, మరియు ప్రకటన లేదు
నేను ఈ GDB ప్రాంప్ట్ ఉంటాయి.
>> ఈ నా సాధారణ జాన్ హార్వర్డ్ ప్రాంప్ట్ అదే కాదు.
ఈ నాకు GDB నియంత్రించడానికి మిమ్మల్ని అనుమతిస్తుంది వెళుతున్న ఒక ప్రేరణ ఉంటుంది.
GDB ఒక డీబగ్గర్ ఉంది.
ఒక డీబగ్గర్ మీరు నడవడానికి అనుమతిస్తుంది ప్రోగ్రామ్
లైన్ ద్వారా లైన్ ద్వారా మీ ప్రోగ్రామ్ లైన్ అమలు,
మార్గం మీరు ప్రోగ్రామ్ మీరు ఏదైనా చేయడం పాటు
కూడా, మరింత ముఖ్యంగా, ఫంక్షన్స్ పిలుపు లేదా చూడటం
వివిధ వేరియబుల్ విలువలు వద్ద.
యొక్క ముందుకు వెళ్లి మనం.
నేను, ముందుకు వెళ్ళి, GDB యొక్క ప్రాంప్టులో పరుగుల టైప్ వెళుతున్న
నేను టైప్ అమలు చేసిన స్క్రీన్ యొక్క దిగువ ఎడమ వైపు గమనించి,
మరియు నేను ఎంటర్ నొక్కండి చేసిన, మరియు ఆ ఏం చేసావ్?
ఇది అక్షరాలా నా కార్యక్రమాన్ని, కానీ నిజానికి చాలా ఇక్కడ న వెళ్లిపోవడం లేదు
నిజానికి డీబగ్గర్ చెప్పలేదు ఎందుకంటే
ఒక నిర్దిష్ట సమయంలో ఆగిపోవటం.
జస్ట్ పరుగుల టైప్ కార్యక్రమం నడుపుతుంది.
నిజానికి ఏదైనా చూడలేదు. నేను సర్దుబాటు కాదు.
>> బదులుగా నాకు మనం.
ఈ GDB ప్రాంప్టులో నాకు బదులుగా ఎంటర్, బ్రేక్ టైప్ తెలియజేయండి.
నేను టైప్ అర్థం కాదు.
బ్రేక్ ప్రధాన టైప్ బదులుగా యొక్క లెట్.
ఇతర మాటలలో, నేను ఒక బ్రేక్ పాయింట్ అని ఏదో, సెట్ చేయాలనుకుంటున్నారా
ఇది బ్రేక్ లేదా విరామం ఎందుకంటే సముచితంగా అనే ఇది
నిర్దిష్ట ప్రదేశంలో మీ ప్రోగ్రామ్ అమలు.
ప్రధాన నా ప్రమేయం పేరు.
GDB అందంగా స్మార్ట్ అని గమనించండి.
ఇది ప్రధాన మార్గం 18 వద్ద సుమారు ప్రారంభించడానికి జరుగుతుందని కనుగొన్నారు
buggy3.c యొక్క, మరియు అప్పుడు ఎడమ ఎగువన ఇక్కడ గమనించవచ్చు
బి + లైన్ 18 హక్కును పక్కనే ఉంది.
నేను లైన్ 18 వద్ద ఒక బ్రేక్ పాయింట్ సెట్ చేసిన నాకు గుర్తు ఉంది.
ఈ సమయంలో నేను పరుగుల టైప్ చేసినప్పుడు, నా ప్రోగ్రామ్ రన్ వెళుతున్న
అప్ వరకు, ఆ బ్రేక్పాయింట్ని హిట్స్
కాబట్టి కార్యక్రమం లైన్ 18 వద్ద నాకు విరామం రెడీ.
ఇక్కడ మేము, వెళ్ళి అమలు.
ఏమీ జరగలేదు అనిపిస్తుంది, కానీ దిగువన ప్రకటన వదిలి
ప్రారంభ కార్యక్రమం, buggy3, buggy3.c లైన్ 18 వద్ద ప్రధాన లో బ్రేక్పాయింట్ని 1.
నేను ఇప్పుడు ఏమి చెయ్యగలను?
>> గమనికను నేను, ముద్రణ వంటి వాటిని టైప్ చెయ్యవచ్చు
కాదు printf, ముద్రణ x, మరియు ఇప్పుడు ఆ వింత ఉంది.
మేము చూస్తారు వంటి $ 1, కేవలం ఉత్సుకత ఉంది
మీరు ఏదో ప్రింట్ ప్రతిసారీ మీరు ఒక కొత్త $ విలువ పొందండి.
, మీరు ఒకవేళ మునుపటి విలువలు తిరిగి చూడండి విధంగా ఉంది
కానీ ఇప్పుడు ఏ print నాకు చెప్తుంటాడు అని కథ ఈ సమయంలో x విలువ
స్పష్టంగా 134514032 ఉంది.
ఏం? కూడా ఎక్కడ నుండి వచ్చింది?
[వినబడని-విద్యార్థి]
నిజానికి, ఈ మేము ఒక చెత్త విలువ పిలుస్తాను ఏమిటి, మరియు మేము ఇంకా ఈ మాట్లాడారు లేదు చేసిన
కానీ మీరు వేరియబుల్స్ ప్రారంభించడం ఆ కారణం
స్పష్టంగా తద్వారా మీరు వాటిని కలిగి కావలసిన కొన్ని విలువ కలిగి ఉంది.
కానీ క్యాచ్ మీరు వేరియబుల్స్ ప్రకటించవచ్చు గుర్తుచేసుకున్నారు ఉంది
నా సిగ్మా ఉదాహరణకు ఒక క్షణం క్రితం చేశాడు
వాస్తవానికి ఒక విలువ ఇవ్వకుండా.
నేను సిగ్మా ఇక్కడ పైగా చేసిన గుర్తు.
నేను n డిక్లేర్డ్, కాని దాన్ని ఏ విలువ ఇవ్వడం లేదు?
గమనిక, నేను తెలుసు ఎందుకంటే ఆ తర్వాత కొన్ని పంక్తులు లో
GetInt n యొక్క లోపల విలువ ఉంచడం యొక్క సమస్య యొక్క రక్షణ పడుతుంది.
>> కానీ లైన్ 11 యొక్క కథ ఈ సమయంలో
మరియు లైన్ 12 మరియు 13 లైన్ మరియు లైన్ 14
ఆ అనేక పంక్తులు అంతటా n విలువ ఏమిటి?
సి లో మీకు లేదు.
ఇది సాధారణంగా కొన్ని చెత్త విలువ, కొన్ని పూర్తిగా రాండమ్ నెంబర్
మునుపటి ఫంక్షన్ తప్పనిసరిగా ను చేసే
మీ కార్యక్రమం నడుపుతుంది కాబట్టి, రన్ జరిగింది
ఫంక్షన్ FUNCTION, ఫంక్షన్, ఫంక్షన్ అందుతుంది అని గుర్తు.
ఈ ఫ్రేములు, అప్పుడు ఆ విధులు తిరిగి మెమరీ పెట్టబడింది మరియు get
మరియు కేవలం నేను వారి మెమరీ చివరకు తిరిగి ఎరేజర్ తో సూచించారు.
సరే, కేవలం ఈ కార్యక్రమంలో ఈ చరరాశి X జరుగుతుంది
134514032 వంటి కొన్ని చెత్త విలువ కలిగి ఉంది
మునుపటి చర్య నుండి, కాని ఒక నేను రాసిన.
ఇది నిర్వహణ వ్యవస్థ సమర్థవంతంగా వచ్చే ఏదో ఉంటుంది
హుడ్ కింద కొన్ని ఫంక్షన్.
>> సరే, ఆ మంచిది, కాని తర్వాత లైన్ చేరుకునేందుకు ఇప్పుడు చూద్దాం.
నా GDB ప్రాంప్టులో "తర్వాత" టైపు ఉంటే నేను, ఎంటర్ నొక్కండి
గమనించి ఆ, లైన్ 19 చేరుకుంటాడు డౌన్ హైలైట్
కానీ తార్కిక సూత్రప్రాయంగా ఆ లైన్ 18
ఇప్పుడు పూర్తి నేను మళ్ళీ టైప్ అయితే, అమలు "ముద్రణ x"
నేను ఇప్పుడు 1 చూస్తారు, మరియు నిజానికి నేను.
మళ్లీ, $ stuff GDB మీరు గుర్తు ఒక మార్గం
అచ్చుల చరిత్ర మీరు పూర్తి చేసిన ఉపయోగించలేరు.
, ఇప్పుడు నన్ను ముందుకు వెళ్లి Y ముద్రించాలా వీలు, మరియు నిజానికి Y అలాగే కొన్ని క్రేజీ విలువ
కానీ పెద్ద ఒప్పందం లైన్ 19 లో మనం అది అప్పగించడం చేసారు ఎందుకంటే
విలువ 2, కాబట్టి నన్ను మళ్ళీ "తర్వాత" టైప్ తెలియజేయండి.
ఇప్పుడు మేము printf లైన్ లో ఉన్నారు.
నాకు print x తెలియజేసేలా.
నాకు print Y తెలియజేసేలా. స్పష్టముగా, నేను ఈ ప్రింటింగ్ కొద్దిగా అలసిపోయానని పొందుతున్నాను.
నాకు బదులుగా "ప్రదర్శన x" మరియు "ప్రదర్శన y," టైప్ లెట్
మరియు ఇప్పుడు ప్రతిసారీ నేను భవిష్యత్తులో ఒక ఆదేశాన్ని
నేను ఏది గుర్తు చేస్తుంది ఏమి x మరియు y, x మరియు y, x మరియు y ఏమిటి.
>> నేను కూడా, ఒక పక్కన, టైప్ "సమాచారం స్థానికులు."
సమాచారం ప్రత్యేక ఆదేశం ఉంది.
స్థానికులు అది నాకు స్థానిక వేరియబుల్స్ చూపిస్తుంది అర్థం.
నేను మర్చిపోతే లేదా ఈ ఒక క్రేజీ, క్లిష్టమైన విధి ఒకవేళ
నేను లేదా ఎవరో సమాచారం స్థానికులు ఇత్సెల్ఫ్ వ్రాసాడు
ఈ స్థానిక ఫంక్షన్ లోపల అన్ని స్థానిక వేరియబుల్స్ ఏమి ఉన్నాయి
మీరు మీ చుట్టూ దూర్చు అనుకుంటే శ్రద్ధ అని.
ఇప్పుడు, printf కాబట్టి నన్ను ముందుకు మరియు కేవలం రకం వీడలేదు, అమలు గురించి "తర్వాత."
మేము ఈ వాతావరణంలో ఉన్నారు మేము దీన్ని చూసిన లేదు
ఇక్కడ డౌన్ అమలు, కానీ ఇక్కడ ఒక చిన్న నిర్వాహిత సంతరించుకోనుంది గమనిస్తారు.
కానీ, అది తెర భర్తీ నోటీసు
కనుక అది ఒక ఖచ్చితమైన కార్యక్రమం కాదు, కానీ నేను ఎప్పుడూ చుట్టూ దూర్చు ఎందుకంటే ఆ సరైందే
నేను కావాలా print ఉపయోగించి.
>> నా తర్వాత మళ్ళీ టైప్ లెట్, మరియు ఇప్పుడు ఇక్కడ ఆసక్తికరమైన భాగం.
కథలో ఈ సమయంలో, Y 2, మరియు x 1
ఇక్కడ సూచించిన, మరియు తిరిగి, వంటి
నేను కమాండు ఉపయోగిస్తారు ఎందుకంటే ఈ స్వయంచాలకంగా ఇప్పుడు ప్రదర్శించడం ఉంది కారణం
ప్రదర్శన x మరియు ప్రదర్శన y, నేను తరువాత టైప్ కాబట్టి క్షణం
సిద్ధాంతం x మరియు y లో మార్చుకున్నారు మారాలి.
ఇప్పుడు, మేము ఇప్పటికే కేసు మాత్రం కాదు మనకు తెలుసు,
కానీ మేము నిజమైన వై గుర్తించడానికి లోతైన ఈత కొట్టడానికి ఎలా క్షణంలో చూస్తారు.
దురదృష్టవశాత్తు తరువాత, మరియు, Y ఇప్పటికీ 2 మరియు x ఇంకా 1, మరియు నేను చాలా ధృవీకరించవచ్చు.
ప్రింట్ x, y ముద్రణ.
నిజానికి, ఇచ్చిపుచ్చుకోవడంతో ఏ వాస్తవానికి జరిగింది, ఈ పైగా ప్రారంభిద్దాం.
స్పష్టంగా swap విభజించబడింది.
యొక్క బదులుగా మళ్ళీ "రన్" టైప్ లెట్.
నాకు అవును అని పిలవబడు, నేను ప్రారంభం నుండి దీన్ని మళ్ళీ ప్రారంభించండి మీరు నమోదు చేయండి.
>> ఇప్పుడు నేను తిరిగి అప్ లైన్ 18 వద్ద ఉన్నాను.
ఇప్పుడు x మరియు y మళ్లీ చెత్త విలువలు గమనిస్తారు.
, తదుపరి తదుపరి, తర్వాత, తదుపరి.
నేను విసుగు వస్తే నేను కూడా తర్వాతి కోసం n టైప్ చెయ్యవచ్చు.
మీరు అక్షరాలు తక్కువ అవకాశం క్రమంలో అది సంక్షిప్తంగా చేయవచ్చు.
Swap ఇప్పుడు విభజించబడింది.
బదులుగా తరువాత టైప్ కాబట్టి, లో యొక్క డైవ్ లెట్
నేను ఈ చర్య యొక్క లోపల పునాది చేస్తున్నాను కాబట్టి ఇప్పుడు నేను అడుగు టైప్ వెళుతున్న
నేను నడుస్తూ, అందువలన నేను అడుగు హిట్ తరువాత ఎంటర్ కాబట్టి.
గమనికను లైన్ 36 నా కార్యక్రమంలో హైలైట్ హెచ్చుతగ్గుల క్రింది ఆ.
ఇప్పుడు స్థానిక వేరియబుల్స్ ఏవి?
సమాచారం స్థానికులు.
మేము ఆ లైన్ కు సంపాదించిన లేదు చేసిన ఎందుకంటే ఇంకా ఏదీ,
కాబట్టి యొక్క ముందుకు వెళ్లి అని పిలవబడు "తర్వాత."
ఇప్పుడు మేము tmp, ముద్రణ tmp ఉన్నారు.
చెత్త విలువ, కుడి? నేను అలా అనుకుంటున్నాను.
ఎలా ఒక, ముద్రణ బి, 1 మరియు 2 ప్రింట్?
ఒక క్షణం లో, వెంటనే నేను తరువాత మళ్ళీ టైప్
tmp, ఆశాజనక, 1 యొక్క విలువ తీసుకోవాలని అన్నారు
tmp ఒక విలువ కేటాయించిన కావడం ఎందుకంటే.
>> ఇప్పుడు ఒక, ముద్రణ బి ప్రింట్ చెయ్యాలి కదా,
కానీ ఇప్పుడు tmp ప్రింట్ మరియు ఇది నిజంగానే 1 ఉంది.
నా తర్వాత తెలియజేసేలా. నా తర్వాత తెలియజేసేలా.
నేను swap ఫంక్షన్ పూర్తి చేసిన.
నేను లైన్ 40 లో లోపలి ఇప్పటికీ ఉన్నాను, కాబట్టి నాకు ప్రింట్ తెలియజేయండి
ముద్రణ బి, మరియు నేను tmp ఏమిటి పట్టించుకోను.
అది ఒక అండ్ బి ఇచ్చిపుచ్చుకోవడంతో విషయానికి వస్తే swap సరైన ఉన్నట్లు తెలుస్తుంది.
కానీ ఇప్పుడు తదుపరి టైప్ ఉంటే, నేను, లైన్ 25 తిరిగి వెళ్ళు
అలాగే, x మరియు ముద్రణ y లో నేను టైపు చేస్తే
వారు ఇప్పటికీ మారలేదు, కాబట్టి మేము సమస్య పరిష్కరించబడింది లేదు.
కానీ diagnostically ఇప్పుడు బహుశా ఈ GDB కార్యక్రమం
మేము కనీసం అవగాహన ఒక మెట్టు దగ్గరగా సంపాదించిన చేసిన
ఇక్కడికి ఒక printf ఉంచడం ద్వారా లిట్టర్ మా కోడ్ చేయకుండా తప్పు అవకాశముంది,
printf ఇక్కడ, ఇక్కడ printf తరువాత మళ్ళీ మళ్ళీ అమలు
తప్పు ఏమి గుర్తించడానికి ప్రయత్నిస్తున్నారు.
>> ఐ క్విట్ మొత్తంగా ముందుకు వెళ్లి ఈ నుండి నిష్క్రమించినప్పుడు వెళుతున్న.
తర్వాత సే అవకాశముంది, "ఏమైనప్పటికీ నిష్క్రమించు?" అవును.
ఇప్పుడు నా సాధారణ ప్రాంప్టులో తిరిగి ఉన్నాను, నేను GDB ఉపయోగించి పూర్తయింది.
ఒక పక్కన, మీరు ఈ-టుయ్ జెండాను వినియోగించాలని అవసరం లేదు.
మీరు దీనిని మినహాయించడం ఉంటే నిజానికి, మీరు తప్పనిసరిగా స్క్రీన్ దిగువన సగం పొందండి.
నేను అప్పుడు అమలు తర్వాత విరామం ముఖ్యమైన మరియు ఉంటే
నేను ఇప్పటికీ నా ప్రోగ్రామ్ రన్, కానీ అది చేస్తుంది ఎక్కువ textually ఉంటుంది
ఒక సమయంలో నా ప్రస్తుత రేఖ ఒక చూపించు.
-టుయ్, పాఠ్య యూజర్ ఇంటర్ఫేస్,
కేవలం మీరు ఒకసారి, బహుశా ఒక బిట్ సంభావితంగా సులభంగా అనేది ప్రోగ్రామ్ యొక్క మరింత చూపిస్తుంది.
కానీ నిజానికి, నేను, తర్వాత తర్వాత, తదుపరి చేయవచ్చు
మరియు నేను ఒక సమయంలో ఒక వరుస చూడండి వెళుతున్న మరియు నేను నిజంగా ఏమి చూడాలనుకుంటే
నేను జాబితా టైప్ మరియు పొరుగు రేఖల మొత్తంగా బంచ్ చూడగలరు.
>> మేము సమస్య 3 సెట్స్ కోసం మీరు చూసే అడిగారు ఒక వీడియో ఉంది
దీనిలో నేట్, GDB యొక్క చిక్కులతో కొన్ని కప్పి
మరియు ఈ, నిజాయితీగా, ఆ విషయాలు ఒకటి పేరు మీరు కొన్ని కాని అల్పమైన శాతం
GDB టచ్ కాదు, మరియు ఒక చెడ్డ అంశం ఉంటుంది
అక్షరాలా మీరు ఈ సెమిస్టర్ తరువాత ఎక్కువ సమయం గడిపిన ముగింపు చేసే ఎందుకంటే
దోషాలు డౌన్ వెంటాడుకునే మీరు ఆ అరగంట / గంట లో ఉంచుతాడు ఉంటే
ఈ వారం లెర్నింగ్ GDB సౌకర్యవంతంగా పొందడానికి.
Printf మీ స్నేహితుడు.
GDB మీ స్నేహితుడు ఉండాలి.
>> GDB ఏ ప్రశ్నలు?
మరియు ఇక్కడ అత్యంత శక్తివంతమైన మరియు ఉపయోగకరమైన ఆదేశాలను కొన్ని శీఘ్ర జాబితా ఉంది.
అవును. >> మీరు ఒక స్ట్రింగ్ ప్రింట్ చెయ్యగలనా?
మీరు ఒక స్ట్రింగ్ ప్రింట్ చెయ్యగలనా? ఖచ్చితంగా.
ఇది కేవలం పూర్ణ గా లేదు.
ఒక వేరియబుల్ s print లు కేవలం రకం స్ట్రింగ్ ఉంటే.
ఇది ఆ స్ట్రింగ్ వేరియబుల్ ఏమిటి మీరు చూపిస్తుంది.
[వినబడని-విద్యార్థి]
మీరు చిరునామా మరియు స్ట్రింగ్ కూడా ఇస్తుంది.
మీరు రెండు చూపిస్తుంది.
ఒక చివరి విషయం, ఈ చాలా గుడ్ టు నో ఎందుకంటే.
వెనుకకు మరియు ఫ్రేమ్, నాకు ఈ చివరిసారిగా ప్రవేశిస్తాడు తెలియజేయండి
GDB అదే ఖచ్చితమైన కార్యక్రమం.
నాకు ముందుకు వెళ్లి పాఠ్య యూజర్ ఇంటర్ఫేస్ వెర్షన్ అమలు అయ్యేలా అనుమతించండి,
ప్రధాన విడిపోయారు.
నాకు ముందుకు వెళ్లి మళ్లీ అమలు అయ్యేలా అనుమతించండి. ఇక్కడ నేను.
ఇప్పుడు నాకు, తర్వాత తర్వాత, తదుపరి, తర్వాత, తదుపరి వీడలేదు, మెట్టు, ఇవ్వండి.
>> ఇప్పుడు నేను ఉద్దేశపూర్వకంగా స్వాప్ లో ఇప్పుడు రెడీ అనుకుందాం, కానీ నేను వంటి రెడీ "డామన్, x యొక్క విలువ ఏమిటి?"
నేను ఏవిధంగానూ x చెయ్యలేరు.
వారు పరిధిని చెయ్యని కారణంగా నేను y చెయ్యలేరు.
వారు సందర్భంలో లేదు, కానీ సమస్య లేదు.
నేను వెనుకకు టైప్ చెయ్యవచ్చు.
నాకు ఈ సమయంలో వరకు అమలు చేసిన కార్యక్రమాలను అన్ని చూపిస్తుంది.
గమనికను ప్రధాన ప్రధాన అడుగున ఒక, లైన్లు
ఇక్కడ మా చిత్రం యొక్క అడుగు భాగం లో ఉంది.
swap స్వాప్ ఇక్కడ మెమరీ పైన ఉండటం తో దానిని మార్గాల పైన నిజాన్ని,
మరియు నేను తాత్కాలికంగా ప్రధాన తిరిగి పొందడానికి అనుకుంటే నేను "ఫ్రేమ్." చెప్పగలదు
ఏమి సంఖ్య? మెయిన్ ఫ్రేమ్ # 1.
నేను ముందుకు వెళ్లి చెప్పే వెళుతున్న "ఫ్రేమ్ 1."
>> ఇప్పుడు నేను ప్రధాన తిరిగి ఉన్నాను, నేను x ముద్రించవచ్చు, మరియు నేను, Y ముద్రించవచ్చు
కానీ నేను లేదా బి ముద్రించలేరు.
నేను అయితే నేను, "సరే, ఒక నిమిషం ఆగండి. ఎక్కడ స్వాప్ ఉంది?" చేయవచ్చు
నాకు ముందుకు వెళ్లి అని పిలవబడు "ఫ్రేమ్ 0."
ఇప్పుడు నేను, నేను ఎక్కడ ఉన్నాను తిరిగి, మరియు జనాంతికంగా
మీరు నిజంగా విసుగు టైపింగ్ తరువాత, తదుపరి, తర్వాత, తదుపరి పొందుతుంటే వంటి ఇతర ఆదేశాలు,, చాలా ఉంది
మీరు సాధారణంగా ", తర్వాత 10" వంటి వాటిని చెప్పగలదు మరియు ఆ తరువాత 10 పంక్తులు ద్వారా దిగవచ్చు.
మీరు నిజంగా అది ద్వారా పునాది విసుగు చెంది ఎప్పుడు "కొనసాగు" వ్రాయగలవు.
అది మరొక బ్రేక్పాయింట్ని హిట్స్ వరకు కొనసాగు, ఆటంకం లేకుండా మీ అమలు చేస్తుంది
ఒక లూప్ లో లేదా మీ కార్యక్రమంలో క్రింది.
>> ఈ సందర్భంలో మనం చివరి వరకు కొనసాగింది, మరియు ప్రోగ్రామ్ సాధారణంగా ముగిసింది.
ఈ ఒక ఫాన్సీ మార్గం, అధో ప్రక్రియ.
మీ ప్రోగ్రామ్ సాధారణంగా ముగిసింది.
వీడియో మరియు రాబోయే సెషన్స్ డీబగ్గింగ్ ఆ మరింత.
ఒక నవ్వులాట.
లెట్ యొక్క ఇక్కడ మా 5 నిమిషాల విరామం, మరియు మేము structs మరియు ఫైళ్లను తిరిగి పొందుతారు.
>> మీరు ఇప్పటికే ఈ వారం యొక్క pset ముందుకు అధిగమించాడు ఉంటే
మీరు, మేము పంపిణీ కోడ్ ఉపయోగించే తెలుసు ఉంటాం
మేము ఒక ప్రారంభ బిందువు కొన్ని కొత్త పద్ధతులు మీకు అందించే సోర్స్ కోడ్.
ముఖ్యంగా, మేము, నిర్మాణం కోసం, struct అని ఈ కొత్త కీవర్డ్ పరిచయం
కాబట్టి మేము రకాల మలచుకొనిన వేరియబుల్స్ సృష్టించవచ్చు.
మేము కూడా, ఫైలు I / O, ఫైలు ఇన్పుట్ మరియు అవుట్పుట్ యొక్క భావన పరిచయం
మరియు ఈ మేము రాష్ట్ర సేవ్ చేయవచ్చు ఉంది
మీ పెనుగులాట బోర్డు డిస్క్ లో ఉన్న ఒక ఫైల్ కు
టీచింగ్ సభ్యులు మరియు నేను అర్ధం తద్వారా
ఏ మానవీయంగా ప్లే చేయకుండా మీ ప్రోగ్రామ్ యొక్క లోపల జరగబోతోంది
పెనుగులాట యొక్క గేమ్స్ డజన్ల కొద్దీ.
మేము మరింత automatedly చేయవచ్చు.
>> ఒక struct ఈ ఆలోచన పూర్తి ఖచ్చితంగా సమస్య పరిష్కారమవుతుంది.
మేము కొన్ని కార్యక్రమం అమలు చేయదలిచిన ఒకవేళ
ఆ ఏదో, విద్యార్థులు సమాచారాన్ని ట్రాక్
మరియు విద్యార్థులు, ఉదాహరణకు, ఒక పేరు ఒక ID కలిగి ఉండవచ్చు
మరియు హార్వర్డ్ వంటి ప్రదేశంలో ఒక ఇల్లు, కాబట్టి ఈ సమాచారం యొక్క 3 ముక్కలు ఉంటాయి
మేము చుట్టూ ఉంచాలని, కాబట్టి నన్ను ముందుకు వెళ్లి ఇక్కడ ఒక చిన్న ప్రోగ్రామ్ రాయడం ప్రారంభిద్దాం,
stdio.h ఉన్నాయి.
నాకు cs50.h. ఉన్నాయి తెలియజేసేలా
అప్పుడు నా ప్రధాన విధి ప్రారంభించండి.
నేను ఏ ఆదేశ పంక్తి వాదనలు తో ఇబ్బంది లేదు
మరియు ఇక్కడ నేను ఒక విద్యార్థి కావాలి, కాబట్టి నేను వెళుతున్నాను
ఒక విద్యార్థి ఒక పేరు ఉంది, కాబట్టి నేను వెళుతున్నాను "స్ట్రింగ్ పేరు."
అప్పుడు నేను, ఒక విద్యార్థి కూడా, కాబట్టి Int ID ఒక ID కలిగి వెళుతున్న
మరియు ఒక విద్యార్ధి ఒక ఇల్లు ఉంది, నేను కూడా చెప్పడానికి వెళుతున్న "స్ట్రింగ్ హౌస్."
అప్పుడు నేను ఈ వంటి మరింత సజావుగా ఈ చిన్న ఆర్డర్ చేస్తాము.
సరే, ఇప్పుడు నేను, "ఒక విద్యార్థి." ఇది ఒక విద్యార్థి ప్రాతినిధ్యం 3 వేరియబుల్స్ ఉన్నాయి
>> ఇప్పుడు నేను ఈ విలువలు జననివాసం మీరు, కాబట్టి నా లాంటి ఏదో ముందుకు వెళ్లి అని పిలవబడు
"ID = 123."
పేరు డేవిడ్ పొందడానికి అన్నారు.
లెట్ యొక్క ఇల్లు, మాథుర్ పొందగలిగిన చెప్పారు
మరియు నేను ("% s, ఏకపక్ష printf వంటి ఏదో ఒకటి వెళుతున్న
దీని ID% d ఉంది,% s నివసిస్తున్నారు.
ఇప్పుడు, నేను, ఇక్కడ ప్లగిన్ ఇతర తర్వాత ఏది కావాలి?
పేరు, ID, house; తిరిగి 0.
సరే, తప్ప ఎక్కడో ఇక్కడ ఇరుక్కొనిపోయింది
మనం ఒక విద్యార్థి నిల్వ ఒక అందమైన మంచి కార్యక్రమం ఉంటుందని అనుకుంటున్నాను.
అయితే, ఈ అన్ని ఆసక్తికరమైన కాదు. నేను 2 విద్యార్థులు కలిగి అనుకుంటే?
ఏ పెద్ద ఒప్పందం పేర్కొంది. నేను 2 ప్రజలు మద్దతునిస్తుంది.
నాకు ముందుకు వెళ్లి ఈ హైలైట్ మరియు ఇక్కడ కోల్పోండి,
మరియు నేను కిర్క్ల్యాండ్ నివసించే రాబ్ వంటి ఒకరి కోసం "ID = 456" చెప్పగలను.
>> సరే,, వేచి, కాని నేను ఈ ఇదే కాల్ చెయ్యలేరు
మరియు నేను ఈ కాపీ కలిగి వెళుతున్న అనిపిస్తుంది,
కాబట్టి నన్ను ఈ డేవిడ్ యొక్క వేరియబుల్స్ అని అని పిలవబడు,
మరియు నాకు రాబ్ కోసం ఈ యొక్క కొన్ని కాపీలు పొందుటకు అనుమతిస్తుంది.
ఈ రోబ్ యొక్క పిలుస్తాను కానీ ప్రస్తుతం పని వెళ్ళడం లేదు
I-వేచి ఎందుకంటే, యొక్క NAME1 మరియు house1, id1 నాకు మార్చుకోవడానికి అనుమతించే.
రాబ్, 2 2 ఉంటుంది.
నేను ఇక్కడ, ఇక్కడ, ఇక్కడ, ఇక్కడ, ఇక్కడ, ఇక్కడ ఈ మార్పు వచ్చింది వచ్చింది.
వేచి, ఏమి టామీ గురించి? మళ్ళీ ఇది యొక్క లెట్.
మీరు ఇప్పటికీ ఈ ఈ చేయడం మంచి మార్గం అనుకుంటున్నాను నిజానికి, అది, కాదు
కాబట్టి కాపీ / చెడు అతికించండి.
అయితే వారం క్రితం ఈ పరిష్కారమైంది.
>> మేము అదే రకం అనేక చోట్ల కలిగి కోరుకున్నారు మా పరిష్కారం ఏమిటి?
[స్టూడెంట్స్] ఒక అమరిక.
ఒక అమరిక, కాబట్టి ఈ శుభ్రం చేయడానికి ప్రయత్నించండి తెలియజేయండి.
నాకు ఎగువన నా కోసం కొన్ని కల్పించడానికి, మరియు నాకు బదులుగా ఇక్కడ మనం లెట్.
ఈ ప్రజలు పిలుస్తాను, మరియు బదులుగా నేను ", Int ఐడిలు" అని వెళుతున్న
ఇప్పుడు మాకు యొక్క 3 మద్దతు వెళుతున్న.
నేను, "స్ట్రింగ్ పేర్లు" అని నేను మా 3 మద్దతు చేస్తాము వెళుతున్న
మరియు నేను ", స్ట్రింగ్ ఇళ్ళు" అని నేను మా 3 మద్దతు వెళుతున్న వెళుతున్న.
ఇప్పుడు ఇక్కడ బదులుగా డేవిడ్ తన స్వంత స్థానిక వేరియబుల్స్ పొందడానికి లో
మేము ఆ విమోచనం పొందవచ్చు.
అంటే ఈ శుభ్రం చేస్తున్న మంచి భావిస్తాడు.
నేను అప్పుడు డేవిడ్ [0] మరియు పేర్లు [0] అని అన్నారు చెప్పగలదు
మరియు గృహాలు [0].
మరియు తర్వాత మేము అదేవిధంగా ఈ సేవ్ చేయవచ్చు రోబ్.
యొక్క ఈ డౌన్ ఇక్కడ ఉంచండి తెలియజేయండి, కనుక అతను ఏకపక్ష ఐడిలు [1] చేస్తాడు.
అతను పేర్లు చేస్తాడు [1],
మరియు తర్వాత చివరగా, ఇళ్ళు [1].
>> , స్టిల్ కొద్దిగా శ్రమతో, మరియు ఇప్పుడు నేను ఈ గుర్తించడానికి కలిగి
చెప్పడానికి "లెట్స్ పేర్లు [0], id [0] ఇళ్ళు [0]
మరియు యొక్క ఈ ప్లూరలైజ్ తెలియజేయండి.
ఐడీలు, ID లు, ఐడిలు.
మరియు తిరిగి, దాని చేయటం నాకు నేను, మరలా, నేను ఇప్పటికే, మళ్ళీ అతికించండి / కాపీ నైజం నేను
కాబట్టి అసమానత మరొక పరిష్కారం ఇక్కడ ఉంది ఉంటాయి.
నేను బహుశా, ఆ వంటి లూప్ లేదా ఏదైనా మరింత ఈ శుభ్రం చేయవచ్చు
కాబట్టి చిన్న లో ఇది కాస్త బెటర్ కానీ అనుకుని
నేను అతికించండి / కాపీ నైజం చేస్తున్నాను, అయితే ఈ కూడా, నేను దావా
నిజంగా ప్రాథమికంగా కుడి పరిష్కారం కాదు ఎందుకంటే
కొన్నిసార్లు మేము నిర్ణయించుకుంటే మీరు ఏమి ఏమి?
మమ్మల్ని డేవిడ్ మరియు రాబ్ కోసం ఇమెయిల్ చిరునామాలను నిల్వ వుండాలి
మరియు ఈ కార్యక్రమంలో ప్రతి ఒక్కరూ.
మేము కూడా ఫోన్ సంఖ్యలను నిల్వ చేయాలి.
మేము కూడా అత్యవసర నంబర్లు నిల్వ చేయాలి.
మేము, మేము నిల్వ కావలసిన డేటా అన్ని ఈ ముక్కలు కలిగి
కాబట్టి మీరు చేసే విధంగా గురించి గో?
>> పైన ఉన్న మరొక శ్రేణి ప్రకటించి, తర్వాత మీరు మానవీయంగా జోడించండి
ఒక ఇమెయిల్ చిరునామా [0], ఇమెయిల్ చిరునామా [1]
డేవిడ్ మరియు రాబ్ కోసం మొదలైనవి.
కానీ ఈ రూపకల్పన అంతర్లీన కేవలం ఒక ఊహ నిజంగా ఉంది
నేను మీకు గౌరవం వ్యవస్థ ఉపయోగిస్తున్నాను ఆ
[I] అనేక శ్రేణుల యొక్క ప్రతి
కేవలం ఒకే వ్యక్తి చూడండి ఏమవుతుంది
కాబట్టి [0] ID లను సంఖ్య 123 ఉంది
మరియు నేను ఆ పేర్లు ఊహించుకోవటం వెళుతున్న [0]
అదే వ్యక్తి యొక్క పేరు మరియు ఇళ్ళు [0]
నేను సృష్టించే వివిధ శ్రేణుల యొక్క అన్ని ఒకే వ్యక్తి యొక్క హౌస్ మొదలైనవి ఉంది.
కానీ ప్రాథమిక బంధన ఉంది అని గుర్తించలేకపోతే
సమాచారం, id, పేరు మరియు ఇంటి ఆ 3 ముక్కలు మధ్య,
మేము ఈ కార్యక్రమంలో మోడల్ ప్రయత్నిస్తున్న పరిధి శ్రేణుల అయినప్పటికీ.
వ్యూహాలను ఇలా ఈ ప్రోగ్రాముల మార్గం.
మేము నిజంగా మా కార్యక్రమం లో మోడల్ చేయడానికి ఏమి ఒక వ్యక్తి
డేవిడ్, ఇది లోపలి రాబ్ వంటి ఒక వ్యక్తి వలె
లేదా encapsulating ఒక పేరు మరియు ID మరియు ఒక మందిరం.
>> మేము ఏదో తొడుగు ఈ ఆలోచన వ్యక్తీకరించవచ్చు
ఒక వ్యక్తి ఒక ID, ఒక పేరు మరియు ఒక ఇల్లు ఉంది అనగా
మరియు నిజంగా ఈ హాక్ ఆశ్రయించాల్సిన లేదు వస్తే మేము
ఆ బ్రాకెట్ ఏదో విశ్వసించే
ఈ అసమాన శ్రేణుల యొక్క ప్రతి అదే మానవ పరిధి సూచిస్తుంది?
మేము నిజంగా చేయవచ్చు.
నాకు ఇప్పుడు పై ప్రధాన వెళ్లి, నా సొంత డేటా రకం సృష్టించడానికి వీలు లెట్
మొదటిసారి నిజంగా కోసం.
మేము, పెనుగులాట లో ఈ టెక్నిక్ ఉపయోగించిన
కానీ ఇక్కడ నేను, ముందుకు వెళ్ళి, ఒక డేటా రకాన్ని సృష్టించడానికి వెళుతున్న
మరియు మీరు ఏ, నేను, విద్యార్థి లేదా వ్యక్తి కాల్ వెళుతున్న తెలుసు
మరియు నేను టైప్ ను నిర్వచిస్తాయి కోసం typedef ఉపయోగించడానికి వెళుతున్న.
నేను, ఈ నిర్మాణం పేర్కొన్నారు వెళుతున్న
మరియు ఈ నిర్మాణం, రకం విద్యార్థి యొక్క కోసం, మేము సే చేస్తాము అన్నారు
అది నాకు ఇప్పుడు నాటి లిటిల్ అయినప్పటికీ.
మేము "Int ID." అని మీరు
మేము "స్ట్రింగ్ పేరు." అని మీరు
అప్పుడు మేము "స్ట్రింగ్ హౌస్," అని మీరు
కాబట్టి ఇప్పుడు కోడ్ ఈ కొన్ని పంక్తులు చివరికి
నేను ఉంది గణగణమని ద్వని చేయు నేర్చుకున్న
తీగలను పాటు ints పక్కన ఒక డేటా రకాన్ని, పాటు తేలియాడుతున్న పాటు, డబుల్స్.
>> సమయ పంక్తి 11 లో ఈ క్షణం నాటికి, విద్యార్థులు అనే కొత్త రకం డేటా, ఇప్పుడు ఉంది
మరియు ఇప్పుడు నేను, ఎక్కడైనా నేను అనుకుంటున్నాను ఒక విద్యార్థి వేరియబుల్ ప్రకటించవచ్చు
కాబట్టి నన్ను ప్రజలు ఇక్కడ స్క్రోల్ డౌన్ తెలపండి.
, ఇప్పుడు నేను ఈ వదిలించుకోవటం మరియు నేను ఇక్కడ డేవిడ్ తిరిగి డౌన్ వెళ్ళే
మరియు డేవిడ్ కోసం నేను నిజంగా ఆ డేవిడ్, చెప్పగలదు
మేము వాచ్యంగా, నాకు తర్వాత వేరియబుల్ పేరు చేయవచ్చు
రకం విద్యార్థి అని అన్నారు.
ఈ చిన్న అసహజ చూడండి ఉండవచ్చు కానీ ఈ అన్ని ఆ వివిధ కాదు
ఒక పూర్ణాంకానికి లేదా ఒక స్ట్రింగ్ లేదా ఫ్లోట్ గా ఏదో ప్రకటించారు నుండి.
ఇది కేవలం కాబట్టి, ఇప్పుడు విద్యార్థి అని ఏమవుతుంది
మరియు నేను ఈ నిర్మాణం లోపల ఏదో ఉంచండి అనుకుంటే
నేను ఇప్పుడు వాక్యనిర్మాణం యొక్క కొత్త భాగాన్ని ఉపయోగించడానికి ఉంటుంది, కాని అది చాలా సూటిగా ఉంది
david.id = 123, రాజధాని D లో david.name = "డేవిడ్",
మరియు david.house = "మాథుర్,"
మరియు ఇప్పుడు నేను ఇక్కడ ఈ విషయాన్ని విమోచనం పొందవచ్చు.
మేము ఇప్పుడు నిజంగా ఒక మంచి మార్గంలో మా కార్యక్రమం తిరిగి రూపకల్పన చేసిన ప్రకటన
ఆ ఇప్పుడు మా కార్యక్రమం వాస్తవ ప్రపంచ ప్రతిబింబిస్తుంది.
>> ఒక వ్యక్తి లేదా ఒక విద్యార్థి యొక్క వాస్తవ ప్రపంచ భావన ఉంది.
ఇక్కడ మేము ఇప్పుడు ఒక వ్యక్తి లేదా ప్రత్యేకంగా ఒక విద్యార్థి ఒక సి సంస్కరణను కలిగి ఉన్నారు.
ఆ వ్యక్తి యొక్క లోపలి ఈ సంబంధిత లక్షణాల ఉన్నాయి
ID, పేరు మరియు ఇంటి, కాబట్టి రాబ్ ముఖ్యంగా డౌన్ ఇక్కడ ఇదే అవుతుంది,
, విద్యార్థి రాబ్ కాబట్టి, మరియు ఇప్పుడు = 456 rob.id
rob.name = "రాబ్."
వేరియబుల్ రాబ్ అంటారు వాస్తవం అర్ధం యొక్క విధమైన ఉంది.
మేము X లేదా Y లేదా z అని ఉండవచ్చు.
మేము దానిని అర్థ వివరణ కలిగి రాబ్ అనే
కానీ నిజంగా పేరు, ఆ రంగం యొక్క లోపల ఉంది
కాబట్టి ఇప్పుడు నేను ఈ ఉంటాయి.
ఈ చాలా గట్టిగా డేవిడ్ కోడ్ చేసిన అత్యుత్తమ డిజైన్ భావిస్తాను లేదు.
నేను హార్డ్ రాబ్ కోడ్ చేసిన.
నేను ఇప్పటికీ కొన్ని కాపీ ఆశ్రయించాల్సిన మరియు నేను కొత్త వేరియబుల్స్ కావలసిన ప్రతిసారీ పేస్ట్ చేయాలి.
అంతేకాకుండా, నేను, స్పష్టంగా అంశాలపై ప్రతి ఒక పేరు ఇవ్వాల్సి ఉంటుంది
నేను చాలా కాకుండా అంశాలపై వివరించడానికి మీరు కూడా
మరింత సామాన్యముగా వంటి విద్యార్థులు.
>> ఇప్పుడు మేము బాగా పని చేసిన ఆలోచనలు విలీనం చెయ్యగలరు
మరియు బదులుగా, మీరు నాకు వేరియబుల్ అని విద్యార్థులు ఇవ్వాలని ఏ, తెలిసిన "సే
మరియు ఇప్పుడు నేను ఈ మరింత శుద్ధి కాబట్టి ", ఇది పరిమాణం 3 అయి వివరించారు,
, మానవీయంగా డిక్లేర్డ్ డేవిడ్ వదిలించుకోవటం
మరియు నేను బదులుగా [0] ఇక్కడ విద్యార్థులు వంటి ఏదో చెప్పగలను.
నేను, [0] ఇక్కడ విద్యార్థులు చెప్పగలదు
విద్యార్థులు ఇక్కడ, మొదలైనవి [0], మరియు నేను చుట్టూ వెళ్ళే
మరియు రాబ్ ఆ శుభ్రం.
నేను కూడా ఇప్పుడు బహుశా ఒక లూప్ జోడించడం గురించి వెళ్ళటానికి
మరియు వాస్తవానికి వినియోగదారు నుండి ఈ విలువలు పొందడానికి GetString మరియు GetInt ఉపయోగించి.
ఈ సాధారణంగా తప్పుడు పద్ధతి ఎందుకంటే నేను స్థిరమైన జోడించడం గురించి వెళ్ళటానికి
ఇక్కడే 3 హార్డ్ కోడ్ కొన్ని స్వతంత్రమైన
మరియు అప్పుడు మీరు ఇంకా ఏ 3 కంటే విద్యార్థులు ఉంచారు అని గుర్తు.
ఇది బహుశా నా ఫైలు ఎగువన నిర్వచించే # ఉపయోగించడానికి మంచిదని
మరియు అవ్ట్, కాబట్టి నిజానికి నాకు ముందుకు వెళ్లి ఈ క్రమపరచుట అనుమతించే అంశం.
>> నాకు నేటి మధ్య ఉండే ఒక ఉదాహరణ ప్రారంభం లెట్
ముందుగానే ఉదాహరణలు, structs1.
ఈ # ఇక్కడ నిర్వచించే ఉపయోగించే మరింత పూర్తి కార్యక్రమం
మరియు మేము సిద్ధంగా 3 విద్యార్ధులు చూడాలని అన్నారు.
ఇక్కడ నేను, విద్యార్థులు ఒక తరగతి విలువ ప్రకటించి నేను
విద్యార్థులు ఒక తరగతిలో కాబట్టి, మరియు ఇప్పుడు నేను ఒక లూప్ ఉపయోగించి నేను
కేవలం కోడ్ కొంచెం సొగసైన చేయడానికి, తరగతి జననివాసం
యూజర్ యొక్క ఇన్పుట్ తో, కాబట్టి 3 ఇది విద్యార్థులు, నేను = 0 నుండి అప్ iterate.
మరియు నేను ఈ వెర్షన్ లో వినియోగదారును ప్రాంప్ట్
ఏ విద్యార్థి ID, మరియు నేను GetInt తో పొందండి.
ఏ విద్యార్థి యొక్క పేరు, మరియు అప్పుడు నేను GetString తో పొందండి.
విద్యార్థి ఇంటికి ఏమిటి? నేను GetString తో పొందండి.
మరియు ఇక్కడ దిగువన నేను మార్చడానికి నిర్ణయించుకున్నారు
నేను ఈ ముద్రించిన ఏళ్ళ అసలైన లూప్ ఎలా ఉపయోగించాలో,
మరియు నేను చేసిన ప్రింటింగ్ వున్నాను?
వ్యాఖ్య ప్రకారం నేను, మాథుర్ ఎవరైనా ప్రింటింగ్ నేను
మరియు ఆ రాబ్ మరియు టామీ అదే విధంగా ముందుకు-వాస్తవానికి టామీ యొక్క మాథుర్ లో ఇది.
టామీ మరియు డేవిడ్ ఈ సందర్భంలో ముద్రించబడిన, కానీ ఎలా ఈ పని ఉంది?
మేము ముందు ఈ ఫంక్షన్ చూడరు, కానీ అలా ఏమి ఒక అంచనా పడుతుంది లేదు.
తీగలను సరిపోలుస్తుంది.
>> ఇది అవుతుంది ఎందుకంటే తీగలను సరిపోలుతుందో కొద్దిగా కాని స్పష్టమైన యొక్క
అది అర్థం 0 తిరిగి ఉంటే తీగలు ఉంటాయి.
అది ఒక -1 తిరిగి ఉంటే ఒక, ఇతర ముందు అక్షర వస్తుంది అంటే
ఇతర పదం అర్థం +1 తిరిగి ఉంటే మరియు అక్షర వస్తుంది
ఇతర ముందు, మరియు మీరు ఆన్లైన్ లేదా మనిషి పేజీ చూడవచ్చు
సరిగ్గా ఇది మార్గం ఇది చూడటానికి, కానీ ఈ ఇప్పుడు చేస్తున్న అది చెప్పడం అని
[i]. హౌస్ "మాథుర్" సమానంగా ఉంటే
అప్పుడు ముందుకు వెళ్లి అలా ముద్రించాలా మరియు అందువలన మాథుర్ ఉంది.
కానీ ఇక్కడ మేము ముందు చూడని ఏదో ఉంది, మరియు మేము ఈ వచ్చి చేస్తాము.
నేను ఎప్పుడూ నా కార్యక్రమాలు ఏ దీన్ని అవసరం గుర్తు లేదు.
ఉచిత స్పష్టంగా, మెమరీ సూచిస్తూ మెమరీ ఉండండి ఉంది
కానీ నేను స్పష్టంగా ఈ కార్యక్రమం దిగువన ఈ లూప్ లో ఏం మెమరీ ఉండండి వున్నాను?
నేను ఒక వ్యక్తి యొక్క పేరు ఉండండి నేను కనిపిస్తుంది
మరియు ఒక వ్యక్తి యొక్క ఇల్లు, కాని ఎందుకు అని?
>> మీరు GetString ఉపయోగించి చేసిన అన్ని ఈ వారాల అవుతుంది
మేము రకమైన మీ కార్యక్రమాల ప్రతి ఒక ఒక బగ్ పరిచయం చేసిన.
మీరు ఒక స్ట్రింగ్ తిరిగి విధంగా రూపకల్పన కేటాయించుకునే మెమరీ ద్వారా GetString,
వంటి డేవిడ్, లేదా రాబ్, మరియు మీరు మీకు కావలసిన పనులను చేయవచ్చు
మేము మీ కోసం మెమరీ రిజర్వు చేసిన ఎందుకంటే మీ కార్యక్రమంలో ఆ తీగ.
సమస్య మీరు GetString కాల్ ప్రతిసారీ ఈ సమయం
మేము, GetString రచయితలు, ఆపరేటింగ్ సిస్టమ్ అడగడం జరిగింది
ఈ స్ట్రింగ్ కోసం మాకు RAM యొక్క ఒక బిట్ ఇవ్వాలని.
ఈ తదుపరి స్ట్రింగ్ కోసం మాకు RAM యొక్క ఒక బిట్ ఇవ్వండి.
మాకు ఈ తదుపరి స్ట్రింగ్ కోసం కొన్ని మరింత RAM ఇవ్వండి.
ఏం మీరు, ప్రోగ్రామర్, చేస్తున్న ఎప్పుడూ
, మాకు ఆ స్మృతి తిరిగి ఇవ్వడం ఉంది
కాబట్టి ఈ అనేక వారాలు కార్యక్రమాలు అన్ని మీరు వ్రాయలేదు
వారు ను ఉపయోగిస్తూ చేయటం కూడా మెమరీ లీపు అని ఏమి కలిగి
మరింత మెమరీ మీరు GetString కాల్, మరియు ఆ మంచిది ప్రతిసారీ.
ఇది ఆసక్తికరమైన కాదు ఎందుకంటే మేము ఉద్దేశపూర్వకంగా మొదటి వారాలలో అలా
స్ట్రింగ్ నుంచి వస్తున్న కౌంటీ గురించి ఆందోళన కలిగి.
మీరు అన్ని పదం ఉన్నప్పుడు యూజర్ రకాల అది సైన్ తిరిగి రావాలని రోబ్ ఉంది
>> కానీ ముందుకు వెళ్ళటం మేము ఇప్పుడు దీని గురించి మరింత క్లిష్టమైన పొందడానికి ప్రారంభించడానికి కలిగి ఉంటాయి.
మేము మెమరీని కేటాయించాల్సిన ఏ సమయంలో మేము మంచి చివరికి తిరిగి చేతితో.
లేకపోతే మీ Mac లేదా PC లో నిజ ప్రపంచంలో మీరు అప్పుడప్పుడు అనుభవం కలిగి ఉండవచ్చు
మీ కంప్యూటర్ చివరకు halt కు గ్రౌండింగ్ కౌంటీ లక్షణాలు
లేదా స్టుపిడ్ స్పిన్నింగ్ బీచ్ బంతి కేవలం కంప్యూటర్ యొక్క భాగమును ఆక్రమించి ఉన్న
మొత్తం దృష్టిని మరియు మీరు పనులను కాదు.
ఆ దోషాలను ఎన్ని వివరించారు, కానీ ఆ అవకాశం దోషాలు మధ్య చేయవచ్చు
విషయాలు మెమరీ లీకేజ్ అని చేయటం సాఫ్ట్వేర్ ఆ భాగాన్ని రాశాడు ఎవరైనా
మీరు ఉచిత మెమరీ గుర్తుంచుకోండి లేదు ఉపయోగించే
అతను లేదా ఆమె కోసం ఆపరేటింగ్ సిస్టమ్ కోరింది
ఒక CS50 విషయం ఎందుకంటే, GetString ఉపయోగించి, కాని ఇలాంటి ఫంక్షన్లను ఉపయోగించి లేదు
మెమరీ కోసం ఆపరేటింగ్ సిస్టమ్ అడిగే.
మీరు లేదా అవి మేకు మరియు ఉంటే వాస్తవానికి ఆ స్మృతి ఎన్నటికీ తిరిగి
ఒక ప్రోగ్రామ్ తగ్గిస్తుంది మరియు తగ్గిస్తుంది మరియు వేగం తగ్గితే ఆ ఉండాలనే ఒక కారణం
మీరు ఉచిత కాల్ గుర్తుంచుకోండి తప్ప.
>> ఎప్పుడు ఎందుకు మీరు ఉచిత అంటారని మేము వచ్చి చేస్తాము
కానీ యొక్క కేవలం మంచి కొలత కోసం ముందుకు వెళ్లి ఈ ప్రత్యేక కార్యక్రమం అమలు ప్రయత్నించండి తెలియజేయండి.
ఈ structs1 అని పిలిచేవారు, ఇవ్వండి.
డేవిడ్ మాథుర్, నాకు ముందుకు వెళ్లి structs1 అమలు 123 లెట్
456, రాబ్ కిర్క్ల్యాండ్, 789,
టామీ మాథుర్, మరియు మేము మాథుర్ డేవిడ్ చూడండి, టామీ యొక్క మాథుర్ లో.
ఈ కార్యక్రమం పనిచేస్తుందని కొంచెం తెలివి చెక్ ఉంది.
ఇప్పుడు, దురదృష్టవశాత్తు, ఈ కార్యక్రమం ఆ చిన్న నిరాశపరిచింది ఉంది
నేను 9 తీగలు అన్ని పని టైప్ లేదు, ఎంటర్ నొక్కండి
మాథుర్ లో ఉన్న చెప్పారు, ఇంకా ఖచ్చితంగా నేను టైప్ ఎందుకంటే ఇప్పటికే మాథుర్ లో తెలిసినట్లు జరిగినది.
ఈ కార్యక్రమం మరింత డేటాబేస్ వంటి ఉంటే కనీసం బాగుండేది
మరియు అది నిజానికి నేను టైప్ చేసిన తర్వాత ఏమి గుర్తు
నేను మళ్ళీ ఈ ఇన్పుట్ విద్యార్థి రికార్డులు అవసరం లేదు.
దీనికి ఒక registrarial వ్యవస్థ వంటిది.
>> మేము, ఫైలు I / O, ఫైలు ఇన్పుట్ మరియు అవుట్పుట్ గా పిలువబడే ఈ పద్ధతిని ఉపయోగించి చేయవచ్చు
మీరు ఫైల్లను చదవండి లేదా ఫైళ్ళను రాయడానికి కావలసిన సమయం చెప్పడం చాలా సాధారణ మార్గం
మీరు విధులను కొన్ని నియమాలకు తో చేయవచ్చు.
నాకు ముందుకు వెళ్లి ఈ ఉదాహరణ structs2.c తెరిచి లెట్
ఇది దాదాపు ఒకేలా ఉంటుంది, కానీ ఇప్పుడు ఏమి చూడటానికి యొక్క.
ఫైలు ఎగువన నేను విద్యార్థులు ఒక తరగతి ప్రకటిస్తాయి.
నేను, వినియోగదారు యొక్క ఇన్పుట్ తో క్లాస్ జననివాసం
కాబట్టి కోడ్ ఆ పంక్తులు సరిగ్గా ముందు వంటివే.
మాథుర్ లో ఉన్న ప్రతి ఒక్కరూ ఏకపక్ష ముందు నేను ఇక్కడ స్క్రోల్ డౌన్ అయితే నేను ప్రింట్
కానీ ఈ ఆసక్తికరమైన కొత్త లక్షణం.
, కోడ్ యొక్క ఈ పంక్తులు కొత్త అవి ఇక్కడ ఏదో పరిచయం
ఫైలు, అన్ని టోపీలు, మరియు అది ఇక్కడ * కలిగి ఉంది.
నాకు అదే ఇక్కడ పైగా, ఇక్కడ ఒక * ఈ తరలించడానికి లెట్.
>> ఈ ఫంక్షన్ మేము ముందు చూడని, fopen,
కానీ ఫైల్ను తెరువు అంటే, కనుక ఈ ద్వారా యొక్క చెడిపోయిన తెలియజేయండి
మరియు ఈ, మేము భవిష్యత్ psets లో తిరిగి వచ్చి మీరు విషయం
కానీ ఇక్కడ ఈ లైన్ ముఖ్యంగా, డేటాబేస్ గా పిలువబడే ఒక ఫైల్ తెరుచుకుంటుంది
మరియు అది ప్రత్యేకంగా అది ఏ చేసే విధంగా అది తెరుచుకుంటుంది?
[వినబడని-విద్యార్థి]
కుడి, కనుక "W" జస్ట్ ఆపరేటింగ్ సిస్టమ్ చెప్పుచున్నారు అర్థం
నేను వ్రాయగలరు విధంగా ఈ ఫైల్ను తెరవడం.
నేను చదవడం ఇష్టం లేదు. కేవలం ఇది కు ఇష్టం లేదు.
నేను, దాన్ని మార్చండి మరియు శక్తివంతంగా stuff జోడించదలచిన
మరియు ఫైల్ డేటాబేస్ అని అన్నారు.
ఈ ఏదైనా చెప్పబడతాయి.
ఈ database.txt ఉంటుంది. ఈ. DB ఉంటుంది.
ఈ foo లాంటి పదం ఉంటుంది, కానీ నేను ఏకపక్ష ఫైలు డేటాబేస్ పేరు ఎంచుకున్నాడు.
ఈ, మేము సమయం మీద ఎక్కువ వివరాలు వచ్చి మేము ఒక చిన్న తెలివి చెక్ ఉంది
fp, ఫైలు పాయింటర్ కోసం, సమాన NULL లేనప్పుడు అన్ని బాగా అర్థం.
>> లాంగ్ కథ చిన్న, fopen వంటి విధులను కొన్నిసార్లు విఫలం.
బహుశా ఫైల్ ఉనికిలో లేదు. బహుశా మీరు డిస్కు ఖాళీ లేదు.
బహుశా మీరు ఆ ఫోల్డర్ అనుమతి లేదు
fopen శూన్య ఏదో తిరిగి అయితే చెడు జరిగింది.
Fopen శూన్య తిరిగి ఒకవేళ విరుద్ధంగా, అన్ని బాగా ఉంటుంది
మరియు నేను ఈ ఫైలుకు రాయడం మొదలు పెట్టవచ్చు.
ఇక్కడ ఒక కొత్త ట్రిక్ యొక్క.
ఇది నా విద్యార్థులు ప్రతి పైగా iterating ఒక కోసం లూప్ ఉంది
మరియు ఈ, మేము ముందు చేసిన ఏ అలా పోలి ఉంది
కానీ ఈ ఫంక్షన్, printf printf ఫైల్ కోసం fprintf అని ఒక బంధువు
మరియు అది మాత్రమే 2 మార్గాలు వివిధ నోటీసు.
ఒకటి, అది, బదులుగా p యొక్క f మొదలవుతుంది
కానీ దాని మొదటి వాదన స్పష్టంగా ఏమిటి?
[స్టూడెంట్స్] ఫైలు. >> ఇది ఒక ఫైలు యొక్క.
మేము చివరికి ఒక ఫైలు పాయింటర్ ఏమిటి కాకుండా బాధించటం మేము fp అని ఈ విషయం,,
కానీ ఇప్పుడు కోసం fp కేవలం నేను తెరిచిన ఫైల్ సూచిస్తుంది
కాబట్టి fprintf ఇక్కడ, ఫైలు ఈ యూజర్ యొక్క ID ముద్రించడం సాధ్యం కు చెబుతున్నారు.
ఫైలు యూజర్ యొక్క పేరును, కాని స్క్రీన్ చేయడం, ముద్రించడం
ఫైల్ చేయడానికి, కాదు, సహజంగా, డౌన్ ఇక్కడ అప్పుడు స్క్రీన్ చేయడం, మరియు హౌస్
ఫైలు మూసివేయండి, అప్పుడు డౌన్ ఇక్కడ మెమరీ ఉచిత.
>> ఈ వెర్షన్ 2 మరియు సంస్కరణ 1 మధ్య తేడా
fopen పరిచయం మరియు * ఈ ఫైలు
మరియు fprintf యొక్క ఈ భావన, కాబట్టి ముగింపు ఫలితంగా ఏమిటి యొక్క చూసేలా.
నా టెర్మినల్ విండో లోకి వెళ్ళి తెలపండి.
నమోదు, నాకు structs2 అమలు అయ్యేలా అనుమతించండి.
అన్ని బాగా ఉన్నట్లు కనిపిస్తుంది. యొక్క structs2 తిరిగి లెట్.
123, డేవిడ్ మాథుర్, 456, రాబ్ కిర్క్ల్యాండ్,
789, టామీ మాథుర్, ఇవ్వండి.
ఒకే ప్రవర్తించారు కనిపిస్తోంది, కానీ ఇప్పుడు ls లేకపోతే
నా కోడ్ మధ్య ఇక్కడ ఏమి ఫైలు గమనించి, డేటాబేస్,
కాబట్టి యొక్క ఆ వద్ద ఆ, డేటాబేస్ యొక్క gedit, మరియు లుక్ తెరిచి తెలియజేయండి.
ఇది ఫైల్ ఫార్మాట్లు అత్యంత శృంగారమైన కాదు.
నిజంగా పంక్తికి పంక్తికి డేటా లైన్ ఒకటి భాగం
కానీ Excel లేదా CSV ఫైళ్లు ఉపయోగించే మీరు ఆ, కామా విలువలు వేరు
నేను ఖచ్చితంగా బదులుగా బహుశా దీన్ని ఇష్టపడుతున్నారు ఏదో ఒకటి చేయడానికి fprintf ఉపయోగించారు కాలేదు
నిజానికి Excel ఫైల్ యొక్క సమానమైన సృష్టించడానికి అందువల్ల ఆ
కామాలు, కేవలం కొత్త లైన్లను విషయాలు వేరుచేయడం ద్వారా.
>> ఈ సందర్భంలో నేను బదులుగా కామాలతో బదులుగా కొత్త మార్గాల ఉపయోగిస్తారు ఉంటే
నేను బదులుగా ఇలా చేసిన నేను అక్షరాలా Excel లో ఈ డేటాబేస్ ఫైల్ను తెరవడం సాధ్యం.
చిన్న లో, ఇప్పుడు మేము ఫైళ్లను వ్రాయడం అధికారం ఆ
మేము ఇప్పుడు డిస్క్ మీద ఉంచుకున్నాము, కొనసాగుతుంది డేటా ప్రారంభించవచ్చు
మేము మళ్లీ మళ్లీ చుట్టూ సమాచారాన్ని చేయవచ్చు.
ఇప్పుడు కొంచెం ఎక్కువగా తెలిసిన ఇతర విషయాలను గమనించండి.
ఈ సి ఫైలు ఎగువన మేము ఒక typedef కలిగి
మేము ఒక పదానికి ఒక డేటా రకాన్ని సృష్టించాలనుకుంది, ఎందుకంటే
ఈ రకం పదం అంటారు కాబట్టి, మరియు లోపల ఈ నిర్మాణం యొక్క
అది ఇప్పుడు చిన్న ఫ్యాన్సియెర్స్ ఉంది.
ఎందుకు పదం స్పష్టంగా వ్యూహం రూపొందించబడింది?
కేవలం intuitively పదం ఏమిటి?
>> ఇది అక్షరాలు యొక్క వ్యూహం ఉంది.
దానిని తిరిగి తిరిగి అక్షరాలు ఒక శ్రేణి యొక్క.
అన్ని CAPS లో అక్షరాలు మేము ఏకపక్ష సే నిర్మాణము గరిష్ట పొడవు
మేము పెనుగులాట కోసం ఉపయోగించే ఆ నిఘంటువులో ఏ పదం యొక్క.
నేను ఒక +1 ఉన్నాయి?
శూన్య పాత్ర.
మేము Bananagrams ఉదాహరణ చేసుకుంది మేము ఒక ప్రత్యేక విలువ అవసరం రీకాల్
ట్రాక్ పదం చివర క్రమంలో
సమస్య సెట్ వివరణ చెప్పారు పదాలు వాస్తవానికి ఆగిపోయిన యొక్క, మరియు
ఇక్కడ మేము, ఒక పదం బూలియన్ విలువ అనుబంధించడం చేస్తున్నారు
ఒక జెండా, కాబట్టి, ఒప్పు లేదా తప్పు మాట్లాడటం.
మేము గుర్తించడం ఎందుకంటే మీరు ఇప్పటికే ఈ పదం కనుగొన్నారు
మేము నిజంగా గుర్తు ఒక మార్గం అవసరం మాత్రమే పెనుగులాట ఒక పదం ఏమిటి
కానీ మీరు లేదో, మానవ, అది కనుగొన్నారు
మీరు కనుగొనడానికి లేకపోతే పదం "" మీరు టైప్ కాదు, అందువలన ఎంటర్, ఎంటర్, ఎంటర్
మరియు 3 పాయింట్లు, 3 పాయింట్లు, 3 పాయింట్లు, 3 పాయింట్లను పొందుతారు.
మేము ఒక bool అమర్చుట ద్వారా ఆ పదం బ్లాక్ లిస్టు చెయ్యడానికి మీరు
మీరు ఇప్పటికే అది అనిపిస్తే ఎందుకు నిజమైన, అందుచే మేము యొక్క
ఈ నిర్మాణం లో కప్పబడుతుంది.
>> ఇప్పుడు, డౌన్ ఇక్కడ పెనుగులాట లో నిఘంటువు అని ఈ ఇతర struct ఉంది.
ఇక్కడ కరువవడంతో typedef పదం ఎందుకంటే ఈ సందర్భంలో
మేము, ఒక నిఘంటువు యొక్క ఆలోచన మాత్రం అవసరం
మరియు ఒక నిఘంటువు, పదాల మొత్తం బంచ్ కలిగి
ఈ శ్రేణి సూచించినట్లు, మరియు ఎలా ఆ పదాలు చాలా ఉన్నాయి?
Well, ఈ వేరియబుల్ అని పరిమాణం అన్నారు ఏ.
కానీ మేము కేవలం ఒక నిఘంటువు అవసరం.
మేము నిఘంటువు అనే డేటా రకం అవసరం లేదు.
మేము వాటిని ఒక అవసరం, కాబట్టి ఇది C హాజరవుతారు
మీరు typedef చెప్పలేను, మీరు struct పేర్కొన్నట్లు, అప్పుడు వంకర జంట కలుపులు లోపల
మీరు పేరు పెట్టి తర్వాత, మీ వేరియబుల్స్ ఉంచండి.
ఈ ఒక వేరియబుల్ అని నిఘంటువు ప్రకటించటం
ఈ కనిపిస్తోంది.
దీనికి విరుద్ధంగా, ఈ పంక్తులు పదం అని ఒక పునర్వినియోగ డేటా నిర్మాణం సృష్టిస్తున్నారు
మేము సృష్టించిన వలె మీరు, పలు కాపీలు సృష్టించవచ్చు ఆ
విద్యార్థులు పలు కాపీలు.
>> ఈ చివరికి మాకు ఏమి అనుమతిస్తోంది?
నాకు సులువైన సార్లు నుండి, చెప్పాలి సాధారణ ఉదాహరణ కదా, తిరిగి వెళ్ళి తెలపండి,
మరియు compare1.c, యొక్క అని పిలవబడు, నాకు తెరవడం అనుమతిస్తాయి.
చేతిలో ఇక్కడ సమస్య వాస్తవానికి తిరిగి చర్మము ఉంది
ఒక స్ట్రింగ్ యొక్క పొర మరియు ఈ శిక్షణ చక్రాలు ఆఫ్ అవుతూ ప్రారంభం
అది ఒక స్ట్రింగ్ అన్ని ఈ సమయంలో అవుతుంది ఎందుకంటే
మేము నిజంగా వారం 1 కేవలం ఒక మారుపేరు వాగ్దానం వంటి ఉంది,
పర్యాయపదంగా కొంచెం గుప్తమైన కనిపించే ఏదో కోసం CS50 లైబ్రరీ నుండి,
చార్ *, మరియు మేము ముందు ఈ స్టార్ చూసిన.
మేము ఫైళ్లను సందర్భంలో చూశాడు.
>> మేము ఇప్పుడు కొంత సమయం కోసం ఈ వివరాలు దాచి చేసిన వై ఇప్పుడు చెప్పండి.
ఇక్కడ compare1.c గా పిలువబడే ఒక ఫైల్, ఉంది
మరియు ఇది స్పష్టంగా, s మరియు t, 2 రెమ్మలు కోసం వినియోగదారు అడుగుతుంది
మరియు అప్పుడు, లైన్ 26 లో సమానత్వం కోసం ఆ తీగలను పోల్చడం ప్రయత్నిస్తుంది
వారు అది సమాన అయితే, "మీరు అదే పని టైప్"
మరియు వారు సమానం కాదు అయితే అది "మీరు వివిధ విషయాలను టైప్" అని అంటాడు.
నాకు ముందుకు వెళ్లి ఈ ప్రోగ్రామ్ రన్ లెట్.
నా మూల డైరెక్టరీ లోకి వెళ్ళి తెలపండి, ఒక compare1 చేయండి. ఇది సరే సంకలనం.
నాకు compare1 అమలు అయ్యేలా అనుమతించండి.
నేను, జూమ్ నమోదు చేస్తారు.
ఏదైనా చెప్పండి. HELLO.
నేను మళ్ళీ ఏదైనా చెప్పండి చేస్తాము. HELLO.
నేను ఖచ్చితంగా వివిధ విషయాలను టైప్ లేదు.
>> నాకు మళ్ళీ ప్రయత్నించండి లెట్. బై బై.
ఖచ్చితంగా వివిధ కాదు, ఇక్కడ ఏమి కాబట్టి?
Well, నిజంగా లైన్ 26 లో ఏం పోలిస్తే ఉంది?
[వినబడని-విద్యార్థి]
అవును, కాబట్టి ఇది ఒక స్ట్రింగ్, డేటా రకం, ఒక తెల్ల అబద్ధం రకం అని అవుతుంది.
ఒక స్ట్రింగ్ ఒక చార్ *, కానీ ఒక చార్ * ఏమిటి?
ఒక చార్ *, వారు చెప్పగలను, ఒక పాయింటర్ గా
మరియు ఒక పాయింటర్, ప్రభావవంతంగా ఒక చిరునామా
ఒక మొత్తం మెమరీలో స్థానం, మరియు మీరు HELLO వంటి పదం టైప్ చేసిన తర్వాత జరిగితే,
తీగల యొక్క గత చర్చల నుండి రీకాల్
ఈ పదం వంటి HELLO ఉంది.
HELLO వంటి ప్రాతినిధ్యం పదం చేయవచ్చు గుర్తుంచుకోండి
ఈ వంటి పాత్రలు యొక్క వ్యూహం
తరువాత చివరిలో ఒక ప్రత్యేక పాత్ర, శూన్య పాత్ర అని
\ సూచిస్తుంది వంటి.
ఒక స్ట్రింగ్ నిజానికి ఏమిటి?
, ఈ మెమరీ బహుళ భాగాలుగా ఉంది అని గుర్తించలేకపోతే
మీరు మొత్తం స్ట్రింగ్ ద్వారా చూడండి ఒకసారి మరియు వాస్తవానికి, ముగింపు మాత్రమే అంటారు
ప్రత్యేక శూన్య పాత్ర కోసం చూస్తున్న.
కానీ ఈ నా కంప్యూటర్ యొక్క మెమరీ నుంచి మెమరీ భాగం ఉంది,
లెట్స్ ఏకపక్ష ఈ స్ట్రింగ్ కేవలం లక్కీ వచ్చింది, చెబుతారు
మరియు ఇది నా కంప్యూటర్ యొక్క RAM యొక్క చాలా ప్రారంభంలో ఉంచిన తీసుకున్నారు.
ఈ బైట్ 0, 1, 2, 3, 4, 5, 6 ...
>> నేను GetString వంటి ఏదైనా చెప్పండి నేను స్ట్రింగ్ s = GetString చేసినప్పుడు
నిజంగా ఏమి తిరిగి చేయబడిన?
ఈ గత కొన్ని వారాలపాటు, వాట్ రియల్లీ s నిల్వ చేయబడిన
పర్ సే ఈ స్ట్రింగ్ కాదు, కానీ ఈ విషయంలో ఏ నిల్వ చేయబడిన ఉంది
GetString నిజానికి ఏమి చేస్తుంది ఎందుకంటే సంఖ్య 0
అది భౌతికంగా ఒక స్ట్రింగ్ తిరిగి లేదు.
కూడా నిజంగా సంభావిత సమంజసం అనిపించుకోదు.
అది తిరిగి అనేక ఏమి చేస్తుంది.
ఆ సంఖ్యను, మెమరీ లో హలో చిరునామా
మరియు స్ట్రింగ్ s తర్వాత, మేము తిరిగి చర్మము ఈ పొర, స్ట్రింగ్ నిజంగా లేకపోతే.
ఇది మాత్రమే CS50 లైబ్రరీలో సాధారణంగా ఉంది.
>> ఇది నిజంగా చార్ * అని ఏదో ఉంది.
ఏ HELLO వంటి పదం ఎందుకంటే చార్ అర్ధమే?
సరే, అక్షరాలు వరుస, అక్షరాలు ఒక సిరీస్ ఉంది.
చార్ *, ఒక పాత్ర యొక్క చిరునామా అర్థం
సో వాట్ ఒక స్ట్రింగ్ తిరిగి శతకము
ఒక స్ట్రింగ్ తిరిగి ఒక మంచి, సులభమైన మార్గం
ఉంది కాకుండా నేను 5 లేదా 6 వివిధ బైట్లు తిరిగి ఎలా గుర్తించడానికి ప్రయత్నించండి
నాకు ఇది బైట్ యొక్క చిరునామా తిరిగి తెలియజేయండి?
మొదటి ఒకటి.
ఇతర మాటలలో, నాకు మీరు మెమరీ ఒక పాత్ర యొక్క చిరునామా కల్పించడానికి అనుమతిస్తాయి.
ఆ, చార్ * సూచిస్తుంది ఏమి మెమోరీలో ఏక పాత్ర యొక్క చిరునామా ఉంది.
ఆ వేరియబుల్ s కాల్.
నేను ఏకపక్ష చెప్పాడు ఖచ్చితమైన చిరునామా, 0 అని s లో స్టోర్,
కేవలం విషయాలు సాధారణ ఉంచడానికి, కానీ నిజానికి అది సాధారణంగా ఒక పెద్ద సంఖ్య ఉంది.
>> ఒక నిమిషం ఆగండి.
మీరు మాత్రమే నా మొదటి పాత్ర యొక్క చిరునామా ఇచ్చి ఉంటే, నేను చిరునామా ఏమిటి తెలుసు
రెండవ పాత్ర, మూడవ, నాలుగవ మరియు ఐదవ?
[వినబడని-విద్యార్థి]
స్ట్రింగ్ ముగింపు ఈ సులభ ట్రిక్ ద్వారా ఉన్న మీరు, తెలిసిన
కాబట్టి మీరు వంటి printf ఏదో ఉపయోగిస్తున్నప్పుడు, ఏ printf వాచ్యంగా, దాని వాదన తీసుకుని
మేము ఈ% s ప్లేస్హోల్డర్ ఉపయోగించే గుర్తు, తరువాత మీరు పాస్
ఒక స్ట్రింగ్ నిల్వ చేసే వేరియబుల్.
ఏం మీరు నిజంగా ప్రయాణిస్తున్న చేస్తున్న స్ట్రింగ్ మొదటి అక్షరం యొక్క చిరునామా.
Printf తర్వాత, ఆ చిరునామా అందుకున్న తర్వాత లూప్ లేదా కొంత లూప్ ఒక ఉపయోగిస్తుంది
ఉదాహరణకు, 0, కనుక, నాకు ఇప్పుడు మనం
printf ("% s \ n" s);
నేను కాల్ చేసినప్పుడు printf ("% s \ n" s); నేను నిజంగా తో printf అందించే వెబ్
ఈ ఏకపక్ష కేసులో H. ఇది s లో మొదటి అక్షరం యొక్క చిరునామా, ఉంది
>> ఎలా printf తెరపై ప్రదర్శించడానికి సరిగ్గా ఏం తెలుసు?
అమలు వ్యక్తి printf లూప్ కొంత లూప్ లేదా ఒక అమలు
ఈ పాత్ర ప్రత్యేక శూన్య పాత్ర సమానంగా లేదు చెప్పారు?
లేకపోతే, ప్రింట్. ఎలా ఈ గురించి?
ప్రింట్ లేకపోతే, ప్రింట్ ప్రింట్, ప్రింట్.
ఓహ్, ఈ ఒక ప్రత్యేక ఉంది. ముద్రణ ఆపు మరియు వినియోగదారు తిరిగి.
మరియు ఆ, సాహిత్యపరంగా హుడ్ కింద జరుగుతున్న అయిన అంతే
మరియు ఆ, ఒక తరగతి యొక్క మొదటి రోజు జీర్ణమై పలు అంశాలు
కానీ ఇప్పుడు ఇది నిజంగా అవగాహన ప్రతిదీ యొక్క భవనం బ్లాక్
ఆ, మా కంప్యూటర్ యొక్క మెమరీ లోపల జరుగుతున్నాయి యొక్క
చివరకు మేము ఒక చిన్న సహాయం తో ఈ వేరుగా బాధించటం చేస్తాము
స్టాన్ఫోర్డ్ వద్ద మా ఫ్రెండ్స్ నుండి.
>> స్టాన్ఫోర్డ్ వద్ద ప్రొఫెసర్ నిక్ Parlante ఈ అద్భుతమైన వీడియో క్రమాన్ని చేశారు
పరిచయం వివిధ భాషల అన్ని రకాల నుండి
ఈ చిన్న స్ ఎ క్లెమేషన్ పాత్ర Binky.
మీరు కేవలం కొన్ని రెండవ స్నీక్ ప్రివ్యూ లో వినడానికి చేయబోతున్నారు వాయిస్
ఒక స్టాన్ఫోర్డ్ ప్రొఫెసర్ ఆ ఉంటుంది మరియు చేస్తున్నారు
ఈ హక్కు కేవలం 5 లేదా 6 సెకన్లు ఇప్పుడు,
కానీ ఈ రోజు మేము ముగించారు చేస్తాము ఏ గమనిక ఉంది
మరియు బుధవారం ప్రారంభమవుతుంది.
నేను మీరు Binky, ప్రివ్యూ తో పాయింటర్ ఫన్ ఇస్తాయి.
[♪ ♪ సంగీతం] [ప్రొఫెసర్ Parlante] హేయ్, Binky.
నిద్రలేపే. ఇది పాయింటర్ వినోదం కోసం సమయం.
[Binky] ఆ ఏమిటి? గమనికలు గురించి తెలుసుకోండి?
ఓహ్, GOODY!
>> మేము బుధవారం మీరు చూస్తారు.
[CS50.TV]