[Powered by Google Translate] [విభాగం 6] [అత్యంత సౌకర్యవంతమైన]
[రాబ్ బౌడెన్] [హార్వర్డ్ విశ్వవిద్యాలయం]
[ఈ CS50 ఉంది.] [CS50.TV]
>> మేము ప్రశ్నలు మా విభాగం వెళ్ళవచ్చు.
నేను ముందు స్పేస్ కోసం URL పంపారు.
ప్రశ్నలు యొక్క విభాగం ప్రారంభం సే-
స్పష్టంగా నేను చాలా సులభమైన ప్రశ్న unsick-ఉంటుంది పూర్తిగా కాదు
valgrind మాత్రమే ఏమి?
Valgrind ఏమి చేస్తుంది?
ఎవరైనా valgrind ఏమి చెప్పాలనుకోవడం?
[స్టూడెంట్] తనిఖీలను మెమరీ లీకేజ్.
అవును, valgrind సాధారణ మెమరీ చెక్కర్ ఉంది.
మీరు ఏ మెమరీ లీకేజ్ ఉంటె, చివరకు,, మీరు చెబుతుంది
మీరు అనుకుంటే మేము ఎందుకంటే ఇది ఉపయోగించి ఏమి ఎక్కువగా ఉంది
సమస్య సెట్ లో లేదా మీరు అనుకుంటే బాగా
పెద్ద బోర్డు మీద వస్తుంది, మీ, ఎలాంటి మెమరీ లీకేజ్ కలిగి ఉండాలి
మరియు ఒకవేళ మీరు, మీరు దొరకలేదా మెమొరీ లీక్ కలిగి
మీరు ఒక ఫైల్ తెరిచిన ప్రతిసారి కూడా గుర్తుంచుకోండి
మరియు మీరు దాన్ని మూసివేసి లేకపోతే, ఆ మెమొరీ లీక్ ఉంది.
>> మంది వారు విడుదల చేస్తున్నట్లు కొన్ని నోడ్ శోధిస్తున్న
ఉన్నప్పుడు నిజంగా, వారు మొట్టమొదటి దశలో నిఘంటువు దగ్గరగా లేదు.
ఇది కూడా, మీరు ఏ చెల్లని ఉంటే చదివే మీరు చెబుతుంది లేదా రాశాడు
మీరు ప్రయత్నించండి మరియు ఒక విలువ సెట్ చేస్తే అంటే
ఆ కుప్ప ముగింపు మించి మరియు అది seg లోపం సంభవించవచ్చు లేదు
కానీ valgrind, మీరు నిజంగా అక్కడ వ్రాయడం లేదు, ఇది పట్టుకొని
మరియు మీరు ఖచ్చితంగా ఆ గాని ఏదీ లేదు.
మీరు ఎలా valgrind ఉపయోగించగలను?
>> ఇది ఒక సాధారణ ప్రశ్న
రకం అమలు మరియు అవుట్పుట్ చూడండి.
అవుట్పుట్ సార్లు చాలా అధిక ఉంది.
మీరు కొన్ని భయంకరమైన విషయం ఉంటే పేరు సరదాగా లోపాలు కూడా ఉన్నాయి
ఒక లూప్ వస్తున్న, అది చివరికి ", వే చాలా లోపాలు యున్నది.
నేను ఇప్పుడు లెక్కింపు ఆపడానికి వెళుతున్న. "
ఇది ప్రాథమికంగా మీరు అన్వయించడం కలిగి పాఠ్య అవుట్పుట్ ఉంది.
చివరకు, అది, మీరు ఏదైనా మెమరీ లీకేజ్ చెప్పడం కనిపిస్తుంది
ఉపయోగకరమైన ఎన్ని బ్లాక్స్, ఉండవచ్చు ఎందుకంటే
అది ఒక బ్లాక్ unfreed అది దానిని కనుగొనేందుకు సాధారణంగా సులభం
1,000 బ్లాక్స్ unfreed కంటే.
Unfreed 1,000 బ్లాక్స్ బహుశా మీరు ఉండండి లేదు అంటే
సరిగ్గా లేదా ఏదో మీ లింక్ జాబితాలు.
ఆ valgrind యొక్క.
>> ఇప్పుడు మేము, ప్రశ్నలు మా విభాగం కూడా
మీరు డౌన్లోడ్ లేదు.
మీరు నా పేరు మీద క్లిక్ చేసి స్పేస్ వాటిని పుల్ అప్ చేయవచ్చు.
ఇప్పుడు నా మీద క్లిక్ చేయండి.
కూర్పుల 1 మేము మొదటి చేస్తున్నా ఇది స్టాక్ ఉంటుంది.
కూర్పుల 2 క్యూ ఉంటుంది, మరియు కూర్పుల 3 ఒక్కొక్కటిగా లింక్ జాబితా ఉంటుంది.
మా స్టాక్ తో ప్రారంభించడానికి.
అది ఇక్కడ చెప్పినట్టుగా, ఒక స్టాక్ అత్యంత ప్రాధమిక ఒకటి
కంప్యూటర్ సైన్స్ యొక్క ప్రధాన సమాచార నిర్మాణాలకు.
చాలా ప్రాధమిక ఉదాహరణ
భోజనశాలలో ట్రేలు యొక్క స్టాక్.
మీరు ఒక స్టాక్ కు పరిచయం చేశారు ఎప్పుడు, ప్రధానంగా ఉంది
ఎవరైనా, చెప్పడానికి అన్నారు "ట్రేలు ఒక స్టాక్ వలె, ఓహ్."
మీరు ట్రేలు స్టేక్ అప్.
అప్పుడు మీరు ఒక ట్రే తీసి వెళ్ళి,
లాగి సంతరించుకోనుంది మొదటి ట్రే స్టాక్ ఉంచబడినది చివరి ఒకటి.
అది కూడా వంటి స్టాక్ ఇక్కడ చెప్పారు
మేము స్టాక్ అనే మెమరీ విభాగంలో ఉంటాయి.
మరియు ఎందుకు స్టాక్ అంటారు?
>> ఎందుకంటే ఒక స్టాక్ డేటా వంటి నిర్మాణం,
ఇది స్టాక్ మీద స్టాక్ ఫ్రేములు నెడుతుంది మరియు బయటకు
స్టాక్ ఫ్రేములు ఒక చర్య యొక్క ఒక నిర్దిష్ట కాల్ వంటి చోట.
మరియు ఒక స్టాక్ వలె, మీరు ఎల్లప్పుడూ తిరిగి ఉంటుంది
ఒక ఫంక్షన్ కాల్ మీరు మళ్ళీ తక్కువ స్టాక్ ఫ్రేములు దిగి పొందవచ్చు ముందు.
మీరు ప్రధాన కాల్ foo కాల్ బార్ మరియు ప్రధాన నేరుగా బార్ తిరిగి పొందలేరు.
ఇది ఎల్లప్పుడూ నెట్టడం మరియు పాపింగ్ సరైన స్టాక్ అనుసరించండి తీరవలసినదే.
రెండు ప్రక్రియలు, నేను అన్నాడు వంటి పుష్ మరియు పాప్ ఉంటాయి.
ఆ యూనివర్సల్ నిబంధనలు ఉన్నాయి.
మీరు స్టాక్స్ నో మేటర్ వాట్ పరంగా పుష్ మరియు పాప్ తెలుసుకోవాలి.
మేము క్యూలు వివిధ యొక్క ఒకరకమైన చూస్తారు.
ఇది నిజంగా ఒక యూనివర్సల్ పదం లేదు, కానీ పుష్ మరియు పాప్ స్టాక్లకు సార్వత్రిక ఉంటాయి.
పుష్ కేవలం స్టాక్ మీద పెట్టబడింది.
పాప్ స్టాక్ టేకాఫ్ ఉంది.
మరియు మేము, మేము మా typedef struct స్టాక్ కలిగి ఇక్కడ చూడండి
కాబట్టి మేము చార్ ** తీగలు ఉంటాయి.
ఏ ** భయపడ్డ పొందలేము.
ఈ తీగలు యొక్క వ్యూహం మాదిరిగా ముగించారు అన్నారు
అక్షరాలకు గమనికలు లేదా ఒక వరుస పేరు
అక్షరాలకు గమనికలు తీగలు ఉంటాయి.
ఇది తీగలను ఉండాలి, కానీ ఇక్కడ, వారు తీగలను మాత్రం చేస్తున్నారు.
>> మేము తీగలను యొక్క వ్యూహం ఉంది.
మేము స్టాక్ ప్రస్తుతం ఎన్ని అంశాలు సూచిస్తుంది ఒక పరిమాణం, కలిగి
మరియు తర్వాత మేము స్టాక్ మీద ఎన్ని అంశాలు ఉంటుంది సామర్థ్యం కలిగి ఉంటాయి.
సామర్థ్యం, ​​1 కంటే ఎక్కువ ఏదో ఆఫ్ ప్రారంభం కావాలి
కానీ పరిమాణం 0 గా కాకుండా ప్రారంభించు అన్నారు.
ఇప్పుడు, మీరు ఒక స్టాక్ ఆలోచించవచ్చు మూడు వేర్వేరు మార్గాల్లో ప్రధానంగా ఉన్నాయి.
Well, అక్కడ బహుశా మరింత ఉంటాయి, కాని రెండు ప్రధాన మార్గాలు
మీరు వరుసను ఉపయోగించి దాన్ని అమలు చేయవచ్చు, లేదా మీరు ఒక లింక్ జాబితా ద్వారా అమలు చేయవచ్చు.
లింక్ జాబితాలు రకమైన నుండి స్టాక్స్ తయారు చిన్నవిషయం ఉంటాయి.
ఇది అనుసంధాన జాబితాలు ఉపయోగించి స్టాక్ చేయడానికి చాలా సులభం
ఇక్కడ, మేము, శ్రేణుల ఉపయోగించి స్టాక్ తయారు చేయబోతున్నామని
మరియు తర్వాత వ్యూహాన్ని ఉపయోగిస్తాయి, మీరు దాని గురించి ఆలోచించటం రెండు మార్గాలు కూడా ఉన్నాయి.
ముందు, నేను అన్నాడు, మేము, స్టాక్ కోసం సామర్ధ్యం కలిగి ఉంటుంది
కాబట్టి మేము స్టాక్ మీద ఒక మూలకం ఇముడుతుంది.
>> ఇది జరిగి ఒక మార్గం వెంటనే మీకు 10 అంశాలను హిట్, అప్పుడు మీరు పూర్తి చేసిన ఉంది.
మీరు ప్రపంచంలో 10 విషయాలను కట్టుబడి ఒక ఉన్నత లేదు అని తెలిసిన
మీరు, మీ స్టాక్ ఎక్కువ 10 విషయాల్లో ఎప్పటికీ ఆ
ఈ సందర్భంలో మీరు మీ స్టాక్ పరిమాణం పైన కట్టుబడి ఒక ఉన్నత ఉండవచ్చు.
లేదా మీరు, మీ స్టాక్ అపరిమితం కూడా కలిగి ఉండవచ్చు
మీరు ఒక అర్రే చేస్తున్నా అయితే, ఆ, ప్రతి మీరు 10 అంశాలను హిట్ అంటే
మీరు 20 అంశాలను కొట్టాడు అప్పుడు మీరు, 20 అంశాలను పెరగడం కొనసాగుతుందని, మరియు మీరు
మీరు 30 అంశాలు లేదా 40 అంశాలను మీ శ్రేణి పెరగడం చూడాలని.
మీరు ఇక్కడ మేము చేయబోతున్నామని ఏమి ఉంది సామర్థ్యం, ​​పెంచే అవసరతను చూడాలని.
మేము, మా స్టాక్ గరిష్ట పరిమాణాన్ని చేరి ప్రతి సమయం
మేము ఇంకా న ఏదో పుష్, మేము సామర్థ్యాన్ని అవసరం చూడాలని.
ఇక్కడ, మనం పుష్ bool పుష్ (చార్ * STR) వంటి నిర్ధారించారు.
చార్ * STR, మేము స్టాక్ పై నెట్టడం తీగ ఉంది
మరియు bool కేవలం మేము విజయం లేదా విఫలమైంది అని చెప్పారు.
>> మేము ఎలా విఫలం కావచ్చు?
మీరు భావిస్తారు మాత్రమే పరిస్థితి ఏమిటి
మేము తప్పుడు తిరిగి ఉంటుంది ఎక్కడ?
అవును.
[స్టూడెంట్] ఇది పూర్తి మరియు మేము ఒక సరిహద్దులో అమలు ఉపయోగిస్తున్నట్లయితే.
అవును, కాబట్టి మేము ఎలా నిర్వచించాలి-అతను సమాధానం
అది పూర్తి మరియు మేము ఒక పరిమిత అమలు ను ఉపయోగిస్తున్నట్లయితే.
అప్పుడు మేము ఖచ్చితంగా తప్పుడు తిరిగి ఉంటుంది.
వెంటనే మేము శ్రేణి లో 10 పనులను హిట్, మేము 11 సరిపోవు, మేము తప్పుడు తిరిగి కాబట్టి.
అది అపరిమితం ఏమి? అవును.
మీరు కొన్ని కారణాల కోసం శ్రేణి విస్తరణ పోతే.
అవును, కాబట్టి మెమరీ, ఒక పరిమిత వనరు
చివరకు, మేము మళ్ళీ మరియు పైగా స్టాక్ పై నెట్టడం విషయాలు ఉంటే,
మేము సరిపోయే పెద్ద అర్రే ప్రయత్నించండి మరియు కేటాయించే వెళుతున్న
ఇక్కడ పెద్ద సామర్థ్యం, ​​మరియు malloc లేదా ఎలాగైనా తప్పుడు తిరిగి అన్నారు.
Well, malloc శూన్య చూపిస్తుంది.
>> గుర్తుంచుకోండి, మీరు malloc కాల్ ప్రతి సారి, చూడటానికి తనిఖీ చేయాలి ఉంటే అది
శూన్య తిరిగి లేదంటే ఒక సరి కోత ఉంది.
మేము ఒక అపరిమితం స్టాక్ కావాలి కాబట్టి,
మేము ప్రయత్నించినట్లయితే మేము తప్పుడు తిరిగి చూడాలని మాత్రమే సందర్భంలో
సామర్థ్యం మరియు malloc పెంచడానికి లేదా తప్పుడు తిరిగి ఏ.
అప్పుడు పాప్, ఎటువంటి వాదనలూ లేవు పడుతుంది
మరియు అది స్టాక్ పైన అని స్ట్రింగ్ తిరిగి.
ఏమైనప్పటికీ ఇటీవల స్టాక్ మీద వెళ్ళింది, తిరిగి ఏమి పాప్ ఉంది
మరియు అది కూడా స్టాక్ నుంచి అది తొలగిస్తుంది.
మరియు స్టాక్ మీద ఏమీ లేకపోతే అది శూన్య తిరిగి గుర్తించాము.
ఇది స్టాక్ ఖాళీ అని ఎల్లప్పుడూ సాధ్యపడుతుంది.
జావా, మీరు ఆ, లేదా ఇతర భాషలు ఉపయోగిస్తారు చేస్తుంటే,
ఒక ఖాళీ స్టాక్ నుండి పాప్ ప్రయత్నిస్తున్న ఒక మినహాయింపు లేదా ఏదో వస్తుంది.
>> కానీ సి లో, శూన్య మేము ఈ సమస్యలను ఎలా నిర్వహిస్తాయనే కేసులు చాలా యొక్క రకం.
శూన్య తిరిగి మేము స్టాక్ ఖాళీ అని సూచిస్తుంది చూడాలని ఎలా ఉంది.
మేము, మీ స్టాక్ యొక్క కార్యాచరణ పరీక్షించడానికి ఆ కోడ్ అందించిన
పుష్ మరియు పాప్ అమలు.
ఈ కోడ్ యొక్క చాలా ఉండదు.
నేను రెడీ-నిజానికి, మేము అలా ముందు, సూచన, సూచనను-
మీరు చూడని ఉంటే, malloc మాత్రమే క్రియ కాదు
మీరు కోసం కుప్ప మెమరీ కేటాయించుకునే.
Alloc ఫంక్షన్ల ఒక కుటుంబం ఉన్నాయి.
మొదటి మీకు ఇది malloc, ఉంది.
అప్పుడు malloc అదే విషయం చేస్తుంది ఇది calloc, లేదు
కానీ మీరు అన్ని బయటకు సున్నాకి కనిపిస్తుంది.
మీరు ఏదో mallocing తర్వాత శూన్యం ప్రతిదీ సెట్ కోరుకున్నామని చెప్తూ ఉంటే
మీరు బదులుగా వ్రాసే మొదటి స్థానంలో calloc ఉపయోగించాలి
మెమరీ మొత్తం బ్లాక్ అవుట్ సున్నాకి లూప్ ఒక.
>> Realloc, malloc ఉంటుంది మరియు ప్రత్యేక సందర్భాలలో చాలా ఉంది
కానీ ప్రాథమికంగా realloc ఏమి ఉంది
ఇది ఇప్పటికే కేటాయించబడ్డాయి చేయబడిన ఒక పాయింటర్ పడుతుంది.
Realloc మీరు ఇక్కడ దృష్టి పెట్టారు అనుకుంటే విధి.
ఇది ఇప్పటికే malloc నుంచి తిరిగి చేయబడిన ఒక పాయింటర్ పడుతుంది.
మీరు malloc నుండి 10 బైట్లు ఒక పాయింటర్ అభ్యర్థించవచ్చు చెప్పారు.
తరువాత మీరు, మీరు 20 బైట్లు కోరుకున్నారు తెలుసుకుంటారు
కాబట్టి మీరు, 20 బైట్లు ఆ పాయింటర్ ఆన్ realloc కాల్
మరియు realloc స్వయంచాలకంగా మీ కొరకు అన్నిచోట్ల కాపీ చేస్తుంది.
మీరు నేను 10 బైట్లు ఒక బ్లాక్ ఉన్నట్లు, మళ్ళీ malloc అని. ఉంటే
ఇప్పుడు నేను 20 బైట్లు ఒక బ్లాక్, అవసరం
నేను malloc 20 బైట్లు, అప్పుడు నేను మానవీయంగా మొదటి విషయం నుండి 10 బైట్లు పైగా కాపీ కలిగి
మొదటి విషయం రెండవ విషయం మరియు తర్వాత ఫ్రీ.
Realloc మీరు ఆ పోరాడతాను.
>> సంతకం, శూన్యమైన * అని అన్నారు గమనించండి
ఇది కేవలం, మెమరీ బ్లాక్ ఒక పాయింటర్ తిరిగి
అప్పుడు తప్ప * PTR.
మీరు ఒక సాధారణ పాయింటర్ గా తప్ప * యొక్క ఆలోచించవచ్చు.
సాధారణంగా, మీరు, శూన్యమైన * తో వ్యవహరించే ఎప్పుడూ
కానీ malloc ఒక గర్జన * తిరిగి, ఆపై ఇది వంటి ఉపయోగించబడిన
ఇది నిజానికి ఒక చార్ * అని అన్నారు.
malloc ద్వారా తిరిగి ఆ మునుపటి తప్ప *
ఇప్పుడు పరిమాణం అప్పుడు realloc జారీ కావడం, మరియు
మీరు కేటాయించే కావలసిన బైట్లు యొక్క కొత్త సంఖ్య, మీ కొత్త సామర్థ్యం ఉంది.
నేను మీరు ఒక జంట నిమిషాల ఇవ్వడం, మరియు మా ప్రదేశంలో చేయును.
కూర్పుల 1 ప్రారంభించండి.
నేను, పుష్ అమలు తగినంత సమయం తర్వాత ఆశాజనక మీరు ఆపడానికి ఉంటాం
మరియు నేను మీరు పాప్ చేయడానికి మరొక బ్రేక్ ఇస్తాను.
కానీ నిజంగా అన్ని వద్ద ఎక్కువ కోడ్ కాదు.
అత్యంత కోడ్ సామర్థ్యాన్ని పెంచుకుంటూ, బహుశా విస్తరించడం stuff ఉంది.
సరే, పూర్తిగా చెయ్యటానికి ఎలాంటి ఒత్తిడి,
కానీ కాలం మీరు కుడి మార్గంలో చేస్తున్నట్లు మీకు, ఆ మంచి.
>> ఎవరైనా నన్ను పైకి లాగడం తో సుఖంగా ఏ కోడ్ కలిగి ఉందా?
అవును, నేను రెడీ, కాని ఎవరైనా నేను పుల్ అప్ చేయవచ్చు ఏ కోడ్ కలిగి ఉన్నారు?
సరే, మీరు ఇది ఏమైనా అది సేవ్, ప్రారంభించగలరు?
నేను ఎప్పుడూ అడుగు మర్చిపోతే.
సరే, పుష్ చూడటం,
మీరు మీ కోడ్ వివరించేందుకు కోరుకుంటున్నారు?
[స్టూడెంట్] అన్ని యొక్క మొదటి, నేను పరిమాణం పెరిగింది.
నేను నేను ఆ-ఏమైనప్పటికీ ఉండాలి ఊహించడం, నేను, పరిమాణాన్ని
అది సామర్థ్యం కంటే తక్కువగా ఉంటే నేను చూడండి.
మరియు అది సామర్థ్యం కంటే తక్కువగా ఉంటే, మనం ఇప్పటికే ఆ శ్రేణి జోడించండి.
అది కాదు ఉంటే, నేను, 2 సామర్థ్యం గుణిస్తారు
ఇప్పుడు ఒక పెద్ద సామర్థ్యం పరిమాణం ఏదో కోసం తీగలను శ్రేణి reallocate.
ఒకవేళ విఫలమైతే మరియు అప్పుడు, నేను యూజర్ చెప్పండి మరియు, తప్పుడు తిరిగి
అది మంచిది ఉంటే, అప్పుడు నేను కొత్త స్పాట్ లో స్ట్రింగ్ ఉంచండి.
>> [రాబ్ B.] ఇక్కడ మేము ఒక మంచి bitwise ఆపరేటర్లు ఉపయోగిస్తారు గమనించండి
2 ద్వారా హెచ్చించాము కు.
గుర్తుంచుకోండి, ఎడమ షిఫ్ట్ ఎల్లప్పుడూ 2 గుణించి అవతరిస్తుంది.
మీరు అర్థం గుర్తుంచుకోవాలి వంటి కుడి Shift కాలం 2 విభజించబడిన
2 ద్వారా విభజించబడింది పూర్ణాంకం లో 2 భాగాలుగా విభజించారు.
ఇది ఇక్కడ లేదా అక్కడ ఒక 1 ఖండించు ఉండవచ్చు.
కానీ 1 విడిచిపెట్టిన షిఫ్ట్ ఎప్పుడూ 2 గుణించి అవతరిస్తుంది
మీరు ఓవర్ఫ్లో పూర్ణాంక యొక్క సరిహద్దులు తప్ప, మరియు అప్పుడు అది సాధ్యం కాదు.
ఒక సైడ్ కామెంట్.
నేను, ఏమి-ఈ ఏ విధంగా కోడింగ్ మార్చడానికి వెళ్ళడం లేదు మీరు
కానీ నేను ఈ వంటి ఏదో చేయాలని.
ఇది నిజానికి అది కొద్దిగా పొడవుగా సిధ్ధంగా ఉంటుంది.
బహుశా ఈ, ఈ చూపించడానికి ఖచ్చితమైన కేసు కాదు
కానీ నేను యొక్క ఈ ముక్కలుగా సెగ్మెంట్ ఇష్టపడతారని
ఇది జరిగితే ఉంటే సరే,, అప్పుడు నేను, ఏదో ఒకటి వెళుతున్న
ఆపై చర్య జరుగుతుంది.
నేను ఫంక్షన్ డౌన్ నా కళ్ళు అన్ని మార్గం స్క్రోల్ లేదు
ఇంకా తర్వాత ఏమి చూడటానికి.
ఇది జరిగితే ఉంటే ఇది, అప్పుడు నేను తిరిగి.
ఇది కూడా ఈ మించి ప్రతిదీ యొక్క నైస్ అదనపు ప్రయోజనం ఉంది
ఇప్పుడు ఒకసారి ఎడమ మారిపోయి ఉంది.
నేను ఇకపై కు-ఉంటే మీరు హాస్యాస్పదమైన దీర్ఘ పంక్తులు సమీపంలో అవసరం
, అప్పుడు ఆ 4 బైట్లు సహాయపడుతుంది మరియు కూడా మరింత ఎడమ విషయం
తక్కువ నాలాంటి ఓకే, నేను గుర్తు ఉంటే మీకు నిష్ఫలంగా
నేను లూప్ ఒక యొక్క ఒక else లోపల లోపల కొంత లూప్ ప్రస్తుతం ఉన్నాను.
ఎక్కడైనా మీరు నేను రకమైన వంటి వెంటనే ఈ తిరిగి చేయవచ్చు.
ఇది పూర్తిగా ఇచ్చాపూరితం మరియు ఏ విధంగా అంచనా లేదు.
>> [స్టూడెంట్] అక్కడ ఒక పరిమాణం ఉండాలి - ఫెయిల్ స్థితిలో?
ఇక్కడ ఫెయిల్ పరిస్థితి మేము అవును, realloc విఫలమైంది ఉంది.
చాలావరకు ఫెయిల్ పరిస్థితిలో ఎలా గమనించండి
మేము ఉచిత స్టఫ్ తర్వాత తప్ప, మేము ఎల్లప్పుడూ విఫలం చూడాలని
ఏదో కొట్టాలని ప్రయత్నించండి ఎన్ని సార్లు ఉన్నా.
మేము నెట్టడం ఉంటే, మేము, పెంచడం పరిమాణం ఉంచడానికి
మేము స్టాక్ లో ఏదైనా ఉంచడం లేదు అయినప్పటికీ.
సాధారణంగా మేము వరకు పరిమాణం పెంచడం లేదు
మేము విజయవంతంగా స్టాక్ ఉంచారు తరువాత.
మేము గాని ఇక్కడ మరియు ఇక్కడ చెప్పడానికి, అది చేయరు.
బదులుగా ≤ సామర్థ్యం s.size చెప్పడం మరియు అప్పుడు, సామర్థ్యం కంటే తక్కువగా
ప్రతిదీ పేరు మేము తరలించారు మాత్రమే ఎందుకంటే.
>> ఇంకా గుర్తుంచుకోండి, మేము బహుశా తప్పుడు మాత్రమే చోటు తిరిగి విధుల్లో
realloc శూన్య వచ్చిన,, ఇక్కడ ఉంది
మరియు మీరు ప్రామాణిక తప్పు గుర్తు జరిగితే,
మీరు ప్రామాణిక దోషం ముద్రించడానికి ఎక్కడ బహుశా మీరు, ఈ కేసులో పరిగణించబడతారు
బదులుగా కేవలం ప్రామాణిక అవుట్ నేరుగా ప్రింటింగ్ కాబట్టి fprintf stderr.
మళ్లీ,, అంచనా కాదు, అయితే ఇది ఒక లోపం ఉంటే
printf టైప్ చేసి, మీరు బదులుగా ప్రామాణిక అవుట్ యొక్క ప్రామాణిక లోపం ప్రింట్ తయారు చేయవచ్చు.
>> ఎవరైనా గమనించండి వేరే ఏదైనా ఉందా? అవును.
[స్టూడెంట్] మీరు [వినబడని] మీద వెళ్ళే?
[రాబ్ B.] అవును, నిజమైన దానిని binariness లేదా ఏ అవునా?
[స్టూడెంట్] కాబట్టి మీరు 2 ద్వారా గుణిస్తారు?
[రాబ్ B.] అవును, ప్రధానంగా.
బైనరీ భూమి, మేము ఎల్లప్పుడూ అంకెలు మా సెట్.
కుడివైపు వద్ద ఇక్కడ ప్రధానంగా ఇన్సర్ట్ అది 1 ఈ ఎడమ షిఫ్టింగ్.
ఈ కావడానికి, బైనరీ లో ప్రతిదీ గుర్తు
, 2 యొక్క ఒక శక్తి ఉంటుంది, అందుచే 0 to 2 సూచిస్తుంది
1 ఈ 2, ఈ 2 2.
ఇప్పుడు కుడివైపు ఒక 0 చేర్చడం ద్వారా, మేము అన్నిచోట్ల ఉంచారు.
ఏ 0 to 2 ఉపయోగిస్తున్నప్పుడు 2, ఇప్పుడు 2 1 2 ఉంది.
మేము చేర్చబడ్డ ఆ కుడివైపు
తప్పనిసరిగా 0 గా అంటే,
ఇది అర్థవంతంగా ఉంటుంది.
మీరు 2 అనేక గుణిస్తారు, అది, బేసి వదులుకోవడానికి మాత్రం కాదు
కాబట్టి 0 స్థానానికి 2, 0 ఉండాలి
మీరు మార్చేందుకు జరిగే లేకపోతే మరియు ఈ నేను సగం ఉంటుంది ముందు గురించి హెచ్చరించారు ఏమిటి
పూర్ణాంకం లో బిట్స్ సంఖ్య దాటి,
ఈ 1 షో ముగుస్తుంది అన్నారు.
మీరు నిజంగా పెద్ద సామర్థ్యాలను వ్యవహరించే విధంగా జరిగితే మాత్రమే ఆందోళన ఉంది.
కానీ ఆ సమయంలో, మీరు, విషయాలను బిలియన్ల యొక్క వ్యూహం వ్యవహరించే చేస్తున్నారు
ఏమైనప్పటికీ మెమోరీలో సరిపోని విధంగా.
>> ఇప్పుడు మేము కూడా సులభం ఇది పాప్, పొందవచ్చు.
మీరు మొత్తం బంచ్ పాప్ జరిగితే మీరు, ఇది ఇష్టపడతారు కాలేదు
ఇప్పుడు మీరు మళ్ళీ సగం సామర్థ్యం వద్ద ఉన్నారు.
మీరు, మీరు మెమరీ మొత్తం తగ్గించడం realloc కాలేదు
కానీ దాని గురించి ఆందోళన లేదు, అందుచే మాత్రమే realloc సందర్భంలో అన్నారు
, మెమరీ తగ్గిపోతున్న ఎప్పుడూ, మెమరీ పెరుగుతున్న
ఇది పాప్ సూపర్ సులభంగా అన్నారు.
స్టాక్స్ వంటి ఉంటాయని నేను ఇది ఇప్పుడు క్యూలు,
కానీ మీరు విషయాలు చేద్దామని ఆ క్రమాన్ని తలక్రిందులు ఉంది.
ఒక క్యూ యొక్క ప్రాధమిక ఉదాహరణ, ఒక లైన్
నేను మీరు ఇంగ్లీష్ అయితే ఊహించడం, నేను చెప్పి ఉండవచ్చు
ఒక క్యూ ఒక ప్రాధమిక ఉదాహరణ ఒక క్యూ ఉంది.
కాబట్టి ఒక లైన్ వలె, మీరు లైన్ లో మొదటి వ్యక్తి అయితే,
మీరు లైన్ నుండి మొదటి వ్యక్తిగా భావిస్తున్నారు.
మీరు లైన్ లో చివరి వ్యక్తి అయితే, మీరు సర్వీస్డ్ చివరి వ్యక్తి ఉంటాయని నేను.
స్టాక్ ఎల్ఐఎఫ్ఓ నమూనా ఉంది అయితే మేము ఆ FIFO నమూనా కాల్.
ఆ పదాలను అందంగా సార్వత్రిక ఉంటాయి.
>> స్టాక్స్ వంటి మరియు శ్రేణుల కాకుండా, క్యూలు సాధారణంగా మధ్యలో అంశాలను నిర్వహించడానికి వీలు లేదు.
ఇక్కడ, ఒక స్టాక్ మేము పుష్ మరియు పాప్ ఉన్నాయి.
ఇక్కడ, మేము వాటిని ఎన్క్యూ మరియు dequeue పిలుపునిచ్చారు ఏం.
నేను కూడా వాటిని మార్పు మరియు unshift అని విన్నాను.
నేను ప్రజలు పుష్ మరియు పాప్ క్యూలు కూడా దరఖాస్తు నేను విన్నాను చేసిన.
నేను, తొలగించడం ఇన్సర్ట్ విన్నాను
కాబట్టి పుష్ మరియు మీరు స్టాక్స్ మాట్లాడుకుంటే, మీరు నెట్టడం మరియు పాపింగ్ ఉన్నాయి, పాప్.
మీరు క్యూలు గురించి మాట్లాడుతూ ఉంటే, మీరు ఉపయోగించాలనుకుంటున్న పదాలు పొందగలిగేలా
చొప్పించడం మరియు తొలగింపు కొరకు, దీనిని ఏ ఎటువంటి ఏకాభిప్రాయం ఉంది.
కానీ ఇక్కడ, మేము ఎన్క్యూ మరియు dequeue ఉన్నాయి.
ఇప్పుడు, struct స్టాక్ struct దాదాపు ఒకేలా ఉంటుంది.
కానీ మేము తల ట్రాక్ ఉంటుంది.
నేను దానిని ఎక్కడా ఇక్కడ చెప్పారు ఊహించడం, అయితే ఎందుకు తల చేయాలి?
నమూనాలను పుష్ మరియు పాప్ ప్రధానంగా సమానంగా ఉంటాయి.
మీరు పుష్ మరియు పాప్ గా కూడా ఆలోచించవచ్చు.
మాత్రమే తేడా పాప్ ఉంది తిరిగి-బదులుగా గత యొక్క, అది మొదటి తిరిగి అని.
2, 1, 3, 4, లేదా ఏదో.
మరియు ఇక్కడ ప్రారంభిద్దాం.
మా క్యూ పూర్తిగా నిండినది, కాబట్టి అది నాలుగు అంశాలను ఉంది.
మా క్యూ ముగింపు, ప్రస్తుతం 2
మరియు ఇప్పుడు మేము ఏదో ఇన్సర్ట్ వెళ్ళండి.
>> మేము స్టాక్ వెర్షన్ కోసం మేము ఏమి else విధి, ఇన్సర్ట్ చెయ్యడానికి ఉంటుంది
మేము మెమరీ మా బ్లాక్ విస్తరించబడింది.
ఈ తో సమస్య ఏమిటి?
[స్టూడెంట్] మీరు 2 తరలించండి.
నేను క్యూ ముగింపులో ముందు చెప్పారు, ఏమి
ఈ, 1 వద్ద మేము ప్రారంభించండి సమంజసం అనిపించుకోదు
అప్పుడు మేము అప్పుడు dequeue 3, dequeue 4, dequeue 1 అనుకుంటున్నారా
అప్పుడు dequeue 2, అప్పుడు ఈ ఒక dequeue.
మేము ఇప్పుడు realloc ఉపయోగించలేరు
లేదా కనీసం, మీరు వేరే విధంగా realloc ఉపయోగించాలి.
కానీ మీరు బహుశా కేవలం realloc ఉపయోగించరాదు.
మీరు మానవీయంగా మీ మెమరీ కాపీ పొందబోతున్నారు.
>> మెమరీ కాపీ రెండు విధులు ఉన్నాయి.
Memcopy మరియు memmove ఉంది.
నేను ప్రస్తుతం మీరు ఉపయోగించాలనుకుంటున్న చూడాలని ఇది ఒక చూడటానికి man పేజీలను వింటున్నాను.
సరే, memcopy, తేడా
memcopy మరియు memmove, ఒక సరిగ్గా కేసు చూడటానికి
మీరు ప్రాంతంలో విస్త్రుతలతో జరిగినప్పుడు ఒక ప్రాంతంలో కాపీ ఎక్కడ
మీరు నుండి కాపీ చేస్తున్నారు.
Memcopy నిర్వహించేవి లేదు. Memmove చేస్తుంది.
మీరు-సమస్య యొక్క ఆలోచించవచ్చు
లెట్స్, నేను కాపీ అనుకుందాం
ఈ వ్యక్తి ఈ నాలుగు.
చివరకు, అర్రే ఇష్టం కనిపించాలి
కాపీ తర్వాత 2, 1, 2, 1, 3, 4, మరియు చివరిలో కొన్ని అంశాలను తర్వాత.
కానీ ఈ, మేము నిజంగా కాపీ ఏ క్రమంలో ఆధారపడి ఉంటుంది
మేము ప్రాంతంలో మేము లోకి కాపీ చేసిన వాస్తవం గనుక నుండి
భర్తీ మనం కాపీ చేసిన ఒక,
అప్పుడు మేము, ఇక్కడ ప్రారంభించండి ఇష్టపడతారు మేము వెళ్లాలనుకుంటే స్థానంలో 2 కాపీ ఉండవచ్చు
అప్పుడు ముందుకు మా గమనికలు తరలించండి.
>> ఇప్పుడు మేము ఇక్కడ మరియు ఇక్కడ చూడాలని, మరియు ఇప్పుడు మేము కాపీ మీరు
ఈ ఈ గై పైగా గై మరియు ముందుకు మా గమనికలు తరలించండి.
మనం పొందడానికి వదులుకోవడానికి వెళుతున్న, 1, 2, 1, 2, 1 2
బదులుగా తగిన 2 యొక్క, 1, 2, 1, 3, 4 ఎందుకంటే
2, 1 Original 3, 4 overrode.
Memmove సరిగ్గా ఆ నిర్వహిస్తోంది.
ఈ సందర్భంలో, ప్రధానంగా కేవలం ఎల్లప్పుడూ memmove ఉపయోగించడానికి
ఇది సరిగ్గా నిర్వహించే ఎందుకంటే.
ఇది సాధారణంగా ఏ దారుణంగా చెయ్యదు.
ఆలోచన బదులుగా నుండి ప్రారంభమై మరియు ఈ విధంగా కాపీ ఉంటుంది
మేము ఇక్కడ చేశాడు, ఇది చివరి నుండి మొదలవుతుంది మరియు కాపీ
మరియు ఆ సందర్భంలో, మీరు ఒక సమస్య ఎప్పుడూ.
ఏ ప్రదర్శన ఉన్నాయి పోతుంది.
ఎల్లప్పుడూ memmove ఉపయోగించండి. Memcopy గురించి ఆందోళన లేదు.
ప్రత్యేకంగా మీరు memmove రెట్లు వెళుతున్న మరియు ఆ
మీ క్యూ యొక్క చుట్టి-చుట్టూ భాగం.
కంగారుపడవద్దు పూర్తిగా చేస్తే లేదు.
స్టాకు, పుష్, మరియు పాప్ కన్నా ఎక్కువ కష్టం.
>> ఎవరైనా మేము తో పనిచేసే ఏ కోడ్ ఉందా?
పూర్తిగా అసంపూర్తిగా ఉంటే?
[స్టూడెంట్] అవును, అది అయితే, పూర్తిగా అసంపూర్తిగా ఉంది.
మేము మీరు పునర్విమర్శ సేవ్ వంటి పూర్తిగా అసంపూర్తిగా కాలం ఉత్తమంగా ఉంటుంది?
నేను ఆ ప్రతి సమయం మర్చిపోతే.
మేము విషయాలు పరిమాణాన్ని అవసరం వచ్చినప్పుడు సరే, దాన్ని విస్మరిస్తున్నారు జరుగుతుంది.
పూర్తిగా పునఃపరిమాణం విస్మరించండి.
ఈ కోడ్ వివరించండి.
పరిమాణం అన్ని మొదటి కాపీని కంటే తక్కువ ఉంటే నేను మొదటి అన్ని యొక్క తనిఖీ చేస్తున్నాను
మరియు ఆ తర్వాత, నేను ఇన్సర్ట్-I తల + పరిమాణం, పడుతుంది
మరియు నేను, అది యెరే యొక్క సామర్థ్యం చుట్టూ మూటగట్టి నిర్ధారించుకోండి
మరియు నేను ఆ స్థానంలో కొత్త స్ట్రింగ్ ఇన్సర్ట్.
అప్పుడు నేను పరిమాణం పెంచడానికి మరియు నిజమైన తిరిగి.
>> [రాబ్ B.] ఈ ఖచ్చితంగా మీరు mod ఉపయోగించి చేయండి వెళుతున్న ఆ సందర్భాలలో ఒకటి.
మీరు చుట్టూ చుట్టడం అనుకుంటే మీరు,, చుట్టూ చుట్టడం చేసిన సందర్భంలో అయినా
వెంటనే ఆలోచన mod ఉండాలి.
శీఘ్ర సర్వోత్తమీకరణం /, మీ కోడ్ ఒక లైన్ తక్కువగా అనిపిస్తుంది
మీరు లైన్ వెంటనే ఈ క్రింద అని గుర్తించలేకపోతే
కేవలం పరిమాణం + +, కాబట్టి మీరు విలీనం ఈ లైను, పరిమాణం + +.
డౌన్ ఇక్కడ ఇప్పుడు, మేము సందర్భాన్ని
అక్కడ, తగినంత మెమరీ లేదు
కాబట్టి మేము 2 మా సామర్థ్యం పెరుగుతుంది.
నేను మీరు ఇక్కడ అదే సమస్య కాలేదు అంచనా, కానీ మేము ఇప్పుడు విస్మరించవచ్చు
మీరు మీ సామర్థ్యాన్ని అయింది ఉంటే,
అప్పుడు మీరు మళ్ళీ 2 ద్వారా మీ సామర్థ్యం తగ్గుతుంది మీరు చూడాలని.
మరో చిన్న గమనిక మీరు చేయవచ్చు వలె ఉంటుంది + =,
మీరు కూడా << = చేయవచ్చు.
సమానం ముందు దాదాపు ఏదైనా కావచ్చు, + =, | =, & =, << =.
చార్ * కొత్త మెమరీ మా కొత్త బ్లాక్ ఉంది.
ఓహ్, ఇక్కడ పైగా.
>> ప్రజలు మెమరీ మా కొత్త బ్లాక్ రకం గురించి ఏమి ఆలోచిస్తాడు?
[స్టూడెంట్] ఇది చార్ ** ఉండాలి.
ఇక్కడ మా struct తిరిగి థింకింగ్,
తీగలను మేము reallocating ఏ ఉంది.
మేము క్యూలో మూలకాల కోసం ఒక సంపూర్ణ నూతన డైనమిక్ నిల్వ చేస్తున్నాము.
మనం మీ తీగలను కు కేటాయించి కావడం, మేము ప్రస్తుతం mallocing ఏమి ఉంది
అందువలన కొత్త చార్ ** అని అన్నారు.
ఇది తీగలను యొక్క వ్యూహం చేస్తాడు.
అప్పుడు మేము తప్పుడు తిరిగి చూడాలని ఇది కింద కేసు ఏమిటి?
[స్టూడెంట్] మేము చార్ * చేయడం ఉండాలా?
[రాబ్ B.] అవును, మంచి కాల్.
[స్టూడెంట్] ఏమిటి అని?
[రాబ్ B.] మేము ఏ ఎందుకంటే చార్ * యొక్క పరిమాణం చేయాలనుకుంటున్నామని పొడవైన
sizeof (చార్) 1 ఎందుకంటే ఇది నిజానికి ఒక చాలా పెద్ద సమస్య అవుతుంది.
Sizeof చార్ *, 4 అవతరిస్తుంది
కాబట్టి మీరు ints వ్యవహరించే చేసినప్పుడు సార్లు చాలా,
మీరు దానిని దూరంగా ఉంటాయి ఎందుకంటే Int * యొక్క Int మరియు పరిమాణం పరిమాణం
ఒక 32-bit వ్యవస్థ మీద ఇదే ఉంటాయని నేను.
కానీ ఇక్కడ, sizeof (చార్) మరియు sizeof (చార్ *) ఇప్పుడు ఇదే ఉంటాయని నేను.
>> మేము తప్పుడు తిరిగి పేరు పరిస్థితి ఏమిటి?
[స్టూడెంట్] న్యూ NULL.
కొత్త శూన్య ఉంటే అవును,, మేము, తప్పుడు తిరిగి
మరియు నేను క్రింద త్రో వెళుతున్న ఇక్కడ
[స్టూడెంట్] [వినబడని]
[రాబ్ B.] అవును, ఈ ఉత్తమంగా ఉంటుంది.
మీరు 2 సార్లు సామర్థ్యం లేదా సామర్థ్యం షిఫ్ట్ 1 మరియు అప్పుడు మాత్రమే ఇక్కడ లేదా అది డౌన్ సెట్ పని చేయడు.
మేము అప్పుడు వంటి మేము చేస్తాము.
సామర్థ్యం >> = 1.
మరియు మీరు 1 స్థానాన్ని కోల్పోయిన గురించి ఆందోళన కొనసాగుతుందని ఎప్పుడూ చేస్తున్నారు
మీరు 1 మారింది వదిలి కాబట్టి, 1 స్థానాన్ని, తప్పనిసరిగా ఒక 0
కాబట్టి కుడి 1 మార్చటం, మీరు ఇప్పటికీ జరిమానా చూడాలని.
[స్టూడెంట్] మీరు తిరిగి ముందు అలా చేయాలి?
[రాబ్ B.] అవును, ఈ ఖచ్చితంగా అర్థవంతంగా ఉంటుంది.
>> మేము చివర నిజమైన తిరిగి ముగుస్తుంది చూడాలని ఇప్పుడు భావిస్తాయి.
మేము ఈ memmoves చేయబోతున్నామని మార్గం,
మేము వాటిని ఎలా జాగ్రత్తగా ఉండాలి.
ఎవరైనా మేము వాటిని ఎలా ఏ సలహాలను కలిగి ఉందా?
ఇక్కడ మా ప్రారంభిద్దాం.
అనివార్యంగా, మేము మళ్ళీ ప్రారంభంలో ప్రారంభం కావాలి
అక్కడ నుండి మరియు కాపీ విషయాలు, 1, 3, 4, 2.
మీరు ఎలా చేయాలి?
మొదటి, నేను మళ్ళీ memmove కోసం మనిషి పేజీ చూడండి ఉంటుంది.
Memmove, వాదనలు క్రమాన్ని చాలా ముఖ్యం.
మేము మూల రెండవ, మూడవ పరిమాణం, మొదటి మా గమ్యం కావలసిన.
మూల మరియు గమ్య రివర్స్ ఇది విధులను కూడా ఉన్నాయి.
గమ్యం, మూల కొంతవరకు కలిగి ఉంటుంది.
Move, అది ఏ తిరిగి?
మీరు ఆ చేయవచ్చు కారణం ఏదైనా గమ్యానికి ఒక పాయింటర్ తిరిగి.
నేను చదువుకోవచ్చు చిత్రం, కాని మేము మా గమ్యం కి కావలసిన.
>> మా గమ్యం ఏమి జరుగుతుందో?
[స్టూడెంట్] న్యూ.
[రాబ్ B.] అవును, మరియు మేము నుండి కాపీ చేయబడతాయి?
మేము కాపీ చేయబడతాయి మొదటి విషయం ఈ 1, 3, 4 ఉంటుంది.
,, 4 3-ఈ 1 ఏమిటి.
ఈ 1 యొక్క చిరునామా ఏమిటి?
ఆ 1 యొక్క చిరునామా ఏమిటి?
[స్టూడెంట్] [వినబడని]
[రాబ్ B.] హెడ్ + మొదటి మూలకం యొక్క చిరునామా.
మేము ఎలా యెరే నందలి మొదటి మూలకం వస్తుందా?
[స్టూడెంట్] క్యూ.
[రాబ్ B.] అవును, q.strings.
గుర్తుంచుకోండి, ఇక్కడ, మా తల 1.
అది రంధ్రాన్ని సరి చేయు. కేవలం ఇది అని మంత్రవిద్య
ఇక్కడ, మా తల 1. నేను చాలా నా రంగు మార్చడానికి వెళుతున్న.
మరియు ఇక్కడ తీగలను ఉంది.
మేము ఇక్కడ పైగా వలె ఈ, మేము గాని అది రాయడం
తో తలలు + q.strings.
మంది కూడా వ్రాయుటకు & q.strings [తల].
ఇది నిజంగా ఏ తక్కువ సామర్థ్యం లేదు.
మీరు dereferencing ఆపై యొక్క చిరునామా పొందడానికి మీరు, ఆలోచించి ఉండవచ్చు
కానీ కంపైలర్ q.strings + తల, ఎలాగైనా మేము ముందు ఏ దానిని అనువదించు అన్నారు.
మీరు ఆలోచించి మీరు ఎలాగైనా.
>> మరియు ఎన్ని బైట్లు మేము కాపీ అనుకుంటున్నారు?
[స్టూడెంట్] కెపాసిటీ - తల.
కెపాసిటీ - తల.
ఆపై మీరు ఎల్లప్పుడూ ఒక ఉదాహరణను రాస్తుంది
అది నిజం ఉంటే గుర్తించడానికి.
[స్టూడెంట్] తర్వాత 2 ద్వారా విభజించబడింది అవసరం.
అవును, నేను మేము పరిమాణం ఉపయోగించవచ్చు అంచనా.
మేము ఇంకా పరిమాణం కలిగి ఉండటం-
పరిమాణం ఉపయోగించి, మేము 4 సమానంగా పరిమాణంలో ఉంటాయి.
మా పరిమాణం 4 ఉంటుంది. మా తల 1.
ఈ 3 అంశాలు కాపీ మీరు.
ఆ పవిత్రత ఆ పరిమాణం తనిఖీ ఉంది - తల సరిగ్గా 3.
మేము ముందు చెప్పారు వంటి మరియు, ఇక్కడ తిరిగి వచ్చే
మేము సామర్థ్యం ఉపయోగిస్తే, అప్పుడు మేము 2 విభజించడానికి భావిస్తాను
మేము ఇప్పటికే మా సామర్థ్యాన్ని పెంచే చేసిన కాబట్టి, బదులుగా, మేము పరిమాణాన్ని ఉపయోగిస్తుంది చూడాలని.
ఆ కాపీలు ఆ భాగం.
ఇప్పుడు, మేము ఇతర భాగాన్ని ప్రారంభానికి వదిలేస్తే ఆ భాగాన్ని కాపీ అవసరం.
>> ఏ స్థానం లో memmove వెళుతున్న?
[స్టూడెంట్] ప్లస్ పరిమాణం - తల.
అవును, కాబట్టి మేము ఇప్పటికే పరిమాణం కాపీ చేసినట్లు - తల బైట్లు,
అందువలన మేము మిగిలిన బైట్లు కాపీ చోట కొత్త ఉంది
ఆపై పరిమాణం మైనస్-బాగా, బైట్లు సంఖ్య మేము సైన్ కాపీ చేసిన
మరియు తర్వాత అక్కడ నుండి కాపీ చేయబడతాయి?
[స్టూడెంట్] Q.strings [0].
[రాబ్ B.] అవును, q.strings.
మేము దానిని & q.strings [0]. కాలేదు
ఈ కంటే తక్కువగా ఉంటుంది.
అది కేవలం 0 చేస్తాడు, అప్పుడు మీరు q.strings భావిస్తున్నారు చేస్తాము.
మనం కాపీ చేసిన పేర్కొంది.
మేము కాపీ ఎన్ని బైట్లు వదిలి ఉందా? >> [స్టూడెంట్] 10.
కుడి.
[స్టూడెంట్] మేము 5 గుణిస్తారు కు ఉందా - 10 సార్లు బైట్లు లేదా ఏదో యొక్క పరిమాణం?
అవును, ఈ పేరు అంటే సరిగ్గా మేము కాపీ చేయబడతాయి?
[స్టూడెంట్] [వినబడని]
మేము కాపీ చేసిన విషయం రకం ఏమిటి?
[స్టూడెంట్] [వినబడని]
వారి నుంచి వచ్చే అవును, చార్ * s మేము కాపీ చేస్తున్న కాబట్టి, మనం చెప్పలేము.
Well, వారు సూచించే ఎక్కడ, తీగలు వలె మేము వరుసలో ఇది నెట్టడం ముగుస్తుంది
లేదా వరుసలో enqueuing.
వారి నుంచి వచ్చే, మేము సంఖ్య ఆలోచన ఉంది.
మేము చార్ * s తమ ట్రాక్ అవసరం.
తల బైట్లు - మేము పరిమాణం కాపీ లేదు.
తల చార్ * s, - మేము పరిమాణం కాపీ మీరు
కాబట్టి మేము sizeof (చార్ *) ద్వారా ఈ గుణిస్తారు చూడాలని.
అదే డౌన్ ఇక్కడ, తల * sizeof (చార్ *).
>> [స్టూడెంట్] దేని గురించి [వినబడని]?
ఇక్కడ ఈ కుడి?
[స్టూడెంట్] కాదు, ఆ క్రింద, పరిమాణం - తల.
[రాబ్ B.] ఈ కుడి?
పాయింటర్ అంకగణితం.
అంక గణితానికి వెళ్లాలని ఎలా ఉంది
అది స్వయంచాలకంగా వ్యవహరించే చేస్తున్న రకం పరిమాణం గుణించబడుతుంది.
జస్ట్, ఇక్కడ పైగా వంటి కొత్త + (పరిమాణం - తల)
& కొత్త [- తల పరిమాణం] సమానంగా ఉంటుంది
మేము ఆ, సరిగ్గా పని అంచనా వరకు
మేము ఒక పూర్ణాంకానికి శ్రేణి వ్యవహరించే మీరు నుండి, తర్వాత మేము ద్వారా Int-ఇండెక్స్ లేదు
లోకి లేదా 5 యొక్క పరిమాణం మరియు మీరు 4 వ మూలకం కోరుకుంటే, మేము సూచిక
Int శ్రేణి [4].
మీరు don't-[4] Int యొక్క పరిమాణం *.
ఈ కేసు స్వయంచాలకంగా నిర్వహిస్తుంది, మరియు
సాహిత్యపరంగా సమానం, కాబట్టి బ్రాకెట్ సింటాక్స్
కేవలం వెంటనే మీకు కంపైల్ ఈ లాగ అన్నారు.
మీరు ఆ జాగ్రత్తగా ఉండాలి సమ్థింగ్ '
మీరు పరిమాణం జోడించడం చేసినప్పుడు - తల
మీరు ఒక బైట్ కాదు జోడిస్తున్నారు.
మీరు ఒక బైట్లు లేదా ఎలాగైనా ఉండవచ్చు, ఒక చార్ * జోడించే.
>> ఇతర ప్రశ్నలు?
సరే, dequeue సులభంగా అన్నారు.
నేను మీరు అమలు చేయడానికి ఒక నిమిషం ఇస్తాము.
ఓహ్, నేను ఇదే పరిస్థితి అంచనా పేరు
ఏ ఎన్క్యూ కేసు మేము శూన్య enqueuing చేస్తుంటే,
బహుశా మేము అది నిర్వహించడానికి కావలసిన, బహుశా మేము లేదు.
మేము ఇక్కడ మళ్ళీ ఇది, కాని మా స్టాక్ కేసు అదే కాదు.
మేము శూన్య ఎన్క్యూ, దాన్ని మేము విస్మరించవచ్చు అనుకోవచ్చు.
ఎవరైనా నేను పుల్ అప్ చేయవచ్చు కొన్ని కోడ్ ఉందా?
[స్టూడెంట్] నేను dequeue ఉన్నాయి.
వెర్షన్ 2 అని-సరే.
మీరు వివరించేందుకు అనుకుంటున్నారా?
[స్టూడెంట్] మొదట, మీరు క్యూలో విషయం ఏదైనా నిర్ధారించుకోండి
మరియు పరిమాణం 1 గోయింగ్ డౌన్ ఆ.
మీరు అలా అవసరం లేదు, మరియు అప్పుడు మీరు తల తిరిగి
మరియు తర్వాత 1 అప్ తల తరలించండి.
సరే, మేము పరిగణించాలి ఒక మూలలో ఆధారాలున్నాయి. అవును.
[స్టూడెంట్], మీ తల గత మూలకం వద్ద ఉంటే
అప్పుడు మీరు తల శ్రేణి వెలుపల మార్చాలి లేదు.
>> అవును, కాబట్టి వెంటనే తల, మా శ్రేణి ముగింపు హిట్స్
మేము dequeue ఉన్నప్పుడు, మా తల 0 తిరిగి modded చేయాలి.
దురదృష్టవశాత్తు, మేము ఒక దశ లో అలా కాదు.
నేను బహుశా అది పరిష్కరించడానికి కావలసిన విధంగా అంచనా
ఈ, మేము తిరిగి ఏమి ఒక చార్ * అని అన్నారు
మీ వేరియబుల్ పేరు చేయాలనుకుంటున్నారు ఏ.
అప్పుడు మేము మా సామర్థ్యం ద్వారా తల MoD మీరు
ఆపై Ret తిరిగి.
ఇక్కడ మంది అవి-ఉండవచ్చు
ఈ-you'll యొక్క సందర్భంలో ప్రజలు చూడగలరు ఉంటే తల
సామర్థ్యం కంటే ఎక్కువగా తల చేయండి - సామర్థ్యం.
మరియు కేవలం mod ఏమి చుట్టూ పనిచేస్తున్న.
హెడ్ ​​mod = సామర్థ్యం చాలా శుభ్రంగా ఉంది
సామర్థ్యం -. చుట్టూ సామర్థ్యం తల కంటే తల ఎక్కువ ఉంటే కంటే కట్టి యొక్క
>> ప్రశ్నలు?
సరే, మేము వదలి లాస్ట్ థింగ్ మా అనుబంధ జాబితా ఉంది.
మీరు చేస్తే మీరు లింక్ జాబితా ప్రవర్తన యొక్క కొన్ని ఉపయోగించవచ్చు
మీరు ఒక హాష్ పట్టిక, మీ హాష్ పట్టికలలో జాబితాలు లింక్.
నేను గట్టిగా హాష్ పట్టిక సిఫార్సు చేస్తున్నాము.
మీరు ఇప్పటికే ఒక trie చేసి ఉండవచ్చని
కానీ ప్రయత్నాలు మరింత కష్టం.
సిద్ధాంతంలో, వారు asymptotically మెరుగైన ఉన్నాము.
కానీ, పెద్ద బోర్డు చూడండి
మరియు బాగా ఎప్పటికీ ప్రయత్నిస్తుంది, మరియు వారు మరింత మెమరీ పడుతుంది.
ప్రతిదీ గురించి మరింత పని నష్టం ఉండటం ముగుస్తుంది ప్రయత్నిస్తుంది.
ఇది డేవిడ్ మలన్ యొక్క పరిష్కారం ఎప్పుడు ఏమిటి యొక్క
అతను ఎప్పుడూ తన పోస్ట్స్ trie పరిష్కారం, మరియు ప్రస్తుతం ఉన్న యొక్క చూసేలా.
అతను డేవిడ్ J, కింద ఏమిటి?
అతను # 18 యొక్క, ఆ భయంకరమైన చెడు కాదు కాబట్టి
మరియు ఉత్తమ ఒకటిగా జరగబోతోంది మీరు కూడా ఆలోచించవచ్చు ప్రయత్నిస్తుంది
లేదా ఉత్తమ ఒక trie యొక్క ప్రయత్నిస్తుంది.
అది తన అసలైన పరిష్కారం కూడా కాదు?
Trie SOLUTIONS RAM వాడుక ఈ పరిధిలో మరింత ఉంటాయి అని నేను భావిస్తున్నాను.
>> చాలా పైకి క్రిందికి వెళ్ళు, మరియు RAM వాడుక ఒకే అంకెలు ఉంది.
దిగువ దిశగా డౌన్ వెళ్లి, మీరు ప్రయత్నిస్తుంది చూడడాన్ని ప్రారంభించడానికి
మీరు ఖచ్చితంగా భారీ RAM వాడుక చోటే,
మరియు ప్రయత్నాలు మరింత కష్టం.
పూర్తిగా కానీ ఒక విద్యా అనుభూతిని విలువ మీరు ఒక చేస్తే.
లాస్ట్ థింగ్, మా లింక్ జాబితా
మరియు ఈ మూడు విషయాలు, స్టాక్స్, క్యూలు, మరియు అనుసంధాన జాబితాలు,
మీరు కంప్యూటర్ సైన్స్ లో ఏమి భవిష్యత్తులో విషయం
మీరు ఈ విషయాలు దగ్గిర ఉన్నాయి నష్టమని అంచనా.
వారు ప్రతిదీ చేయడం పోషిస్తాయి.
>> జాబితాలు లింక్, మరియు ఇక్కడ మేము ఒక ఒక్కొక్కటిగా లింక్ జాబితా మా అమలు ఉండబోతుంది ఉన్నాయి.
ఒక్కొక్కటిగా ఏమిటి సంబంధం లేదు వంటి రెట్టింపైన లింక్ వ్యతిరేకంగా అర్థం? అవును.
[స్టూడెంట్] ఇది మాత్రమే, తదుపరి పాయింటర్ కంటే గమనికలు పాయింతు
అది తరువాత ఒక ముందు ఒక ఇష్టపడుతున్నారు.
అవును, కాబట్టి చిత్రాన్ని ఫార్మాట్, నేను ఏం చేసావ్?
నేను రెండు విషయాలు ఉన్నాయి. నేను చిత్రం మరియు చిత్రం కలిగి.
చిత్రం ఫార్మాట్ లో, మా ఒక్కొక్కటిగా లింక్ జాబితాలు,
అనివార్యంగా, మేము, మా జాబితా యొక్క తలపై పాయింటర్ రకమైన కలిగి
తరువాత మా జాబితా లోపల, మనం కేవలం గమనికలు కలిగి
మరియు ఇంకా ఈ పాయింట్లు శూన్యం కు.
ఇది ఒక ఒక్కొక్కటిగా లింక్ జాబితా యొక్క మీ సాధారణ డ్రాయింగ్ చేస్తాడు.
నటన ఎన్నటికీ లింక్ జాబితా, మీరు వెనుకకు వెళ్ళవచ్చు.
నేను మీరు జాబితా ఏదైనా నోడ్ ఇవ్వాలని, అప్పుడు మీరు తప్పనిసరిగా పొందవచ్చు
ఇతర నోడ్ జాబితాలో నటన ఎన్నటికీ లింక్ జాబితా ఉంది.
కానీ, నేను మీరు జాబితాలో మూడవ నోడ్ పొందండి మరియు ఒక ఒక్కొక్కటిగా లింక్ జాబితా ఉంటే,
మీరు మొదటి మరియు రెండవ నోడ్స్ ను చూడాలని. కాదు
మరియు ప్రయోజనాలు మరియు నష్టాలు, మరియు ఒక స్పష్టమైన ఒక ఉంది
మీరు మరింత పరిమాణం పడుతుంది, మరియు మీరు ఈ విషయాలు పై ఇక్కడ ట్రాక్ చేస్తుంది.
కానీ మేము కేవలం ఒక్కొక్కటిగా లింక్ శ్రద్ధ.
>> మేము అమలు చూడాలని కొన్ని విషయాలు.
మీ typedef struct నోడ్, Int నేను: struct నోడ్ * తదుపరి నోడ్.
ఆ typedef మీ మనస్సులలో లోకి బూడిద చేయాలని.
Quiz 1, అనుబంధ జాబితా నోడ్ యొక్క ఒక typedef ఇవ్వాలని ఇష్టం చేయాలి
మరియు మీరు వెంటనే ఆ డౌన్ ని విధంగా ఉండాలి
దాని గురించి ఆలోచించకుండా.
నేను ఒక జంట ప్రశ్నలు ఊహించడం, మనం ఇక్కడ struct చేయాలి?
ఎందుకు మేము నోడ్ * చెప్పలేని?
[స్టూడెంట్] [వినబడని]
అవును.
ఒక విషయం ఒక నోడ్ నిర్వచిస్తుంది మాత్రమే విషయం
స్వయంగా typedef ఉంది.
కానీ ఈ పాయింట్, మేము ఈ struct నోడ్ నిర్వచనం ద్వారా పార్సింగ్ రకమైన ఉన్నప్పుడు,
మేము, typedef పూర్తి కాలేదు కాబట్టి నుండి, ఇంకా మా typedef పూర్తి చెయ్యలేదు
నోడ్ లేదు.
కానీ struct నోడ్ చేస్తుంది, మరియు ఈ నోడ్ ఇక్కడ,
ఈ కూడా ఏదైనా చెప్పబడతాయి.
ఈ n చెప్పబడతాయి.
ఇది అనుబంధ జాబితా నోడ్ చెప్పబడతాయి.
ఇది ఏదైనా చెప్పబడతాయి.
కానీ ఈ struct నోడ్ ఈ struct నోడ్ అదే విషయం అని ఉంటుంది.
మీరు ఈ కూడా ఇక్కడ ఉండాలి కాల్ ఏమిటి,
మరియు కనుక ప్రశ్న రెండవ స్థానం సమాధానం
ఎందుకు-ఒక మీరు structs మరియు structs యొక్క typedefs చూసినప్పుడు సార్లు చాలా, ఇది
మీరు typedef struct చూస్తారు మీరు, అనామక structs చూస్తారు
struct, నిఘంటువు లేదా ఎలాగైనా అమలు.
>> ఎందుకు ఇక్కడ మేము నోడ్ సే చేయాలి?
ఎందుకు అది ఒక అనామక struct ఉండకూడదు?
ఇది దాదాపు అదే సమాధానం ఉంది.
[స్టూడెంట్] మీరు struct లోపల అది చూడండి అవసరం.
అవును, struct లో, struct కూడా చూడండి అవసరం.
మీరు struct ఒక పేరు ఇచ్చి లేకపోతే అది ఒక అనామక struct అయితే, మీరు చూడండి కాదు.
మరియు చివరి కాని తక్కువ ఈ అన్ని ఉండాలి కొంతవరకు సూటిగా లేదు,
మీరు ఈ లిఖించడానికి అయితే వారు మీరు తెలుసుకుంటారు సహాయం చేయాలి
విషయాలు ఈ రకమైన సమంజసం మీరు ఏదో తప్పు చేస్తున్న.
చివరిది కానీ, ఎందుకు ఈ struct నోడ్ * ఉండాలి లేదు?
ఎందుకు అది తర్వాతి నోడ్ struct సాధ్యం కాదు?
తదుపరి struct కు [స్టూడెంట్] పాయింటర్.
అంటే ఏమి అనివార్యంగా ఉంది.
ఎందుకు తదుపరి struct నోడ్ ఎప్పటికీ కాలేదు?
ఎందుకు అది * తర్వాత struct నోడ్ ఉండాలి లేదు? అవును.
[స్టూడెంట్] ఇది ఒక అనంతమైన లూప్ వంటిది.
అవును.
[స్టూడెంట్] ఇది అన్నీ ఒకే ఉంటుంది.
అవును, కేవలం మేము యొక్క పరిమాణం లేదా ఏదో ఒకటి ఎలా భావిస్తారు.
ఒక struct పరిమాణం రప్పించింది + లేదా - ఇక్కడ లేదా అక్కడ కొన్ని నమూనా.
ఇది ప్రాథమికంగా struct వస్తువుల పరిమాణాలు మొత్తం చేస్తాడు.
ఇక్కడ ఈ కుడి, ఏదైనా మార్చకుండా, పరిమాణం సులభంగా అన్నారు.
Struct నోడ్ యొక్క పరిమాణం తరువాతి నేను + పరిమాణం పరిమాణం అవతరిస్తుంది.
నేను పరిమాణం 4 అని అన్నారు. తదుపరి పరిమాణం 4 అని అన్నారు.
Struct నోడ్ యొక్క పరిమాణం 8 అని అన్నారు.
మేము * లేకపోతే, sizeof ఆలోచన
అప్పుడు sizeof (i) 4 అని అన్నారు.
Struct నోడ్ యొక్క పరిమాణం తదుపరి తదుపరి struct నోడ్ యొక్క + పరిమాణం నేను పరిమాణం ఉండబోతుంది
తదుపరి struct నోడ్ యొక్క నేను + పరిమాణం + పరిమాణం.
ఇది నోడ్స్ యొక్క ఒక అనంత సూత్రం ఉంటుంది.
ఈ విషయాలు ఉండాలి ఎలా ఎందుకు ఉంది.
>> మళ్లీ, ఖచ్చితంగా, ఆ గుర్తు
లేదా కనీసం మీరు వీటిని వీలుగా అది అర్థం
అది ఎలా ఉండాలో ద్వారా కారణం.
మేము అమలు చేయండి వెళుతున్న విషయాలు.
ఉంటే పొడవు జాబితా-
మీరు మోసం మరియు ఒక చుట్టూ కీపింగ్ చేయవచ్చు
ప్రపంచ పొడవు లేదా ఏదో, కాని మేము ఆ పని చేస్తారో లేదు.
మేము జాబితా పొడవు లెక్కించడానికి వెళుతున్న.
మేము కలిగి ఉన్నాయి, ప్రాథమికంగా ఒక శోధన వంటిది కనుక
కాబట్టి మేము ఈ పూర్ణాంక లింక్ జాబితాలో ఉంటే చూడటానికి పూర్ణాంకాల యొక్క లింక్ జాబితా.
Prepend జాబితా ప్రారంభంలో ఇన్సర్ట్ అన్నారు.
చేర్చు చివరిలో ఇన్సర్ట్ అన్నారు.
Insert_sorted జాబితాలో క్రమబద్ధీకరించబడతాయి స్థానం ఇన్సర్ట్ అన్నారు.
యొక్క Insert_sorted రకమైన మీరు prepend ఉపయోగిస్తారు లేదా చెడు మార్గాల్లో జోడించు ఎప్పుడూ తెలుపుతాయి.
>> మీరు అమలు చేసినప్పుడు insert_sorted-Insert_sorted
లెట్స్ మేము మా లింక్ జాబితా చెప్పారు.
ఇది ప్రస్తుతం 5, 4, 2, ఎలా ఉంటుంది.
నేను, కాబట్టి కాలం జాబితా కూడా ఇప్పటికే క్రమబద్ధీకరించబడింది వంటి, 3 ఇన్సర్ట్ చెయ్యడానికి మీరు
ఇది 3 చెందిన ఎక్కడ వెతకాలో సులభం.
నేను 2 వద్ద ప్రారంభించండి.
సరే, 3 2 కంటే ఎక్కువ, కాబట్టి నేను వెళ్ళడం ఉంచాలని.
ఓహ్, 4 చాలా పెద్దది, నేను 3 2 మరియు 4 మధ్య వెళ్లి అన్నారు తెలుసు
మరియు నేను గమనికలు మరియు అన్ని అంశాలను పరిష్కరించడానికి ఉన్నాయి.
కానీ మేము ఖచ్చితంగా, insert_sorted ఉపయోగించడానికి పొతే
ఇష్టం లెట్స్ కేవలం, నేను 6 prepend సే
నా అనుబంధ జాబితా ఈ మారింది అన్నారు.
ఇది ఇప్పుడు insert_sorted కోసం, మీరు పొందవచ్చు కనుక, అస్సలు అర్ధమే లేదు
కార్యకలాపాలు ఉన్నాయి అయినప్పటికీ జాబితా, క్రమబద్ధీకరించబడింది ఆ
అది వేరు కాదు కారణమవుతాయి, అంతే.
ఆ మీరు అమలు చూడాలని ప్రధాన విషయాలు ఒక ఉపయోగపడిందా చొప్పించు-కాబట్టి కనుగొనండి.
>> ప్రస్తుతం,, పొడవు చేయడానికి నిమిషం మరియు కలిగి
మరియు ఆ చాలా త్వరగా ఉండాలి.
ముగింపు సమయం సమీపంలో, కాబట్టి ఎవరైనా పొడవు కోసం ఏదైనా లేదా కలిగి?
వారు దాదాపు ఒకేలా మాత్రం చేస్తున్నారు.
[స్టూడెంట్] పొడవు.
, చూడండి పునర్విమర్శ లెట్.
సరే.
మీరు వివరించేందుకు అనుకుంటున్నారా?
[స్టూడెంట్] నేను పాయింటర్ నోడ్ సృష్టించడానికి మరియు మా గ్లోబల్ వేరియబుల్ ఇది మొదటి, దానిని ప్రారంభించటానికి,
తరువాత నేను ఒక seg లోపం పొందండి మరియు ఒకవేళ 0 తిరిగి కాబట్టి అది శూన్య అయితే తనిఖీ చేయండి.
లేకపోతే, నేను ద్వారా లూప్, పూర్ణాంక లోపల పర్యవేక్షించడం
నేను జాబితా యొక్క తదుపరి మూలకం ప్రాప్తి మీరు ఎన్ని సార్లు
మరియు అదే పెంపు ఆపరేషన్ లో కూడా, నిజమైన మూలకం యాక్సెస్
మరియు నేను నిరంతరం, అది శూన్య అయితే చెక్ చూడండి చేయడానికి
అది శూన్య అయితే మరియు, అది aborts మరియు కేవలం నేను ప్రాప్తి చేసిన అంశాల సంఖ్యను చూపిస్తుంది.
>> [రాబ్ B.] ఎవరైనా ఏదైనా ఏ వ్యాఖ్యలు కలిగి ఉందా?
ఈ జరిమానా సరి పద్ధతి ఉంది.
[స్టూడెంట్] నేను మీరు నోడ్ == శూన్య అవసరం భావించడం లేదు.
అవును, కాబట్టి నోడ్ ఉంటే == శూన్య తిరిగి 0.
కానీ నోడ్ == శూన్య ఈ-OH, ఒక సరి సమస్య ఉంటే.
ఇది నాకు తిరిగి చేస్తున్నారు, కానీ ఇప్పుడు అది పరిధిని కాదు.
మీరు Int నేను అవసరం, కాబట్టి నేను = 0.
నోడ్ శూన్య ఉంటే కానీ, అప్పుడు నేను ఇప్పటికీ 0 అవతరిస్తుంది
మరియు మేము తిరిగి 0 చూడాలని, ఈ సందర్భంలో ఒకేలా ఉంటుంది.
మరొక సాధారణ విషయం ప్రకటన ఉంచుకోవడం
లూప్ యొక్క నోడ్ లోపలి.
యు సే-OH కాలేదు ఏ.
ఈ ఉంచేందుకు యొక్క లెట్.
నేను బహుశా, Int i = 0 ఇక్కడ ఉంచుతాడు
అప్పుడు నోడ్ * నోడ్ = ఇక్కడ మొదటి.
మరియు ఈ ఇప్పుడు ఈ విమోచనం-పొందడానికి ఎలా కావచ్చు.
ఈ నేను రాసిన ఎలా కావచ్చు.
మీరు ఈ దాన్ని కూడా వైపు చూస్తున్న కాలేదు.
ఇక్కడే లూప్ నిర్మాణం కోసం ఈ
Int i = 0 కోసం మీ దాదాపు వంటి సహజ ఉండాలి
నేను శ్రేణి యొక్క పొడవు కంటే తక్కువగా ఉంటుంది నేను + +.
మీరు వ్యూహం మీద iterate ఎలా ఉంటే, ఈ మీరు ఒక లింక్ జాబితా పై iterate ఎలా ఉంది.
>> ఈ సందర్భంలో రెండవ ప్రకృతి ఉండాలి.
గ్రహించండి, ఈ దాదాపు అదే కాదు అన్నారు.
మీరు అనుబంధ జాబితా పై iterate మీరు చూడాలని.
ఉంటే నోడ్-I విలువ పిలవబడే సంఖ్య ఆలోచన ఉంది.
నోడ్ నేను.
ఆ నోడ్ వద్ద విలువ = i నిజమైన తిరిగి, అంతే ఉంటే.
గమనికను మేము ఎప్పుడూ తప్పుడు తిరిగి ఏకైక మార్గం
మేము మొత్తం లింక్ జాబితా పై iterate మరియు నిజమైన తిరిగి ఎప్పుడూ ఉంటుంది,
కాబట్టి యొక్క ఈ ఏమి చేస్తుంది.
ఒక వైపు గుర్తించదగిన మేము బహుశా కలపవచ్చు లేదా prepend కు అందదు.
>> త్వరిత చివరి గమనించండి.
మీరు స్టాటిక్ కీవర్డ్ చూసినట్లయితే, కాబట్టి, స్థిర Int COUNT = 0 అని పిలవబడు
అప్పుడు మేము COUNT చేయండి + +, మీరు ప్రాథమికంగా ఒక భౌగోళిక వేరియబుల్ దానిని ఆలోచించవచ్చు,
నేను ఈ మేము పొడవు అమలు చూడాలని ఎలా లేనని చెప్పాడు కూడా.
నేను ఇక్కడ ఈ చేయడం మరియు తర్వాత + + COUNT చేస్తున్నాను.
మేము మా COUNT పెంచడం ఉంటాయి మా అనుబంధ జాబితా ఒక నోడ్ ఎంటర్ విధంగా.
ఈ పాయింట్ స్టాటిక్ కీవర్డ్ అంటే ఏమిటి.
నేను Int COUNT కలిగి ఉంటే = రెగ్యులర్ పాత ప్రపంచ వేరియబుల్ అని 0.
ఏ స్థిర Int COUNT అనగా ఈ ఫైల్ కోసం ప్రపంచ వేరియబుల్ ఉంటుంది.
ఇది కొన్ని ఇతర ఫైల్ కోసం అసాధ్యం
మీరు ప్రారంభించారు ఉంటే, pset 5 భావిస్తారు ఇష్టం.
, మీరు రెండు speller.c కలిగి, మరియు మీరు dictionary.c కలిగి
మరియు మీరు speller.c, అప్పుడు ఏదైనా ప్రపంచ ఒక ప్రకటించే విషయం ఉంటే
dictionary.c మరియు తదనుగుణ్యాలను ప్రాప్తి చేయవచ్చు.
గ్లోబల్ వేరియబుల్స్, ఏ. సి ఫైల్ ద్వారా అందుబాటులో ఉంటాయి
కానీ స్టాటిక్ వేరియబుల్స్, ఫైలు లోపలే నుండి మాత్రమే అందుబాటులో ఉంటాయి
కాబట్టి లోపల dictionary.c యొక్క స్పెల్ చెకర్ లేదా లోపల యొక్క,
ఈ నా శ్రేణి యొక్క పరిమాణం నా వేరియబుల్ డిక్లేర్ ఎలా రకం
లేదా నిఘంటువు పదాలు నా సంఖ్య పరిమాణాన్ని.
నేను ఎవరికీ ఆక్సెస్ ఒక ప్రపంచ వేరియబుల్ ప్రకటించాలని మీరు కాబట్టి,
నేను నిజంగా నా సొంత ప్రయోజనాల కోసం ఇది పట్టించుకోనట్లు.
>> ఈ గురించి మంచి విషయం కూడా మొత్తం పేరు తాకిడి stuff ఉంది.
కొన్ని ఇతర ఫైల్ COUNT పేరుతో ఒక అంతర్జాతీయ వేరియబుల్ ఉపయోగించడానికి ప్రయత్నిస్తే, విషయాలు చాలా తప్పు,
, ఈ తగిలిన విషయాలను దూరంగా ఉంచుతుంది, మరియు మీరు దాన్ని ఆక్సెస్ చెయ్యవచ్చు
మరియు ఎవరూ మరియు ఇతరులు COUNT పేరుతో ఒక అంతర్జాతీయ వేరియబుల్ ప్రకటించాడు ఉంటే,
అప్పుడు లెక్కింపు అని పిలువబడుతుంది మీ స్టాటిక్ వేరియబుల్ జోక్యం లేదు.
ఆ స్థిరమైనది ఏమిటి. ఇది ఒక ఫైల్ ప్రపంచ చరరాశి.
>> ఏదైనా ప్రశ్నలకు?
అన్ని సెట్. ఇక సెలవు.
[CS50.TV]