[సంగీతాన్ని]
>> డేవిడ్ J. మలన్: అన్ని కుడి.
ఈ CS50 ఉంది.
మరియు ఈ వారం 5 ప్రారంభంలో ఉంది.
మరియు మీరు గమనించి ఉండవచ్చు గా, కొన్ని విషయాలు
కొంచెం పెరిగిపోతుంది క్లిష్టమైన, తక్కువ దట్టమైన.
>> మరియు అది ముఖ్యంగా, చాలా సులభం మీరు కొంత సమయం కోసం అలవాటు ఉన్నాను
అత్యంత డౌన్ ని ప్రయత్నిస్తున్న మేము ఏదైనా, మేము తరగతి లో మాట్లాడుతూ చేస్తున్నారు.
కానీ ఆ బహుశా కాదు, గుర్తించలేరు ఆదర్శ బోధనకు విధానం
పదార్థం యొక్క ఈ రకమైన జ్ఞానార్జన, మరియు పదార్థం మరింత సాధారణంగా.
కాబట్టి మనం సంతోషిస్తున్నారు ఆ CS50 యొక్క సొంత Gheng ప్రకటించిన
గాంగ్ సిద్ధం ప్రారంభించింది గమనికలు యొక్క సాధారణ సెట్
కోర్సు కోసం, ఆశ ఇది ఈ, ఒకటి
మాత్రమే అందజేయడం సూచన మరియు ఒక వనరు
పదార్థం సమీక్షించిన మరియు వెళుతున్న కోసం తిరిగి పదార్థం ద్వారా కలిగి ఉండవచ్చని
మీరు చుట్టూ మొదటిసారి తప్పించుకుంటాడు కానీ కూడా తద్వారా మీ తలలు ఉంటుంది మరింత
డౌన్, అది కంటే అప్ ఉపన్యాసాలిచ్చేందుకు సమయం వస్తుంది,
మీరు నిమగ్నం కావచ్చు కనుక మరింత thoughtfully, వంటి
మరింత scribbly వ్యతిరేకంగా.
>> అన్నారు తో, మీరు పొందుతారు ఏమి వెబ్సైట్ ఈ వంటి పత్రాలు ఉంది.
మరియు ప్రకటన, ఎడమ ఎగువన ఉంది మాత్రమే విషయాల పట్టిక,
కానీ సమయం సంకేతాలు అని వెంటనే మీరు జంప్
తగిన భాగం వీడియో ఆన్లైన్.
మరియు ఇక్కడ ఏమి చాంగ్ చేశారు , తప్పనిసరిగా, పత్ర
ఏమి ఈ జరిగిన ప్రత్యేక ఉపన్యాసం.
మరియు ఉపన్యాసాలు అనేక ఇప్పటికే ఇప్పుడు ఆన్లైన్ ఈ URL తో.
మరియు మేము మిగిలిన పోస్ట్ చేస్తాము ఈ వారం చివరికి ఆ,
కాబట్టి ఆ రిసోర్స్ ప్రయోజనాన్ని లేదు.
>> కనుక తదుపరి శ్రమ లేకుండా, మేము తిరిగి రాలిపోవడం ప్రారంభించారు
ఉంది ఆ పొర కొంత సమయం కోసం స్ట్రింగ్.
మరియు మేము ఒక స్ట్రింగ్ ఏమి లేదు నిజానికి గత వారం?
కాబట్టి చార్ స్టార్.
మరియు చార్ స్టార్, బాగా, ఏమి నిజంగా అర్థం లేదు?
Well, ఈ సమయంలో, మేము చేసిన ఉంటే ఒక ఫంక్షన్ కాల్,
GetString, మరియు నిల్వ వంటి అని పిలవబడే తిరిగి
ఒక లో GetString విలువ వేరియబుల్ అది అని
మేము రాయడం చేసిన స్ట్రింగ్ s రకం అక్కడికి ఎగువ కోడ్ లైన్.
నేను చూసినప్పుడు ఇది మాత్రమే నా చేతిరాత ఇక్కడ వృద్ధి
నేను ఈ కేవలం ఎంత దారుణమైన రియలైజ్.
>> అయితే, ఆ యొక్క ఊహించుకోవటం తెలియజేయండి, కుడి వైపు
, అయితే, ఒక సహేతుకమైన ఉంది ఏది చిత్రణ
ఈ జరుగుతున్నాయి GetString తో సమయం.
GetString, కోర్సు యొక్క, ఒక స్ట్రింగ్ పొందుతాడు.
కానీ నిజంగా అర్థం ఏమిటి?
ఇది ఒక భాగం అవుతుందని అర్ధం ఆపరేటింగ్ సిస్టమ్ నుండి మెమరీ
ఒక చర్యను కాల్ చేస్తున్నప్పుడు, malloc అని.
కానీ ఆ తర్వాత.
ఆపై దానిని populates మెమరీ ఆ భాగం
అక్షరాలతో వినియోగదారు ఉంది , లో టైప్ తరువాత, కోర్సు యొక్క,
ఒక శూన్య పాత్ర, లేదా బాక్ స్లాష్ చాలా చివరిలో సున్నా.
>> ఇంతలో, ఎడమ చేతి వైపు ఈ కథ, ఈ సమయంలో,
మేము, వంటి ఒక వేరియబుల్ ప్రకటించారు చేసిన.
మరియు ఆ వేరియబుల్ ఇప్పుడు ఏమిటి ఒక పాయింటర్ కాల్ ప్రారంభించడానికి ఉంటుంది.
ఇది లోపల ఇది బాక్స్ కాదు మేము స్ట్రింగ్ చాలు, Daven, ప్రతి SE,
కానీ మేము ఆ చదరపు చాలు ఎడమ వేటి బాక్స్?
అవును?
>> ప్రేక్షకులు: పాఠశాల చిరునామా మెమరీ లో ఉన్న యొక్క.
>> డేవిడ్ J. మలన్: ఖచ్చితంగా.
Daven పేరు యొక్క చిరునామా మెమరీలో ఉన్న.
మరియు Daven అన్ని ఉన్న పేరు కేవలంగా, కానీ ప్రత్యేకంగా చిరునామా
ఏమి?
అవును?
>> ప్రేక్షకులు: మొదటి పాత్ర.
>> డేవిడ్ J. మలన్: మొదటి పాత్ర ఈ సందర్భంలో Daven, దీనిలో,
నేను ఏకపక్ష ఉంది ప్రతిపాదించారు అవాస్తవ రీతిలో 1, Ox1,
ఇది కేవలం అర్థం 1 హెక్సాడెసిమల్ సంఖ్య.
కానీ అది బహుశా జరగబోతోంది ఒక పెద్ద సంఖ్య అని
మేము డ్రా ఉండవచ్చు ఉపసర్గ ఒక 0x తో,
ఒక హెక్సాడెసిమల్ పాత్ర సూచిస్తున్న.
మరియు మేము తెలుసుకోవాలి లేదు ఎందుకంటే Daven అక్షరాలు మిగిలిన
ఎందుకంటే, ఏమిటో సాధారణ డిజైన్ నిర్ణయం అనేక సంవత్సరాల క్రితం జరిగింది?
అవును?
>> ప్రేక్షకులు బ్యాక్స్లాష్ 0.
డేవిడ్ J. మలన్: అవును, సరిగ్గా.
బాక్ స్లాష్ 0 లో అయితే, మీరు అనుమతిస్తుంది సరళ సమయం, స్ట్రింగ్ ప్రయాణించేందుకు,
ఎడమ నుండి కుడికి నడిచి, ఒక లూప్ లేదా కొంత తో
లూప్, లేదా ఏదో వంటి ఆ, మరియు ఇక్కడ, OH, గుర్తించడానికి
ఈ ప్రత్యేక స్ట్రింగ్ ముగింపు.
కేవలం చిరునామాతో కాబట్టి ఒక స్ట్రింగ్ ప్రారంభంలో,
మేము సంపూర్ణంగా యాక్సెస్ చేయవచ్చు అది అన్ని ఈ ఎందుకంటే,
ఒక స్ట్రింగ్ కేవలం ఒక చార్ స్టార్ ఉన్నారు.
>> కనుక ఇది ఉపయోగించడం కొనసాగించాలని ఖచ్చితంగా మంచిది CS50 లైబ్రరీ మరియు ఈ నైరూప్యత,
కాబట్టి మాట్లాడటం, కానీ మేము చేస్తాము సరిగ్గా చూడటానికి ప్రారంభం
ఏమి జరుగుతున్నాయి ఈ మొత్తం సమయం కింద.
కాబట్టి మీరు ఈ ఉదాహరణ గుర్తుకు, చాలా, చివరిసారి నుండి, 0 పోల్చడం
నిజానికి సరిపోల్చండి లేదు.
కానీ మేము ఈ పరిష్కరించడానికి ప్రారంభమైంది.
>> కానీ బహుశా ఒక రిఫ్రెషర్, నేను ఎవరైనా ఆసక్తి ఉండవచ్చు
ఒక పింక్ ఏనుగు నేడు, కూడా చాంగ్ చేసిన?
ఎలా ముందు మీరు? [వినబడని].
అప్ న వస్తాయి.
>> మరియు ఈ మధ్యకాలంలో, మీరు వచ్చేటప్పుడు, లెట్స్
కేవలం ఒక క్షణం భావిస్తారు ఏమి ఈ కోడ్ వాస్తవానికి చేయడం జరిగినది.
ఇది రెండు చరరాశుల ప్రకటించారు లో టాప్, s మరియు t, మరియు GetString కాల్.
ఈ ఒక చాలా యూజర్ ఫ్రెండ్లీ కార్యక్రమం కాదు మీరు చెప్పండి లేదు ఎందుకంటే మీరు ఏమి.
కానీ మేము ఉన్నాము భావిస్తాయి తెలియజేయండి జ్యుసి భాగం చిత్రీకరించింది.
లు సమానం ఉంటే అప్పుడు మేము, చేయండి అది printf చెప్పాలి T సమానం,
మీరు అదే పని టైప్.
హలో.
మీ పేరు ఏమిటి?
>> Janelle: Janelle.
డేవిడ్ J. మలన్: Janelle, మీరు ఎవరిని బాగుంది.
మీ సవాలు సో ఈ ఏనుగు వైపు
మొదటి మాకు ఏది చిత్రాన్ని డ్రా ఉంది ఆ మొదటి రెండు ప్రాతినిధ్యం చేస్తున్నారు
పంక్తులు.
కాబట్టి s మరియు t కావచ్చు ఎలా తెరపై ప్రాతినిధ్యం?
మరియు మీరు కేవలం అది డ్రా చేయవచ్చు ఈ పెద్ద తెరపై మీ వేలు.
>> కాబట్టి రెండు భాగాలుగా ఉంది సమీకరణం ప్రతి వైపు.
సో అక్కడ ఎడమ లు, మరియు అప్పుడు కుడివైపు GetString.
ఆపై టి, ఎడమ ఉంది మరియు సరైన GetString.
కాబట్టి మేము ఎలా ప్రారంభం కావచ్చు ఒక చిత్రాన్ని గీయడం ఆ
జరగబోతోంది ఏమి సూచిస్తుంది ఇక్కడ మెమరీ, మీరు చెబుతా?
నాకు మీరు వివరించడానికి వీలు తెలియజేయండి మీరు వంటి మీరు చేస్తున్న ఏమి.
>> Janelle: సరే.
బాగా, మొదటి, ఇది కోరుతూ మీరు ఇన్పుట్ స్ట్రింగ్ పొందడానికి.
మరియు అది క్షమించాలి, OH store-- ఉంటుంది.
డేవిడ్ J. మలన్: సరే.
గుడ్.
మరియు ఈ ఏమి అంటారు?
సరే, అవును.
కొనసాగించడాన్ని.
నేను అంతరాయం ఉద్దేశ్యం కాదు.
Janelle: క్షమించండి.
కనుక ఇది ఇన్పుట్ లోకి చేస్తాను చిరునామా ఖచ్చితంగా కాదు of--.
నేను ఖచ్చితంగా సంఖ్య గుర్తులేకపోతే, కానీ నేను అది 0 తో మొదలు నమ్ముతారు.
>> డేవిడ్ J. మలన్: ఆ, అన్ని కుడి వార్తలు నేను సంఖ్యలు అప్ యుంటారు
కాబట్టి ఎటువంటి హక్కు సమాధానం ఉంది.
>> Janelle: 0 ఆర్క్ ప్రారంభిస్తోంది.
>> డేవిడ్ J. మలన్: సరే, అందువలన మూలకం 0.
షూర్.
>> Janelle: ఆపై ఉంటే కేవలం రెండు letter-- వంటి
>> డేవిడ్ J. మలన్: సరే, మీరు తిరిగి.
>> Janelle: సో మూలకం 0, మరియు అప్పుడు మూలకం 1 లేదా మూలకం 2.
ఇది భాగం యొక్క మరియు: డేవిడ్ J. మలన్ చిత్రాన్ని మీరు ప్రస్తుతం గీస్తున్నారు?
getString పిలుపు?
లేదా S యొక్క ప్రకటన?
>> Janelle నిర్దారణ s యొక్క, నేను నమ్మకం.
ఓహ్, GetString, అది ఎందుకంటే ప్రతి [లోకి ఇన్పుట్ అవుతుంది? ప్రాంతం. ?]
>> డేవిడ్ J. మలన్: గుడ్.
సరిగ్గా.
కూడా ఈ సమర్థవంతంగా అయితే వ్యూహం, రీకాల్ తిరిగి,
మేము ఒక స్ట్రింగ్ తిరిగి వచ్చినప్పుడు, మేము చెయ్యవచ్చు 01 మరియు 2 ఉపయోగించి ఆ స్ట్రింగ్ లోకి సూచిక.
సాంకేతికంగా, ఈ బహుశా ఉంటాయి వ్యక్తిగత చిరునామాలు ప్రాతినిధ్యం,
కానీ ఆ మంచిది.
>> కాబట్టి, ఊహించు ఉంటే నేను కేవలం ఫాస్ట్ మేము వదిలి పేరు ముందుకు
చివరిసారి, ఒకటి ఉంటే తీగలను, ఒక బి ఇ గ్రా ఉంది
బాక్ స్లాష్ 0, తద్వారా ప్రాతినిధ్యం గాబే యొక్క ఇన్పుట్, ఎలా మేము ఇప్పుడు ప్రతిఫలించే?
అన్నారు ఆ మెమరీ ఉంటే getString ద్వారా తిరిగి?
>> Janelle: ఇది ఉంటుందా ఒక ఆర్క్ ద్వారా ప్రాతినిధ్యం?
>> డేవిడ్ J. మలన్: ఒక ఆర్క్ ద్వారా?
Well, ఏ.
, యొక్క కేవలం చిత్రాల చెబుతారు నాకు ముందుకు వెళ్లి తెలియజేయండి
ఈ లు ఉంటే, ఈ ప్రతిపాదించారు GetString తిరిగి విలువ.
మరియు మీరు 0, 1, 2, ఈ డ్రా చేసిన , ఖచ్చితంగా మంచిది మేము ఎందుకంటే
వంటి స్ట్రింగ్ లోకి ఇండెక్స్, చెయ్యవచ్చు.
కానీ కేవలం స్థిరంగా ఉండాలి చివరిసారి, నాకు ముందుకు తెలియజేయండి
మరియు ఏకపక్ష ఈ ప్రతిపాదించారు చిరునామా 1, ఈ చిరునామా, 2
ఈ మొదలైనవి చిరునామా 3, మరియు.
కాబట్టి, కేవలం సూపర్ ఉండాలి స్పష్టమైన, ఏమి జరగబోతోంది
ఆ ఫలితంగా లు వెళ్లాల్సి కోడ్ మొదటి లైన్, మీరు చెబుతా?
>> Janelle: చిరునామా 1?
>> డేవిడ్ J. మలన్: ఖచ్చితంగా.
కాబట్టి 0x1 పరిష్కరించారని.
మరియు అదే సమయంలో, నాకు ముందుకు తెలియజేయండి మరియు మీరు చేసిన ఏ చాలా నకిలీ
మరియు ఇక్కడ నా సొంత T జోడించండి.
నేను గాబే లో టైప్ ఉంటే మళ్ళీ రెండవసారి,
GetString తో ప్రాంప్ట్ ఎప్పుడు, ఎక్కడ, కోర్సు యొక్క, గాబే గో అన్నారు?
వెల్, presumably--
>> Janelle: ఇక్కడ ఇలా?
డేవిడ్ J. మలన్: అవును.
Janelle: లేదా ఒకే బాక్సులను లో కూడా?
డేవిడ్ J. మలన్: నాకు అవును, ప్రపోజ్ లెట్ సరిగ్గా ఈ అదనపు బాక్సులను కాబట్టి.
కానీ ఇప్పుడు కీ కూడా, అని నేను ఈ అందంగా దగ్గరగా డ్రా చేసిన అయితే
together-- 0x1, ఈ వాస్తవానికి 0x2-- ఉంది,
ఈ ఇప్పుడు, చిరునామా 0x10 కావచ్చు ఉదాహరణకు, మరియు 0x11, మరియు 0x12,
మొదలగునవి.
కాబట్టి, ఒకవేళ, ఎంచు లో ఇక్కడ ముగుస్తుంది జరగబోతోంది?
>> Janelle: 0x10?
డేవిడ్ J. మలన్: ఖచ్చితంగా.
కాబట్టి 0x10.
కాబట్టి ఇప్పుడు, చివరి ప్రశ్న.
మీరు చాలా ద్వారా, పని కలిగి ఇప్పటివరకు ఒక ఏనుగు కోసం కష్టతరమైన.
ఇప్పుడు ద్వారా, నేను కోడ్ పుల్ అప్ ఉంటే మళ్ళీ, నేను చేస్తే, లైన్ మూడుసార్లు,
లు సమానం T సమానం ఉంటే, నేను నిజానికి ఏమి am మేము ఇక్కడ డ్రా చేసిన పోల్చడం ఆ?
>> Janelle: రెండు చిరునామాలు?
డేవిడ్ J. మలన్: ఖచ్చితంగా.
కాబట్టి నేను t సమానంగా సమానం చెప్పడం?
ఇతర మాటలలో, 10 సమానం సమానం 1?
మరియు కోర్సు యొక్క, స్పష్టమైన సమాధానం ఇప్పుడు ఏ ఉంది.
కాబట్టి ఈ ప్రోగ్రామ్ అంతిమంగా మీరు చెప్పే, ఏమి ప్రింట్ అన్నారు?
>> Janelle: ఇది ఉంటుందా మీరు అదే పని టైప్?
>> డేవిడ్ J. మలన్: చేస్తే లు 1 మరియు T 10?
>> Janelle: మీరు వివిధ విషయాలను టైప్.
>> డేవిడ్ J. మలన్: ఖచ్చితంగా.
మీరు వివిధ విషయాలను టైప్.
అన్ని కుడి.
కాబట్టి చప్పట్లు ఒక రౌండ్, ఇక్కడ, మేము అనుకొనుట ఉంటే.
[చప్పట్లు]
ఆ బాధాకరమైన ఉంది.
నేను తెలుసు.
చక్కగా పూర్తి.
కాబట్టి ఇప్పుడు యొక్క చూసేలా ఉంటే మేము కాదు పరిష్కారము ఏమి వేరుగా బాధించటం.
మరియు కోర్సు యొక్క, మేము ఉండాలి ఈ స్థిర ఇది నేను ఇప్పుడు green-- లో ప్రాతినిధ్యం చేస్తాము
మేము ఇక్కడ విస్తరింపులను జంట చేశాడు.
మొదటి, కేవలం ఒక తెలివి గా నేను మొదటి తనిఖీ చేస్తున్నాను, తనిఖీ
లు శూన్య సమానం మరియు t శూన్య సమానం.
మరియు కేవలం స్పష్టతను, ఉన్నప్పుడు కలిగింది s లేదా t ఈ వంటి కోడ్ శూన్య ఉంటుంది?
చేసినప్పుడు లేదా t శూన్య కావచ్చు.
అవును?
>> ప్రేక్షకులు: [వినబడని].
>> డేవిడ్ J. మలన్: ఖచ్చితంగా.
స్ట్రింగ్ వినియోగదారు ఉంటే లో టైప్ మార్గం చాలా పొడవుగా ఉంది
మెమరీ లోకి సరిపోయే, లేదా కొన్ని ఆ వంటి అసహజ మూలలో కేసు
మేము చూస్తారు వంటి వాచ్యంగా, GetString నేడు, దాని డాక్యుమెంటేషన్,
అది శూన్య తిరిగి చెబుతాడు ఒక ప్రత్యేక కాపలాదారుడు విలువ,
లేదా కేవలం విధమైన ప్రత్యేక చిహ్నం ఏదో తప్పు జరిగింది అర్థం.
అందుకని మనం చెక్ అనుకుంటున్నారా అది అవుతుంది ఎందుకంటే, ఆ
ఆ శూన్య చాలా ప్రమాదకరమైన విలువ ఉంది.
>> తరచుగా, మీరు ఏదో ఒకటి చేయాలని ప్రయత్నిస్తే శూన్య ప్రయాణిస్తున్న ఒక ఫంక్షన్ పాల్గొన్న
ఇన్పుట్ వంటి, ఆ ఫంక్షన్ instance-- కోసం చాలా దానితో, క్రాష్ మరియు ఉండవచ్చు,
మీ మొత్తం కార్యక్రమాన్ని డౌన్ పడుతుంది.
కాబట్టి ఈ మూడవ లైన్ ఇప్పుడు తెలివి ఉంది మీరు రెడీ ఉంటే, దోష పరిశీలన తనిఖీ.
ఆ కోసం ఇప్పుడు ఒక మంచి అలవాటు ఉంది మాకు ఏ సమయంలో పొందడానికి మేము
ఒక విలువ ఉపయోగించడానికి ప్రయత్నించండి , సమర్థవంతంగా, శూన్య కావచ్చు.
>> ఇప్పుడు, ఇక్కడ నాలుగవ లైన్ లో, "ఉంటే strcmp (s, t)" అలాగే,
వాటిని సూచించే ఆ?
Well, మేము ఈ చాలా క్లుప్తమైన ఒక చెప్పాడు స్ట్రింగ్ పోలిక కోసం అనే ఫంక్షన్.
మరియు జీవితం లో ప్రయోజనం పోల్చడం రెండవ అది వ్యతిరేకంగా మొదటి వాదన,
కానీ వారి చిరునామాలు పరంగా, మేము ఒక క్షణం అనుకోకుండా వలె
క్రితం ఎరుపు కోడ్ తో, కానీ కాకుండా ఆ రెండు పోల్చడానికి
మనిషిలా సహజమైన తీగలను దీనితోపాటుగా ఈ పోల్చడం ద్వారా మార్గం,
ఈ, వ్యతిరేకంగా, మరియు వ్యతిరేకంగా అప్పుడు ఆపటం ఉన్నప్పుడు ఒక ఉంటే
లేదా నా వేళ్ళు రెండు ఒక బాక్ స్లాష్ 0 హిట్స్.
కాబట్టి ఎవరైనా సంవత్సరాల క్రితం అమలు strcmp కార్యాచరణ మాకు అమలు
మేము ఉండాల్సిందని ఆశించాను కేవలం రెండు సాధారణ విలువలు పోల్చడం ద్వారా.
>> ఇప్పుడు స్పష్టముగా, నేను డ్రాయింగ్ ఉంచడానికి ఈ వివిధ సంఖ్యల అన్ని.
కానీ వాస్తవంలో నేను ఉన్నాను, ఉంది మొత్తం సమయం ఈ ముందుకెళ్లి.
కాబట్టి నాకు ముందుకు వెళ్లి తెలియజేయండి మరియు ఈ అవ్ట్ ని
ఒక పాయింట్ చేయడానికి, చివర రోజు మరియు ముందుకు వెళ్లడానికి,
మేము నిజంగా శ్రద్ధ వెళ్ళడం లేదు చేస్తున్నాం ఏమి విషయాలు నిజానికి ఉన్నాయి చిరునామాలు
మెమరీలో.
కాబట్టి నేను ఈ డ్రా వెళుతున్న కాదు చాలా ఇకపై సంఖ్యలు రకాల
నేను దూరంగా ఈ కేవలం ఒక నైరూప్య ఉన్నాను కేవలం బాణాలు తో మరింత స్నేహపూర్వక కొద్దిగా.
>> ఇతర మాటలలో, ఒక పాయింటర్ ఉంటే, బాగా, యొక్క కేవలం సాహిత్యపరంగా, అది డ్రా తెలియజేయండి
ఒక పాయింటర్ గా, ఒక బాణంతో , ఏదో నుండే
మరియు గురించి చాలా ఎక్కువ చింతించకండి ఈ అడ్రస్ల minutia
ఇది మళ్ళీ, నేను ఏమైనప్పటికీ తయారు.
కానీ మేము ఆ చిరునామాలను చూస్తారు, కొన్నిసార్లు కోడ్ డీబగ్గింగ్ చేసేటప్పుడు అధికం.
>> ఇప్పుడు అదే సమయంలో, ఈ కార్యక్రమం ఇక్కడ పరిష్కారాలను, కోర్సు యొక్క,
పోల్చడం ద్వారా ఆ సమస్య ఆ రెండు తీగలను.
కానీ మేము మరొక సమస్య పడింది.
ఈ కాపీ నుండి ఉంది గత టైం ప్రోగ్రాం
అనగా, నేను పెట్టుబడిగా ప్రయత్నిస్తున్నప్పుడు ఒక స్ట్రింగ్ కేవలం మొదటి పాత్ర.
కానీ లక్షణం ఏమిటి మేము చివరిసారి చూసిన
ఒక వినియోగదారు వంటి, ఒక విలువ లో టైప్ చిన్న లో గాబే, s కోసం,
అప్పుడు మేము, T లోకి లు కేటాయించిన అక్కడ మూడో వరుసలో ఉండటం,
ఆపై నేను ప్రయత్నించారు T బ్రాకెట్ 0 చూపడంలో?
ప్రభావం ఏమిటి T బ్రాకెట్ 0 ఇక్కడ మారుతున్న?
>> ప్రేక్షకులు: ఇది s కు మార్చబడింది.
>> డేవిడ్ J. మలన్: అవును, నేను అలాగే, s కు మార్చబడింది.
నిజంగా జరుగుతుందో ఏమి ఎందుకంటే?
Well, నేను శుభ్రం చేయవచ్చు ఉంటే నాకు చూద్దాము ఈ చిత్రాన్ని అప్, వంటి అనుసరిస్తుంది.
>> లు ఉంటే, మళ్ళీ, పదం గ్రా, ఒక, B, E, బాక్ స్లాష్, 0, మరియు లు
మేము ఒక బాక్స్ డ్రాయింగ్ చేస్తాము ఇక్కడ, అయితే మరింత చిరునామాలు.
యొక్క విషయాలు అప్ స్టాప్ మేకింగ్ లెట్.
యొక్క కేవలం ఒక చిత్రాన్ని డ్రా లెట్ ప్రపంచంలో సులభతరం.
>> నేను స్ట్రింగ్ t తో t డిక్లేర్ చేసినప్పుడు, మెమరీ ఆ భాగం సృష్టిస్తుంది.
స్క్వేర్ 32 నిర్మాణము చాలా కంప్యూటర్లు బిట్స్.
నిజానికి, మీరు ఎప్పుడైనా ఒక విన్న చేసిన కంప్యూటర్, ఒక 32-bit నిర్మాణం కలిగి
నిజంగా ఫాన్సీ-మాట్లాడటం, కేవలం ఇది 32 బిట్ అడ్రస్లను ఉపయోగిస్తుంది అర్థం.
పక్కన సాంకేతిక, మీరు ఆలోచిస్తున్నారా చేసిన ఉంటే
ఎందుకు పాత కంప్యూటర్లు, నిజానికి మీరు ఉంటే RAM యొక్క మా తో సూప్ వాటిని అప్ ప్రయత్నించారు,
మాత్రమే గరిష్టంగా కలిగి ఉంటుంది RAM నాలుగు గిగాబైట్ల,
అలాగే ఆ వాచ్యంగా, ఎందుకంటే, మీ పాత కంప్యూటర్లో అనుకొనుట మాత్రమే
4 వంటి అధిక లెక్కింపు బిలియన్, 4 బిలియన్ బైట్లు,
ఇది ఎందుకంటే 32-bit ఉపయోగించి జరిగినది చిరునామాలకు సంఖ్యలు.
>> కానీ ఏ సందర్భంలో, ఈ ఉదాహరణకు, కథ యొక్క అతి సాధారణ చేస్తుంది.
t కేవలం మరొక పాయింటర్ ఉంది, లేదా నిజంగా ఒక చార్ స్టార్, ఆక స్ట్రింగ్.
మరియు ఎలా నేను ఈ చిత్రాన్ని అప్డేట్ అనుకుంటున్నారు ఇప్పుడు కోడ్ రెండవ లైన్ తో,
డాట్ తర్వాత, డాట్, డాట్?
నేను చేసినప్పుడు స్ట్రింగ్ t, లు సెమికోలన్ సమానం ఈ చిత్రాన్ని ఎలా మార్చదు?
అవును?
>> ప్రేక్షకులు: [వినబడని].
>> డేవిడ్ J. మలన్: అవును.
సరిగ్గా.
నేను నుండి ఒక బాణం పెట్టి అదే చిరునామాకు T బాక్స్,
లో అదే మొదటి లేఖ ఇచ్చారు.
లేదా సాంకేతికంగా, ఈ గై, 0x1 లోనే ఉన్నారు
నేను కలిగి అయితే ఉంది ఇక్కడ 0x1 మరియు ఇక్కడ 0x1.
కానీ మళ్ళీ, ఎవరు పట్టించుకుంటారు చిరునామాలు గురించి?
ఇది ఇప్పుడు ఆ విషయాలను కేవలం ఆలోచన.
కాబట్టి ఈ ఇక్కడ జరుగుతున్నది ఏమిటి.
కోర్సు యొక్క, మీరు t ఉంటే బ్రాకెట్ కాబట్టి శ్రేణి సంజ్ఞామానం ఇది 0,
యొక్క కోర్సులో మరియు స్పష్టముగా, అది కనిపిస్తుంది ఇక్కడ పైగా వ్యూహం ఉన్నట్లు,
కానీ ఇప్పుడు ఈ విచిత్రమైన విషయం ఉంది.
ప్రోగ్రామింగ్ భాష తెలిసిన, సి, మీరు ఈ లక్షణం అందిస్తుంది
అనగా, t ఒక పోయినప్పటికీ పాయింటర్, లేదా ఒక పాయింటర్ ఉంది,
మీరు ఇప్పటికీ, తెలిసిన ఉపయోగించవచ్చు సౌకర్యవంతమైన చదరపు బ్రాకెట్
సంజ్ఞామానం మొదటి మూలకం వెళ్ళడానికి, రెండవ మూలకం, లేదా ఏ మూలకం లేదా
ఆ పాయింటర్ సూచించబడిన ఆ బహుశా, ఎందుకంటే, అది
ఈ సందర్భంలో, ఉంది కొన్ని శ్రేణి వద్ద గురిపెట్టి.
>> సో ఎలా మేము ఈ పరిష్కరించాలి?
అది ఒక వచ్చింది పేరు స్పష్టముగా, ఈ ఉంది మొదటి చూపులో కొద్దిగా అధిక.
కానీ ఇక్కడ ఒక కొత్త మరియు మెరుగైన వెర్షన్.
>> కాబట్టి మొదటి, నేను పొందుతున్నాను CS50 లైబ్రరీ యొక్క వదులుకొను,
కేవలం నిజానికి ఆ s ఉంది బహిర్గతం ఒక చార్ స్టార్, కేవలం ఒక పర్యాయపదంగా.
మరియు t కూడా ఒక చార్ నక్షత్రం.
కానీ మీద ఏమి జరుగుతుందో ఏమి ఆ మార్గం యొక్క కుడి చేతి వైపు
t ఒక విలువ కేటాయించిన ఎక్కడ?
>> Malloc అంటే ఏమిటి?
ఇది ఏమిటి strlen యొక్క?
Sizeof (చార్) అంటే ఏమిటి?
ఎందుకు హెక్ చేస్తుంది లైన్ లుక్ కాబట్టి క్లిష్టమైన?
ఏం ఒక అధిక స్థాయిలో చేస్తోంది?
ఏం అది T లో నిల్వ?
అవును?
ప్రేక్షకులు: ఇది కేటాయించడం యొక్క ఒక మెమరీని యొక్క నిర్దిష్ట మొత్తం.
ఇది నిల్వ వార్తలు, నేను ఊహిస్తున్నాను అక్షరాలు [వినబడని].
>> డేవిడ్ J. మలన్: పర్ఫెక్ట్.
పర్ఫెక్ట్.
ఇది ఒక నిర్దిష్ట కేటాయించడం యొక్క మెమరీని యొక్క మొత్తం
బహుశా, భవిష్యత్ అక్షరాలు నిల్వ.
మరియు ముఖ్యంగా, malloc అందువలన ఏమి తిరిగి?
>> ప్రేక్షకులు: [వినబడని] తిరిగి?
డేవిడ్ J. మలన్: ఖచ్చితంగా.
మెమరీ చిరునామా సాధించాక, ఇది చెప్పడం ఒక ఫాన్సీ మార్గం
యొక్క చిరునామా తిరిగి ఆ మెమరీ మొదటి బైట్.
నన్ను గుర్తుంచుకోవడానికి న జవాబుదారి ఉంది ఎంత మెమరీ నేను నిజానికి
కేటాయించింది లేదా కొరకు malloc కోరారు.
>> ఇప్పుడు ఎంత ఉంది?
Well, అక్కడ అయినప్పటికీ ఇక్కడ కుండలీకరణాలు చాలా,
malloc కేవలం ఒక వాదన పడుతుంది.
మరియు నేను యొక్క strlen పేర్కొనడం, కాబట్టి ఇవ్వాలని చేస్తున్నాను నాకు అనేక బైట్లు లు ఉన్నాయి గా,
కానీ ఒక జోడించండి.
ఎందుకు?
అవును?
>> ప్రేక్షకులు బ్యాక్స్లాష్ 0.
డేవిడ్ J. మలన్: ఖచ్చితంగా.
మేము ఒక చిన్న హౌస్ కీపింగ్ చేయడానికి పొందారు.
ఒక బాక్ స్లాష్ ఉంది కనుక అలా 0, మేము మంచి గుర్తుంచుకోవాలి ఇష్టం.
లేకపోతే, మేము చేయబోతున్నామని ఒక స్ట్రింగ్ రూపొందించడానికి ఆ
ప్రత్యేక టెర్మినేటర్ లేదు.
>> ఇంతలో, కేవలం సూపర్ ఉండాలి అంగ, నేను, sizeof (చార్) కలిగి
కేవలం సందర్భంలో ఎవరైనా నా నడుస్తుంది కాదు CS50 ఉపకరణం కోడ్,
కానీ బహుశా వేరే కంప్యూటర్ మొత్తంగా పేరు అక్షరాలు
సాంప్రదాయకంగా, ఒక బైట్ ఉంటాయి, కాని రెండు బైట్లు, లేదా కంటే పెద్ద ఏదో.
ఇది కేవలం సూపర్ వెయ్యబడింది, లోపాలు సూపర్ విముఖత.
అయినప్పటికీ, నిజానికి ఇది వార్తలు ఎక్కువగా ఒక 1 చేస్తాడు.
>> ఇప్పుడు, మరోవైపు, నేను ముందుకు వెళ్లి కాపీ స్ట్రింగ్, T బ్రాకెట్ నేను T బ్రాకెట్ లు సమానం.
నేను గత వారం యొక్క వాయిదా సోర్స్ కోడ్ జరగబోతోంది ఏమి చూడటానికి.
కీ takeaway, మరియు కాని కారణం నేను, గ్రీన్ ఇప్పుడు కోడ్ను ఉంచాలి
, చాలా చివరి లైన్ ఎందుకంటే T బ్రాకెట్ 0, toupper సమానం
ప్రభావం కోరుతాయి స్ట్రింగ్?
t మరియు / లేదా s?
కోడ్ యొక్క చివరి పంక్తి.
>> ఏమి ఎందుకంటే జస్ట్, T ఈ సమయంలో జరిగింది
నేను కొద్దిగా ఆ చివరి దశలో దిద్దుబాటు రద్దుచెయ్యి ఉంటే, నేను malloc కాల్ చేసినప్పుడు, ఏమి హాపెండ్ లో
నేను తప్పనిసరిగా మెమరీ భాగం పొందండి అసలు అదే పరిమాణం,
అంకగణితం ఎందుకంటే నేను చేసింది.
నేను చిరునామా T లో నిల్వ చేస్తున్నాను మెమరీ ఆ భాగం యొక్క.
కూడా ఈ nice కనిపిస్తోంది అయితే మరియు, అందంగా nice మరియు ఖాళీ,
ఈ సంఘంలో ఏమి మేము చేస్తాము ఉంది ఉంది ఇక్కడ, కాల్ చెత్త విలువలు ఉంచండి.
మెమరీ ఆ భాగం వాటిని చాలా అలాగే ముందు ఉపయోగిస్తున్నారు,
కొన్ని సెకన్ల కొన్ని నిమిషాలు క్రితం.
సో ఖచ్చితంగా సంఖ్యలు ఉండవచ్చు కేవలం ప్రమాదంలో అక్కడ లేక అక్షరాలు.
కానీ వారు నేను వరకు, చెల్లుబాటు కావు నాకు మెమొరీ ఈ భాగం జనసాంద్రత
అసలు అక్షరాలు, నేను అక్కడ లూప్ అని చేయండి.
అన్ని కుడి?
>> కాబట్టి ఇప్పుడు, క్లైమాక్స్ ఈ మూడు ఉదాహరణలు
అకారణంగా, చివరిసారి అధిగమించే ఈ swap ఉదాహరణకు, ఈ ఫంక్షన్
భావంలో పని అది ఒక అండ్ బి మార్చుకున్నారు ఆ.
కానీ ఏమిటి ఇతర అర్ధంలో లో పని చేయలేదు?
అవును?
>> ప్రేక్షకులు: [వినబడని].
>> డేవిడ్ J. మలన్: ఖచ్చితంగా.
నేను ఈ ఫంక్షన్ కాల్ చేస్తే ఉదాహరణకు another-- నుండి,
, పేరు ప్రధాన వంటి ఫంక్షన్ నుండి నేను, ఒక వేరియబుల్, x మరియు y కలిగి
గత వారం చేశాడు, అదే కోడ్, నేను x మరియు y లో పాస్
swap, ఆపై Swap-- ఈ కాల్, కోర్సు యొక్క, సరైన వెర్షన్
మేము చేయబోతున్నారు ఏమిటి see-- అది పని చేయలేదు.
కాబట్టి పరిష్కారము ఏమి ఉంది?
>> Well, కాబట్టి కేవలం ఉండాలి స్పష్టమైన, నాకు ముందుకు తెలియజేయండి
మీరే ఇక్కడ రెండవ నాకే ఇవ్వాలని, మరియు చూడండి నేను మీరు చివరి చూపవచ్చు ఉంటే
నేను వెదుక్కోవచ్చు ఉంటే యొక్క చూసేలా in-- ఉంటుంది ఈ నిజమైన fast-- సరే, [వినబడని].
సరే, అక్కడ అది.
సో నేను టైప్ చేస్తున్నానని ఆదేశాలను పట్టించుకోకుండా.
నేను వద్ద తిరిగి కావలసిన చివరి నిమిషంలో ఒక ఉదాహరణ
చివరిసారి నుండి ఇది ఇప్పుడు ఏ స్వాప్ అంటారు.
>> సో సంఖ్య మార్పిడి పేరు ఉంది మేము చివరిసారి వదిలి
అనగా, నేను initialized 1 x మరియు 2 కు y.
నేను అప్పుడు 1 మరియు 2 లో ప్రయాణిస్తున్న, స్వాప్ కాల్.
ఆపై ఈ ఫంక్షన్ కొన్ని భావంలో పని,
కానీ అది ఎటువంటి శాశ్వత వచ్చింది x మరియు y న ప్రభావితం.
కాబట్టి చేతిలో ప్రశ్న ఎలా ఇప్పుడు, మేము నిజానికి ఈ సమస్య పరిష్కరించాలి?
చేతిలో పరిష్కారం ఏమిటి?
>> Well, నేడు కొత్త ఉంది దీనిలో swap.c లో, తేడాలు యొక్క ఒక జంట గమనించి.
x మరియు y ఒకటే.
కానీ ఏమి స్పష్టంగా ఉంది లైన్ 25 గురించి వివిధ?
మీరు గుర్తు ఉంటే ఏమి, అక్కడ కొత్త వార్తలు ఇది రెండవ క్రితం వంటి చూసారు ఏమి?
>> ప్రేక్షకులు: [వినబడని].
>> డేవిడ్ J. మలన్: అవును.
కాబట్టి ampersands ఒక కొత్త ముక్క ఉన్నాయి వాక్యనిర్మాణం యొక్క మాత్రమే ఈ కార్యక్రమం లో,
కానీ కూడా మరింత సాధారణంగా CS50 లో.
నేటికి, నేను భావించడం లేదు మేము ఏ ఉదాహరణలు చూసిన
లేదా నిజంగా ఏ వాటిని గురించి మాట్లాడారు బహుశా, preemptively కంటే ఇతర వివరాలు,
విభాగంలో, ఈ వంటి ఒక ఆంపర్సండ్ చిహ్నం.
సరే, ఆంపర్సండ్ చిహ్నం ఒకటి అవుతుంది కొత్త వాక్యనిర్మాణం యొక్క గత ముక్కలు
మేము తెలుసుకోవడానికి చూడాలని.
ఇది అర్థం అన్ని ఉంది కొన్ని వేరియబుల్ చిరునామా.
ఏమి చిరునామా వద్ద X నివసిస్తున్నారు లేదు?
కానీ Y చిరునామా ఏమిటి లేదు?
ఎందుకంటే ముందు ప్రాథమిక సమస్య
ఆ x మరియు y జారీ చేస్తున్నారు చేసింది మేము నిజంగా చేయాలనుకుంటున్నారా ఏమి కాపీలు, వంటి
ఒక నిధి వంటి తో Swap అందించడానికి ఉంది ఇక్కడ x మరియు నిజానికి Y దారితీస్తుంది చిహ్నం
కాబట్టి, RAM లో ఉన్నాయి స్వాప్ మ్యాప్ అనుసరించండి
X లేదా Y గుర్తులతో ఎక్కడికి మరియు వెళ్ళండి మరియు వాస్తవ విలువలను మార్చడం 1 మరియు 2
అక్కడ.
>> కాబట్టి swap చాలా కొద్దిగా మార్చడానికి అవసరం.
మరియు మొదటి చూపులో, ఈ మైట్ చార్ స్టార్ కొద్దిగా సమానంగా ఉన్నాయి.
నిజానికి ఇది.
కాబట్టి ఒక డేటా రకం ఒక పాయింటర్ ఉంది, ఈ హైలైట్ భాగం ఆధారంగా?
కనుక ఇది ఒక పూర్ణాంకానికి ఉంది.
>> కాబట్టి ఒక ఇకపై ఒక Int, అది ఒక పూర్ణాంకానికి యొక్క చిరునామా ఉంది.
మరియు అలాగే, బి ఇప్పుడు అన్నారు ఒక పూర్ణాంకానికి యొక్క చిరునామా ఉంటుంది.
నేను ఇప్పుడు ప్రధాన నుండి స్వాప్ కాల్ చేసినప్పుడు, నేను swap 1 మరియు 2 ఇస్తాయి వెళుతున్న కాదు.
నేను వంటి ఇవ్వాలని వెళుతున్న దున్నేందుకు ఏదో మరియు ఆక్స్-ఏదో,
దారి తీస్తుంది రెండు చిరునామాలు వారి అసలు స్థానాలకు swap
నా కంప్యూటర్ యొక్క మెమరీ లో.
>> కాబట్టి ఇప్పుడు, నా మిగిలిన అమలు ఒక టాడ్ మార్చడానికి అవసరం.
ఇప్పుడు ఏం స్పష్టంగా విభిన్నమైనది కోడ్ యొక్క ఈ మూడు పంక్తులు?
ఈ తిట్టు నక్షత్రాలు ఉంది చోట్ల, అన్ని కుడి?
సో వాట్ ఇక్కడ జరగబోతోంది?
అవును?
>> ప్రేక్షకులు: [వినబడని] స్పష్టంగా ఉంది.
>> డేవిడ్ J. మలన్: ఖచ్చితంగా.
ఈ సందర్భం లో సో ఈ లేదు ఉత్తమ నిర్ణయానికి ఆమోదం
క్రితం సంవత్సరాల.
ఈ సందర్భంలో, పేరు మీరు కేవలం ఒక స్టార్,
మరియు మీరు ఒక డేటా రకాన్ని కలిగి లేదు, Int వంటి, వెంటనే ఎడమ,
బదులుగా మీరు స్పష్టంగా, సమాన సైన్ కలిగి, ఈ సందర్భంలో, మీరు చెప్పినప్పుడు ఒక స్టార్,
ఆ వెళ్ళడానికి అంటే ఒక ఉందని చిరునామా.
కాబట్టి మాట్లాడటం, నిధి పటం అనుసరించండి.
>> మరియు అదే సమయంలో, లైన్ 37 లో, అదే విషయం అర్థం.
చిరునామా ఒక వెళ్ళండి, మరియు అక్కడ ఉంచారు?
ఏది వద్ద ఉంది బి పేర్కొనే నగర.
ఇతర మాటలలో, బి వెళ్ళండి.
ఆ విలువ పొందండి.
సమాన శాతం, ఒక వెళ్ళండి మరియు సైన్ అప్పగించిన ఆపరేటర్లు,
అక్కడ ఆ విలువను ఉంచారు.
>> అదేవిధంగా, Int టెంప్ కేవలం ఒక పూర్ణాంకానికి ఉంది.
నథింగ్ తాత్కాలిక గురించి మార్చడానికి అవసరం.
ఇది Annenberg నుండి కేవలం ఒక విడి గాజు వార్తలు కొన్ని పాలు లేదా నారింజ రసం కోసం.
కానీ నేను చెప్పేది, బి వెళ్లాలి లేదు.
ఆ గమ్యానికి వెళ్లి అక్కడ తాత్కాలిక విలువ ఉంచారు.
కాబట్టి అప్పుడు ఏం?
నేను నిజానికి, ఈ సమయంలో మార్చు కాల్ చేసినప్పుడు ఈ మొదటి ట్రే ఇక్కడ, ప్రధాన సూచిస్తుంది
ఈ రెండవ ట్రే స్వాప్ సూచిస్తుంది, ఎప్పుడు నేను ఆంపర్సండ్ చిహ్నం x మరియు ఆంపర్సండ్ చిహ్నం Y పాస్
ప్రధాన swap కు నుండి, కేవలం స్పష్టతను ఈ స్టాక్ ఫ్రేమ్ అందుకునే ఏమి ఉంది?
అవును?
>> ప్రేక్షకులు: [వినబడని].
డేవిడ్ J. మలన్: ఖచ్చితంగా.
x యొక్క చిరునామా మరియు y యొక్క చిరునామా.
మరియు మీరు ఈ యొక్క ఆలోచించవచ్చు పోస్టల్ చిరునామా వంటి.
33 ఆక్స్ఫోర్డ్ స్ట్రీట్ మరియు 35 ఆక్స్ఫోర్డ్ స్ట్రీట్, మరియు మీరు
రెండు భవనాలు తరలించాలనుకుంటున్న ఆ స్థానాల్లో ఉన్నవి అని.
>> ఇది ఒక పరిహాసాస్పదం ఆలోచన యొక్క విధమైన ఉంది, కానీ ఆ మేము చిరునామా అర్ధం అంతే.
ఎక్కడ ప్రపంచంలో చెయ్యవచ్చు మీరు ఆ రెండు ints కనుగొనేందుకు?
ప్రపంచంలో మీరు చెయ్యవచ్చు ఆ రెండు భవనాలు కనుగొనేందుకు?
సో చివరకు ఉంటే, ఈ సమయంలో నేను తర్వాత నేటి సోర్స్ కోడ్ లోకి వెళ్ళి కంపైల్
Swap మరియు రన్ ./swap, చివరకు, కోసం మొదటిసారి మేము నిజంగా ఆ చూడండి లేదు
నా విలువలు నిజానికి కలిగి విజయవంతంగా మార్చుకున్నారు.
ఇప్పుడు, మేము కూడా పట్టవచ్చు ఈ లో, సే, GDB నోటు.
>> నాలో ఒకే ఫైల్ లోకి వీడలేదు.
నాకు ముందుకు వెళ్లి ./swap యొక్క GDB అమలు లెట్.
మరియు ఇప్పుడు, స్వాప్ లో, నేను వెళ్ళడానికి వెళుతున్న ముందుకు మరియు మెయిన్ ఒక బ్రేక్ పాయింట్ సెట్.
ఇప్పుడు నేను వెళ్ళడానికి వెళుతున్న ముందుకు మరియు అమలు.
ఇప్పుడు మేము నా కోడ్ చూడండి ఆ లైన్ వద్ద నిలిపివేయబడింది.
>> నేను ముందుకు ముద్రణ వెళ్ళి ఉంటే X, నేను ఇక్కడ ఏమి చూస్తారు?
ఇది ఒక ప్రశ్న.
మళ్ళీ సే?
>> ప్రేక్షకులు: [వినబడని].
>> డేవిడ్ J. మలన్: సో యాదృచ్ఛిక సంఖ్యలు, బహుశా.
నేను లక్కీ పొందండి, మరియు అది వార్తలు 0 వంటి, nice మరియు సాధారణ.
కానీ దీనికి కొన్ని యాదృచ్ఛిక నెంబర్.
ఈ సందర్భంలో, నేను లక్కీ వచ్చింది.
ఇది కేవలం 0 నిర్మాణము.
కానీ అది నిజానికి అదృష్టం ఉంది వరకు ఎందుకంటే నేను
తరువాత టైప్ ఆపై ముద్రణ x ఉందని ఉంది కోడ్ లైన్, లైన్ 19 అమలు చేశారు.
>> ఇంతలో, నేను టైప్ ఉంటే తదుపరి మళ్ళీ, మరియు ఇప్పుడు నేను 2 చూడండి వెళుతున్న, Y ముద్రించాలా.
నేను తదుపరి టైప్ ఉంటే ఇప్పుడు, దానికి జరగబోతోంది కొద్దిగా గందరగోళంగా పొందవచ్చు, ఇప్పుడు ఎందుకంటే,
printf కనిపించడం అన్నారు స్క్రీన్ చేసియున్నారు, వంటి. x 1.
>> మళ్ళీ మనం.
మరియు ఇప్పుడు, ఇక్కడ, ఇక్కడ వార్తలు విషయాలు ఆసక్తికరమైన పొందండి.
నేను swap లేదా కూడా అడుగు కాల్ ముందు అది లోకి, యొక్క ఒక చిన్న పీక్ తీసుకుందాం.
X, మళ్ళీ, 1.
Y, కోర్సు యొక్క, శీఘ్ర తెలివి ఉంది కాబట్టి హార్డ్ కాదు, అక్కడ 2 తనిఖీ.
కానీ ఆంపర్సండ్ చిహ్నం x ఏమి ఉంది?
సమాధానం ఇది అల్లరిగా రకం ఆరాటపడుతుంది.
కానీ కుండలీకరణాలు లో Int నక్షత్రం కేవలం ఉంది ఈ యొక్క GDP యొక్క మార్గం చిరునామా.
ఇది ఒక ఒక పాయింటర్ ఒక పూర్ణాంకానికి యొక్క కాదు Int, లేదా ఏదో ఒక చిరునామా అని పిలిచే.
>> ఈ వెర్రి విషయం ఏమిటి?
మేము ఏదో ఎప్పుడూ చూడలేదు చాలా ముందు వంటి.
కాబట్టి ఈ నా కంప్యూటర్ యొక్క చిరునామా X నివసిస్తున్నారు నిర్మాణము యొక్క మెమరీ.
ఇది దున్నేందుకు ఏదో ఉంది.
మరియు ఈ స్పష్టముగా, ఎందుకు ఉంది నేను బాణాలు గీయడం ప్రారంభించారు చేసిన,
బదులుగా సంఖ్యల, ఎవరు నిజంగా అడిగే ఎందుకంటే
మీ పూర్ణాంకానికి ఒక నిర్దిష్ట వద్ద అని పెద్ద అని చిరునామా.
కానీ bffff0c4, ఇవన్నీ ఉంటాయి నిజానికి హెక్సాడెసిమల్ అంకెలు,
F ద్వారా 0 ఇవి.
>> కాబట్టి మేము ఆ చాలా నివసించు వెళ్ళడం లేదు చేస్తున్నాం ఆ విషయాలు ఏమి దీర్ఘ.
కానీ నేను y ముద్రించాలా ఉంటే, కోర్సు యొక్క, నేను 2 చూడండి.
కానీ ఆంపర్సండ్ చిహ్నం Y, నేను ఈ చిరునామా చూడండి.
మరియు ప్రకటన, ఆసక్తికరమైన, వేరుగా x మరియు y ఎంత దూరం?
మీరు చిరునామా అత్యంత విస్మరించవచ్చు.
నాలుగు బైట్లు.
ఆ స్థిరంగా మా గతంలో ఒక పూర్ణాంకానికి ఎంత పెద్ద దావా?
నాలుగు బైట్లు.
కనుక ఇది ప్రతిదీ లైనింగ్ అప్ కనిపిస్తోంది చక్కగా, మీరు మెమరీలో, ఆశించవచ్చు.
>> కాబట్టి ఇప్పుడు, కేవలం ఫాస్ట్ ఫార్వర్డ్ తెలియజేయండి ఈ కథ ముగింపు.
, యొక్క ముందుకు వెళ్లి అడుగు టైప్ లెట్ swap ఫంక్షన్ ప్రవేశిస్తాడు.
ఇప్పుడు నేను ఒక టైప్ ఉంటే, అది గమనించని x యొక్క చిరునామా సమానంగా.
నేను బి టైప్ ఉంటే, ఇది ఏకరూప y యొక్క చిరునామాకు.
సో నేను ఉంటే ఏమి చూస్తారు ఒక చిరునామా వెళ్ళండి సే?
కాబట్టి ఒక నక్షత్రం ప్రింట్.
కాబట్టి నటి ఈ సందర్భంలో, అంటే అక్కడ వెళ్ళండి.
ఆంపర్సండ్ చిహ్నం చిరునామా ఏమిటి అర్థం.
కాబట్టి ఒక సాధనంగా 1 స్టార్.
మరియు ముద్రణ స్టార్ బి నాకు 2 ఇస్తుంది.
>> నాకు క్షణం ఊహించుకుంటే తెలియజేయండి కనీసం కోడ్ ఆ
అని ఇప్పుడు అమలు ఉపక్రమించాడు ఆ విధంగా ద్వారా కారణం.
కానీ మేము దీర్ఘ ముందు ఈ ఆలోచన సందర్శించండి చేస్తాము.
స్వాప్ కాబట్టి ఈ వెర్షన్ ఇప్పుడు సరైన అనుమతించే
మాకు ఈ ప్రత్యేక డేటా రకం మార్చుకోవడానికి.
>> కాబట్టి అప్పుడు ఏదైనా ప్రశ్నలు స్వాప్?
స్టార్?
యొక్క చిరునామా న?
మరియు మీరు తో, చూస్తారు సమస్య విధమైన సెట్ 4
కానీ సమస్య 5, ఖచ్చితంగా, ఎలా ఈ సెట్ విషయాలు ఉపయోగకరం మరియు పొందుటకు మరింత
ఫలితంగా, వాటిని సౌకర్యవంతమైన.
అన్ని వద్ద ఏదైనా?
అన్ని కుడి.
కాబట్టి malloc, ఈ ఫంక్షన్ మళ్ళీ, కేవలం మెమరీ, మెమరీ కేటాయించుకునే
కేటాయింపు.
ఎందుకు ఈ ఉపయోగపడుతుంది?
Well, ఈ సమయంలో, మీరు malloc ఉపయోగించి పరిష్కరించగలుగుతున్నాము.
ఎలా మీరు ఇప్పుడు పరిగణలోకి ఉంటే రచనలు GetString, బహుశా, ఇది వార్తలు
ఒక భాగం కోసం ఎవరైనా అడగడం జరిగింది జ్ఞాపకశక్తి, ఎప్పుడైనా వినియోగదారు రకాల స్ట్రింగ్
, ఖచ్చితంగా మేము ఎందుకంటే తెలియదు, CS50 సిబ్బంది వంటి,
ఎంత పెద్ద ఆ తీగలను మానవులు కావచ్చు టైప్ వెళ్తున్నారు.
>> కాబట్టి, మొదటి సారి, ప్రారంభిద్దాం చర్మము తిరిగి ఎలా CS50 లైబ్రరీ రచనలు,
ఉదాహరణలలో ఒక జంట ద్వారా అక్కడ మాకు దారి తీస్తుంది.
నేను gedit అప్ తెరిచి చేస్తే మరియు, scanf 0 తెరవటానికి
మేము ఈ క్రింది కోడ్ చూడండి చూడాలని.
వెబ్సైట్లో అందుబాటులో scanf 0, నేడు కోడ్ సాపేక్షంగా కొన్ని పంక్తులు ఉంది
ఇక్కడ, 20 ద్వారా 14.
మరియు ఇది ఏమి చూద్దాం.
ఇది ఒక పూర్ణాంకానికి అని x ప్రకటించాడు.
ఏదో, సంఖ్య దయచేసి చెప్పారు.
ఇప్పుడు అది scanf% i, & X అన్నారు.
కాబట్టి అక్కడ కొత్త stuff ఒక సమూహం ఉంది.
>> కానీ scanf, మీరు రకమైన ఆలోచించవచ్చు యొక్క printf వ్యతిరేకం గా.
printf, కోర్సు యొక్క, స్క్రీన్ ప్రింట్లు.
యూజర్ యొక్క నుండి స్కాన్లు scanf విధమైన కీబోర్డ్ ఏదో అతను లేదా ఆమె టైప్.
>> % I కేవలం printf వంటిది.
ఇది అంచనా అర్థం వినియోగదారు ఒక Int టైప్.
మరియు ఇప్పుడు, ఎందుకు మీరు నేను భావిస్తున్నాను లేదు scanf & x ప్రయాణిస్తున్న ఉండవచ్చు?
ఉంటే scanf జీవితం లో ప్రయోజనం వినియోగదారు నుండి ఏదో పొందుటకు ఉంది,
యొక్క అర్థం ఏమిటి ఇప్పుడు, అది దాటారు & x?
అవును?
>> ప్రేక్షకులు: [వినబడని].
డేవిడ్ J. మలన్: ఖచ్చితంగా.
ఏమైనప్పటికీ నేను, మానవ, నా ఇన్పుట్ టైప్ ఆ స్థానాన్ని సేవ్ అన్నారు.
ఇది కేవలం, గుర్తు, సరిపోతాయి కాదు మేము ఇప్పటికే చూసిన ఎందుకంటే, x లో పాస్,
ఏ సమయంలో మీరు, కేవలం ఒక ముడి వేరియబుల్ పాస్ ఒక పూర్ణాంకానికి వంటి కొన్ని ఇతర ఫంక్షన్,
ఖచ్చితంగా, అది మార్చవచ్చు వేరియబుల్, కానీ శాశ్వతంగా.
ఇది ప్రధాన ప్రభావం ఉండకూడదు.
ఇది మాత్రమే దాని స్వంత స్థానిక కాపీ మార్చవచ్చు.
అయితే, బదులుగా, మీరు లేదు నాకు అసలు పూర్ణాంకానికి ఇవ్వాలని,
కానీ మీరు నాకు ఆదేశాలు ఇవ్వాలని ఆ Int, నేను ఇప్పుడు, scanf ఉండటం
ఖచ్చితంగా, నేను ఆ అనుసరించండి పరిష్కరించడానికి మరియు అక్కడ అనేక చాలు
కాబట్టి మీరు అలాగే అది యాక్సెస్.
>> నేను ఈ ప్రోగ్రామ్ రన్ కనుక, యొక్క చూసేలా.
Scanf 0 డాట్ స్లాష్ చేయండి, 0 scanf.
మరియు నేను ఇప్పుడు ఒక సంఖ్య టైప్ ఉంటే 50 వంటి, 50 ధన్యవాదాలు.
నేను ఇప్పుడు వంటి అనేక టైప్ ఉంటే ప్రతికూల 1, మొత్తం 1 ప్రతికూల.
నేను ఇప్పుడు HM 1.5 వంటి సంఖ్యను టైప్ చేయండి.
ఎందుకు నా ప్రోగ్రామ్ నాకు పట్టించుకోకుండా లేదు?
వెల్, ఎందుకంటే కేవలం, నేను చెప్పారు అది ఒక పూర్ణాంకానికి మాత్రమే ఆశించే.
అన్ని కుడి.
కాబట్టి ఈ ఒకటి సంస్కరణ.
యొక్క ఒక గీత అప్ విషయాలు తీసుకుందాం ఈ మంచి కాదు అని ప్రతిపాదించారు.
మరియు ఇక్కడ ఒక చాలా చిన్న ఉదాహరణ ఉంది మేము రచనలలో కోడ్ ప్రారంభించవచ్చు ఎలా
ఇతర ప్రజలు దోపిడీ చేసే లేదా చెడు పనులు చేయడం ద్వారా రాజీ.
కాబట్టి లైన్ 16, అలా పోలి ఆత్మ ముందు,
కానీ నేను ఈ సమయంలో, Int ప్రకటించారు లేదు చేస్తున్నాను.
నేను స్ట్రింగ్ ఆక, ఇది చార్ స్టార్ ప్రకటించారు చేస్తున్నాను.
>> కానీ నిజంగా అర్థం ఏమిటి?
కాబట్టి నేను ఒక చిరునామాతో ఇవ్వకండి ఉంటే నేను కక్ష్య కాల్ చేస్తున్నాను, బఫర్,
కానీ నేను simple-- ఉండటానికి, అది వార్తలు కాల్ కాలేదు ఆపై నేను దీన్ని నాకు వివరించేందుకు
మీరు మునుపటి ఆధారంగా, అనుకొనుట ఉంటే తర్కం, scanf లైన్ 18 లో, ఏమి
పాస్% s మరియు బఫర్ ఉంటే, ఒక చిరునామా ఉంటుంది?
మీరు దరఖాస్తు ఉంటే scanf, ఏమిటి వెర్షన్ 0 గా ఖచ్చితమైన అదే తర్కం,
ఇక్కడ అలా ప్రయత్నించండి అన్నారు ఉన్నప్పుడు వినియోగదారు రకాల ఏదో?
అవును?
>> ప్రేక్షకులు: [వినబడని].
>> డేవిడ్ J. మలన్: ఖచ్చితంగా.
Scanf, తర్కం ముందువి ద్వారా, స్ట్రింగ్ పడుతుంది అన్నారు
మానవ టైప్ అది ఇప్పుడు ఒక స్ట్రింగ్ in--
అది, బహుశా, ఒక సంఖ్య కాదు అతను లేదా ఆమె cooperates-- ఉంటే
మరియు అది ఉంచారు ప్రయత్నించండి జరగబోతోంది ఏమైనా చిరునామా మెమరీ స్ట్రింగ్
బఫర్ నిర్దేశిస్తుంది.
మరియు ఈ గొప్ప ఉంది బఫర్ ఎందుకంటే నిజంగానే చిరునామా అని అర్థం.
>> కానీ నేను ఈ కార్యక్రమం లో బగ్గీ ఉంది దావా చాలా తీవ్రమైన విధంగా, విలువ ఏమిటి ఎందుకంటే
అప్రమేయంగా స్వీకరించేందుకు?
నేను లోకి ఏం initialized చేశారు?
మెమరీ ఏమిటి భాగం?
నేను లేదు, కుడి?
>> కాబట్టి నేను కేటాయించింది చేసిన అయినప్పటికీ ఒక ఇకపై లు అని చార్ స్టార్,
ఇది బదులుగా అని, కాబట్టి buffer-- వేరియబుల్ యొక్క పేరు డ్రా తెలియజేయండి
నేను కలిగి ఉంటే ఇప్పుడు buffer-- ఇక్కడ GetString లేదా malloc అని,
ఆ సమర్థవంతంగా అర్థం బఫర్ కేవలం కొన్ని చెత్త విలువ.
>> ఇప్పుడు ఆ అర్థం ఏమిటి?
ఇది నేను scanf చెప్పారు అర్థం వినియోగదారు నుండి ఒక స్ట్రింగ్ ఆశించడం.
మరియు మీరు ఏమి?
ఏది ఈ విషయం సూచించబడిన ఆలోచన మరియు నేను ప్రశ్న మార్క్ డ్రా,
కానీ వాస్తవంలో, ఇది చేస్తాడు Ox1, 2, 3, వంటి ఏదో కుడి?
ఇది కొన్ని బోగస్ విలువ కేవలం ముందు నుండి ఉన్నాయి నిర్మాణము.
కాబట్టి మరో విధంగా చెప్పాలంటే, ఇది వార్తలు బఫర్ కేవలం అయినప్పటికీ గా
మెమరీ లో ఏదో చెబుతోంది.
నేను ఏమి సంఖ్య ఆలోచన ఉంది.
>> నేను ఇప్పుడు గాబే లో టైప్ చేస్తే, అది జరగబోతోంది అక్కడ G-a-b-ఇ / 0 ఉంచాలి ప్రయత్నించండి.
కానీ ఎవరు అని తెలుసు?
మరియు గతంలో ఏ మేము తాకే ప్రయత్నించారు చేసిన సమయం
చెందినది కాదు మెమరీ మాకు, ఏమి జరిగింది?
లేదా దాదాపు ప్రతిసారీ.
విభజన లోపంగా, కుడి?
>> ఇది ఎక్కడ ఈ బాణం, నేను సంఖ్య ఆలోచన ఉంది పాయింటింగ్. ఇది కేవలం కొన్ని యాదృచ్ఛిక విలువ ఏమిటి.
మరియు కోర్సు యొక్క, మీరు అనుకుంటున్నట్లు ఉంటే ఒక చిరునామా ఒక యాదృచ్ఛిక విలువ,
మీరు వెళ్ళండి చూడాలని కొన్ని యాదృచ్ఛిక గమ్యం.
కాబట్టి గాబే క్రాష్ నిజానికి వాటిని ఇక్కడ ఈ సందర్భంలో నా ప్రోగ్రామ్.
>> కాబట్టి మేము దాదాపు చెడు ఏమి చేయవచ్చు?
ఈ మూడవ పరిగణించండి మరియు scanf ఆఖరి ఉదాహరణ.
ఈ సంస్కరణ ఏ కోణంలో ఉత్తమం?
మీరు సౌకర్యవంతంగా ఉంటాయి ఉంటే మునుపటి సమస్య, ఈ మంచి ఉంది.
ఎందుకు?
>> ప్రేక్షకులు: [వినబడని].
డేవిడ్ J. మలన్: గుడ్.
లైన్ 16 కాబట్టి ఈ కేసు భావంలో, ఉత్తమం
మేము స్పష్టంగా ఉన్నట్లు కొన్ని మెమరీ పెడుతోంది.
మేము, malloc ఉపయోగించి లేదు మేము వారం 2 ఉపయోగించి చేస్తున్నారు
కేవలం వ్యూహం ప్రకటించే విధానం.
మరియు మేము ఒక స్ట్రింగ్ ముందు చెప్పారు చేసిన కేవలం అక్షరాల యొక్క శ్రేణి,
కాబట్టి ఈ పూర్తిగా అవసరమని.
కానీ అది, కోర్సు యొక్క, ఉంది మీరు 16, స్థిర పరిమాణం గమనించండి.
>> కాబట్టి ఈ ప్రోగ్రామ్ ఉంది పూర్తిగా సురక్షితంగా, నేను టైప్ ఉంటే
ఒక పాత్ర తీగలను లో, రెండు మూర్తులు తీగలను, 15 పాత్ర తీగలను.
కానీ వెంటనే నేను 16 టైప్ మొదలు, 17, 18, 1,000 పాత్ర తీగలను,
అక్కడ ఆ స్ట్రింగ్ ముగుస్తుంది అన్నారు?
ఇది పాక్షికంగా ఇక్కడ వదులుకోవడానికి జరగబోతోంది.
కానీ అప్పుడు ఎవరు ఏం else తెలుసు సరిహద్దులు దాటి ఉంది
ఈ ప్రత్యేక శ్రేణి యొక్క?
>> నేను చేసిన అయితే ఇది ఇక్కడ 16 బాక్సులను ప్రకటించింది.
కాబట్టి అన్ని 16 అవ్ట్ డ్రా కాకుండా, మేము చేస్తాము కేవలం నేను 16 డ్రా చేసిన నటిస్తారు.
కానీ నేను ఒక స్ట్రింగ్ చదవడానికి ప్రయత్నించండి ఉంటే 50 అక్షరాలు వంటి, చాలా పొడవుగా ఉంది,
నేను పెట్టటం మొదలు వెళుతున్న ఒక, B, C, D, X, Y, Z.
మరియు ఈ బహుశా ఉంది కొన్ని ఇతర మెమరీ విభాగంలో
మళ్ళీ, కారణం కావచ్చు నా ప్రోగ్రామ్ క్రాష్
నేను అడిగారు చేసిన ఎందుకంటే కేవలం 16 బైట్ల కంటే ఎక్కువ ఏదైనా.
>> కాబట్టి ఎవరు పట్టించుకుంటారు?
సరే, ఇక్కడ CS50 లైబ్రరీ.
మరియు ఈ అత్యంత కేవలం ఉంది టాప్ వంటి సూచనలను.
CS50 లైబ్రరీ, ఈ సమయంలో, లైన్ 52 లో ఈ లైన్ కలిగి ఉంది.
మేము typedef చూసిన, లేదా చేసిన మీరు typedef చూస్తారు
కేవలం సృష్టిస్తుంది ఇది pset 4 లో పర్యాయపదంగా చార్ స్టార్ మలిచారు
కేవలం స్ట్రింగ్ వలె సూచిస్తారు.
కాబట్టి ఈ ఒకటి కొన్ని శిక్షణ చక్రాలు
మేము హుడ్ కింద రహస్యంగా ఉపయోగించారు చేసిన.
>> ఇంతలో, ఇక్కడ GetChar, ఫంక్షన్ ఉంది.
ఇప్పుడు స్పష్టంగా, అది ఎటువంటి శరీరం ఉంది.
నిజానికి, నేను ఉంచుకుంటే స్క్రోలింగ్, నేను నిజానికి లేదు
ఏ ఆచరణలు చూడండి ఈ విధులను.
ఒక పవిత్రత చెక్, ఆ ఎందుకు?
>> ప్రేక్షకులు: [వినబడని].
డేవిడ్ J. మలన్: అవును.
కాబట్టి ఈ శీర్షిక ఫైలు.
మరియు శీర్షిక ఫైళ్లు నమూనాలను కలిగి, ప్లస్ కొన్ని ఇతర అంశాలు, అది కనిపిస్తుంది,
typedefs వంటి.
కానీ cs50.c, మేము చేసిన బొత్తిగా మీరు ఇచ్చిన ఎప్పుడూ,
కానీ CS50 పరికరంలోని సంతరించుకున్నాయి అన్ని ఈ సమయంలో, లోతైన దాని ఫోల్డర్లను లోపల,
మొత్తం అక్కడ గమనిస్తారు ఇక్కడ విధులు సమూహం.
>> నిజానికి, యొక్క స్క్రోల్ డౌన్ తెలపండి.
ఇప్పుడు కోసం, వాటిలో చాలా విస్మరించండి లెట్.
కానీ GetInt క్రిందికి స్క్రోల్ మరియు GetInt పనిచేస్తుంది ఎలా చూడండి.
కాబట్టి ఇక్కడ GetInt ఉంది.
మీరు నిజంగా ఆలోచించలేదు ఉంటే చేయాలో పొందండి పూర్ణాంకానికి ఇక్కడ పనిచేస్తుంది దాని డాక్యుమెంటేషన్ ఉంది.
మరియు విషయాలతోపాటు అది మీరు చెబుతుంది చెప్పారు
విలువలు శ్రేణులు తిరిగి చేయవచ్చు ఏమి.
ఇది ముఖ్యంగా ప్రతికూల వార్తలు 2 బిలియన్ అనుకూల 2 బిలియన్ ఇవ్వడం లేదా తీసుకోవడం.
>> మరియు అది అన్ని ఈ టర్న్స్ సమయం, మేము ఎప్పుడూ చేసిన అయినప్పటికీ
మీరు దాని కోసం తనిఖీ చేసింది, ఏదో తప్పు పోతే,
ఇది అన్ని ఆ అవుతుంది ఈ సమయంలో, GetInt ఉంది
ఒక ప్రత్యేక తిరిగి చేశారు , శూన్య, స్థిరమైనది కాదు
కానీ ఇది int_max కేవలం ఒక ప్రోగ్రామర్ కన్వెన్షన్.
ఇది ఇక్కడ అర్థం ఒక ప్రత్యేక విలువ ఉంది.
కేవలం ఈ తనిఖీ నిర్ధారించుకోండి విషయంలో ఏదో తప్పు జరిగితే.
కానీ మేము పొందలేదన్న ఎప్పుడూ చేసిన తేదీ ఆ,
మళ్ళీ, ఈ ఎందుకంటే సరళీకృతం చేయడానికి ఉద్దేశించబడింది.
>> కానీ ఎలా GetInt అమలు చేసుకోగా లేదు?
సరే,, అది ఎటువంటి వాదనలూ లేవు పడుతుంది.
మేము తెలుసు.
ఇది ఒక పూర్ణాంకానికి తిరిగి.
మేము తెలుసు.
కాబట్టి ఎలా హుడ్ కింద పని చేస్తుంది?
>> కాబట్టి స్పష్టంగా అనంత ఉంది లూప్ ఒక కనీసం ప్రదర్శన.
మేము GetString ఉపయోగించి గమనించాలి.
కాబట్టి ఆసక్తికరంగా ఉందని. GetInt మా సొంత ఫంక్షన్ GetString, పిలుస్తుంది.
ఇప్పుడు ఎందుకు ఈ సందర్భంలో కావచ్చు?
ఎందుకు నేను రక్షక ఉండటం am ఇక్కడ లైన్ 165 లో?
ఏం లైన్ లో జరిగి 164, కేవలం స్పష్టతను?
ఇది ముందు అదే సమాధానం ఉంది.
కేవలం మెమరీ బయటకు కావచ్చు.
ఏదో, GetString తో తప్పు జరిగితే మేము ఆ నిర్వహించడానికి చెయ్యగలరు పొందారు.
మరియు కారణం నేను శూన్య తిరిగి లేదు ఆ సాంకేతికంగా శూన్య ఒక పాయింటర్ ఉంది.
GetInt ఒక పూర్ణాంకానికి తిరిగి ఉంది.
కాబట్టి నేను ఏకపక్ష చేసిన ముఖ్యంగా నిర్ణయించుకుంది
2 బిలియన్ అని, వెళ్ళి ఇవ్వాలని లేదా పడుతుంది ఒక ప్రత్యేక విలువ అని నేను చెయ్యవచ్చు ఎప్పుడూ
వాస్తవానికి వినియోగదారు నుండి పొందండి.
ఇది నేను వెళుతున్నాను కేవలం ఒక విలువ వార్తలు ఒక లోపం కోడ్ ప్రాతినిథ్యం వృధా.
>> కాబట్టి ఇప్పుడు, విషయాలు కొద్దిగా ఫాన్సీ పొందండి.
మరియు అది చాలా అదే ఫంక్షన్ కాదు ముందు గా, కానీ అది చాలా పోలి ఉంది.
కాబట్టి నేను లైన్ లో ఇక్కడ డిక్లేర్ గమనించవచ్చు 172, ఒక పూర్ణాంకానికి n మరియు ఒక చార్ సి రెండూ.
ఆపై నేను, ఈ అల్లరిగా పంక్తిని ఉపయోగించండి దాన్ని మారుతుంది ఇది sscanf,
కీబోర్డ్ నుండి ఒక స్ట్రింగ్ స్కాన్ లేదు.
ఇది ఇప్పటికే ఉన్న స్ట్రింగ్ నిలిచే యూజర్ ఇప్పటికే సైన్ టైప్.
కాబట్టి నేను ఇప్పటికే GetString, అని ఇది నేను మెమరీ లో ఒక స్ట్రింగ్ కలిగి అర్థం.
sscanf ఏమి మీరు కావలసిన ఒక పదనిరూపణ ఫంక్షన్ కాల్.
ఇది నేను చేసిన స్ట్రింగ్ చూసి , పాత్ర, పాత్ర లో టైప్
మరియు ఉపయోగకరమైన ఏదో చేస్తుంది.
ఆ స్ట్రింగ్ లైన్ లో నిల్వ చేయబడుతుంది.
మరియు నేను మాత్రమే వెళ్తుంటే తెలుసు సరే, OH, ఇక్కడ మరియు మాట్లాడుతూ బ్యాకప్,
నేను ఈ సమయం, కానీ లైన్ అని.
>> ఇప్పుడు ఈ చిన్న భిన్నంగా ఉంటుంది.
కానీ ఈ సమర్థవంతంగా కారణాల కోసం, అర్థం మేము కొంతవరకు నేడు, మా చేతులు దుర్చాల్సిన చేస్తాము
మేము తనిఖీ చేస్తున్నాము అని యూజర్ టైప్ చూడండి
మరియు Int మరియు బహుశా మరొక పాత్ర.
వినియోగదారు ఒక Int లో టైప్ ఉంటే, అది వార్తలు నేను ఉన్నాను ఎందుకంటే అన్నారు, N భద్రపర్చడానికి
చిరునామా ద్వారా ఈ దాటారు మేము నేడు చూసిన కొత్త ట్రిక్.
వినియోగదారు టైప్ ఉంటే వంటి 123x లో, ఆ x
ఒక ముగుస్తుంది అన్నారు పాత్ర సి లో లేఖ.
>> ఇప్పుడు ఆ sscanf అవుతుంది తెలివిగా, చెప్పు,
ఎన్ని వేరియబుల్స్ sscanf చేశారు పూరించడానికి విజయవంతంగా చేయగలరు.
ఈ తర్కం ద్వారా, చేస్తే ఫంక్షన్ నేను, GetInt అమలు చేస్తున్నాను
కానీ నేను తనిఖీ చేస్తున్నాను, సమర్థవంతంగా, యూజర్ కోసం
ఒక Int లో టైప్ చేసిన తర్వాత ఏదో తరువాత,
ఏమి నేను sscanf యొక్క అనుకుంటున్నారు తిరిగి విలువ నిజంగా ఉండాలి?
ప్రయోజనం పొందడానికి ఉంటే కేవలం యూజర్ నుండి ఒక పూర్ణాంకానికి?
>> కాబట్టి sscanf తిరిగి ఉంటే 2, ఆ అర్థం ఏమిటి?
యూజర్ టైప్ ఏదో వంటి, వాచ్యంగా,
కేవలం అర్ధంలేని ఇది 123x.
ఇది ఒక లోపం పరిస్థితి, మరియు నేను ఆ కోసం తనిఖీ చెయ్యవచ్చును.
>> కాబట్టి ఈ వినియోగదారు రకాల ఉంటే, ద్వారా ఈ తర్కం, తిరిగి sscanf ఏమి,
మీరు చెబుతా?
కాబట్టి ఇది ఎందుకంటే, 2 తిరిగి వెళుతున్న 123, ఇక్కడ వెళ్ళండి అన్నారు
మరియు x ఇక్కడ ముగుస్తుంది అన్నారు.
కానీ నేను x నిండి పెట్టడానికి వద్దు.
నేను మాత్రమే విజయవంతం sscanf కావలసిన దాని వేరియబుల్స్ మొదటి నింపి.
కాబట్టి ఎందుకు నేను sscanf 1 తిరిగి అనుకుంటున్నారా.
>> మరియు ఈ తలపై ఒక బిట్ ఉంటే క్షణం కోసం, ఆ పూర్తిగా మంచిది.
అయితే ఆ ఒకటి రియలైజ్ GetInt మరియు GetString విలువలు
మేము ఒక హెక్ చేస్తున్న ఉంది ఈ విధంగా వంటి తనిఖీ లోపం చాలా
ఆ తేదీ వరకు, మీరు చాలా చక్కని చెయ్యవచ్చు మీ కీబోర్డ్ వద్ద ఏదైనా టైప్
మరియు మేము అది క్యాచ్ ఉంటుంది.
మరియు మేము ఖచ్చితంగా, సిబ్బంది, కాదు ఖచ్చితంగా రెడీ
ఒక బగ్ మూలం ఉంటుంది మీ కార్యక్రమం, మేము రక్షణాత్మకంగా ఉన్నాము ఎందుకంటే
స్టుపిడ్ అన్ని కోసం తనిఖీ ఒక వినియోగదారు విషయముల,
, ఒక స్ట్రింగ్ టైపింగ్ వంటి మీరు నిజంగా పూర్ణాంకానికి కోరుకున్నారు.
కాబట్టి మేము వచ్చి చేస్తాము ఇప్పుడు కోసం తిరిగి ఈ లాంగ్ ముందు
కానీ ఈ సమయంలో, GetString మరియు GetInt కలిగి
ఈ ఉపయోగించి హుడ్ కింద ఉన్నారు మెమరీ అడ్రసులను ప్రాథమిక ఆలోచన.
>> కాబట్టి ఇప్పుడు, ఒక యొక్క విషయాలు తయారు చేద్దాము యూజర్ ఫ్రెండ్లీ కొంచెం ఎక్కువ ఉంటుంది.
మీరు Binky చివరి నుండి, గుర్తుకు విధంగా time-- నా మౌస్ కాబట్టి cooperate-- ఉంటే
మేము ఈ కోడ్ కలిగి లేని స్పష్టముగా, బొత్తిగా పనికిమాలిన.
ఈ కోడ్ ఏమీ సాధిస్తుంది ఉపయోగకరమైన, కాని ఉదాహరణ
ఆ ప్రొఫెసర్ Parlante య క్రమంలో ఉపయోగిస్తారు
ఏమి ఒక లో జరగబోతోంది మెమరీ పాల్గొన్న కార్యక్రమం.
>> కాబట్టి యొక్క ఈ కధా శ్రేణిలో తెలియజేయండి కథ సూపర్ క్లుప్తంగా.
ఈ మొదటి రెండు పంక్తులు లో ఇంగ్లీష్, మీరు ఏమి చెబుతారు లేదు?
జస్ట్ సహేతుక మానవ, కానీ కొద్దిగా సాంకేతిక నిబంధనలు, ఒక ఉదంతం పడుతుంది.
ప్రేక్షకులు: [వినబడని].
>> డేవిడ్ J. మలన్: సరే, మీరు స్థాపించటం చేస్తున్నారు మీ x మరియు y వేరియబుల్స్ చిరునామాలు.
కాదు, x మరియు y కాదు ఎందుకంటే సంప్రదాయ అర్థంలో వేరియబుల్స్.
x మరియు y చిరునామాలు లేదా చిరునామా నిల్వ చేస్తుంది.
కాబట్టి యొక్క ఈ సారి మరిన్ని ప్రయత్నించండి తెలియజేయండి.
Not a చెడు ప్రారంభం, అయితే.
అవును?
>> ప్రేక్షకులు: [వినబడని].
డేవిడ్ J. మలన్: గుడ్.
నేను ఒక చిన్న క్లీనర్ అని.
రెండు పాయింటర్లు, రెండు పూర్ణాంకాల ప్రకటన.
మరియు మేము వాటిని x మరియు y కాల్ చేస్తున్నారు.
లేదా మేము ఉన్నట్లయితే డ్రా ఈ చిత్రాన్ని మళ్ళీ,
చాలా సరళంగా అన్ని గుర్తుకు మేము, మొదటి లైన్ తో చేస్తున్నా
ఈ వంటి ఒక బాక్స్ గీయడం, అది కొన్ని చెత్త విలువతో
ఆపై ఇది x పిలుపు ఈ వంటి మరొక బాక్స్,
కొన్ని చెత్త విలువతో అది, Y పిలుస్తూ.
మేము రెండు డిక్లేర్డ్ చేసిన గమనికలు చివరికి
ఒక పూర్ణాంకానికి యొక్క చిరునామా నిల్వ చేస్తుంది.
కాబట్టి అన్ని ఉంది.
>> Binky ఈ చేశాడు కాబట్టి, మట్టి కేవలం ఈ వంటి చూసారు.
మరియు నిక్ కేవలం రకమైన బాణాలు ముగిస్తుంది,
అయితే వారు ఎక్కడైనా పై లేదు ముఖ్యంగా, ఎందుకంటే వారు మాత్రమే ఉన్నారు
చెత్త విలువలు.
వారు స్పష్టంగా initialized లేదు ఎక్కడైనా పెడుతోంది.
>> ఇప్పుడు తదుపరి లైన్ కోడ్, రీకాల్, ఈ ఉంది.
సహేతుక యూజర్ ఫ్రెండ్లీ కాబట్టి కానీ కొంతవరకు సాంకేతిక ఇంగ్లీష్,
కోడ్ చేస్తోంది ఈ లైన్ ఏమిటి?
అవును?
>> ప్రేక్షకులు: [వినబడని].
>> డేవిడ్ J. మలన్: పర్ఫెక్ట్.
ఇది భాగం కేటాయించడం యొక్క ఒక పూర్ణాంకానికి యొక్క పరిమాణం మెమరీ.
మరియు ఆ సగం సమాధానం ఉంది.
మీరు కుడి సమాధానం వ్యక్తీకరణ సగం.
ఏం జరుగుతుందో సమాన సైన్ ఎడమ వైపు?
అవును?
ప్రేక్షకులు: గలవారు ఇది వేరియబుల్ x కు?
>> డేవిడ్ J. మలన్: మరియు గలవారు ఇది వేరియబుల్ x కు.
పునశ్చరణ, కుడి చేతి వైపు కేటాయించుకునే సో తగినంత మెమరీ ఒక పూర్ణాంకానికి నిల్వ.
కానీ malloc ప్రత్యేకంగా చిరునామా తిరిగి
మీరు చేసిన మెమరీ ఆ భాగం యొక్క కేవలం x లో నిల్వ కావాలి ప్రతిపాదించారు.
>> సో వాట్ నిక్ Binky తో చివరిసారిగా చేసింది ఉంది అతను ఆ పాయింటర్ బయటకు లాగారు, మట్టి,
మెమరీ తెలుపు భాగం వద్ద ఇప్పుడు మార్చాలి ఒక పూర్ణాంకానికి యొక్క పరిమాణం సమానంగా ఉంది.
నిజానికి, ఆ అర్థం ఉంది నాలుగు బైట్లు సూచించడానికి.
>> కోడ్ యొక్క ఇప్పుడు వచ్చే లైన్ ఈ చేశాడు, స్టార్ X 42 గెట్స్.
కాబట్టి 42 సూటిగా ఉంటుంది కుడి వైపు, జీవితం యొక్క అర్థం.
ఎడమ చేతి వైపు, స్టార్ X అంటే అర్థం?
ఆ సరే gone-- ఆ చాలా కలిగి ఉండవచ్చు.
సరే.
>> ప్రేక్షకులు: సాధారణంగా, [వినబడని] కు వెళ్ళండి
డేవిడ్ J. మలన్: గుడ్.
ప్రేక్షకులు: [వినబడని].
డేవిడ్ J. మలన్: ఖచ్చితంగా.
ఎడమ చేతి వైపు x కు వెళ్ళి అర్థం.
X చిరునామా.
ఇది 33 ఆక్స్ఫోర్డ్ స్ట్రీట్, లేదా Ox1 వంటిది.
ఆ నక్షత్రం అని X వెళ్ళండి అర్థం అడ్రసు మరియు అక్కడ ఉంచారు?
42.
>> కాబట్టి నిజంగా, ఆ నిక్ చేసాడు ఖచ్చితంగా ఏమిటి.
అతను ద్వారా ప్రారంభించండి ముఖ్యంగా, మానసికంగా
ఒక వేలు వద్ద గురిపెట్టి X, బాణం తర్వాత
కుడి వైపు వైట్ బాక్స్ వైపు, మరియు అనేక 42 నిలిపివేసింది.
కానీ విషయాలు వచ్చింది చిన్న ప్రమాదకరమైన, కుడి?
Binky తన తల కోల్పోతారు గురించి.
>> స్టార్ Y అర్థం, 13, చెడు అదృష్టం సమానం?
కాబట్టి స్టార్ Y అంటే Y చిరునామా వెళ్ళండి.
కానీ Y చిరునామా ఏమిటి?
అన్ని కుడి, అది చెత్త విలువ, కుడి?
నేను ఒక ప్రశ్న గుర్తు వంటి ఇది ఆకర్షించింది.
నిక్ ఒక అప్ వంకరగా బాణం వంటి ఇది ఆకర్షించింది.
మరియు వెంటనే మీకు ప్రయత్నించండి గా అక్కడ వెళ్ళి చెప్పడం, స్టార్ Y చేయండి,
కానీ ఒక చట్టబద్ధమైన లేదు చిరునామా, అది కొన్ని బోగస్ బట్టి,
క్రాష్ ప్రోగ్రామ్ జరగబోతోంది.
మరియు Binky తల అన్నారు ఇది ముందులా ఆఫ్ ఫ్లై.
>> చివరికి, ఈ కార్యక్రమం కాబట్టి కేవలం flat అవుట్ దోషం ఉంది.
ఇది ఒక బగ్గీ కార్యక్రమం.
మరియు అది నిర్ధారించడానికి అవసరమైన.
మరియు మాత్రమే మార్గం, నిజంగా, దాన్ని పరిష్కరించడానికి ఉంటుంది, ఉదాహరణకు, ఈ రేఖ
మేము కూడా రాలేదు ఇది ఎందుకంటే కార్యక్రమం చాలా త్వరగా కుప్పకూలింది.
కానీ మేము ఈ పరిష్కరించడానికి ఒకవేళ, ఏ ప్రభావం Y సమానంగా x చేస్తున్నానో చేస్తుంది?
సరే, తప్పనిసరిగా వద్ద y పాయింట్లు సంసార విలువ x వద్ద గురిపెట్టి ఉంటుంది.
>> నిక్ యొక్క కథ లో, లేదా Binky యొక్క కథ, రెండు
x మరియు y వద్ద గురిపెట్టి చేయబడ్డాయి మెమరీ తెలుపు భాగం,
కాబట్టి, చివరకు, మీరు y మళ్లీ 13 సమానం నటించనున్నాడు లేదు,
మీరు 13 పెట్టటం ముగుస్తుంది సరైన స్థానాన్ని.
కాబట్టి ఈ పంక్తులు అన్ని ఖచ్చితంగా ఉంటాయి చట్టబద్ధమైన, ఈ ఒక తప్ప,
ఇది మీరు ముందు జరిగినప్పుడు నిజానికి వై కొన్ని విలువ కేటాయించిన.
>> ఇప్పుడు కృతజ్ఞతగా, మీరు లేదు అన్ని ద్వారా కారణం కలిగి
మీ స్వంత సమస్యలు ఈ రకాల.
నాకు ముందుకు వెళ్లి తెరిచి లెట్ ఇక్కడ ఒక టెర్మినల్ విండో
మరియు కేవలం ఒక క్షణం, తెరవడం, ఒక చిన్న సూపర్ కార్యక్రమం
కూడా అర్ధం యొక్క విధమైన ఉంది.
ఇది అగ్లీ యొక్క.
ఇది ఉపయోగకరమైన ఏదైనా సాధించడానికి లేదు.
కానీ అది సమస్యలను ప్రదర్శించేందుకు లేదు memory, కాబట్టి యొక్క పరిశీలించి తెలియజేయండి.
>> మెయిన్, సూపర్ సాధారణ.
ఇది స్పష్టంగా ఒక ఫంక్షన్ కాల్స్, f, మరియు అప్పుడు 0 తిరిగి.
ఇది మెస్ ఈ అప్ రకమైన కష్టం.
కాబట్టి ప్రధాన ఇప్పటివరకు ప్రెట్టి గుడ్ ఉంది.
>> కాబట్టి f సమస్యాత్మకంగా ఉంది.
మరియు కేవలం చాలా పెట్టలేదు నామకరణ లోకి ప్రయత్నం
ఇక్కడ కోడ్ దృష్టి ఉంచాలని.
F రెండు పంక్తులు కలిగి ఉంది.
మరియు ఇప్పుడు జరగబోతోంది ఏమి చూడటానికి.
కాబట్టి ఒక వైపు ఇక్కడ నాకు తెలియజేయండి
మునుపటి ఈ స్థిరమైన ఒకవైపు ఉదాహరణకు,
ఎడమ చేతి వైపు ఇంగ్లీష్ లో, ఏమి చేస్తున్న?
ఇది is--
ప్రేక్షకులు: ఒక పాయింటర్ సృష్టిస్తోంది.
డేవిడ్ J. మలన్: ఒక పాయింటర్ సృష్టిస్తోంది ఒక పూర్ణాంకానికి అని పిలవడం ఇది x.
కాబట్టి అది ఆ బాక్సులను ఒకటి సృష్టించడం నేను టచ్ స్క్రీన్ తీసుకుంటూ వస్తున్నాను.
మరియు ఇప్పుడు, కుడి చేతి మీద వైపు, malloc, కోర్సు యొక్క,
మెమరీ భాగం కేటాయించడం ఉంది.
మరియు కేవలం స్పష్టతను, ఎలా మెమరీని స్పష్టంగా అది ఉంది
పెడుతోంది, మీరు కేవలం రకమైన ఇక్కడ గణిత చేయండి?
>> కాబట్టి అది 40 బైట్లు ఉంది.
మరియు నాకు తెలుసు అని నేను తెలుసు మాత్రమే ఎందుకంటే Int, CS50 ఉపకరణం, కనీసం,
నాలుగు బైట్లు.
కాబట్టి 10 సార్లు 4 40 ఉంది.
కాబట్టి ఈ ఒక x నిల్వ, చిరునామా 40 ints యొక్క మొదటి ఆ
తిరిగి కేటాయించింది చేశారు తిరిగి, తిరిగి, తిరిగి.
>> ఆ malloc గురించి కీ ఏమిటి.
ఇది ఒక చిన్న మెమరీ తీసుకోదు ఇక్కడ, ఇక్కడ కొద్దిగా, కొద్దిగా ఇక్కడ.
ఇది, మీరు మెమరీ ఒకటి భాగం ఇస్తుంది పక్కపక్కన, ఆపరేటింగ్ నుండి
వ్యవస్థ.
>> ఇప్పుడు ఈ గురించి ఏమి, X బ్రాకెట్ 10 0 సమానం?
కోడ్ అనియత లైన్.
ఇది ఉపయోగకరమైన ఏదైనా సాధించడానికి లేదు.
కానీ అది ఆసక్తికరంగా ఉంటుంది, X బ్రాకెట్ 10-- ఎందుకంటే?
అవును?
>> ప్రేక్షకులు: [వినబడని]?
>> డేవిడ్ J. మలన్: X బ్రాకెట్ 10 శూన్య ఉండాలి లేదు.
శూన్య వివరాలు మాత్రమే ఆటలోకి వస్తుంది తీగలను తో, ఒక స్ట్రింగ్ చివరిలో.
కానీ ఒక మంచి ఆలోచన.
>> ఎంత పెద్ద కూడా, ఈ శ్రేణి నేను 40 బైట్లు కేటాయించింది చేసిన అయితే?
ఇది కుడి, తొమ్మిది ద్వారా 0?
ఇది మొత్తం 10 ints యొక్క.
40 బైట్లు, కానీ 10 ints, 0 ద్వారా ఇండెక్స్ 0.
>> కాబట్టి ఆ x బ్రాకెట్ 10 ఏమి ఉంది?
ఇది నిజానికి కొన్ని తెలియని చెత్త విలువ.
ఇది నాకు చెందినవి లేని మెమరీ ఉంది.
నేను ఆ తాకడం చేయరాదు బైట్ సంఖ్య 41, 42, 43, 44.
నేను చాలా దూరం కొద్దిగా వెళుతున్న.
>> నిజానికి, నేను అమలు చేస్తే ఈ కార్యక్రమం, ఇది చాలా బాగా క్రాష్ కావచ్చు.
కానీ కొన్నిసార్లు, మేము లక్కీ పొందుతారు.
కాబట్టి కేవలం ప్రదర్శించేందుకు దీన్ని మరియు స్పష్టముగా,
మీరు ముందు తెలుసు ఎప్పుడూ దాన్ని యొక్క ఈ అమలు అనుమతిస్తాయి లేదు.
ఇది వాస్తవానికి క్రాష్ లేదు.
>> కానీ నేను ఈ మార్చుకుంటే ఉదాహరణకు, 1,000 ఉండాలనే
నిజంగా ఈ చేయడానికి ఉద్దేశపూర్వక, యొక్క చూసేలా
మేము లభిస్తే అది ఈ సమయంలో క్రాష్.
OK, అది క్రాష్ లేదు.
ఎలా 100,000 గురించి?
యొక్క ఇది రీమేక్ లెట్, మరియు ఇప్పుడు అది తిరిగి.
సరే.
అయ్యో.
అన్ని కుడి.
కాబట్టి స్పష్టంగా, మళ్ళీ, ఈ మెమరీ విభాగాలు, కాబట్టి, మాట్లాడటం
కాబట్టి మేము, సహేతుక పెద్ద ఉంటాయి మళ్లీ మళ్లీ అదృష్ట పొందుటకు.
కానీ చివరికి, ఒకసారి మీరు హాస్యాస్పదంగా పొందండి మరియు నిజంగా, తెరపై చాలా అవ్ట్ వెళ్ళి
మీరు నిజంగా మెమరీ టచ్ నిజంగా మీకు చెందదు.
>> కానీ స్పష్టముగా, ఈ దోషాలు రకాల వెళ్తున్నారు
కష్టం మరియు కష్టం అని మీ స్వంత న గుర్తించడానికి.
కానీ కృతజ్ఞతగా, ప్రోగ్రామర్లు, మేము కలిగి మా కోసం దీన్ని అనుమతించే ఉపకరణాలు.
కాబట్టి ఈ బహుశా, ఒకటి ugliest కార్యక్రమాలు
GDB యొక్క అవుట్పుట్ కంటే కూడా uglier.
కానీ ఇది ఎల్లప్పుడూ ఒక లైన్ ఉంది లేదా సూపర్ ఉపయోగకరంగా రెండు.
>> Valgrind సహాయపడుతుంది కార్యక్రమం మీరు ఒక ప్రోగ్రామ్ డీబగ్ కాదు, ప్రతి SE,
కానీ మెమరీ సంబంధిత కనుగొనేందుకు సమస్యలు, ప్రత్యేకంగా.
ఇది స్వయంచాలకంగా మీ కోడ్ అమలు చేస్తుంది మీరు మరియు కనీసం రెండు విషయాలు కోసం చూడండి.
ఒకటి, మీరు ఏదో చేసావ్ టచ్ మెమరీ వంటి ప్రమాదవశాత్తు
మీరు ఉండలేదు?
ఇది మీరు ఆ సందర్భాలలో సహాయపడుతుంది.
>> రెండు, అది సహాయం చేస్తుంది మీరు అని ఏదో కనుగొనేందుకు
మెమరీ లీకేజ్, మేము కలిగి పూర్తిగా నిర్లక్ష్యం, naively,
కొంత సమయం కోసం మరియు పరమానందంగా.
కానీ ఇది అన్ని అవుతుంది ఈ సమయంలో, చేసినప్పుడు
మీరు GetString లో అని చేసిన మా కార్యక్రమాలు చాలా ఉన్నాయి,
మీరు ఆపరేటింగ్ అభ్యర్థిస్తున్నాము మెమరీ సిస్టమ్,
కానీ మీరు ఏ జ్ఞప్తికి తెచ్చుకొను ఎప్పుడూ ఇవ్వడం
తిరిగి చేస్తున్న unalloc, లేదా ఉచిత, అది అని.
లేదు, ఎందుకంటే మేము ఎప్పుడూ చేసిన అలా మీరు అడిగారు.
>> కానీ ఈ సమయంలో, కార్యక్రమాలు మీరు C లో రాయడం చేసిన
మెమరీ లీకింగ్ చేశారు ఆపరేటింగ్ అడుగుతూ
మరింత సిస్టమ్ తీగలను మరియు whatnot మెమరీ,
కానీ అది తిరిగి ఇవ్వడానికి ఎప్పుడూ.
ఇప్పుడు ఈ ఒక బిట్ ఉంది ఒక అతిసూక్ష్మీకరణ,
కానీ మీరు ఎప్పుడూ మీరు మీరు మీ Mac అమలు లేదా కొంతకాలంగా ప్రారంభ కోసం మీ PC
కార్యక్రమాలు మా, బహుశా, కార్యక్రమాలు మూసివేయడం
అయినప్పటికీ మీ కంప్యూటర్ క్రాష్ లేదు,
అది చాలా నెమ్మదిగా సంతరించుకోనుంది ఇది నిజంగా అయితే వంటి
మెమరీ చాలా ఉపయోగించి లేదా వనరులు, అయినప్పటికీ,
మీరు తెలియకపోతే కూడా కీబోర్డును స్పృశించడం,
ఆ ఉండబోతుంది కానీ always-- గలిగారు కార్యక్రమాలు మీరు రన్ చేస్తున్న ఉంటుంది
తాము మెమరీ లీకేజ్.
మరియు వారు మరింత మరియు OS అడగడం మరింత మెమరీ ఉంది, కానీ దాని గురించి మర్చిపోకుండా,
నిజానికి, ఇది ఉపయోగించడం లేదు కానీ అందువలన దూరంగా మెమరీ తీసుకొని
కావలసిన ఉండవచ్చు ఇతర కార్యక్రమాలు నుండి.
కాబట్టి ఒక సాధారణ వివరణ ఉంది.
ఇప్పుడు ఇక్కడ ఎక్కడ Valgrind యొక్క వార్తలు అవుట్పుట్ పూర్తిగా ఉంది
ఆ తక్కువ దారుణమైన మరియు అలైక్ మరింత సౌకర్యవంతమైన.
కానీ ఆసక్తికరమైన అంశాలు ఇక్కడ కుడి అప్ ఉంది.
ఇది నాకు ఒక చెల్లని రాసే చెప్తుంటాడు పరిమాణం నాలుగు, ఈ కార్యక్రమం జరుగుతుంది
ముఖ్యంగా, memory.c యొక్క లైన్ 21 వద్ద.
>> నేను HM, అక్కడ నిజానికి, 21 వరుసలో వెళ్ళి ఉంటే పరిమాణం నాలుగు చెల్లని రాసే ఉంది.
ఎందుకు పరిమాణం నాలుగు?
Well, ఈ సంఖ్య మరియు అది ఏదైనా కావచ్చు ఒక పూర్ణాంకానికి ఉంది.
అది నాలుగు బైట్లు ఉంది.
కాబట్టి నేను నాలుగు బైట్లు చూస్తూ నేను అక్కడ వారు లభించవు.
ఆ ఏమి Valgrind వార్తలు నిజానికి నాకు చెప్తుంటాడు.
అంతేకాక, అది కూడా రెడీ మేము చూస్తారు వంటి, నాకు చెప్పండి,
మీరు ఈ భవిష్యత్ pset లో అమలు వంటి, మరియు మీరు ఇది నిజానికి మెమరీ, వెల్లడైంది చేసినప్పుడు
నేను అని చేసిన ఎందుకంటే నేను కలిగి malloc, కానీ నేను నిజానికి కాదు కలిగి
ఉచిత, ఈ సందర్భంలో, ఒక అని, ఇది మేము చివరికి చూస్తారు
malloc యొక్క వ్యతిరేకం.
>> కాబట్టి ఇప్పుడు, నేను, ఒక చివరి ఉదాహరణకు అనుకుంటున్నాను.
కాబట్టి ఈ ఒక కొంచెం వార్తలు రహస్యములు, కానీ అది బహుశా వార్తలు
అతిపెద్ద కారణం స్మృతితో జాగ్రత్తగా ఉండాలి
మరియు కారణం అనేక కార్యక్రమాలు మరియు కూడా ఈ రోజు / లేదా వెబ్ సర్వర్లు,
ఎక్కడో చెడు అబ్బాయిలు స్వాధీనం ఇంటర్నెట్ లో ఏదో ఎవరు
మీ సర్వర్కు బోగస్ ప్యాకెట్లను పంపడం మీ ఖాతాలను రాజీ ప్రయత్నిస్తున్న,
లేదా మీ డేటా పడుతుంది, లేదా కేవలం సాధారణంగా ఒక యంత్రం పై పడుతుంది.
బఫర్ ఓవర్ఫ్లో, వంటి పేరు, అంటే సూచిస్తుంది
ఒక Int, కానీ ఒక బఫర్ పొంగి.
మరియు ఒక బఫర్ కేవలం ఒక ఫాన్సీ మార్గం చెప్పడం మెమరీ బంచ్ ఉంది.
>> నిజానికి, నేను ఒక స్ట్రింగ్ అనే బదులుగా s యొక్క బఫర్, ముందు.
అది ఒక బఫర్ ఉంటే ఎందుకంటే, YouTube అర్థంలో వంటి,
లేదా మీరు ఒక వీడియో చూడటం చేసినప్పుడు, మీరు పదం బఫరింగ్ చూసిన ఉండవచ్చు,
డాట్, డాట్ డాట్.
ఇది చాలా బాధించే ఉంది.
మరియు కేవలం అర్థం మీ వీడియో ఆటగాడు
మా డౌన్లోడ్ ప్రయత్నిస్తున్నారు బైట్లు బైట్లు, బోలెడంత
ఇంటర్నెట్ నుండి ఒక వీడియో నుండి.
కానీ నెమ్మదిగా, కనుక అది ప్రయత్నిస్తున్నాడు వాటిని కొంత డౌన్లోడ్
కాబట్టి ఒక బఫర్ ఒక కంటైనర్, పూరించడానికి మీరు అది అప్పుడు తగినంత బైట్లు
, మీరు వీడియో చూపించు నిరంతరం pausing లేకుండా.
కానీ మీకు టర్న్స్ ఈ పెద్ద ఒక బఫర్.
కానీ ఈ చాలా డేటా ఉంచాలి ప్రయత్నించండి అది, చాలా చెడ్డ విషయాలు జరుగుతుంది.
కాబట్టి ఉదాహరణకు, యొక్క చూద్దాం ఒక ఉదాహరణ ఈ ఫైనల్ టీజర్.
ఈ మరొక కార్యక్రమం ఆ, మొదటి చూపులో,
సూపర్ ఉపయోగకరమైన ఏమీ లేదు.
ఇది ఒక ప్రధాన ఫంక్షన్ సంపాదించి ఆ F, ఆ ఫంక్షన్ కాల్స్.
మరియు ఆ ఫంక్షన్ f, ఇక్కడ ఉంది ఒక చార్ అర్రే పరిమాణం 12, c అనే.
ఆపై ఈ ఉపయోగించి కొత్త ఫంక్షన్ strncpy అని.
>> ఇది, ఈ సాధారణ, ఆ బయటకు వస్తాడు కోడ్ యొక్క సాధారణ లైన్, కేవలం రెండు పంక్తులు
మేము నా పూర్తి ప్రోగ్రామ్ చేసిన అందువలన, నా పూర్తి కంప్యూటర్,
మరియు నా యూజర్ ఖాతా, మరియు నా హార్డ్ ఎవరికైనా సమర్థవంతంగా అవకాశం డ్రైవ్
ఎవరు తెలుసు మరియు అమలు చేయడానికి తగినంత మంచి ఉంది ఒక నిర్దిష్ట కమాండ్ లైన్ తో ఈ కార్యక్రమం
వాదన.
ఇతర మాటలలో, ఈ చెడ్డ వ్యక్తి టైప్ చేసి argvargv [1] లోపలి ఉంచుతుంది
కీబోర్డ్ చాలా ప్రత్యేకంగా రూపొందించుకున్న వద్ద స్ట్రింగ్, ABC, 123, కానీ ముఖ్యంగా,
ఎక్జిక్యూటబుల్ సూచించే బైనరీ చిహ్నాలు కోడ్, అతను లేదా ఆమె రాశారు ఒక కార్యక్రమం,
ఇది ఈ సులభమైన కార్యక్రమం తో కార్యక్రమాలు వేల ప్రతినిధి
ఆ విశ్వసించుటకు సిద్ధంగానుండు, అదేవిధంగా గురవుతుంటాయి అతను లేదా ఆమె చివరకు అన్ని తొలగించవచ్చు
నా హార్డు డ్రైవు ఫైళ్లను, ఒక పొందండి అతను లేదా ఆమె తద్వారా ప్రాంప్ట్ మెరిసే
వారి సొంత ఆదేశాలను టైప్ నాకు అన్ని ఫైళ్ళను ఇమెయిల్.
నేను చేయవచ్చు ఏదైనా, అతను లేదా ఆమె ఈ కోడ్ తో చేయవచ్చు.
>> మేము చాలా ఇంకా ఈ పరిష్కరించడానికి కాదు.
నిజానికి, ఇది జరగబోతోంది ఒక చిన్న చిత్రాన్ని కలిగి
ఈ వంటి, మేము వెంటనే వచ్చి చేస్తాము దీనిలో అన్ని మంచి అర్థం.
కానీ నేడు, యొక్క అంతం తెలియజేయండి కొద్దిగా ఎక్కువ ఆశాజనక, ఏమిటి
అర్థమయ్యేలా xkcd జోక్, మేము తదుపరి సమయం రెస్యూమ్ వరకు.
అన్ని కుడి.
బుధవారం మీరు చూడండి.
>> [సంగీతాన్ని]
>> స్పీకర్: ఇప్పుడు, లోతైన Daven Farnham ఆలోచనలు,.
మెమరీ కుప్ప దూకి వంటిది ఒక ఆదివారం మధ్యాహ్నం బంగారు ఆకులు.
గాలి వీచే, ఎగరవేసినప్పుడు మీ ఓహ్ hair--, నేను రోజుల when-- మిస్
>> [నవ్వు]