[Powered by Google Translate] [వీక్ 5]
[డేవిడ్ J. మలన్ - హార్వర్డ్ యూనివర్శిటీ]
[ఈ CS50 ఉంది. - CS50.TV]
>> ఈ CS50, వీక్ 5 ఉంది.
నేడు మరియు ఈ వారం, మేము ఫోరెన్సిక్స్ ప్రపంచం యొక్క కొద్దిగా పరిచయం
సమస్య యొక్క సందర్భంలో 4 సెట్ చెయ్యండి.
ఇక్కడ ఒక ప్రత్యేక సంఘటన తర్వాత అక్కడ ఎందుకంటే నేడు ఒక సంక్షిప్త ప్రసంగం ఉంటుంది.
కాబట్టి మేము ఒక పరికించండి మరియు విద్యార్థులు మరియు అలైక్ తల్లిదండ్రులు నేడు రెండు బాధించటం చేస్తాము
హోరిజోన్ మీద ఉన్న కొన్ని విషయాలు తో.
>> వాటిలో, సోమవారం నాటికి, మీరు కొన్ని సహ విద్యార్థులను ఉంటుంది.
edX, హార్వర్డ్ మరియు ఓపెన్ కోర్స్ వేర్ మరియు మరిన్ని కోసం MIT యొక్క కొత్త ఆన్లైన్ చొరవ,
సోమవారం వచ్చి దాని సోమవారం, న హార్వర్డ్ యొక్క ప్రాంగణంలో ప్రారంభించాయి
మీరు, గత లెక్కింపు యొక్క, 86,000 అదనపు సహ విద్యార్థులను ఉంటుంది
CS50 యొక్క ఉపన్యాసాలు మరియు విభాగాలు తో చేసిన పాటు క్రింది విధంగా కనిపిస్తుంది
మరియు పూర్తి వివరణలు మరియు సమస్య సెట్లు.
మరియు ఈ భాగంగా, మీరు CS50 మరియు ఇప్పుడు CS50x ప్రారంభ స్థాయి సభ్యుల అవుతుంది.
ఈ భాగంగా ఇప్పుడు అలాగే కొన్ని చేయబడనపుడు ఉంటుంది అని తెలుసుకోవటం.
విద్యార్ధులు భారీ సంఖ్యలో, ఈ కోసం సిద్ధంగా ఉండటానికి,
చెప్పడానికి అది తగినంత మేము 108 TFS మరియు CA ల లేనప్పటికీ,
మేము విద్యార్ధులు 80,000 హిట్ ఒకసారి చాలా ఉత్తమ విద్యార్థుల గురువు నిష్పత్తి కాదు.
మేము, మానవీయంగా సెట్స్ చాలా సమస్య శ్రేణి కావడం లేదు
కాబట్టి సమస్య సెట్ లో ఈ వారం పరిచయం, CS50 చెక్ ఉంటుంది
ఉపకరణం లోపల ఆదేశ పంక్తి సౌలభ్యాన్ని మాత్రం ఇది
మీరు ఈ వారాంతంలో తరువాత అప్డేట్ ఒకసారి మీరు పొందుతారు ఆ.
మీరు, మీ స్వంత pset ఒక ఆదేశం, check50, అమలు చేయగలరు
మరియు మీరు మీ కార్యక్రమాన్ని సరైన లేదా తప్పు అన్నది తక్షణ చూడు పొందుతారు
మేము అందించిన వివిధ డిజైన్ లక్షణాలు ప్రకారం.
సమస్య సెట్ వివరణలో ఆ మరింత.
CS50x సహ విద్యార్థులను కూడా ఈ ఉపయోగించారు.
>> సమస్య సెట్ 4, అన్ని ఫోరెన్సిక్స్ గురించి
మరియు ఈ pset నిజంగా కొన్ని వాస్తవ విషయాలను ప్రేరణతో
దానిద్వారా నేను గ్రాడ్యుయేట్ పాఠశాలలో ఉన్నప్పుడు నేను కొంతకాలం ఖైదు
మిడిల్సెక్స్ కౌంటీ యొక్క జిల్లా అటార్నీ కార్యాలయం ఫోరెన్సిక్ పని తో
వారి ప్రధాన ఫోరెన్సిక్ పరిశోధకుడిని తో.
నేను కొన్ని వారాలు పేర్కొన్నారు ఆలోచించినట్లు ఈ, మొత్తం
మాస్ రాష్ట్ర పోలీసు లేదా ఇతరులు వస్తాయి ఉంది
వారు, హార్డ్ డ్రైవ్లు మరియు CD లు మరియు ఫ్లాపీ డిస్కుల మరియు వంటి వంటి వాటిని ఆఫ్ పడిపోతాయనే
ఆపై ఫోరెన్సిక్స్ కార్యాలయం గోల్ నిర్ధారించేందుకు ఉంది
ఉంది లేదా కొన్ని రకాల ఆధారాలు కాదని.
ఈ స్పెషల్ ఇన్వెస్టిగేషన్స్ యూనిట్, అందువలన ఇది వైట్ కాలర్ నేరం జరిగింది.
ఈ నేరాలు ఎక్కువగా ఇబ్బంది పెట్టే విధమైన, డిజిటల్ మీడియా రకమైన పాల్గొన్న ఏదైనా ఉంది.
ఇది చాలా మంది చెప్పడం ఇమెయిల్ వ్రాయటం లేదు అని, "నేను చేసింది." ఆ అవుతుంది
కాబట్టి తరచూ, ఈ ఫోరెన్సిక్ శోధనలు, అన్ని ఎక్కువ పండు వైపు లేదు
కానీ కొన్నిసార్లు ప్రజలు ఇమెయిళ్ళు రాస్తుంది.
కాబట్టి కొన్నిసార్లు ప్రయత్నాలు దక్కించుకున్నారు.
>> కానీ ఈ ఫోరెన్సిక్ pset, మేము pset4 లో గ్రాఫిక్స్ ఒక బిట్ పరిచయం అవుతారు అప్ దారితీసింది.
బహుశా మీరు ఆమోదింపబడిన ఈ విషయాలను తీసుకుని - JPEGs, GIF లు, మరియు వంటి - ఈ రోజులు.
కానీ మీరు నిజంగా దాని గురించి అనుకుంటే, ఒక చిత్రం, చాలా రాబ్ ముఖం వంటి,
చుక్కలు లేదా పిక్సెళ్ళు క్రమం వలె తయారు చేయవచ్చు.
రాబ్ ముఖం యొక్క సందర్భంలో, రంగులు అన్ని రకాల ఉన్నది
మరియు మేము, లేకపోతే పిక్సెళ్ళు అని పిలుస్తారు వ్యక్తి చుక్కలు, చూడండి ప్రారంభించారు
ఒకసారి మేము సైన్ జూమ్ ప్రారంభించారు
కానీ ప్రపంచంలో ఒక బిట్ సులభతరం మరియు ఈ ఇక్కడ నలుపు మరియు తెలుపు రాబ్ అని చెప్పుకోవాలంటే,
నలుపు మరియు తెలుపు ప్రాతినిధ్యం, మేము బైనరీ ఉపయోగించవచ్చు.
మరియు మేము బైనరీ ఉపయోగించడానికి వెళుతున్న ఉంటే, 1 లేదా 0, మేము ఈ అదే చిత్రం వ్యక్తీకరించవచ్చు
బిట్స్ ఈ నమూనాతో రాబ్ యొక్క నవ్వే ముఖం యొక్క.
11000011 తెలుపు, తెలుపు, నలుపు, నలుపు, నలుపు, నలుపు, తెలుపు, తెలుపు సూచిస్తుంది.
మరియు అందువలన, రంగురంగుల ఛాయాచిత్రాలను గురించి మాట్లాడటం మొదలు తర్వాత భారీ లీపు కాదు
మీరు Facebook లో చూడండి లేదా ఒక డిజిటల్ కెమెరా తో తీసుకోవాలని భావిస్తున్నట్టు విషయాలు.
కానీ ఖచ్చితంగా అది రంగులు విషయానికి వస్తే, మీరు మరింత బిట్స్ అవసరం.
మరియు ఛాయాచిత్రాల ప్రపంచంలో చాలా సాధారణ, 1-bit రంగు ఉపయోగిస్తారు
ఈ సూచించును, అయితే 24-bit రంగు, మీరు నిజంగా రంగులు మిలియన్ల చోటే. వంటి
కాబట్టి మేము రాబ్ యొక్క కంటికి జూమ్ చేసినప్పుడు సందర్భంలో,
వివిధ రంగుల అవకాశాలను మిలియన్ల ఏ సంఖ్య.
కాబట్టి మేము, ప్రాబ్లం సెట్ 4 పాటు walkthrough ఈ పరిచయం చేస్తాము
ఎందుకంటే ఇక్కడ శుక్రవారం ఉపన్యాసం యొక్క సాధారణ 2.30 బదులుగా 3:30 వద్ద నేడు అవుతుంది.
కానీ వీడియో సాధారణ రేపు వంటి ఆన్లైన్ ఉంటుంది.
>> మేము కూడా మరొక ఫైల్ ఫార్మాట్ మీరు పరిచయం చేస్తాము.
ఈ ఉద్దేశపూర్వకంగా, మొదటి వద్ద భయపెట్టడం చూడండి ఉద్దేశించబడింది
కానీ ఈ ఒక సి struct కోసం కొన్ని డాక్యుమెంటేషన్ ఉంది.
ఇది Microsoft సంవత్సరాల క్రితం ఈ ఫార్మాట్ ప్రసిద్ధం చేసింది ఆ అవుతుంది
Bitmap ఫైల్ ఫార్మాట్, BMP, మరియు ఈ ఒక సూపర్ సాధారణ, రంగురంగుల గ్రాఫికల్ ఫైల్ ఫార్మాట్ చెయ్యబడింది
ఆ డెస్క్టాప్లు న సంక్రాంతి కొన్నిసార్లు ఇంకా కొంత సమయం కోసం ఉపయోగిస్తారు మరియు జరిగినది.
మీరు Windows XP మరియు కొండలు, నీలి ఆకాశం తిరిగి భావిస్తే,
సాధారణంగా ఒక bmp లేదా బిట్మ్యాప్ చిత్రం ఉంది.
వారు ఒక బిట్ మరింత సంక్లిష్టత ఎందుకంటే బిట్ మ్యాప్ చిత్రాలన్నీ మా ఆహ్లాదకరమైన.
ఇది చాలా 0 సె మరియు 1s ఈ గ్రిడ్ వంటి సాధారణము ఉంది.
బదులుగా, మీరు ఒక ఫైల్ ప్రారంభంలో ఒక శీర్షిక వంటి వాటిని కలిగి ఉంటాయి.
కాబట్టి లోపల. BMP ఫైల్ ఇతర పదాలు లో 0 సె మరియు 1s యొక్క మొత్తం బంచ్, ఉంది
అయితే కొన్ని అదనపు 0 సె మరియు 1s ఉంది.
మరియు అది సంవత్సరాలు మంజూరు కోసం మనం బహుశా తీసిన చేసిన అవుతుంది -
. డిఓసి లేదా. xls లేదా. mp3, వంటి ఫైల్ ఫార్మాట్లు. mp4, ఏ ఫైల్ ఫార్మాట్లు
మీకు తెలిసిన ఆ - ఏది కూడా, ఒక ఫైల్ ఫార్మాట్ అని అర్థం లేదు
రోజు చివరిలో ఈ ఫైళ్ల యొక్క అన్ని మేము 0 సె మరియు 1s ఉపయోగాన్ని ఎందుకంటే.
మరియు ఇంకా ఆ 0 సె మరియు 1s ASCII ద్వారా ABC లేదా ఇలాంటి ప్రాతినిధ్యం
కానీ రోజు చివరిలో, అది ఇప్పటికీ కేవలం 0 సె మరియు 1s ఉంది.
కాబట్టి మానవులు కేవలం అప్పుడప్పుడు కొత్త ఫైల్ ఫార్మాట్ కనుగొనడమే నిర్ణయించుకుంటారు
వారు బిట్స్ క్రమాలు వాస్తవానికి ప్రభావితం చేస్తుంది ప్రామాణికంగా పేరు.
మరియు ఇక్కడ ఈ సందర్భంలో, ఫొల్క్స్ Bitmap ఫైల్ ఫార్మాట్ ఆకృతి చేసిన
ఒక Bitmap ఫైల్ లో మొట్టమొదటి బైట్ వద్ద, అక్కడ ఆఫ్సెట్ 0 చే సూచిస్తారు చెప్పారు,
కొన్ని cryptically అనే వేరియబుల్ అని bfType, ఉన్నట్లు అన్నారు
కేవలం Bitmap ఫైల్ రకం కోసం నిలుచునే, ఏ Bitmap ఫైల్ రకం ఉంటుంది.
మీరు 2 ఆఫ్సెట్ ఆ రెండవ వరుసలో, బైట్ సంఖ్య 2, బహుశా ప్రతిపాదించే చేయవచ్చు
ఏ ప్రాతినిధ్యం 0 సె మరియు 1s ఒక ఆకృతిని కలిగి ఉంటుంది? ఏదో యొక్క పరిమాణం.
మరియు అది అక్కడి నుండి వెళ్లి.
కాబట్టి సమస్య సెట్ 4 లో, మీరు ఈ విషయాలు కొన్ని సంచరించింది వస్తారు.
మేము వాటిని అన్ని గురించి caring కొనసాగిస్తున్నాను కనిపిస్తుంది.
కానీ బైట్ 54 చుట్టూ ఆసక్తికరమైన పొందడానికి మొదలవుతుంది గ్రహించండి: rgbtBlue, గ్రీన్, మరియు Red.
మీరు విన్న ఉంటే ఎక్రోనిం RGB - ఎరుపు, ఆకుపచ్చ, నీలం - ఈ కు సూచన
అది అవుతుంది ఎందుకంటే మీరు ఇంద్రధనుస్సు రంగులు అన్ని చిత్రీకరించాడు
ఎరుపు మరియు నీలం మరియు ఆకుపచ్చ కొన్ని కలిపి.
నిజానికి, గదిలో తల్లిదండ్రులు ప్రారంభ ప్రొజెక్టర్లు కొన్ని గుర్తు ఉండవచ్చు.
ఈ రోజుల్లో, మీరు, ఒక ప్రకాశవంతమైన కాంతి ఒక కటకాల రావడం చూడండి
అయితే తన రోజు లో మీరు, ఎరుపు లెన్స్, నీలం లెన్స్, మరియు ఆకుపచ్చ లెన్స్ కలిగి
మరియు కలిసి వారు ఒక స్క్రీన్ లక్ష్యంగా మరియు ఒక రంగుల చిత్రాన్ని ఏర్పాటు.
మరియు తరచూ, మాధ్యమిక పాఠశాలలు మరియు ఉన్నత పాఠశాలలు ఆ కటకములు ఉంటుంది
ఇంత కొద్దిగా వంకరగా, కాబట్టి మీరు డబుల్ లేదా ట్రిపుల్ చిత్రాలు చూసిన యొక్క విధమైన.
కానీ ఆ ఆలోచన. మీరు ఒక చిత్రాన్ని పెయింట్ ఎరుపు మరియు ఆకుపచ్చ మరియు నీలం కాంతి కలిగి.
అదే సూత్రాన్ని కంప్యూటర్లు ఉపయోగిస్తారు.
>> కాబట్టి సమస్య మీ కోసం అప్పుడు సవాళ్లు మధ్య సెట్ 4 కొన్ని అంశాలను వెళ్తున్నారు.
ఒకటి ఏమిటంటే ఒక చిత్రం పరిమాణాన్ని చెప్పవచ్చు, 0 సె మరియు 1s ఒక నమూనాలో తీసుకోవాలని,
, 0 సె మరియు 1s యొక్క భాగాలు నిర్మాణంలో ఈ వంటి ప్రాతినిధ్యం ఇది గుర్తించడానికి
రెడ్స్, బ్లూస్, ఆకుకూరలు - మరియు తర్వాత పిక్సెళ్ళు నకలు ఎలా పూర్తి చేయాలో అంచనా -
లోపల కాబట్టి చిత్రాన్ని మొదట ఈ కనిపిస్తోంది ఉన్నప్పుడు,
ఆ తర్వాత బదులుగా ఇలా ఉండవచ్చు.
ఇతర సవాళ్ళను మధ్య చాలా మీరు ఒక ఫోరెన్సిక్ చిత్రం జారీ చేస్తాము అని అన్నారు
ఒక డిజిటల్ కెమెరా నుండి ఒక నిజమైన ఫైల్.
మరియు ఆ కెమెరా, ఒకసారి ఒక సమయం మీద, ఫోటోలను మొత్తం బంచ్ ఉన్నారు.
సమస్య మేము అనుకోకుండా మాసిపోయిన లేదా చిత్రం ఏదో పాడైన కలిగి ఉంది.
బాడ్ థింగ్స్ డిజిటల్ కెమెరాలు తో జరిగే.
కాబట్టి మేము త్వరగా మీకు, ఆ కార్డు యొక్క 0 సె మరియు 1s ఆఫ్ అన్ని కాపీ
4 సెట్ ఒక పెద్ద ఫైలు వాటిని సేవ్, మరియు అప్పుడు మేము సమస్య అవి మీకు చేతితో చేస్తాము
మీరు ఆదర్శంగా ఆ JPEGs అన్ని పునరుద్ధరించడానికి తో సి ఒక ప్రోగ్రామ్ను రాయడం చేయవచ్చు.
మరియు వారు ఒక క్లిష్టమైన ఫైల్ ఆకృతి యొక్క కొంతవరకు ఉన్నప్పటికీ, ఆ JPEGs అవుతుంది -
వారు చాలా క్లిష్టమైన ఇక్కడ ఈ నవ్వే ముఖం కంటే మీరే -
ప్రతి JPEG 0 సె మరియు 1s అదే నమూనాలను తో ప్రారంభమయ్యే అవుతుంది.
కాబట్టి ఉపయోగించి, చివరకు, లూప్ లేదా ఇలాంటి కోసం కొంత లూప్ లేదా,
మీరు, ఈ ఫోరెన్సిక్ చిత్రం అన్ని 0 సె మరియు 1s పైగా iterate చేయవచ్చు
మరియు మీరు సమస్య సెట్ స్పెసిఫికేషన్ లో నిర్వచించబడింది చేసే ప్రత్యేక నమూనా చూడండి ప్రతి సమయం,
మీరు చాలా ఎక్కువ సంభావ్యత ఒక JPEG ప్రారంభంలో ఇక్కడ పొందవచ్చు.
మరియు వెంటనే మీకు ఇదే పంధాను బైట్లు కొన్ని సంఖ్య కనుగొనేందుకు వంటి
లేదా లు లేదా మెగాబైట్ల తరువాత, మీరు ఇక్కడ పొందవచ్చు, రెండో JPEG ఉంది
ఫోటో నేను మొదటి ఒక తర్వాత పట్టింది.
నాకు ఆ మొదటి ఫైల్ చదవడం ఆపి లెట్, ఈ కొత్త రాయటం మొదలుపెట్టాలని
మరియు pset4 మీ ప్రోగ్రామ్ అవుట్పుట్ చాలా 50 JPEGs అని అన్నారు.
50 JPEGs కాదు ఉంటే, మీరు ఒక లూప్ యొక్క ఒక బిట్ కలిగి ఉంటాయి.
మీరు JPEGs ఒక అనంతమైన ఉంటే, మీరు ఒక అనంతమైన లూప్ ఉన్నాయి.
కాబట్టి ఆ చాలా చాలా సాధారణ విషయం ఉంటుంది.
కాబట్టి ఆ క్షితిజాన్ని ఆన్ ఏమిటి.
>> మాకు వెనుక 0 క్విజ్, హ్యాపీ రెండు వారు వారిని స్థిరముగా ఉన్నాయి నా ఇమెయిల్ శాతం తెలుసుకుంటారు
తటస్థ, మరియు క్విజ్ చుట్టూ విచారంగా 0 సమయంలో అబ్బాయి.
మరియు తల TF Zamyla, మీ స్వంత TF, నాకు చేరుకోవడానికి దయచేసి
మీరు విషయాలను వెళ్లి ఎలా చర్చించడానికి అని మీరు తెలుసు CA ల లేదా ఒక.
>> కాబట్టి గది లో ఇక్కడ తల్లిదండ్రులు ఆకట్టుకోవడానికి, CS50 లైబ్రరీ ఏమిటి?
[నవ్వు] గుడ్ జాబ్.
CS50 లైబ్రరీ ఏమిటి? అవును. >> [విద్యార్థి] ఇది కోడ్ యొక్క ముందుగా రాసిన సెట్ యొక్క [వినబడని]
సరే, మంచి.
ఇది మేము సిబ్బంది రాసిన కోడ్ యొక్క ముందుగా రాసిన సెట్ కు, మేము, మీకు అందించడానికి
ఆ, కొన్ని సాధారణ కార్యాచరణ అందిస్తుంది
నాకు స్ట్రింగ్ పొందండి వంటి అంశాలు, నాకు పొందండి ఒక పూర్ణాంకానికి - ఇక్కడ జాబితా చేసిన పనులను అన్ని.
>> ఇప్పుడు మొదలు, మేము నిజంగా ఈ శిక్షణ చక్రాలు టేకాఫ్ ప్రారంభించండి.
మీరు ఒక స్ట్రింగ్ దూరంగా తీసుకుని ఆరంభమవుతుంది చేస్తున్నారు
ఇది రీకాల్ ఏమి వాస్తవ డేటా రకం కోసం ఒక పర్యాయపదంగా ఉంది? >> [బహుళ విద్యార్థులు] చార్ *.
చార్ *. తల్లిదండ్రులు కోసం, ఆ బహుశా [చేస్తుంది whooshing ధ్వని] ఉంది. ఆ బావుంటుంది.
చార్ * మేము, మేము మా పదజాలం నుండి స్ట్రింగ్ తొలగించడానికి అన్ని మరింత తెరపై చూడడానికి మీరు
వాస్తవానికి కోడ్ రాయడం దానిని వస్తుంది కనీసం ఉన్నప్పుడు.
అదేవిధంగా, మేము ఈ విధులను కొన్ని ఎక్కువ ఉపయోగించి ఆపడానికి ఉంటాం
మా కార్యక్రమాలు మరింత అధునాతన పొందగలిగిన ఎందుకంటే.
కంటే, ఒక ప్రాంప్టు మెరిసే తో అక్కడ కూర్చుని ప్రోగ్రాములను వ్రాయటానికి
ఏదో టైప్ వినియోగదారు వేచి, మరొకచోట నుండి మీరు మీ ఇన్పుట్లను పొందుతారు.
ఉదాహరణకు, మీరు స్థానిక హార్డు డ్రైవు బిట్స్ వరుస నుండి పొందుతారు.
మీరు బదులుగా, ఒక నెట్వర్క్ కనెక్షన్ నుండి భవిష్యత్తులో వాటిని పొందుతారు
ఎక్కడో కొన్ని వెబ్సైట్.
>> కాబట్టి మొదటి సారి తిరిగి ఈ పొర చర్మము యొక్క Let మరియు CS50 ఉపకరణం పుల్ అప్
మీరు # వారాలు సహా చేసిన ఇది cs50.h అని మరియు ఈ ఫైలు,,
కానీ వాస్తవానికి యొక్క ఈ లోపల ఏమి చూడటానికి.
నీలం లో ఫైల్ టాప్ కేవలం వ్యాఖ్యల మొత్తం బంచ్ ఉంది:
వారంటీ సమాచారం మరియు లైసెన్సింగ్.
ఈ సాఫ్ట్వేర్ ఒక సాధారణ ఉదాహరణ యొక్క విధమైన ఉంది
సాఫ్ట్వేర్ చాలా ఈ రోజులు ఓపెన్ సోర్స్ అని ఏమి ఎందుకంటే,
ఇది ఎవరైనా కోడ్ రాసిన మరియు స్వేచ్ఛగా అందుబాటులో ఉంది అంటే
కేవలం అమలు చేయడానికి మరియు ఉపయోగించడానికి కానీ చదివి మార్పు మరియు మీ స్వంత కృతి కలిసిపోవడానికి.
తద్వారా మీరు చాలా చిన్న రూపంలో అయితే, ఓపెన్ సోర్స్ సాఫ్ట్ వేర్ ఉపయోగించి చేసిన ఏమిటి.
నేను వ్యాఖ్యలను గత స్క్రోల్ డౌన్ ఉంటే, అయితే, మేము కొన్ని మరింత చేరువైన విషయాలు చూడండి మొదలుపెడతారు.
Cs50.h ఫైల్ హెడర్ ఫైళ్ళ మొత్తం బంచ్ కలిగి ఇక్కడ ఎగువన నోటీసు.
వీటిలో చాలా మేము ముందు చూడని, కానీ ఒక సుపరిచితమే.
ఈ ఏది మేము ఇప్పటివరకు, క్లుప్తంగా, అయినప్పటికీ చూసిన? >> [విద్యార్థి] ప్రామాణిక లైబ్రరీ.
అవును, ప్రామాణిక లైబ్రరీ. stdlib.h malloc ఉంది.
ఒకసారి మేము, డైనమిక్ మెమరీ కేటాయింపు గురించి మాట్లాడటం మొదలుపెట్టాడు
మేము అదే వచ్చే వారం తిరిగి వచ్చి మేము, ఆ ఫైల్ను సహా ప్రారంభించారు.
ఇది bool మరియు నిజమైన మరియు తప్పుడు వాస్తవానికి సి కేవలంగా లో లేని అవుతుంది
మీరు ఇక్కడ ఈ ఫైలు ఉన్నాయి తప్ప.
మేము వారాలు stdbool.h సహా చేశారు
మీరు ఒక, bool ఒప్పు లేదా తప్పు. భావన ఉపయోగించడానికి ఆ
ఈ లేకుండా, మీరు నకిలీ అది యొక్క క్రమం మరియు ఒక పూర్ణాంకానికి ఉపయోగించవలసి వస్తుంది
మరియు కేవలం ఏకపక్ష 0 తప్పుగా మరియు 1 నిజమైన భావించవలసి.
మేము మరింత స్క్రోల్ డౌన్ ఉంటే, ఇక్కడ ఒక స్ట్రింగ్ యొక్క మా నిర్వచనం ఉంది.
ఈ నక్షత్రం పేరు నిజంగా ప్రాధాన్యత లేదు, మేము ముందు చెప్పారు చేసిన వంటి, అవుతుంది.
మీరు కూడా అన్ని చుట్టూ ఖాళీ చేయవచ్చు.
మేము ఈ సెమిస్టర్ స్పష్టంగా ఈ గా ప్రచారం చేశారు
స్టార్, రకం సంబంధం కలిగి ఉంటుంది, ఆ
కొంచెం సాధారణంగా అయితే, కేవలం వంటి సాధారణ తెలుసుకుంటారు
అక్కడ ఉంచారు, కానీ క్రియాశీలంగా ఒకే విషయం.
మేము మరింత డౌన్ చదవండి అయితే ఇప్పుడు, యొక్క GetInt పరిశీలించి తెలియజేయండి
మేము ఏదైనా ఈ సెమిస్టర్ ముందు బహుశా మొదటి ఉపయోగిస్తారు ఎందుకంటే.
ఇక్కడ GetInt ఉంది. ఈ ఏమిటి? >> [విద్యార్థి] ఒక నమూనా. >> ఇది ఒక నమూనా ఉంది.
తరచుగా, మేము మా యొక్క టాప్స్ వద్ద నమూనాలను నిలబెట్టాయి. సి ఫైళ్లు,
కానీ మీరు కూడా ఇక్కడ ఈ విధంగా శీర్షిక ఫైళ్లు,. h ఫైళ్లు, ప్రోటోటైప్స్ ఉంచవచ్చు
తద్వారా మీరు కొన్ని విధులు రాయడానికి మీరు, ఇతర వ్యక్తులు ఉపయోగించవచ్చు చేయదలిచిన
ఇది ఖచ్చితంగా CS50 లైబ్రరీ సందర్భంలో
మీరు, cs50.c లాగ మీ విధులు అమలు మాత్రమే
మీరు కూడా లేదు ఫైల్ ఎగువన కానీ శీర్షికా ఫైలును ఎగువన నమూనాలను ఉంచండి.
ఆ శీర్షికా ఫైలును స్నేహితులు మరియు సహచరులు హాజరవుతారు ఏమిటి
తో # వారి స్వంత కోడ్ చేర్చండి.
ఈ సమయంలో, మీరు, ఈ నమూనాలను అన్ని సహా చేసిన
సమర్థవంతంగా మీ ఫైల్ ఎగువన కానీ ఈ మార్గం ద్వారా # యంత్రాంగం ఉన్నాయి
మీ స్వంత లోకి ఇది అత్యవసరంగా కాపీలు మరియు ముద్ద ఈ ఫైలు.
ఇక్కడ కొన్ని విశదమైన డాక్యుమెంటేషన్ ఉంది.
GetInt ఒక పూర్ణాంకానికి అందుతుంది అని మంజూరు కోసం మేము చాలా చక్కని తీసుకున్నారు,
కొన్ని సందర్భాలలో మూలలో ఉన్నాయి అవుట్ కానీ మారుతుంది.
నా quintillion, మార్గం చాలా పెద్దది ఒక సంఖ్య లోని యూజర్ రకాల ఉంటే,
కేవలం ఒక పూర్ణాంకానికి లోపలి సరిపోవు? ఊహించిన ప్రవర్తన ఏమిటి?
ఆదర్శవంతంగా, ఊహించదగిన ఉంది.
కాబట్టి ఈ విషయంలో, మీరు నిజంగా, ఫైన్ ప్రింట్ చదివినట్లయితే
మీరు నిజంగా ఆ లైన్ తెలుసుకోలేదు ఉంటే, ఈ రాబడి INT_MAX చూస్తారు.
మేము ఈ గురించి మాట్లాడారు, కానీ దాని పెట్టుబడి ఆధారంగా అది ఏ కావచ్చు ఎప్పుడూ చేసిన?
[విద్యార్థి] స్థిరమైన. >> అది స్థిరమైన ఉంది.
ఇది బహుశా ఆ శీర్షిక ఫైళ్లు ఒక ప్రకటించబడిన కొన్ని ప్రత్యేక స్థిరంగా ఉంది
, ఆ ఫైల్ లో ఎక్కువ, మరియు INT_MAX సుమారు 2 బిలియన్ వంటి బహుశా విషయం
మేము ఏదో ఏదో సూచిస్తుంది అవసరం ఎందుకంటే దీనికి ఆలోచన, తప్పు జరిగింది
మేము, అవును, మా పారవేయడం వద్ద 4 బిలియన్ సంఖ్యలు ఉంటాయి: -2 బిలియన్ 2 బిలియన్ న, ఇవ్వాలని లేదా పడుతుంది.
Well, ఏ ప్రోగ్రామింగ్ కూడా సాధారణం, మీరు ఆ సంఖ్యల ఒక దొంగతనం ఉంది
బహుశా 0, బహుశా 2 బిలియన్, బహుశా -2 బిలియన్,
మీరు ప్రపంచానికి కమిట్ విధంగా కాబట్టి మీరు మీ సాధ్యమయ్యే విలువలను ఒకటి ఖర్చు
ఏదో తప్పు పోతే, నేను ఈ సూపర్ పెద్ద విలువ అందిస్తుంది.
కానీ మీరు యూజర్ 234 వంటి నిగూఢ ఏదో టైప్ అనుకోవడం లేదు ..., చాల పెద్ద సంఖ్య.
మీరు స్థిరమైన వంటి బదులుగా క్రమపరచుట.
మీరు గత కొన్ని వారాల ఆసన అనే చేస్తే నిజంగా, ఏ సమయంలో మీరు, GetInt అని
పరిస్థితి INT_MAX వినియోగదారు టైప్ చేశారా మీరు ఒక తో తనిఖీ వుండాలి,
లేదా, మరింత ప్రత్యేకంగా, అది చేస్తే ఎందుకంటే, GetInt తిరిగి INT_MAX చేశాడు,
వాస్తవానికి వారు టైపు లేదు అని అర్థం. ఏదో ఈ విషయంలో తప్పు జరిగింది.
కాబట్టి ఈ సాధారణంగా కేవలం ప్రత్యేక అంటే ఒక సెంటినెల్ విలువ, గా పిలిచే దాన్ని ఉంది.
>> . సి ఫైలు మారిపోతాయి ఇప్పుడు చూద్దాం.
సి ఫైల్ కొంత సమయం కోసం పరికరంలోని ఉనికిలో ఉంది.
నిజానికి, ఉపకరణం ఇది పూర్వ సంకలనం మేము వస్తువు కోడ్ అనే విషయం లోకి మీరు కలిగి
సిస్టమ్ తెలుసు ఎందుకంటే అది ఎక్కడ కానీ అది కేవలం మీకు సంబంధించిన లేదు
ఈ సందర్భంలో అది ఎక్కడ ఉంది: ఉపకరణం.
ఈ సమయంలో GetInt మరియు GetInt పని ఎలా ఇప్పుడు స్క్రోల్ డౌన్ లెట్ యొక్క.
ఇక్కడ మేము ముందు నుంచి సారూప్య వ్యాఖ్యలు ఉన్నాయి.
నాకు కేవలం కోడ్ భాగం లో జూమ్ లెట్.
మరియు మేము GetInt కోసం కింది ఉంది.
ఇది ఇన్పుట్ పడుతుంది.
, ఇది (నిజమైన) అయితే, ఒక పూర్ణాంకానికి తిరిగి, కాబట్టి మేము ఒక ఉద్దేశపూర్వక అనంతమైన లూప్ కలిగి
కానీ బహుశా మేము ఏదో ఈ యొక్క బయటకు లేదా ఈ లోపల నుండి తిరిగి వస్తుంది.
>> ఎలా ఈ పనులు చూసేలా.
మేము, లూప్ లోపల ఈ మొదటి లైన్ లో 166 GetString ఉపయోగించి కనిపిస్తుంది.
ఏ పరిస్థితుల్లో GetString తిరిగి ఎందుకంటే ఈ ఇప్పుడు మంచి పద్ధతి
ప్రత్యేక కీవర్డ్ NULL? >> [విద్యార్థి] ఏదో తప్పు జరిగితే ఉంటే.
ఏదో తప్పు జరిగితే ఉంటే. మరియు మీరు GetString లాగ కాల్ చేసినప్పుడు తప్పు ఏ?
అవును. >> [విద్యార్థి] malloc అది ints ఇవ్వాలని విఫలమైతే.
అవును. బహుశా malloc విఫలమైతే.
ఎక్కడో హుడ్ కింద, GetString మెమరీ కేటాయించుకునే ఇది malloc, కాల్
వర్ణాల అన్ని కంప్యూటర్ స్టోర్ చేయడానికి అనుమతిస్తుంది
ఆ కీబోర్డ్ లో యూజర్ రకాల.
మరియు, యూజర్ ఖాళీ సమయంలో మొత్తం చాల ఉన్నాయి మరియు ఉదాహరణకు, ఎక్కువ టైప్ అనుకుందాం
కంప్యూటర్ కంటే ఎక్కువ అక్షరాలు, కంటే 2 బిలియన్ అక్షరాలు కూడా RAM కలిగి ఉంది.
GetString మీరు ఆ సూచిస్తుంది సామర్థ్యాన్ని కలిగి ఉండాలి.
ఈ సూపర్, సూపర్ అసాధారణ మూలలో కేసు కూడా ఉంటే
ఇది ఏదో ఈ నిర్వహించడానికి సామర్థ్యాన్ని కలిగి ఉండాలి
అందువలన మేము తిరిగి వెళ్లి తన డాక్యుమెంటేషన్ చదవండి ఉంటే, GetString, నిజానికి తిరిగి NULL లో చేస్తుంది.
GetString NULL రావడం ద్వారా విఫలమైతే కాబట్టి ఇప్పుడు ఉంటే, GetInt INT_MAX రావడం ద్వారా విఫలం అన్నారు
ఒక సెంటినెల్ వంటి. ఇవి మానవ సమావేశాలు ఉంటాయి.
ఇదే తెలుసు మాత్రమే మార్గం డాక్యుమెంటేషన్ చదవడం ద్వారా ఉంది.
>> Int వాస్తవానికి సంపాదించిన కౌంటీ క్రిందికి స్క్రోల్ లెట్ యొక్క.
నేను ఒక బిట్ మరింత స్క్రోల్ డౌన్ ఉంటే, లైన్ 170 లో, మేము ఈ మార్గాల పైన వ్యాఖ్య ఉందా.
మేము 172 లో ఒక Int, n, మరియు ఒక చార్, సి, మరియు ఈ కొత్త ఫంక్షన్, డిక్లేర్
మీరు కొన్ని, sscanf ముందు అంతటా డెక్కన్ ఛార్జర్స్ చేశారు.
ఈ స్ట్రింగ్ scanf సూచిస్తుంది.
ఇతర మాటలలో, నాకు స్ట్రింగ్ ఇవ్వాలని నేను ఆసక్తికరమైన సమాచారం ముక్కలు కోసం స్కాన్ చేస్తుంది.
ఆ శతకము
నేను Enter ని అప్పుడు కీబోర్డ్ వద్ద 123, వాచ్యంగా, టైపు ఆ అనుకుందాం.
GetString ద్వారా తిరిగి 123 యొక్క డేటా రకం ఏమిటి? >> [విద్యార్థి] స్ట్రింగ్.
ఇది కుడి, స్పష్టంగా ఒక స్ట్రింగ్ ఏమిటి? నేను ఒక స్ట్రింగ్ వచ్చింది.
కాబట్టి 123, నిజంగా కోట్-unquote, అది ముగింపులో \ 0 తో 123 ఉంది.
ఒక Int కాదు. ఒక సంఖ్య కాదు. ఇది అనేక కనిపిస్తోంది అయితే కాదు.
సో వాట్ GetInt లేదు లేదు?
123 \ 0 - - మరియు ఏదో ఒక వాస్తవ పూర్ణాంక మీరు మార్చిన ఇది ఎడమ ఆ స్ట్రింగ్ స్కాన్ ఉంటుంది.
మీరు దీన్ని ఎలా పూర్తి చేయాలో అంచనా కాలేదు.
మీరు pset2 తిరిగి భావిస్తే, మీరు బహుశా సీజర్ గల చిన్న సౌకర్యవంతమైన వచ్చింది
లేదా విజెనెరే, కాబట్టి మీరు స్ట్రింగ్ పైగా iterate, మీరు ints కు అక్షరాలు మార్చవచ్చు.
కానీ హెక్, ఇది మొత్తం పలు అంశాలు.
ఎందుకు మీరు ఆ చేసే sscanf వంటి ఫంక్షన్ కాల్?
కాబట్టి sscanf ఒక వాదన ఆశిస్తున్నట్లు - ఈ సందర్భంలో లైన్ స్ట్రింగ్ ఇది అని.
అప్పుడు మీరు ఈ స్ట్రింగ్ లో చూడాలనుకుంటున్నారా ఏమి, సమానమైన కు printf, కోట్స్ లో పేర్కొనండి.
మరియు నేను ఏ ఇక్కడ చెప్పడం నేను నేను దశాంశ సంఖ్య చేసి ఒక పాత్ర చూడాలనుకుంటున్నారా ఉంది.
ఈ ఒక్క నిమిషం లో కేసు ఎందుకు మరియు మేము చూస్తారు.
మరియు ఈ సంజ్ఞామానం ఇప్పుడు stuff గుర్తుచేస్తుంది ఆ అవుతుంది మేము గురించి మాట్లాడటం మొదలుపెట్టాడు
ఒక వారం క్రితం మీద.
ఏమిటి & n మరియు & సి ఇక్కడ మాకు చేయడం? >> [విద్యార్థి] n యొక్క చిరునామా మరియు సి యొక్క చిరునామా.
అవును. ఇది నాకు సి యొక్క n మరియు చిరునామా చిరునామా ఇచ్చి ఉన్నారు. ఎందుకు ముఖ్యమైనది?
మీరు C లో విధులు, మీరు ఎల్లప్పుడూ అన్ని వద్ద ఒక విలువ లేదా సంఖ్య విలువ తిరిగి ఆ తెలుసు.
మీరు ఒక Int, ఒక స్ట్రింగ్, ఫ్లోట్, ఒక భస్మం, ఏ, లేదా మీరు తప్ప తిరిగి, తిరిగి
కానీ మీరు మాత్రమే గరిష్టంగా ఒక విషయం తిరిగి రావచ్చు.
కానీ ఇక్కడ మేము sscanf బహుశా ఒక Int, ఒక దశాంశ సంఖ్య, నాకు తిరిగి కావాలి
మరియు ఒక చార్, మరియు నేను ఒక క్షణం లో ఎందుకు చార్ వివరించడానికి చేస్తాము.
మీరు సమర్థవంతంగా sscanf రెండు విషయాలు తిరిగి కావాలి, కాని ఆ C. కేవలం సాధ్యం కాదు
మీరు రెండు చిరునామాలు లో పంపిస్తూ చుట్టూ పని చేయవచ్చు
వెంటనే మీకు ఒక ఫంక్షన్ రెండు చిరునామాలు చేతితో ఎందుకంటే,
ఆ ఫంక్షన్ వారితో ఏమి చెయ్యగలను? >> [విద్యార్థి] ఆ చిరునామాలకు వ్రాయండి.
ఇది ఆ చిరునామాలను వ్రాయవచ్చు.
మీరు స్టార్ ఆపరేషన్ ఉపయోగించడానికి మరియు ఆ చిరునామాలను ప్రతి, అక్కడ వెళ్ళవచ్చు.
ఇది చరరాశులు యొక్క విలువలలో మార్చినందుకు విధమైన ఈ అక్రమ యంత్రాంగం కాని సాధారణ యొక్క
ఈ సందర్భంలో, రెండు - కేవలం ఒకే చోట కంటే ఎక్కువ.
ఇప్పుడు నేను == 1 తనిఖీ మరియు ఆ నిజానికి, నిజమైన విశ్లేషించదు ఒకవేళ n తిరిగి నేను గమనించి.
కాబట్టి ఏం జరగబోతోంది? సాంకేతికంగా, మేము నిజంగా GetInt లో ఏమి చేయాలనే ఈ ఉంది.
కోట్-unquote 123 - మేము మాట్లాడటానికి, అన్వయించడం కావాలి, మేము స్ట్రింగ్ చదవాలనుకుంటున్న -
మరియు మేము sscanf చెప్పడం ఏమి అక్కడ అనేక ఉన్నది కనిపిస్తుంది ఉంటే
ఈ వేరియబుల్ n నాకు - 123 - ఆ సంఖ్యను జారీ చేస్తారు.
కాబట్టి ఎందుకు వాస్తవానికి ఈ అదే ఉందా?
మీరు కూడా ఇక్కడ ఒక పాత్ర పొందడానికి ఉండవచ్చు చెప్పడం sscanf పాత్ర ఏమిటి?
[వినబడని విద్యార్థి ప్రతిస్పందన] >> ఒక దశాంశ బిందువు వాస్తవానికి పనిచేస్తుంది.
ఒక క్షణం ఆలోచన ఆ యొక్క కలిగి లెట్. ఏమి?
[విద్యార్థి] ఇది NULL ఉంటుంది. >> గుడ్ ఆలోచన. ఇది శూన్య పాత్ర ఉంటుంది.
ఈ సందర్భంలో వాస్తవానికి కాదు. అవును. >> [విద్యార్థి] ASCII.
ASCII. లేదా నాకు మరింత క్రమపరచుట తెలియజేయండి.
అక్కడ% సి కేవలం దోష పరిశీలన మాత్రమే.
మేము, సంఖ్య తర్వాత ఒక పాత్ర ఉన్నట్లు ఇష్టం లేదు
కానీ ఈ నాకు అనుమతిస్తుంది అనుసరిస్తున్నారు.
ఇది ఆ sscanf, ఇక్కడ ఈ ఉదాహరణలో n మరియు సి విలువలు నిల్వ పాటు, అవుతుంది
అది కూడా వేరియబుల్స్ యొక్క సంఖ్యను చూపించే ఏమి అది సైన్ విలువలు ఉంచండి
మీరు మాత్రమే 123 లో టైప్ చేస్తే, అప్పుడు మాత్రమే% d, మ్యాచ్ అన్నారు
మరియు మాత్రమే n, 123 వంటి విలువ నిల్వ అవుతుంది
ఏమీ సి ఉంచే.
సి మాట్లాడటానికి, ఒక చెత్త విలువ ఉంది -
చెత్త ఎందుకంటే కొన్ని విలువ initialized ఎప్పటికీ.
నేను, ఆ గమనికలు యొక్క 1 జనాభా కనుక అలా ఆ సందర్భంలో, sscanf 1 తిరిగి
నేను మెమరీ అప్ విముక్తికై లైన్ విడిపించేందుకు కాబట్టి ఇది గొప్ప సందర్భంలో, నేను ఒక పూర్ణాంకానికి కలిగి
ఆ GetString వాస్తవానికి కేటాయించింది, ఆ తరువాత, n తిరిగి
ఆ ప్రకటన నుండి వచ్చింది మళ్ళీ ప్రయత్నించండి పేరు మీరు ఆలోచిస్తున్నారా else, అది ఇక్కడ నుండే వస్తుంది.
అయితే, దీనికి భిన్నంగా, నేను 123foo టైప్ - టెక్స్ట్ యొక్క కొన్ని యాదృచ్ఛిక క్రమంలో -
sscanf సంఖ్య, సంఖ్య, సంఖ్య, f, చూడండి అన్నారు
మరియు అది n లో 123 పరుగులు చేసి, జరగబోతోంది ఇది సి లో F ఉంచారు మరియు తర్వాత 2 తిరిగి వెళుతున్న.
కాబట్టి మేము కేవలం sscanf యొక్క ప్రవర్తన, చాలా సులభమైన మార్గం యొక్క ప్రాధమిక నిర్వచనం ఉపయోగించి కలిగి -
అలాగే, మొదటి చూపులో కానీ రోజు చాలా సులభం విధానం చివరిలో క్లిష్టమైన -
చెప్పడం ఒక Int ఉంది మరియు కనుక అని నేను దొరకలేదు మాత్రమే విషయం?
మరియు ఇక్కడ ఖాళీలు ఉద్దేశపూర్వక ఉంది.
మీరు sscanf కోసం డాక్యుమెంటేషన్ చదవండి ఉంటే, మీరు తెల్లని భాగాన్ని కలిగి ఉంటే మీరు చెబుతుంది
ప్రారంభంలో లేదా చివరిలో, sscanf కూడా కారణం ఏదైనా వినియోగదారు అనుమతిస్తుంది
స్పేస్ బార్ 123 నొక్కండి మరియు చట్టబద్ధమైన ఉంటుంది.
వారు ఖాళీ బార్ హిట్ కనుక మీరు యూజర్ అరుస్తుంటారు లేదు
ప్రారంభంలో లేదా చివరిలో, ఇది వినియోగదారు అనుకూలమైన కొంచెం ఎక్కువ.
>> అప్పుడు ఏదైనా ప్రశ్నలు GetInt న? అవును. >> [విద్యార్థి] మీరు ఒక చార్ ఉంచారు ఏమి?
ప్రశ్న గుడ్.
ఏం మీరు F వంటి చార్ లో టైప్ మరియు ఎప్పుడూ 123 టైప్ లేకుండా నమోదు కొట్టినప్పుడు?
మీరు ఈ కోడ్ యొక్క లైన్ ప్రవర్తన అప్పుడు ఉంటుంది ఏమి ఆలోచిస్తాడు?
[వినబడని విద్యార్థి ప్రతిస్పందన]
ఆ సందర్భంలో, అది n లేదా సి పూర్తి మాత్రం కాదు ఎందుకంటే అవును, కాబట్టి sscanf కూడా ఉంటాయి.
ఇది సందర్భంలో, నేను కూడా ఆ దృష్టాంతంలో క్యాచింగ్ నేను బదులుగా, 0 తిరిగి వెళుతున్న
నేను మీరు ఊహించిన విలువ 1 ఎందుకంటే.
నాకు ఒకే ఒక అనుకుంటున్నారా మరియు మాత్రమే ఒక విషయం నింపవచ్చు. ప్రశ్న గుడ్.
>> ఇతరులు? అన్ని కుడి.
>> ఇక్కడ విధులు అన్ని ద్వారా వెళ్ళి యొక్క లెట్ లేదు,
కానీ మిగిలిన ఆసక్తి బహుశా కనబడుతోందని ఒక GetString ఉంది
అది GetLongLong, GetFloat, GetInt, GetDouble ఆ అవుతుంది ఎందుకంటే
అన్ని రౌడీ GetString వారి కార్యాచరణను చాలా.
కాబట్టి అతను ఇక్కడ అమలు ఎలా పరిశీలించి అనుమతిస్తుంది.
ఈ ఒక చిన్న క్లిష్టమైన ఉంది, కానీ అది అదే ఫండమెంటల్స్ ఉపయోగిస్తుంది
మేము గత వారం గురించి మాట్లాడటం మొదలుపెట్టాడు ఆ.
GetString లో, ఇది ఇక్కడ తప్ప ప్రకారం ఏ వాదన పడుతుంది
మరియు నేను స్పష్టంగా బఫర్ అనే స్ట్రింగ్ ప్రకటించారు am, ఒక స్ట్రింగ్ తిరిగి.
నేను నిజంగా ఆ ఇంకా ఉపయోగించకూడదు ఏమి తెలియదు, కానీ మేము చూస్తారు.
సామర్థ్యం డిఫాల్ట్ 0 ద్వారా ఉన్నట్లు తెలుస్తుంది.
కాదు ఖచ్చితంగా పేరు ఈ n ఇంకా ఉపయోగించవచ్చు అన్నారు ఏమి ఖచ్చితంగా, కాదు అంటే,
కానీ ఇప్పుడు అది కొంచెం ఆసక్తికరమైన సంతరించుకోనుంది.
లైన్ 243 లో, మేము ఒక Int, సి ప్రకటిస్తాయి.
ఈ ఒక పెద్ద వివరాలు యొక్క విధమైన ఉంది.
ఒక చార్ 8 బిట్స్, మరియు 8 బిట్స్ ఎలా అనేక విలువలు నిల్వ చేయవచ్చు? >> [విద్యార్థి] 256. >> 256.
మీరు ఉంటాయి 256 వివిధ ASCII అక్షరాలు కలిగి అనుకుంటే సమస్య
మీరు తిరిగి అనుకుంటే - మరియు ఈ గుర్తుంచుకోవలసిన విషయం కాదు.
మీరు పెద్ద ASCII చార్ట్ తిరిగి అనుకుంటే కానీ మేము వారాల క్రితం వచ్చింది,
128 లేదా 256 ASCII అక్షరాలు ఆ సందర్భంలో ఉన్నాయి.
మేము 0 సె మరియు 1s అప్ అన్ని నమూనాలు ఉపయోగిస్తారు.
మీరు ఒక దోషాన్ని గుర్తించే సామర్థ్యం కోరుకుంటే ఒక సమస్య
మీరు ఇప్పటికే మీ అక్షరాలు కోసం 256 విలువలు ను ఉపయోగిస్తున్నట్లయితే ఎందుకంటే,
ఇప్పుడు మీరు చెబుతున్న సంఖ్య మార్గం లేని కారణంగా మీరు నిజంగా, ముందుకు ప్లాన్ లేదు
ఈ ఒక సక్రమం అక్షరం, ఈ కొన్ని తప్పుడు సందేశం.
సో వాట్ ప్రపంచ చేస్తుంది వారు తదుపరి అతిపెద్ద విలువ, ఒక పూర్ణాంకానికి లాగ, ఉపయోగిస్తారు
మీరు 4 బిలియన్ విలువల కోసం, బిట్స్, 32 యొక్క ఒక క్రేజీ సంఖ్య కలిగి ఉంటారు
మీరు కేవలం, ముఖ్యంగా 257 వాటిలో ఉపయోగించి అవుతుంది కాబట్టి
1 ఇది ఒక లోపం వంటి కొన్ని ప్రత్యేక అర్థం ఉంది.
>> కాబట్టి ఎలా ఈ పనులు చూడటానికి.
లైన్ 246 లో, నేను, fgetc కాల్ ఈ పెద్ద సమయంలో లూప్ కలిగి
F అర్థం ఫైలు, కాబట్టి getc, ఆపై stdin.
ఈ కేవలం కీబోర్డ్ నుండి ఇన్పుట్ చదవండి చెప్పడం మరింత ఖచ్చితమైన మార్గం అవుతుంది.
ప్రామాణిక ఇన్పుట్ అంటే కీబోర్డు, ప్రామాణిక అవుట్పుట్, స్క్రీన్ అర్థం
మరియు మేము pset4 లో చూస్తారు ఇది ప్రామాణిక తప్పు, స్క్రీన్ అర్థం
కానీ వాస్తవమైన ఉత్పత్తి తో స్క్రీన్ ప్రత్యేక భాగంగా కలిపారు లేదు, అందుచే
మీరు ముద్రించడానికి ఉద్దేశించి. భవిష్యత్తులో ఆ మరింత.
కాబట్టి fgetc కేవలం కీబోర్డ్ నుండి ఒక పాత్ర చదివి పేరు నిల్వ అంటే?
సి లో నిల్వ.
మరియు తర్వాత తనిఖీ - కాబట్టి నేను ఇక్కడ కొన్ని బూలియన్ సముచ్ఛయాలు ఉపయోగించి వెబ్ -
అది సమానం కాదు చేసే తనిఖీ - \ n అందువల్ల వినియోగదారుడు నమోదు సాధించాడు, ఆ సమయంలో ఆపివేయాలనుకుంటున్నారా,
లూప్ అయిపోయాయి - మరియు మేము కూడా ప్రత్యేక స్థిరంగా EOF తనిఖీ మీరు,
మీకు తెలిసిన లేదా ఊహించడం, అది ఏ ఏ నిలబడటానికి లేదు? ఫైల్ >> [విద్యార్థి] ముగింపు. ఫైల్ >> ముగింపు.
ఈ రకమైన పిచ్చి ఎందుకంటే నేను కీబోర్డ్ వద్ద టైప్ చేస్తున్నానని ఉంటే,
ఈ ప్రమేయం ఏ ఫైల్, నిజంగా ఉంది
కానీ ఇది సూచించడానికి ఉపయోగిస్తారు సాధారణ పదం యొక్క క్రమం ఉంది
ఇంకా ఆ ఏమీ మానవ యొక్క చేతి వేళ్ళ నుంచి వస్తోంది.
EOF - ఫైలు యొక్క ముగింపు.
మీరు మీ కీబోర్డు వద్ద కంట్రోల్ D నొక్కండి ఉంటే ఒక పక్కన, మీరు ఇంకా కాదు అని -
మీరు కంట్రోల్ సి హిట్ చేసిన - కంట్రోల్ D EOF అని ఈ ప్రత్యేక స్థిరంగా పంపుతుంది.
కాబట్టి ఇప్పుడు మేము కొన్ని డైనమిక్ మెమరీ కేటాయింపు ఉంది.
>> అయితే (n + 1> సామర్థ్యం). ఇప్పుడు నేను n వివరించడానికి చేస్తాము.
N కేవలం ఎన్ని బైట్లు, బఫర్ ప్రస్తుతం ఉంటాయి
మీరు ప్రస్తుతం వినియోగదారు నుండి రూపొందించడంలో చేస్తున్న స్ట్రింగ్.
మీరు బఫర్ లో సామర్థ్యం కంటే మీ బఫర్ లో ఎక్కువ అక్షరాలు కలిగి ఉంటే,
intuitively మేము అప్పుడు ఏమి చేయాలి మరింత సామర్థ్యం కేటాయించాలని ఉంది.
నేను ఇక్కడ అంకగణితం యొక్క కొన్ని పైగా చెడిపోయిన మరియు ఇక్కడ మాత్రమే ఈ చర్య దృష్టి వెళుతున్న.
మీరు malloc తెలుసు లేదా కనీసం సాధారణంగా తెలిసిన.
Realloc ఏమి ఒక అంచనా తీసుకోండి. >> [విద్యార్థి] మెమరీ జోడిస్తుంది.
ఇది చాలా మెమరీ జోడించడం కాదు. ఇది ఈ కింది విధంగా మెమరీ reallocates.
మీరు ఆ మెమరీ మరింత ఇవ్వాలని స్ట్రింగ్ చివరిలో గది ఇప్పటికీ ఉంది ఉంటే
ఇది మొదట మీరు ఇస్తుంది కంటే, మీరు అదనపు మెమరీ పొందుతారు.
కాబట్టి మీరు వెనక్కి తిరిగి తిరిగి తిరిగి స్ట్రింగ్ యొక్క అక్షరాలు చూస్తూ ఉంచుకోవచ్చు.
ఆ సందర్భంలో కాదు అయితే మీరు చాలా పొడవుగా వేచి ఎందుకంటే
మరియు యాదృచ్ఛిక ఏదో మెమరీలో plopped పొందిన
కానీ అదనపు మెమరీ ఇక్కడ డౌన్ ఉంది, ఆ సరైందే.
Realloc, మీరు అన్ని భారీ ట్రైనింగ్ చేయడానికి వెళ్తున్నారు
, మీరు ఇప్పటివరకు ఇక్కడ నుండి చదివారు స్ట్రింగ్ తరలించడానికి అది అణిచివేసేందుకు,
మరియు మీరు ఆ సమయంలో కొన్ని మరింత రన్వే ఇస్తాయి.
>> కాబట్టి చేతి యొక్క కెరటంతో, నాకు ఏమి GetString చేస్తున్న ఆ అని పిలవబడు
అది ఒక చిన్న బఫర్, బహుశా ఒక్క పాత్ర తో ప్రారంభమయ్యే అని
మరియు రెండు అక్షరాలు వినియోగదారు రకాల ఉంటే, GetString realloc కాల్ ముగుస్తుంది మరియు చెప్పారు
ఒక పాత్ర సరిపోలేదు; నాకు రెండు అక్షరాలు ఇస్తాయి.
మీరు లూప్ యొక్క తర్కం ద్వారా రీడ్ అప్పుడు, అది చెప్పడానికి జరగబోతోంది
3 అక్షరాలు లో టైప్ యూజర్;, ఇప్పుడు కాదు 2 కాని 4 అక్షరాలు నాకు ఇవ్వండి
అప్పుడు నాకు 16 మరియు 32 ఇవ్వాలని తర్వాత, నాకు 8 ఇస్తాయి.
నేను సామర్థ్యం ప్రతి సమయం రెట్టింపు చేస్తున్నాను వాస్తవం
బఫర్ నెమ్మదిగా వృద్ధి వెళ్ళడం లేదు అంటే, అది సూపర్ ఫాస్ట్ పెరగడం జరగబోతోంది.
మరియు ఆ ప్రయోజనాన్ని కావచ్చు?
నేను బఫర్ పరిమాణం రెట్టింపు am
యూజర్ కేవలం కీబోర్డ్ నుండి ఒక అదనపు పాత్ర అవసరం ఉండవచ్చు అయినప్పటికీ?
[వినబడని విద్యార్థి ప్రతిస్పందన] >> ఆ ఏమిటి? >> [విద్యార్థి] మీరు తరచుగా పెరగడం లేదు.
సరిగ్గా. మీరు తరచుగా పెరగడం లేదు.
మరియు ఈ మీరు కేవలం రకం, ఇక్కడ మీ పందెం పరిమితం చేసిన
దీనిని నెమ్మదిగా ఉంటుంది ఎందుకంటే మీరు realloc చాలా కాల్ అనుకుంటున్న అనేది.
మీరు, మెమరీ కోసం ఆపరేటింగ్ సిస్టమ్ అడగండి ఏదైనా సమయం
మీరు వెంటనే భవిష్య సమస్య సెట్ లో చూస్తారు, అది కొంత సమయం పడుతుంది ఉంటుంది.
కాబట్టి మీరు కొన్ని అంతరిక్ష వృధా చేసిన కూడా, సమయం ఆ మొత్తం తగ్గించడం,
ఒక మంచి విషయం ఉంటుంది.
>> కానీ మేము ఇక్కడ GetString చివరి భాగం చదివి ఉంటే -
మళ్ళీ ఇక్కడ ప్రతి లైన్ understanding నేడు అంత ముఖ్యమైనది కాదు -
అది చివరకు మళ్ళీ malloc కాల్స్ అని గుర్తించలేకపోతే
అది స్ట్రింగ్ అవసరమైన మరియు చాలా బైట్లు వంటి సరిగ్గా కేటాయించుకునే
మరియు తర్వాత ఫ్రీ అతి భారీ బఫర్ కాల్ దూరంగా విసురుతాడు
ఇది నిజంగానే చాలా సార్లు రెట్టింపు వస్తే.
కాబట్టి చిన్న లో, ఆ GetString ఈ సమయంలో పని చేస్తుంది ఎలా.
అది, మళ్ళీ, మళ్ళీ, మళ్ళీ ఒకసారి ఒక పాత్ర చదవబడుతుంది లేదు
మరియు అది కొన్ని అదనపు మెమరీ అవసరం ప్రతిసారీ, ఇది కోసం ఆపరేటింగ్ సిస్టమ్ అడుగుతుంది
realloc కాల్.
>> ఏదైనా ప్రశ్నలు? అన్ని కుడి.
>> దాడి.
, ఇప్పుడు మేము గమనికలు అర్థం లేదా కనీసం గమనికలు విపరీతంగా తెలిసిన
మొత్తం ప్రపంచం కూలిపోయింది మొదలవుతుంది ఎలా భావిస్తారు తెలియజేయండి
మీరు చాలా పటిష్టమయిన వినియోగదారులు ఎదుర్కోవటానికి లేకపోతే,
మీ వ్యవస్థ హాక్ ప్రయత్నిస్తున్న వ్యక్తులు,
కొన్ని నమోదు కోడ్ అధిగమిస్తూ ద్వారా మీ సాఫ్ట్వేర్ దొంగిలించడానికి ప్రయత్నించిన వ్యక్తులు
వారు సైన్ టైప్ చూపించే
>> దిగువన ప్రధాన విధిగా కలిగి కేవలం సి కోడ్ ఇది ఇక్కడ ఈ ఉదాహరణ గమనించండి
ఒక చర్యను foo పిలుస్తుంది. మరియు దానిని foo కు అక్కడ ఉన్న?
[విద్యార్థి] ఒక వాదన. >> [మలన్] ఒక వాదన.
కాబట్టి argv [1], ఇది వినియోగదారు కమాండ్ లైన్ వద్ద టైప్ చేసి మొదటి పదం అర్థం
a.out లేదా ఎలాగైనా ఆ కార్యక్రమం అని పిలుస్తారు.
ఎగువన foo ఒక చార్ * లో జరుగుతుంది కాబట్టి. కానీ చార్ * కేవలం ఏమిటి? >> [విద్యార్థి] ఒక స్ట్రింగ్.
[మలన్] ఒక స్ట్రింగ్, కొత్త ఏమీ ఇక్కడ ఉంది కాబట్టి.
ఆ స్ట్రింగ్ ఏకపక్ష బార్ అని ఉంది.
ఇక్కడ ఈ లైన్ లో చార్ సి [12]; సెమీ సాంకేతిక ఆంగ్ల విధమైన లో, ఈ లైన్ ఏమి ఉంది?
యొక్క [విద్యార్థి] ఒక అమరిక - యొక్క >> అర్రే? >> [విద్యార్థి] అక్షరాలు. >> అక్షరాలు.
నాకు 12 అక్షరాలు యొక్క వ్యూహం ఇవ్వండి. కాబట్టి మేము ఈ ఒక బఫర్ కాల్ ఉండవచ్చు.
ఇది సాంకేతికంగా సి అని, కానీ ప్రోగ్రామింగ్ ఒక బఫర్ కేవలం స్థలం కొంత అర్థం యొక్క
మీరు కొన్ని విషయాలను సైన్ ఉంచవచ్చు ఆ
అప్పుడు చివరగా, memcpy మేము ముందు ఉపయోగించరు, కానీ మీరు బహుశా దీన్ని ఏమి అంచనా.
ఇది మెమరీ కాపీ చేస్తుంది. ఇది ఏమి చేస్తుంది?
ఇది స్పష్టంగా సి లోకి, దాని ఇన్పుట్, బార్ కాపీ కాని మాత్రమే బార్ యొక్క పొడవు.
కానీ ఇక్కడ ఒక బగ్ ఉంది. >> [విద్యార్థి] మీరు sizeof పాత్ర అవసరం. సరే >>.
సాంకేతికంగా, మేము నిజంగా strlen చేయండి (బార్) * sizeof (చార్)). ఉండాలి ఆ సరైన ఉంటుంది.
కానీ ఇక్కడ చెత్త సందర్భంలో, ఆ యొక్క that's ఊహించుకోవటం తెలియజేయండి -
సరే. అప్పుడు రెండు దోషాలు ఉన్నాయి.
కాబట్టి sizeof (చార్));
యొక్క ఈ చిన్న విస్తృత తయారు చేద్దాము.
కాబట్టి ఇప్పుడు ఏమి ఉంది బగ్, ఇప్పటికీ ఉంది? >> [వినబడని విద్యార్థి ప్రతిస్పందన]
ఏ తనిఖీ? >> [విద్యార్థి] NULL కోసం తనిఖీ చెయ్యండి.
చెడు విషయాల జరిగే ఎందుకంటే మేము సాధారణంగా NULL తనిఖీ చేయాలి
మీరు, అక్కడ వెళ్ళి ముగుస్తుంది కాబట్టి మీ పాయింటర్ NULL ఉన్నప్పుడు
మరియు మీరు స్టార్ ఆపరేటర్లు తో dereferencing ద్వారా శూన్య వెళ్ళి లేదు.
కాబట్టి ఆ బావుంటుంది. మరియు మేము ఏమి చేస్తున్నారు? తార్కికంగా, ఒక దోషం చాలా ఇక్కడ ఉంది.
[విద్యార్థి] argc> = 2 అని తనిఖీ.
Argc> = 2 ఉంటే కాబట్టి తనిఖీ. సరే, ఈ కార్యక్రమంలో మూడు దోషాలు ఇక్కడ ఉంది కాబట్టి.
యూజర్ వాస్తవానికి argv లోకి ఏదైనా టైప్ మేము ఇప్పుడు తనిఖీ చేస్తున్నాము [1]. గుడ్.
కాబట్టి మూడవ బగ్ ఏది? అవును. >> [విద్యార్థి] సి తగినంత పెద్ద కాదు.
గుడ్. మేము ఒక దృష్టాంతంలో తనిఖీ.
మేము పరిపూర్ణంగా బార్ యొక్క పొడవు మించిపోతుంది కంటే మరింత మెమరీని కాపీ లేదు తనిఖీ.
కాబట్టి స్ట్రింగ్ ఉంటే టైప్ యూజర్ 10 అక్షరాలు,
ఈ మాత్రమే 10 అక్షరాలు కాపీ అని. మరియు ఆ సరైందే.
కానీ వినియోగదారు 20 పాత్ర పదం వంటి ప్రాంప్టులో పదం లో ఏం టైప్ ఉంటే?
ఈ విధంగా బార్ నుండి కాపీ 20 అక్షరాలు అని?
లేకపోతే మా బఫర్ అని పిలుస్తారు సి, ఇది మీరు డేటా రాశారు అర్థం
మీరు స్వంతం కాని 8 బైట్ స్థానాలకు,
మరియు మీరు వాటిని కేటాయించింది ఎప్పుడూ కోణంలో వాటిని కలిగి లేదు.
కాబట్టి ఈ సాధారణంగా బఫర్ ఓవర్ఫ్లో దాడి లేదా బఫర్ ఆక్రమిత దాడి గా పిలిచే దాన్ని ఉంది.
మరియు అది కోణంలో దాడి అని, వినియోగదారు లేదా మీ చర్యను కాల్ చేసే కార్యక్రమం
వాస్తవానికి తదుపరి ఏమి, హానికరమైన ఈ చేస్తోంది నిజానికి చాలా చెడ్డ ఉంటుంది.
>> కాబట్టి యొక్క ఇక్కడ ఈ చిత్రాన్ని చూసి తెలియజేయండి.
ఈ చిత్రం మెమరీ మీ స్టాక్ సూచిస్తుంది.
మీరు ఒక ఫంక్షన్ కాల్ ప్రతిసారీ మీరు స్టాక్ ఈ చిన్న Frame పొందండి గుర్తుచేసుకున్నారు
మరియు వేరొక మరియు వేరొక మరియు మరొక.
మరియు ఇప్పటివరకు, మేము కేవలం రకమైన మీరు ఈ దీర్ఘ చతురస్రాలు గా సంగ్రహించబడింది
బోర్డు మీద లేదా ఇక్కడ తెరపై గాని.
కానీ మీరు ఒక ఫంక్షన్ foo కాల్ చేసినప్పుడు దీర్ఘ చతురస్రాలు ఒక, లో జూమ్ ఉంటే,
అంతకన్నా దీర్ఘ చతురస్రం లో ఆ ఫ్రేమ్ యొక్క స్టాక్ లోపల అక్కడ అవుతుంది
కంటే మేము swap గురించి మాట్లాడటం లేదు మాదిరిగా x మరియు y మరియు a మరియు b.
ఇది కొన్ని తక్కువ స్థాయి వివరాలు రిటర్న్ చిరునామా, వాటిలో అక్కడ అవుతుంది.
ప్రధాన foo కాల్స్ కనుక అది అవుతుంది, ప్రధాన foo సమాచారం ఉంటుంది
ఏ ప్రధాన యొక్క చిరునామా కంప్యూటర్ యొక్క మెమరీ లో ఉంది
లేకపోతే ఎందుకంటే, వెంటనే foo వంటి, ఇక్కడ ఈ సందర్భంలో, అమలు చేయబడుతుంది
ఒకసారి మీరు, foo చివరిలో ఈ మూసి వంకర కలుపు చేరుకోవడానికి
కార్యక్రమం యొక్క నియంత్రణను పడతాయని భావించబడుతోంది కౌంటీ ఎలా హెక్ foo తెలుసా?
ఇది ఆ ప్రశ్నకు సమాధానం ఇక్కడ ఈ Red దీర్ఘ చతురస్రం లో అని అవుతుంది.
ఈ ఒక పాయింటర్ సూచిస్తుంది, మరియు ఇది తాత్కాలికంగా నిల్వ చేయడానికి కంప్యూటర్ ఇష్టం
అని పిలవబడే స్టాక్ న తద్వారా వెంటనే foo వంటి ప్రధాన యొక్క చిరునామా అమలు చేయబడుతుంది,
కంప్యూటర్ పేరు మరియు వెళ్ళడానికి ప్రధాన లో ఏం లైన్ తెలుసు.
సేవ్ Frame పాయింటర్ ఈ సమానంగా సంబంధం.
ఇక్కడ చార్ * బార్ ఏమి సూచిస్తుంది?
ఇప్పుడు ఈ నీలం విభాగంలో ఇక్కడ foo యొక్క ఫ్రేమ్. బార్ ఏమిటి?
బార్ కేవలం foo కు వాదన ఉంది.
కాబట్టి ఇప్పుడు మేము తెలిసిన చిత్రం విధమైన వద్ద వెనక్కి వచ్చారు.
స్క్రీన్ పై ఎక్కువ అంశాలను మరియు మరింత వ్యాపకాలు, ఉన్నాయి
కానీ ఈ లేత నీలం విభాగంలో కేవలం మేము సుద్ద బోర్డ్ పై చిత్రించడం చేసిన ఏమిటి
swap వంటి వాటి కోసం. ఆ foo కోసం ఫ్రేమ్.
మరియు అది మాత్రమే విషయం ప్రస్తుతం ఈ పారామితి ఇది బార్.
కానీ ఏమి ఇక్కడ ఈ కోడ్ ప్రకారం స్టాక్ ఉండాలి?
[విద్యార్థి] చార్ సి [12]. >> [మలన్] చార్ సి [12].
మేము కూడా, సి అనే వేరియబుల్ కు కేటాయించిన మెమొరీ యొక్క 12 చతురస్రాలు చూస్తారు
నిజానికి మేము తెరపై ఆ ఉన్నాయి.
చాలా టాప్ ఉంది సి [0] ఈ చిత్రం యొక్క, మరియు అప్పుడు రచయిత
చతురస్రాలు అన్ని గీయడం కష్టం, అయితే 12 నిజంగానే ఉన్నాయి లేదు
ఎందుకంటే మీరు కుడి దిగువన చూడండి ఉంటే, సి [11] మీరు 0 నుండి COUNT ఉంటే 12 వ అటువంటి బైట్ ఉంది.
కానీ ఇక్కడ సమస్య.
సి ఇది దిశలో పెరుగుతోంది?
క్రమీకరించు ఇది టాప్ మొదలవుతుంది మరియు దిగువ పెరుగుతాయి డౌన్ టాప్.
మేము అన్ని వద్ద ఇక్కడ మేమే చాలా రన్వే వదిలి కనిపించడం లేదు.
మేము రకమైన, ఒక మూలలో మేమే పెయింట్ చేసిన
మరియు ఆ C [11] సేవ్ Frame పాయింటర్ వ్యతిరేకంగా హక్కు ఉంది దీనిలో బార్ పై కుడి అప్,
ఇది రిటర్న్ చిరునామా వ్యతిరేకంగా హక్కు ఉంది. దీనిలో ఖాళీ లేదు.
మీరు అప్ మేకు చేస్తే అంత అప్పుడు ఏమి
మరియు మీరు ఒక 12-బైట్ బఫర్ లోకి 20 బైట్లు reading ప్రయత్నించండి?
ఎక్కడ ఆ 8 అదనపు బైట్లు వెళ్ళడానికి వెళ్తున్నారు? >> [విద్యార్థి] ఇన్సైడ్ -
మిగతా వాటి లోపల, వీటిలో కొన్ని ముఖ్యమైన సూపర్ ఉంది.
మరియు అతి ముఖ్యమైన విషయం, సమర్థవంతంగా, అక్కడ తిరిగి చిరునామా ఎరుపు బాక్స్
ఎందుకంటే, మీరు అనుకోకుండా లేదా adversarially ఆ 4 బైట్లు తిరిగి రాస్తుంది ఆ అనుకుందాం
చెత్త కానీ అనేక కేవలం ఆ పాయింటర్ చిరునామా,
ఆ స్మృతి ఒక నిజమైన చిరునామా నిర్మాణము.
తార్కికంగా సూత్రప్రాయంగా, ఏమిటి? >> [విద్యార్థి] ఫంక్షన్ వేరే స్థానంలో తిరిగి అన్నారు.
సరిగ్గా.
Foo తిరిగి మరియు హిట్స్ వంకర కలుపు ఆ కార్యక్రమం ముందుకు వెళ్ళడం చేసినప్పుడు
ప్రధాన తిరిగి, ఆ ఎర్ర బాక్స్ లో ఉండే వస్తువు చిరునామా తిరిగి వెళుతున్న.
>> మోసపూరిత సాఫ్ట్వేర్ నమోదు విషయంలో,
తిరిగి చేయబడిన ఆ చిరునామా సాధారణంగా అని చెపుతాడు ఆ విధి ఏం
మీరు సాఫ్ట్వేర్ చెల్లించిన మరియు మీ నమోదు కోడ్ ఇన్పుట్? తర్వాత
మీరు ఇక్కడ వెళ్ళడం లేదు లోకి ట్రిక్ కంప్యూటర్ యొక్క క్రమం కానీ బదులుగా ఇక్కడ వెళ్లి చేయవచ్చు.
మీరు నిజంగా తెలివైన అయితే లేదా, శత్రువులు నిజానికి, ఉదాహరణకు, కీబోర్డ్ లో టైప్ చేయగలరు
వాస్తవ పదం, కాదు 20 అక్షరాలు, కాని అతను లేదా ఆమె నిజానికి రకాల అనుకుందాం
కోడ్ ప్రాతినిధ్యం కొన్ని అక్షరాలు.
మరియు అది సి కోడ్ మాత్రం కాదు, అది నిజంగా అక్షరాలు చేస్తాడు
ఆ 0 సె మరియు 1s బైనరీ యంత్రం కోడ్, సూచిస్తాయి.
కానీ, అలా తగినంత తెలివైన ఉన్నారు అనుకుందాం
ఏదో ముఖ్యంగా సంకలనం కోడ్ అని GetString ప్రాంప్ట్ దానిని పేస్ట్,
మరియు గత 4 బైట్లు ఆ తిరిగి చిరునామా తిరిగి రాస్తుంది.
మరియు ఆ ఇన్పుట్ ఏమి చిరునామా చేస్తుంది?
ఇది వాస్తవానికి ఈ Red దీర్ఘ చతురస్రం బఫర్ యొక్క మొదటి బైట్ యొక్క చిరునామా లో నిల్వ చేస్తుంది.
, కాబట్టి మీరు నిజంగా తెలివైన ఉండాలి, మరియు ఈ అక్కడ చెడు వ్యక్తులు కోసం విచారణ మరియు లోపం చాలా ఉంది
కానీ మీరు ఈ బఫర్ ఎలా పెద్దది గుర్తించడానికి లేదో
ఇన్పుట్ లో గత కొన్ని బైట్లు మీరు ప్రోగ్రామ్ అందించే అటువంటి
మీ బఫర్ యొక్క ప్రారంభ చిరునామా సమానం కావడం, మీరు చేయవచ్చు.
మేము సాధారణంగా హలో మరియు \ 0 చెప్పుకోవాలంటే, ఆ బఫర్ లో ముగుస్తుంది ఏమిటి.
కానీ మాకు మరింత తెలివైన ఉన్నారు మరియు మేము సామాన్యముగా దాడి కోడ్ పిలుస్తాను ఏమి ఆ బఫర్ పూర్తి ఉంటే -
AAA, దాడి, దాడి, దాడి - ఇది చెడు ఏదో చేసే ఏదో ఉంటుంది,
మీరు నిజంగా తెలివైన అయితే ఏమి, మీరు దీన్ని ఉండవచ్చు.
80, C0, 35, 08 - ఇక్కడ ఎరుపు బాక్స్ లో సంఖ్యల వరుస ఉంది.
ఆ ఇక్కడ ఆ సంఖ్య సరిపోయే గమనించండి.
ఇది రివర్స్ క్రమంలో, కానీ కొన్ని ఇతర సమయం ఎక్కువ.
ఈ తిరిగి చిరునామా కావాలనే మార్పు అని గమనించండి
ఇక్కడ చిరునామా అప్ సమం, ప్రధాన కాదు చిరునామా.
చెడు వ్యక్తి సూపర్ స్మార్ట్ కాబట్టి, అతను లేదా ఆమె ఆ దాడి కోడ్ ఉన్నాయి అన్నారు
యూజర్ యొక్క ఫైళ్ళను తొలగించడానికి లేదా పాస్వర్డ్లను కాపీ ఏదో వంటి
లేదా నేను మీరు లాగిన్ ఒక వినియోగదారు ఖాతా సృష్టించు - ఏదైనా అన్ని వద్ద.
>> మరియు ఈ ప్రమాదంలో మరియు C. యొక్క శక్తి రెండూ
మీరు గమనికలు ద్వారా మెమరీ ప్రాప్తి ఎందుకంటే
మరియు మీరు అందువలన, కంప్యూటర్ యొక్క మెమరీ లోనికి మీరు ఏదైనా వ్రాయవచ్చు
మీరు ఒక కంప్యూటర్ మీరు ఏదైనా చేయవచ్చు
కేవలం ద్వారా దాని స్వంత మెమరీ ఖాళీలో చుట్టూ జంప్ అయ్యారు.
కాబట్టి ఈ రోజు చాలా కార్యక్రమాలు మరియు చాలా వెబ్ సైట్లు రాజీ చేసే
ఈ యొక్క ప్రయోజనాన్ని ప్రజలకు డౌన్ పొంగు.
మరియు ఈ ఒక సూపర్ ఆధునిక దాడులను వంటి కనిపిస్తుంది, కానీ ఇది ఎల్లప్పుడూ విధంగా మొదలు లేదు.
రియాలిటీ, ఏ చెడ్డ వ్యక్తులు సాధారణంగా చేస్తుంది ఉంటుంది
అది ఒక కమాండ్ లైన్ వద్ద ఒక కార్యక్రమం లేదా ఒక GUI ప్రోగ్రామ్ లేదా ఒక వెబ్సైట్, అయినా
మీరు అర్ధంలేని అందించడం మొదలు.
మీరు, అన్వేషణ రంగంలో మరియు హిట్ నమోదు ఒక నిజంగా పెద్ద పదం టైప్
మరియు మీరు వెబ్సైట్ క్రాష్ చూడడానికి వేచి
లేదా మీరు ప్రోగ్రామ్ కొన్ని దోష సందేశం విశదపరుస్తుంది ఉంటే చూడటానికి వేచి
మీరు చెడ్డ వ్యక్తిగా లక్కీ పొందండి మరియు మీరు కొన్ని క్రేజీ ఇన్పుట్ను అందించాలి ఎందుకంటే
ప్రోగ్రామర్ మీ ప్రవర్తనను ముందుగా లేదు అంటే కార్యక్రమం, కూలిపోతుంది అని
ఇది మీరు తగినంత కృషి విచారణ మరియు లోపం తో బహుశా దీని అర్థం
మరింత ఖచ్చితమైన దాడి వేతనాన్ని ఎలా పూర్తి చేయాలో అంచనా.
భద్రత కనుక చాలా భాగం కేవలం మొత్తంగా ఈ దాడులు తప్పించుకోవడం లేదు
కానీ వాటిని గుర్తించడం మరియు వాస్తవానికి లాగ్లను చూడటం
మరియు క్రేజీ ఇన్పుట్లను మీ వెబ్సైట్లో టైప్ ప్రజలు ఏమి చూసిన,
ఏ శోధన పదాలు మీ వెబ్సైట్లో ప్రజలు టైప్ చేసిన తర్వాత
కొన్ని బఫర్ పొంగిప్రవహిస్తున్న ఆశతో.
మరియు సాధారణ బేసిక్స్ ఈ అన్ని దిమ్మల డౌన్ వ్యూహం యొక్క
మరియు అది మెమరీని కేటాయించాల్సిన మరియు ఉపయోగించడానికి అర్థం లేదు.
>> ఆ తర్వాత చాలా ఇది సంబంధించినది.
యొక్క ఇంకా మళ్లీ హార్డు డ్రైవు యొక్క లోపల మెరుపు లెట్.
మీరు క్రితం వారం లేదా రెండు నుండి రీకాల్ మీ రీసైకిల్ బిన్ లేదా ట్రాష్ కెన్ ఫైళ్ళను డ్రాగ్ ఉన్నప్పుడు
ఏమి జరుగుతుంది? >> [విద్యార్థి] ఏమీ లేదు. >> ఖచ్చితంగా ఏమీ, కుడి?
మీరు డిస్కు ఖాళీ తక్కువగా అమలు, చివరికి ఉంటే
Windows లేదా Mac OS మీరు ఫైళ్ళను తొలగించడంలో ప్రారంభమౌతుంది.
మీరు అక్కడ ఏదో డ్రాగ్ అయితే, అన్ని సురక్షితంగా వద్ద లేదు.
మీ చదరపు గజం లేదా స్నేహితుడు లేదా కుటుంబ సభ్యుడు చేయాలి డబుల్ క్లిక్ చేయండి మరియు, voila, ఉంది
మీరు తొలగించాలనుకుంటున్నారా ప్రయత్నించిన అన్ని నమూనాలను ఫైళ్లను ఉంది.
మాకు చాలా కనీసం మీరు కుడి క్లిక్ చేయండి లేదా క్లిక్ నియంత్రణ ఉందని మీకు
మరియు ఆ వంటి చెత్త లేదా ఏదో ఖాళీ.
అయితే అప్పుడు చాలా ట్రిక్ విధంగా లేదు అని
మీరు మీ హార్డు డ్రైవు ఒక ఫైలుని కలిగి ఏమి జరుగుతుంది ఎందుకంటే
, కొన్ని పద పత్రం లేదా కొన్ని JPEG సూచిస్తుంది, మరియు ఇది మీ హార్డుడ్రైవు సూచిస్తుంది
మరియు లెట్స్ ఇక్కడ ఈ అంశం గురించి ఆలోచించారు, ఆ ఫైల్ సూచిస్తుంది సే
మరియు అది 0 సె మరియు 1s యొక్క మొత్తం బంచ్ కలిగివుంటుంది.
ఏం మీరు మాత్రమే ట్రాష్ ఆ ఫైల్ డ్రాగ్ లేదు జరుగుతుంది లేదా బిన్ రీసైకిల్ చేయవచ్చు
కానీ ఖాళీ? ఏమీ అబ్బాయి.
ఇది ఇప్పుడు పూర్తిగా ఏమీ కాదు.
కొంచెం ఈ పట్టిక రూపంలో జరుగుతుంది ఎందుకంటే ఇప్పుడు అది కేవలం ఏమీ ఉంది.
కాబట్టి ఒక కంప్యూటర్ యొక్క మెమరీ లోపల డేటాబేస్ లేదా పట్టిక యొక్క రకమైన లేదు
ఆ ముఖ్యంగా, ఫైళ్లను ఒక కాలమ్ 'పేర్లు మరియు ఫైళ్లను ఒక కాలమ్' నగర ఉంది
పేరు ఈ నగర 123, కేవలం ఒక యాదృచ్చిక సంఖ్య కావచ్చు.
కాబట్టి మేము x.jpeg మరియు నగర 123 వంటి ఏదైనా కలిగి ఉండవచ్చు.
మీరు నిజంగా మీ ట్రాష్ను ఖాళీ ఏమి అప్పుడు జరుగుతుంది?
దూరంగా వెళ్ళే.
కాని దూరంగా వెళ్ళి లేదు 0 సె మరియు 1s ఉంది.
>> కాబట్టి pset4 కు కనెక్షన్ తర్వాత ఏమిటి?
Well, pset4, కేవలం మేము అనుకోకుండా కాంపాక్ట్ ఫ్లాష్ కార్డ్ మాసిపోయిన చేసిన ఎందుకంటే
చెడు అదృష్టం ఈ ఫోటోలను అన్ని లేదా అది ఎందుకంటే కలిగి పాడైన మారింది
0 సె మరియు 1s ఇప్పటికీ అక్కడ లేని కాదు.
ఏదో పాడైన కాబట్టి బహుశా వాటిలో కొన్ని పోతాయి
కొన్ని 0 సె 1s మారింది మరియు 1s 0 సె మారింది కోణంలో.
బగ్గీ సాఫ్ట్వేర్ లేదా హార్డ్వేర్ లోపాలు కారణంగా బాడ్ థింగ్స్ జరుగుతుంది.
కానీ ఆ బైట్ల అనేక, బహుశా వాటిని కూడా 100%, ఇప్పటికీ.
ఇది JPEG1 ప్రారంభించారు కంప్యూటర్ లేదా కెమెరా తెలియదని కేవలం యొక్క
మరియు JPEG2 ప్రారంభించారు.
కానీ మీరు, ప్రోగ్రామర్, ఆ JPEGs ఎక్కడ అవగాహన ఒక బిట్ తెలిసిన
లేదా వారు ఎలా కాబట్టి మీరు 0 సె మరియు 1s మరియు చెప్పడానికి JPEG, JPEG, విశ్లేషిస్తుంది
మీరు తప్పనిసరిగా ఒక కోసం ఒక ప్రోగ్రామ్ను రాయడం లేదా అయితే లూప్
ఆ ఫైళ్లను ప్రతి ఒక కోలుకుంటుంది.
పాఠం తరువాత సురక్షితంగా మీ ఫైళ్ళను erasing ప్రారంభించడానికి ఉంటుంది
మీరు పూర్తిగా ఈ నివారించడానికి చెయ్యాలనుకుంటే. అవును.
>> [విద్యార్థి] ఎలా వస్తుందని మీ కంప్యూటర్ చెప్పాడు
మీరు ముందు కన్నా ఎక్కువ మెమొరీ కలిగి?
మీరు ముందు కన్నా ఎక్కువ మెమొరీ కలిగి - >> [విద్యార్థి] మరింత మెమరీ.
ఓహ్. ప్రశ్న గుడ్.
కాబట్టి ఎందుకు ఖాళీ తర్వాత మీ కంప్యూటర్ తెలుస్తుంది లేదు
మీరు ముందు కన్నా ఎక్కువ ఖాళీని కలిగి?
క్లుప్తంగా, అది అబద్ధం ఎందుకంటే.
ఇప్పుడు మీరు చెప్పారు ఎందుకంటే సాంకేతికంగా, మీరు మరింత ఖాళీని కలిగి ఉన్నారా
ఫైల్ ఒకప్పుడు పేరు మీరు ఇతర విషయాలను ఉంచవచ్చు.
కానీ, బిట్స్ దూరంగా వెళ్తున్నారు కాదు
మరియు ఆ బిట్స్, ఉదాహరణకు, అన్ని 0 సె మార్చారు చేస్తున్నారు కాదు
మీ రక్షణ కొరకు.
కాబట్టి దీనికి విరుద్ధంగా, మీరు సురక్షితంగా ఫైళ్ళు వేయండి లేదా భౌతికంగా పరికరాన్ని నాశనం ఉంటే,
ఆ నిజంగా ఆ చుట్టూ కొన్నిసార్లు మాత్రమే మార్గం.
>> ఎందుకు మేము ఆ సెమీ స్కేరీ గమనిక న విడిచి, మరియు మేము సోమవారం మీరు చూస్తారు.
[చప్పట్లు]
>> [CS50.TV]