>> [సంగీతాన్ని]
డేవిడ్ J. మలన్: అన్ని కుడి.
ఈ CS50, మరియు ఈ వీక్ నాలుగు ముగింపు.
మరియు విషయాలు ఒకటి నేడు డిజిటల్ ఫోరెన్సిక్స్, ఉంది
సమాచారం కోలుకుంటున్నారు కళ.
నిజానికి, అయినప్పటికీ మీరు మధ్యలో ఉన్నాము
ప్రస్తుతం శాంతి మూడు వద్ద మరియు బ్రేక్అవుట్, వచ్చే వారం,
దృష్టి ఉంటుంది ఖచ్చితంగా ఈ డొమైన్.
>> చక్కని ఉద్యోగాలు సో నేను ఎప్పుడూ చేసిన ఒక వచ్చింది, తిరిగి గ్రాడ్యుయేట్ పాఠశాలలో
నేను స్థానిక పనిచేస్తున్నారు ఉన్నప్పుడు మిడిల్సెక్స్ కౌంటీ జిల్లా అటార్నీ
ఆఫీసు, చేస్తున్న ఫోరెన్సిక్స్ పని.
కాబట్టి ముఖ్యంగా, మసాచుసెట్స్ రాష్ట్ర పోలీసులు, సందర్భంగా,
కేసులపై పనిచేసేటప్పుడు చేస్తాను హార్డ్ డ్రైవ్లు వంటి విషయాల తీసుకుని
మరియు ఫ్లాపీ డిస్క్ మెమరీ కార్డులు మరియు ఇష్టపడుతున్నారు.
మరియు వారు వాటిని అప్పగిస్తాం అని నాకు మరియు నా గురువు,
మరియు మా లక్ష్యం సాక్ష్యం కనుగొనేందుకు ఉంది ఈ మీడియా మీద ఏ, ఉంది ఉంటే.
ఇప్పుడు, మీరు చూసిన ఉండవచ్చు గ్లింప్సెస్ ఫోరెన్సిక్స్ ఈ ప్రపంచంలోని
మీడియా, TV మరియు సినిమాలు.
కానీ ఉద్యోగం నేను కలిగి, మరియు విశ్వసించుటకు సిద్ధంగానుండు ప్రపంచానికి
మీరు చూడగలం వంటి చాలా కాదు.
యొక్క పరిశీలించి లెట్ ఏమి మీరు బహుశా చూసిన చేసిన.
[వీడియో ప్లేబ్యాక్]
-OK.
ఇప్పుడు, మీరు ఒక మంచి లుక్ పొందుటకు వీలు.
>> [సంగీతాన్ని]
>> ఇది -Hold.
ఆ వెనుక అమలు.
>> ఒక నిమిషం -Wait.
కుడి వెళ్ళండి.
-There.
ఆ ఫ్రీజ్.
BREAK -సంపూర్ణ స్క్రీన్.
>> -OK.
ఆ ఫ్రీజ్.
మీరు, ఆ పై అప్ -Tighten?
>> ఆ లో -Vector తిరిగి వీల్ ద్వారా గై.
>> ఇక్కడే ఈ స్పాట్ లో -Zoom.
>> కుడి పరికరాలు ఉంటుది-, చిత్రం విస్తరించి పదును చేయవచ్చు.
>> ఆ -What వార్తలు?
>> -ఇది ఒక వృద్ది కార్యక్రమం.
>> ఆ అప్ ఏ స్పష్టమైన మీరు -Can?
>> -I తెలియదు.
యొక్క పెంచడానికి లెట్.
>> -Enhance విభాగం A6.
నేను వివరాలు మెరుగైన, మీరే
-I విస్తరించేందుకు తగినంత ఉందని నేను అనుకుంటున్నాను.
నా స్క్రీన్ దానిని విడుదల.
>> -I ఆమె కంటిలో ప్రతిబింబం విస్తరించింది.
-Let ద్వారా ఈ అమలు వీడియో మెరుగుదల.
>> -ఎడ్గార్, మీరు ఈ విస్తరించేందుకు చేయవచ్చు?
>> న -Hang.
>> ఈ తెలివితో పని -I've.
>> -ఉంది ఒకరి ప్రతిబింబం.
>> -Reflection.
మనిషి ముఖం యొక్క ప్రతిబింబం-ఉంది.
>> -ఫిల్టర్లు ప్రతిబింబం!
ప్రతిబింబం-ఉంది.
అద్దం లో -Zoom.
మీరు ఒక పరావర్తనం చూడగలరు.
>> మీరు ఇక్కడ నుండి చిత్రం విస్తరించేందుకు -Can?
మీరు విస్తరించేందుకు -Can?
మేము ఈ విస్తరించేందుకు -Can?
మీరు విస్తరించేందుకు -Can?
రెండవ -Hold.
నేను విస్తరించేందుకు చేస్తాము.
తలుపు లో -Zoom.
10 -Times.
-Zoom.
లో -Move.
యంత్రాలు ఎక్కువగా.
-Wait, ఆపడానికి.
-Stop.
ఇది -Pause.
మాకు 75 డిగ్రీల -Rotate నిలువు చుట్టూ దయచేసి.
>> -Stop.
భాగం తిరిగి వెళ్ళు తలుపు గురించి మళ్ళీ.
>> బిట్మ్యాప్ ఒక చిత్రం పెంచే -Got?
>> మేము ప్రదీప్ సింగ్ ఉపయోగించవచ్చు -Maybe పద్ధతి Windows లోకి చూడటానికి.
>> -ఫిల్టర్లు సాఫ్ట్వేర్ కళ యొక్క రాష్ట్రం.
>> -ఫిల్టర్లు Eigenvalue ఆఫ్ ఉంది.
>> కుడి ఉంటుది- అల్గోరిథంలు యొక్క కలయిక
>> -He యొక్క తీసుకున్న ప్రకాశం తదుపరి స్థాయికి క్రమసూత్ర
మరియు నేను వాటిని ఉపయోగించవచ్చు ఈ ఛాయాచిత్రం మెరుగుపరచండి.
>> న -Lock మరియు z అక్షం వచ్చేలా.
>> -Enhance.
పెంచు.
-Enhance.
-Freeze మరియు మెరుగుపరచడానికి.
[END వీడియో ప్లేబ్యాక్]
డేవిడ్ J. మలన్: సో ఉంటాయి అన్ని పదాలు, కానీ వారు కాదు
సరిగ్గా వాక్యాలను ఉపయోగించారు.
నిజానికి భవిష్యత్తులో, ఏ సమయంలో, మీరు ఎవరైనా పదం చెప్పే వినడానికి దయచేసి,
కేవలం కొద్దిగా లోలోపల నవ్వుకొను ", విస్తరించేందుకు".
మీరు విస్తరించేందుకు ప్రయత్నించండి చేసినప్పుడు, ఉదాహరణకు, ఈ ఏమి జరుగుతుందో ఉంది.
>> కాబట్టి ఇక్కడ ఒక అందమైన ఫోటో.
ఈ CS50 యొక్క సొంత Daven ఉంది.
మరియు మేము కోరుకున్నాడు అనుకుందాం తన కంటి లో ట్వింకిల్ కేంద్రీకరించండి,
లేదా ప్రతిబింబం స్పష్టంగా అని చెడ్డ వ్యక్తి
భద్రతా కెమెరా ద్వారా స్వాధీనం.
ఈ ఏమవుతుందో ఉంది మీరు ఒక చిత్రం లో జూమ్
కేవలం పరిమిత సంఖ్యలో ఉన్నాయి ఇది సంబంధం బిట్స్.
>> మీరు పొందుతారు ఏమిటి.
నిజానికి, Daven యొక్క కన్ను బహుశా, ఆరు పిక్సెళ్ళు కానీ నాలుగు
ఆ వేటి కంపోజ్ అక్కడ మిణుకు జరిగినది.
కాబట్టి సమస్య సెట్ నాలుగు చివరికి ఉంటుంది మీరు ముఖ్యంగా, ఈ ప్రపంచాన్ని అన్వేషించండి
ఏదో స్వభావం ద్వారా మేము ఫైలు I / O, ఇక్కడ కాల్
I / O ఒక ఫాన్సీ మార్గం ఇన్పుట్ మరియు అవుట్పుట్ మాట్లాడుతూ.
>> కాబట్టి ఇప్పటివరకు, పరస్పర అన్ని మనం కంప్యూటర్ కలిగింది
ఎక్కువగా ఉన్నాయి మీ కీబోర్డు మరియు స్క్రీన్,
కానీ హార్డ్ డిస్క్ తో ఎక్కువ, లేదా వాటిని దాటి ఫైళ్ళను సేవ్ మీరు
మీరే వ్రాయండి.
మీ కార్యక్రమాలు ఇప్పటివరకు కలిగి కాదు, సృష్టించడంలో, మరియు సేవ్ చేయబడింది
మరియు వారి స్వంత ఫైళ్ళను నవీకరించుటకు.
>> Well, ఒక ఫైల్ ఏది?
వెల్, ఒక JPEG వంటి ఏదో.
ఈ మీరు వాటిని ఒక చిత్రం ఉంది లేదా Facebook కు అప్లోడ్
లేదా ఎక్కడైనా వెబ్లో చూడండి.
నిజానికి, ఆ ఫోటో కేవలం Daven చూసిన ఒక JPEG ఉంది.
మరియు ఏ ఆసక్తికరమైన వార్తలు JPEGs ఇలా ఫైళ్ళ గురించి
వారు గుర్తించారు సాధ్యం చేసే ఉంది, సాధారణంగా, బిట్స్ నిర్దిష్ట నమూనాలు ద్వారా.
>> ఇతర మాటలలో, అది ఏమిటి ఒక GIF నుండి ఒక JPEG వేరుచేస్తుంది
ఒక పదం నుండి పింగ్ నుండి Excel ఫైల్ నుండి పత్ర?
సరే, కేవలం విభిన్నమైనది బిట్స్ క్రమాలు.
మరియు ఆ వివిధ నమూనాలు ఉన్నాయి సాధారణంగా ఆ ఫైళ్ళను ప్రారంభంలో.
>> మీ కంప్యూటర్లో ఒక పద తెరిచినప్పుడు కాబట్టి డిఓసి, లేదా ఒక కంప్యూటర్ ఒక JPEG తెరిచినప్పుడు,
ఇది సాధారణంగా కనిపిస్తుంది ఫైలు లో మొదటి అనేక బిట్స్.
మరియు అది ఒక నమూనా గుర్తిస్తుంది ఉంటే, ఇది ఓహ్, ఈ ఒక చిత్రం, చెప్పారు.
నాకు అది ప్రదర్శించడానికి లెట్ ఒక గ్రాఫిక్ యూజర్.
లేదా, OH, ఈ ఒక పద డిఓసి కనిపిస్తోంది.
నాకు ఒక వ్యాసంలో యూజర్ దానిని చూపించడానికి లెట్.
>> కాబట్టి ఉదాహరణకు, JPEGs, అది ఉంటాయి మారుతుంది
చాలా క్లిష్టమైన హుడ్ కింద.
కానీ చాలా ప్రతి ముగ్గురిలో బైట్లు JPEG ఈ మూడు సంఖ్యలు ప్రారంభం.
కాబట్టి బైట్ సున్నా, ఒకటి, మరియు రెండు ఉన్నాయి అత్యంత ప్రతి JPEG, 255, అప్పుడు సంఖ్య
216, అప్పుడు సంఖ్య 255.
>> మరియు మీరు చేయగలరు దానికి వచ్చే వారం చేయడం మొదలు
నిజానికి కింద poking ఉంది JPEGs ఇలా ఫైళ్లు హుడ్
మరియు బిట్మ్యాప్ ఫైళ్లు వంటి, మరియు చూసిన ఏ ఎల్లప్పుడూ కాలం కోసం ఉన్నాయి
మీరు ఒక కంప్యూటర్ ను ఉపయోగించి పరిష్కరించగలుగుతున్నాము.
>> కానీ సాధారణంగా లేదు ఏమిటి ఈ వంటి దశాంశ సంఖ్యలు వంటి వ్రాసిన.
కంప్యూటర్ శాస్త్రవేత్తలు లేదు దశాంశ లో మాట్లాడటం ఉంటాయి.
వారు నిజంగా బైనరీ లో మాట్లాడడం లేదు.
సాధారణంగా, మేము కావలసిన సంఖ్యలు వ్యక్తీకరించడానికి,
మేము నిజంగా హెక్సాడెసిమల్ ఉపయోగించడానికి, ఇది మీరు రీకాల్ చేయవచ్చు
సమస్య సెట్, సే, నుండి ఎయిమ్స్ ఒకటి,
మీరు వేరే వ్యవస్థ గురించి ఆలోచించాలి.
>> మేము, కోర్సు యొక్క, తెలిసిన తొమ్మిది ద్వారా దశాంశ, సున్నా.
మేము బైనరీ గురించి మాట్లాడారు.
మరియు మేము నిజంగా లేని ఇక్కడ చాలా ఉపయోగించడానికి
అవుట్, కంప్యూటర్లు ఆ ఉపయోగిస్తుంది ఎందుకంటే.
కానీ ప్రోగ్రామర్లు చాలా రెడీ తరచుగా, కానీ ఎల్లప్పుడూ,
కేవలం అంటే, హెక్సాడెసిమల్ ఉపయోగించడానికి మీరు మీ వర్ణమాలలో 16 అక్షరాలు కలిగి
రెండు లేదా 10 వ్యతిరేకించారు.
>> సో ఎలా మీరు అధిక లెక్కింపు లేదు హెక్సాడెసిమల్ లో తొమ్మిది కంటే?
మీరు వెళ్ళి 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, ఒక కేవలం కన్వెన్షన్ ద్వారా C, D, E, F, బి.
కానీ ఏ కీ ఉంది అని ప్రతి ఈ ఒకే గుర్తు.
ఏ 10 ఉంది.
ప్రతి ఎందుకంటే, ఏ 11, కేవలంగా ఉంది మీ అంకెలు యొక్క, దశాంశ లో ఇష్టం
కేవలం బైనరీ లో మరియు, కేవలం తప్పక సాంప్రదాయకంగా ఒకే ఒక పాత్ర ఉంటుంది.
>> తర్వాత మేము వర్ణమాల కాబట్టి ఆ హెక్సాడెసిమల్ కోసం మా పారవేయడం వద్ద.
కాబట్టి ఒక JPEG మీరు ఉంటే వంటి లుక్ వాట్ లేదు ఆ మొదటి మూడు రాయడానికి ఉన్నాయి
దశాంశ కాదు బైట్లు కానీ ఉదాహరణకు, హెక్సాడెసిమల్ వంటి?
ఎందుకు హెక్స్ ఉపయోగకరమైన కూడా ఇంతేనా?
>> Well, ఒక ఉదాహరణ శీఘ్ర లుక్.
నేను బిట్స్ వ్రాయండి చేస్తే ఈ దశాంశ numbers-- ప్రాతినిధ్యం
ఈ కొద్దిగా రస్టీ కావచ్చు ఇప్పుడు తిరిగి కొన్ని వారాల నుండి,
ఒక్క మరియు కానీ కుడి ఒకటి అందంగా సులభం.
255 అత్యధిక సంఖ్యలో మేము ఉన్నది ఎనిమిది బిట్స్ తో ప్రాతినిధ్యం వహిస్తుంది.
ఇది అన్ని వాటిని ఉంది.
కాబట్టి స్వల్పంగా అని మాత్రమే ఒకటి ఆసక్తికరమైన మధ్యలో ఒకటి.
మరియు మీరు రకమైన అవుట్ లేకపోతే గణిత, మీరు, నిజానికి, నిరూపించు చేస్తుంది
ఒక నమూనా మరియు సున్నాలు 216 సూచిస్తుంది.
కాబట్టి యొక్క కేవలం నిబంధనలు తెలియజేయండి ఇప్పుడు ఈ సరైనవని.
కానీ ఎందుకు ఈ ఆసక్తికరమైన ఉంది?
>> Well, ఒక బైట్, కోర్సు యొక్క, ఎనిమిది బిట్స్ ఉంది.
మరియు మీరు అనుకుంటే ఆ అవుతుంది నాలుగు బిట్స్ రెండు భాగాలుగా ఒక బైట్ యొక్క,
దీనిని ఇష్టపడుతున్నారు.
నాకు కొన్ని ఖాళీ జోడించడానికి లెట్.
కాబట్టి ముందు, తర్వాత.
నేను కేవలం కొన్ని వైట్ స్పేస్ జోడించిన ఇక్కడ విజువలైజేషన్ కోసమని.
ఎలా మేము ఇప్పుడే ప్రతిఫలించే, సే, హెక్సాడెసిమల్ బిట్స్ ప్రతి క్వాడ్,
నాలుగు బిట్స్ ప్రతి సమితి?
>> ఉదాహరణకు, ఎడమ కాబట్టి ఇప్పుడు మేము బైనరీ లో 1111 చేశారు.
దశాంశ లో ఆ సంఖ్యను ఏమిటి, మీరు గణిత అవుట్ లేకపోతే?
మీరు వాటిని స్థలం కలిగి, పరుగులు తీయడం స్థానంలో, ఫోర్లు స్థానంలో, మరియు ఎయిట్స్కి స్థానంలో.
>> ప్రేక్షకులు: 15.
డేవిడ్ J. మలన్: ఇది 15 ఉంది.
కాబట్టి మేము ఎనిమిది ప్లస్ నాలుగు లేకపోతే ప్లస్ రెండు ప్లస్ ఒకటి, మేము 15 పొందండి.
నేను క్రింద 15 వ్రాసి కాలేదు 1111, కానీ ఇక్కడ మొత్తం పాయింట్
హెక్సాడెసిమల్ దశాంశ కాదు.
కాబట్టి బదులుగా లిఖించడానికి 15, 1-5, నేను, హెక్స్ లో రాయడానికి వెళుతున్న
మీరు కలిగి ఉంటే మీరు తిరిగి అనుకుంటే ఇది F ద్వారా సున్నా, ఏమి 15 అవతరిస్తుంది?
ప్రేక్షకులు: ఎఫ్.
డేవిడ్ J. మలన్: సో అది యొక్క F అవుతుంది.
మరియు మీరు చెప్పి పని చేయవచ్చు, ఒక 10 ఉంటే బాగా, అప్పుడు సరే, F 15.
కాబట్టి నిజంగా, మేము తిరిగి అని F F వంటి సంఖ్యల ఈ అదే సెట్.
మరియు తర్వాత మేము గణిత ఒక బిట్ లేకపోతే, మేము ఆ d యొక్క నిరూపించు చేస్తాము.
ఎనిమిది, అందంగా సులభం మేము ఎందుకంటే ఎయిట్స్కి స్థానంలో ఒక ఒకటి.
ఆపై, మేము F F యొక్క ఒక జంట ఎక్కువ.
>> సో వాట్ మానవులు కన్వెన్షన్ ద్వారా చేసుకొంటాయి వారు ఉపయోగించడానికి ఉన్నప్పుడు హెక్సాడెసిమల్ వారు కేవలం ఉంది
మరింత క్లుప్తమైన ఈ కొద్దిగా వ్రాయండి, ఆ తెల్లని స్థలం అత్యంత వదిలించుకోవటం.
మరియు కేవలం సూపర్ స్పష్టమైన ఉండాలి ఈ హెక్సాడెసిమల్ పాఠకులకు,
మధ్య సాధారణ సమావేశం మానవులలో సున్నా వ్రాయడానికి ఉంది
ఇతర ఏ అర్థాన్ని కలిగి X, ఒక దృశ్య నిర్ధారిణి కంటే,
ఇక్కడ ఒక hex సంఖ్య వస్తుంది.
>> ఆపై, మీరు F రెండు అంకెలు చాలు ఈ సందర్భంలో F, అప్పుడు D ఒక, f ఎఫ్.
సో లాంగ్ కథ చిన్న, హెక్సాడెసిమల్ కేవలం ఉంటుంది
ఉపయోగకరంగా ప్రతి ఎందుకంటే దాని అంకెలు, F ద్వారా సున్నా, సంపూర్ణ పంక్తులు
నాలుగు బిట్స్ నమూనా.
>> మీరు రెండు హెక్సాడెసిమల్ సంఖ్యలను కలిగి ఉంటే కాబట్టి, సున్నా మళ్లీ మళ్లీ F ద్వారా,
ఆ సంపూర్ణ మీరు ఇస్తుంది ఎనిమిది బిట్స్ లేదా ఒక బైట్.
ఇది ఉంటుంది ఎందుకు అలా ఆ సంప్రదాయకంగా ఉపయోగకరంగా ఉంటుంది.
ఏ మేధో ఉంది నిజంగా ఆ మించి కంటెంట్,
దాని అసలు వినియోగ కంటే ఇతర.
>> ఇప్పుడు JPEGs మాత్రమే కాదు గ్రాఫిక్స్ ఫార్మాట్లలో దాఖలు.
మీరు ఉన్నాయి గుర్తుచేసుకున్నారు ఉండవచ్చు ప్రపంచంలో ఈ వంటి ఫైళ్ళ,
కనీసం తిరిగి కొన్ని సంవత్సరాల నుండి.
>> కాబట్టి ఈ వాస్తవానికి ఉంది విండోస్ XP లో ఇన్స్టాల్
ప్రపంచవ్యాప్తంగా PC లు మిలియన్ల.
మరియు ఈ ఒక బిట్మ్యాప్ BMP, ఉంది.
మరియు ఒక బిట్మ్యాప్ ఫైలు, మీరు తదుపరి చూస్తారు వారం, కేవలం చుక్కలు నమూనా అంటే,
వారు అని పిక్సెళ్ళు, ఒక నిజంగా, బిట్స్ మ్యాప్.
>> సో వాట్ అయితే, ఆసక్తికరమైన వార్తలు, ఈ ఫైల్ ఫార్మాట్, BMP గురించి ఉంది
హుడ్ కింద, అది కేవలం మూడు బైట్ల కంటే ఎక్కువ ఉంది
కాబట్టి, దాని శీర్షిక కంపోజ్ మొదటి కొన్ని గాట్లు మాట్లాడటం.
ఇది నిజానికి ఒక చిన్న కనిపిస్తోంది మొదటి చూపులో సంక్లిష్టంగా.
మరియు మీరు పి సెట్ లో ఈ చూస్తారు.
మరియు ఏదో పొందడానికి ఈ ప్రత్యేక ముగిసింది
కేవలం నిజానికి, కాబట్టి ముఖ్యమైనది కాదు ప్రతి బిట్మ్యాప్ ప్రారంభంలో
ఫైల్, ఒక గ్రాఫికల్ ఫార్మాట్, సంఖ్యల మొత్తం బంచ్ ఉంది.
>> ఇప్పుడు మైక్రోసాఫ్ట్, ఈ ఫార్మాట్ రచయిత,
ఆ కాల్ ఉంటుంది విషయాలు కాదు ints మరియు అక్షరాలు
మరియు తేలియాడుతున్న కానీ పదాలు మరియు D పదాలు మరియు longs మరియు బైట్లు.
కాబట్టి అవి వివిధ రకాల డేటా ఉన్నాము.
వారు వివిధ పేర్లు ఉన్నాము ఇదే కోసం.
కానీ మీరు p సెట్ ఫోర్ లో చూస్తారు.
>> కానీ ఈ చెప్పడానికి మాత్రమే అని ఒక మానవ ఉంటే కొన్ని .BMP ఫైలు డబుల్ క్లిక్ తన
లేదా ఆమె హార్డ్ డ్రైవ్, మరియు ఒక విండో తెరుచుకుంటుంది అతనికి లేదా ఆమె ఆ చిత్రం చూపిస్తున్న అప్,
ఆపరేటింగ్ ఎందుకంటే జరిగింది వ్యవస్థ బహుశా మాత్రమే గమనించి
.BMP ఫైల్ పొడిగింపు ఫైలు పేరు లో,
కానీ నిజానికి ఉందని కొంత బిట్స్ నమూనా కన్వెన్షన్
చాలా ప్రారంభంలో ఆ బిట్మ్యాప్ ఫైలు యొక్క.
>> కానీ ఇప్పుడు దృష్టి తెలియజేయండి ఒక క్లిష్టమైన ఫైలు,
కానీ బదులుగా ఈ వంటి ఏదో.
నేను, gedit ఇక్కడ అనుకుందాం కేవలం ప్రారంభం ఉన్నాయి
అందంగా సులభం ఒక కార్యక్రమం.
నేను కొన్ని టాప్ అప్ ఇచ్చింది పొందారు.
ఇప్పుడు నేను పొందారు # ఉన్నాయి "structs.h" కానీ నేను ఒక క్షణం లో ఆ వచ్చి చేస్తాము.
కానీ ఈ ఇప్పుడు ఉపయోగకరంగా ఉంది.
కాబట్టి ఈ ప్రోగ్రామ్ ఆ అమలు జరగబోతోంది
రిజిస్ట్రార్ యొక్క డేటాబేస్ వంటి.
కనుక విద్యార్థులు డేటాబేస్, మరియు ప్రపంచంలో ప్రతి విద్యార్థి
బహుశా కొన్ని ఒక పేరు మరియు ఒక ఇల్లు ఉంది ఇతర stuff, కానీ మేము సాధారణ ఉంటాం.
ప్రతి విద్యార్థి ఒక పేరు మరియు ఒక ఇల్లు ఉంది.
>> నేను ఒక రాయడానికి కోరుకున్నారు కనుక దీని ప్రయోజనం జీవితంలో కార్యక్రమం
కేవలం నుంచి iterate జరిగినది మూడు మీద సున్నా,
ముగ్గురు విద్యార్థులు అక్కడ ఉంటే హార్వర్డ్ విశ్వవిద్యాలయంలో.
నేను కేవలం GetString ఉపయోగించి పొందడానికి కావలసిన, ప్రతి విద్యార్థి యొక్క పేరు మరియు ఇంటి,
ఆపై కేవలం ఆ ప్రింట్.
>> ఈ విధమైన వీక్ వంటిది వన్ వీక్ రెండు విషయాన్ని ఇప్పుడు,
నేను కేవలం ఒక చోట లూప్ లేదా అలాంటిదే.
మరియు నేను GetString కొన్ని కాల్ అనుకుంటున్నారా సార్లు, మరియు అప్పుడు కొన్ని సార్లు F ​​ప్రింట్.
కాబట్టి నేను అయితే, దీన్ని ఎలా, ఒక పేరు మరియు ఒక ఇల్లు రెండు
ప్రతి విద్యార్థి కోసం పాల్గొంటున్నారు?
>> కాబట్టి నా మొట్టమొదటి ప్రవృత్తి వాటిని ఈ వంటి ఏదో చేయాలని ఉంటుంది.
నేను మొదటి చక్కగా, నాకు ఇవ్వండి అని అనవచ్చు, , పేర్లు తీగలను యొక్క వ్యూహం అంటున్నారు.
నేను ఒక hardcode మూడు ఇక్కడ వద్దు.
నేను అక్కడ ఉంచారు అనుకుంటున్నారు?
కేవలం ఎందుకంటే, విద్యార్థులు సో ఎగువన ప్రకటించింది స్థిరమైన,
నేను hardcode లేదు కేవలం అనేక స్థానాల్లో మూడు.
ఈ విధంగా, నేను, అది ఒకే చోట మార్చవచ్చు మరియు ప్రతిచోటా మార్పు ప్రభావితం చేస్తుంది.
ఆపై, నేను ఏమి ఉండవచ్చు స్ట్రింగ్ STUDENTS హౌసెస్.
>> మరియు ఇప్పుడు, నేను వంటి ఏదో ఉండవచ్చు నేను విద్యార్థులు <;; కోసం (నేను = 0 Int నేను ++.
కాబట్టి నేను వేగంగా టైప్ చేస్తున్నానని, కానీ ఈ ఉంది ఇప్పుడు బహుశా తెలిసిన సింటాక్స్.
>> మరియు ఇప్పుడు, ఈ మరింత ఇటీవలి జరిగినది.
నేను i-th లో చాలు అనుకొంటే విద్యార్థి యొక్క పేరు, నేను దీన్ని భావిస్తున్నాను.
ఆపై, పేర్లు కానీ ఇళ్ళు నేను బ్రాకెట్.
నేను ఈ GetString లేదు, మరియు తెలపండి నాకు తిరిగి వెళ్లి ఈ లైన్ పరిష్కరించడానికి.
అంగీకరిస్తున్నారు?
విభేదిస్తున్నారు?
ఇది చాలా యూజర్ ఫ్రెండ్లీ కాదు.
నేను ఏమి యూజర్ చెప్పారు లేదు.
>> కానీ ఇప్పుడు, నేను కూడా ఉంటే తరువాత, లెట్స్ కావలెను
సే, ఈ విషయాలను ప్రింట్ out-- కాబట్టి TODO తరువాత.
నేను మరింత తో చేయ బోతున్నాను నిస్సందేహంగా ఈ దీన్ని
ఒక సరైన అమలు పేర్లు మరియు ఇళ్ళు, మూడు పొందడానికి
ఒక యూజర్ నుండి ప్రతి యొక్క వాటిలో మొత్తం.
>> కానీ ఈ చాలా మంచి డిజైన్ కుడి కాదు?
ఏం ఒక విద్యార్ధి కాదు కేవలం ఒక పేరు ఉంది ఉంటే మరియు ఒక ఇల్లు, కానీ కూడా ఒక ID సంఖ్య,
మరియు ఒక టెలిఫోన్ సంఖ్య, మరియు ఒక ఇమెయిల్ చిరునామా,
మరియు ఉండవచ్చు ఒక హోమ్ పేజీ మరియు బహుశా ఒక ట్విట్టర్ హ్యాండిల్,
మరియు ఇతర వివరాలు ఏ సంఖ్య ఒక విద్యార్థి లేదా ఒక వ్యక్తి తో సంబంధం,
సాధారణంగా.
మేము చేర్చండి ప్రారంభమవుతుంది ఎలా ఈ కార్యక్రమానికి కార్యాచరణను?
>> Well, నేను వాటిని సరళమైన మార్గం భావిస్తాను , వంటి ఏదో ఒకటి చెప్పాలి వీలు,
ఐడిలు STUDENTS Int.
కాబట్టి నేను అక్కడ వారి ఐడిలను ఉంచవచ్చు.
ఆపై, ఏదో కోసం ఫోన్ నంబర్లు వంటి,
నేను ఎలా ఖచ్చితంగా తెలియదు ఇంకా ఆ సూచిస్తాయి.
కాబట్టి యొక్క ముందుకు మరియు కేవలం కాల్ వీడలేదు ఈ విద్యార్థులు, ట్విట్టర్లతో ఇది
ఒక చిన్న వింత, but-- ఉంది మరియు ఖాళీలను కొంత ఎక్కువ.
>> నేను సమర్థవంతంగా ప్రారంభించారు చేసిన కాపీ మరియు ఇక్కడ అతికించండి.
మరియు ఈ అందంగా పెరుగుతాయి అన్నారు అందంగా త్వరగా అతిపెద్దదైన, కుడి?
ఉన్నాయి ఉంటే అది nice కాదు ప్రపంచంలో ఒక డేటా నిర్మాణం తెలిసిన
ఒక పూర్ణాంకానికి లేదా ఒక స్ట్రింగ్, కానీ ఏదో అధిక స్థాయి, ఒక సంగ్రహణం కాబట్టి
ఒక విద్యార్థి వలె పిలుస్తారు, మాట్లాడటం ఎలా |?
సి అంతర్నిర్మిత తో రాలేదు విద్యార్థులకు కార్యాచరణ,
కాని దాన్ని ఇవ్వాలని కోరారు ఉంటే ఏమి?
>> సరే, నేను వెళుతున్న టర్న్స్ , structs.h ఇక్కడ పిలువబడే ఒక ఫైల్ తెరిచి
మరియు మీరు ఖచ్చితంగా ఆ చేయవచ్చు.
మరియు మేము ఇప్పుడు ఇలా మొదలు చూడాలని.
మరియు P సెట్ మూడు హుడ్ కింద, మీరు ఇప్పటికే ఇప్పుడు ఈ చేయడం చేసిన.
ఒక గ్రా RECT అనేందుకు ఉంది లేదా ప్రోగ్రామింగ్ భాష C. లో ఒక గ్రా ఓవల్
>> స్టాన్ఫోర్డ్ వద్ద చేసారో ఆ అమలు ఇక్కడ ఈ విధానాన్ని ఉపయోగించి డేటా రకాల
వారి స్వంత కొత్త డేటా ప్రకటించారు ఒక కొత్త కీవర్డ్ ఉపయోగించి రకాల
అని struct మరియు మరొక ఒకటి అని typedef.
నిజానికి, అయినప్పటికీ వాక్యనిర్మాణం stuff నుండి కొద్దిగా భిన్నంగా కనిపిస్తోంది
మేము ముందు చూసిన సూత్రం, సూపర్ సులభం.
>> ఈ కేవలం "ఒక రకం నిర్వచించే." అంటే
ఒక చేస్తాడు నిర్మాణం, మరియు ఒక నిర్మాణం
కేవలం ఒక కంటైనర్ వంటి ఉంది బహుళ విషయాల కోసం.
ఆ నిర్మాణం అన్నారు నేమ్ అనే స్ట్రింగ్ కలిగి,
మరియు ఒక స్ట్రింగ్ హౌస్ అని.
మరియు లెట్స్ కేవలం సౌలభ్యం కోసం, కాల్ తెలియజేయండి ఈ మొత్తం డేటా నిర్మాణం విద్యార్థి.
>> కాబట్టి క్షణం మీరు ను సెమికోలన్, మీరు ఇప్పుడు కలిగి
మీ స్వంత డేటా రూపొందించినవారు రకం అని విద్యార్థి
ఇప్పుడు, Int పాటు ఉంటుంది మరియు ఫ్లోట్, మరియు చార్ మరియు స్ట్రింగ్,
మరియు g RECT, మరియు g Oval, మరియు ఏ సంఖ్య ఇతర విషయాలను ప్రజలను తున్నారు.
>> కాబట్టి దీని గురించి ఉపయోగకరమైన ఏమిటి ఇప్పుడు నేను తిరిగి వెళ్లి ఉంటే ఉంటుంది
0 struct మరియు ఈ పూర్తి నేను రాసింది అమలు,
ఇక్కడ ముందుగానే, అన్ని గమనించవచ్చు అనివార్య అవకతవకలు ఆ
నేను జోడించిన సంభవించే ఆరంభమవుతుందని ఫోన్ నంబర్లు మరియు ట్విట్టర్లతో మరియు అన్ని
ఈ ఇతర విషయాలు ఒక విద్యార్థి యొక్క నిర్వచనం,
ఇప్పుడు అది క్లుప్తమైన ముగిస్తుంది లో విద్యార్థులు కేవలం ఒక శ్రేణి వంటి.
>> మరియు ఆ విద్యార్థులు ప్రతి ఇప్పుడు అది లోపలి బహుళ విషయాలు ఉన్నాయి.
కాబట్టి కేవలం ఒక ప్రశ్న వెళ్లిపోతాడు.
ఎలా మీరు పేరు వస్తుందా, మరియు హౌస్, మరియు ID,
మిగిలిన సంసార ఉంది విద్యార్థి యొక్క లోపల?
సూపర్ సాధారణ, అలాగే.
కొత్త సింటాక్సు, కానీ ఒక సాధారణ ఆలోచన.
>> శ్రేణి లోకి మీరు కేవలం ఇండెక్స్, మేము గత వారం మరియు ఈ ఆదరించాడు.
మరియు ఏమి స్పష్టంగా వార్తలు వాక్యనిర్మాణం యొక్క కొత్త భాగాన్ని?
జస్ట్., అంటే "లోపల వెళ్ళి నిర్మాణం మరియు ఫీల్డ్ అని పెట్టడానికి
పేరు, ఇల్లు అనే field పొందండి విద్యార్థి అని రంగంలో పొందండి. "
>> కాబట్టి P సెట్ మూడు, మీరు అయితే ఇప్పటికీ ఆ పని,
ఇప్పటికీ మరియు అత్యంత ఫొల్క్స్ , మీరు ఆ తెలుసుకుంటారు ఉంటాయి
వంటి విషయాలను ఉపయోగించి ప్రారంభం గ్రా rects మరియు g ovals
మరియు ఇతర విషయాలు కనిపించడం లేదు వీక్ సున్నా, ఒకటి, లేదా రెండు నుండి వచ్చి,
ఆ స్టాన్ఫోర్డ్ ఎందుకంటే ఉందని గుర్తించండి కొన్ని కొత్త డేటా రకాల ప్రకటించింది.
>> నిజానికి, ఖచ్చితంగా ఏమి మేము చేస్తాము p సెట్ ఫోర్ లో, అలాగే, చేయండి ఉన్నప్పుడు
మేము విషయాలు వ్యవహరించే ప్రారంభం చిత్రాలు, బిట్ మ్యాప్ చిత్రాలన్నీ, మరియు మరిన్ని.
కాబట్టి ఆ టీజర్ మరియు ఒక వార్తలు వచ్చి ఏమి మానసిక మోడల్.
ఇప్పుడు, నేను procrastinated ఒక బిట్ ఈ ఉదయం.
నేను ఏమి చూడటానికి రకమైన ఆసక్తికరమైన ఉంది మైక్రోసాఫ్ట్ వాల్ నిజానికి
నేడు కనిపిస్తుంది.
మరియు అది 2006 లో ఎవరైనా అవుతుంది నిజానికి దాదాపు ఖచ్చితంగా వెళ్ళింది
అదే స్పాట్ వాస్తవానికి చిత్రీకరించే ఏమి ఈ రోజుల్లో ఆ కనిపిస్తుంది.
రంగంలో ఇప్పుడు ఒక చిన్న కట్టడాలు ఉంది.
>> కాబట్టి చిత్రాల ఇప్పుడు మాట్లాడుతున్న, యొక్క ఇక్కడ Daven బాగు తెలియజేయండి
స్క్రీన్ మరియు నికోలస్ న, మరియు కేవలం మీరు గుర్తు
మీరు భోజనం కోసం మాకు చేరడానికి చెయ్యాలనుకుంటే మన మామూలు URL కు ఈ శుక్రవారం, తల
ఇక్కడ.
>> కాబట్టి అక్కడ సోమవారం ఆఫ్ చెబుతావా?
మేము కుడి, ఈ సమస్య పరిచయం?
ఈ అంతమయినట్లుగా చూపబడతాడు ఒక సరైనదే స్వాప్ అమలు
అనగా మీరు, రెండు ints తీసుకొని ఒకటి, బి అని ఒకటి, ఒక అని
లారా ఇక్కడ చేసినట్టుగానే, వాటిని మార్పిడి పాలు మరియు నీటితో వేదికపై,
ఒక తాత్కాలిక ఉపయోగించి వేరియబుల్, లేదా ఒక ఖాళీ కప్పు,
మేము ఒక మరియు ఒక లో బి ఉంచారు కాలేదు విషయాలు గజిబిజి లేకుండా బి.
మేము ఒక వేరియబుల్ ఉపయోగించారు.
ఇది తాత్కాలిక అని.
>> కానీ ప్రాథమిక ఏమిటి సోమవారం ఈ కోడ్ తో సమస్య?
ఇక్కడ సమస్య ఏమిటి?
అవును.
>> ప్రేక్షకులు: ఇది మరింత స్థలాన్ని పడుతుంది.
>> డేవిడ్ J. మలన్: మరింత అప్ టేక్స్ స్పేస్, నేను ఒక వేరియబుల్ ఉపయోగించి నేను ఎందుకంటే,
మరియు ఆ సరే.
ఆ నిజం, కానీ నేను ఉన్నాను ఆ సరే చెప్పాలి.
ఇది గ్రాండ్ లో మాత్రమే 32 బిట్స్ విషయాలు పథకం, కాబట్టి ఒక పెద్ద ఒప్పందం.
ఇతర ఆలోచనలు?
ప్రేక్షకులు: ఇది మాత్రమే మార్పిడులు స్థానికంగా వేరియబుల్స్.
డేవిడ్ J. మలన్: ఖచ్చితంగా.
ఇది కేవలం స్థానికంగా వేరియబుల్స్ మార్పిడులు.
ఏ సమయంలో మీరు ఒక ఫంక్షన్ కాల్ ఎందుకంటే నేను Annenberg నుండి ట్రేలు ఉన్నప్పుడు
చివరిసారి, మీరు అడుగున ప్రధాన చేశారు.
వెంటనే మీరు అని ఒక ఫంక్షన్ కాల్ వంటి స్వాప్, స్వాప్ x మరియు y లభించక
అసలు విలువలు.
మనం దావా లేదు, స్వాప్ చేయదా?
ప్రేక్షకులు: ప్రతులు.
డేవిడ్ J. మలన్: వాటిలో కాపీలు కాబట్టి.
కాబట్టి మీరు ఉంటే, ఒక మరియు రెండు గెట్స్ చివరిసారి నుండి, ఉదాహరణకు, రీకాల్
కానీ ఒక మరియు రెండు ప్రతిని విజయవంతంగా మార్చుకున్నారు ఉంటాయి.
కానీ దురదృష్టవశాత్తు చివరికి, ఆ విలువలు ఇప్పటికీ ఒకటే.
కాబట్టి మేము ఈ చూడగలరు మా కొత్త స్నేహితుడు, ఆశాజనక, GDB,
మీరు లేదా TFS మరియు Ca యొక్క కలిగి ఈ క్రింది విధంగా వైపు మీరు మార్గదర్శక చేశారు.
>> సో సంఖ్య స్వాప్ రీకాల్ లెట్ యొక్క వంటి కనిపిస్తుంది ఈ వంటి ఉండాలి ఈ లుక్స్ అప్ తెరవండి.
మేము రెండు, ఒకటి y, x initialized.
ముద్రణ F యొక్క బంచ్ కలిగి.
కానీ, కీ కాల్ ఇక్కడ, స్వాప్ ఇది
సరిగ్గా కోడ్ మేము కేవలం ఒక క్షణం క్రితం చూసింది.
ఇది మొదటి వద్ద సరైన ఉంది చూపులో క్రియాశీలంగా
ఈ కార్యక్రమం ఎందుకంటే, పని లేదు అది శాశ్వతంగా x మరియు y రెండు స్వాప్ లేదు.
>> కాబట్టి, ఒక శీఘ్ర వెచ్చని యొక్క చూసేలా ఈ ఇక్కడ GDB, ఒక ./noswap తో.
అధిక సమాచారము సమూహం ఆ నేను ఇప్పుడు కోసం కంట్రోల్ L తో విమోచనం పొందుతారు.
మరియు ఇప్పుడు, నేను వెళుతున్న ముందుకు వెళ్ళడానికి మరియు అమలు.
మరియు దురదృష్టవశాత్తు, ఆ ఆ ఉపయోగకరం కాదు.
ఇది ఈ లోపల కార్యక్రమం నడిచింది కార్యక్రమం, GDB ఒక డీబగ్గర్ అని
కానీ అది నాకు చుట్టూ దూర్చు వీలు లేదు.
>> నేను నిజానికి విరామం చేయవచ్చు ఎలా ఈ కార్యక్రమం లోపల అమలు?
కాబట్టి విడిపోయారు.
నేను ఏ విచ్ఛిన్నం కాలేదు లైన్ నెంబర్, ఒక, 10, 15.
కానీ నేను కూడా ప్రతీకాత్మకంగా విరిగిపోతాయి విరామం ప్రధాన విధంగా.
మరియు ఒక విరామం సెట్ చేస్తాడు పాయింట్, స్పష్టంగా ప్రధాన లైన్ 16 వద్ద.
మరియు ఎక్కడ లైన్ 16?
యొక్క కోడ్ వరకు వెళ్ళి తెలపండి మరియు noswap వరకు వెళ్ళండి.
నిజానికి, లైన్ 16 మొదటి కార్యక్రమం లో.
>> కాబట్టి ఇప్పుడు, నేను ముందుకు వెళ్లి టైప్ ఈ సమయాన్ని అమలు ఎంటర్, ఇది పాజ్.
కాబట్టి యొక్క చుట్టూ దూర్చు తెలియజేయండి.
ఎందుకు X సున్నా x-- ముద్రించు?
మరియు డాలర్ సైన్ పట్టించుకోకండి.
ఆ ఫ్యాన్సియెర్స్ కేవలం వార్తలు కార్యక్రమం వాడుక.
ఎందుకు సమయంలో x సున్నా?
అవును.
>> ప్రేక్షకులు: ఇది కుడి ముందు పాజ్ లైన్ 16, నిజానికి లైన్ 16 న.
డేవిడ్ J. మలన్: ఖచ్చితంగా.
GDB, అప్రమేయంగా, నిలిపివేయబడింది కేవలం లైన్ 16 ముందు మరణశిక్ష.
కాబట్టి అది అమలు చేయలేదు ఇది కొన్ని తెలియని విలువ ఉంది x అంటే.
మరియు మేము అది అదృష్ట వచ్చింది సున్నా వంటి శుభ్రంగా ఏదో.
కాబట్టి ఇప్పుడు నేను తదుపరి టైప్ ఉంటే, ఇప్పుడు అది 16 అమలు.
నాకు 17 అమలు కోసం ఇది వేచి యొక్క.
నాకు ముందుకు ముద్రణ x వెళ్ళి తెలపండి.
ఇది ఒకటి.
నాకు ముందుకు మరియు y ముద్రణ వెళ్ళి తెలపండి.
నేను ఇప్పుడు ఏమి చూస్తారు?
>> ప్రేక్షకులు: [వినబడని]
>> డేవిడ్ J. మలన్: బిగ్గరగా కొద్దిగా.
>> ప్రేక్షకులు: [వినబడని]
డేవిడ్ J. మలన్: కాదు చాలా ఏకాభిప్రాయం.
కాబట్టి అవును, మేము కొన్ని చెత్త విలువ చూడండి.
ఇప్పుడు, Y అక్కడ 134514064 ఉంది.
సరే, కేవలం కొన్ని చెత్త విలువ ఏమిటి.
నా కార్యక్రమం RAM ఉపయోగించే వివిధ ప్రయోజనాల కోసం.
ఇతర విధులు ఉన్నాయి.
ఇతర ప్రజలు నా కంప్యూటర్ లోపల రాశారు.
కాబట్టి ఆ బిట్స్ కోసం ఉపయోగిస్తున్నారు ఇతర విలువలు, నేను ఏమి చూసిన వెబ్
కొన్ని అవశేషాలు ఉంది మెమరీ ముందు ఉపయోగం.
>> అలా ఏ పెద్ద ఒప్పందం, ఎందుకంటే త్వరలో నేను తరువాత టైప్ ఆపై ముద్రణ y వంటి,
అది initialized ఉంది నేను కావలసిన విలువ.
కాబట్టి ఇప్పుడు, యొక్క కొద్దిగా వేగంగా ముందుకు వెళ్ళి తెలపండి.
తరువాతి కోసం ఉ.
మళ్ళీ దాన్ని లెట్.
కానీ నేను హిట్ వద్దు ఇక్కడ అది, ఎందుకంటే నేను ఉంటే
లోపల ఏం జరగబోతోంది చూడాలనుకుంటే స్వాప్, ఆదేశం ఏమిటి?
>> ప్రేక్షకులు: దశలను.
>> డేవిడ్ J. మలన్: దశలను.
కాబట్టి ఈ లోకి నన్ను వేసింది అంతేకానీ పైగా కంటే ఫంక్షన్.
మరియు ఇప్పుడు, ఒక చిన్న గుప్తమైన వార్తలు నిజాయితీగా, కానీ ఈ కేవలం ఉంది
నేను ఇప్పుడు లైన్ 33 లో ఉన్నాను నాకు చెప్పటం.
మరియు మళ్ళీ తెలియజేసేలా.
ప్రింట్ తాత్కాలిక.
చెత్త విలువ, ప్రతికూల ఈ సమయంలో, కానీ కేవలం ఇప్పటికీ ఒక చెత్త విలువ ఏమిటి.
కాబట్టి యొక్క తదుపరి, ముద్రణ టెంప్ తెలియజేసేలా.
ఇది, 1 to initialized ఇందులో ఒక ఆక x యొక్క విలువ ఉంది.
>> ఇప్పుడు, అక్కడ మా ఒక మరియు నుండి వస్తున్న x?
Well, మేము ప్రధాన గమనించవచ్చు ఈ విలువలు x మరియు y అనే.
మేము అప్పుడు వాటిలో స్వాప్ వశమైంది.
ఎక్స్ కామా Y, మొదటి వచ్చింది.
ఆపై, స్వాప్ వాటిని x మరియు y కాల్ కాలేదు.
సరళత కోసం, అది వార్తలు a మరియు b వాటిని కాల్.
కానీ అండ్ బి ఇప్పుడు వెళ్తున్నారు వరుసగా x మరియు y యొక్క కాపీలు.
>> నేను, టెంప్ తిరిగి GDB వెళ్ళండి చేస్తే ఇప్పుడు ఒకటి మరియు ఇప్పుడు ఒకటి.
నేను ఇప్పుడు తదుపరి చేయండి మరియు అయితే ముద్రణ చేయండి ఒక, ఒక గడిచినా తరలించబడింది.
పాలు మాజీ లోకి కురిపించింది చేయబడింది నారింజ రసం యొక్క గాజు, లేదా ఇదే విధంగా విరుద్ధంగా.
>> మరియు నేను ఇప్పుడు మళ్ళీ తరువాతి ఏమి, మరియు ఉంటే నేను ఒక పవిత్రత చెక్ వలె ముద్రించవచ్చు ఉంటే,
ఇప్పటికీ రెండు, కానీ బి ఇప్పుడు ఒకటి.
స్పష్టముగా, అది ఇప్పటికీ ఉంది.
నేను ఏమి తాత్కాలిక పట్టించుకోను.
కానీ వెంటనే నేను ఇప్పుడు టైప్ వంటి, యొక్క అని పిలవబడు ఇప్పుడు నేను చివరిలో ఉన్నాను, తిరిగి వెళ్ళడానికి కొనసాగుతుంది
కార్యక్రమం.
మరియు దురదృష్టవశాత్తు, X ఉంది ఒక మరియు Y ఇప్పటికీ రెండు ఉంది.
>> సో అక్కడ GDB యొక్క వినియోగ ఏమి ఉంది?
ఇది నాకు పరిష్కరించడానికి సహాయం లేదు పర్ సే సమస్య,
కానీ ఆశాజనక నాకు సహాయం తెలుసుకొని ద్వారా అది అర్థం
అవును, నా తర్కం కుడి, కానీ నా కోడ్ చివరికి కలిగి లేదు
శాశ్వత ప్రభావం.
కాబట్టి మేము ఉన్నాము సమస్య ఇప్పుడు నేడు పరిష్కరించడానికి వెళ్తున్నారు.
>> కానీ యొక్క ఈ మార్గం ద్వారా అక్కడ పొందుటకు వీలు.
స్ట్రింగ్ ఒక అబద్ధం ఉంది.
ఇది, చాలా, ఒక డేటా రకం అంతే C. లో ఉంది
కొన్ని పర్యాయపదంగా ఉన్నారు ఏదో కోసం సమయం
మరియు మేము ఈ క్రింది తెలుస్తుంది.
>> నాకు ముందుకు వెళ్లి తెరుచుకుంటుంది లెట్ ఒక కార్యక్రమం పోల్చి-0 అని.
మరియు ఈ ఒక రకం అవుట్ కాకుండా, మేము కోడ్ నడవడానికి మొదలు పెడతారేమో
నేను ఇప్పటికే రాశారు, కానీ ఇది కేవలం కొన్ని పంక్తులు ఉంది.
కాబట్టి ఈ సరిపోల్చండి-0.
మరియు మొదటి విషయం నేను ఏమి చేస్తున్నానో టెక్స్ట్ లోని ఒక లైన్ పెరిగిపోతుంది.
>> కానీ నేను ఉన్నాను గమనిస్తారు మొదటిసారి చేయడం.
ఏం స్పష్టంగా లైన్ 21 గురించి భిన్నంగా ఉంటుంది?
అసలైన, ఒక నిమిషం వేచి.
ఈ కాపీ రెండు ఉంది.
కూడా కుడి కార్యక్రమం కాదు.
అన్ని కుడి, స్పాయిలర్ హెచ్చరిక.
All right, కాబట్టి పర్వాలేదు.
ఒక భవిష్యత్తు ప్రశ్నకు సమాధానం ఉంది.
>> ఇక్కడ-0 పోల్చి, మరియు నేను ఉన్నాను ఉంది టెక్స్ట్ యొక్క ఒక లైన్ పొందడానికి గురించి.
ప్రోగ్రామ్ యొక్క అతి సాధారణ చేస్తుంది.
కాబట్టి ఈ ముక్కుసూటి ఉంది.
ఈ వారం ఒకటి, వీక్ రెండు stuff వంటి ఉంది సమయంలో. స్ట్రింగ్ s = GetString.
ఇప్పుడు, నేను ఇక్కడ డౌన్ మళ్ళీ చెప్పాను.
స్ట్రింగ్ t = GetString.
ఈ ఆపై, చివరి విషయం కార్యక్రమం, దాని పేరు సూచించిన విధంగా,
నేను వాటిని పోల్చడానికి ప్రయత్నించండి వెళుతున్న ఉంది.
>> కాబట్టి s ఉంటే, మొదటి స్ట్రింగ్, = T, అప్పుడు నేను ఉన్నాను సమానం
మీరు అదే విషయం టైప్ చెప్పండి వెళుతున్న.
ఎల్స్, నేను చెప్పడానికి వెళుతున్న మీరు వివిధ విషయాలను టైప్.
కాబట్టి యొక్క ఈ కార్యక్రమం కంపైల్ మరియు అమలు అనుమతిస్తాయి.
కాబట్టి సున్నా పోల్చి తయారు.
బాగుంది.
ఏ సంగ్రహం లోపాలు.
>> నాకు ఇప్పుడు ముందుకు వెళ్ళి తెలపండి మరియు ./compare-0 టైప్ చేయండి.
నాకు ముందుకు వెళ్లి ఏదో చెప్పటానికి లెట్ : Daven మరియు ఏదో: రాబ్.
మరియు నేను వివిధ విషయాలను టైప్.
సో ఫార్, సో గుడ్.
ప్రోగ్రామ్ సరైన ఉంది.
>> కానీ మళ్ళీ దాన్ని అమలు అనుమతిస్తాయి.
ఏదో సే: గాబే.
అన్ని కుడి.
బహుశా నేను స్పేస్ బార్ నొక్కండి లేదా అల్లరిగా ఏదో.
మళ్ళీ దాన్ని లెట్.
Zamyla కాబట్టి.
Zamyla.
వివిధ విషయాలు.
కాబట్టి ఏం జరుగుతుందో?
>> కాబట్టి మేము ఈ రెండు పంక్తులు కలిగి కోడ్ GetString, రెండుసార్లు అని పిలిచారు.
ఆపై, నేను కేవలం ఉన్నాను s మరియు t పోల్చడానికి ప్రయత్నిస్తున్న.
కానీ జరుగుతుందో అప్పుడు నిజంగా ఏమి?
బాగా, నా చేతిరాత గురించి కొంతవరకు ఈ ఉదాహరణ బుట్చేర్.
మరియు వాస్తవానికి త్రో అనుమతిస్తాయి ఈ అప్ ఇక్కడ పైగా, అలాగే.
>> కాబట్టి మేము ఒక లైన్ వలె కలిగి స్ట్రింగ్ s = GetString.
కాబట్టి ఆ కేవలం మొదటి వార్తలు ఆ కార్యక్రమం నుంచి ఆసక్తికరమైన లైన్.
కానీ ఈ సమయంలో ఉంది ఏమి హుడ్ కింద జరగబోతోంది?
వెల్, ఎడమ వైపు వైపు తీగ ఉంది ఇది వేరియబుల్ కొన్ని రకం,
మరియు అది యొక్క అని.
కాబట్టి నేను ఈ మెమరీ ఉపయోగించి తెలుసు, లేదా RAM, ఏదో నా కంప్యూటర్ లో.
నేను బొత్తిగా వెళుతున్న ఒక చదరపు వంటి డ్రా.
32 బిట్స్, ఇది అవుతుంది, కానీ భవిష్యత్తులో ఆ మరింత.
ఆపై, ఏమి ఇక్కడ పైగా జరగబోతోంది?
>> సరే, స్పష్టంగా GetString వినియోగదారు నుండి ఒక స్ట్రింగ్ పొందుతాడు.
మరియు GetString వచ్చింది Zamyla లేదా గాబే లేదా Daven.
కాబట్టి యొక్క మొదటి ఎంపిక తెలియజేయండి వారిలో, Daven ఇది.
అది ప్రభావవంతంగా, ఏమి GetString వచ్చింది నాకు ఆ మొదటి సందర్భంలో D-a-V-E-N జరిగినది.
ఆపై, ఏమి చేసాడు అది నాకు రహస్యంగా ఇవ్వాలని?
ప్రేక్షకులు: [వినబడని]
డేవిడ్ J. మలన్: అవును, / 0 లేదా శూన్య పాత్ర.
కనుక ఇది సమర్థవంతంగా నాకు ఒక స్ట్రింగ్ ఇచ్చారు.
కానీ మేము ఇప్పటికే మునుపటి నుండి తెలుసు ఒక స్ట్రింగ్ కేవలం ఒక శ్రేణి కనిపిస్తోంది
అక్షరాలు, మరియు అది ద్వారా రద్దు యొక్క ఈ ప్రత్యేక కాపలాదారుడు పాత్ర, / 0.
>> కానీ ఈ నిజమైన ఉంటే మరియు ఈ ఒక కూడలి,
ఈ స్పష్టంగా చాలా పెద్ద దీర్ఘచతురస్రం ఉంది.
నిజానికి, ఈ, నేను మాత్రమే 32 బిట్స్ పేర్కొంటున్నాయి.
మరియు ఈ స్పష్టంగా కంటే ఎక్కువ 32 బిట్స్, ఈ బహుశా ఎందుకంటే
ఎనిమిది ప్లస్ ఎనిమిది ప్లస్ ఎనిమిది ప్లస్ ఎనిమిది ప్లస్ ఎనిమిది,
కేవలం ASCII లో బైట్లు ఎందుకంటే.
ఎలా హెక్ మేము సరిపోయే వెళ్తున్నారు ఇక్కడ ఈ చిన్న పెట్టెలో Daven?
>> Well, వాస్తవానికి చేయడం GetString ఉంది?
Well, ఈ గ్రిడ్ ఇక్కడ సూచిస్తుంది నా కంప్యూటర్ యొక్క మెమరీ లేదా RAM.
కాబట్టి యొక్క ఏకపక్ష ఉంటే అని పిలవబడు ఈ యొక్క ప్రతి ఒక బైట్ సూచిస్తుంది
అప్పుడు మేము ప్రతి ఆలోచించవచ్చు బైట్ ఒక చిరునామా కలిగి,
33 ఆక్స్ఫోర్డ్ స్ట్రీట్, లేదా 34 వలె ఆక్స్ఫోర్డ్ స్ట్రీట్, లేదా 35 ఆక్స్ఫోర్డ్ స్ట్రీట్.
>> కాబట్టి గృహాలు చిరునామాలను కలిగి వలె మరియు భవనాలు చిరునామాలను కలిగి,
కాబట్టి వ్యక్తిగత బైట్లు చేయండి మెమరీ చిరునామాలు లేదా సంఖ్యలు కలిగి
ఆ ప్రత్యేకంగా వాటిని గుర్తిస్తాయి.
ఇప్పుడు, ఈ ఏకపక్ష ఉంది.
కానీ నేను వెళుతున్న, అది సాధారణ ఉంచడానికి కేవలం కన్వెన్షన్ ద్వారా హెక్సాడెసిమల్ ఉపయోగించడానికి,
కానీ 0x ఇతర ఏమీ అర్థం కంటే "ఈ హెక్సాడెసిమల్."
మరియు నేను ఆ దావా వెళుతున్న "D" మెమరీలో బైట్ వన్ వద్ద ముగుస్తుంది.
>> నేను వేరే ఏమీ లో జరగబోతోంది వచ్చింది జ్ఞాపకాలు, Daven మొదటి స్పాట్ వచ్చింది
బైట్ ఒక.
ఈ అప్పుడు 0x2 అవతరిస్తుంది.
ఈ 0x3 అన్నారు.
ఈ 0x4 అవతరిస్తుంది.
ఈ 0x5 అన్నారు.
ఈ 0x6 అవతరిస్తుంది.
>> కానీ ఒకసారి మీరు ఆలోచిస్తూ ప్రారంభించండి ఏమి కంప్యూటర్ చేయుచున్నాడు గురించి
హుడ్ కింద, మీరు ప్రతిపాదించే ప్రారంభించవచ్చు
ఎలా మీరు, కొన్ని సంవత్సరాల క్రితం, భవిష్యత్తును కూడా సి అమలు చేశారు.
బహుశా GetString ఏమిటి returning-- అది ఎందుకంటే
అది కాదు అనుకుని తిరిగి Daven, ప్రతి SE,
అతను తప్పనిసరిగా వెళ్ళడం లేదు ఎందుకంటే ఈ చిన్న box-- లో సరిపోయే
కాబట్టి ఏమి GetString బహుశా తిరిగి?
>> ప్రేక్షకులు: [వినబడని]
>> డేవిడ్ J. మలన్: Daven నగర.
మరియు అది ఈ చేస్తోంది ఎప్పుడూ వీక్ వన్ నుండి.
ఏం GetString నిజంగా ఉంది తిరిగి ఒక స్ట్రింగ్, కేవలంగా కాదు.
ఆ చిన్న తెల్ల అసత్యాలు ఒకటి.
ఇది యొక్క చిరునామా తిరిగి మెమరీ స్ట్రింగ్, ఏకైక చిరునామా.
Daven 33 ఆక్స్ఫోర్డ్ స్ట్రీట్ వద్ద నివసిస్తున్నారు.
కానీ మరింత క్లుప్తమైన, గావిన్ నివసిస్తున్నారు 0x1 వద్ద, సంఖ్య ఒక చిరునామా.
>> సో వాట్ ఈ ఉంచే చిన్న బాక్స్ అప్పుడు, స్పష్టంగా ఉండాలి
ఆ స్ట్రింగ్ యొక్క చిరునామా.
కాబట్టి ఈ అన్ని సమయం, ఈ ఉంది జరుగుతున్నాయి.
కానీ ఈ సూచనలను ఇప్పుడు అన్ని ఉంటే కలిగి ఉంది
అది లోపల అనేక, ఎవరు ఉంది మీరు ఆపడానికి, ప్రోగ్రామర్,
లో ఎన్ని ఉంచడం నుండి ఏ వేరియబుల్ మరియు కేవలం జంపింగ్
మెమరీ ఆ భాగం?
నిజానికి, మేము చూస్తారు ఒక బెదిరింపు తదుపరి సమయం.
>> కానీ ఇప్పుడు కోసం, ఈ చాలని అనిపిస్తుంది.
నేను చెప్పేది ఉంటే, నాకు ఒక పొందండి స్ట్రింగ్, మీరు నాకు Daven ఇస్తాయి.
కానీ మీరు నిజంగా నాకు Daven ఇవ్వాలని లేదు.
మీరు నాకు ఇవ్వాలని అన్ని Daven యొక్క చిరునామా.
నేను అప్పుడు ఖచ్చితంగా తెలుసు ఎలా తోబుట్టువుల Daven ప్రారంభమవుతుంది మరియు ends--
కథ యొక్క అసహజ పొందడానికి Daven ప్రారంభమవుతుంది మరియు ముగుస్తుంది,
మరియు, తదుపరి తర్వాత మెమరీ స్ట్రింగ్ మొదలవుతుంది?
>> సరే, మీరు ఇవ్వడానికి చేస్తుంటే నాకు Daven ప్రారంభంలో,
ముఖ్యంగా, ఎలా నేను తెలుసు తన పేరు చివర ఎక్కడ ఉంది?
ప్రత్యేక శూన్య పాత్ర ఇది అన్ని మరింత ముఖ్యమైన ఇప్పుడు
కింద తీగలను ఉంటే హుడ్ కేవలం గుర్తించబడతాయి
ప్రత్యేకం స్మృతిలో వారి నగర ద్వారా.
కాబట్టి అన్ని ఈ సమయంలో, ఆ వార్తలు ఏమి జరుగుతున్నాయి.
>> కాబట్టి మేము ఇప్పుడు చూడండి ఇక్కడ కోడ్ వివరించడానికి
మీరు లైన్ 26 లో బగ్ అని.
ఎందుకు Zamyla మరియు Zamyla భిన్నంగా ఉంటుంది?
ఎందుకు గాబే మరియు గాబే భిన్నంగా ఉంటుంది?
అవును, తిరిగి లో.
>> ప్రేక్షకులు: వారు వివిధ చిరునామాలను కలిగి.
>> డేవిడ్ J. మలన్: కేవలం ఎందుకంటే వారు వివిధ చిరునామాలను కలిగి.
మీరు GetString కాల్ చేసినప్పుడు మళ్ళీ, నేను ఇక్కడ త్వరగా చేస్తాను ఇది,
ఈ రెండవ పంక్తి, స్ట్రింగ్ ఉంటే టి, నేను ఆ ప్రోగ్రాం వచ్చింది,
GetString మరొక కాల్ సమానం.
నేను కాల్ తదుపరి సమయం GetString, నేను వెళుతున్నాను
మెమరీ వేరొక భాగం పొందడానికి.
>> GetString అనుమతి ఆపరేటింగ్ గోవా
మరింత మెమరీ వ్యవస్థ.
ఇది అదే తిరిగి మాత్రం కాదు ఆరు బైట్లు ప్రతి ఒక్క సారి.
ఇది ఒక కొత్త పొందడానికి జరగబోతోంది మెమరీ భాగం, ఇది
T వస్తుందా మాత్రం అర్థం ఇక్కడ పైగా కొన్ని ఇతర విలువ.
>> నేను అలా చేసినప్పుడు లు = సమానం T, మీరు పోల్చడం లేదు
ఈ మరియు ఒక వ్యతిరేకంగా డి ఈ మరియు ఈ వ్యతిరేకంగా వి.
మీరు ఈ పోల్చడం చేస్తున్నారు , ఇది ఈ వ్యతిరేకంగా
స్పష్టముగా అందంగా useful-- useless-- ఉంది అందంగా నిరుపయోగం నిజంగా ఎందుకంటే
తీగలను మెమరీ ఎక్కడ పట్టించుకుంటారు?
>> నిజానికి, మేము కలిగి.
మరియు మేము వెళ్ళడం లేదు చేస్తున్నాం ముఖ్యంగా caring ప్రారంభించండి.
మాత్రమే దోషాలు తలెత్తుతాయి ఆ మేరకు మరియు భద్రతా బెదిరింపులతో సంకల్పం పెరగవచ్చు
మేము నిజానికి ఈ పట్టించుకోనట్లు మొదలు.
కాబట్టి ఈ సమస్య పరిష్కరించడానికి అనుమతిస్తాయి.
మీరు సూపర్ కేవలం దాన్ని పరిష్కరించడానికి, అవుతుంది.
>> మరియు నేను ముందు, నిజానికి లెట్స్ మళ్ళీ వెల్లడించలేదు ఏమైంది
ఒక CS50 తరగతి లో ఉంటే మీరు, మరియు మీరు అమలు వచ్చింది
రెండు రెమ్మలు వ్యతిరేకంగా ఒక పోలిక.
మీరు స్పష్టంగా, s = T సమానం ఉపయోగించలేరు.
కానీ కేవలం తార్కికంగా, ఎలా మీరు ఈ స్ట్రింగ్ పోల్చి చేస్తుంది
సి కోడ్ ఉపయోగించి ఈ స్ట్రింగ్ వ్యతిరేకంగా?
అవును.
>> ప్రేక్షకులు: జస్ట్ లూప్ [వినబడని]
డేవిడ్ J. మలన్: పర్ఫెక్ట్.
ప్రేక్షకులు: [వినబడని]
డేవిడ్ J. మలన్: అవును.
కేవలం లూప్ లేదా ఒక ఉపయోగించడానికి లూప్ లేదా సంసార అయితే.
కానీ కేవలం ప్రాథమిక ఆలోచన దరఖాస్తు ఉంటే ఈ మెమోరీ లేదా వ్యూహం యొక్క ఒక భాగం ఉంది
మరియు ఈ పైగా iterate రెండూ ఒకే సమయంలో.
మరియు కేవలం అక్షరాలు సరిపోల్చండి.
>> మరియు మీరు ఒక కలిగి పొందారు చిన్న జాగ్రత్తగా, మీరు ఎందుకంటే
ఒక వేలు వద్దు ఇతర గతంలో వెళ్ళడానికి
ఒక స్ట్రింగ్ ఎందుకంటే ఇతర కంటే ఎక్కువ.
కాబట్టి మీరు చెక్ అనుకుంటున్నారా చూడాలని చివరిలో ఈ ప్రత్యేక విలువ, శూన్య.
కానీ అది నిజంగా ఉంది ముగింపు, వంటి సాధారణము.
మరియు స్పష్టముగా, మేము అవసరం లేదు ఆ చక్రం ఆవిష్కరించుకునే.
ఇక్కడ వెర్షన్ రెండు ఉంది.
మరియు నేను ఏ ఇక్కడ చెప్పడానికి వెళుతున్న ఉంది బదులుగా లు పోల్చుట, = t సమానం
ఒకవేళ స్ట్రింగ్ నేను బదులుగా, చెప్పడానికి వెళుతున్నాను లు కామా T పోలిక = 0 సమానం.
ఇప్పుడు, స్ట్రింగ్ ఏమి పోల్చడానికి ఉంది?
>> ఇది ఒక ఫంక్షన్ ఉంది, ఆ బయటకు వస్తాడు దీని ప్రయోజనం జీవితంలో సి తో వస్తుంది
రెండు రెమ్మలు పోల్చడం.
మేము చదివితే మరియు పోల్చడానికి కదిలించు దాని మనిషి పేజీ లేదా డాక్యుమెంటేషన్ లేదా CS50
సూచన, అది రెడీ కేవలం మీరు స్టైర్ చెప్పండి
ప్రతికూల స్థితికి వస్తుంది సరిపోల్చండి సంఖ్య లేదా ఒక ధనాత్మక సంఖ్యకు లేదా సున్నా
సున్నా అంటే అక్కడ వారు సమాన ఉన్నారు.
>> కాబట్టి కేవలం ప్రతిపాదనను.
ఇది ఏం కావచ్చు సరిపోల్చండి రాబడి కదిలించు
ప్రతికూల విలువ లేదా సానుకూల విలువ?
ప్రేక్షకులు: కంటే ఎక్కువ లేదా కంటే తక్కువ.
డేవిడ్ J. మలన్: అవును, కంటే ఎక్కువ లేదా కంటే తక్కువ.
కాబట్టి మీరు ఒక మొత్తం క్రమం కోరుకుంటే ఒక dictionary-- లో తీగల యొక్క బంచ్
మేము చివరికి road-- డౌన్ రెడీ పరిపూర్ణ ఫంక్షన్ సమర్థవంతంగా ఉపయోగించడానికి,
అలా వెళుతున్న ఎందుకంటే మీరు తీగలను పోల్చడం, మరియు చెప్పండి
మీరు ఒక బి ముందు వస్తుంది లేదు, లేదా చేస్తుంది బి అక్షర ముందు పేర్కొనబడతాయి.
మేము ఖచ్చితంగా ఆ చేయవచ్చు.
>> నేను ఇతర ఒకటి లేదు గమనించండి ఈ ఉదాహరణలో విషయం.
ఇంకా ఏమి ఎక్కువ మార్చబడింది ఈ ప్రధాన ఫంక్షన్ లో?
చార్ *.
మరియు ఈ ఇతర తెలుపు అబద్ధం ఉంది.
అన్ని ఈ సమయంలో, మీరు చేసిన స్ట్రింగ్ వ్రాయడం జరిగింది,
మేము రహస్యంగా మళ్లీ చేశారు చార్ వంటి స్ట్రింగ్ * కనుక వాస్తవానికి గణగణమని ద్వని చేయు
మీరు అర్థం.
>> ఇతర మాటలలో, CS50.h లో మరియు మేము చివరికి చూస్తారు,
మేము ఒక పర్యాయపదంగా అని స్ట్రింగ్ చేసింది ఆ చార్ * అదే విషయం.
ఇప్పుడు కోసం, కేవలం తెలుసు * ఈ సందర్భంలో, కనీసం,
చిరునామా అర్థం.
>> ఏమి చిరునామా?
వెల్, నేను అన్నాడు ఆ చార్ *, మరియు * Int లేదా * తేలుతూ కాదు
చార్ * ఉంది అంటే ఒక చార్ యొక్క చిరునామా.
కాబట్టి ఇక్కడ ఈ చిన్న పెట్టెలో, ఆక స్ట్రింగ్, నిజంగా రకం చార్ * ఉంది,
ఇది చెప్పడం కేవలం ఒక ఫాన్సీ మార్గం ఈ బాక్స్ లో ఒక చిరునామా వెళ్తుంది.
మరియు ఆ చిరునామాకు చూడండి లేదు?
స్పష్టంగా, ఒక చార్.
>> కానీ మేము ఖచ్చితంగా జరిగింది Int * మరియు ఇతర విషయాలు ఉన్నాయి.
కానీ ఇప్పుడు కోసం, చార్ * నిజంగా చాలా ఉంది ముక్కుసూటి మరియు ఆసక్తి ఒకటి.
కాబట్టి ఈ సమస్య అన్నారు మళ్ళీ, అయితే, పెరుగుతుంది.
>> నేను ఈ కార్యక్రమం తెరుచుకుంటుంది అనుకుందాం.
ఇప్పుడు మేము అంచనా లేదో యొక్క చూసేలా ఏమి ఈ కోడ్ తప్పు.
కాబట్టి ఈ ప్రోగ్రామ్ లో, కాపీ 0, నేను రెడీ ముందుకు వెళ్లి మళ్లీ కాల్ వెళుతున్న
GetString మరియు s విలువ నిల్వ.
>> ఆపై, ఎందుకు నేను ఇలా చేస్తున్నాను కేవలం వారాల గతం నుండి ఒక రిమైండర్ గా?
మేము ఆ GetString అని పేర్కొన్నారు కొన్నిసార్లు శూన్య తిరిగి.
ఇది ఏం చేయమంటారు GetString శూన్య తిరిగి?
ఏదో తప్పు జరిగింది.
ఇది బహుశా స్ట్రింగ్ చాలా ఉంది అంటే పెద్ద, మెమరీ కంప్యూటర్ యొక్క అవుట్.
ఇది సూపర్, సూపర్, సూపర్ జరుగుతుంది అరుదుగా, కానీ అది జరిగి.
దాని కోసం మేము చెక్ అనుకుంటున్నారా, మరియు మేము చేస్తున్న అంతే.
>> మీరు లేకపోతే మేము ఇప్పుడు చూస్తారు ఎందుకంటే విషయాల కోసం అలవాటుగా తనిఖీ ప్రారంభం
శూన్య వంటి, మీరు వాటిని వాస్తవానికి వెళ్ళి మొదలు
మెమరీ చిరునామాలను చెల్లుబాటు అని ఉంటాయి.
మరియు మీరు ప్రేరేపించే ఆరంభమవుతుంది చేస్తున్నారు మరింత సెగ్మెంటేషన్ లోపాలుగా.
లేదా ఒక Mac లేదా PC లో కేవలం ఒక కంప్యూటర్ దీనివల్ల హేంగ్
లేదా ప్రోగ్రామ్ సమర్థవంతంగా, స్తంభింప చేయడానికి.
>> కాబట్టి ఇప్పుడు, నేను కాపీ 0.c లో క్లెయిమ్ నేను మార్గం ద్వారా ఈ తీగల కాపీ వెళ్ళిపోతున్నాను
28 తీరతారు.
ఆపై, నేను వెళుతున్నాను దిగువన దావా
ఇక్కడ నేను వెళుతున్న ఆ వాటిలో ఒకటి మార్చడానికి.
>> కాబట్టి ఈ గమనిస్తారు.
నేను మా పాత స్నేహితుడు strlen కాల్ చేస్తున్నాను.
మరియు కేవలం ఇంగ్లీష్ లో వివరించేందుకు ఈ లైన్ 34 ఏమి ఉంది?
ఏం T బ్రాకెట్ 0 చేస్తుంది ఎడమవైపు సూచిస్తాయి.
అవును.
>> ప్రేక్షకులు: t యొక్క మొదటి పాత్ర?
డేవిడ్ J. మలన్: t యొక్క మొదటి పాత్ర.
అంతే.
T యొక్క మొదటి పాత్ర, నేను కావలసిన పెద్ద వెర్షన్ పెట్టేందుకు
T లో మొదటి అక్షరం యొక్క.
కాబట్టి ఈ కేంద్రీకరణ ఉంటుంది మొదటి లేఖ.
ఆపై, ఆఖరి మాట చేయండి ఈ కార్యక్రమం లో నేను ఇక్కడ క్లైమ్
అసలు, s, మరియు ఇక్కడ కాపీ, t యొక్క.
>> కానీ కథ ఆధారంగా మేము కేవలం తీగలను నిజంగా ఏమిటో గురించి చెప్పారు
నిజంగా లైన్ 28 ఏమి ఉంది కలిగెను ఏమిటి
అన్నారు ఫలితంగా బగ్ తెరపై ఉండాలి?
>> కాబట్టి మొదటి, మొదటి ప్రశ్న, 28.
స్ట్రింగ్ t = s నిజంగా ఏం చేస్తోంది?
మేము ఎడమ వైపు ఉంటే ఇక్కడ వైపున స్ట్రింగ్ t = ఏమిటి;
నాకు ఒక బాక్స్ ఇస్తుంది ఇక్కడ మరియు ఒక బాక్స్ ఇక్కడ.
మరియు, ఈ చిరునామా 0x అనుకుందాం యొక్క కక్ష్య, ఈ సమయంలో, చెప్పడానికి 50 తెలియజేయండి.
ఏం స్ట్రింగ్ t = s చేస్తుంది హుడ్ కింద ఏమి?
>> ప్రేక్షకులు: [వినబడని]
>> డేవిడ్ J. మలన్: ఇది మెమరీ నిల్వ అక్కడ పరిష్కరించేందుకు, కాబట్టి 0x50 అక్కడ వెళ్తాడు.
ఇప్పుడు చేస్తే, నేను మొదటి వెళ్ళండి T లో పాత్ర మరియు అప్పర్కేస్,
నేను సమర్థవంతంగా s కు ఏమి చేస్తున్నాను?
నేను నిజంగా కుడి, అదే పనిని చేస్తున్నాను?
ఎందుకంటే, చిరునామా 0x50-- మరియు కేవలం నేను బోర్డు మీద ఇక్కడ తావు లేదు,
కానీ, ఈ ఇక్కడ డౌన్ 0x50 భావిస్తాయి నా కంప్యూటర్ యొక్క మెమరీ లో ఎక్కడో.
>> నేను, ఉదాహరణకు, గాబే చేశారు ఈ వంటి, ఇక్కడ చిన్న లో.
మరియు నేను చెప్పారు T బ్రాకెట్ 0 పెట్టుబడిగా కావాలి.
వెల్, T బ్రాకెట్ 0 T లో మొదటి అక్షరం.
కాబట్టి చిన్న g అన్నారు మారింది పెద్ద జి కానీ సమస్య
ఏమి కూడా పాయింట్ ఉంది?
>> ప్రేక్షకులు: అదే.
>> డేవిడ్ J. మలన్: అదే ఖచ్చితమైన విషయం.
కాబట్టి బహుశా ఒక సాధారణ వివరణ, సింటాక్స్ ఒక చిన్న అసహజ పోయినప్పటికీ.
కాబట్టి దీన్ని చూద్దాం.
./copy-0 అప్పుడు కాపీని-0 చేయండి మరియు.
ఏదో సే: గాబే.
మరియు దురదృష్టవశాత్తు, రెండు వాటిని ఇప్పుడు పెట్టుబడిగా చేశారు
కానీ ఆ కోసం అంతర్లీన మేము కేవలం అని కారణం
ఇప్పుడు చిరునామాలను వ్యవహరించే.
>> కాబట్టి మేము ఎలా ప్రారంభం చెయ్యాలి చిరునామాతో ఏ పన్ intended--
మేము చిరునామా ప్రారంభించారు ఎలా ఈ ప్రత్యేక సమస్య?
వెల్, copy1.c, విషయాలు వెళ్తున్నారు కొద్దిగా మరింత క్లిష్టంగా పొందుటకు.
కానీ నేను ఒక దావా సంభావితంగా సాధారణ పరిష్కారం.
>> మొదటి చూపులో పొందుటకు కాబట్టి హార్డ్.
మొదటి కోసం సులభం మాత్రం కాదు సమయం మీరు, బహుశా, దాన్ని టైప్
కానీ సమస్య ఉంటే కేవలం T = లు కేవలం చేయడం
కాపీలు చిరునామా, ఏమిటి, మళ్ళీ నేను మీరు ఎంచుకోవచ్చు ఉంటే,
పరిష్కారం అవతరిస్తుంది నిజానికి ఒక స్ట్రింగ్ కాపీ కోసం?
>> ప్రేక్షకులు: మేము బహుశా చేస్తాము మళ్ళీ ఒక లూప్ ఉపయోగించడానికి.
>> డేవిడ్ J. మలన్: అవును.
కాబట్టి మేము మళ్ళీ ఒక లూప్ అవసరం చూడాలని.
మరియు మేము కాపీ అనుకుంటే ఎందుకంటే మరొక స్ట్రింగ్ ఒక స్ట్రింగ్ s,
మేము బహుశా దీన్ని చేయాలనుకుంటున్నారా పాత్ర పాత్ర.
కానీ సమస్య ఉంటే, ఈ నిజానికి s ఉంది
ఇప్పుడు మనం స్పష్టంగా ప్రారంభించడానికి అవసరం T మెమరీ పెడుతోంది.
>> ఇతర మాటలలో, లెట్స్ ఈ చివరిసారిగా పునర్.
ఈ స్ట్రింగ్ s = GetString ఉంటే.
మరియు అలాగే, ఇక్కడ ఈ అప్ చాలు తెలపండి.
ఈ GetString ఉంది.
ఏదో ఆపై, చిత్రాన్ని ఆ వంటి అని ముందు అన్నారు,
G-a-b-ఇ / 0.
ఈ వంటి కొంత కనిపిస్తోంది.
మరియు s అందువలన, మేము ఈ 0x50 కాల్ మరియు ఆ 51, 52 చేస్తాడు.
>> కాబట్టి ఈ 0x50 ఉంది.
ఆపై, నేను స్ట్రింగ్ t చేయండి.
మెమరీ, కేవలం జరగబోతోంది నాకు ఈ వంటి చిన్న చదరపు ఇస్తాయి.
కాబట్టి కీలక దశ ఇప్పుడు ఏమిటి?
నేను t లోకి లు కాపీ అనుకుంటే, ఏమి ఖాళీ మేము ఇక్కడ పూరించడానికి అవసరం?
లేదా మేము ఏమి చేయాలి అధిక స్థాయిలో లేదు?
అవును?
ఎవరో?
అవును.
>> ప్రేక్షకులు: మేము [వినబడని] అవసరం.
డేవిడ్ J. మలన్: అవును, మేము ఈ ఖాళీ పూరించడానికి అవసరం.
నేను కాపీ మరియు కాదు గాబే యొక్క పేరు చూపడంలో
నేను ఆపరేటింగ్ సిస్టమ్ అడగండి వరకు మెమరీ మరొక భాగం కోసం
అసలు కనీసం పెద్దది.
కాబట్టి ఒక ప్రశ్న తో వెళ్లిపోతాడు.
>> నేను ఆపరేటింగ్ సిస్టమ్ కాదు అడుగుతారు చెయ్యాలి ఎలా కేవలం ఒక సాధారణ చిన్న పాయింటర్ కోసం
ఈ పిలవబడే ఒక చిరునామా, ఒక పాయింటర్ కాదు
ఒక సాధారణ చిన్న బాక్స్ ఈ వంటి ఒక స్ట్రింగ్ అనే?
ఎలా నేను ఆపరేటింగ్ అడగండి లేదు మెమరీ యొక్క ఒక పెద్ద భాగం కోసం సిస్టమ్?
ఇంతవరకు, నేను మాత్రమే తిరిగి సంపాదించిన చేసిన పరోక్షంగా GetString కాల్.
సో ఎలా GetString ఉంది దాని మెమరీ పొందడం కూడా?
>> సరే, అక్కడ ఉండే అవుతుంది ఇక్కడ ఈ ఇతర ఫంక్షన్
మేము ఇప్పుడు ఉపయోగించడానికి మొదలు పెడతారేమో.
ఇప్పుడు, ఈ విధంగా మరింత గుప్తమైన than-- కనిపిస్తోంది మరియు నేను దాన్ని చూడగలరు ఒక్కడినే
ఈ లైన్ మార్గం మరింత గుప్తమైన కనిపిస్తోంది అప్పుడు మొదటి చూపులో తప్పక.
కానీ అది వేరుగా బాధించటం తెలియజేయండి.
>> ఎడమ చేతి వైపు, నేను చార్ * t చేశారు.
ఇంగ్లీష్ లో కాబట్టి, యొక్క సూత్రీకరించి ప్రారంభిద్దాం సాంకేతిక పరిభాషలో సరైన వాక్యాలు.
కాబట్టి ఈ పెడుతోంది ఒక రకం చార్ వేరియబుల్ T అనే *.
ఇప్పుడు, ఆ నిజంగా అర్థం ఏమిటి?
>> సరే, అర్థం, నేను ఏమి వెళ్తున్నాను T అనే ఈ వేరియబుల్ ఉంచాలి?
ఒక చార్ యొక్క ఒక చిరునామా.
కాబట్టి ఆ, కేవలం సరళంగా వార్తలు మరింత సహేతుకమైన మార్గం
ఎడమచేతి వైపు అభివర్ణించాడు.
కాబట్టి ఇక్కడ మాత్రమే ఈ బాక్స్ సృష్టిస్తుంది.
సో కుడి చేతి వైపు, బహుశా, వెళ్ళి
పెద్ద అని కేటాయించే మెమరీ ఎలా భాగం?
కాబట్టి యొక్క ఈ వేరుగా బాధించటం తెలియజేయండి.
>> ఇది మొదటి చూపులో అఖండమైన ఉంది కానీ ఇక్కడ లోపల ఏం జరగబోతోంది?
మొదటి, malloc, ఉంది దీనిలో మా కొత్త స్నేహితుడు, స్పష్టంగా ఉంది
"మెమరీని కేటాయించాల్సిన."
కాబట్టి ఈ జారీ చేస్తున్నారు వాదన ఉంది అది లోకి, కాబట్టి అది ఒక అందమైన పెద్ద వాదన.
కాబట్టి యొక్క ఈ వేరుగా బాధించటం తెలియజేయండి.
>> S యొక్క strlen, వాస్తవానికి, సూచిస్తుంది వాట్
ప్రేక్షకులు: అక్షరాలు సంఖ్య.
డేవిడ్ J. మలన్: జస్ట్ లు పాత్రలు సంఖ్య.
కాబట్టి s యొక్క పొడవు, అసలు స్ట్రింగ్.
కాబట్టి G-a-b-ఇ.
కనుక ఇది బహుశా నాలుగు ఈ సందర్భంలో వార్తలు.
ఎందుకు నేను తరువాత +1 చేస్తున్న S యొక్క strlen కాల్?
ప్రేక్షకులు: [వినబడని]
డేవిడ్ J. మలన్: ఆ కోసం ప్రత్యేక శూన్య పాత్ర.
మీరు నాకు చెప్పండి ఉంటే పొడవు ఉంది ఏమి గాబే యొక్క పేరు, నేను నాలుగు చెప్పటానికి వెళ్ళిపోతున్నాను.
హుడ్ కింద, అయితే, నేను అవసరం శూన్య పాత్ర కోసం ఐదో బైట్.
I +1 చేయడం నేను ఎందుకు కాబట్టి ఆ.
>> ఇప్పుడు కేవలం సందర్భంలో మీరు ఈ నడుస్తున్నాయి కాకుండా వేరే కంప్యూటర్లో ప్రోగ్రాం సే,
CS50 ఉపకరణం, ఇక్కడ ఒక చార్ యొక్క పరిమాణం
వివిధ కావచ్చు నా సొంత కంప్యూటర్ నుండి
నేను ఈ కాల్ చేసుకోవచ్చు అవుతుంది ఆపరేటర్లు sizeof, కేవలం కంప్యూటర్ అడగండి
ఒక యొక్క పరిమాణం ఏమిటి ఈ కంప్యూటర్లో చార్?
>> మరియు ఈ ఐదుగురు గుణించడం ద్వారా ఒక చార్ యొక్క పరిమాణం, ఉదాహరణకి ఇది
చాలా కంప్యూటర్లలో రెడీ కేవలం ఒకటి, malloc ఉంటుంది
నాకు ఈ పెద్ద కోసం కేటాయించాలని అన్నారు ఇక్కడ కుడివైపు పైగా మెమరీ భాగం.
మరియు అది తిరిగి జరగబోతోంది కాబట్టి ఇది అది ఒక ఫంక్షన్ ఉంది
ఏమిటో నాకు తిరిగి వెళుతున్న?
ప్రేక్షకులు: చిరునామాను?
డేవిడ్ J. మలన్: ఏమి చిరునామా?
ప్రేక్షకులు: మెమరీ ఇది కేటాయించింది?
డేవిడ్ J. మలన్: ది మెమరీ అది కేటాయించింది.
కాబట్టి నేను, స్పష్టముగా, ఏ ఆలోచన కలిగి ఇక్కడ ఈ అప్ ముగుస్తుంది అన్నారు.
నేను ప్రతిపాదించారు వెళుతున్న ఇది 0x88 వద్ద ముగుస్తుంది జరగబోతోంది.
పూర్తిగా ఏకపక్షంగా, కానీ 0x50 కంటే ఇతర ఎక్కడో,
ఆపరేటింగ్ సిస్టమ్ ఎందుకంటే, ఏమి Windows మరియు Mac OS నన్ను ఇలా, ఉంది
ఇది ఇచ్చి చేసే నిర్ధారించుకోండి నాకు RAM వివిధ భాగాలుగా.
>> కాబట్టి ఈ విలువ ఎక్కడ ఈ మెమరీ భాగం ముగుస్తుంది ఉండవచ్చు.
కాబట్టి ఈ 0x88, ఇక్కడ ముగుస్తుంది ఏమిటి.
కాబట్టి ఇప్పుడు స్పష్టంగా, నేను అర్థం చేసుకోవచ్చు ఈ అదే కాదు,
వారు సూచించే ఉన్నందున మెమరీ వివిధ భాగాలుగా.
నేను ఇప్పుడు వాస్తవానికి ఈ కాపీ అనుకుంటే కాబట్టి , యొక్క మీ ప్రతిపాదిత పరిష్కారం తెలియజేసేలా.
>> , యొక్క కేవలం వెళ్ళి లూప్ ఒక సృష్టించడానికి లెట్ మరియు t బ్రాకెట్ చేయండి నేను s బ్రాకెట్ నేను పొందుతాడు.
ఇప్పుడు నేను ఉపయోగించవచ్చు ఎందుకంటే ఈ శ్రేణి వంటి సంజ్ఞామానం
ఎందుకంటే అయినప్పటికీ, malloc చాలా సామాన్యముగా నాకు మెమరీ కేటాయించుకునే,
మెమరీ కేవలం ఆనుకొని బైట్లు.
బైట్, బైట్, బైట్, తిరిగి తిరిగి వెనుకకు.
>> నేను ఒక ప్రోగ్రామర్ గా తప్పనిసరిగా చెయ్యవచ్చు వ్యూహం గా చికిత్స ఇది
నేను ఈ చివరకు తెలిసిన ఉపయోగించవచ్చు అర్థం కొన్ని చదరపు బ్రాకెట్లలో నొటేషన్.
>> నాలో, ఎందుకంటే అక్కడ విరామం తెలియజేయండి ఈ కూడా, ఒకేసారి చాలా ఉంది
ప్రాథమిక ఆలోచన రీక్యాప్ అయితే తీగ ఉంది, ఈ సమయంలో,
ఒక కొత్త డేటా రకం కేవలంగా కాదు.
ఇది కేవలం ఒక అని పిలవబడే పాయింటర్ ఒక పాత్ర యొక్క చిరునామా,
ఇది కేవలం అనగా ఒక సంఖ్య మానవ కన్వెన్షన్ ద్వారా
మేము 0x ఏదో రాయడానికి ఉంటాయి.
>> కానీ అది కేవలం ఒక సంఖ్య 33 ఆక్స్ఫోర్డ్ స్ట్రీట్ వంటి,
ఇది నిర్మాణము CS భవనం యొక్క చిరునామా.
ఈ వివరాలను ఏదైనా ప్రశ్నలు?
అవును?
>> ప్రేక్షకులు: ఎందుకు మేము తనిఖీ చేయండి సమాన T కోసం శూన్యం?
>> డేవిడ్ J. మలన్: మేము ఎందుకు చేయండి శూన్యం సమానంగా T తనిఖీ?
మేము documentation-- చదివితే malloc కోసం గొప్ప question--,
ఇది ఫైన్ ప్రింట్ లో చెప్పడానికి జరగబోతోంది కొన్నిసార్లు, malloc శూన్య తిరిగి ఉండవచ్చు
కేవలం GetString వంటి.
నిజానికి, GetString శూన్య తిరిగి , క్రమంగా, malloc శూన్య తిరిగి ఉంటే,
GetString malloc ఉపయోగించే ఎందుకంటే.
>> OS ఉంటే ఆ జరిగే ఉండవచ్చు Mac OS, Windows, సంసార, కేవలం ఉంది
మీరు మెమరీని ఔట్.
కాబట్టి ఆ అక్కడ జరిగిన ఏమిటి.
>> నాకు ఒక విషయం ఇతర బహిర్గతం వీలు కేవలం మీ మనసును రగిలించు ఉండవచ్చు
లేదా పూర్తిగా చాలా దూరం లైన్పై ఉంటుంది.
కానీ నాకు పుల్ అప్ తెలియజేయండి కాపీ లూప్ అదే,
ఇది ఒక క్షణం క్రితం, రీకాల్ ఉంది ఈ. T బ్రాకెట్ నేను s బ్రాకెట్ నేను పొందుతాడు.
>> నైస్ మరియు యూజర్ ఫ్రెండ్లీ.
మళ్ళీ వీక్ రెండు అనుకుని.
కానీ ఈ వెర్షన్ నిజానికి ఉంటుంది గుప్తమైన కనిపిస్తోంది ఈ, రాసి.
ఇది ఒక టెక్నిక్ అని పాయింటర్ అంక, చిరునామా అంకగణితం.
కానీ ఎందుకు ఈ పని చేస్తుంది?
>> ఇప్పుడు annoyingly, సి రచయితలు ఉపయోగించడానికి నిర్ణయించుకుంది
వివిధ ప్రయోజనాల కోసం * సంకేతం.
మేము, అది ఇప్పటికే ఒకసారి ఉపయోగించిన చూసిన అంటే చార్ *, "నాకు ఒక వేరియబుల్ ఇవ్వాలని
ఆ కలిగి జరగబోతోంది ఒక చార్ యొక్క చిరునామా. "
ఆ సందర్భంలో కాబట్టి చార్ * "నాకు ఒక వేరియబుల్ ఇస్తాయి." అంటే
>> దురదృష్టవశాత్తు, మీరు * లేకుండా ఉపయోగిస్తే అది ముందు ఒక పదం, చార్ వంటి,
అది ఇప్పుడు అని dereference ఆపరేటర్లు.
మరియు మేము దీర్ఘ ముందు ఈ మరింత చూస్తారు.
కానీ అది కేవలం "అక్కడ వెళ్ళండి." అంటే
ఎవరైనా నాకు అప్పగించారు ఇది చెప్పడం వంటిది కాగితం ముక్క మీద "33 ఆక్స్ఫోర్డ్ స్ట్రీట్,"
నేను "* 33 ఆక్స్ఫోర్డ్ స్ట్రీట్," అలా చేస్తే అర్థం "CS భవనం వీధిలోనే వెళ్ళండి."
>> కాబట్టి * అక్కడే ఉంటే వెళ్ళడానికి అంటే అది ముందు ఏ పదం ఉంది.
కాబట్టి ప్రశాంతంగా ఉంటుంది, t ఏమిటి?
t యొక్క భాగం యొక్క చిరునామా నాకు తిరిగి ఇవ్వబడింది మెమరీ.
లు స్పష్టతను ఏమి యొక్క చిరునామా ఉదాహరణకు మనం చర్చిస్తున్న చేసిన,
చిన్న గాబే యొక్క?
యొక్క చిరునామా of--
ప్రేక్షకులు: స్ట్రింగ్.
డేవిడ్ J. మలన్: గాబే యొక్క అసలు పేరు.
కనుక ఇది యొక్క చిరునామా వార్తలు మెమొరీ ఈ భాగం.
కాబట్టి నేను చెప్పుకోవాలంటే టి + ఐ కెన్ ఐ, నోటీసు, కేవలం మా పాత స్నేహితుడు.
ఇది కేవలం ఒక ఇండెక్స్ వేరియబుల్ వార్తలు ఆ మీద సున్నా నుండి iterating
స్ట్రింగ్ s యొక్క పొడవు.
కాబట్టి అది అప్పుడు సున్నా, ఒకటి చేస్తాడు రెండు, మూడు, నాలుగు.
కాబట్టి యొక్క ఈ కొత్త సిద్ధం తెలియజేయండి స్క్రాచ్ వంటి పజిల్ ముక్కలు, మీరు రెడీ ఉంటే,
అయినప్పటికీ, మళ్లీ, వాక్యనిర్మాణం స్క్రాచ్ కంటే మరింత రహస్య ఉంది.
కాబట్టి T ఒక చిరునామా ఉంది + నేను నాకు ఇవ్వాలని అన్నారు
ఒక సంఖ్య, ఈ ఎందుకంటే అన్ని ఉన్నాయి మేము హెక్స్ గీయడం చేసిన సంఖ్యలు.
కానీ వారు కేవలం సంఖ్యలు ఉన్నారు.
>> T యొక్క చిరునామా మేము చెప్పారు చేస్తే ఉంది 0x88, 0x88 ప్లస్ సున్నా ఏమిటి.
మీరు సౌకర్యవంతమైన లేదు కూడా ఉంటే ఇంకా హెక్స్ తో, ఒక అంచనా పడుతుంది.
>> ప్రేక్షకులు: అసలు.
>> డేవిడ్ J. మలన్: 0x88 స్టిల్.
కాబట్టి * ఏమి అర్థం 0x88 లేదు?
ఇది అంటే "అక్కడ వెళ్ళి" అంటే సమర్థవంతంగా, "ఇక్కడ మీ వేలు ఉంచండి."
ఇప్పుడు కుడి వైపు ఈ వ్యక్తీకరణ * ఆపై parens లో,
నేను చేస్తున్న, ఇది అర్థం + ఇక్కడ చిన్న g అప్ పరిష్కరించడానికి.
s +0, కోర్సు యొక్క, ఉంది ఏ s, s.
>> కాబట్టి ఇప్పుడు, అది * లు, ఇందులో కేవలం * 33 వంటి ఆక్స్ఫోర్డ్ స్ట్రీట్ చిరునామా వెళ్ళండి అర్థం
లు.
కాబట్టి ఇక్కడ ఈ వేలు, కుడి చేతి.
సో నేను ఏమి లోకి కాపీ వెళ్తున్నాను?
ఇది కుడి విషయం, గాబే, ఇక్కడ లోకి ఇక్కడ చిన్న g.
>> ఆ కాబట్టి ప్రభావం లూప్ యొక్క మొదటి మళ్ళా,
మీరు కనిపిస్తోంది అయినప్పటికీ, ప్రతిపాదించిన అన్నింటికన్నా క్రేజీ మరింత క్లిష్టంగా
మేము ముందు చూసిన కేవలం చెబుతున్నారు ఇక్కడ వెళ్లి ఇక్కడ ఆ పాత్ర కాపీ.
ఇది మీరు రెండు స్థానాలను ఒక మ్యాప్ ఇవ్వడం.
>> మేము ఈ చాలా చూస్తారు.
కానీ ఇప్పుడు కోసం, ఆశ కేవలం ఉంది ఈ ప్రాథమిక ఆలోచనలు కొన్ని పరిచయం.
నిజానికి, చూద్దాం ఇక్కడ ఒక చివరి కార్యక్రమం,
ఆపై వాగ్దానం క్లేమాషన్గా, ఇది ప్రతిదీ అన్ని కుడి చేస్తుంది.
అన్ని కుడి.
కాబట్టి నాకు అక్కడ మేము వెళ్ళి up-- తెరిచి తెలియజేయండి.
మేము తిరిగి వచ్చి చేస్తాము నాకు సో తెలియజేయండి దీర్ఘ ముందు ఈ చిత్రానికి.
నాకు ఇక్కడ ఈ చివరి ఉదాహరణ ప్రారంభం లెట్.
>> కాబట్టి ఇక్కడ ఒక సూపర్, సూపర్ ఉంది నెరవేరుస్తుంది కార్యక్రమం
కింది చేసే జీవితంలో ఏదీ.
ఇది మొదటి రెండు వేరియబుల్స్ x ప్రకటించాడు మరియు ఈ సమయంలో సంఖ్యలు లేని Y,
కేవలంగా.
వారు కేవలంగా, పూర్ణ లేదు.
వారు * స్పష్టంగా Int.
కాబట్టి కేవలం ఎవరైనా, అది అర్థం ఏమిటి మీ డేటా రకం ఉంటే, మీ వేరియబుల్,
రకం Int * తార ఉంది?
ఒక పూర్ణాంకానికి యొక్క చిరునామా ఉంది.
>> కాబట్టి నేను ఇంకా ఎలాంటి ఆలోచన చేశారు.
ఇది కేవలం "చివరికి, ఉంచారు అనగా ఇక్కడ ఒక పూర్ణాంకానికి యొక్క చిరునామా. "
అది ఎంతవరకూ 0x50, 0x88, జ్ఞాపకశక్తి, ఒక చిరునామా ఉన్నట్లు అన్నారు.
ఆ Y ఏమిటి అలాగే చేస్తాడు.
>> నేను ఇప్పుడు చెప్పండి చేస్తే x = malloc (sizeof (Int)), ఈ చెప్పడం ఒక ఫాన్సీ మార్గం,
హే ఆపరేటింగ్ సిస్టమ్, malloc ద్వారా, పరిమాణం నాకు తగినంత మెమరీ ఇవ్వాలని
బహుశా ఇది ఒక పూర్ణాంకానికి యొక్క 32 బిట్స్ లేదా నాలుగు బైట్లు చేస్తాడు.
>> కాబట్టి malloc ఏ తిరిగి లేదు?
Malloc ఒక చిరునామా తిరిగి.
సో వాట్ x నిల్వ పరుచుట?
భాగం యొక్క చిరునామా జ్ఞాపకశక్తి, నాలుగు బైట్లు, ఆ malloc
కేవలం అడుగుతూ నాకు దొరకలేదు ఆపరేటింగ్ సిస్టమ్.
>> ఇప్పుడు అదే సమయంలో, లైన్ ఇక్కడ నాలుగు, * x = 42.
జస్ట్ స్పష్టతను అక్కడ డౌన్ ఏమి జరగబోతోంది?
ఎడమ చేతి వైపు, * x.
ఆ * 33 ఆక్స్ఫోర్డ్ స్ట్రీట్ వంటిది.
కాబట్టి * x అంటే?
>> ప్రేక్షకులు: వెళ్ళండి.
>> డేవిడ్ J. మలన్: ఆ చిరునామా వెళ్ళండి.
ఎక్కడైతే ఆ భాగం మెమరీ దానికి వెళ్ళండి.
మరియు స్పష్టంగా, అంటే చాలు?
ప్రేక్షకులు: 42.
డేవిడ్ J. మలన్: 42.
అన్ని కుడి, * వై, అదే ఆలోచన.
Y చిరునామా వెళ్ళండి.
అక్కడ 13 ఉంచండి కానీ క్షణం వద్ద Y ఏమిటి?
ప్రేక్షకులు: జ్ఞాపకాలు Y కోసం ఉంది.
డేవిడ్ J. మలన్: అక్కడ Y కోసం ఏ మెమరీ ఉంది.
సో వాట్ బహుశా Y చేస్తుంది మేము చెప్పడం చేసిన, కలిగి?
>> ప్రేక్షకులు: గార్బేజ్.
>> డేవిడ్ J. మలన్: కొన్ని చెత్త విలువ.
ఇప్పుడు, చెత్త విలువ ఇప్పటికీ ఒక సంఖ్య.
ఇది ఇప్పటికీ ఒక చిరునామా పొరబడుతుంటారు.
ఇది ఎవరైనా అయితే వార్తలు డౌన్ ఏదో రాతలు
మరియు నేను అర్థం గా తప్పుగా వీధిలో కొన్ని భవనం.
మరియు మీరు కేవలం లోకి వెళ్ళడానికి ప్రయత్నించండి ఉంటే మీరు స్వంతం లేదు కొన్ని భవనం,
లేదా మెమరీ కొన్ని భాగం మీరు కాదు ఇవ్వబడిన చెడు పనులు జరిగే.
కంప్యూటర్ కొన్ని ఇతర క్రాష్, లేదా ఉండవచ్చు వివరించలేని ప్రాంతంనుండి ప్రవర్తన జరిగే.
>> కాబట్టి, అప్పుడు Binky, ఈ పరిచయ ఉంది.
నేను ఇప్పటికీ 20, గుర్తు కొన్ని బేసి సంవత్సరాల తరువాత,
నేను చివరికి నేను అక్కడ గమనికలు అర్థం.
>> మీకు, చెప్పటానికి ఇది మూడు నిమిషాల ఇక్కడ వదిలి
మరియు నేను లేదు అనుకుంటున్నాను గమనికలు అర్థం, తెలుసుకోవటం
నేను 20 గుర్తుకువచ్చి కొన్ని క్రేజీ కారణం సంవత్సరాల
ఎప్పుడు ఎందుకు అది చివరకు మునిగిపోయాయి , నా శిక్షణతో కూర్చొని
తోటి, నిషాత్ మెహతా లో ఎలియట్ డైనింగ్ హాల్ వెనుక.
ఇప్పుడు, నేను జ్ఞాపకం చేసిన ఈ ఎందుకంటే
విషయాలు నేను కూడా ఒకటి ప్రత్యేక పోరాడింది.
ఆపై, చివరకు క్లిక్, వంటి నేను విషయాలు చాలా చెప్పటానికి ధైర్యం
చివరికి రెడీ.
మరియు ఇప్పుడు, అన్ని అనిపించవచ్చు సంతోషముగా మరియు అన్ని మరింత ఆమోదయోగ్యమైన
యొక్క ఒక చివరి లుక్ తీసుకుందాం మా ఇక్కడ Binky గత మూడు నిమిషాలు,
మా స్నేహితుడు, నిక్ నుండి స్టాన్ఫోర్డ్ నుండి Parlante.
>> [వీడియో ప్లేబ్యాక్]
>> -Hey, Binky ఆన్లైన్.
నిద్రలేపే!
ఇది పాయింటర్ వినోదం కోసం సమయం.
>> ఆ -What వార్తలు?
గమనికలు గురించి తెలుసుకోండి?
ఓహ్, అమ్మ!
>> -సరే, ప్రారంభించడానికి, మనం ఉన్నాము అంచనా ఒక జంట గమనికలు అవసరం అన్నారు.
>> -OK.
ఈ కోడ్, రెండు పాయింటర్లు కేటాయించుకునే ఇది పూర్ణ సూచిస్తుంది.
-OK.
Well, నేను రెండు పాయింటర్లు చూడండి, కానీ వారు ఏదైనా సూచించే అనిపించడం లేదు.
>> -ఆ సరియే.
మొదట్లో, గమనికలు ఏదైనా సూచించడానికి లేదు.
వారు అని సూచించడానికి విషయాలు pointees, మరియు వాటిని ఏర్పాటు
ప్రత్యేక అడుగు.
>> కుడి, కుడి, -OH.
నేను తెలుసు.
pointees విడిగా ఉంటాయి.
Er, కాబట్టి మీరు ఒక pointee కేటాయించాలని చెయ్యాలి?
>> -OK.
Well, ఈ కోడ్ కేటాయించుకునే ఒక కొత్త పూర్ణాంక pointee,
మరియు ఈ భాగం సెట్లు x అది సూచించడానికి.
>> -Hey, మంచి కనిపిస్తోంది.
కాబట్టి అది ఏదో ఒకటి చేయండి.
>> -OK.
నేను dereference పాయింటర్ x చేస్తాము దాని pointee లోకి సంఖ్య 42 నిల్వ.
ఈ ట్రిక్ కోసం, నేను అవసరం ఉంటుంది నా Dereferencing యొక్క మ్యాజిక్ వాండ్.
>> Dereferencing యొక్క -మీ మేజిక్ వాండ్?
ఆ గొప్ప పని.
>> -ఈ కోడ్ కనిపిస్తోంది ఏమిటి.
నేను కేవలం సంఖ్య, మరియు [పాప్] ఏర్పాటు చేస్తాము
>> -Hey, చూడండి.
అక్కడ అది వెళుతుంది.
>> X అనుసరిస్తుంది ఒక dereference చేయడం -కాబట్టి బాణం దాని pointee ప్రాప్తి చేయడానికి.
ఈ సందర్భంలో, అక్కడ ఒక స్టోర్ 42.
హే సంఖ్య నిల్వ దానిని ఉపయోగించి ప్రయత్నించండి ఇతర పాయింటర్ ద్వారా 13, Y.
>> -OK.
నేను y ఇక్కడ పైగా వెళ్తారో సంఖ్య 13 సెట్ అప్ పొందండి.
ఆపై, మంత్రదండం టేక్ Dereferencing మరియు కేవలం [Buzz]
>> -OH!
>> హే, -OH!
ఆ పని చేయలేదు.
Binky, నేను dereferencing భావించడం లేదు, సే మీరు తెలుసు ఎందుకంటే Y, ఒక మంచి ఆలోచన
pointee ఏర్పాటు ప్రత్యేక అడుగు.
మరియు మనం ఎప్పుడూ చేసియున్నారు భావించడం లేదు.
>> -గుడ్ పాయింట్.
-Yeah.
మేము పాయింటర్ Y కేటాయించింది, కాని మేము ఎప్పుడూ ఒక pointee సూచించడానికి సెట్.
>> -Very గమనించే.
-Hey, మీరు అక్కడ Binky మంచి చూస్తున్న.
కాబట్టి మీరు దాన్ని పరిష్కరించడానికి చేయవచ్చు y పాయింట్లు x అదే pointee కు?
>> -Sure.
నేను నా మాజిక్ మంత్ర ఉపయోగిస్తాము పాయింటర్ అప్పగించిన.
>> అవతరిస్తుంది చూడబడ్డాడు ముందు వంటి సమస్య?
-సంఖ్య.
ఈ pointees టచ్ లేదు.
ఇది కేవలం ఒక పాయింటర్ మార్పులు మరొక అదే విషయం సూచించడానికి.
>> -OH, నేను చూడండి.
X అదే స్థానంలో ఇప్పుడు Y పాయింట్లు.
కాబట్టి వేచి.
ఇప్పుడు, Y పరిష్కరించబడింది.
ఇది ఒక pointee ఉంది.
కాబట్టి మీరు వాండ్ ప్రయత్నించవచ్చు 13 కి పైగా పంపడానికి మళ్ళీ dereferencing.
>> సరే, -Uh.
ఇక్కడ చేజారిపోతుంది. [పాప్]
>> -Hey, ఆ దృష్టి.
ఇప్పుడు Y పనులు dereferencing.
గమనికలు భాగస్వామ్యం ఎందుకంటే ఒక pointee అని, వారు రెండు 13 చూడండి.
-Yeah.
పంచుకుంటున్న సంసార.
కాబట్టి మేము ఇప్పుడు ప్రదేశాలు మారడానికి వెళ్తున్నారు?
>> ఓహ్, చూడండి.
మేము సమయం లేదు.
>> -But--
>> మూడు పాయింటర్ నియమాలు గుర్తుంచుకోవాలి-కేవలం.
నెంబర్ వన్, ప్రాథమిక నిర్మాణం మీరు ఒక పాయింటర్ కలిగి ఉంది,
మరియు ఇది ఒక pointee కు చూపాడు.
కానీ పాయింటర్ మరియు pointee, ప్రత్యేక ఉన్నాయి
మరియు సాధారణ లోపాన్ని ఒక పాయింటర్ ఏర్పాటు చేయడం,
కానీ ఒక pointee ఇవ్వాలని మర్చిపోవటానికి.
>> సంఖ్య రెండు, పాయింటర్ dereferencing పాయింటర్ మొదలవుతుంది
మరియు దాని బాణం క్రింది దాని pointee ప్రాప్తి చేయడానికి.
మేము అన్ని తెలిసిన, ఈ ఉందనుకోండి మాత్రమే పనిచేస్తుంది
ఒక pointee ఏ రకమైన నెంబర్ వన్ రూల్ వచ్చేస్తుంది.
>> సంఖ్య మూడు, పాయింటర్ అప్పగించిన ఒక పాయింటర్ పడుతుంది
మరియు మార్చాలి మరొక పాయింటర్ అదే pointee.
అప్పగించిన తర్వాత కాబట్టి, రెండు పాయింటర్లు
అదే pointee కు ఆకర్షిస్తాయి.
కొన్నిసార్లు, భాగస్వామ్య అని.
మరియు ఆ నిజంగా, ఇది ఉంది అంతే.
బై బై-ఇప్పుడు.
[END వీడియో ప్లేబ్యాక్]
డేవిడ్ J. మలన్: ఆ CS50 కోసం అంతే.
వచ్చే వారం మీరు చూస్తారు.