[Powered by Google Translate] [వీక్ 5]
[డేవిడ్ J. మలన్, హార్వర్డ్ విశ్వవిద్యాలయం]
[ఈ CS50 ఉంది.] [CS50.TV]
[వుమన్] అతను అబద్ధం ఆడుతున్నారు; గురించి, నాకు తెలియదు.
[ద] కాబట్టి మేము ఏమి తెలుసు?
[వుమన్] 9:15 వద్ద, రే Santoya ATM ఉంది ఆ.
[ద] కాబట్టి ప్రశ్న, అతను 9:16 వద్ద ఏమి చేయబడింది?
[వుమన్] ఏదో వద్ద 9 mm చిత్రీకరణ.
బహుశా తాను స్నిపర్ చూసింది.
[ద] లేదా అతను పని.
[వుమన్] ఆగండి. ఒక తిరిగి వెళ్లండి.
[ద] మీరు ఏమి చూస్తారు?
[♫ ఉత్కంట సంగీతం ♫]
[వుమన్] తన ముఖాన్ని తీసుకురండి. పూర్తి స్క్రీన్.
[ద] అతని అద్దాలు. >> ప్రతిబింబం ఉంది.
[♫ ఉత్కంట సంగీతం ♫]
[ద] ఆ Nuevita యొక్క బేస్బాల్ జట్టు. వారి చిహ్నం యొక్క.
[వుమన్] మరియు అతను ఆ జాకెట్ వేసుకొని చెప్పగలిగితే మాట్లాడుతూ ఉంటాడు.
>> [డేవిడ్ మలన్] కాబట్టి, ఈ CS50 వారం 5, నేటి మేము మీ కోసం టెలివిజన్ మరియు చిత్రం యొక్క బిట్ నాశనం.
కాబట్టి మీరు ఇక్కడ ఇటువంటి ఒక కార్యక్రమం చూస్తున్న చేసినప్పుడు,
మరియు కాప్స్ "మీరు ఆ శుభ్రం కాదు?" అని లేదా "పెంచు,"
వాస్తవ ప్రపంచంలో పెంచడానికి లేదు.
నిజానికి, మీరు నిజంగా పొందండి ఈ వంటి ఒక చిన్న విషయం.
నేను పేజీ నుండి సిబ్బంది ఫోటోలు ఒకటి ఆగింది చేసిన.
ఈ Photoshop అనే ప్రోగ్రామ్. ఈ, 2 Bowdens యొక్క 1
వాస్తవానికి 1 3 Bowdens, నేడు, మేము రాబ్ మరియు పాల్ తో, అలాగే ఇక్కడ శ్రీమతి బౌడెన్ ఎందుకంటే.
కానీ ఇక్కడ తెరపై రాబ్, మరియు అతను ఎప్పుడూ తన కంటికి లో చేసే ప్రకాశం లో మేము జూమ్,
మీరు నిజంగా చూసే మీరు వాట్ యు గెట్ ఉంటుంది.
ఈ ", మెరుగైన" కాబట్టి "CSI" అది ఒక బిట్ తప్పు ఉంది.
మేము కేవలం కొద్దిగా ఎక్కువ "CSI" లో ఎంచుకోవచ్చు ఉంటే మరొక క్లిప్, ఉన్నాయి.
ఇందులో మీ అనుకుంటే ఇకమీదట ఉచ్ఛరించాడు ఒక nice ఫ్రేజ్
నిజంగా, మీరు ఖచ్చితంగా ఏమీ చెప్పడం చేసినప్పుడు, మీ స్నేహితులతో సాంకేతిక శబ్దం.
>> [ద] వారాల పాటు నేను Cabby కిల్లర్ హత్యలు దర్యాప్తు చేసిన
ఒక నిర్దిష్ట వ్యాధిగ్రస్తమైన మోహం తో.
[వుమన్ # 1] ఈ నిజ సమయంలో ఉంది.
[వుమన్ # 2] నేను ఒక IP చిరునామా ట్రాక్ లేదో చూడటానికి, విజువల్ బేసిక్ ఉపయోగించి ఒక GUI ఇంటర్ఫేస్ సృష్టిస్తారు.
>> [మలన్] విజువల్ బేసిక్ ఉపయోగించి ఒక GUI ఇంటర్ఫేస్ సృష్టిస్తుంది పక్కన సమకాలీకరణలో కాబట్టి ఆడియో
ఒక IP చిరునామా ట్రాక్ పూర్తి అర్ధంలేనిది.
ఈ రోజుల్లో మీరు, విజువల్ బేసిక్ ఉపయోగించడానికి కాదు
అక్కడ ఒక GUI అవసరం ఉంది, మరియు IP చిరునామా ఒక సాంకేతికంగా ఖచ్చితమైన పదం.
కాబట్టి ఈ ఒక కన్ను ఉంచేందుకు, మరియు నా అభిమాన:
మీరు వేరే భాష తెలుసుకోవాలి ఎందుకంటే ఈ ఒక, కొంచెం అద్భుత ఉంది.
C. యొక్క సూపర్సెట్గా ఇది ఆబ్జెక్టివ్-C అనే భాష, ఉన్నాయి
ఇది వారికి విషయ ఆధారిత ప్రోగ్రామింగ్ మధ్య దాని సి ప్లస్ కొన్ని అదనపు లక్షణాలు, అర్థం.
మరియు ఈ Apple iOS ప్రోగ్రామింగ్ కోసం తెచ్చారు భాష.
మరియు ఇక్కడ ", సంఖ్యలు" నుండి, పూర్తిగా వేరే కార్యక్రమం నుండి క్లిప్ యొక్క
మీరు నిజంగా కుడి సమయంలో మీ TiVo మరియు విరామం న దగ్గరగా చూస్తే,
మీరు ఏ వారు వద్ద చూస్తున్న చెప్పుకోదగ్గ వర్ణించాడు అంశం అని చూస్తారు.
నాకు ఇక్కడ వేరే ఆడియో కనెక్టర్ ప్రయత్నించండి మరియు మేము పోతే చూడటానికి
సమకాలీకరణ లో ఆడియో ఈ సమయాన్ని కలిగివుండుటకు.
నేను "సంఖ్యలు." మీరు ఇవ్వాలని
>> [ద # 1] ఇది ఒక 32-bit IPv4 చిరునామా ఉంది.
[ద # 2] IP, ఆ ఇంటర్నెట్. >> ప్రైవేట్ నెట్వర్క్. ఇది అనిత యొక్క ప్రైవేట్ నెట్వర్క్.
[మలన్] సరే. , ఈ ఆబ్జెక్టివ్-C, మరియు ఇది కొన్ని కిడ్ యొక్క రంగు కార్యక్రమం కోసం యొక్క
మీరు బహుశా అక్కడ వేరియబుల్ యొక్క పేరు నుండి ప్రతిపాదించే చేయవచ్చు.
కాబట్టి, తర్వాత, "సంఖ్యలు" గా చెప్పవచ్చు. మేము పరిచయం నేడు మరియు ఈ వారం కాబట్టి
ఫోరెన్సిక్స్ మరియు అందువలన సమస్యలు సందర్భంలో ప్రపంచం యొక్క కొద్దిగా.
ఇక్కడ ఒక ప్రత్యేక సంఘటన ఉంది ఎందుకంటే ఈ రోజు ఒక సంక్షిప్త ప్రసంగం ఉంటుంది
తరువాత, కాబట్టి మేము విద్యార్థులు మరియు అలైక్ తల్లిదండ్రులు నేడు రెండు పరికించండి, మరియు బాధించటం చేస్తాము
హోరిజోన్ మీద ఉన్న కొన్ని విషయాలు తో.
వాటిలో, సోమవారం నాటికి, మీరు కొన్ని సహ విద్యార్థులను ఉంటుంది.
EdX, హార్వర్డ్ మరియు ఓపెన్ courseware కోసం MITs లైన్ చొరవ
మరియు మరింత, సోమవారం హార్వర్డ్ యొక్క ప్రాంగణంలో ప్రారంభించాయి.
వచ్చి సోమవారం అర్ధం మీరు ఉంటుంది - గత లెక్కింపు యొక్క,
86,000 అదనపు సహ విద్యార్థులను CS50 యొక్క ఉపన్యాసాలు పాటు క్రింది విధంగా కనిపిస్తుంది
మరియు విభాగాలు మరియు పూర్తి వివరణలు మరియు సమస్య సెట్లు.
మరియు ఈ భాగంగా, మీరు ప్రారంభ స్థాయి సభ్యుల అవుతుంది
CS50 మరియు ఇప్పుడు CS50x.
>> ఈ భాగంగా, ఇప్పుడు, అదే కొన్ని చేయబడనపుడు ఉంటుంది అని తెలుసుకోవటం.
విద్యార్ధులు భారీ సంఖ్యలో, ఈ కోసం సిద్ధంగా ఉండటానికి,
చెప్పడానికి అది తగినంత మేము 108 TFS మరియు CA ల లేనప్పటికీ,
కాదు చాలా ఉత్తమ విద్యార్థి / గురువు నిష్పత్తి మేము 80,000 ఇతర విద్యార్థులు హిట్ ఒకసారి.
కాబట్టి మేము చాలా సమస్య శ్రేణి కావడం లేదు మానవీయంగా అమర్చుతుంది.
కాబట్టి సమస్య సెట్ లో ఈ వారం పరిచయం, CS50 చెక్ ఉంటుంది
ఉపకరణం లోపల ఒక కమాండ్ లైన్ యుటిలిటీ మాత్రం ఇది
మీరు ఈ వారాంతంలో తరువాత అప్డేట్ ఒకసారి మీరు పొందుతారు ఆ,
మరియు మీరు ఒక ఆదేశాన్ని చేయగలరు, 50 తనిఖీ
మీ స్వంత pset న, మరియు మీరు మీ కార్యక్రమాన్ని అన్నది కొన్ని చూడు పొందుతారు
సరైన లేదా తప్పు మేము అందించిన వివిధ డిజైన్ లక్షణాలు ప్రకారం.
కాబట్టి ఆ మరింత మరియు సమస్య సెట్ వివరణ మరియు
CS50x సహ విద్యార్థులను కూడా ఈ ఉపయోగించారు.
>> కాబట్టి సమస్య సెట్ 4 ఫోరెన్సిక్స్ గురించి అన్ని ఉంది.
మరియు ఈ భాగాన్ని కొన్ని వాస్తవ విషయాలను ప్రేరణతో
నేను గ్రాడ్యుయేట్ స్కూల్ లో వస్తే, నేను, ఒక సమయంలో కోసం ఖైదు
మిడిల్సెక్స్ కౌంటీ యొక్క జిల్లా అటార్నీ కార్యాలయం ఫోరెన్సిక్ పని
వారి ప్రధాన ఫోరెన్సిక్ పరిశోధకుడిని తో, మరియు ఈ మొత్తం
నేను కొన్ని వారం యొక్క గత పేర్కొన్నారు అనుకుంటున్నాను, మాస్ రాష్ట్ర పోలీస్ లేదా ఇతరులు ఉంది
వస్తాయి, అవి హార్డు డ్రైవులు మరియు CD లు మరియు ఫ్లాపీ డిస్కుల వంటి వాటిని ఆఫ్ పడిపోతాయనే
ఆపై వంటి, మరియు ఫోరెన్సిక్స్ కార్యాలయం గోల్ నిర్ధారించేందుకు అని
ఉంది లేదా కొన్ని రకాల ఆధారాలు కాదు.
, ఈ స్పెషల్ ఇన్వెస్టిగేషన్స్ యూనిట్, అందువలన ఇది వైట్ కాలర్ నేరం ఉంది
అది, నేరాల మరింత ఇబ్బందికర విధమైన ఉంది
డిజిటల్ మీడియా రకమైన పాల్గొన్న ఏదైనా; అవుతుంది కాదు అనేక మంది
చెప్పడం ఇమెయిల్ వ్రాయటం "నేను చేశాడు."
కాబట్టి తరచూ ఈ ఫోరెన్సిక్స్ శోధనలు, అన్ని ఎక్కువ పండు వైపు లేదు
కానీ కొన్నిసార్లు ప్రజలు ఇమెయిళ్ళు రాస్తుంది.
కాబట్టి కొన్నిసార్లు ప్రయత్నాలు దక్కించుకున్నారు.
>> కానీ ఈ ఫోరెన్సిక్ pset దారితీస్తాయి, మేము pset 4 గ్రాఫిక్స్ ఒక బిట్ లో పరిచయం అవుతారు.
కాబట్టి మీరు బహుశా, మంజూరు, JPEGs, GIF లు మరియు ఈ రోజుల్లో వంటి కోసం ఈ విషయాలు పడుతుంది
కానీ మీరు నిజంగా దాని గురించి అనుకుంటే, ఒక చిత్రం, చాలా రాబ్ ముఖం వంటి,
ఒక చుక్కల క్రమం, లేదా పిక్సెళ్ళు వలె తయారు చేయవచ్చు.
ఇప్పుడు, రాబ్ ముఖం యొక్క సందర్భంలో, రంగులు అన్ని రకాల ఉన్నది
మరియు మేము, otherwide పిక్సెళ్ళు అని పిలుస్తారు వ్యక్తి చుక్కలు, చూడండి ప్రారంభించారు
ఒకసారి మేము సైన్ జూమ్ ప్రారంభించారు
కానీ ప్రపంచంలో ఒక బిట్ సులభతరం, మరియు కేవలం ఇక్కడ ఈ రాబ్ అని చెప్పుకోవాలంటే
నలుపు మరియు తెలుపు, బాగా, ప్రాతినిథ్యం నలుపు మరియు తెలుపు మేము బైనరీ ఉపయోగించవచ్చు.
మరియు మేము బైనరీ ఉపయోగించడానికి వెళుతున్న ఉంటే, 1 లేదా 0, మేము ఈ అదే చిత్రం వ్యక్తీకరించవచ్చు
బిట్స్ ఈ నమూనాతో రాబ్ యొక్క నవ్వే ముఖం యొక్క: 11000011 సూచిస్తుంది
తెలుపు, తెలుపు, నలుపు, నలుపు, నలుపు, నలుపు, తెలుపు తెలుపు.
మరియు అందువలన రంగురంగుల ఛాయాచిత్రాలను గురించి మాట్లాడటం మొదలు, అప్పుడు, ఒక భారీ లీపు కాదు.
మీరు Facebook లో చూడండి లేదా ఒక డిజిటల్ కెమెరా తో పడుతుంది థింగ్స్,
కానీ, ఖచ్చితంగా, అది రంగులు విషయానికి వస్తే, మీరు మరింత బిట్స్ అవసరం.
మరియు ఛాయాచిత్రాల ప్రపంచంలో చాలా సాధారణ, 1-bit రంగు ఉపయోగిస్తారు
ఈ సూచించును, అయితే 24-bit రంగు, మీరు నిజంగా రంగులు మిలియన్ల చోటే. వంటి
కాబట్టి మేము రాబ్ యొక్క కంటికి జూమ్ చేసినప్పుడు సందర్భంలో,
వివిధ రంగుల అవకాశాలను మిలియన్ల ఏ సంఖ్య.
>> కాబట్టి మేము, ప్రాబ్లం సెట్ 4 పాటు walkthrough ఈ పరిచయం చేస్తాము
ఎందుకంటే ఇక్కడ శుక్రవారం ఉపన్యాసం యొక్క సాధారణ 2.30 బదులుగా 3:30 వద్ద నేడు అవుతుంది.
కానీ వీడియో, సాధారణ గా, రేపు ఆన్ లైన్ ఉంటుంది.
మేము కూడా మరొక ఫైల్ ఫార్మాట్ మీరు పరిచయం చేస్తాము.
కాబట్టి ఈ ఉద్దేశపూర్వకంగా, మొదటి వద్ద భయపెట్టడం చూడండి ఉద్దేశించబడింది
కానీ ఈ ఒక సి struct కోసం కొన్ని డాక్యుమెంటేషన్ ఉంది.
ఇది Microsoft, సంవత్సరాల క్రితం, ఈ ఫార్మాట్ ప్రసిద్ధం చేసింది ఆ అవుతుంది
Bitmap ఫైల్ ఫార్మాట్, BMP, మరియు ఈ సూపర్ సాధారణ ఉంది, అని
అంతేకాకుండా, తక్కువ సమయంలో ఉపయోగించిన రంగుల గ్రాఫికల్ ఫైల్ ఫార్మాట్
మరియు కొన్నిసార్లు డెస్క్టాప్లు న సంక్రాంతి కోసం.
మీరు Windows XP మరియు కొండలు, నీలి ఆకాశం తిరిగి భావిస్తే,
సాధారణంగా ఒక BMP, లేదా బిట్మ్యాప్ చిత్రం, మరియు బిట్ మ్యాప్ చిత్రాలన్నీ ఉంది
వారు ఒక బిట్ మరింత సంక్లిష్టత ఎందుకంటే మాకు ఆహ్లాదకరమైన.
ఇది 0 మరియు 1 యొక్క ఈ గ్రిడ్ వంటి చాలా సాధారణ కాదు;
బదులుగా, మీరు ఒక ఫైల్ ప్రారంభంలో ఒక శీర్షిక వంటి వాటిని కలిగి ఉంటాయి.
కాబట్టి ఇతర మాటలలో,. BMP ఫైల్ లోపల 0 మరియు 1 యొక్క మొత్తం బంచ్, ఉంది
కానీ కొన్ని అదనపు 0 మరియు 1 యొక్క అక్కడ లో ఉంది.
మరియు ఇది సంవత్సరాల మంజూరు కోసం మనం బహుశా తీసిన చేసిన అవుతుంది
. డిఓసి లేదా. xls లేదా. mp3 లేదా. mp4, వంటి ఫైల్ ఫార్మాట్లు
మీకు తెలిసిన ఆ ఏ ఫైల్ ఫార్మాట్లు.
Well, దానిని కూడా ఒక ఫైల్ ఫార్మాట్ అని శతకము
రోజు చివరిలో ఎందుకంటే, మేము ఉపయోగించే ఈ ఫైళ్లు అన్ని కేవలం 0 మరియు 1 యొక్క
మరియు ఇంకా ఆ 0 మరియు 1 యొక్క a, b, c, ASCII లేదా వంటి ద్వారా, ప్రాతినిథ్యం
కానీ రోజు చివరిలో ద్వారా, అది కేవలం 0 మరియు 1 యొక్క ఉంటుంది.
>> కాబట్టి మానవులు కేవలం అప్పుడప్పుడు కొత్త ఫైల్ ఫార్మాట్ కనుగొనడమే నిర్ణయించుకుంటారు
వారు బిట్స్ క్రమాలు వాస్తవానికి ప్రభావితం చేస్తుంది ప్రామాణికంగా పేరు.
మరియు ఇక్కడ ఈ సందర్భంలో, ఫొల్క్స్ Bitmap ఫైల్ ఫార్మాట్ ఆకృతి చేసిన
ఒక Bitmap ఫైల్ లో మొట్టమొదటి బైట్ వద్ద, వంటి ఆఫ్సెట్ 0 చే సూచిస్తారు చెప్పారు, అక్కడ,
కొన్ని cryptically అనే వేరియబుల్ అని bfType, ఉన్నట్లు జరగబోతోంది
ఇది కేవలం Bitmap ఫైల్ రకం కోసం ఉంది; ఏమిటి Bitmap ఫైల్ రకం.
మీరు 2 ఆఫ్సెట్ ఆ రెండవ వరుసలో, బైట్ సంఖ్య 2 నుండి, బహుశా, అనుమానించే చేయవచ్చు
0 మరియు 1 యొక్క ఏమి ప్రాతినిధ్యం ఒక ఆకృతిని కలిగి ఉంటుంది?
ఏదో యొక్క పరిమాణం, మరియు అది అక్కడి నుండి వెళ్లి.
కాబట్టి సమస్య సెట్ 4 లో, మీరు ఈ విషయాలు కొన్ని సంచరించింది వస్తారు.
>> మేము వాటిని అన్ని గురించి caring ముగుస్తుంది, కాని గుర్తించరు అది ఆసక్తికరమైన పొందడానికి మొదలవుతుంది
గీత లేదా బైట్ 54, rgbtBlue, ఆకుపచ్చ మరియు ఎరుపు చుట్టూ.
మీరు ఎక్రోనిం RGB, ఎరుపు, ఆకుపచ్చ నీలం విన్న చేసిన ఉంటే, ఇది ఒక సూచన.
అది అవుతుంది ఎందుకంటే మీరు ఇంద్రధనుస్సు రంగులు అన్ని చిత్రీకరించాడు
ఎరుపు మరియు నీలం మరియు ఆకుపచ్చ కొన్ని కలిపి.
మరియు, నిజానికి, గదిలో తల్లిదండ్రులు ప్రారంభ ప్రొజెక్టర్లు కొన్ని గుర్తు ఉండవచ్చు.
ఈ రోజుల్లో, మీరు 1 ప్రకాశవంతమైన కాంతి ఒక కటకాల రావడం చూడండి.
అయితే తన రోజు, మీరు Red లెన్స్, నీలం లెన్స్, మరియు ఆకుపచ్చ లెన్స్ కలిగి
మరియు కలిసి వారు తెర లక్ష్యంగా మరియు ఒక రంగుల చిత్రాన్ని ఏర్పాటు.
మరియు తరచూ మధ్య పాఠశాలలు మరియు ఉన్నత పాఠశాలలు ఆ కటకములు ఉంటుంది
నిరంతరం విధంగా కొద్దిగా వంకరగా, కాబట్టి మీరు, డబుల్ లేదా ట్రిపుల్ చిత్రాలు చూసిన యొక్క విధమైన
కానీ ఆ ఆలోచన. మీరు ఒక చిత్రాన్ని పెయింట్ ఎరుపు మరియు ఆకుపచ్చ మరియు నీలం కాంతి కలిగి.
అదే సూత్రాన్ని కంప్యూటర్లు ఉపయోగిస్తారు.
>> కాబట్టి సవాళ్లు మధ్య, అప్పుడు, మీరు సమస్య 4 సెట్
కొన్ని అంశాలను వెళ్తున్నారు; ఒక నిజానికి ఒక చిత్రం పరిమాణాన్ని చెప్పవచ్చు.
0 మరియు 1 యొక్క నమూనాలో తీసుకుంటే,
, 0 మరియు 1 యొక్క భాగాలు నిర్మాణంలో ఈ వంటి ప్రాతినిధ్యం ఇది గుర్తించడానికి
రెడ్స్, బ్లూస్, గ్రీన్స్: తరువాత పిక్సెళ్ళు నకలు ఎలా పూర్తి చేయాలో అంచనా
కాబట్టి లోపల ఒక చిత్రాన్ని మొదట ఈ కనిపిస్తోంది, ఆ తర్వాత బదులుగా ఇలా ఉండవచ్చు.
ఇతర సవాళ్ళను మధ్య కూడా మీరు అప్పగించారు వస్తుంది అని అన్నారు
ఒక డిజిటల్ కెమెరా నుండి ఒక నిజమైన ఫైల్ యొక్క ఫోరెన్సిక్ చిత్రం
మరియు ఆ కెమెరా, ఒకసారి ఒక సమయం మీద, ఫోటోలను మొత్తం బంచ్ ఉన్నారు.
సమస్య, మేము అనుకోకుండా మాసిపోయిన లేదా చిత్రం ఏదో పాడైన కలిగి ఉంది.
బాడ్ థింగ్స్ డిజిటల్ కెమెరాలు తో జరిగే, అందువలన మేము త్వరగా 0 మరియు 1 యొక్క అన్ని కాపీ
ఆఫ్ మీరు ఆ కార్డు యొక్క, 1 పెద్ద ఫైలు వాటిని సేవ్, మరియు అప్పుడు మీరు వారిని చేతితో చేస్తాము
మీరు తిరిగి తో సి లో ఒక ప్రోగ్రామ్ రాయగలగాలి సమస్య 4 సెట్
ఆ JPEGs అన్ని ఆదర్శంగా.
మరియు అది, వారు కొంతవరకు ఒక సంక్లిష్ట ఫైల్ ఆకృతి యొక్క ఉన్నప్పటికీ, ఆ JPEGs అవుతుంది
వారు చాలా క్లిష్టమైన ఇక్కడ ఈ నవ్వే ముఖం కంటే ఉన్నారు.
ప్రతి JPEG 0 మరియు 1 యొక్క మాదిరి తో ప్రారంభమయ్యే అవుతుంది.
కాబట్టి లూప్ లేదా ఇలాంటి కోసం కొంత లూప్ లేదా ఉపయోగించి,
మీరు అన్ని 0 మరియు 1 యొక్క ఈ ఫోరెన్సిక్ చిత్రం లో iterate చేయవచ్చు
మరియు మీరు సమస్య సెట్ యొక్క స్పెసిఫికేషన్ లో నిర్వచించబడింది చేసే ప్రత్యేక నమూనా చూడండి ప్రతి సమయం,
మీరు చాలా ఎక్కువ సంభావ్యత కలిగిన, 'ఓహ్, ఇక్కడ ఉంది, పొందవచ్చు
ఒక JPEG ప్రారంభంలో, 'మరియు వెంటనే మీకు కనుగొనడానికి అదే తీరు
తరువాత బైట్లు లేదా లు లేదా మెగాబైట్ల కొన్ని సంఖ్య,
మీరు Ooh ', పొందవచ్చు! ఇక్కడ రెండవ JPEG, నేను మొదటి ఒక తర్వాత పట్టింది ఫోటో ఉంది.
నాకు ఆ మొదటి ఫైల్ చదవడం ఆపి లెట్, ఈ కొత్త వ్రాయడం ప్రారంభించండి. '
మరియు pset 4 మీ ప్రోగ్రామ్ అవుట్పుట్ చాలా 50 JPEGs అని అన్నారు.
50 JPEGs కాదు ఉంటే, మీరు ఒక లూప్ యొక్క ఒక బిట్ కలిగి ఉంటాయి.
మీరు JPEGs ఒక అనంతమైన ఉంటే, మీరు ఒక అనంతమైన లూప్ ఉన్నాయి.
అందువలన కూడా చాలా సాధారణ విషయం ఉంటుంది.
ఆ క్షితిజాన్ని ఆన్ ఏమిటి.
>> మాకు వెనుక 0 క్విజ్. రియలైజ్, నా ఇమెయిల్ శాతం, ఆ స్థిరముగా ఫొల్క్స్ లేదు
హ్యాపీ, తటస్థ విదంగా మరియు క్విజ్ చుట్టూ విచారంగా 0 రెండు ఉన్నారు.
మరియు తల TFS, Zamyla, మీ స్వంత TF, నాకు చేరుకోవడానికి దయచేసి
మీరు విషయాలను వెళ్లి ఎలా చర్చించడానికి అని మీరు తెలుసు CA ల లేదా ఒక.
>> కాబట్టి, గదిలో ఇక్కడ తల్లిదండ్రులు ఆకట్టుకోవడానికి
CS50 లైబ్రరీ ఏమిటి? మంచి పని చేసారు.
CS50 లైబ్రరీ ఏమిటి? Yeah? [స్టూడెంట్ సమాధానాలు, అపారదర్శక]
>>, సరే మంచి. కాబట్టి మనం సిబ్బంది, రాసిన కోడ్ యొక్క prewritten సెట్ కు,
మేము కొన్ని సాధారణ కార్యాచరణ అందించడానికి, మీకు అందిస్తాయి.
ఇక్కడ జాబితా చేసిన పనులను అన్ని నాకు ఒక పూర్ణాంకానికి పొందండి; నాకు స్ట్రింగ్ పొందండి ఇష్టం విషయం.
ఇప్పుడు మొదలు, మేము నిజంగా ఈ శిక్షణ చక్రాలు టేకాఫ్ ప్రారంభించండి.
కాబట్టి మేము, మీ నుంచి "స్ట్రింగ్" దూరంగా తీసుకుని ఆరంభమవుతుంది చేస్తున్నారు
ఇది, రీకాల్, ఏ నిజమైన డేటా రకం కోసం ఒక పర్యాయపదంగా ఉంది? చార్ *.
కాబట్టి తల్లిదండ్రులు కోసం, ఆ బహుశా - మంచి, కాబట్టి చార్ * మేము చూడడానికి మీరు
తెరపై అన్ని మేము మా పదజాలం నుండి "స్ట్రింగ్" తొలగించు వంటి,
వాస్తవానికి కోడ్ రాయడం దానిని వస్తుంది కనీసం ఉన్నప్పుడు.
అదేవిధంగా, మేము చాలా ఈ విధులు వాడి ఆపడానికి ఉంటాం
మా కార్యక్రమాలు మరింత అధునాతన పొందగలిగిన ఎందుకంటే
కాకుండా కేవలం, ఒక ప్రాంప్టు మెరిసే తో అక్కడ కూర్చుని ప్రోగ్రాములను వ్రాయటానికి
సైన్ ఏదో టైప్ వినియోగదారు వేచి
మరొకచోట నుండి మీరు మీ ఇన్పుట్లను పొందుతారు.
ఉదాహరణకు, మీరు స్థానిక హార్డు డ్రైవు బిట్స్ వరుస నుండి పొందుతారు.
బదులుగా మీరు కొన్ని వెబ్ సైట్ ఎక్కడో ఒక నెట్వర్క్ కనెక్షన్ నుండి భవిష్యత్తులో వాటిని పొందుతారు.
కాబట్టి మొదటి సారి తిరిగి ఈ పొర చర్మము యొక్క వివరించారు, CS50 ఉపకరణం పుల్ అప్
మీరు వారాలు సహా పదునైన ఉన్నాను ఇది CS50.h అని మరియు ఈ ఫైలు,.
>> కానీ వాస్తవానికి యొక్క ఈ లోపల ఏమి చూడటానికి.
కాబట్టి నీలం లో ఫైల్ టాప్, కేవలం వ్యాఖ్యల మొత్తం బంచ్ ఉంది
వారంటీ సమాచారం మరియు లైసెన్సింగ్. ఈ సాధారణ ఉదాహరణ యొక్క విధమైన ఉంది
సాఫ్ట్వేర్ లో, ఎందుకంటే సాఫ్ట్వేర్ చాలా ఈ రోజుల్లో ", ఓపెన్ సోర్స్" అని ఏమిటి
ఇది ఎవరైనా కోడ్ వ్రాశారు అర్థం
మరియు, కేవలం అమలు చేయడానికి మరియు ఉపయోగించడానికి, దీనిని ఉచితంగా అందుబాటులో
కానీ వాస్తవానికి చదివి మార్పు మరియు మీ స్వంత కృతి కలిసిపోవడానికి.
కాబట్టి, మీరు, ఓపెన్ సోర్స్ సాఫ్ట్ వేర్ ఉపయోగించి చేసిన ఏది
చాలా చిన్న రూపంలో రూపొందించబడింది.
నేను వ్యాఖ్యలను గత స్క్రోల్ డౌన్ ఉంటే, అయితే, మేము కొన్ని మరింత చేరువైన విషయాలు చూడండి మొదలుపెడతారు.
కాబట్టి CS50.h ఫైల్ హెడర్ ఫైళ్ళ మొత్తం బంచ్ కలిగి, ఇక్కడ ఎగువన గమనిస్తారు.
ఇప్పుడు, ఈ అత్యంత మేము ముందు చూడని, కానీ ఒకటి
తెలిసిన; ఈ ఏ మేము ఇప్పటివరకు, క్లుప్తంగా, అయినప్పటికీ చూసిన?
అవును, ప్రామాణిక గ్రంధాలయాలు. Stdlib.h, malloc ఉంది
కాబట్టి ఒకసారి మేము, డైనమిక్ మెమరీ కేటాయింపు గురించి మాట్లాడటం మొదలుపెట్టాడు
మేము అదే వచ్చే వారం తిరిగి వచ్చి మేము, ఆ ఫైల్ను సహా ప్రారంభించారు.
ఇది bool మరియు నిజమైన మరియు తప్పుడు వాస్తవానికి, ప్రతి SE, C లో లేని అవుతుంది
మీరు ఇక్కడ ఈ ఫైలు ఉన్నాయి తప్ప.
కాబట్టి మేము, వారాలు, ప్రామాణిక bool.h సహా చేశారు
మీరు ఒక, bool ఒప్పు లేదా తప్పు. భావన ఉపయోగించడానికి ఆ
ఈ లేకుండా, మీరు నకిలీ అది యొక్క క్రమం మరియు ఒక పూర్ణాంకానికి ఉపయోగించవలసి వస్తుంది
మరియు కేవలం ఏకపక్ష 0 తప్పుగా మరియు 1 నిజమైన భావించవలసి.
>> ఇప్పుడు, మేము మరింత స్క్రోల్ డౌన్ ఇక్కడ ఒక స్ట్రింగ్ యొక్క మా నిర్వచనం ఉంది.
ఈ * ఉన్న నిజంగా ప్రాధాన్యత లేదు, మేము ముందు చెప్పారు చేసిన వంటి, అవుతుంది.
మీరు కూడా అన్ని చుట్టూ ఖాళీ చేయవచ్చు.
మేము, ఈ సెమిస్టర్, * రకం సంబంధం కలిగి ఉంటుంది, అని స్పష్టం చేయడానికి ఈ గా ప్రచారం చేశారు.
కానీ కొంచెం సాధారణ లేకపోతే, అక్కడ అది ఉంచాలి, కేవలం వంటి సాధారణ, తెలుసుకుంటారు
కానీ క్రియాశీలంగా ఒకే విషయం.
మేము మరింత డౌన్ చదవండి అయితే ఇప్పుడు, యొక్క సే పరిశీలించి, GetInt, తీసుకుందాం
మేము ఏదైనా ఈ సెమిస్టర్ ముందు, బహుశా, ఆ ఉపయోగిస్తారు ఎందుకంటే.
మరియు ఇక్కడ GetInt ఉంది. ఈ ఏమిటి?
ఈ నమూనా ఉంది. కాబట్టి తరచుగా, మేము మా యొక్క టాప్స్ వద్ద నమూనాలను నిలబెట్టాయి. సి ఫైళ్లు,
కానీ మీరు కూడా శీర్షిక ఫైళ్లు,. h ఫైళ్లు, ప్రోటోటైప్స్ ఉంచవచ్చు
ఇక్కడ ఈ విధంగా తద్వారా మీరు కొన్ని విధులు వ్రాస్తున్నప్పుడు
మీరు ఇతర ప్రజలు ఉపయోగించవచ్చు చేయదలిచిన, ఇది CS50 లైబ్రరీ తో సరిగ్గా సందర్భంలో
మీరు, CS50.c లాగ మీ విధులు అమలు మాత్రమే
మీరు కూడా, కాని ఫైల్ ఎగువన నమూనాలను ఉంచారు, కానీ ఒక శీర్షికా ఫైలును ఎగువన
ఆ శీర్షికా ఫైలును, స్నేహితులు మరియు సహచరులు హాజరవుతారు ఏమిటి
పదునైన తమ సొంత కోడ్ చేర్చండి.
ఈ సమయంలో మీరు ఈ నమూనాలను అన్ని సహా చేసిన
సమర్థవంతంగా మీ ఫైల్ ఎగువన, కానీ ఈ పదునైన ద్వారా యంత్రాంగం ఉన్నాయి
ఆ ముఖ్యంగా కాపీలు మరియు ముద్ద మీ స్వంత ఈ ఫైలు.
ఇప్పుడు, ఇక్కడ కొన్ని విశదమైన డాక్యుమెంటేషన్ ఉంది.
>> GetInt ఒక పూర్ణాంకానికి అందుతుంది అని మంజూరు కోసం మేము చాలా చక్కని తీసుకున్నారు,
కొన్ని సందర్భాలలో మూలలో ఉంది అవుట్ కానీ, కుడి మారుతుంది?
ఏ విధంగా చాలా పెద్దది ఒక సంఖ్య లోని యూజర్ రకాల ఉంటే?
కేవలం ఒక పూర్ణాంకానికి లోపలి సరిపోవు ఒక quintillion,?
ఊహించిన ప్రవర్తన ఏమిటి? Well, ఆదర్శవంతంగా, ఊహించదగిన ఉంది.
కాబట్టి ఈ విషయంలో, మీరు నిజంగా, ఫైన్ ప్రింట్ చదివినట్లయితే
మీరు ఆ పంక్తిలో తెలుసుకోలేదు ఉంటే, ఈ రాబడి INT_MAX చూస్తారు.
మేము దీని గురించి మాట్లాడారు, కానీ దాని పెట్టుబడి ఆధారంగా ఎప్పుడూ చేసిన
అది బహుశా, ఏమిటి?
అది స్థిరమైన, కనుక అది ప్రకటించబడిన కొన్ని ప్రత్యేక స్థిరంగా ఉంది
ఫైలు ఎగువ అని ఆ శీర్షిక ఫైళ్లు ఒక,
మరియు INT_MAX బహుశా 2 బిలియన్, సుమారు, వంటిది.
మేము ఏదో ఏదో సూచిస్తుంది అవసరం ఎందుకంటే దీనికి ఆలోచన, తప్పు జరిగింది
మేము, అవును, మా పారవేయడం వద్ద 4 బిలియన్ సంఖ్యలు ఉంటాయి
2 బిలియన్ న ప్రతికూల 2 బిలియన్ ఇవ్వడం లేదా పడుతుంది.
Well, ఏ ప్రోగ్రామింగ్ లో సాధారణంగా మీరు ఆ సంఖ్యల ఒక దొంగతనం ఉంది.
బహుశా 0, బహుశా 2 బిలియన్, బహుశా ప్రతికూల 2 బిలియన్.
మీరు ప్రపంచానికి కమిట్ విధంగా కాబట్టి మీరు మీ సాధ్యమయ్యే విలువలను ఒకటి ఖర్చు
ఏదో తప్పు పోతే, నేను ఈ సూపర్ పెద్ద విలువ అందిస్తుంది.
కానీ మీరు యూజర్ వంటి నిగూఢ ఏదో టైప్ ఇష్టం లేదు "4, 2, 3 ..."
నిజంగా పెద్ద సంఖ్యలో, మీరు స్థిరమైన వంటి బదులుగా క్రమపరచుట.
కాబట్టి నిజంగా, మీరు గత కొన్ని వారాల ఆసన అనే ఉంటే,
మీరు GetInt కాల్ ఎప్పుడైనా, మీరు ఒక ఉంటే పరిస్థితికి తనిఖీ వుండాలి.
, లేదా మరింత ప్రత్యేకంగా, INT_MAX వినియోగదారు టైప్ చేశారా
GetInt తిరిగి INT_MAX చేశాడు? ఎందుకంటే అది చేస్తే,
వాస్తవానికి వారు టైపు లేదు అని; ఏదో ఈ విషయంలో తప్పు జరిగింది.
కాబట్టి ఈ సాధారణంగా కేవలం ప్రత్యేక అంటే ఒక "సెంటినెల్" విలువ, గా పిలిచే దాన్ని ఉంది.
>> సరే, ఇప్పుడు. సి ఫైళ్లను కు తిరగండి తెలియజేయండి.
సి ఫైలు, కొంత సమయం కోసం పరికరంలోని ఉనికిలో ఉంది
మరియు, నిజానికి, ఉపకరణం మీ కోసం precompiled ఉంది
ఆ విషయం లో మేము ", వస్తువు కోడ్" అని
సిస్టమ్ తెలుసు ఎందుకంటే అది ఎక్కడ కానీ అది కేవలం మీకు సంబంధించిన లేదు,
ఈ సందర్భంలో, అది ఎక్కడ, ఉపకరణం.
కానీ యొక్క GetInt ఇప్పుడు స్క్రోల్ డౌన్ తెలియజేయండి మరియు GetInt ఈ సమయంలో పని ఎలా చూడండి.
కాబట్టి ఇక్కడ ముందు నుండి ఇలాంటి వ్యాఖ్యలు ఉన్నాయి.
నాకు కేవలం కోడ్ భాగం లో జూమ్ లెట్
మరియు మేము GetInt కోసం కింది ఉంది.
(నిజమైన), కాబట్టి మేము ఒక ఉద్దేశపూర్వక అనంతమైన లూప్ కలిగి ఉండటం వలన ఇది ఇన్పుట్ తీసుకుని అది ఒక పూర్ణాంకానికి తిరిగి
కానీ, బహుశా, మేము ఏదో ఈ యొక్క బయటకు, లేదా ఈ లోపల నుండి తిరిగి వస్తుంది.
కాబట్టి ఎలా ఈ పనులు చూడటానికి. Well, మేము GetString ఉపయోగించి కనిపిస్తుంది
లూప్, 166 లోపల ఈ మొదటి లైన్ లో.
ఈ ఇప్పుడు మంచి పద్ధతి ఎందుకంటే ఏమి పరిస్థితుల్లో
GetString ఈ ప్రత్యేక కీవర్డ్, NULL తిరిగి విధుల్లో?
ఏదో తప్పు జరిగితే ఉంటే. మీరు GetString లాగ కాల్ చేసినప్పుడు తప్పు ఏం చేయాలో?
Yeah? [స్టూడెంట్ సమాధానం, అపారదర్శక] >> అవును. కాబట్టి బహుశా malloc విఫలమైతే.
ఎక్కడో హుడ్ GetString కింద, malloc కాల్
ఇది కంప్యూటర్ స్టోర్ చేయడానికి అనుమతిస్తుంది, ఇది మెమరీ కేటాయించుకునే
పాత్రలు ఆ కీబోర్డ్ లో యూజర్ రకాల.
మరియు యూజర్ ఖాళీ సమయంలో మొత్తం చాల ఉన్నాయి అనుకుందాం
మరియు 2 బిలియన్ కంటే ఎక్కువ అక్షరాలు, ఉదాహరణకు, ఎక్కువ టైప్.
కంప్యూటర్ కంటే ఎక్కువ అక్షరాలు కూడా RAM కలిగి ఉంది.
Well, GetString, మీరు ఆ సూచిస్తుంది సామర్థ్యాన్ని కలిగి ఉండాలి
ఈ సూపర్, సూపర్ అసాధారణ మూలలో సందర్భంలో కూడా.
ఇది ఏదో ఈ నిర్వహించడానికి సామర్థ్యాన్ని కలిగి ఉండాలి, మరియు అందువలన GetString
మేము తిరిగి వెళ్లి తన డాక్యుమెంటేషన్ చదవండి ఉంటే, నిజానికి, NULL తిరిగి లేదు.
GetString NULL రావడం ద్వారా విఫలమైతే ఇప్పుడు ఉంటే, GetInt విఫలం అన్నారు
ఒక సెంటినెల్ వంటి, INT_MAX రావడం ద్వారా.
ఇవి మానవ సమావేశాలు ఉంటాయి. మీరు ఈ తెలుసు మాత్రమే మార్గం సందర్భంలో
డాక్యుమెంటేషన్ చదవడం ద్వారా ఉంది.
కాబట్టి యొక్క Int వాస్తవానికి GotInt ఉన్న క్రిందికి స్క్రోల్ అనుమతిస్తుంది.
>> నేను ఒక బిట్ మరింత స్క్రోల్ డౌన్ చేస్తే, లైన్ 170 లో మేము ఈ మార్గాల పైన వ్యాఖ్య ఉందా.
కాబట్టి మేము, 172 లో, ఒక పూర్ణాంకానికి n మరియు ఒక చార్ సి, మరియు ఈ కొత్త ఫంక్షన్ డిక్లేర్
మీరు కొన్ని ముందు అంతటా డెక్కన్ ఛార్జర్స్, కానీ sscanf చేశారు.
ఈ స్ట్రింగ్ స్కాన్ F సూచిస్తుంది.
ఇతర మాటలలో, నాకు స్ట్రింగ్ ఇవ్వాలని నేను ఆసక్తికరమైన సమాచారం ముక్కలు కోసం స్కాన్ చేస్తుంది.
కాబట్టి ఆ అర్థం ఏమిటి? Well, నేను కీబోర్డ్ వద్ద 1 2 3, వాచ్యంగా, టైప్ చేసే ఉద్దేశం
ఆపై ఎంటర్ నొక్కండి. GetString ద్వారా తిరిగి 1 2 3 యొక్క డేటా రకం ఏమిటి?
ఇది కుడి, స్పష్టంగా ఒక స్ట్రింగ్ ఏమిటి? నేను ఒక స్ట్రింగ్ వచ్చింది, కాబట్టి 1 2 3 నిజంగా "1 2 3"
అది ముగింపులో \ 0 తో. ఒక Int కాదు.
ఒక సంఖ్య కాదు. ఇది అనేక కనిపిస్తోంది అయితే కాదు.
సో వాట్ GetInt లేదు లేదు? ఇది ఎడమ ఆ స్ట్రింగ్ స్కాన్ ఉంటుంది
1 2 3 \ 0, మరియు ఏదో ఒక వాస్తవ పూర్ణాంక మార్పు చేయండి.
ఇప్పుడు, మీరు దీన్ని ఎలా పూర్తి చేయాలో అంచనా కాలేదు.
మీరు pset 2 తిరిగి భావిస్తే, మీరు బహుశా కొద్దిగా సౌకర్యవంతమైన వచ్చింది
సీజర్ లేదా విజెనెరే తో కాబట్టి మీరు ఒక స్ట్రింగ్ పైగా iterate చేయవచ్చు
మీరు పిక్ ints కు అక్షరాలు మార్చవచ్చు. కృతి యొక్క మొత్తం చాలా పేర్కొంది.
ఎందుకు మీరు ఆ చేసే sscanf వంటి ఫంక్షన్ కాల్?
కాబట్టి sscanf స్ట్రింగ్ ఉన్న లైన్ అని ఈ సందర్భంలో, లో, ఒక వాదన ఆశించారు.
అప్పుడు మీరు,, కోట్స్ లో, printf సమానమైన పేర్కొనండి
మీరు ఈ స్ట్రింగ్ లో చూడటానికి ఏమి అనుకుంటున్నావా?
నేను ఇక్కడ చెప్పడం నేను ఉంది, నేను ఒక దశాంశ సంఖ్య చేసి ఒక పాత్ర చూడాలనుకుంటున్నారా.
ఈ ఒక్క నిమిషం లో కేసు ఎందుకు మరియు మేము చూస్తారు.
ఈ సంజ్ఞామానం ఇప్పుడు stuff గుర్తుచేస్తుంది ఆ అవుతుంది
మేము కేవలం ఒక వారం క్రితం మీద గురించి మాట్లాడటం మొదలుపెట్టాడు.
>> ఏమిటి & n మరియు & సి ఇక్కడ మాకు చేయడం? [స్టూడెంట్ సమాధానాలు, అపారదర్శక]
>> అవును. ఇది నాకు సి యొక్క n మరియు చిరునామా చిరునామా ఇచ్చి ఉన్నారు.
ఇప్పుడు, ఎందుకు ముఖ్యమైనది? సరే, మీరు తెలుసు సి లో విధులు
మీరు ఎల్లప్పుడూ అన్ని వద్ద ఒక విలువ లేదా సంఖ్య విలువ తిరిగి రావచ్చు.
మీరు ఒక Int, ఒక స్ట్రింగ్, ఫ్లోట్, ఒక భస్మం, ఏ తిరిగి రావచ్చు.
లేదా మీరు తప్ప తిరిగి, కానీ మీరు మాత్రమే గరిష్టంగా 1 విషయం తిరిగి రావచ్చు.
కానీ ఇక్కడ మేము sscanf బహుశా ఒక Int, ఒక దశాంశ సంఖ్య, నాకు తిరిగి కావాలి
మరియు ఒక చార్, మరియు నేను ఒక క్షణం లో ఎందుకు చార్ వివరించడానికి చేస్తాము.
కాబట్టి మీరు సమర్థవంతంగా F 2 విషయాలు తిరిగి కావలసిన; ఆ C. కేవలం సాధ్యం కాదు
కాబట్టి మీరు, 2 చిరునామాలలో పంపిస్తూ చుట్టూ పని చేయవచ్చు
మీరు ఒక ఫంక్షన్ 2 చిరునామాలు చేతితో వెంటనే, ఆ ఫంక్షన్ వారితో ఏమి ఎందుకంటే?
ఇది ఆ చిరునామాలను వ్రాయవచ్చు. మీరు * ఆపరేషన్ ఉపయోగించడానికి మరియు ఆ చిరునామాలను ప్రతి "అక్కడ వెళ్ళి" చేయవచ్చు.
ఈ బ్యాక్డోర్ను యంత్రాంగం విధమైన, కానీ చరరాశులు యొక్క విలువలలో మార్చడానికి చాలా సాధారణ
ఈ సందర్భంలో 2 కేవలం 1 స్థానంలో, కంటే ఎక్కువ లో.
ఇప్పుడు నేను == to1 తనిఖీ, మరియు ఆ నిజానికి, నిజమైన విశ్లేషించదు ఒకవేళ n తిరిగి నేను గమనించి.
కాబట్టి ఏం జరగబోతోంది? Well, సాంకేతికంగా, మేము నిజంగా GetInt లో ఏమి చేయాలనే ఈ ఉంది.
మేము మాట్లాడటానికి, విశ్లేషించడం మీరు; మేము స్ట్రింగ్ చదవాలనుకుంటున్న
"1 2 3" మరియు అక్కడ అనేక ఉంది కనిపిస్తుంది ఉంటే,
మనం చెయ్యవలసింది sscanf చెప్పుకుంటున్నారు నాకు ఈ వేరియబుల్ n ఆ సంఖ్య, 1 2 3, పెట్టబడింది.
ఎందుకు, అప్పుడు, నేను కూడా ఈ ఉందా?
కూడా sscanf, మీరు కూడా ఇక్కడ ఒక పాత్ర పొందడానికి ఉండవచ్చు విధంగా పాత్ర ఏమిటి.
[స్టూడెంట్ మాట్లాడే, అపారదర్శక] >> కాదు - ఒక దశాంశ బిందువు పనిచేస్తుంది.
ఒక క్షణం ఆలోచన ఆ యొక్క కలిగి లెట్. ఏమి?
[స్టూడెంట్, అపారదర్శక] >> కాబట్టి, మంచి ఆలోచన, అది NULL పాత్ర ఉంటుంది.
ఈ సందర్భంలో, వాస్తవానికి కాదు. Yeah? [స్టూడెంట్, అపారదర్శక]
>> >> ASCII. లేదా, నాకు మరింత క్రమపరచుట తెలియజేయండి.
అక్కడ% సి కేవలం లోపం పరిశీలన మాత్రమే.
మేము, సంఖ్య తర్వాత పాత్ర ఉన్నట్లు ఇష్టం లేదు
కానీ ఈ నాకు అనుమతిస్తుంది ఇలా ఉంటాయి:
ఇది ఆ sscanf, ఇక్కడ ఈ ఉదాహరణలో, n మరియు సి విలువలు నిల్వ పాటు, అవుతుంది
అది కూడా వేరియబుల్స్ యొక్క సంఖ్యను చూపించే ఏమి అది సైన్ విలువలు ఉంచండి
మీరు మాత్రమే అప్పుడు, 1 2 3 లో టైప్ చేస్తే మాత్రమే% d మ్యాచ్ అన్నారు
మరియు మాత్రమే n 1 2 3 వంటి విలువ నిల్వ అవుతుంది మరియు ఏమీ సి ఉంచే;
సి మాట్లాడటానికి, ఒక చెత్త విలువ ఉంది.
అది కొన్ని విలువ initialized ఎప్పుడూ యొక్క చెత్త ఎందుకంటే.
నేను ఆ గమనికలు ఒక జనాభా కనుక అలా ఆ సందర్భంలో, sscanf, 1 తిరిగి
ఈ సందర్భంలో, గొప్ప. నేను ఒక పూర్ణాంకానికి కలిగి ఉంటాయి, కాబట్టి నేను మెమరీ అప్ విముక్తికై లైన్ విడిపించేందుకు
ఆ GetString వాస్తవానికి కేటాయించింది, ఆ తరువాత n తిరిగి.
ఆ మళ్ళీ పేరు మీరు ఆలోచిస్తున్నారా ఉంటే ఎల్స్, ప్రకటన నుండి వచ్చింది, ఇక్కడ నుండే వస్తుంది.
ఉంటే దీనికి విరుద్ధంగా, నేను, 1 2 3 foo టైప్
టెక్స్ట్ యొక్క కొన్ని యాదృచ్ఛిక క్రమంలో, sscanf, చూడండి అన్నారు
F - ooh, ooh, సంఖ్య సంఖ్య ooh, సంఖ్య ooh.
మరియు అది n లో 1 2 3 ఉంచాలి జరగబోతోంది.
ఇది సి లో F ఉంచారు, మరియు అప్పుడు 2 తిరిగి వెళుతున్న.
కాబట్టి మేము కేవలం scanf యొక్క ప్రవర్తన యొక్క ప్రాధమిక నిర్వచనం ఉపయోగించి కలిగి
చాలా సులభమైన మార్గం - అదే, మొదటి చూపులో క్లిష్టమైన, కానీ రోజు చివరిలో,
చెప్పడం యొక్క నిరాడంబర యంత్రాంగం అక్కడ ఒక Int, మరియు అలా అయితే, ఆ నేను దొరకలేదు మాత్రమే విషయం?
మరియు ఇక్కడ వైట్ స్పేస్ ఉద్దేశపూర్వక ఉంది. మీరు sscanf కోసం డాక్యుమెంటేషన్, చదవడానికి ఉంటే
ఆ మీరు ప్రారంభంలో లేదా చివరిలో వైట్ స్పేస్ భాగాన్ని కలిగి ఉంటే, మీరు చెబుతుంది
sscanf చాలా spacebar 1 2 3 నొక్కండి, కారణము ఏదైనప్పటికీ, యూజర్ అనుమతిస్తుంది, మరియు ఆ చట్టబద్ధమైన ఉంటుంది.
వారు ప్రారంభంలో లేదా చివరిలో spacebar నొక్కండి కనుక ఇది వినియోగదారు మీద అరుస్తుంటారు లేదు
ఇది యూజర్ ఫ్రెండ్లీ కొంచెం ఎక్కువ.
>> ఏదైనా ప్రశ్నలు, అప్పుడు, GetInts న? Yeah?
[స్టూడెంట్ ప్రశ్న, అపారదర్శక]
>> మంచి ప్రశ్న. మీరు ఒక చార్ లో టైప్ చేస్తే, f, మరియు విజయవంతమైన వంటి నమోదు ఏమిటి
ఎప్పుడూ 1 2 3 టైప్ లేకుండా; మీరు కోడ్ ఈ రేఖ యొక్క ప్రవర్తన అప్పుడు ఉంటుంది ఏమి ఆలోచిస్తాడు?
కాబట్టి sscanf, కూడా ఉంటాయి ఆ సందర్భంలో ఎందుకంటే,
అది n లేదా సి పూర్తి మాత్రం కాదు; ఇది బదులుగా 0 తిరిగి వెళుతున్న.
నేను మీరు ఊహించిన విలువ 1 ఎందుకంటే ఈ సందర్భంలో, నేను కూడా, ఆ దృష్టాంతంలో క్యాచింగ్ చేస్తున్నాను.
నేను మాత్రమే 1 కావాలి, మరియు మాత్రమే 1 విషయం నింపవచ్చు. ప్రశ్న గుడ్. ఇతరులు?
>> All right, కాబట్టి ఇక్కడ విధులు అన్ని ద్వారా వెళ్ళి వినియోగించవద్దు,
కానీ మిగిలిన ఆసక్తి, బహుశా, కనబడుతోందని ఒక
అది అవుతుంది ఎందుకంటే GetString అని GetFloat, GetInt,
అన్ని రౌడీ GetString వారి కార్యాచరణను చాలా GetLongLong, GetDouble.
కాబట్టి అతను ఇక్కడ అమలు ఎలా పరిశీలించి అనుమతిస్తుంది.
ఈ ఒక చిన్న క్లిష్టమైన ఉంది కానీ అదే ఫండమెంటల్స్ ఉపయోగిస్తుంది
మేము గత వారం గురించి మాట్లాడటం మొదలుపెట్టాడు ఆ. కాబట్టి GetString లో,
ఇది ఇక్కడ తప్ప ప్రకారం ఏ వాదన పడుతుంది
మరియు అది ఒక స్ట్రింగ్ పంపుతుంది; నేను బఫర్ అనే స్ట్రింగ్ ప్రకటించారు am.
నేను నిజంగా ఆ ఇంకా ఉపయోగించకూడదు ఏమి తెలియదు, కానీ మేము చూస్తారు.
సామర్థ్యం ఉన్నట్లు ఉంది డిఫాల్ట్, 0 ద్వారా, ఉంటుంది; ఈ వెళ్లి కౌంటీ చాలా ఖచ్చితంగా లేదు.
కాదు n ఇంకా ఉపయోగించకూడదు ఏమి ఖచ్చితంగా.
కానీ ఇప్పుడు, చాలా లైన్ 243 లో, ఒక చిన్న ఆసక్తికరమైన సంతరించుకోనుంది
మేము ఒక పూర్ణాంకానికి సి, ఈ ఒక పెద్ద వివరాలు యొక్క విధమైన ఉంది ప్రకటిస్తాయి.
ఒక చార్ 8 బిట్స్, మరియు 8 బిట్స్ ఎలా అనేక విలువలు నిల్వ చేయవచ్చు?
256. మీరు 256 వివిధ ASCII అక్షరాలు అనుకుంటే సమస్య, ఉంది
ఇది అక్కడ మీరు తిరిగి భావిస్తే, ఈ గుర్తుంచుకోవలసిన విషయం కాదు.
మీరు పెద్ద ASCII చార్ట్ తిరిగి అనుకుంటే కానీ మేము వారాల క్రితం వచ్చింది,
ఆ సందర్భంలో, 128 లేదా 256 ASCII అక్షరాలు లో ఉన్నాయి.
మేము అన్ని 0 యొక్క నమూనాలు మరియు 1 ఇష్టం ఉపయోగిస్తారు.
మీరు ఒక దోషాన్ని గుర్తించే సామర్థ్యం కోరుకుంటే ఒక సమస్య.
మీరు ఇప్పటికే మీ అక్షరాలు కోసం 256 విలువలు ను ఉపయోగిస్తున్నట్లయితే ఎందుకంటే,
ఇప్పుడు మీరు చెబుతున్న సంఖ్య మార్గం లేని కారణంగా మీరు నిజంగా,, ముందుకు ప్లాన్ లేదు
"ఇది సక్రమం పాత్ర కాదు; ఈ కొన్ని తప్పుడు సందేశం."
సో వాట్ ప్రపంచ ఉండదు, వారు తదుపరి అతిపెద్ద విలువ ఉపయోగించడానికి,
ఒక పూర్ణాంకానికి లాగ మీరు బిట్స్ ఒక క్రేజీ ఉన్నాయి కాబట్టి,
4 బిలియన్ విలువల కోసం 32, తద్వారా మీరు కేవలం ఉపయోగించి అవుతుంది
ముఖ్యంగా, వాటిలో 257, 1 ఇది ఒక లోపం వంటి కొన్ని ప్రత్యేక అర్థం ఉంది.
>> కాబట్టి ఎలా ఈ పనులు చూడటానికి. లైన్ 246 లో, ఈ పెద్ద సమయంలో లూప్ కలిగి
ఆ fgetc కాల్; అప్పుడు F అర్థం ఫైలు, getc, మరియు stdin.
ఇది చెప్పడం మరింత ఖచ్చితమైన మార్గం అవుతుంది "కీబోర్డ్ నుండి ఇన్పుట్ చదవండి."
ప్రామాణిక ఇన్పుట్ అంటే కీబోర్డు, ప్రామాణిక అవుట్పుట్, స్క్రీన్ అర్థం
మరియు మేము pset 4 లో చూస్తారు ఇది ప్రామాణిక తప్పు,,, స్క్రీన్ అర్థం
కానీ స్క్రీన్ ప్రత్యేక భాగంగా కలిపారు లేదు, అందుచే
మీరు ముద్రించడానికి ఉద్దేశించిన నిజమైన కృషిని; కానీ భవిష్యత్తులో ఆ మరింత.
కాబట్టి fgetc కేవలం కీబోర్డ్ నుండి ఒక పాత్ర చదవండి, మరియు నిల్వ అంటే?
సి లో నిల్వ చేసి, ఆపై తనిఖీ, కాబట్టి నేను ఇక్కడ కొన్ని బూలియన్ సముచ్ఛయాలు ఉపయోగించి నేను,
అది n అందువల్ల వినియోగదారుడు ఎంటర్ నొక్కండి ఉంది \ సమానం కాదు చేసే తనిఖీ.
మేము ఆ, లూప్ చివరిలో ఆపివేయాలనుకుంటున్నారా, మరియు మేము కూడా తనిఖీ మీరు
కోసం మీకు లేదా ఊహించడం ఉంటే ప్రత్యేక స్థిరమైన, EOF, - ఇది ఏ స్టాండ్ లేదు?
ఫైలు ముగింపు. నేను కీబోర్డ్ వద్ద టైప్ చేస్తున్నానని ఉంటే ఎందుకంటే ఈ, పిచ్చి రకం
ఈ ప్రమేయం ఏ ఫైల్, నిజంగా ఉంది
కానీ ఇది సూచించడానికి ఉపయోగిస్తారు సాధారణ పదం యొక్క క్రమం ఉంది
ఇంకా ఆ ఏమీ మానవ యొక్క చేతి వేళ్ళ నుంచి వస్తోంది. EOF. ఫైలు ముగింపు.
ఒక పక్కన, మీరు మీ కీబోర్డ్ లో నియంత్రణ d హిట్ ఉంటే,
మీరు ఇంకా కాదు ఆ; మీరు కంట్రోల్ సి హిట్ చేసిన.
కానీ కంట్రోల్ d ఈ ప్రత్యేక స్థిరంగా అని EOF పంపుతుంది.
>> కాబట్టి ఇప్పుడు మేము కొన్ని డైనమిక్ మెమరీ కేటాయింపు ఉంది.
N + 1> సామర్థ్యం, ​​ఇప్పుడు నేను n వివరించడానికి మీరు చేస్తున్నాను.
n కేవలం ఎన్ని బైట్లు, బఫర్ ప్రస్తుతం ఉంటాయి
మీరు ప్రస్తుతం వినియోగదారు నుండి రూపొందించడంలో చేస్తున్న స్ట్రింగ్.
మీరు బఫర్ లో సామర్థ్యం కంటే మీ బఫర్ లో ఎక్కువ అక్షరాలు కలిగి ఉంటే,
intuitively, అప్పుడు ఏమి చేయాలి మరింత సామర్థ్యం కేటాయించాలని ఉంది.
నేను ఇక్కడ అంకగణితం యొక్క కొన్ని పైగా చెడిపోయిన వెళుతున్న
మరియు ఇక్కడ మాత్రమే ఈ చర్య దృష్టి.
మీరు malloc ఉంది ఏమి, లేదా కనీసం సాధారణంగా తెలిసిన.
Realloc ఏమి ఒక అంచనా తీసుకోండి. [స్టూడెంట్ సమాధానం, అపారదర్శక]
>> అవును. మరియు చాలా మెమరీ జోడించడం కాదు; అది ఈ కింది విధంగా మెమరీ reallocates:
మీరు ఆ మెమరీ మరింత ఇవ్వాలని స్ట్రింగ్ చివరిలో గది ఇప్పటికీ ఉంది ఉంటే
ఇది మొదట మీరు ఇస్తుంది కంటే, మీరు అదనపు మెమరీ పొందుతారు.
కాబట్టి మీరు వెనక్కి తిరిగి తిరిగి తిరిగి తీగలను అక్షరాలు చూస్తూ చేయవచ్చు.
ఆ సందర్భంలో కాదు అయితే, ఎందుకంటే మీరు చాలా పొడవుగా వేచి
మరియు యాదృచ్ఛిక ఏదో మెమోరీలో plopped వచ్చింది, కానీ అదనపు లేదు
ఇక్కడ డౌన్ మెమరీ, ఆ సరైందే. Realloc, మీరు అన్ని భారీ ట్రైనింగ్ చేయడానికి వెళ్తున్నారు
, మీరు ఇప్పటివరకు ఇక్కడ నుండి చదివారు స్ట్రింగ్ తరలించడానికి
అక్కడ దీనిని కాదని, ఆపై మీరు ఆ సమయంలో కొన్ని మరింత రన్వే ఇస్తాయి.
కాబట్టి చేతి యొక్క కెరటంతో, నాకు ఏమి GetString చేస్తున్న ఆ అని పిలవబడు
అది ఒక చిన్న బఫర్, బహుశా 1 సింగిల్ పాత్ర తో ప్రారంభమయ్యే అని
మరియు 2 అక్షరాలు వినియోగదారు రకాల ఉంటే, GetString ముగుస్తుంది
realloc కాల్ మరియు Ooh 'అన్నారు, 1 పాత్ర తగినంత లేదు.
నాకు 2 అక్షరాలు ఇవ్వండి. ' మీరు, లూప్ యొక్క తర్కం ద్వారా రీడ్ అప్పుడు ఉంటే
అది, Ooh ', 3 అక్షరాలు లో టైప్ యూజర్ చెప్పడానికి జరగబోతోంది.
ఇప్పుడు కాదు 2 కాని 4 అక్షరాలు నాకు ఇవ్వండి, అప్పుడు నాకు 16 మరియు 32 ఇవ్వాలని తర్వాత, నాకు 8 ఇస్తాయి. '
నేను సామర్థ్యం ప్రతి సమయం రెట్టింపు చేస్తున్నాను వాస్తవం
బఫర్ నెమ్మదిగా వృద్ధి వెళ్ళడం లేదు అని అర్థం.
ఇది సూపర్ ఫాస్ట్ పెరుగుతాయి అవకాశముంది, మరియు ఆ ప్రయోజనాన్ని కావచ్చు ఏమి?
నేను యూజర్ అయినప్పటికీ, బఫర్ పరిమాణం రెట్టింపు am
కేవలం కీబోర్డు నుండి 1 అదనపు పాత్ర అవసరం ఉండవచ్చు?
[స్టూడెంట్ సమాధానం, అపారదర్శక]. >> అంటే ఆ?
సరిగ్గా. మీరు తరచుగా పెరగడం లేదు.
మరియు ఈ ఒక కేవలం రకం - you're ఇక్కడ మీ పందెం పరిమితం.
దీనిని నెమ్మదిగా ఉంటుంది ఎందుకంటే మీరు, realloc చాలా కాల్ అనుకుంటున్న అనేది.
మీరు వెంటనే చూస్తారు మీరు, మెమరీ కోసం ఆపరేటింగ్ సిస్టమ్ అడగండి ఏదైనా సమయం
ఒక భవిష్యత్తు సమస్య సెట్ లో కొంత సమయం పడుతుంది ఉంటుంది.
మీరు కొన్ని అంతరిక్ష వృధా చేసిన కూడా, సమయం ఆ మొత్తం తగ్గించడం కాబట్టి, ఒక మంచి విషయం ఉంటుంది.
>> కానీ మేము ఇక్కడ GetString చివరి భాగం చదివి ఉంటే,
మళ్ళీ ఇక్కడ ప్రతి లైన్ understanding నేడు అంత ముఖ్యమైనది కాదు.
కానీ చివరికి మళ్ళీ malloc కాల్స్ అని గుర్తించలేకపోతే, మరియు అది కేటాయించుకునే
అది స్ట్రింగ్ కోసం అనేక బైట్లు కావాలి వంటి ఖచ్చితంగా
మరియు తర్వాత అతి భారీ బఫర్, ఉచిత కాల్ దూరంగా విసురుతాడు
ఇది నిజంగానే చాలా సార్లు రెట్టింపు వస్తే.
చిన్న లో, ఆ GetString ఈ సమయంలో పని చేస్తుంది ఎలా.
అది మళ్లీ మళ్లీ మళ్లీ ఒకసారి ఒక పాత్ర చదవబడుతుంది
మరియు అది కొన్ని అదనపు మెమరీ అవసరం ప్రతిసారీ, ఇది realloc కాల్ దాని కోసం ఆపరేటింగ్ సిస్టమ్ అడుగుతుంది.
ఏదైనా ప్రశ్నలు? అన్ని కుడి.
>> దాడి. మేము గమనికలు అర్థం ఇప్పుడు ఆ, లేదా కనీసం
, గమనికలు విపరీతంగా తెలిసిన
మొత్తం ప్రపంచం కూలిపోయింది మొదలవుతుంది ఎలా భావిస్తారు తెలియజేయండి
మీరు చాలా పటిష్టమయిన వినియోగదారులు ఎదుర్కోవటానికి లేకపోతే,
మీ వ్యవస్థ హాక్ ప్రయత్నిస్తున్న వ్యక్తులు.
కొన్ని నమోదు కోడ్ అధిగమిస్తూ ద్వారా మీ సాఫ్ట్వేర్ దొంగిలించడానికి ప్రయత్నించిన వ్యక్తులు
వారు సైన్ టైప్ చూపించే
కేవలం సి కోడ్ ఇది ఇక్కడ ఈ ఉదాహరణ గమనించండి
ఆ దిగువన ప్రధాన విధిగా కలిగి, ఆ, ఒక ఫంక్షన్ foo కాల్స్
మరియు అది foo కు అక్కడ ఉన్న? [స్టూడెంట్] ఒక వాదన.
>> సింగిల్ వాదన. కాబట్టి argv [1], ఇది వినియోగదారు టైప్ మొదటి పదం అర్థం
a.out లేదా ఎలాగైనా తర్వాత కమాండ్ లైన్ వద్ద కార్యక్రమం.
Foo కాబట్టి, ఎగువన, ఒక చార్ * లో జరుగుతుంది, కానీ చార్ * కేవలం ఏమిటి?
స్ట్రింగ్. అక్కడ కొత్త ఏమీ ఇక్కడ, మరియు ఆ స్ట్రింగ్ ఏకపక్ష బార్ అని ఉంది.
ఇక్కడ ఈ లైన్ లో చార్ సి [12], సెమీ సాంకేతిక ఆంగ్ల విధమైన లో, ఈ లైన్ ఏమి ఉంది?
అర్రే -? అక్షరాలు. నాకు 12 అక్షరాలు యొక్క వ్యూహం ఇవ్వండి.
కాబట్టి మేము ఈ ఒక బఫర్ కాల్ ఉండవచ్చు. ఇది సాంకేతికంగా సి అని, కానీ ప్రోగ్రామింగ్ ఒక బఫర్ యొక్క
కేవలం మీరు కొన్ని విషయాలను సైన్ ఉంచవచ్చు ఆ స్థలాన్ని కొంత అర్థం
>> అప్పుడు చివరగా, memcpy, మేము ముందు ఉపయోగిస్తారు చెయ్యలేదు.
కానీ మీరు బహుశా దీన్ని ఏమి అంచనా. ఇది మెమరీ కాపీ చేస్తుంది.
ఇది ఏమి చేస్తుంది? సరే, స్పష్టంగా, సి లోకి, దాని ఇన్పుట్, బార్ కాపీ
కానీ మాత్రమే బార్ యొక్క పొడవు.
కానీ ఇక్కడ ఒక బగ్ ఉంది.
సరే, సాంకేతికంగా మేము నిజంగా (బార్) సరైన అని x sizeof (చార్), strlen చెయ్యాలి.
కానీ ఇక్కడ చెత్త సందర్భంలో, ఆ యొక్క that's ఊహించుకోవటం తెలియజేయండి - కాబట్టి, సరే.
అప్పుడు 2 దోషాలు ఉన్నాయి. కాబట్టి sizeof (చార్), హక్కు, యొక్క ఈ చిన్న విస్తృత తయారు చేద్దాము.
కాబట్టి ఇప్పుడు ఏమి ఉంది బగ్, ఇప్పటికీ ఉంది?
[స్టూడెంట్ సమాధానం, అపారదర్శక] దానికి >> చెక్? సరే, మేము తనిఖీ చేయాలి
NULL కోసం, మీ పాయింటర్ NULL ఉన్నప్పుడు చెడు విషయాల జరిగే ఎందుకంటే,
మీరు అక్కడ వెళ్ళటం ముగింపు పరిష్కారాలను, మరియు మీరు శూన్య వెళ్ళి చేయకూడదు ఎందుకంటే
* ఆపరేటర్లు తో dereferencing ద్వారా.
కాబట్టి మంచి, మరియు మేము ఏమి చేస్తున్నారు? తార్కికంగా ఒక దోషం చాలా ఇక్కడ ఉంది.
[స్టూడెంట్ సమాధానం, అపారదర్శక]
>> చేసుకుంటూ ఉంటే argc ≥ 2 తనిఖీ?
సరే, ఈ కార్యక్రమంలో 3 దోషాలు ఇక్కడ ఉంది కాబట్టి.
యూజర్ వాస్తవానికి argv [1], మంచి లోకి ఏదైనా టైప్ మేము తనిఖీ లేదు.
కాబట్టి మూడవ బగ్ ఏది? Yeah?
గుడ్ [స్టూడెంట్ సమాధానం, అపారదర్శక] >>.
కాబట్టి మేము ఒక దృష్టాంతంలో తనిఖీ. మేము పరిపూర్ణంగా అధిక మెమరీ కాపీ లేదు తనిఖీ
బార్ యొక్క పొడవు మించిపోతుంది కంటే.
కాబట్టి స్ట్రింగ్ ఉంటే టైప్ యూజర్ 10 అక్షరాలు,
ఈ 'మాత్రమే 10 అక్షరాలు కాపీ.', అని
మరియు సరే, కానీ ఏం ప్రాంప్టులో పదం టైప్ యూజర్
ఒక 20 పాత్ర పదం వంటి; ఈ విధంగా బార్ నుండి కాపీ 20 అక్షరాలు మాట్లాడుతూ, ఉంది?
లేకపోతే మా బఫర్ అని పిలుస్తారు సి, ఇది మీరు డేటా రాశారు అర్థం
మీరు స్వంతం కాని 8 బైట్ స్థానాలకు,
మరియు మీరు వాటిని కేటాయించింది ఎప్పుడూ కోణంలో వాటిని కలిగి లేదు.
కాబట్టి ఈ సాధారణంగా బఫర్ ఓవర్ఫ్లో దాడి గా పిలిచే ఏమిటి
కోణంలో లేదా బఫర్ ఆక్రమిత దాడి, మరియు అది దాడి చేసే వినియోగదారు
లేదా మీ చర్యను కాల్ చేసే కార్యక్రమం, హానికరమైన ఈ చేస్తోంది
ఏ వాస్తవానికి తదుపరి చాలా చెడ్డ ఉంటుంది జరుగుతుంది.
>> యొక్క ఇక్కడ ఈ చిత్రాన్ని చూసి లెట్.
ఈ చిత్రం మెమరీ మీ స్టాక్ సూచిస్తుంది.
మరియు, ప్రతిసారీ మీరు ఒక ఫంక్షన్ కాల్ గుర్తుచేసుకున్నారు
మీరు స్టాక్ ఈ చిన్న Frame పొందండి మరియు వేరొక మరియు వేరొక మరియు వేరొక.
మరియు ఇప్పటివరకు మేము కేవలం రకమైన మీరు దీర్ఘ చతురస్రాలు ఈ దూరంగా సంక్షిప్తమైన
అక్కడ బోర్డులో లేదా ఇక్కడ తెరపై గాని.
కానీ మేము ఆ దీర్ఘ చతురస్రాలు ఒక దగ్గరికి జూమ్ ఉంటే,
మీరు ఒక ఫంక్షన్ foo కాల్, అది మరింత స్టాక్ న అక్కడ అవుతుంది
ఆ ఫ్రేమ్ మరియు ఆ దీర్ఘ చతురస్రం యొక్క లోపల
కంటే మేము swap గురించి మాట్లాడటం లేదు మాదిరిగా x మరియు y మరియు a మరియు b.
ఇది కొన్ని తక్కువ స్థాయి వివరాలు ఉన్నాయి అవుతుంది
వాటిలో చిరునామా తిరిగి.
ప్రధాన foo కాల్స్ కనుక అది అవుతుంది, ప్రధాన foo సమాచారం ఉంటుంది
కంప్యూటర్ యొక్క మెమరీ లో ఏం ప్రధాన యొక్క చిరునామా.
లేకపోతే కనుక, వెంటనే foo వంటి, ఇక్కడ ఈ సందర్భంలో, అమలు చేయబడుతుంది
ఒకసారి మీరు, foo చివరిలో ఈ దగ్గరి వంకర కలుపు చేరుకోవడానికి
కార్యక్రమం యొక్క నియంత్రణను పడతాయని భావించబడుతోంది కౌంటీ ఎలా హెక్ foo తెలుసా?
ఇది ఆ ప్రశ్నకు సమాధానం ఇక్కడ ఎరుపు దీర్ఘ చతురస్రం లో అని అవుతుంది.
, ఈ ఒక పాయింటర్ సూచిస్తుంది, మరియు ఇది తాత్కాలికంగా నిల్వ చేయడానికి కంప్యూటర్ ఇష్టం
అని పిలవబడే స్టాక్ న తద్వారా వెంటనే foo వంటి ప్రధాన యొక్క చిరునామా అమలు చేయబడుతుంది,
కంప్యూటర్ పేరు మరియు వెళ్ళడానికి ప్రధాన లో ఏం లైన్ తెలుసు.
సేవ్ ఫ్రేమ్ పాయింటర్ ఈ సమానంగా సంబంధం.
ఇక్కడ చార్ * బార్ ఏమి సూచిస్తుంది?
Well, ఇప్పుడు ఈ నీలం విభాగంలో ఇక్కడ foo యొక్క ఫ్రేమ్, బార్ ఏమిటి?
సరే, బార్ foo ఫంక్షన్ కేవలం వాదన ఉంది.
>> కాబట్టి ఇప్పుడు మేము తెలిసిన చిత్రాన్ని తిరిగి ఉన్నారు.
స్క్రీన్ పై ఎక్కువ అంశాలను మరియు మరింత శుద్ధ ఉన్నాయి
కానీ ఈ లేత నీలం విభాగంలో మేము swap వంటి వాటి కోసం సుద్ద బోర్డ్ పై చిత్రించడం చేసిన ఏమిటి.
ఆ, బార్ ఇప్పుడు foo కోసం ఫ్రేమ్ మరియు అది మాత్రమే విషయం
ఈ పారామితి ఉంది.
కానీ ఏమి ఇక్కడ ఈ కోడ్ ప్రకారం, స్టాక్ ఉండాలి?
చార్ సి [12]. కాబట్టి మేము కూడా, జ్ఞాపకశక్తి యొక్క 12 చతురస్రాలు చూస్తారు
సి అనే వేరియబుల్ కు కేటాయించింది.
నిజానికి మేము తెరపై ఆ ఉన్నాయి.
చాలా టాప్ ఉంది సి [0] ఈ చిత్రం యొక్క, మరియు అప్పుడు రచయిత
చతురస్రాలు అన్ని గీయడం కష్టం అయితే 12 నిజంగానే ఉన్నాయి లేదు
ఎందుకంటే మీరు కుడి దిగువన చూడండి ఉంటే, సి [11], మీరు 0 నుండి COUNT ఉంటే, 12 అటువంటి బైట్లు.
కానీ ఇక్కడ సమస్య: ఇది దిశలో సి పెరుగుతోంది?
డౌన్ టాప్ క్రమీకరించు, కుడి? ఇది టాప్ మొదలవుతుంది మరియు దిగువ పెరుగుతాయి,
మేము అన్ని వద్ద ఇక్కడ మేమే చాలా రన్వే వదిలి వలె కనిపించడం లేదు.
మేము రకమైన, ఒక మూలలో మేమే పెయింట్ చేసిన
మరియు ఆ C [11] స్టాక్ ఫ్రేమ్ పాయింటర్ వ్యతిరేకంగా హక్కు ఉంది దీనిలో బార్ పై కుడి అప్,
ఇది తిరిగి చిరునామా వ్యతిరేకంగా హక్కు ఉంది; దీనిలో ఖాళీ లేదు.
మీరు అప్ మేకు చేస్తే అంత, అప్పుడు, ఏది
మరియు మీరు ఒక 12-బైట్ బఫర్ లోకి 20 బైట్లు reading ప్రయత్నించండి?
ఎక్కడ ఆ 8 అదనపు బైట్లు వెళ్ళడానికి వెళ్తున్నారు?
మిగతా వాటి లోపల, వీటిలో కొన్ని ముఖ్యమైన సూపర్ ఉంది.
మరియు అతి ముఖ్యమైన విషయం, సమర్థవంతంగా, అక్కడ తిరిగి చిరునామా ఎరుపు బాక్స్ ఉంది.
మీరు అనుకోకుండా లేదా adversarially అని అనుకుందాం ఎందుకంటే
ఆ 4 బైట్లు, ఆ పాయింటర్ చిరునామా, తిరిగి రాస్తుంది
కేవలం చెత్త తో, కాని మెమొరీ ఒక నిజమైన చిరునామా చేసేట్టు అనేక?
తార్కికంగా implicaiton, ఏమిటి?
[స్టూడెంట్ సమాధానాలు, అపారదర్శక] >> ఖచ్చితంగా. Foo వచ్చినప్పడు
మరియు విజయవంతమైన వంకర కలుపు ఆ కార్యక్రమం, ప్రధాన తిరిగి ముందుకు అన్నారు
ఆ ఎరుపు బాక్స్ లో ఉండే వస్తువు చిరునామా తిరిగి వెళుతున్న.
>> ఇప్పుడు, మోసపూరిత సాఫ్ట్వేర్ నమోదు విషయంలో,
కు తిరిగి చేసే చిరునామా ఏమిటి ఉంది
సాధారణంగా మీరు సాఫ్ట్వేర్ చెల్లించిన తర్వాత అని మరియు మీ నమోదు కోడ్ ఇన్పుట్ పొందే?
మీరు ఇక్కడ వెళ్ళడం లేదు లోకి ట్రిక్ కంప్యూటర్ యొక్క క్రమం, కానీ బదులుగా, ఇక్కడ వెళ్లి పోయింది.
మీరు నిజంగా తెలివైన అయితే లేదా,, శత్రువులు నిజానికి, కీబోర్డ్ లో టైప్ చేయగలరు
ఉదాహరణకు, వాస్తవ పదం, కాదు 20 అక్షరాలు, కాని అనుకుందాం అతను లేదా ఆమె
కోడ్ ప్రాతినిధ్యం కొన్ని అక్షరాలు టైప్?
మరియు అది సి కోడ్ మాత్రం కాదు, అది అక్షరాలు చేస్తాడు
ఆ బైనరీ యంత్రం సంకేతాలు, 0 మరియు 1 యొక్క సూచిస్తాయి.
కానీ వారు ఏదో GetString ప్రాంప్ట్ లోకి పేస్ట్, ఆ విధంగా చేయడానికి అంత తెలివైన ఉన్నారు అనుకుందాం
ముఖ్యంగా కోడ్ కంపైల్ విధి,
మరియు గత 4 బైట్లు ఆ తిరిగి చిరునామా తిరిగి రాస్తుంది, మరియు ఆ ఇన్పుట్ ఏమి చిరునామా చేస్తుంది?
ఈ Red దీర్ఘ చతురస్రం బఫర్ యొక్క మొదటి బైట్ యొక్క చిరునామా లో నిల్వ చేస్తుంది.
కాబట్టి మీరు నిజంగా తెలివైన ఉండాలి, మరియు ఈ విచారణ మరియు లోపం చాలా ఉంది
చెడు అక్కడ ప్రజలు, కానీ మీరు ఈ బఫర్ ఎంత పెద్ద గుర్తించడానికి ఇస్తే, కోసం
మీరు ప్రోగ్రామ్ ఇన్పుట్ లో గత కొన్ని బైట్లు అందించే అలాంటి
మీ బఫర్ యొక్క ప్రారంభ చిరునామా సమానం కావడం,
మీరు చేయవచ్చు. మేము చెప్పుకోవాలంటే, సాధారణంగా, హలో, మరియు \ 0, ఆ బఫర్ లో ముగుస్తుంది ఏమిటి.
కానీ మాకు మరింత తెలివైన ఉన్నాము, మరియు మేము సామాన్యముగా దాడి కోడ్ పిలుస్తాను ఏమి ఆ బఫర్ పూర్తి ఉంటే,
ఎ, ఎ, ఏ, A: ఎటాక్, దాడి, దాడి, దాడి, ఇది చెడు ఏదో చేసే ఏదో ఉంటుంది.
Well, మీరు నిజంగా తెలివైన, మీరు దీన్ని ఉండవచ్చు జరుగుతుంది:
80, CO, 35, 08: ఇక్కడ ఎరుపు బాక్స్ లో సంఖ్యల వరుస ఉంది.
ఆ ఇక్కడ ఆ సంఖ్య సరిపోయే గమనించండి.
ఇది రివర్స్ క్రమంలో, కానీ కొన్ని ఇతర సమయం ఎక్కువ.
ఈ తిరిగి చిరునామా కావాలనే మార్పు అని గమనించండి
ఇక్కడ చిరునామా అప్ సమం, ప్రధాన కాదు చిరునామా.
చెడు వ్యక్తి సూపర్ స్మార్ట్ కాబట్టి, అతను లేదా ఆమె ఆ దాడి కోడ్ ఉన్నాయి అన్నారు
ఏదో వంటి 'యూజర్ యొక్క ఫైళ్లు అన్ని తొలగించు.'
లేదా 'నేను లాగిన్ ఒక వినియోగ ఖాతా సృష్టించుకోండి.' ', పాస్వర్డ్లను కాపీ' లేదా
అన్ని వద్ద ఏదైనా; మరియు ఈ ప్రమాదంలో మరియు C. యొక్క శక్తి రెండూ
మీరు గమనికలు ద్వారా మెమరీ ప్రాప్తి ఎందుకంటే
మరియు మీరు కాబట్టి మీరు ఒక కంప్యూటర్ యొక్క మెమరీ లోనికి కావలసిన ఏదైనా వ్రాయవచ్చు.
మీరు కంప్యూటర్ కేవలం మీరు ఏదైనా చే చేయవచ్చు
తన సొంత మెమరీ ఖాళీలో చుట్టూ జంప్ అయ్యారు.
కాబట్టి, ఈ రోజు, అనేక కార్యక్రమాలు మరియు రాజీ చాలా చాలా వెబ్ సైట్లు
ఈ యొక్క ప్రయోజనాన్ని ప్రజలకు డౌన్ పొంగు.
మరియు ఈ, సూపర్ ఆధునిక దాడులను వంటి కనిపిస్తుంది ఉండవచ్చు
కానీ ఎప్పుడూ విధంగా మొదలు లేదు.
>> రియాలిటీ, ఏ చెడ్డ వ్యక్తులు సాధారణంగా చేస్తుంది ఉంటుంది
అది ఒక కమాండ్ లైన్ వద్ద ఒక కార్యక్రమం లేదా ఒక GUI ప్రోగ్రామ్ లేదా ఒక వెబ్సైట్, అయినా
మీరు అర్ధంలేని అందించడం మొదలు ఉంది.
మీరు, అన్వేషణ రంగంలో మరియు విజయవంతమైన ఎంటర్ ఒక నిజంగా పెద్ద పదం టైప్
మరియు మీరు వెబ్సైట్ క్రాష్ చూడడానికి వేచి.
లేదా మీరు ప్రోగ్రామ్ కొన్ని దోష సందేశం విశదపరుస్తుంది ఉంటే చూడటానికి వేచి.
మీరు లక్కీ వస్తే, ఎందుకంటే చెడ్డ వ్యక్తి,
మరియు మీరు, ప్రోగ్రామ్ కూలిపోతుంది కొన్ని క్రేజీ ఇన్పుట్ను అందించాలి
ఆ ప్రోగ్రామర్ మీ ప్రవర్తనను ముందుగా లేదు అంటే
ఇది తగినంత కృషి తో, మీరు బహుశా దీని అర్థం
తగినంత విచారణ మరియు లోపం, మరింత ఖచ్చితమైన దాడి వేతనాన్ని ఎలా పూర్తి చేయాలో అంచనా.
భద్రత కనుక చాలా భాగం కేవలం మొత్తంగా ఈ దాడులు తప్పించుకోవడం, కానీ వాటిని గుర్తించడం లేదు
మరియు వాస్తవానికి లాగ్లను చూడటం మరియు క్రేజీ ఇన్పుట్లను మీ వెబ్సైట్లో టైప్ ప్రజలు ఏమి చూసిన.
ఏ శోధన పదాలు కొన్ని బఫర్ పొంగిప్రవహిస్తున్న ఆశతో మీ వెబ్సైట్లో ప్రజలు టైప్ చేసిన తర్వాత?
మరియు వ్యూహం ఏది సాధారణ బేసిక్స్ ఈ అన్ని దిమ్మల డౌన్,
మరియు అది మెమరీని కేటాయించాల్సిన మరియు ఉపయోగించడానికి శతకము
మరియు ఆ సంబంధించిన కూడా ఉంటుంది.
>> కాబట్టి ఇంకా మళ్లీ హార్డు డ్రైవు యొక్క లోపల మెరుపు యొక్క అనుమతిస్తాయి.
కాబట్టి మీరు రీకాల్ ఒక వారం లేదా రెండు క్రితం నుండి మీరు ఫైళ్ళను డ్రాగ్ ఉన్నప్పుడు
మీ రీసైకిల్ బిన్ లేదా ట్రాష్ కెన్, ఏమి జరుగుతుంది?
[స్టూడెంట్] ఏమీ లేదు. >> అవును, ఖచ్చితంగా ఏమీ. మీరు తక్కువ రన్ చివరికి ఉంటే
డిస్క్ స్థలం మీద, Windows లేదా Mac OS మీరు ఫైళ్ళను తొలగించడంలో ప్రారంభమౌతుంది.
మీరు అక్కడ ఏదో డ్రాగ్ అయితే, అది సురక్షితమైన అన్ని వద్ద కాదు.
మీ roomate, స్నేహితుడు లేదా కుటుంబ సభ్యుడు చేయాలి డబుల్ క్లిక్ చేయండి, మరియు voila ఉంది.
మీరు తొలగించాలనుకుంటున్నారా ప్రయత్నించిన అన్ని నమూనాలను ఫైళ్లు ఉన్నాయి.
మాకు చాలా కాబట్టి కనీసం మీరు కుడి క్లిక్ చేయండి లేదా క్లిక్ నియంత్రించడానికి ఉందని మీకు
మరియు ఖాళీ ట్రాష్, లేదా అలాంటిదే.
అయితే అప్పుడు, అది చాలా ట్రిక్ విధంగా లేదు.
మీరు మీ హార్డు డ్రైవు ఒక ఫైలుని కలిగి ఏమి జరుగుతుంది ఎందుకంటే
కొన్ని పదం పత్రం లేదా కొన్ని JPEG సూచిస్తుంది?
మరియు, ఈ మీ హార్డు డ్రైవు సూచిస్తుంది, మరియు లెట్స్ ఇక్కడ ఈ అంశం గురించి ఆలోచించారు ఫైల్ సూచిస్తుంది సే
మరియు అది 0 మరియు 1 యొక్క మొత్తం బంచ్ కలిగివుంటుంది.
మీరు మాత్రమే trashcan లేదా రీసైకిల్ బిన్ ఆ ఫైల్ డ్రాగ్ లేదు ఏమి, జరిగినప్పుడు
కానీ ఖాళీ?
ఏమీ అబ్బాయి. ఇది ఇప్పుడు పూర్తిగా ఏమీ కాదు.
కొంచెం ఈ పట్టిక రూపంలో జరుగుతుంది ఎందుకంటే ఇప్పుడు అది కేవలం ఏమీ ఉంది.
కాబట్టి ఒక కంప్యూటర్ యొక్క మెమరీ లోపల డేటాబేస్ లేదా పట్టిక యొక్క రకమైన లేదు
ఆ ముఖ్యంగా, ఫైళ్లు పేర్లు 1 కాలమ్
మరియు ఈ నగర 123, కేవలం ఒక యాదృచ్చిక సంఖ్య కావచ్చు ఫైల్ను యొక్క స్థానాన్ని, 1 కాలమ్.
కాబట్టి మేము x.jpg లాగ, మరియు నగర 123 ఉండవచ్చు.
మీరు మీ ట్రాష్ను ఖాళీ సమయంలో ఏది తర్వాత జరుగుతుంది?
దూరంగా వెళ్ళే. కాని దూరంగా వెళ్ళి లేదు 0 మరియు 1 యొక్క ఉంటుంది.
>> సో వాట్, అప్పుడు, కనెక్షన్ 4 pset చెయ్యాలో?
Well, pset 4 తో, మేము అనుకోకుండా మాసిపోయిన చేసిన కనుక
ఈ ఫోటోలు అన్ని ఉందని కాంపాక్ట్ ఫ్లాష్ కార్డ్,
లేదా చెడు అదృష్టం అది పాడైన మారింది, ఎందుకంటే
0 మరియు 1 యొక్క ఇప్పటికీ అక్కడ లేని కాదు.
ఏదో పాడైన కాబట్టి బహుశా వాటిలో కొన్ని పోతాయి
కొన్ని 0 యొక్క 1 మరియు 1 యొక్క మారింది కోణంలో 0 యొక్క మారింది.
బగ్గీ సాఫ్ట్వేర్ లేదా హార్డ్వేర్ లోపాలు కారణంగా బాడ్ థింగ్స్ జరుగుతుంది.
కానీ ఆ బైట్ల అనేక, బహుశా వాటిని కూడా 100%, ఇప్పటికీ
అది JPEG 1 ప్రారంభించారు కంప్యూటర్ లేదా కెమెరా తెలియదని కేవలం యొక్క
మరియు JPEG 2 ప్రారంభించారు, కాని మీరు, ప్రోగ్రామర్,
ఆ JPEGs లేదా వారు వంటి చూడవచ్చు పేరు అవగాహన ఒక బిట్ తో, తెలిసిన,
మీరు 0 మరియు 1 యొక్క విశ్లేషించేందుకు మరియు Ooh ', చెప్పగలదు. JPEG. , JPEG Ooh. '
మీరు తప్పనిసరిగా ఒక కోసం ఒక ప్రోగ్రామ్ను రాయడం లేదా అయితే లూప్
ఆ ఫైళ్ళను ప్రతి ఒక కోలుకుంటుంది.
పాఠం తరువాత, "సురక్షితంగా" మీ ఫైళ్ళను erasing ప్రారంభించడానికి ఉంటుంది
మీరు పూర్తిగా ఈ నివారించడానికి చెయ్యాలనుకుంటే. అవును?
[స్టూడెంట్ ప్రశ్న, అపారదర్శక]
>> మీరు ముందు కన్నా ఎక్కువ మెమొరి -
ఓహ్! ప్రశ్న గుడ్. ఎందుకు, అప్పుడు, ట్రాష్ ను ఖాళీ తర్వాత,
మీ కంప్యూటర్ మీరు ముందు కన్నా ఎక్కువ ఖాళీని కలిగి మీరు చెప్పండి లేదు?
క్లుప్తంగా, అది అబద్ధం ఎందుకంటే. సాంకేతికంగా, మీరు మరింత ఖాళీని కలిగి ఉన్నారా.
ఇప్పుడు మీరు చెప్పారు కాబట్టి ఆ ఫైల్ ఒకప్పుడు పేరు, మీరు ఇతర విషయాలను పెట్టవచ్చు,
కానీ, బిట్స్ దూరంగా వెళ్తున్నారు కాదు
మరియు ఆ బిట్స్ మీ రక్షణ కొరకు, ఉదాహరణకు, అన్ని 0 యొక్క మార్చబడింది ఉంటాయి కాదు.
దీనికి విరుద్ధంగా, మీరు "సురక్షితంగా" చెరిపివేయి ఫైళ్లు, లేదా భౌతికంగా పరికరాన్ని నాశనం ఉంటే,
ఆ నిజంగా ఆ చుట్టూ, కొన్నిసార్లు మాత్రమే మార్గం.
ఎందుకు మేము ఆ సెమీ స్కేరీ గమనిక న విడిచి, మరియు మేము సోమవారం మీరు చూస్తారు.
CS50.TV