>> DAVID మలన్: అన్ని కుడి, తిరిగి స్వాగతం.
ఈ CS50 ఉంది.
ఈ వారం ఏడు ప్రారంభంలో ఉంది.
కనుక ఇది ఒక సమయంలో కూడా, నేను మేము ఆలపించాలని అనుకున్నాము లో అక్కడ ఒక సుడిగాలి పర్యటన
వదిలి మరియు అక్కడ ప్రస్తుతం చేయబోతున్నామని.
>> ఈ విషయం ఇక్కడ ఉండవచ్చు కాబట్టి మొదటి కొన్ని బెంగ కారణంగా.
కానీ ఆశాజనక, మీరు ప్రారంభిస్తున్నాం ఇక్కడ సూచిస్తుంది ఏమి పరిసర స్థితిగతులకు అలవాటుపరచు -
ఇది ఒక పాయింటర్, ప్రాతినిధ్యం స్టార్ మరింత లేమాన్ పరంగా కేవలం ఏమి?
కనుక ఇది ఒక చిరునామా యొక్క.
>> సో అది చిరునామా వార్తలు మెమరీ ఏదో.
మరియు మేము తిరిగి చర్మము పొరలు ప్రారంభించారు వారాల క్రితం, విషయాలు ఇష్టం
GetString మరియు ఇతర విధులు అన్ని ఈ సమయంలో తిరిగి చేశారు
వంటి మెమరీలో విషయాలను చిరునామాలు, లో మొదటి అక్షరం యొక్క చిరునామా
కొన్ని క్రమం.
>> కాబట్టి మేము కూడా, valgrind పరిచయం చేసిన మీరు ఈ సమస్య కోసం ఉపయోగించడానికి మొదలు పెడతారేమో
ఆ తర్వాతి కోసం, సెట్ సమస్య అలాగే సెట్.
మరియు valgrind మాకు ఏమి చేస్తుంది?
ఇది మెమరీ లీకేజ్ కోసం వెతుకుతుంది, మరియు అది కూడా మెమరీ దుర్వినియోగం కోసం వెతుకుతుంది.
>> ఇది, కొన్ని సంభావ్యత తో, గుర్తించగలదు ఉంటే మీ కోడ్ మెమరీ తాకే వెళ్తున్నారు
అది కేవలం ఉండకూడదు.
సో ఒక లీక్ అవసరం, కానీ మీరు కాదు కొన్ని సరిహద్దులను దాటి వెళ్ళి
అర్రే, మరియు మీరు నిజంగానే valgrind అమలు మరియు ప్రవర్తన ప్రేరేపించడానికి అయితే
valgrind మీ ప్రోగ్రామ్ రన్ అది లోపల నడుస్తున్న, మీరు పొందుతారు
ఈ వంటి సందేశాలను - "చెల్లని యొక్క వ్రాయండి , ఒక జంట గుర్తుకు ఇది పరిమాణం 4, "
వారాల క్రితం నేను అనుకోకుండా వచ్చేది చాలా దూరం ఒక Int నచ్చిన
ఒక అర్రే యొక్క సరిహద్దులు దాటి.
అందువలన పరిమాణం 4 ఇక్కడ పరిమాణం అర్థం నిర్దిష్ట Int యొక్క.
>> సో నిజానికి అభయమిచ్చిన తీసుకోవాలని valgrind యొక్క అవుట్పుట్, అది ఫార్మాట్,
కేవలం ఘోరమైన ఉంది.
ఇది గజిబిజి ద్వారా చూడటానికి నిజంగా కష్టం ఆసక్తికరమైన సమాచారం కోసం.
సో వాట్ మేము ఇక్కడ చేశాను సారాంశంలో ఎక్కువ జంట కొన్ని
ఆసక్తికరమైన పంక్తులు.
కాని వసూలు చేసే valgrind యొక్క 80% అవుట్పుట్ యొక్క ఒక బిట్ అవతరిస్తుంది
పరధ్యానంగా.
>> కేవలం ఇలాంటి నమూనాలు చూడండి - కుడి చెల్లని, చెల్లని, 40 బైట్లు చదవండి
మరియు బ్లాక్లను కొన్ని సంఖ్య ఖచ్చితంగా ఉన్నాయి ఆ వంటి కీలక పదాలు కోల్పోయింది.
మరియు మీరు ఆశాజనక చూస్తారు కొన్ని ఉంది పని ఏమి ఆధారములు రకం
తప్పు సైన్ నిజానికి
ఇక్కడ ఈ సందర్భంలో, ఏ లైన్ లో నా కోడ్ స్పష్టంగా లోపం?
>> ఇది memory.c పిలువబడే ఒక ఫైల్, 26 మేము ప్లే చేశారు ఉదాహరణకు
సమయంలో.
కనుక ఇది malloc బహుశా కాదు.
ఇది బదులుగా నా కోడ్ బహుశా.
కాబట్టి మేము మళ్ళీ ఈ చూస్తారు మళ్ళీ దీర్ఘ ముందు.
>> Scanf సో, ఈ ఒక వచ్చింది ఇప్పటివరకు రకాల జంట.
మేము క్లుప్తంగా sscanf చూసింది.
ఇది ఏదో ఒక సంఖ్య మీరు మీ లోకి dived
క్విజ్ సన్నాహాలు.
మరియు scanf అసలు CS50 లైబ్రరీ కింద ఉపయోగించి చేయబడింది
క్రమంలో కొంతకాలంగా కోసం హుడ్ యూజర్ నుండి ఇన్పుట్ పొందుటకు.
>> ఉదాహరణకు, నేను CS50 కు వచ్చినప్పుడు ఉపకరణం ఇక్కడ, ఒక నన్ను తెరుచుకుంటుంది వీలు
scanf-0.c అని ఉదాహరణగా నేడు మరియు అది సూపర్ సులభం.
ఇది కేవలం కోడ్ యొక్క కొన్ని పంక్తులు వార్తలు.
కానీ అది ప్రదర్శించాడు నిజంగా ఎలా getInt ఈ సమయంలో అన్ని పని చేస్తుంది.
>> లైన్ 16 లో ఇక్కడ ఈ కార్యక్రమం , నేను ఒక Int డిక్లేర్ ప్రకటన.
అందువలన గమనికలు, మాయా ఏమీ అక్కడ, కేవలం ఒక Int.
అప్పుడు లైన్ 17 లో, నేను ప్రాంప్ట్ అనేక యూజర్, దయచేసి.
అప్పుడు చివరి 18 లో, నేను ఇక్కడ scanf ఉపయోగించడానికి.
మరియు నేను పేర్కొన్న, రకమైన వంటి printf యొక్క, నేను కోట్ ఎదురుచూచే చేస్తున్నాను అని
శాతం i unquote.
>> శాతం నేను, కోర్సు యొక్క, ఒక Int సూచిస్తుంది.
కానీ గమనించవచ్చు ఏమి రెండవ scanf కు వాదన.
ఎలా మీరు రెండవ వివరిస్తారు కామా తర్వాత వాదన?
ఆ అంటే ఏమిటి?
>> ఇది x యొక్క చిరునామా యొక్క.
సో ఈ ఎందుకంటే అందించడం ద్వారా ఉపయోగకరంగా ఉంటుంది x యొక్క చిరునామాతో scanf, దేనిని
అలా ఆ ఫంక్షన్ గలదా?
కాదు అక్కడికి వెళ్ళడానికి, కానీ కూడా ఏమి?
>> ఇది మార్పు.
మీరు అక్కడికి వెళ్లేందుకు ఎందుకంటే, అది విధమైన వార్తలు మెమరీ లో ఒక స్థానాన్ని ఒక చిహ్నం వంటి.
మరియు చాలా కాలం మీరు అందిస్తాయి scanf, లేదా ఒక చిహ్నం, ఆ ఏ ఫంక్షన్
ఫంక్షన్ అక్కడ వెళ్ళి, మరియు చేయవచ్చు మాత్రమే విలువ చూడండి, కానీ కూడా చెయ్యవచ్చు
ఉపయోగకరంగా ఉండే ఆ విలువ, మార్చడానికి scanf జీవితంలో ప్రయోజనం ఉంది
ప్రత్యేకంగా, వినియోగదారు నుండి ఇన్పుట్ స్కాన్ కీబోర్డ్ నుండి.
మరియు f వలె, ఆకృతీకరణ సూచిస్తుంది printf, f ఒక ఆకృతీకరణ సూచిస్తుంది
మీరు ముద్రించడానికి కావలసిన స్ట్రింగ్.
>> కాబట్టి చిన్న, ఈ లైన్ 18 కేవలం చెప్పారు, యూజర్ యొక్క నుండి ఒక Int చదవడానికి ప్రయత్నించండి
కీబోర్డ్ మరియు, x యొక్క లోపల నిల్వ x వద్ద నివసించడానికి ఏది చిరునామా.
ఆపై చివరగా, లైన్ 19 కేవలం చెప్పారు, ఈ సందర్భంలో Int ధన్యవాదాలు.
>> సో నాకు ముందుకు వెళ్లి ఈ తయారు చేద్దాము.
సో scanf 0 తయారు.
నాకు ముందుకు సాగి సైన్ జూమ్ లెట్
నేను వెళ్ళి ఈ అమలు చేస్తాము చుక్కలు scanf 0 స్లాష్.
సంఖ్య, దయచేసి?
50.
50 ధన్యవాదాలు.
కనుక ఇది చాలా సులభం.
>> ఇప్పుడు ఏమి లేదు?
ఇది ఒక మొత్తం బంచ్ చేయడం లేదు దోష పరిశీలన యొక్క.
ఉదాహరణకు, నేను సహకారం లేకపోతే, మరియు నేను అనేక టైప్ కానీ లేదు
బదులుగా నేను "హలో," వంటి ఏదో వ్రాయడానికి ఆ వింత చూస్తూ ఉంటాము.
విషయాలు CS50 యొక్క కావున లైబ్రరీ కొన్ని మాకు చేస్తున్న
సమయం ఆ reprompting ఉంది మరియు reprompting.
>> మళ్ళీ పదబంధం ఉపసంహరణలు, cs50.c లో ఉంది మరియు ఆ getInt లో కారణం వార్తలు
CS50 లైబ్రరీ నిజానికి మొత్తం ఉంది దీర్ఘ లైన్లు బంచ్, మేము ఎందుకంటే
ఈ వంటి స్టుపిడ్ స్టఫ్ కోసం తనిఖీ.
యూజర్ ఇవ్వాలని లేదు మాకు, నిజానికి, ఒక Int?
అతను లేదా ఆమె మాకు ఏదో కల్పించింది ఒక అక్షర లేఖ వంటి?
అలా అయితే, మేము గుర్తించడానికి కావలసిన మరియు వాటిని మీద అరుస్తుంటారు.
>> కానీ విషయాలు మరింత ఆసక్తికరంగా పొందుటకు ఈ తదుపరి ఉదాహరణలో.
నేను scanf-1.c వెళ్ళండి ఉంటే, ఏమి ఒకటి ప్రాథమికంగా మారింది అని విషయం
ఈ తదుపరి ఉదాహరణకు?
నేను, కోర్సు యొక్క, చార్ * ఉపయోగించి వెబ్ బదులుగా Int యొక్క.
>> ఎందుకంటే చార్ * సో ఈ, ఆసక్తికరంగా ఉంటుంది గుర్తు, కేవలం నిజంగా ఉంది
స్ట్రింగ్ అదే విషయం.
కనుక ఇది ఉండవచ్చు వంటి ఈ ఒక సూపర్ భావిస్తాడు GetString సాధారణ అమలు.
కానీ నేను పొర తిరిగి ఒలిచిన చేసిన CS50 లైబ్రరీ, నేను కాబట్టి
ఇప్పుడు ఈ చార్ * కాల్.
సో యొక్క చూద్దాము పేరు, ఎక్కడైనా ఉంటే, మేము తప్పు.
>> లైన్ 17 -
నేను మళ్ళీ, నాకు ఏదో ఇవ్వాలని దయచేసి, చెప్పటానికి ఈ సందర్భంలో, ఒక స్ట్రింగ్.
తరువాత లైన్ లో, నేను, scanf కాల్ మళ్ళీ, అది ఒక ఫార్మాట్ కోడ్ ఇవ్వడం,
కానీ ఈ సమయంలో శాతం లు.
ఆపై ఈ సమయంలో, నేను రెడీ! ఇది బఫర్ ఇవ్వడం.
>> ఇప్పుడు నేను ఉపయోగించి కాదు, గమనించండి ఆంపర్సండ్ చిహ్నం.
కానీ ఎందుకు ఇక్కడ బహుశా సరే?
ఇప్పటికే బఫర్ ఏమిటి ఎందుకంటే?
ఇది ఇప్పటికే ఒక పాయింటర్ వార్తలు.
ఇది ఇప్పటికే ఒక చిరునామా యొక్క.
>> మరియు లెట్ ఈ పదం నాకు వీలు ", కంగారు" వార్తలు కేవలం ఉదాహరణకు, అది లు కాల్
సరళత.
కానీ నేను స్వీకరించేందుకు అని చేసిన ఎందుకంటే సాధారణ, ప్రోగ్రామింగ్ లో, మీరు ఒక కలిగి ఉంటే
మెమరీ భాగం, ఇది ఒక స్ట్రింగ్ నిజంగా కేవలం, మీరు ఒక బఫర్ కాల్ ఉండవచ్చు ఉంది.
ఇది సమాచారాన్ని నిల్వచేసే ప్రదేశం.
>> ఉన్నప్పుడు YouTube, వంటి విషయాలను పోలి వారు, మాట్లాడటానికి, బఫరింగ్ చేస్తున్న
దాని నుండి బిట్స్ డౌన్లోడ్ యొక్క అర్థం ఇంటర్నెట్ మరియు ఒక వాటిని నిల్వ
స్థానిక అర్రే, కాబట్టి మెమరీ స్థానిక భాగం మీరు లేకుండా తరువాత చూడవచ్చు
ఇది ముళ్లు లేదా వ్రేలాడుతూ మీరు తిరిగి ఆడుతున్నప్పుడు.
>> సో ఒక సమస్య, అయితే ఇక్కడ ఉంది నేను scanf చెప్పడం నేను ఎందుకంటే, ఒక అంచనా
యూజర్ నుండి స్ట్రింగ్.
ఇక్కడ యొక్క చిరునామా వార్తలు మెమరీ భాగం.
అక్కడ ఆ స్ట్రింగ్ ఉంచండి.
ఎందుకు ఆ బౌండ్ ఇవ్వండి అయితే మాకు ఇబ్బంది,?
>> ఆ ఏమిటి?
నేను ఆక్సెస్ చెయ్యడానికి అనుమతి మెమరీ భాగం?
మీకు తెలిసిన, నేను తెలియదు.
బఫర్ initialized ఎందుకంటే దేని?
కాదు నిజంగా.
కావున మేము కాల్ చేసిన ఏమిటి ఒక చెత్త విలువ, ఇది
ఒక అధికారిక పదం కాదు.
ఇది కేవలం మేము ఏమి బిట్స్ సంఖ్య ఆలోచన ఉంది అంటే నాలుగు బైట్లు లోపలి ఉన్నాయి
నేను బఫర్ వంటి కేటాయించిన చేశారు.
>> నేను malloc అని లేదు.
నేను ఖచ్చితంగా GetString అని చేసిన.
సో ఎవరు అసలు తెలుసు బఫర్ లోపల?
మరియు ఇంకా scanf చెప్పడం నిర్లక్ష్యంగా, అక్కడ వెళ్ళి మరియు వినియోగదారు టైప్ సంసార చాలు.
>> సో కారణమవుతుంది ఏమిటి మా కోడ్ మేము అది అమలు చేస్తే?
బహుశా ఒక segfault.
బహుశా కాకపోవచ్చు, కానీ బహుశా ఒక segfault.
మరియు నేను ఉండవచ్చు కాదు ఎందుకంటే కొన్నిసార్లు మీరు కొన్నిసార్లు, చేయండి
మీరు ఒక segfault పొందలేము.
కొన్ని సమయాల్లో మీరు అదృష్ట పొందుటకు, కానీ ఏది ఏమి అయినప్పటికీ అది చేస్తాడు
మా ప్రోగ్రామ్ ఒక బగ్.
>> సో నాకు ముందుకు వెళ్లి ఈ కంపైల్ వీలు.
నేను పాత పాఠశాల విధంగా చేయ బోతున్నాను.
సో గణగణమని ద్వని చేయు డాష్ 0, scanf-1, scanf-1.c, ఎంటర్ చెయ్యండి.
అయ్యో, పాత పాఠశాల.
యొక్క చూసేలా.
నేను ఏమి అయ్యాయి?
ఓహ్, చార్ * బఫర్.
ఓహ్, ధన్యవాదాలు -
OK, సేవ్ -
చాలా పాత పాఠశాల.
అన్ని కుడి, అది చాలా సేపు అయ్యింది.
>> సో నేను ఫైలు తర్వాత సేవ్ చేసిన ఆ తాత్కాలిక మేకింగ్
ఒక క్షణం క్రితం మార్చడానికి.
మరియు ఇప్పుడు నేను సంగ్రహం మానవీయంగా గణగణమని ద్వని చేయు తో.
మరియు ఇప్పుడు నేను ముందుకు వెళ్ళి వెళుతున్నాను మరియు Enter, scanf-1 అమలు.
స్ట్రింగ్ దయచేసి.
నేను టైప్ చేస్తాము "హలో."
>> మరియు ఇప్పుడు, ఇక్కడ printf, స్పష్టముగా, పేరు వార్తలు కొద్దిగా బాధించే ఉంటుంది.
ఇది నిజానికి మాత్రం కాదు ఈ సందర్భంలో segfault.
Printf కొద్దిగా ప్రత్యేక ఎందుకంటే ఇది సాధారణంగా ఉపయోగిస్తారు కాబట్టి సూపర్ అని
ముఖ్యంగా printf చేస్తున్న మాకు ఒక అనుకూలంగా మరియు తెలుసుకొని,
ఒక చెల్లుబాటు అయ్యే పాయింటర్ కాదు.
నాకు కేవలం ప్రింట్ మీద నన్ను తీసుకుందాం వక్ర శూన్య లో, కూడా
అది తప్పనిసరిగా కాదు అయితే ఏమి మనం అంచనా.
>> కనుక మనం నిజంగా సులభంగా ఒక ప్రేరేపించడానికి కాదు ఈ స్పష్టంగా ఈ segfault, కానీ
నేను కోరుకున్న ప్రవర్తనను కాదు.
సో సాధారణ పరిష్కారం ఏమిటి?
బాగా, scanf-2 లో, నాకు ప్రతిపాదించారు అనుమతించే బదులుగా నిజానికి ఒక కేటాయించడం
చార్ *, నాకు కొద్దిగా తెలివిగా గురించి తెలపండి ఈ, మరియు నాకు బఫర్ కేటాయించుటకు వీలు
16 అక్షరాలు యొక్క ఒక క్రమంలో.
>> నేను మార్గాలు ఈ చేయవచ్చు.
నేను ఖచ్చితంగా malloc ఉపయోగించవచ్చు.
కానీ నేను వారం రెండు వెళ్లవచ్చు ఉన్నప్పుడు నేను ఒక మొత్తం బంచ్ అవసరం
అక్షరాలు.
అది ఒక అర్రే యొక్క.
సో నాకు బదులుగా బఫర్ పునర్నిర్వచించటానికి వీలు 16 అక్షరాల యొక్క శ్రేణి ఉండాలి.
>> మరియు ఇప్పుడు, నేను లో బఫర్ పాస్ -
మరియు ఈ మేము ఏదో ఉంది వారం రెండు గురించి మాట్లాడటానికి -
కానీ మీరు ఒక వ్యూహం చికిత్స చేయవచ్చు అది ఒక చిరునామా యొక్క అయితే.
మేము చూసిన సాంకేతికంగా, వారు ఉన్నాము కొంత భిన్నమైనది.
మీరు పాస్ అయితే scanf చూసుకొని లేదు ఒక అర్రే యొక్క పేరు, ఎందుకంటే ఏమి
మాకు ఖచ్చితంగా ఉంది గణగణమని ద్వని చేయు చేస్తాను ఆ శ్రేణి పేరు చికిత్స
16 బైట్లు భాగం యొక్క చిరునామా.
>> సో ఈ ఉత్తమం.
ఈ ఇప్పుడు నేను ఆశాజనక అంటే క్రింది వాటిని.
నాకు ఒక క్షణం దూరంగా లెట్ మరియు OK సంకలనం scanf-2, ఉందని.
ఇప్పుడు నాకు స్లాష్ scanf-2 వచ్చింది మనం.
స్ట్రింగ్ దయచేసి. "హలో." మరియు అది ఈ సమయం పని కనిపించింది.
>> కానీ ఎవరైనా ఒక సందర్భంలో ప్రతిపాదించారు చేయవచ్చు దీనిలో అది ఇప్పటికీ పనిచేయదు?
అవును?
16 అక్షరాల కంటే ఎక్కువ ఏదో.
మరియు వాస్తవానికి, మేము చేయవచ్చు కొద్దిగా ఎక్కువ ఖచ్చితమైన.
ఇక అప్పుడు 15 అక్షరాలు ఏదో, మేము గుర్తుంచుకోండి అవసరం ఎందుకంటే
మేము ఆ బాక్ స్లాష్ సున్నా అవసరమైన పరిపూర్ణంగా స్ట్రింగ్ ముగింపులో,
ఇది ఒక ప్రక్కన scanf సాధారణంగా ఉంటుంది మాకు యొక్క జాగ్రత్తగా ఉండు.
>> సో నాకు ఏదో తెలియజేసేలా -
కొన్నిసార్లు మేము కేవలం చెయ్యవచ్చు ఆ వంటి వదిలి.
OK, కాబట్టి మేము ఇప్పుడు ప్రేరిత చేసిన మా విభజన లోపంగా.
ఎందుకు?
నేను కంటే ఎక్కువ 15 కు టైప్ ఎందుకంటే అక్షరాలు, అందువలన మేము నిజానికి చేసిన
తాకిన జ్ఞప్తి నేను నిజానికి లేదు.
>> సో వాట్ నిజంగా ఇక్కడ పరిష్కారం ఏమిటి?
బాగా, మేము ఒక పొడవైన స్ట్రింగ్ ఏమి అవసరం ఉంటే?
బాగా, మేము దీనికి 32 బైట్లు తయారు.
బాగా, ఏమి దీర్ఘ చాలదు ఉంటే?
ఎలా 64 బైట్లు?
ఏమి కాలం తగినంత కాదు ఉంటే?
ఎలా 128 గురించి లేదా 200 బైట్లు?
ఏమి నిజంగా ఇక్కడ పరిష్కారం సాధారణ సందర్భంలో, మేము మాకు లేకపోతే
యూజర్ టైప్ జరగబోతోంది ఏమి ముందుకు?
>> ఇది గాడిద ఒక పెద్ద నొప్పి చూస్తూ ఉంటాము నిజాయితీ ఉండాలి, ఇది ఎందుకు
CS50 లైబ్రరీ యొక్క కొన్ని డజన్ల పంక్తులు ఉంది సమిష్టిగా అమలు చేసే కోడ్
మేము చేయలేని విధంగా స్ట్రింగ్ GetString ముందుగానే తెలుసు ఏమి
యూజర్ టైపు కానుంది.
ముఖ్యంగా, మీరు తిరిగి చూడండి cs50.c రెండు వారాల క్రితం నుండి, మీరు చూస్తారు
ఆ GetString నిజానికి చేస్తుంది ఈ విధంగా scanf ఉపయోగించదు.
అయితే, ఇది ఒక పాత్ర చదువుతుంది ఒక సమయంలో.
>> ఎందుకంటే గురించి ఒక nice విషయం ఒక పాత్ర చదివే మేము ఉంది
ఎల్లప్పుడూ కు మేమే హామీ కనీసం ఒక చార్ కలిగి.
నేను పడుతుంది అప్పుడు ఒక చార్ డిక్లేర్, మరియు చేయవచ్చు కేవలం ఈ నిజంగా శిశువు దశలు
ఒక వద్ద ఒక పాత్ర చదవండి కీబోర్డ్ నుండి సమయం.
ఆపై, మీరు GetString చూస్తారు చేస్తుంది, ఇది సహకరించదు ప్రతి సమయం
మెమరీ 16 బైట్లు చెప్పటానికి, అది ఉపయోగిస్తుంది malloc, లేదా ఒక బంధువు వాటి కు
పాత కాపీ, మరింత మెమరీని కేటాయించాల్సిన అప్పుడు కొత్త, మరియు క్రాల్ లోకి మెమరీ
పాటు, ఒక సమయంలో ఒక పాత్ర పొందడానికి ఆ సహకరించదు ఉన్నప్పుడు
మెమరీ భాగం,, ఆక్రమణలకు స్వస్తి దూరంగా విసురుతాడు మెమరీ పెద్ద భాగం, పాత కాపీ
కొత్త, మరియు రిపీట్స్ లోకి.
మరియు అది నిజానికి నిజమైన నొప్పి వార్తలు సాధారణ ఏదో అమలు
ఒక వినియోగదారు నుండి ఇన్పుట్ పొందడానికి.
>> సో మీరు scanf ఉపయోగించవచ్చు.
మీరు ఇతర ఇదేవిధమైన విధులను ఉపయోగించవచ్చు.
మరియు ఒక పాఠ్య పుస్తకాలు చాలా మరియు ఆన్లైన్ ఉదాహరణలు, కానీ వారు ఉన్నాము
ఈ వంటి సమస్యలు దెబ్బతింది.
చివరకు, ఒక segfault విధానం రకం బాధించే ఉంది.
ఇది వినియోగదారు కోసం మంచి కాదు.
>> కానీ చెత్త సందర్భంలో, దేనిని ఇది ప్రాథమికంగా మీ చాలు
ప్రమాదం వద్ద కోడ్?
దాడి రకమైన, సమర్థవంతంగా.
మేము అటువంటి దాడి గురించి మాట్లాడారు - స్టాక్ నిండిన.
కానీ సాధారణంగా, మీరు అనుమతి చేస్తుంటే ఓవర్ఫ్లో ఒక బఫర్, వంటి మేము ఒక చేసాడు
కేవలం రాసే క్రితం వారాల జంట, మరింత స్టాక్ న "హలో" కంటే, మీరు
నిజానికి ఒక, సమర్థవంతమైన, ఆక్రమిస్తాయి కంప్యూటర్, లేదా కనీసం డేటా వద్ద పొందుటకు
మీకు సంబంధించినది కాదు.
>> మేము ఎందుకు అలా చిన్న లో, ఈ ఉంది ఆ శిక్షణ చక్రాలు.
కానీ ఇప్పుడు, మేము, వాటిని ఆఫ్ మొదలయ్యాయి మా కార్యక్రమాలు ఇకపై అవసరం,
యూజర్ నుండి తప్పనిసరిగా, ఇన్పుట్.
కానీ సమస్య విషయంలో, ఆరు సెట్ మీ ఇన్పుట్ భారీ నుండి వస్తాయి
150 తో నిఘంటువు ఫైలు కొన్ని బేసి వేల పదాలు.
>> సో మీరు గురించి ఆందోళన చెందనవసరం లేదు యూజర్ యొక్క అనియత ఇన్పుట్.
మేము మీరు కొన్ని ఊహలు ఇస్తుంది ఫైల్ గురించి.
గమనికలు లేదా scanf ఏ ప్రశ్నలు లేదా సాధారణంగా వినియోగదారు ఇన్పుట్?
>> అన్ని కుడి, కాబట్టి ఒక వద్ద అప్పుడు ఒక త్వరిత వీక్షణ రెండు వారాల క్రితం నుండి అంశం వెనుకంజలో.
మరియు ఒక struct ఈ భావన.
కాదు - ఒక ఈ భావన ఏమి ఇది, struct?
Struct మాకు ఏమి లేదు?
>> నిర్వచించండి -
క్షమించండి?
ఒక వేరియబుల్ రకం నిర్వచించండి.
సో క్రమం యొక్క.
మేము నిజానికి రెండు విషయాలు కలపడం చేస్తున్నారు.
Typedef కలిగిన, ఆ మేము గుర్తు ఒక వంటి, మా సొంత రకం డిక్లేర్
చార్ * కోసం స్ట్రింగ్ వంటి పర్యాయపదంగా.
కానీ typedef మరియు struct ఉపయోగించి, మేము నిజంగా మా సొంత డేటా నిర్మాణాలు సృష్టించడానికి.
>> ఉదాహరణకు, నేను తిరిగి వెళ్ళి ఉంటే gedit లోకి ఇక్కడ కేవలం ఒక క్షణం, నేను ముందుకు వెళ్ళి
మరియు ఏదో ఇష్టం, నాకు సేవ్ చేసేలా ఈ, structs.c, యొక్క చెప్పటానికి వీలు
తాత్కాలికంగా, నేను వెళుతున్నాను ముందుకు వెళ్ళి చేర్చడానికి
standardio.h, Int ప్రధాన శూన్యమైన.
ఆపై ఇక్కడ, నేను మీరు అనుకుంటే నిల్వ ఒక ప్రోగ్రామ్ను రాయడం
బహుళ నుండి బహుళ విద్యార్థులు ఇళ్ళు, ఉదాహరణకు.
కనుక ఇది ఒక registrarial వంటిది కొంత డేటాబేస్.
>> నేను పేరు ఒక విద్యార్థి అవసరం కనుక, నేను , చార్ * పేరు వంటి ఏదో ఉండవచ్చు
మరియు నేను ఏదో చేస్తాను -
నిజానికి, యొక్క CS50 లైబ్రరీ ఉపయోగించడానికి అనుమతిస్తున్నట్లు కేవలం ఒక క్షణం ఈ ఒక చేయడానికి
కొద్దిగా సులభం, కాబట్టి మేము తీసుకోగలగడంతో లైన్స్ ఆఫ్ కోడ్ ఆ డజన్ల కొద్దీ.
మరియు లెట్ అది సాధారణ ఉంచండి లో.
మేము అది స్ట్రింగ్ ఉంటాం మరియు ఇప్పుడు GetString.
>> సో నేను పేరు నిల్వ చేసిన ఇప్పుడు క్లెయిమ్ కొన్ని విద్యార్ధి, మరియు హౌస్ ఆఫ్
కేవలం వేరియబుల్ ఉపయోగించి కొన్ని విద్యార్ధి, మేము వారంలో ఒక. వంటి
కానీ ఇప్పుడు మద్దతు అనుకుంటున్నారా ఊహించు బహుళ విద్యార్థులు.
అన్ని కుడి, నా ప్రవృత్తులు చేయాలని ఉన్నాయి స్ట్రింగ్ NAME2, GetString, స్ట్రింగ్ గెట్స్
house2 GetString గెట్స్.
ఆపై మా మూడవ విద్యార్థి, NAME3 GetString చేయండి చేసుకుందాం.
>> అన్ని కుడి, కాబట్టి ఈ ఆశాజనక అద్భుతమైన ఉంది తెలివితక్కువదని ఇలాంటి మీరు,
ఈ ప్రక్రియ నిజంగా ఎప్పుడూ ఎందుకంటే ముగించాలి వెళ్తున్నారు, మరియు అది కేవలం వెళుతున్న
నా కోడ్ అధ్వాన్నంగా కనిపించేలా మరియు అధ్వాన్నంగా మరియు అధ్వాన్నంగా.
కానీ మేము వారం రెండు చాలా ఇది అధిగమించింది.
మా చాలా శుభ్రంగా పరిష్కారం ఏమిటి మేము బహుళ వేరియబుల్ ఉన్నప్పుడు
అదే డేటా అన్ని సంబంధించిన రకం, కానీ మేము ఈ దారుణమైన గజిబిజి కోరుకోలేదు
అదే విధమైన పేరున్న చరరాశుల?
మేము బదులుగా ఏమి లేదు?
>> సో నేను కొన్ని ప్రదేశాలలో విన్న అనుకుంటున్నాను.
మేము ఒక అర్రే కలిగి.
మీరు అనేక చోట్ల కావాలా ఏదో, ఎందుకు మేము ఈ అన్ని శుభ్రం లేదు
అప్ మరియు నాకు ఇవ్వాలని, చెప్పటానికి అర్రే పేర్లు అని?
>> మరియు ఇప్పుడు కోసం, హార్డ్ కోడ్ 3 వీలు.
ఆపై నాకు మరొక వ్యూహం ఇవ్వాలని ఇళ్ళు అని, మరియు నాకు వీలు
ప్రస్తుతం హార్డ్ కోడ్ 3.
మరియు నేను గురుతర శుభ్రం చేసిన నేను సృష్టించిన విసిగిపోకండి.
ఇప్పుడు, నేను ఇప్పటికీ హార్డ్ 3 కోడ్, కానీ చేసిన కూడా 3 డైనమిక్ నుండి వస్తానని
యూజర్, లేదా argv, లేదా ఇష్టపడుతున్నారు.
సో ఈ ఇప్పటికే క్లీనర్ ఉంది.
>> కానీ ఈ గురించి బాధించే వార్తలు ఉంది ఇప్పుడు, అయినప్పటికీ ఒక పేరు ఏదో ఉంది
ప్రాథమికంగా లింక్ ఒక విద్యార్థి యొక్క house -
ఆ నేను నిజంగా ఒక విద్యార్థి సూచించడానికి కావలసిన -
నేను ఇప్పుడు సమాంతర రెండు శ్రేణుల కలిగి వారు ఉన్నట్లు అర్థంలో
అదే పరిమాణం, మరియు పేర్లు బ్రాకెట్ 0 ఇళ్ళు బ్రాకెట్ 0 బహుశా మాన,
మరియు పేర్లు బ్రాకెట్ 1 మాన గృహాల బ్రాకెట్ 1.
ఇతర మాటలలో, ఆ విద్యార్థి జీవితాలను ఇల్లు, మరియు ఇతర విద్యార్థి
ఇతర ఇంట్లో జీవితాలను.
కానీ తప్పనిసరిగా ఈ కావచ్చు మరింత సజావుగా పూర్తి.
>> బాగా, అది, నిజానికి.
మరియు నాకు ముందుకు వెళ్లి తెరవడానికి వీలు structs.h అప్, మరియు మీరు చేస్తాము
ఇక్కడ ఈ ఆలోచన చూడండి.
మీరు, నేను typedef ఉపయోగించి గమనించవచ్చు క్రితం డిక్లేర్ ఒక క్షణం పేర్కొన్నట్లు మా
సొంత డేటా రకం.
కానీ నేను కూడా ఈ ఇతర కీవర్డ్ ఉపయోగించి వెబ్ struct అని నాకు ఒక కొత్త ఇస్తుంది
డేటా నిర్మాణం.
>> మరియు నేను క్లెయిమ్ ఈ డేటాను నిర్మాణం కానుంది లోపలి రెండు విషయాల్లో
అది - పేరు అనే స్ట్రింగ్, మరియు ఇల్లు అనే స్ట్రింగ్.
మరియు నేను వెళుతున్నాను పేరు ఇవ్వాలని ఈ డేటాను నిర్మాణం కానుంది
విద్యార్థి అని పిలుస్తారు.
నేను, నేను మీరు ఏదైనా అని పిలుస్తాము కానీ ఈ పదానికి అర్థ విచారానికి తయారు
నా మనసు నాకు అంటుంది.
>> కాబట్టి ఇప్పుడు, నేను ఒక మంచి వెర్షన్ తెరుచుకుంటుంది ఉంటే కార్యక్రమం నేను రాయడం మొదలుపెట్టారు
అక్కడ, నాకు టాప్ స్క్రోల్ వీలు.
మరియు కోడ్ కొన్ని పంక్తులు వార్తలు ఇక్కడ, కానీ నాకు దృష్టి వీలు
ఒక క్షణం.
నేను ఒక స్థిరమైన పిలవబడే విద్యార్థులు డిక్లేర్డ్ చేసిన మరియు హార్డ్ ఇప్పుడు కోసం 3 కోడ్.
కానీ ఇప్పుడు, గమనించవచ్చు ఎలా శుభ్రంగా నా కోడ్ పొందడం ప్రారంభిస్తాడు.
>> లైన్ 22 లో, నేను డిక్లేర్ విద్యార్థులు శ్రేణి.
మరియు విద్యార్థి స్పష్టంగా ఉంది అని గుర్తించలేకపోతే ఇప్పుడు ఒక డేటా రకాన్ని.
ఈ ఫైలు యొక్క పైభాగంలో, గమనించవచ్చు ఎందుకంటే నేను ఆ శీర్షికా ఫైలును చేర్చాను
నేను ఒక క్షణం క్రితం ఆగింది ఆ.
మరియు ఆ శీర్షికా ఫైలును చాలా కేవలం కలిగి ఒక విద్యార్థి యొక్క ఈ నిర్వచనం.
>> కాబట్టి ఇప్పుడు, నేను నా స్వంత కస్టమ్ డేటా సృష్టించాను రకం ఆ C సంవత్సరాల రచయితలు
క్రితం ముందుగానే యొక్క నేను భావించలేదు.
కానీ సమస్య.
నన్ను నేను సమాధానపరుచుకుంటాను చేయవచ్చు.
సో ఈ, విద్యార్థులు అనే శ్రేణి దీని సభ్యులు ప్రతి
ఒక విద్యార్థి నిర్మాణం.
మరియు నేను ఆ మూడు అనుకుంటున్నారా అర్రే లో.
>> మరియు ఇప్పుడు, మిగిలిన దేనిని ఈ కార్యక్రమం యొక్క ఏమి?
నేను కొద్దిగా అనియత ఏదో అవసరం.
సో ఆన్లైన్ 24 నుండి, నేను 0 నుండి 3 iterate.
నేను వినియోగదారుని అభ్యర్థించడం విద్యార్థి యొక్క పేరు.
ఆపై నేను ముందు గా GetString ఉపయోగిస్తారు.
అప్పుడు నేను, విద్యార్థి యొక్క హౌస్ గోవా మరియు నేను ముందు గా GetString ఉపయోగించడానికి.
>> కానీ నోటీసు - కొద్దిగా కొత్త సింటెక్స్ ముక్క -
నేను, i-వ విద్యార్థి ఇప్పటికీ సూచిక చెయ్యవచ్చు కానీ నేను నిర్దిష్ట సమాచార ఎలా పొందుటకు లేదు
struct రంగంలో లోపల?
బాగా, స్పష్టంగా ఏమిటి కొత్త సింటెక్స్ ముక్క?
ఇది కేవలం డాట్ ఆపరేటర్లు వార్తలు.
>> మేము నిజంగా ఈ ముందు చూడని చేసిన.
మీరు మీరు pset ఐదు లో చూసిన బిట్మ్యాప్ ఫైళ్లు ఇప్పటికే లో dived.
కానీ డాట్ ఈ లోపలి అర్థం struct లేదా బహుళ ఖాళీలను, డాట్ ఇవ్వాలని
పేరు, లేదా నాకు డాట్ హౌస్ ఇవ్వాలని.
Struct లోపలి వెళ్లి అర్థం మరియు ఆ నిర్దిష్ట ఖాళీలను పొందుటకు.
>> ఈ కార్యక్రమం యొక్క మిగిలిన ఏమి చేస్తుంది?
ఇది అన్ని ఆ సెక్సీ కాదు.
నేను మళ్ళీ 0 నుండి 3 iterate గమనించవచ్చు, మరియు నేను కేవలం ఒక ఆంగ్ల సృష్టించడానికి
అదే విధంగా వంటి పదబంధం ఇటువంటి మరియు ఉంది నుండి డాట్ పేరు లో ప్రయాణిస్తున్న ఒక ఇల్లు,
i-వ విద్యార్థి మరియు వారి ఇల్లు అలాగే.
>> ఆపై చివరగా, ఇప్పుడు మేము పొందుటకు మొదలు పెడతారేమో మేము ఇప్పుడు ఈ గురించి అంగ,
ఏ malloc మరియు తెలిసిన ఇతర విధులు ఉన్నాయి
అన్ని ఈ సమయంలో చేయడం.
ఎందుకు నేను పేరు విముక్తికై కలిగి లేదు మరియు హౌస్, అయినప్పటికీ నేను
malloc కాల్ లేదు?
>> GetString చేసింది.
మరియు ఆ కోసం మురికి కొద్దిగా రహస్య ఉంది అనేక వారాల, కానీ GetString ఉంది
అన్ని పైగా మెమరీ రావడం జరిగింది ఇప్పటివరకు అన్ని సెమిస్టర్ ఉంచండి.
మరియు valgrand చివరకు అవుతుంది మాకు ఈ బహిర్గతం.
>> నాకు తెలుసు ఎందుకంటే కానీ అది ఒక పెద్ద ఒప్పందం కాదు నేను కేవలం పేరు విడిపించేందుకు చేసే
మరియు హౌస్, అయితే సాంకేతికంగా, కు సూపర్, సూపర్ సురక్షితంగా, నేను ఉండాలి
కొన్ని లోపం చేయడం ఇక్కడ తనిఖీ.
మీ కోరికలు నిన్ను ఏమి చెప్పడం ఉంటాయి?
నేను ఏమి తనిఖీ చేయాలి నేను ఒక ఏమిటి విడిపించేందుకు ముందు
స్ట్రింగ్, ఆక ఇది ఒక చార్ *?
>> నేను నిజంగా తనిఖీ చేయాలి విద్యార్థులు ఉంటే బ్రాకెట్ i డాట్ పేరు లేదు
సమాన శూన్య.
అప్పుడు ముందుకు మరియు ఉచిత వెళ్ళడానికి OK ఉంటాం ఆ పాయింటర్, మరియు ఒకేరకమైన లేదా ఇతర
ఒక అదే.
విద్యార్థులు బ్రాకెట్ i డాట్ హౌస్ లేకపోతే శూన్య సమానంగా, ఈ ఇప్పుడు రక్షించడానికి చేస్తుంది
మూలలో సందర్భంలో వ్యతిరేకంగా దీనిలో GetString శూన్య వంటి ఏదో తిరిగి.
మరియు మేము printf అవుతుంది, ఒక క్షణం క్రితం చూసింది కేవలం విధంగా ఇక్కడ మాకు అప్ రక్షించడానికి
నల్, ఇది అసహజ చూడండి కానుంది.
కానీ కనీసం అది segfault కాదు మేము చూసిన వంటి.
>> బాగా, నాకు ఇక్కడ ఒక ఇతర పనిని తెలపండి. structs-0 ఒక పెద్ద కార్యక్రమం రకం
నేను అన్ని ఈ డేటాను నమోదు, మరియు ఎందుకంటే కార్యక్రమం ముగుస్తుంది ఒకసారి కోల్పోయాడు.
కానీ నాకు ముందుకు వెళ్లి ఈ తెలియజేసేలా.
నాకు టెర్మినల్ తయారు చేద్దాము ఒక బిట్ పెద్ద విండో.
, నాకు structs-1 తయారు చేద్దాము ఇది ఈ కొత్త వెర్షన్.
>> నేను కొద్దిగా జూమ్ చేస్తాను.
మరియు ఇప్పుడు నాకు డాట్ అమలు తెలపండి structs-1 స్లాష్.
విద్యార్థి యొక్క పేరు -
డేవిడ్ మాథుర్, రాబ్ కిర్క్ల్యాండ్ చేయండి చేసుకుందాం లారెన్ Leverett చేయండి చేసుకుందాం.
ఏ ఆసక్తికరంగా ఇప్పుడు ప్రకటన -
మరియు నేను మాత్రమే ఈ ఎందుకంటే తెలుసు నేను కార్యక్రమం రాశారు -
ఒక ఫైలు నా ప్రస్తుత ఇప్పుడు ఉంది డైరెక్టరీ students.csv అని.
మీరు కొన్ని చూసిన ఉండవచ్చు వాస్తవ ప్రపంచంలో ఈ.
>> ఒక CSV ఫైల్ ఏమిటి?
విలువలు కామాతో వేరు.
ఇది ఒక పేదవాని వంటి విధమైన వార్తలు Excel ఫైల్ యొక్క వెర్షన్.
ఇది వరుసలు మరియు కాలమ్లను ఒక పట్టిక వార్తలు మీరు, Excel వంటి ప్రోగ్రామ్ తెరుస్తుంది
ఒక Mac లేదా సంఖ్యలు.
>> మరియు నేను gedit ఇక్కడ ఈ ఫైల్ను తెరవడం ఉంటే, నోటీసు - మరియు సంఖ్యలు లేవు.
అది చెప్పడం gedit యొక్క నాకు లైన్ సంఖ్యలు.
ఈ మొదటి పంక్తిలో గమనించండి ఫైలు డేవిడ్ మరియు మాథుర్ ఉంది.
తదుపరి లైన్ రాబ్ కామా కిర్క్ల్యాండ్ ఉంది.
మరియు మూడవ లైన్ లారెన్ ఉంది కామా Leverett.
>> సో నేను సృష్టించిన?
నేను ఇప్పుడు ఒక సి కార్యక్రమం వ్రాసిన చేసిన సమర్థవంతంగా స్ప్రెడ్షీట్లు రూపొందించవచ్చు
ఒక లో తెరవవచ్చు Excel వంటి కార్యక్రమ.
అన్ని ఉందనేందుకు ఒక డేటా సెట్, కానీ మీరు చాలా పెద్ద రాళ్లను కలిగి ఉంటే
మీరు నిజంగానే మీరు డేటా రెట్టింపు మరియు గ్రాఫ్లు మరియు తయారు
ఇష్టం, ఈ బహుశా ఒకటి ఆ డేటా మార్గం.
అంతేకాక, CSVs సాధారణ నిజానికి సూపర్ ఉన్నాయి కేవలం సాధారణ డేటా నిల్వ కోసం -
యాహూ ఫైనాన్స్, ఉదాహరణకు, మీరు పొందుటకు ఉంటే వారి అని పిలవబడే ద్వారా స్టాక్ కోట్స్
API, మీరు అనుమతించే ఉచిత సేవ ప్రస్తుత అప్ టు డేట్ స్టాక్ పొందుటకు
కంపెనీలకు కోట్స్, వారు తిరిగి లో డేటా ఇవ్వాలని
సూపర్ సాధారణ CSV ఫార్మాట్.
>> కనుక మనం ఎలా చేస్తారు?
బాగా, ఈ కార్యక్రమం యొక్క అత్యంత గమనించవచ్చు దాదాపు అదే.
కానీ ఇక్కడ డౌన్ గమనించవచ్చు కాకుండా ముద్రణ లైన్ 35 న విద్యార్థులు అవ్ట్,
తరువాత, నేను సేవ్ వెబ్ వాదించారు డిస్కునకు విద్యార్థులు, కాబట్టి ఒక ఫైల్ సేవ్.
>> నేను ఒక ఫైల్ * ప్రకటించారు వెబ్ గమనించవచ్చు -
ఇప్పుడు, ఈ C. ఒక అసాధారణ విధమైన ఏ కారణం చేతనైనా సరే, FILE, అన్ని పరిమితులను ఉంది
ఇది అనేక ఇతర డేటా రకాలుగా కాదు సి లో అయితే ఇది ఒక అంతర్నిర్మిత
డేటా రకం, FILE *.
మరియు నేను ఒక ఫైల్ కు ఒక పాయింటర్ ప్రకటించారు వెబ్ మీరు భావించి ఎలా ఉంది.
>> fopen ఓపెన్ ఫైలు అర్థం.
మీరు ఏమి ఫైలు తెరవడానికి అనుకుంటున్నారు?
నేను ఒక ఫైల్ తెరవాలనుకుంటున్నారా రెడీ అని ఏకపక్ష students.csv కాల్.
నేను కావలసిన ఏదైనా అని పిలుస్తాము.
>> ఆపై ఒక అంచనా పడుతుంది.
రెండవ వాదన వేటికి fopen బహుశా అర్థం?
కుడి, write కోసం w, అనుకొనుట రీడ్ కోసం r ఉంటుంది.
ఒక append కోసం ఉంది మీరు వరుసలు మరియు జోడించాలనుకుంటే
మొత్తం విషయం తిరిగి రాస్తుంది.
>> కానీ నేను ఈ ఫైలు సృష్టించాలనుకునే ఒకసారి, నేను కోట్ unquote w ఉపయోగిస్తాము.
మరియు నేను కలిగి నుండి మాత్రమే తెలుసు డాక్యుమెంటేషన్, లేదా వ్యక్తి పేజీ.
ఫైలు శూన్య లేకపోతే - ఇతర పదాలు లో, ఏమీ తప్పు ఉంటే -
నేను iterate వీలు 0 నుండి 3 విద్యార్థులు.
>> మరియు ఇప్పుడు ఏదో గమనించవచ్చు ఇంత కొద్దిగా వివిధ
ఇక్కడ గురించి లైన్ 41.
ఇది printf కాదు.
ఇది printf ఫైలు కోసం fprintf వార్తలు.
కనుక ఇది ఫైల్కు వ్రాయడం అవకాశముంది.
ఏ ఫైల్?
దీని పాయింటర్ మీరు పేర్కొన్న ఒక మొదటి వాదన వంటి.
>> అప్పుడు మేము ఒక ఫార్మాట్ స్ట్రింగ్ పేర్కొనండి.
అప్పుడు మేము ఏమి పదాన్ని సూచించండి మొదటి శాతం s కోసం ప్లగ్, మరియు
అప్పుడు మరొక వేరియబుల్ లేదా రెండవ శాతం లు.
అప్పుడు మేము fclose ఫైల్ ముగించలేదు.
నేను అయితే, ముందు మెమరీ విడిపించేందుకు కంటే నేను తిరిగి వెళ్లి జోడించండి ఉండాలి
శూన్య కోసం కొన్ని తనిఖీలను.
>> అంతే.
fopen, fprintf, fclose నాకు ఇస్తుంది టెక్స్ట్ ఫైళ్లు సృష్టించడానికి సామర్ధ్యం.
ఇప్పుడు, మీరు, ప్రాబ్లం సెట్ ఐదు చూస్తారు చిత్రాలు ఉండే, మీరు ఉపయోగిస్తున్న అవుతారు
బైనరీ ఫైళ్ళను బదులుగా.
కానీ ప్రాథమికంగా, ఆలోచన, అదే ఉంది అయినప్పటికీ మీరు చేస్తాము విధులు
కొద్దిగా భిన్నంగా ఉంటాయి చూడండి.
>> సుడిగాలి పర్యటన సో, కానీ మీరు పొందుతారు ఫైలు అన్ని చాలా తెలిసిన I/O--
ఇన్పుట్ మరియు అవుట్పుట్ - pset ఐదు తో.
మరియు గురించి ఏవైనా ప్రశ్నలు ఇక్కడ ప్రారంభ బేసిక్స్?
అవును?
>> మీరు ఒక శూన్య విలువను విముక్తికై ప్రయత్నించండి ఉంటే?
ఉచిత ఒక సంపాదించిన చేసింది తప్ప, నమ్మకం కొంచం user-friendly, మీరు చేయవచ్చు
శక్తివంతమైన segfault.
నాదగ్గర ఎందుకంటే శూన్యం ప్రయాణిస్తున్న చెడు ఉచిత నమ్మకం, మీరు కోసం తనిఖీ bothers
ఇది సమర్ధంగా ఒక వ్యర్థాలు ఉంటుంది ఎందుకంటే అది కూడా చేయాలని సమయం
ప్రపంచంలో ప్రతి ఒక్కరూ.
మంచి ప్రశ్న, అయితే.
>> అన్ని కుడి, ఈ రకమైన గెట్స్ కాబట్టి మాకు ఒక ఆసక్తికరమైన అంశం.
సమస్య సెట్ థీమ్ ఐదు ఫోరెన్సిక్స్ ఉంది.
కనీసం ఒక భాగం యొక్క సమస్య సెట్.
ఫోరెన్సిక్స్ సాధారణంగా సూచిస్తుంది మే లేదా సమాచారాన్ని రికవరీ
తొలగించబడ్డాయి పోవచ్చు ఉద్దేశపూర్వకంగా.
అందువలన నేను మీరు త్వరగా ఇవ్వాలని ఇష్టం ఆలోచన ఏమి రుచి నిజంగా అన్ని జరుగుతుందో
క్రింద ఈ సమయం మీ కంప్యూటర్ యొక్క హుడ్.
>> ఉదాహరణకు, మీరు లోపల కలిగి ఉంటే మీ యొక్క ల్యాప్టాప్ లేదా మీ డెస్క్టాప్ కంప్యూటర్
హార్డు డ్రైవు, అది ఒక యాంత్రిక వార్తలు నిజానికి తిప్పే పరికరం -
platters అని వృత్తాకార విషయాలను చాలా ఆ కనిపిస్తుంది నేను
కేవలం అయితే, ఇక్కడ స్క్రీన్ మీద ఉంది ఈ పెరుగుతున్న పాత పాఠశాల.
ఈ మూడు మరియు-a-సగం అంగుళాల ఉంది హార్డు డ్రైవు.
మరియు మూడు మరియు ఒక అర్ధ అంగుళాలు యొక్క సూచిస్తుంది మీరు ఇన్స్టాల్ చేసినప్పుడు విషయం తో
ఒక కంప్యూటర్ లో.
>> ఇప్పుడు మీ ల్యాప్టాప్లో మీరు అనేక అబ్బాయిలు , సాలిడ్ స్టేట్ డ్రైవ్, లేదా SSDs కలిగి
ఇది కదిలే భాగాలను లేవు.
వారు RAM వంటి మరింత మరియు తక్కువ లాగ ఉన్నాము ఈ యాంత్రిక పరికరాలు.
కానీ ఆలోచనలు, ఇప్పటికీ ఒకటే ఖచ్చితంగా వారు సంబంధించి
సమస్య ఐదు సెట్.
>> మరియు మీరు ఒక హార్డ్ డ్రైవ్ ప్రస్తుతం సుమారు అనుకుంటే ఇది ఒక వృత్తం, ఉండటం ప్రాతినిధ్యం
నేను ఇక్కడ ఇలా డ్రా చేస్తాము.
మీరు, మీ కంప్యూటర్లో ఒక ఫైలు రూపొందించినప్పుడు అది ఒక SSD, లేదా లో లేదో
ఈ సందర్భంలో, పాత పాఠశాల హార్డు డ్రైవు, ఫైల్ బహుళ బిట్స్ ఉన్నాయి.
యొక్క ఈ 0 మరియు 1 అని చెప్పటానికి వీలు, 0 సె మరియు 1s యొక్క మొత్తం బంచ్.
సో ఈ నా మొత్తం హార్డ్ డ్రైవ్.
ఈ స్పష్టంగా ఒక అందమైన పెద్ద ఫైలు.
మరియు ఆ వద్ద 0 సె మరియు 1s అప్ ఉపయోగిస్తోంది భౌతిక పళ్ళెం యొక్క భాగం.
>> బాగా, భౌతిక భాగం ఏమిటి?
బాగా, అది ఒక హార్డ్ డ్రైవ్ ఆ హాజరవుతారు ఈ రకం కనీసం, ఉంది
ఈ చిన్న చిన్న అయస్కాంత అణువులు.
మరియు అవి చాలా ఉత్తర మరియు వారికి దక్షిణ ధ్రువాలు, తద్వారా మీరు
ఆ అయస్కాంత అణువులు ఒకటి చెయ్యి ఈ విధంగా, మీరు అది చెప్పుకునే
ఒక 1 ప్రాతినిధ్యం.
మరియు అది తలక్రిందులుగా దక్షిణాన ఉంటే ఉత్తర, మీరు అది చెప్పుకునే
ఒక 0 ప్రాతినిధ్యం.
>> సో నిజమైన భౌతిక ప్రపంచం లో, ఆ మీరు ఏదో ప్రాతినిధ్యం వహిస్తుంది ఎలా
బైనరీ 0 రాష్ట్ర మరియు ఒక 1.
తద్వారా అన్ని ఫైలు యొక్క.
అయస్కాంత యొక్క మొత్తం బంచ్ ఉంది వారి ఈ విధంగా లేదా అని కణాలు
ఈ విధంగా, సృష్టించడం నమూనాలను యొక్క 0s మరియు 1s.
>> కానీ, మీరు ఒక ఫైల్ సేవ్ చేసినప్పుడు హాజరవుతారు కొన్ని సమాచారం విడివిడిగా సేవ్ చేయబడుతుంది.
సో ఈ, కొద్దిగా పట్టిక ఉంది ఒక డైరెక్టరీ మాట్లాడటానికి.
మరియు నేను ఈ కాలమ్ పేరు కాల్, మరియు ఉంటాం నేను ఈ కాలమ్ నగర కాల్ చేస్తాము.
>> మరియు నేను ఊహించు, చెప్పటానికి వెళుతున్నాను ఈ నా పునఃప్రారంభం ఉంది.
నా resume.doc వద్ద నిల్వ ఉంది నగర, 123 చెప్పటానికి చేసుకుందాం.
నేను ఎల్లప్పుడూ ఆ సంఖ్యను కోసం వెళ్ళి.
కానీ కేవలం ఇష్టం అని అది తగినంత RAM లో, మీరు హార్డు డ్రైవు పట్టవచ్చు
ఒక గిగాబైట్ లేదా 200 గిగాబైట్ల వార్తలు లేదా ఒక టెరాబైట్, మరియు మీరు చెయ్యగలరు
సంఖ్య బైట్లు అన్ని.
మీరు 8 బిట్స్ అన్ని భాగాలు సంఖ్య చేయవచ్చు.
>> కాబట్టి మేము ఈ చెప్పటానికి చేస్తాము నగర 123 ఉంది.
నా ఆపరేటింగ్ ఈ డైరెక్టరీ లోపల సిస్టమ్ గుర్తు నా
పునఃప్రారంభం నగర 123 వద్ద ఉంది.
కానీ ఎప్పుడు ఆసక్తికరమైన గెట్స్ మీరు ఒక ఫైల్ను మీరు తొలగించాలని.
>> ఉదాహరణకు సో -
మరియు అదృష్టవశాత్తూ, ప్రపంచంలో చాలా ఉంది ఈ లో ఆకర్షించింది - ఏమి జరుగుతుంది
మీరు మీ Mac OS ట్రాష్కు ఒక ఫైల్ డ్రాగ్ లేదా మీ Windows రీసైకిల్ బిన్?
ఆ చేయడం వలన ప్రయోజనం ఏమిటి?
ఇది, ఫైలు వదిలించుకోవటం ఖచ్చితంగా ఉంది కానీ ఏమి డ్రాగ్ చర్య చేస్తుంది మరియు
మీ ట్రాష్ లేదా లోకి పడిపోయింది మీ రీసైకిల్ బిన్ ఒక కంప్యూటర్లో చేయాలని?
>> నిజంగా ఖచ్చితంగా ఏమీ.
ఇది కేవలం ఒక ఫోల్డర్ వంటిది.
ఇది తప్పకుండా ఒక ప్రత్యేక ఫోల్డర్ యొక్క.
అయితే ఫైల్ను తొలగించి లేదు?
>> ఏ, బాగా, ఎందుకంటే మీరు బహుశా కొన్ని వంటి ఉన్నాయి, తిట్టు OH, మీరు కాదు
అలా అని అర్థం.
సో మీరు డబుల్ క్లిక్ ట్రాష్ లేదా రీసైకిల్ బిన్.
మీరు చుట్టూ ఎత్తిచూపారు మరియు మీరు కోలుకొని చేసిన కేవలం డ్రాగ్ చేసి ఫైలు
అక్కడ నుండి.
నుంచే, అది తప్పనిసరిగా కాదు తొలగించి.
>> OK, మీరు తెలివిగా కంటే ఉన్నాము.
మీకు తెలిసిన ఆ కేవలం డ్రాగ్ ట్రాష్ లేదా రీసైకిల్ బిన్ కాదు
మీరు ఖాళీ చేస్తున్నారు.
సో మీరు అప్ మెనూ కు వెళ్ళండి, మరియు మీరు చెప్పే ట్రాష్ను ఖాళీ లేదా ఖాళీ రీసైకిల్ బిన్.
అప్పుడు ఏమి జరుగుతుంది?
>> అవును, కాబట్టి అది మరింత కాబట్టి తొలగించబడుతుంది.
కానీ జరిగే అన్ని ఈ.
కంప్యూటర్ పేరు మర్చిపోతోంది resume.doc ఉంది.
>> కానీ ఏమి స్పష్టంగా మార్చలేదు చిత్రంలో?
బిట్స్, నేను ప్రకటిస్తున్నారు 0 సె మరియు 1s ఉన్నాయి కొన్ని భౌతిక అంశం సైట్ న
హార్డ్వేర్.
వారు ఇప్పటికీ ఉన్నారు.
ఇది కేవలం కంప్యూటర్ ఉంది మర్చిపోయారు ఏమి వారు.
>> కనుక ఇది తప్పనిసరిగా విముక్తి యొక్క ఫైలు యొక్క వారు తిరిగి ఉపయోగించ తగినవి బిట్స్ కనుక.
కానీ మీరు, మరింత ఫైళ్లను రూపొందిస్తుంది వరకు మరియు మరిన్ని ఫైళ్ళను, మరియు మరిన్ని ఫైళ్ళను అవుతుంది
చాలా మటుకు, ఆ 0 సె మరియు 1s, ఆ అయస్కాంత అణువులు, మళ్లీ ఉపయోగించబడదు చేసుకోగా,
కోసం పైకి లేదా కుడి వైపున అప్, ఇతర ఫైళ్లు, 0 సె మరియు 1s.
>> సో మీరు సమయం ఈ విండో కలిగి.
మరియు అది ఊహాజనిత యొక్క కాదు పొడవు, నిజంగా.
ఇది మీ హార్డ్ యొక్క పరిమాణం మీద ఆధారపడి ఉంటుంది డ్రైవ్ మరియు ఎన్ని ఫైళ్లు మీరు మరియు
ఎంత త్వరగా మీరు కొత్త వాటిని తయారు.
కానీ సమయం ఈ విండో సమయములో ఉంది ఫైల్ సంపూర్ణ ఇప్పటికీ ఇది
వెలికి.
>> మీరు ఎప్పుడైనా McAfee వంటి కార్యక్రమాలు ఉపయోగించడానికి కనుక లేదా నార్టన్ తిరిగి ప్రయత్నించండి
డేటా, వారు చేస్తున్న అన్ని ప్రయత్నిస్తున్నారు ఈ అని పిలవబడే డైరెక్టరీకి తిరిగి
మీ ఫైలు అక్కడ అవ్ట్ దొరుకుతుందని.
మరియు కొన్నిసార్లు నార్టన్ మరియు, పలుకును ఫైలు 93% దీనిని పునరుద్ధరించడం సాధ్యంకాదు.
బాగా, ఆ అర్థం ఏమిటి?
కేవలం అర్థం కొన్ని ఇతర ఫైలు యాదృచ్చికంగా, చెప్పటానికి, ఉపయోగించి ఇచ్చాను
మీ అసలు ఫైల్ నుండి ఆ బిట్స్.
>> సో నిజానికి ఏమి చేరి ఉంది డేటా కోలుకుంటూ?
బాగా, మీరు ఏదో లేకపోతే నార్టన్, మీ కంప్యూటర్లో ముందు ఇన్స్టాల్
మీరు కొన్నిసార్లు చేయవచ్చు ఉత్తమ చూడండి ఉంది మొత్తం హార్డ్ డ్రైవ్ కోసం చూస్తున్న వద్ద
బిట్స్ క్రమాలు.
మరియు సమస్య సెట్ మూలాల్లో ఒకటి ఐదు మీరు శోధిస్తుంది ఉంది
హార్డు డ్రైవు యొక్క సమానమైన, ఒక ఫోరెన్సిక్ ఒక నుండి ఒక కాంపాక్ట్ ఫ్లాష్ కార్డ్ చిత్రం
0 సె శోధించడం డిజిటల్ కెమెరా, అధిక ఆ సాధారణంగా మరియు 1s,
సంభావ్యత, ప్రాతినిధ్యం ఒక చిత్రం యొక్క మొదలు.
>> మరియు మీరు అబ్బాయిలు ద్వారా చిత్రాలను పునరుద్ధరించవచ్చు నేను ఈ నమూనా చూడండి ఉంటే, ఊహిస్తూ
ఫోరెన్సిక్ చిత్రంపై బిట్స్ తో మార్క్స్ అధిక సంభావ్యత,
ఒక JPEG ప్రారంభంలో.
మరియు నేను మళ్ళీ అదే నమూనా చూడండి ఉంటే, ఆ బహుశా ప్రారంభంలో మార్క్స్
మరొక JPEG, మరియు మరొక JPEG, మరియు మరొక JPEG.
మరియు ఇది సాధారణంగా ఎలా డేటా రికవరీ పని చేస్తుంది.
ఏ JPEGs గురించి nice వార్తలు అయినప్పటికీ ఉంది ఫైల్ ఫార్మాట్ కూడా కొంతవరకు ఉంది
ప్రతి యొక్క క్లిష్టమైన, ప్రారంభంలో ఫైలు నిజానికి చాలా గుర్తించదగిన
, మీరు చూస్తారు గా, మరియు సాధారణ మీరు ఇప్పటికే ఉంటే.
>> సో యొక్క కింద దగ్గరగా పరిశీలించి లెట్ కూడా సరిగ్గా ఏమి హుడ్
జరగబోతోంది, మరియు ఈ 0s మరియు 1s ఏమి మీరు ఒక ఒక బిట్ మరింత ఇవ్వాలని, ఉన్నాయి
ఈ ప్రత్యేక సవాలు సందర్భం.
>> [వీడియో ప్లేబ్యాక్]
>> మీ PC అత్యంత నిల్వ-ఎక్కడ దాని శాశ్వత డేటా.
ఇలా చేయాలంటే, డేటా RAM నుండి ప్రయాణిస్తుంది చెప్పే సాఫ్ట్వేర్ సంకేతాలు పాటు
ఆ సమాచారాన్ని నిల్వచేయటానికి హార్డ్ డ్రైవ్.
హార్డు డ్రైవు సర్క్యూట్లు అనువాదం వోల్టేజ్ లోకి ఆ సంకేతాలను
ఒడిదుడుకులు.
ఈ, అందుకు ప్రతిగా, హార్డ్ డ్రైవ్ యొక్క నియంత్రణ కదిలే భాగాలు, కొన్ని కొన్ని
మిగిలి కదిలే భాగాలు ఆధునిక కంప్యూటర్.
>> సిగ్నల్స్ కొన్ని వాహనాల నియంత్రణ ఇది మెటల్ పూత platters తిప్పుతుంది.
మీ డేటా నిజానికి నిల్వ ఉంది ఈ platters న.
ఇతర సంకేతాలను చదవండి / వ్రాయండి తరలించడానికి చదవడానికి లేదా తలలు
platters డేటా వ్రాయండి.
ఈ యంత్రాలు కాబట్టి ఖచ్చితమైన ఒక మానవ అని జుట్టు కూడా మధ్య పాస్ కాలేదు
తలలు మరియు స్పిన్నింగ్ platters.
ఇంకా, ఇది అన్ని అద్భుతమైన వేగంతో పనిచేస్తుంది.
>> [END వీడియో ప్లేబ్యాక్]
>> DAVID మలన్: కొద్దిగా జూమ్ లోతుగా ఇప్పుడు ఏమి వద్ద
నిజానికి ఆ platters న.
>> [వీడియో ప్లేబ్యాక్]
>> యొక్క చూడండి-లెట్ మేము కేవలం వద్ద స్లో మోషన్ లో చూసింది.
విద్యుత్ సంక్షిప్త పల్స్ ఉన్నప్పుడు ఎగరవేసిన ప్రతిసారి ఉంటే, / వ్రాసే తల పంపిన
ఒక చిన్న విద్యుదయస్కాంత న రెండవ యొక్క ఒక భిన్నం.
అయస్కాంతం ఇది ఒక రంగంలో, సృష్టిస్తుంది మార్పులు చిన్న, చిన్న యొక్క ధ్రువణత
మెటల్ కణాల భాగం ఇది కోటు ప్రతి పళ్ళెం ఉపరితల.
>> ఈ చిన్న నమూనా సిరీస్, డిస్క్ వసూలు అప్ ప్రాంతాల్లో
ఒకే బిట్ ప్రాతినిధ్యం బైనరీ సంఖ్య డేటా
కంప్యూటర్లు ఉపయోగించబడుతుంది.
ఇప్పుడు, ప్రస్తుత పంపినా ఒక మార్గం రీడ్ ద్వారా / ప్రాంతం తల వ్రాయండి
ఒక దిశలో ధృవీకరణం ఉంది.
ప్రస్తుత లో పంపినా వ్యతిరేక దిశలో,
ధ్రువిత తిరగబడుతుంది.
>> మీరు హార్డు డిస్కు ఆఫ్ డేటా ఎంత?
కేవలం ప్రక్రియ రివర్స్.
కనుక ఇది డిస్క్ కణాలు వార్తలు ఎందుకంటే ప్రస్తుతం పొందుటకు
తల కదిలే / వ్రాసే.
ఈ మిలియన్ల కూర్చు అయస్కాంతము భాగాలు, మరియు
మీరు ఒక ఫైల్ వచ్చింది చేసిన.
>> ఇప్పుడు, ఒక ఫైలు యొక్క ముక్కలు చేయవచ్చు అన్ని డ్రైవ్ యొక్క మైదానాల్లో అవుతుంది
గజిబిజి వంటి రకమైన platters, మీ డెస్క్ మీద పత్రాలు.
సో ఒక ప్రత్యేక అదనపు ఫైల్ ట్రాక్ ప్రతిదీ ఇక్కడ.
మీరు కలిగి అనుకుంటున్నారా లేదు అలాంటిదే?
>> [END వీడియో ప్లేబ్యాక్]
>> DAVID మలన్: OK, బహుశా.
సో ఎలా మీరు అనేక అబ్బాయిలు ఈ తో కలిసి పెరిగాను?
OK, కాబట్టి అది తక్కువ వార్తలు చేతులు ప్రతి సంవత్సరం.
కానీ, నేను మీరు కనీసం తెలిసి సంతోషించిన రెడీ! వారితో, ఈ ఎందుకంటే మరియు మా సొంత
పుస్తకం డెమో, పాపం, చాలా చస్తున్నామని పరిచయాన్ని ఇక్కడ మరణం తగ్గించి.
>> కానీ ఈ కనీసం తిరిగి, నేను ఉంది ఉన్నత పాఠశాల, బ్యాకప్ కోసం ఉపయోగిస్తారు ఉపయోగం.
మరియు అది అద్భుతమైన ఉంది, ఎందుకంటే మీరు న 1.4 మెగాబైట్ల నిల్వ చేసుకోవచ్చు
ఈ ప్రత్యేక డిస్కు.
మరియు ఈ, అధిక సాంద్రత వెర్షన్ గా ఇది HD, సూచించిన
నేటి HD వీడియోలను ముందు అర్థం.
>> ప్రామాణిక సాంద్రత 800 కిలోబైట్ల ఉంది.
మరియు ఆ ముందు, ఉన్నాయి 400 కిలోబైట్ డిస్కులను.
మరియు ఆ ముందు, 5 మరియు 1/4 ఉన్నాయి నిజంగా ఫ్లాపీ ఉన్నాయి ఇది అంగుళాల డిస్కులు,,
మరియు కొద్దిగా విస్తృత మరియు పొడవుగా ఇక్కడ ఈ విషయాల కంటే.
కానీ మీరు నిజంగా పిలవబడే చూడగలరు ఈ డిస్కుల ఫ్లాపీ కారక.
>> మరియు పనితీరు వారు నిజానికి ఉన్నాము వద్ద హార్డ్ డ్రైవ్లకు అందంగా ఇదే
కనీసం ఈ రకం.
కొత్త కంప్యూటర్లు మళ్లీ SSDs విభిన్నంగా కొద్దిగా పని.
కానీ మీరు చిన్న మెటల్ ను తరలించు ఉంటే, మీరు నిజంగానే, కొద్దిగా కుకీ చూడగలరు
లేదా పళ్ళెం.
>> ఈ ఒక వంటి మెటల్ కాదు.
ఈ ఒక నిజంగా కొన్ని తక్కువ వార్తలు పదార్థం ప్లాస్టిక్.
మరియు మీరు విగ్లే ఇది రకం చేయవచ్చు.
మరియు మీరు trully కొన్ని ఆఫ్ కనుమరుగవుతుంది చేసిన బిట్స్ లేదా అయస్కాంత కణాల సంఖ్య
ఈ డిస్కు నుండి.
>> సో అదృష్టవశాత్తూ, అది ఏమీ లేదు.
ఆ విషయం విధంగా ఉంటే - మరియు కవర్ మీ కళ్ళు మరియు మీ పొరుగు యొక్క ఆ -
కేవలం రకమైన ఈ లాగండి మీరు చేయవచ్చు ఆ వంటి మొత్తం కోశం ఆఫ్.
కానీ కొద్దిగా వసంత, దాంతో ఉంటుంది మీ కళ్ళు ఆ తెలుసు.
కాబట్టి ఇప్పుడు మీరు నిజంగా ఒక ఫ్లాపీ డిస్కు.
>> మరియు ఈ గురించి గొప్ప వార్తలు ఈ ఉంది అని చాలా ఉంది ఒక
ఒక పెద్ద చిన్న తరహా ప్రాతినిధ్యం హార్డు డ్రైవు, ఈ విషయాలు, సూపర్ ఉన్నాయి
సూపర్ సాధారణ.
మీరు ఇప్పుడు, అది దిగువన చిటికెడు, ఆ ఆ మెటల్ విషయం ఆఫ్ వార్తలు, మరియు తొక్క
వాటిని తెరవడానికి, ఉంది అన్ని రెండు ముక్కలు ఉంది భావించాడు మరియు అని పిలవబడే ఫ్లాపీ డిస్క్
లోపల మెటల్ ఒక ముక్క తో.
>> మరియు సగం అక్కడ వెళ్తాడు నా డిస్క్ యొక్క విషయాలను.
వాటిని మరొక సగం ఉన్నాయి వెళ్తాడు.
కానీ ఆ లోపల తిరుగుతూ ఆ అన్ని వార్తలు ఒకప్పటి మీ కంప్యూటర్ యొక్క.
>> మళ్ళీ, దృష్టికోణం ఈ ఉంచాలి ఎలా పెద్దది మీ అత్యంత
హార్డ్ ఈ రోజుల్లో వెళ్ళే?
500 గిగాబైట్ల, ఒక టెరాబైట్, ఉండవచ్చు లో ఒక డెస్క్టాప్ కంప్యూటర్, 2 టెరాబైట్ల, 3
టెరాబైట్ల, 4 టెరాబైట్ల, కుడి?
ఈ ఒక మెగాబైట్ ఉంది, ఇవ్వాలని లేదా పడుతుంది కూడా ఒక సాధారణ MP3 సరిపోవు ఇది
ఇకపై ఈ రోజుల్లో, లేదా కొన్ని ఇలాంటి సంగీతం ఫైలు.
>> సో కొద్దిగా మీరు కోసం స్మారక నేడు, మరియు కూడా ఏమి contextualize సహాయం
మేము మంజూరు కోసం తీసుకొని వస్తారు ఇప్పుడు సమస్య ఐదు సెట్.
సో ఆ ఉంచాలని మీదే ఉన్నాయి.
సో ఉంటుంది పేరు నాకు బదిలీ వీలు తదుపరి pset ఖర్చు అలాగే.
కనుక మనం ఇప్పుడు ఈ పేజీ సెట్ చేసిన - ఓహ్, త్వరగా ప్రకటనలు జంట.
>> ఈ శుక్రవారం, మీరు అని CS50 చేరడానికి అర్హత కోసం, సాధారణ స్థానంలో వెళ్ళండి
cs50.net/rsvp.
తుది ప్రణాళిక -
కాబట్టి సిలబస్ ప్రకారం, పోస్ట్ చేసిన ఇప్పటికే ఫైనల్ ప్రాజెక్ట్ వివరణ.
అర్థం అని తెలుసుకోవటం ఇది ముఖ్యంగా వెంటనే వలన.
ఇది కేవలం పొందుటకు, నిజంగా, పోస్ట్ చేసిన మీరు అబ్బాయిలు దాని గురించి ఆలోచిస్తూ.
నిజానికి, ఒక సూపర్ ముఖ్యమైన మీరు శాతం పరిష్కారంలో ఉంటుంది
అంశంపై తుది ప్రాజెక్టులు మేము కూడా తరగతి లో సంపాదించిన లేదు,
కానీ తరువాత వారం అవుతుంది.
>> నోటీసు, అయితే, వివరాలను పిలుపు ఆ కొన్ని వివిధ భాగాలు
చివరి ప్రాజెక్ట్.
మొదటి, కొన్ని వారాల లో, ఒక ముందు ప్రతిపాదన, ఒక అందమైన సాధారణం ఇమెయిల్
మీ అతనికి చెప్పాల్సి TF లేదా ఏమి మీరు తో, మీ ప్రాజెక్ట్ కోసం గురించి ఆలోచిస్తూ
ఏ నిబద్ధత.
ప్రతిపాదన మీ ఉంటుంది నిబద్ధత, మాట్లాడుతూ, ఇక్కడ, ఈ ఏమిటి
నేను నా ప్రాజెక్ట్ కోసం చేయాలని భావిస్తున్న.
మీరు ఏమి ఆలోచిస్తాడు?
చాలా పెద్దది?
చాలా చిన్న?
ఇది నిర్వహించటానికి ఉంది?
మరియు మీరు మరిన్ని వివరాలకు చూడండి.
>> వారాల జంట ఆ తర్వాత స్థితి ఇదే ఇది నివేదిక,
ఎంత చెప్పటానికి మీ TF కు సాధారణం ఇమెయిల్ మీరు మీ చివరి ఉన్నాయి కంటే
తరువాత ప్రాజెక్ట్ యొక్క అమలు, CS50 Hackathon ఏ ఒక్కరూ
ఆహ్వానించారు ఉంది, ఒక సంఘటన ఉంటుంది 7:00 వరకు ఒక సాయంత్రం 8:00 PM
మరుసటి రోజు పోస్ట్.
నేను వారంలో చెప్పిన విధంగా పిజ్జా, సున్నా, విల్, 9:00 గంటలకు వడ్డిస్తారు
1:00 వద్ద చైనీస్ ఆహార పోస్ట్.
మరియు మీరు 5:00 వద్ద ఇప్పటికీ మేలుకొని అయితే పోస్ట్, మేము అల్పాహారం కోసం IHOP కి తీసుకొని వెళ్తాము.
>> సో Hackathon మరింత ఒకటి తరగతి లో గుర్తుండిపోయే అనుభవాలు.
అప్పుడు అమలు కారణంగా, మరియు అప్పుడు పతాక CS50 ఫెయిర్.
ఈ అన్ని మరిన్ని వివరాలకు వారాల వచ్చిన.
>> కానీ కొంత తిరిగి వెళ్ళి తెలపండి పాత పాఠశాల -
మళ్ళీ, వ్యూహం.
ఇది పరిష్కరిస్తుంది ఎందుకంటే సో వ్యూహం, nice ఉంది మేము వంటి సమస్యలు కేవలం ఒక చూసింది
విద్యార్థి నిర్మాణాలు క్రితం క్షణం నియంత్రణ కొద్దిగా అవుట్ ఉంటే మేము
విద్యార్థి ఒక విద్యార్ధి రెండు, కలిగి అనుకుంటున్నారా విద్యార్థి మూడు, విద్యార్థి డాట్ డాట్ డాట్,
కొంతమంది విద్యార్ధులు అనియత సంఖ్య.
>> శ్రేణుల సో, కొన్ని వారాల క్రితం, లో swooped మరియు పరిష్కరించాడు మా సమస్యలు కాదు అన్ని
ముందుగానే తెలుసుకోవడం ఎన్ని విషయాలు కొన్ని రకం మేము కావలసిన ఉండవచ్చు.
మరియు మేము structs మాకు సహాయపడే చూసిన మరింత మా కోడ్ నిర్వహించడానికి మరియు ఉంచడానికి
ఒక వంటి సందర్భానుసారంగా పోలి వేరియబుల్స్ పేరు మరియు ఒక ఇల్లు, కలిసి, తద్వారా మేము
లోపల ఒక పరిధి, వాటిని చికిత్స చేయవచ్చు ఇది చిన్న ముక్కలు ఉన్నాయి.
>> కానీ శ్రేణుల కొన్ని లోపాలు ఉన్నాయి.
లోపాలు ఏమిటి మేము ఎదుర్కొన్న
శ్రేణితో ఇప్పటివరకు?
ఆ ఏమిటి?
స్థిర పరిమాణం - కాబట్టి మీరు వాటిని అయితే ఒక కోసం మెమరీని కేటాయించాల్సిన చెయ్యగలరు
అర్రే, మీకు ఎన్ని విద్యార్థులు మీరు ఎన్ని అక్షరాలు కలిగి
యూజర్ నుండి, మీరు కేటాయించిన చేసిన అర్రే, మీరు రకమైన పెయింట్ చేసిన
ఒక మూలలో మీ.
>> మీరు కొత్త అంశాలు ఇన్సర్ట్ ఎందుకంటే వ్యూహం మధ్యలో.
మీరు మరిన్ని అంశములు చేర్చలేరు ఒక అర్రే యొక్క ముగింపు వద్ద.
నిజంగా, మీరు ఒక సృష్టించడం ఆశ్రయించాల్సిన ఉంటుంది మేము చర్చించిన చేసిన వంటి సరికొత్త వ్యూహం,
నూతన పాత కాపీ.
మళ్ళీ, ఆ తలనొప్పి అని మీరు కోసం వ్యవహరించే GetString.
>> కానీ మళ్ళీ, మీరు కూడా చేర్చలేరు అర్రే యొక్క మధ్యలో ఏదో
రేటు పూర్తిగా నిండి లేదు ఉంటే.
ఉదాహరణకు, ఈ శ్రేణి ఇక్కడ పరిమాణం ఆరు మాత్రమే, అది ఐదు అంశాలు ఉన్నాయి
బాగా, మీరు కేవలం అమరిక అనుకొనుట ముగింపు లో ఏదో.
కానీ మీరు ఏదో ఇన్సర్ట్ ఏమి కావాలా మధ్యలో
అర్రే, అది కలిగి ఉండవచ్చు అయినప్పటికీ ఇది ఆరు విషయాలు ఐదు అవ్ట్?
>> బాగా, మేము అన్ని ఉన్నప్పుడు ఏమి లేదు మా మానవ వాలంటీర్లను వేదికపై లో
వారాలు?
మేము ఇక్కడ ఎవరైనా చాలు అనుకుంటే, గాని ఈ తరలించడానికి ఎలా ఈ ప్రజలు
మార్గం, లేదా ఈ తరలించడానికి ఎలా ఈ ప్రజలు మార్గం, మరియు ఆ ఖరీదైన మారింది.
ఒక లోపలి ప్రజల బదిలీ అర్రే అప్ జోడించడం మరియు ఖర్చు ముగిసింది
మాకు సమయం, అందుకే చాలా మా n స్క్వేర్డ్ యొక్క కోసం, చొప్పించడం విధమైన వంటి సార్లు అమలు
ఉదాహరణకు, చెత్త సందర్భంలో.
సో శ్రేణుల గొప్ప ఉంటాయి, కానీ మీరు కలిగి మీరు వాటిని ఎలా పెద్ద ముందుగానే తెలుసు.
>> సో OK, ఇక్కడ ఒక పరిష్కారం యొక్క.
నేను ముందుగానే తెలియకపోతే ఎన్ని విద్యార్థులు నేను ఉండవచ్చు, మరియు నేను ఒకసారి తెలుసు
నేను నిర్ణయించుకుంటారు, అయితే, నేను ఆ కష్టం నేను , ఎందుకు నేను ఎల్లప్పుడూ చాలా విద్యార్థులు లేదు
రెట్టింపు స్థలం కేటాయించాలని నేను అనుకుంటున్నాను ఉండవచ్చు నేను అవసరం?
ఒక సహేతుకమైన పరిష్కారం కాదు?
>> వాస్తవికంగా, నేను మేము ఆ భావించడం లేదు కంటే ఎక్కువ 50 విభాగాలు అవసరం వెళుతున్న
మధ్యస్థ పరిమాణ తరగతి కోసం వ్యూహంలో, కాబట్టి మనం చుట్టుముట్టటమే వీలు.
నేను, నా పరిధిలో 100 విభాగాలు చేస్తాము తద్వారా మేము ఖచ్చితంగా పొందవచ్చు
నేను అంచనా విద్యార్థులు సంఖ్య కొన్ని మధ్యస్థ పరిమాణ తరగతి లో.
సో ఎందుకు కేవలం అప్ అందుబాటులోనున్న మరియు కేటాయించుటకు కాదు వ్యూహం కోసం మరింత మెమరీ, సాధారణంగా,
మీరు కూడా కావాలనుకుంటే కంటే?
ఈ సాధారణ pushback ఏమిటి ఆలోచనను?
>> మీరు కేవలం మెమరీ వృధా చేస్తున్నాం.
మీరు వ్రాయడానికి వాచ్యంగా ప్రతి కార్యక్రమం బహుశా రెండు రెట్లు మెమరీని వాడుకుంటున్నారని
మీరు నిజంగానే అవసరం.
మరియు కేవలం ఒక భావిస్తాను లేదు ముఖ్యంగా చక్కని పరిష్కారం.
అంతేకాక, ఇది కేవలం తగ్గుతుంది ఒక సమస్య సంభావ్యత.
మీరు ఒక ప్రముఖ కోర్సు కలిగి జరిగే ఉంటే ఒక సెమిస్టర్ మరియు మీరు 101 కలిగి
విద్యార్థులు, మీ ప్రోగ్రామ్ ఇంకా ప్రాథమికంగా అదే సమస్య ఎదుర్కొంటున్న.
>> సో అదృష్టవశాత్తూ, ఒక పరిష్కారం ఉంది రూపంలో ఈ ప్రకటన మా సమస్యలు
అని డేటా నిర్మాణాలు వాటి కంటే మరింత క్లిష్టమైన
మేము ఇప్పటివరకు చూసిన.
ఈ, నేను క్లెయిమ్, అనుబంధ జాబితా ఉంది.
ఈ సంఖ్యల జాబితా -
9, 17, 22, 26, మరియు 34 -
మార్గం ద్వారా కలిసి లింక్ చేయబడ్డాయి ఏమి నేను బాణాలు డ్రా గా చేసిన.
>> ఇతర మాటలలో, ఉంటే నేను కోరుకున్నాడు ఒక అర్రే, నేను అలా
ఈ వంటి ఏదో.
మరియు నేను భారాన్ని ఈ పెడతామో కేవలం ఒక క్షణం లో.
నేను అలా -
హలో, అన్ని కుడి.
ఉండండి.
ఇక్కడ కొత్త కంప్యూటర్, స్పష్టమైన -
అన్ని కుడి.
>> నేను అర్రే ఈ సంఖ్యలు కలిగి ఉంటే -
9, 17, 22, 26, 24 -
కొలమానము అవసరం లేదు.
అన్ని కుడి, ఇక్కడ నా శ్రేణి -
ఓహ్ మై గాడ్.
అన్ని కుడి, ఇక్కడ నా శ్రేణి.
ఓహ్ మై గాడ్.
>> [నవ్వు]
>> DAVID మలన్: నటిస్తారు.
తిరిగి వెళ్ళడానికి చాలా కృషి వార్తలు మరియు అందువల్ల, ఆ పరిష్కరించడానికి -
26.
కాబట్టి మేము ఈ శ్రేణి యొక్క కలిగి 9, 17, 22, 26, మరియు 34.
మీరు ఆ చూడగలరు కోసం ఇబ్బందికరమైన తప్పు నేను చేసిన,
అక్కడ ఇది.
>> నేను ఈ చెప్పడము ఒక చాలా సమర్థవంతమైన పరిష్కారంగా.
నేను అనేక ints వంటి కేటాయించిన చేసిన నేను అవసరం - ఒక, రెండు, మూడు,
నాలుగు, ఐదు, ఆరు -
అప్పుడు నేను సంఖ్యలు నిల్వ చేసిన ఈ శ్రేణి యొక్క లోపల.
కానీ ఊహించు, అప్పుడు, నేను ఇన్సర్ట్ అనుకుంటున్నారా సంఖ్య 8 వంటి విలువ?
బాగా, అది గడిచిపోయింది?
నేను ఇన్సర్ట్ మీరు ఊహించు 20 వంటి అనేక.
బాగా, అది గడిచిపోయింది?
ఎక్కడా కూడా మధ్యలో, లేదా సంఖ్య 35 వెళ్ళడానికి ఉంది
ఎక్కడా చివరిలో.
కానీ నేను స్థలం అల్ అవ్ట్ రెడీ.
>> అందువలన ఈ ఒక ప్రాథమిక సవాలు పరిష్కారం లేని శ్రేణుల.
నేను GetString, ఒక క్షణం క్రితం పేర్కొన్నారు ఈ సమస్యను పరిష్కరించే.
మీరు ఒక ఆరవ సంఖ్య ఇన్సర్ట్ అనుకొంటే ఈ శ్రేణి లోకి, కనీసం ఒక ఏమిటి
పరిష్కారం మీరు ఖచ్చితంగా తిరిగి రావొచ్చు మేము GetString సంబంధం వంటి?
ఆ ఏమిటి?
>> బాగా, అది పెద్ద నిర్ధారించుకోండి సులభంగా పూర్తి కంటే చెప్పారు.
మేము తప్పనిసరిగా అర్రే చేయలేరు పెద్ద, కానీ మేము ఏమి చేయవచ్చు?
పరిమాణం యొక్క పెద్ద యొక్క ఒక కొత్త శ్రేణి, చేయండి 6, లేదా ఉండవచ్చు పరిమాణం 10, మేము కావాలా
ముందుకు విషయాలు పొందుటకు, ఆపై కాపీ పాత నూతన శ్రేణి, ఆపై
పాత శ్రేణి విడిపించేందుకు.
>> కానీ నడుస్తున్న సమయం ఏమిటి ఇప్పుడు ఆ ప్రక్రియలో?
ఇది n యొక్క పెద్ద O ఎందుకంటే కాపీ మీరు కొన్ని యూనిట్లు ఖర్చు కానుంది
మేము సమయం, కాబట్టి ఆదర్శ లేకపోతే వెళ్తున్నారు ఇది ఒక కొత్త శ్రేణి, కేటాయించుటకు
రెట్టింపు వినియోగించాయి తాత్కాలికంగా మెమరీ.
నూతన పాత కాపీ -
నా ఉద్దేశ్యం, అది కేవలం ఒక తలనొప్పి, వార్తలు ఇది , మళ్ళీ, ఎందుకు మేము రాశాడు ఉంది
మీరు కోసం GetString.
>> మేము బదులుగా సో ఏమి ఉండవచ్చు?
బాగా, ఏమి మా డేటా నిర్మాణం నిజానికి ఇది లోపాలను కలిగి ఉంది?
నేను కలిగి నా లక్ష్యం విశ్రాంతి అని ఊహించు మెమరీ ఆనుకొని రాళ్లను, పేరు 9
ఇది 17, హక్కు తదుపరి కుడి 22 పక్కన, మరియు అందువలన న.
>> మరియు 9 ఇక్కడ పైగా ఉండవచ్చు ఊహించు RAM, మరియు 17, RAM లో ఇక్కడ చేయవచ్చు
మరియు 22 RAM లో ఇక్కడ చేయవచ్చు.
ఇతర మాటలలో, నేను అవసరం లేదు కూడా ఇకపై వెనుకకు తిరిగి.
నేను ఏదో ఒకవిధంగా ఒక సూది దారం కలిగి ఈ సంఖ్యలు ప్రతి లేదా ప్రతి ద్వారా
ఈ గ్రంథుల, మేము కాల్ చేస్తాము నేను వాటిని డ్రా చేసిన వంటి దీర్ఘ చతురస్రాలు కు
గత ఎలా పొందాలో గుర్తు మొదటి నుంచి నోడ్.
>> సో ప్రోగ్రామింగ్ నిర్మించేందుకు ఏమిటి మేము చాలా ఇటీవల చూసిన ఇది నేను
ఆ థ్రెడ్ అమలు, లేదా , ఇక్కడ డ్రా నేను తో
ఆ బాణాలు అమలు?
సో గమనికలు, కుడి?
నేను ఒక లేదు కేటాయించుటకు ఉంటే Int, కానీ ఒక నోడ్ - మరియు ద్వారా
నోడ్, నేను కంటైనర్ అర్థం.
మరియు దృష్టి, నేను ఒక దీర్ఘ చతురస్రం అర్థం.
ఒక నోడ్ స్పష్టంగా అవసరం కాబట్టి రెండు విలువలు కలిగి -
Int కూడా, ఆపై, వంటి సూచించినట్లు దీర్ఘ చతురస్రం యొక్క దిగువ సగం,
ఒక Int కోసం తగినంత స్థలం.
>> సో కేవలం, ఇక్కడ ముందుకు ఆలోచిస్తూ ఈ నోడ్ ఈ, ఎలా పెద్దది
ప్రశ్న లో కంటైనర్?
Int కోసం ఎన్ని బైట్లు?
బహుశా 4, అది ఉంటే సాధారణ అదే.
ఆపై ఎన్ని బైట్లు పాయింటర్ కోసం?
4.
సో ఈ కంటైనర్, లేదా ఈ నోడ్, ఉంది ఒక 8-బైట్ నిర్మాణం కానుంది.
ఓహ్, మరియు ఒక సంతోషంగా యాధృచ్చికంగా ఆ మేము కేవలం ఈ భావన పరిచయం
ఒక struct, లేదా ఒక సి నిర్మాణం.
>> సో నేను ఒక అడుగు తీసుకోవాలని కావలసిన క్లెయిమ్ ఈ మరింత ఆధునిక వైపు
సంఖ్యల జాబితా, ఒక అమలు సంఖ్యల లింక్ జాబితా, నేను ఒక చెయ్యాల్సిన
కొంచెం ముందు అప్ ఆలోచన మరియు కేవలం ఒక Int, కానీ ఒక struct డిక్లేర్
నేను కాల్ మేము సాంప్రదాయబద్ధంగా ఇక్కడ, నోడ్.
మేము అది మేము కావలసిన ఏదైనా కాల్, కానీ నోడ్ చాలా నేపథ్య అవతరిస్తుంది
విషయాలు మేము ఇప్పుడు చూడటం మొదలు.
>> ఆ నోడ్ లోపల ఒక Int n.
ఆపై ఈ సింటాక్స్, కొద్దిగా మొదటి చూపులో అదృష్టము -
struct నోడ్ * తదుపరి.
బాగా చిత్రాల, ఆ ఏమిటి?
ఆ దిగువన సగం ఉంటుంది మేము చూసిన దీర్ఘచతురస్ర
కేవలం ఒక క్షణం క్రితం.
>> కానీ నేను * struct నోడ్ మాట్లాడుతూ చేస్తున్నాను కేవలం నోడ్ * వ్యతిరేకంగా?
ఆ పాయింటర్ సూచిస్తుంది ఉంటే ఎందుకంటే మరొక నోడ్, అది కేవలం వార్తలు
ఒక నోడ్ చిరునామా.
మేము దాన్ని స్థిరంగా ఉండే ఇప్పటివరకు గమనికలు గురించి చర్చించారు.
నేను దావా అయితే ఎందుకు, ఈ నిర్మాణం కణుపు అని పిలిచే, నేను struct చెప్పటానికి కలిగి లేదు
ఇక్కడ లోపల నోడ్?
>> సరిగ్గా.
ఇది C. ఒక తెలివితక్కువదని రియాలిటీ విధమైన వార్తలు typedef, మాట్లాడటానికి, కాదు ఉంది
ఇంకా జరిగింది.
సి సాహిత్య సూపర్ ఉంది.
ఇది మీ కోడ్ పైకి చదివి దిగువన, ఎడమ.
మరియు వరకు ఆ సెమికోలన్ హిట్స్ బాటమ్ లైన్, వాటిని అంచనా
ఒక దత్తాంశ ఉన్నాయి?
నోడ్, కోట్ unquote నోడ్.
>> కానీ మరింత మందమైన యొక్క ప్రకటన నేను మొదటి పంక్తిలో చేసింది -
typedef struct నోడ్ -
ఆ ముందు వచ్చింది ఎందుకంటే గిరజాల కలుపులు, వంటి విధమైన అని
ముందు చదువు గణగణమని ద్వని చేయు, మీరు ఏమి, నాకు ఒక struct ఇవ్వాలని
struct కణుపు అని పిలిచే.
స్పష్టముగా, నేను కాల్ విషయాలు నచ్చలేదు struct నోడ్, struct నోడ్ అన్ని
నా కోడ్ అంతటా.
కానీ నేను మాత్రమే, కేవలం లోపల, ఒకసారి ఉపయోగించండి కాబట్టి నేను సమర్థవంతంగా చేయవచ్చు
, వృత్తాకార సూచన ఒక విధమైన కాదు సృష్టించడానికి ఒక పర్ సే నాకు పాయింటర్, కానీ ఒక
మరొక కు పాయింటర్ ఒక ఏకరూప రకం.
>> కనుక దీనిని మారుతుంది ఒక డేటా నిర్మాణం ఈ వంటి, కొన్ని ఉంది
కావచ్చు క్రియలకు మాకు ఆసక్తి.
మేము ఇన్సర్ట్ అనుకొనుచున్న ఈ వంటి ఒక జాబితాలో.
మేము తొలగించాలనుకుంటున్నారా ఉండవచ్చు ఈ వంటి ఒక జాబితా నుండి.
మేము ఒక జాబితాలో అన్వేషణ అనుకొనుచున్న విలువ, లేదా మరింత సాధారణంగా, యాత్ర.
మరియు యాత్ర కేవలం ఒక ఫాన్సీ మార్గం ఎడమ ప్రారంభం మాట్లాడుతూ మరియు అన్ని తరలించడానికి
కుడి మార్గం.
>> మరియు కూడా ఈ కొద్దిగా ఎక్కువ నోటీసు, అధునాతన డేటా నిర్మాణం, వీలు
నాకు మేము కొన్ని రుణాలు తీసుకునే ప్రతిపాదించారు గత రెండు వారాల ఆలోచనలు మరియు
అని ఒక ఫంక్షన్ అమలు ఈ వంటి అన్వేషణ.
ఇది లేదా నిజమైన తిరిగి జరగబోతోంది , తప్పుడు సూచిస్తుంది అవును లేదా
ఏ, n జాబితా ఉంది.
దాని రెండవ వాదన పాయింటర్ గా జాబితా కూడా, కాబట్టి ఒక
ఒక నోడ్ కు పాయింటర్.
>> నేను చేయ బోతున్నాను అన్ని డిక్లేర్ ఉంది ఒక తాత్కాలిక వేరియబుల్.
మేము సమావేశం ద్వారా PTR కాల్ చేస్తాము పాయింటర్ కోసం.
మరియు నేను దానిని సమానంగా కేటాయించి జాబితా ప్రారంభం.
>> మరియు ఇప్పుడు అయితే లూప్ గమనించవచ్చు.
చాలా కాలం పాయింటర్ సమానం కాదు వంటి శూన్యం, నేను తనిఖీ వెళుతున్న.
ఉంది పాయింటర్ బాణం n సమానంగా ఆమోదించబడింది ఆ n?
కొత్త - మరియు ఒక నిమిషం వేచి సింటెక్స్ ముక్క.
బాణం ఆకస్మికంగా ఏమిటి?
అవును?
>> సరిగ్గా.
సో అయితే కొన్ని నిమిషాల క్రితం, మేము ఉపయోగించే ఏదో ఆక్సెస్ చెయ్యడానికి డాట్ సంజ్ఞామానం
ఒక struct లోపలి వేరియబుల్ ఉంటే మీరు struct కాదు చేశారు
కూడా, కానీ ఒక struct ఒక పాయింటర్, అదృష్టవశాత్తూ, సింటెక్స్ ఒక ముక్క ఆ
చివరకు సహజమైన అర్ధమే.
బాణం, పాయింటర్ అనుసరించండి అర్థం మా బాణాలు సాధారణంగా అర్ధం వంటి
చిత్రాల, మరియు వెళ్ళి డేటా పొలాలలో.
సో బాణం డాట్ అదే విషయం, కానీ మీరు ఒక పాయింటర్ ఉన్నప్పుడు మీరు దాన్ని ఉపయోగించండి.
>> సో కేవలం, అప్పుడు రీక్యాప్ ఉంటే n రంగంలో struct లోపలి పాయింటర్ అని
సమానం n సమానం, నిజమైన తిరిగి.
లేకపోతే, ఈ లైన్ - పాయింటర్ తదుపరి పాయింటర్ సమానం.
సో ఈ చేస్తున్నది, నోటీసు, ఉంటే నేను ప్రస్తుతం struct వద్ద గురిపెట్టి చేస్తున్నాను
9 మరియు 9 కలిగి సంఖ్య కాదు నేను చూస్తున్నాను - నేను చూస్తున్నాను ఊహించు
కోసం n 50 సమానం -
నా తాత్కాలిక పాయింటర్ అప్డేట్ వెళుతున్న ఈ నోడ్ సమయంలో లేదు
ఇకపై, కానీ పాయింటర్ బాణం తదుపరి, ఇది ఇక్కడ నాకు అప్ చాలు అన్నారు.
>> ఇప్పుడు, నేను ఒక సుడిగాలి ఉంది గ్రహించారు పరిచయం.
బుధవారం, మేము నిజానికి చేస్తాను కొన్ని మానవుల మరియు కొన్ని ఎక్కువ
ఒక నెమ్మదిగా కోడ్.
కానీ గుర్తించిన మేము ఇప్పుడు మా డేటా చేస్తున్న నిర్మాణాలు క్లిష్టమైన కనుక మా
అల్గోరిథంలు, మరింత సమర్థవంతమైన పొందవచ్చు ఇది కోసం అవసరమైన అవతరిస్తుంది
pset ఆరు, మేము మళ్ళీ, లో లోడ్ చేసినప్పుడు, ఆ 150,000 పదాలు, కానీ అలా చెయ్యాల్సి
సమర్ధవంతంగా, మరియు ఆదర్శంగా ఒక సృష్టించడానికి మా వినియోగదారులు లో నడుస్తుంది కార్యక్రమం
సరళ, కాదు స్క్వేర్డ్ n లో, అయితే ఆదర్శ నిరంతరం సమయం,.
>> మేము బుధవారం మీరు చూస్తారు.
>> SPEAKER: తదుపరి CS50, డేవిడ్ వద్ద తన బేస్ కేసు మర్చిపోతోంది.
>> DAVID మలన్: ఆ మీరు పంపే ఎలా తో టెక్స్ట్ సందేశాలను C. ఏం -
>> [వివిధ టెక్స్ట్ సందేశం నోటిఫికేషన్ ధ్వనులు]