1
00:00:00,000 --> 00:00:02,760
[Powered by Google Translate] [వీక్ 5]

2
00:00:02,760 --> 00:00:04,760
[డేవిడ్ J. మలన్, హార్వర్డ్ విశ్వవిద్యాలయం]

3
00:00:04,760 --> 00:00:11,990
[ఈ CS50 ఉంది.] [CS50.TV]

4
00:00:11,990 --> 00:00:17,780
[వుమన్] అతను అబద్ధం ఆడుతున్నారు; గురించి, నాకు తెలియదు.

5
00:00:17,780 --> 00:00:20,300
[ద] కాబట్టి మేము ఏమి తెలుసు?

6
00:00:20,300 --> 00:00:24,120
[వుమన్] 9:15 వద్ద, రే Santoya ATM ఉంది ఆ.

7
00:00:24,120 --> 00:00:27,420
[ద] కాబట్టి ప్రశ్న, అతను 9:16 వద్ద ఏమి చేయబడింది?

8
00:00:27,420 --> 00:00:29,980
[వుమన్] ఏదో వద్ద 9 mm చిత్రీకరణ.

9
00:00:29,980 --> 00:00:31,900
బహుశా తాను స్నిపర్ చూసింది.

10
00:00:31,900 --> 00:00:34,000
[ద] లేదా అతను పని.

11
00:00:34,000 --> 00:00:36,330
[వుమన్] ఆగండి. ఒక తిరిగి వెళ్లండి.

12
00:00:36,330 --> 00:00:38,330
[ద] మీరు ఏమి చూస్తారు?

13
00:00:38,330 --> 00:00:44,520
[♫ ఉత్కంట సంగీతం ♫]

14
00:00:44,520 --> 00:00:48,320
[వుమన్] తన ముఖాన్ని తీసుకురండి. పూర్తి స్క్రీన్.

15
00:00:48,320 --> 00:00:51,230
[ద] అతని అద్దాలు. >> ప్రతిబింబం ఉంది.

16
00:00:51,230 --> 00:01:00,810
[♫ ఉత్కంట సంగీతం ♫]

17
00:01:00,810 --> 00:01:03,580
[ద] ఆ Nuevita యొక్క బేస్బాల్ జట్టు. వారి చిహ్నం యొక్క.

18
00:01:03,580 --> 00:01:07,790
[వుమన్] మరియు అతను ఆ జాకెట్ వేసుకొని చెప్పగలిగితే మాట్లాడుతూ ఉంటాడు.

19
00:01:07,790 --> 00:01:13,730
>> [డేవిడ్ మలన్] కాబట్టి, ఈ CS50 వారం 5, నేటి మేము మీ కోసం టెలివిజన్ మరియు చిత్రం యొక్క బిట్ నాశనం.

20
00:01:13,730 --> 00:01:16,170
కాబట్టి మీరు ఇక్కడ ఇటువంటి ఒక కార్యక్రమం చూస్తున్న చేసినప్పుడు,

21
00:01:16,170 --> 00:01:19,910
మరియు కాప్స్ "మీరు ఆ శుభ్రం కాదు?" అని లేదా "పెంచు,"

22
00:01:19,910 --> 00:01:21,900
వాస్తవ ప్రపంచంలో పెంచడానికి లేదు.

23
00:01:21,900 --> 00:01:25,220
నిజానికి, మీరు నిజంగా పొందండి ఈ వంటి ఒక చిన్న విషయం.

24
00:01:25,220 --> 00:01:27,570
నేను పేజీ నుండి సిబ్బంది ఫోటోలు ఒకటి ఆగింది చేసిన.

25
00:01:27,570 --> 00:01:30,980
ఈ Photoshop అనే ప్రోగ్రామ్. ఈ, 2 Bowdens యొక్క 1

26
00:01:30,980 --> 00:01:36,300
వాస్తవానికి 1 3 Bowdens, నేడు, మేము రాబ్ మరియు పాల్ తో, అలాగే ఇక్కడ శ్రీమతి బౌడెన్ ఎందుకంటే.

27
00:01:36,300 --> 00:01:41,950
కానీ ఇక్కడ తెరపై రాబ్, మరియు అతను ఎప్పుడూ తన కంటికి లో చేసే ప్రకాశం లో మేము జూమ్,

28
00:01:41,950 --> 00:01:47,600
మీరు నిజంగా చూసే మీరు వాట్ యు గెట్ ఉంటుంది.

29
00:01:47,600 --> 00:01:51,690
ఈ ", మెరుగైన" కాబట్టి "CSI" అది ఒక బిట్ తప్పు ఉంది.

30
00:01:51,690 --> 00:01:55,190
మేము కేవలం కొద్దిగా ఎక్కువ "CSI" లో ఎంచుకోవచ్చు ఉంటే మరొక క్లిప్, ఉన్నాయి.

31
00:01:55,190 --> 00:01:58,500
ఇందులో మీ అనుకుంటే ఇకమీదట ఉచ్ఛరించాడు ఒక nice ఫ్రేజ్

32
00:01:58,500 --> 00:02:10,280
నిజంగా, మీరు ఖచ్చితంగా ఏమీ చెప్పడం చేసినప్పుడు, మీ స్నేహితులతో సాంకేతిక శబ్దం.

33
00:02:10,280 --> 00:02:12,970
>> [ద] వారాల పాటు నేను Cabby కిల్లర్ హత్యలు దర్యాప్తు చేసిన

34
00:02:12,970 --> 00:02:15,360
ఒక నిర్దిష్ట వ్యాధిగ్రస్తమైన మోహం తో.

35
00:02:15,360 --> 00:02:17,160
[వుమన్ # 1] ఈ నిజ సమయంలో ఉంది.

36
00:02:17,160 --> 00:02:22,930
[వుమన్ # 2] నేను ఒక IP చిరునామా ట్రాక్ లేదో చూడటానికి, విజువల్ బేసిక్ ఉపయోగించి ఒక GUI ఇంటర్ఫేస్ సృష్టిస్తారు.

37
00:02:22,930 --> 00:02:29,570
>> [మలన్] విజువల్ బేసిక్ ఉపయోగించి ఒక GUI ఇంటర్ఫేస్ సృష్టిస్తుంది పక్కన సమకాలీకరణలో కాబట్టి ఆడియో

38
00:02:29,570 --> 00:02:31,820
ఒక IP చిరునామా ట్రాక్ పూర్తి అర్ధంలేనిది.

39
00:02:31,820 --> 00:02:33,840
ఈ రోజుల్లో మీరు, విజువల్ బేసిక్ ఉపయోగించడానికి కాదు

40
00:02:33,840 --> 00:02:38,920
అక్కడ ఒక GUI అవసరం ఉంది, మరియు IP చిరునామా ఒక సాంకేతికంగా ఖచ్చితమైన పదం.

41
00:02:38,920 --> 00:02:41,730
కాబట్టి ఈ ఒక కన్ను ఉంచేందుకు, మరియు నా అభిమాన:

42
00:02:41,730 --> 00:02:45,070
మీరు వేరే భాష తెలుసుకోవాలి ఎందుకంటే ఈ ఒక, కొంచెం అద్భుత ఉంది.

43
00:02:45,070 --> 00:02:47,860
C. యొక్క సూపర్సెట్గా ఇది ఆబ్జెక్టివ్-C అనే భాష, ఉన్నాయి

44
00:02:47,860 --> 00:02:51,960
ఇది వారికి విషయ ఆధారిత ప్రోగ్రామింగ్ మధ్య దాని సి ప్లస్ కొన్ని అదనపు లక్షణాలు, అర్థం.

45
00:02:51,960 --> 00:02:55,070
మరియు ఈ Apple iOS ప్రోగ్రామింగ్ కోసం తెచ్చారు భాష.

46
00:02:55,070 --> 00:02:58,760
మరియు ఇక్కడ ", సంఖ్యలు" నుండి, పూర్తిగా వేరే కార్యక్రమం నుండి క్లిప్ యొక్క

47
00:02:58,760 --> 00:03:02,450
మీరు నిజంగా కుడి సమయంలో మీ TiVo మరియు విరామం న దగ్గరగా చూస్తే,

48
00:03:02,450 --> 00:03:07,700
మీరు ఏ వారు వద్ద చూస్తున్న చెప్పుకోదగ్గ వర్ణించాడు అంశం అని చూస్తారు.

49
00:03:07,700 --> 00:03:11,170
నాకు ఇక్కడ వేరే ఆడియో కనెక్టర్ ప్రయత్నించండి మరియు మేము పోతే చూడటానికి

50
00:03:11,170 --> 00:03:13,780
సమకాలీకరణ లో ఆడియో ఈ సమయాన్ని కలిగివుండుటకు.

51
00:03:13,780 --> 00:03:20,530
నేను "సంఖ్యలు." మీరు ఇవ్వాలని

52
00:03:20,530 --> 00:03:23,240
>> [ద # 1] ఇది ఒక 32-bit IPv4 చిరునామా ఉంది.

53
00:03:23,240 --> 00:03:38,930
[ద # 2] IP, ఆ ఇంటర్నెట్. >> ప్రైవేట్ నెట్వర్క్. ఇది అనిత యొక్క ప్రైవేట్ నెట్వర్క్.

54
00:03:38,930 --> 00:03:43,810
[మలన్] సరే. , ఈ ఆబ్జెక్టివ్-C, మరియు ఇది కొన్ని కిడ్ యొక్క రంగు కార్యక్రమం కోసం యొక్క

55
00:03:43,810 --> 00:03:51,140
మీరు బహుశా అక్కడ వేరియబుల్ యొక్క పేరు నుండి ప్రతిపాదించే చేయవచ్చు.

56
00:03:51,140 --> 00:03:54,410
కాబట్టి, తర్వాత, "సంఖ్యలు" గా చెప్పవచ్చు. మేము పరిచయం నేడు మరియు ఈ వారం కాబట్టి

57
00:03:54,410 --> 00:03:57,740
ఫోరెన్సిక్స్ మరియు అందువలన సమస్యలు సందర్భంలో ప్రపంచం యొక్క కొద్దిగా.

58
00:03:57,740 --> 00:04:00,590
ఇక్కడ ఒక ప్రత్యేక సంఘటన ఉంది ఎందుకంటే ఈ రోజు ఒక సంక్షిప్త ప్రసంగం ఉంటుంది

59
00:04:00,590 --> 00:04:05,530
తరువాత, కాబట్టి మేము విద్యార్థులు మరియు అలైక్ తల్లిదండ్రులు నేడు రెండు పరికించండి, మరియు బాధించటం చేస్తాము

60
00:04:05,530 --> 00:04:07,420
హోరిజోన్ మీద ఉన్న కొన్ని విషయాలు తో.

61
00:04:07,420 --> 00:04:12,240
వాటిలో, సోమవారం నాటికి, మీరు కొన్ని సహ విద్యార్థులను ఉంటుంది.

62
00:04:12,240 --> 00:04:16,050
EdX, హార్వర్డ్ మరియు ఓపెన్ courseware కోసం MITs లైన్ చొరవ

63
00:04:16,050 --> 00:04:19,120
మరియు మరింత, సోమవారం హార్వర్డ్ యొక్క ప్రాంగణంలో ప్రారంభించాయి.

64
00:04:19,120 --> 00:04:21,490
వచ్చి సోమవారం అర్ధం మీరు ఉంటుంది - గత లెక్కింపు యొక్క,

65
00:04:21,490 --> 00:04:26,210
86,000 అదనపు సహ విద్యార్థులను CS50 యొక్క ఉపన్యాసాలు పాటు క్రింది విధంగా కనిపిస్తుంది

66
00:04:26,210 --> 00:04:29,170
మరియు విభాగాలు మరియు పూర్తి వివరణలు మరియు సమస్య సెట్లు.

67
00:04:29,170 --> 00:04:32,350
మరియు ఈ భాగంగా, మీరు ప్రారంభ స్థాయి సభ్యుల అవుతుంది

68
00:04:32,350 --> 00:04:35,090
CS50 మరియు ఇప్పుడు CS50x.

69
00:04:35,090 --> 00:04:39,310
>> ఈ భాగంగా, ఇప్పుడు, అదే కొన్ని చేయబడనపుడు ఉంటుంది అని తెలుసుకోవటం.

70
00:04:39,310 --> 00:04:43,790
విద్యార్ధులు భారీ సంఖ్యలో, ఈ కోసం సిద్ధంగా ఉండటానికి,

71
00:04:43,790 --> 00:04:47,180
చెప్పడానికి అది తగినంత మేము 108 TFS మరియు CA ల లేనప్పటికీ,

72
00:04:47,180 --> 00:04:50,790
కాదు చాలా ఉత్తమ విద్యార్థి / గురువు నిష్పత్తి మేము 80,000 ఇతర విద్యార్థులు హిట్ ఒకసారి.

73
00:04:50,790 --> 00:04:52,850
కాబట్టి మేము చాలా సమస్య శ్రేణి కావడం లేదు మానవీయంగా అమర్చుతుంది.

74
00:04:52,850 --> 00:04:55,920
కాబట్టి సమస్య సెట్ లో ఈ వారం పరిచయం, CS50 చెక్ ఉంటుంది

75
00:04:55,920 --> 00:04:58,450
ఉపకరణం లోపల ఒక కమాండ్ లైన్ యుటిలిటీ మాత్రం ఇది

76
00:04:58,450 --> 00:05:01,200
మీరు ఈ వారాంతంలో తరువాత అప్డేట్ ఒకసారి మీరు పొందుతారు ఆ,

77
00:05:01,200 --> 00:05:03,200
మరియు మీరు ఒక ఆదేశాన్ని చేయగలరు, 50 తనిఖీ

78
00:05:03,200 --> 00:05:06,500
మీ స్వంత pset న, మరియు మీరు మీ కార్యక్రమాన్ని అన్నది కొన్ని చూడు పొందుతారు

79
00:05:06,500 --> 00:05:11,160
సరైన లేదా తప్పు మేము అందించిన వివిధ డిజైన్ లక్షణాలు ప్రకారం.

80
00:05:11,160 --> 00:05:13,580
కాబట్టి ఆ మరింత మరియు సమస్య సెట్ వివరణ మరియు

81
00:05:13,580 --> 00:05:17,240
CS50x సహ విద్యార్థులను కూడా ఈ ఉపయోగించారు.

82
00:05:17,240 --> 00:05:19,230
>> కాబట్టి సమస్య సెట్ 4 ఫోరెన్సిక్స్ గురించి అన్ని ఉంది.

83
00:05:19,230 --> 00:05:21,940
మరియు ఈ భాగాన్ని కొన్ని వాస్తవ విషయాలను ప్రేరణతో

84
00:05:21,940 --> 00:05:24,620
నేను గ్రాడ్యుయేట్ స్కూల్ లో వస్తే, నేను, ఒక సమయంలో కోసం ఖైదు

85
00:05:24,620 --> 00:05:28,650
మిడిల్సెక్స్ కౌంటీ యొక్క జిల్లా అటార్నీ కార్యాలయం ఫోరెన్సిక్ పని

86
00:05:28,650 --> 00:05:31,650
వారి ప్రధాన ఫోరెన్సిక్ పరిశోధకుడిని తో, మరియు ఈ మొత్తం

87
00:05:31,650 --> 00:05:35,260
నేను కొన్ని వారం యొక్క గత పేర్కొన్నారు అనుకుంటున్నాను, మాస్ రాష్ట్ర పోలీస్ లేదా ఇతరులు ఉంది

88
00:05:35,260 --> 00:05:39,000
వస్తాయి, అవి హార్డు డ్రైవులు మరియు CD లు మరియు ఫ్లాపీ డిస్కుల వంటి వాటిని ఆఫ్ పడిపోతాయనే

89
00:05:39,000 --> 00:05:42,340
ఆపై వంటి, మరియు ఫోరెన్సిక్స్ కార్యాలయం గోల్ నిర్ధారించేందుకు అని

90
00:05:42,340 --> 00:05:44,600
ఉంది లేదా కొన్ని రకాల ఆధారాలు కాదు.

91
00:05:44,600 --> 00:05:48,010
, ఈ స్పెషల్ ఇన్వెస్టిగేషన్స్ యూనిట్, అందువలన ఇది వైట్ కాలర్ నేరం ఉంది

92
00:05:48,010 --> 00:05:52,350
అది, నేరాల మరింత ఇబ్బందికర విధమైన ఉంది

93
00:05:52,350 --> 00:05:55,990
డిజిటల్ మీడియా రకమైన పాల్గొన్న ఏదైనా; అవుతుంది కాదు అనేక మంది

94
00:05:55,990 --> 00:05:59,370
చెప్పడం ఇమెయిల్ వ్రాయటం "నేను చేశాడు."

95
00:05:59,370 --> 00:06:03,290
కాబట్టి తరచూ ఈ ఫోరెన్సిక్స్ శోధనలు, అన్ని ఎక్కువ పండు వైపు లేదు

96
00:06:03,290 --> 00:06:05,850
కానీ కొన్నిసార్లు ప్రజలు ఇమెయిళ్ళు రాస్తుంది.

97
00:06:05,850 --> 00:06:08,490
కాబట్టి కొన్నిసార్లు ప్రయత్నాలు దక్కించుకున్నారు.

98
00:06:08,490 --> 00:06:14,420
>> కానీ ఈ ఫోరెన్సిక్ pset దారితీస్తాయి, మేము pset 4 గ్రాఫిక్స్ ఒక బిట్ లో పరిచయం అవుతారు.

99
00:06:14,420 --> 00:06:18,260
కాబట్టి మీరు బహుశా, మంజూరు, JPEGs, GIF లు మరియు ఈ రోజుల్లో వంటి కోసం ఈ విషయాలు పడుతుంది

100
00:06:18,260 --> 00:06:21,640
కానీ మీరు నిజంగా దాని గురించి అనుకుంటే, ఒక చిత్రం, చాలా రాబ్ ముఖం వంటి,

101
00:06:21,640 --> 00:06:24,430
ఒక చుక్కల క్రమం, లేదా పిక్సెళ్ళు వలె తయారు చేయవచ్చు.

102
00:06:24,430 --> 00:06:26,680
ఇప్పుడు, రాబ్ ముఖం యొక్క సందర్భంలో, రంగులు అన్ని రకాల ఉన్నది

103
00:06:26,680 --> 00:06:29,940
మరియు మేము, otherwide పిక్సెళ్ళు అని పిలుస్తారు వ్యక్తి చుక్కలు, చూడండి ప్రారంభించారు

104
00:06:29,940 --> 00:06:31,610
ఒకసారి మేము సైన్ జూమ్ ప్రారంభించారు

105
00:06:31,610 --> 00:06:35,590
కానీ ప్రపంచంలో ఒక బిట్ సులభతరం, మరియు కేవలం ఇక్కడ ఈ రాబ్ అని చెప్పుకోవాలంటే

106
00:06:35,590 --> 00:06:40,560
నలుపు మరియు తెలుపు, బాగా, ప్రాతినిథ్యం నలుపు మరియు తెలుపు మేము బైనరీ ఉపయోగించవచ్చు.

107
00:06:40,560 --> 00:06:44,960
మరియు మేము బైనరీ ఉపయోగించడానికి వెళుతున్న ఉంటే, 1 లేదా 0, మేము ఈ అదే చిత్రం వ్యక్తీకరించవచ్చు

108
00:06:44,960 --> 00:06:51,970
బిట్స్ ఈ నమూనాతో రాబ్ యొక్క నవ్వే ముఖం యొక్క: 11000011 సూచిస్తుంది

109
00:06:51,970 --> 00:06:55,160
తెలుపు, తెలుపు, నలుపు, నలుపు, నలుపు, నలుపు, తెలుపు తెలుపు.

110
00:06:55,160 --> 00:06:59,290
మరియు అందువలన రంగురంగుల ఛాయాచిత్రాలను గురించి మాట్లాడటం మొదలు, అప్పుడు, ఒక భారీ లీపు కాదు.

111
00:06:59,290 --> 00:07:01,920
మీరు Facebook లో చూడండి లేదా ఒక డిజిటల్ కెమెరా తో పడుతుంది థింగ్స్,

112
00:07:01,920 --> 00:07:04,730
కానీ, ఖచ్చితంగా, అది రంగులు విషయానికి వస్తే, మీరు మరింత బిట్స్ అవసరం.

113
00:07:04,730 --> 00:07:08,470
మరియు ఛాయాచిత్రాల ప్రపంచంలో చాలా సాధారణ, 1-bit రంగు ఉపయోగిస్తారు

114
00:07:08,470 --> 00:07:12,730
ఈ సూచించును, అయితే 24-bit రంగు, మీరు నిజంగా రంగులు మిలియన్ల చోటే. వంటి

115
00:07:12,730 --> 00:07:15,430
కాబట్టి మేము రాబ్ యొక్క కంటికి జూమ్ చేసినప్పుడు సందర్భంలో,

116
00:07:15,430 --> 00:07:19,270
వివిధ రంగుల అవకాశాలను మిలియన్ల ఏ సంఖ్య.

117
00:07:19,270 --> 00:07:22,260
>> కాబట్టి మేము, ప్రాబ్లం సెట్ 4 పాటు walkthrough ఈ పరిచయం చేస్తాము

118
00:07:22,260 --> 00:07:27,050
ఎందుకంటే ఇక్కడ శుక్రవారం ఉపన్యాసం యొక్క సాధారణ 2.30 బదులుగా 3:30 వద్ద నేడు అవుతుంది.

119
00:07:27,050 --> 00:07:29,930
కానీ వీడియో, సాధారణ గా, రేపు ఆన్ లైన్ ఉంటుంది.

120
00:07:29,930 --> 00:07:31,880
మేము కూడా మరొక ఫైల్ ఫార్మాట్ మీరు పరిచయం చేస్తాము.

121
00:07:31,880 --> 00:07:34,150
కాబట్టి ఈ ఉద్దేశపూర్వకంగా, మొదటి వద్ద భయపెట్టడం చూడండి ఉద్దేశించబడింది

122
00:07:34,150 --> 00:07:38,980
కానీ ఈ ఒక సి struct కోసం కొన్ని డాక్యుమెంటేషన్ ఉంది.

123
00:07:38,980 --> 00:07:42,280
ఇది Microsoft, సంవత్సరాల క్రితం, ఈ ఫార్మాట్ ప్రసిద్ధం చేసింది ఆ అవుతుంది

124
00:07:42,280 --> 00:07:46,630
Bitmap ఫైల్ ఫార్మాట్, BMP, మరియు ఈ సూపర్ సాధారణ ఉంది, అని

125
00:07:46,630 --> 00:07:50,390
అంతేకాకుండా, తక్కువ సమయంలో ఉపయోగించిన రంగుల గ్రాఫికల్ ఫైల్ ఫార్మాట్

126
00:07:50,390 --> 00:07:53,640
మరియు కొన్నిసార్లు డెస్క్టాప్లు న సంక్రాంతి కోసం.

127
00:07:53,640 --> 00:07:57,410
మీరు Windows XP మరియు కొండలు, నీలి ఆకాశం తిరిగి భావిస్తే,

128
00:07:57,410 --> 00:08:00,660
సాధారణంగా ఒక BMP, లేదా బిట్మ్యాప్ చిత్రం, మరియు బిట్ మ్యాప్ చిత్రాలన్నీ ఉంది

129
00:08:00,660 --> 00:08:03,340
వారు ఒక బిట్ మరింత సంక్లిష్టత ఎందుకంటే మాకు ఆహ్లాదకరమైన.

130
00:08:03,340 --> 00:08:05,640
ఇది 0 మరియు 1 యొక్క ఈ గ్రిడ్ వంటి చాలా సాధారణ కాదు;

131
00:08:05,640 --> 00:08:10,680
బదులుగా, మీరు ఒక ఫైల్ ప్రారంభంలో ఒక శీర్షిక వంటి వాటిని కలిగి ఉంటాయి.

132
00:08:10,680 --> 00:08:15,520
కాబట్టి ఇతర మాటలలో,. BMP ఫైల్ లోపల 0 మరియు 1 యొక్క మొత్తం బంచ్, ఉంది

133
00:08:15,520 --> 00:08:18,070
కానీ కొన్ని అదనపు 0 మరియు 1 యొక్క అక్కడ లో ఉంది.

134
00:08:18,070 --> 00:08:21,450
మరియు ఇది సంవత్సరాల మంజూరు కోసం మనం బహుశా తీసిన చేసిన అవుతుంది

135
00:08:21,450 --> 00:08:27,040
. డిఓసి లేదా. xls లేదా. mp3 లేదా. mp4, వంటి ఫైల్ ఫార్మాట్లు

136
00:08:27,040 --> 00:08:29,910
మీకు తెలిసిన ఆ ఏ ఫైల్ ఫార్మాట్లు.

137
00:08:29,910 --> 00:08:31,900
Well, దానిని కూడా ఒక ఫైల్ ఫార్మాట్ అని శతకము

138
00:08:31,900 --> 00:08:35,740
రోజు చివరిలో ఎందుకంటే, మేము ఉపయోగించే ఈ ఫైళ్లు అన్ని కేవలం 0 మరియు 1 యొక్క

139
00:08:35,740 --> 00:08:39,950
మరియు ఇంకా ఆ 0 మరియు 1 యొక్క a, b, c, ASCII లేదా వంటి ద్వారా, ప్రాతినిథ్యం

140
00:08:39,950 --> 00:08:42,030
కానీ రోజు చివరిలో ద్వారా, అది కేవలం 0 మరియు 1 యొక్క ఉంటుంది.

141
00:08:42,030 --> 00:08:45,300
>> కాబట్టి మానవులు కేవలం అప్పుడప్పుడు కొత్త ఫైల్ ఫార్మాట్ కనుగొనడమే నిర్ణయించుకుంటారు

142
00:08:45,300 --> 00:08:49,420
వారు బిట్స్ క్రమాలు వాస్తవానికి ప్రభావితం చేస్తుంది ప్రామాణికంగా పేరు.

143
00:08:49,420 --> 00:08:52,790
మరియు ఇక్కడ ఈ సందర్భంలో, ఫొల్క్స్ Bitmap ఫైల్ ఫార్మాట్ ఆకృతి చేసిన

144
00:08:52,790 --> 00:08:58,260
ఒక Bitmap ఫైల్ లో మొట్టమొదటి బైట్ వద్ద, వంటి ఆఫ్సెట్ 0 చే సూచిస్తారు చెప్పారు, అక్కడ,

145
00:08:58,260 --> 00:09:02,320
కొన్ని cryptically అనే వేరియబుల్ అని bfType, ఉన్నట్లు జరగబోతోంది

146
00:09:02,320 --> 00:09:06,510
ఇది కేవలం Bitmap ఫైల్ రకం కోసం ఉంది; ఏమిటి Bitmap ఫైల్ రకం.

147
00:09:06,510 --> 00:09:10,780
మీరు 2 ఆఫ్సెట్ ఆ రెండవ వరుసలో, బైట్ సంఖ్య 2 నుండి, బహుశా, అనుమానించే చేయవచ్చు

148
00:09:10,780 --> 00:09:15,980
0 మరియు 1 యొక్క ఏమి ప్రాతినిధ్యం ఒక ఆకృతిని కలిగి ఉంటుంది?

149
00:09:15,980 --> 00:09:18,320
ఏదో యొక్క పరిమాణం, మరియు అది అక్కడి నుండి వెళ్లి.

150
00:09:18,320 --> 00:09:20,660
కాబట్టి సమస్య సెట్ 4 లో, మీరు ఈ విషయాలు కొన్ని సంచరించింది వస్తారు.

151
00:09:20,660 --> 00:09:24,480
>> మేము వాటిని అన్ని గురించి caring ముగుస్తుంది, కాని గుర్తించరు అది ఆసక్తికరమైన పొందడానికి మొదలవుతుంది

152
00:09:24,480 --> 00:09:30,780
గీత లేదా బైట్ 54, rgbtBlue, ఆకుపచ్చ మరియు ఎరుపు చుట్టూ.

153
00:09:30,780 --> 00:09:35,280
మీరు ఎక్రోనిం RGB, ఎరుపు, ఆకుపచ్చ నీలం విన్న చేసిన ఉంటే, ఇది ఒక సూచన.

154
00:09:35,280 --> 00:09:37,840
అది అవుతుంది ఎందుకంటే మీరు ఇంద్రధనుస్సు రంగులు అన్ని చిత్రీకరించాడు

155
00:09:37,840 --> 00:09:41,580
ఎరుపు మరియు నీలం మరియు ఆకుపచ్చ కొన్ని కలిపి.

156
00:09:41,580 --> 00:09:46,560
మరియు, నిజానికి, గదిలో తల్లిదండ్రులు ప్రారంభ ప్రొజెక్టర్లు కొన్ని గుర్తు ఉండవచ్చు.

157
00:09:46,560 --> 00:09:49,360
ఈ రోజుల్లో, మీరు 1 ప్రకాశవంతమైన కాంతి ఒక కటకాల రావడం చూడండి.

158
00:09:49,360 --> 00:09:52,870
అయితే తన రోజు, మీరు Red లెన్స్, నీలం లెన్స్, మరియు ఆకుపచ్చ లెన్స్ కలిగి

159
00:09:52,870 --> 00:09:56,620
మరియు కలిసి వారు తెర లక్ష్యంగా మరియు ఒక రంగుల చిత్రాన్ని ఏర్పాటు.

160
00:09:56,620 --> 00:09:59,590
మరియు తరచూ మధ్య పాఠశాలలు మరియు ఉన్నత పాఠశాలలు ఆ కటకములు ఉంటుంది

161
00:09:59,590 --> 00:10:02,680
నిరంతరం విధంగా కొద్దిగా వంకరగా, కాబట్టి మీరు, డబుల్ లేదా ట్రిపుల్ చిత్రాలు చూసిన యొక్క విధమైన

162
00:10:02,680 --> 00:10:07,500
కానీ ఆ ఆలోచన. మీరు ఒక చిత్రాన్ని పెయింట్ ఎరుపు మరియు ఆకుపచ్చ మరియు నీలం కాంతి కలిగి.

163
00:10:07,500 --> 00:10:09,570
అదే సూత్రాన్ని కంప్యూటర్లు ఉపయోగిస్తారు.

164
00:10:09,570 --> 00:10:12,000
>> కాబట్టి సవాళ్లు మధ్య, అప్పుడు, మీరు సమస్య 4 సెట్

165
00:10:12,000 --> 00:10:16,080
కొన్ని అంశాలను వెళ్తున్నారు; ఒక నిజానికి ఒక చిత్రం పరిమాణాన్ని చెప్పవచ్చు.

166
00:10:16,080 --> 00:10:18,050
0 మరియు 1 యొక్క నమూనాలో తీసుకుంటే,

167
00:10:18,050 --> 00:10:22,840
, 0 మరియు 1 యొక్క భాగాలు నిర్మాణంలో ఈ వంటి ప్రాతినిధ్యం ఇది గుర్తించడానికి

168
00:10:22,840 --> 00:10:26,800
రెడ్స్, బ్లూస్, గ్రీన్స్: తరువాత పిక్సెళ్ళు నకలు ఎలా పూర్తి చేయాలో అంచనా

169
00:10:26,800 --> 00:10:32,460
కాబట్టి లోపల ఒక చిత్రాన్ని మొదట ఈ కనిపిస్తోంది, ఆ తర్వాత బదులుగా ఇలా ఉండవచ్చు.

170
00:10:32,460 --> 00:10:35,590
ఇతర సవాళ్ళను మధ్య కూడా మీరు అప్పగించారు వస్తుంది అని అన్నారు

171
00:10:35,590 --> 00:10:38,900
ఒక డిజిటల్ కెమెరా నుండి ఒక నిజమైన ఫైల్ యొక్క ఫోరెన్సిక్ చిత్రం

172
00:10:38,900 --> 00:10:42,410
మరియు ఆ కెమెరా, ఒకసారి ఒక సమయం మీద, ఫోటోలను మొత్తం బంచ్ ఉన్నారు.

173
00:10:42,410 --> 00:10:47,030
సమస్య, మేము అనుకోకుండా మాసిపోయిన లేదా చిత్రం ఏదో పాడైన కలిగి ఉంది.

174
00:10:47,030 --> 00:10:51,040
బాడ్ థింగ్స్ డిజిటల్ కెమెరాలు తో జరిగే, అందువలన మేము త్వరగా 0 మరియు 1 యొక్క అన్ని కాపీ

175
00:10:51,040 --> 00:10:55,410
ఆఫ్ మీరు ఆ కార్డు యొక్క, 1 పెద్ద ఫైలు వాటిని సేవ్, మరియు అప్పుడు మీరు వారిని చేతితో చేస్తాము

176
00:10:55,410 --> 00:11:00,000
మీరు తిరిగి తో సి లో ఒక ప్రోగ్రామ్ రాయగలగాలి సమస్య 4 సెట్

177
00:11:00,000 --> 00:11:02,660
ఆ JPEGs అన్ని ఆదర్శంగా.

178
00:11:02,660 --> 00:11:06,280
మరియు అది, వారు కొంతవరకు ఒక సంక్లిష్ట ఫైల్ ఆకృతి యొక్క ఉన్నప్పటికీ, ఆ JPEGs అవుతుంది

179
00:11:06,280 --> 00:11:09,580
వారు చాలా క్లిష్టమైన ఇక్కడ ఈ నవ్వే ముఖం కంటే ఉన్నారు.

180
00:11:09,580 --> 00:11:14,320
ప్రతి JPEG 0 మరియు 1 యొక్క మాదిరి తో ప్రారంభమయ్యే అవుతుంది.

181
00:11:14,320 --> 00:11:18,820
కాబట్టి లూప్ లేదా ఇలాంటి కోసం కొంత లూప్ లేదా ఉపయోగించి,

182
00:11:18,820 --> 00:11:22,350
మీరు అన్ని 0 మరియు 1 యొక్క ఈ ఫోరెన్సిక్ చిత్రం లో iterate చేయవచ్చు

183
00:11:22,350 --> 00:11:26,670
మరియు మీరు సమస్య సెట్ యొక్క స్పెసిఫికేషన్ లో నిర్వచించబడింది చేసే ప్రత్యేక నమూనా చూడండి ప్రతి సమయం,

184
00:11:26,670 --> 00:11:29,770
మీరు చాలా ఎక్కువ సంభావ్యత కలిగిన, 'ఓహ్, ఇక్కడ ఉంది, పొందవచ్చు

185
00:11:29,770 --> 00:11:33,520
ఒక JPEG ప్రారంభంలో, 'మరియు వెంటనే మీకు కనుగొనడానికి అదే తీరు

186
00:11:33,520 --> 00:11:36,050
తరువాత బైట్లు లేదా లు లేదా మెగాబైట్ల కొన్ని సంఖ్య,

187
00:11:36,050 --> 00:11:40,550
మీరు Ooh ', పొందవచ్చు! ఇక్కడ రెండవ JPEG, నేను మొదటి ఒక తర్వాత పట్టింది ఫోటో ఉంది.

188
00:11:40,550 --> 00:11:44,720
నాకు ఆ మొదటి ఫైల్ చదవడం ఆపి లెట్, ఈ కొత్త వ్రాయడం ప్రారంభించండి. '

189
00:11:44,720 --> 00:11:49,980
మరియు pset 4 మీ ప్రోగ్రామ్ అవుట్పుట్ చాలా 50 JPEGs అని అన్నారు.

190
00:11:49,980 --> 00:11:52,400
50 JPEGs కాదు ఉంటే, మీరు ఒక లూప్ యొక్క ఒక బిట్ కలిగి ఉంటాయి.

191
00:11:52,400 --> 00:11:55,580
మీరు JPEGs ఒక అనంతమైన ఉంటే, మీరు ఒక అనంతమైన లూప్ ఉన్నాయి.

192
00:11:55,580 --> 00:11:58,280
అందువలన కూడా చాలా సాధారణ విషయం ఉంటుంది.

193
00:11:58,280 --> 00:12:00,280
ఆ క్షితిజాన్ని ఆన్ ఏమిటి.

194
00:12:00,280 --> 00:12:03,740
>> మాకు వెనుక 0 క్విజ్. రియలైజ్, నా ఇమెయిల్ శాతం, ఆ స్థిరముగా ఫొల్క్స్ లేదు

195
00:12:03,740 --> 00:12:06,820
హ్యాపీ, తటస్థ విదంగా మరియు క్విజ్ చుట్టూ విచారంగా 0 రెండు ఉన్నారు.

196
00:12:06,820 --> 00:12:10,160
మరియు తల TFS, Zamyla, మీ స్వంత TF, నాకు చేరుకోవడానికి దయచేసి

197
00:12:10,160 --> 00:12:14,120
మీరు విషయాలను వెళ్లి ఎలా చర్చించడానికి అని మీరు తెలుసు CA ల లేదా ఒక.

198
00:12:14,120 --> 00:12:16,460
>> కాబట్టి, గదిలో ఇక్కడ తల్లిదండ్రులు ఆకట్టుకోవడానికి

199
00:12:16,460 --> 00:12:23,990
CS50 లైబ్రరీ ఏమిటి? మంచి పని చేసారు.

200
00:12:23,990 --> 00:12:32,280
CS50 లైబ్రరీ ఏమిటి? Yeah? [స్టూడెంట్ సమాధానాలు, అపారదర్శక]

201
00:12:32,280 --> 00:12:35,730
>>, సరే మంచి. కాబట్టి మనం సిబ్బంది, రాసిన కోడ్ యొక్క prewritten సెట్ కు,

202
00:12:35,730 --> 00:12:38,460
మేము కొన్ని సాధారణ కార్యాచరణ అందించడానికి, మీకు అందిస్తాయి.

203
00:12:38,460 --> 00:12:42,290
ఇక్కడ జాబితా చేసిన పనులను అన్ని నాకు ఒక పూర్ణాంకానికి పొందండి; నాకు స్ట్రింగ్ పొందండి ఇష్టం విషయం.

204
00:12:42,290 --> 00:12:45,260
ఇప్పుడు మొదలు, మేము నిజంగా ఈ శిక్షణ చక్రాలు టేకాఫ్ ప్రారంభించండి.

205
00:12:45,260 --> 00:12:48,230
కాబట్టి మేము, మీ నుంచి "స్ట్రింగ్" దూరంగా తీసుకుని ఆరంభమవుతుంది చేస్తున్నారు

206
00:12:48,230 --> 00:12:52,790
ఇది, రీకాల్, ఏ నిజమైన డేటా రకం కోసం ఒక పర్యాయపదంగా ఉంది? చార్ *.

207
00:12:52,790 --> 00:12:57,020
కాబట్టి తల్లిదండ్రులు కోసం, ఆ బహుశా - మంచి, కాబట్టి చార్ * మేము చూడడానికి మీరు

208
00:12:57,020 --> 00:13:00,810
తెరపై అన్ని మేము మా పదజాలం నుండి "స్ట్రింగ్" తొలగించు వంటి,

209
00:13:00,810 --> 00:13:02,760
వాస్తవానికి కోడ్ రాయడం దానిని వస్తుంది కనీసం ఉన్నప్పుడు.

210
00:13:02,760 --> 00:13:06,240
అదేవిధంగా, మేము చాలా ఈ విధులు వాడి ఆపడానికి ఉంటాం

211
00:13:06,240 --> 00:13:08,390
మా కార్యక్రమాలు మరింత అధునాతన పొందగలిగిన ఎందుకంటే

212
00:13:08,390 --> 00:13:11,370
కాకుండా కేవలం, ఒక ప్రాంప్టు మెరిసే తో అక్కడ కూర్చుని ప్రోగ్రాములను వ్రాయటానికి

213
00:13:11,370 --> 00:13:13,580
సైన్ ఏదో టైప్ వినియోగదారు వేచి

214
00:13:13,580 --> 00:13:15,220
మరొకచోట నుండి మీరు మీ ఇన్పుట్లను పొందుతారు.

215
00:13:15,220 --> 00:13:18,720
ఉదాహరణకు, మీరు స్థానిక హార్డు డ్రైవు బిట్స్ వరుస నుండి పొందుతారు.

216
00:13:18,720 --> 00:13:23,340
బదులుగా మీరు కొన్ని వెబ్ సైట్ ఎక్కడో ఒక నెట్వర్క్ కనెక్షన్ నుండి భవిష్యత్తులో వాటిని పొందుతారు.

217
00:13:23,340 --> 00:13:27,460
కాబట్టి మొదటి సారి తిరిగి ఈ పొర చర్మము యొక్క వివరించారు, CS50 ఉపకరణం పుల్ అప్

218
00:13:27,460 --> 00:13:32,300
మీరు వారాలు సహా పదునైన ఉన్నాను ఇది CS50.h అని మరియు ఈ ఫైలు,.

219
00:13:32,300 --> 00:13:34,380
>> కానీ వాస్తవానికి యొక్క ఈ లోపల ఏమి చూడటానికి.

220
00:13:34,380 --> 00:13:38,250
కాబట్టి నీలం లో ఫైల్ టాప్, కేవలం వ్యాఖ్యల మొత్తం బంచ్ ఉంది

221
00:13:38,250 --> 00:13:41,340
వారంటీ సమాచారం మరియు లైసెన్సింగ్. ఈ సాధారణ ఉదాహరణ యొక్క విధమైన ఉంది

222
00:13:41,340 --> 00:13:44,600
సాఫ్ట్వేర్ లో, ఎందుకంటే సాఫ్ట్వేర్ చాలా ఈ రోజుల్లో ", ఓపెన్ సోర్స్" అని ఏమిటి

223
00:13:44,600 --> 00:13:46,940
ఇది ఎవరైనా కోడ్ వ్రాశారు అర్థం

224
00:13:46,940 --> 00:13:50,060
మరియు, కేవలం అమలు చేయడానికి మరియు ఉపయోగించడానికి, దీనిని ఉచితంగా అందుబాటులో

225
00:13:50,060 --> 00:13:53,660
కానీ వాస్తవానికి చదివి మార్పు మరియు మీ స్వంత కృతి కలిసిపోవడానికి.

226
00:13:53,660 --> 00:13:55,790
కాబట్టి, మీరు, ఓపెన్ సోర్స్ సాఫ్ట్ వేర్ ఉపయోగించి చేసిన ఏది

227
00:13:55,790 --> 00:13:58,030
చాలా చిన్న రూపంలో రూపొందించబడింది.

228
00:13:58,030 --> 00:14:01,860
నేను వ్యాఖ్యలను గత స్క్రోల్ డౌన్ ఉంటే, అయితే, మేము కొన్ని మరింత చేరువైన విషయాలు చూడండి మొదలుపెడతారు.

229
00:14:01,860 --> 00:14:08,090
కాబట్టి CS50.h ఫైల్ హెడర్ ఫైళ్ళ మొత్తం బంచ్ కలిగి, ఇక్కడ ఎగువన గమనిస్తారు.

230
00:14:08,090 --> 00:14:11,160
ఇప్పుడు, ఈ అత్యంత మేము ముందు చూడని, కానీ ఒకటి

231
00:14:11,160 --> 00:14:15,640
తెలిసిన; ఈ ఏ మేము ఇప్పటివరకు, క్లుప్తంగా, అయినప్పటికీ చూసిన?

232
00:14:15,640 --> 00:14:18,720
అవును, ప్రామాణిక గ్రంధాలయాలు. Stdlib.h, malloc ఉంది

233
00:14:18,720 --> 00:14:21,590
కాబట్టి ఒకసారి మేము, డైనమిక్ మెమరీ కేటాయింపు గురించి మాట్లాడటం మొదలుపెట్టాడు

234
00:14:21,590 --> 00:14:24,960
మేము అదే వచ్చే వారం తిరిగి వచ్చి మేము, ఆ ఫైల్ను సహా ప్రారంభించారు.

235
00:14:24,960 --> 00:14:29,660
ఇది bool మరియు నిజమైన మరియు తప్పుడు వాస్తవానికి, ప్రతి SE, C లో లేని అవుతుంది

236
00:14:29,660 --> 00:14:32,460
మీరు ఇక్కడ ఈ ఫైలు ఉన్నాయి తప్ప.

237
00:14:32,460 --> 00:14:35,770
కాబట్టి మేము, వారాలు, ప్రామాణిక bool.h సహా చేశారు

238
00:14:35,770 --> 00:14:39,020
మీరు ఒక, bool ఒప్పు లేదా తప్పు. భావన ఉపయోగించడానికి ఆ

239
00:14:39,020 --> 00:14:41,830
ఈ లేకుండా, మీరు నకిలీ అది యొక్క క్రమం మరియు ఒక పూర్ణాంకానికి ఉపయోగించవలసి వస్తుంది

240
00:14:41,830 --> 00:14:45,920
మరియు కేవలం ఏకపక్ష 0 తప్పుగా మరియు 1 నిజమైన భావించవలసి.

241
00:14:45,920 --> 00:14:49,980
>> ఇప్పుడు, మేము మరింత స్క్రోల్ డౌన్ ఇక్కడ ఒక స్ట్రింగ్ యొక్క మా నిర్వచనం ఉంది.

242
00:14:49,980 --> 00:14:54,820
ఈ * ఉన్న నిజంగా ప్రాధాన్యత లేదు, మేము ముందు చెప్పారు చేసిన వంటి, అవుతుంది.

243
00:14:54,820 --> 00:14:56,750
మీరు కూడా అన్ని చుట్టూ ఖాళీ చేయవచ్చు.

244
00:14:56,750 --> 00:15:01,550
మేము, ఈ సెమిస్టర్, * రకం సంబంధం కలిగి ఉంటుంది, అని స్పష్టం చేయడానికి ఈ గా ప్రచారం చేశారు.

245
00:15:01,550 --> 00:15:05,370
కానీ కొంచెం సాధారణ లేకపోతే, అక్కడ అది ఉంచాలి, కేవలం వంటి సాధారణ, తెలుసుకుంటారు

246
00:15:05,370 --> 00:15:07,480
కానీ క్రియాశీలంగా ఒకే విషయం.

247
00:15:07,480 --> 00:15:11,070
మేము మరింత డౌన్ చదవండి అయితే ఇప్పుడు, యొక్క సే పరిశీలించి, GetInt, తీసుకుందాం

248
00:15:11,070 --> 00:15:15,350
మేము ఏదైనా ఈ సెమిస్టర్ ముందు, బహుశా, ఆ ఉపయోగిస్తారు ఎందుకంటే.

249
00:15:15,350 --> 00:15:19,620
మరియు ఇక్కడ GetInt ఉంది. ఈ ఏమిటి?

250
00:15:19,620 --> 00:15:24,650
ఈ నమూనా ఉంది. కాబట్టి తరచుగా, మేము మా యొక్క టాప్స్ వద్ద నమూనాలను నిలబెట్టాయి. సి ఫైళ్లు,

251
00:15:24,650 --> 00:15:28,190
కానీ మీరు కూడా శీర్షిక ఫైళ్లు,. h ఫైళ్లు, ప్రోటోటైప్స్ ఉంచవచ్చు

252
00:15:28,190 --> 00:15:32,110
ఇక్కడ ఈ విధంగా తద్వారా మీరు కొన్ని విధులు వ్రాస్తున్నప్పుడు

253
00:15:32,110 --> 00:15:36,790
మీరు ఇతర ప్రజలు ఉపయోగించవచ్చు చేయదలిచిన, ఇది CS50 లైబ్రరీ తో సరిగ్గా సందర్భంలో

254
00:15:36,790 --> 00:15:40,900
మీరు, CS50.c లాగ మీ విధులు అమలు మాత్రమే

255
00:15:40,900 --> 00:15:46,720
మీరు కూడా, కాని ఫైల్ ఎగువన నమూనాలను ఉంచారు, కానీ ఒక శీర్షికా ఫైలును ఎగువన

256
00:15:46,720 --> 00:15:50,810
ఆ శీర్షికా ఫైలును, స్నేహితులు మరియు సహచరులు హాజరవుతారు ఏమిటి

257
00:15:50,810 --> 00:15:52,800
పదునైన తమ సొంత కోడ్ చేర్చండి.

258
00:15:52,800 --> 00:15:55,440
ఈ సమయంలో మీరు ఈ నమూనాలను అన్ని సహా చేసిన

259
00:15:55,440 --> 00:15:59,870
సమర్థవంతంగా మీ ఫైల్ ఎగువన, కానీ ఈ పదునైన ద్వారా యంత్రాంగం ఉన్నాయి

260
00:15:59,870 --> 00:16:03,320
ఆ ముఖ్యంగా కాపీలు మరియు ముద్ద మీ స్వంత ఈ ఫైలు.

261
00:16:03,320 --> 00:16:06,400
ఇప్పుడు, ఇక్కడ కొన్ని విశదమైన డాక్యుమెంటేషన్ ఉంది.

262
00:16:06,400 --> 00:16:08,880
>> GetInt ఒక పూర్ణాంకానికి అందుతుంది అని మంజూరు కోసం మేము చాలా చక్కని తీసుకున్నారు,

263
00:16:08,880 --> 00:16:10,740
కొన్ని సందర్భాలలో మూలలో ఉంది అవుట్ కానీ, కుడి మారుతుంది?

264
00:16:10,740 --> 00:16:14,320
ఏ విధంగా చాలా పెద్దది ఒక సంఖ్య లోని యూజర్ రకాల ఉంటే?

265
00:16:14,320 --> 00:16:17,350
కేవలం ఒక పూర్ణాంకానికి లోపలి సరిపోవు ఒక quintillion,?

266
00:16:17,350 --> 00:16:21,180
ఊహించిన ప్రవర్తన ఏమిటి? Well, ఆదర్శవంతంగా, ఊహించదగిన ఉంది.

267
00:16:21,180 --> 00:16:23,460
కాబట్టి ఈ విషయంలో, మీరు నిజంగా, ఫైన్ ప్రింట్ చదివినట్లయితే

268
00:16:23,460 --> 00:16:27,850
మీరు ఆ పంక్తిలో తెలుసుకోలేదు ఉంటే, ఈ రాబడి INT_MAX చూస్తారు.

269
00:16:27,850 --> 00:16:30,800
మేము దీని గురించి మాట్లాడారు, కానీ దాని పెట్టుబడి ఆధారంగా ఎప్పుడూ చేసిన

270
00:16:30,800 --> 00:16:33,030
అది బహుశా, ఏమిటి?

271
00:16:33,030 --> 00:16:36,610
అది స్థిరమైన, కనుక అది ప్రకటించబడిన కొన్ని ప్రత్యేక స్థిరంగా ఉంది

272
00:16:36,610 --> 00:16:39,460
ఫైలు ఎగువ అని ఆ శీర్షిక ఫైళ్లు ఒక,

273
00:16:39,460 --> 00:16:43,400
మరియు INT_MAX బహుశా 2 బిలియన్, సుమారు, వంటిది.

274
00:16:43,400 --> 00:16:48,160
మేము ఏదో ఏదో సూచిస్తుంది అవసరం ఎందుకంటే దీనికి ఆలోచన, తప్పు జరిగింది

275
00:16:48,160 --> 00:16:51,090
మేము, అవును, మా పారవేయడం వద్ద 4 బిలియన్ సంఖ్యలు ఉంటాయి

276
00:16:51,090 --> 00:16:53,980
2 బిలియన్ న ప్రతికూల 2 బిలియన్ ఇవ్వడం లేదా పడుతుంది.

277
00:16:53,980 --> 00:16:58,030
Well, ఏ ప్రోగ్రామింగ్ లో సాధారణంగా మీరు ఆ సంఖ్యల ఒక దొంగతనం ఉంది.

278
00:16:58,030 --> 00:17:02,250
బహుశా 0, బహుశా 2 బిలియన్, బహుశా ప్రతికూల 2 బిలియన్.

279
00:17:02,250 --> 00:17:06,720
మీరు ప్రపంచానికి కమిట్ విధంగా కాబట్టి మీరు మీ సాధ్యమయ్యే విలువలను ఒకటి ఖర్చు

280
00:17:06,720 --> 00:17:10,089
ఏదో తప్పు పోతే, నేను ఈ సూపర్ పెద్ద విలువ అందిస్తుంది.

281
00:17:10,089 --> 00:17:13,329
కానీ మీరు యూజర్ వంటి నిగూఢ ఏదో టైప్ ఇష్టం లేదు "4, 2, 3 ..."

282
00:17:13,329 --> 00:17:17,079
నిజంగా పెద్ద సంఖ్యలో, మీరు స్థిరమైన వంటి బదులుగా క్రమపరచుట.

283
00:17:17,079 --> 00:17:19,380
కాబట్టి నిజంగా, మీరు గత కొన్ని వారాల ఆసన అనే ఉంటే,

284
00:17:19,380 --> 00:17:23,800
మీరు GetInt కాల్ ఎప్పుడైనా, మీరు ఒక ఉంటే పరిస్థితికి తనిఖీ వుండాలి.

285
00:17:23,800 --> 00:17:27,109
, లేదా మరింత ప్రత్యేకంగా, INT_MAX వినియోగదారు టైప్ చేశారా

286
00:17:27,109 --> 00:17:29,900
GetInt తిరిగి INT_MAX చేశాడు? ఎందుకంటే అది చేస్తే,

287
00:17:29,900 --> 00:17:35,140
వాస్తవానికి వారు టైపు లేదు అని; ఏదో ఈ విషయంలో తప్పు జరిగింది.

288
00:17:35,140 --> 00:17:38,970
కాబట్టి ఈ సాధారణంగా కేవలం ప్రత్యేక అంటే ఒక "సెంటినెల్" విలువ, గా పిలిచే దాన్ని ఉంది.

289
00:17:38,970 --> 00:17:41,020
>> సరే, ఇప్పుడు. సి ఫైళ్లను కు తిరగండి తెలియజేయండి.

290
00:17:41,020 --> 00:17:44,500
సి ఫైలు, కొంత సమయం కోసం పరికరంలోని ఉనికిలో ఉంది

291
00:17:44,500 --> 00:17:47,540
మరియు, నిజానికి, ఉపకరణం మీ కోసం precompiled ఉంది

292
00:17:47,540 --> 00:17:49,720
ఆ విషయం లో మేము ", వస్తువు కోడ్" అని

293
00:17:49,720 --> 00:17:52,940
సిస్టమ్ తెలుసు ఎందుకంటే అది ఎక్కడ కానీ అది కేవలం మీకు సంబంధించిన లేదు,

294
00:17:52,940 --> 00:17:54,780
ఈ సందర్భంలో, అది ఎక్కడ, ఉపకరణం.

295
00:17:54,780 --> 00:18:00,620
కానీ యొక్క GetInt ఇప్పుడు స్క్రోల్ డౌన్ తెలియజేయండి మరియు GetInt ఈ సమయంలో పని ఎలా చూడండి.

296
00:18:00,620 --> 00:18:02,380
కాబట్టి ఇక్కడ ముందు నుండి ఇలాంటి వ్యాఖ్యలు ఉన్నాయి.

297
00:18:02,380 --> 00:18:04,930
నాకు కేవలం కోడ్ భాగం లో జూమ్ లెట్

298
00:18:04,930 --> 00:18:07,410
మరియు మేము GetInt కోసం కింది ఉంది.

299
00:18:07,410 --> 00:18:12,770
(నిజమైన), కాబట్టి మేము ఒక ఉద్దేశపూర్వక అనంతమైన లూప్ కలిగి ఉండటం వలన ఇది ఇన్పుట్ తీసుకుని అది ఒక పూర్ణాంకానికి తిరిగి

300
00:18:12,770 --> 00:18:16,560
కానీ, బహుశా, మేము ఏదో ఈ యొక్క బయటకు, లేదా ఈ లోపల నుండి తిరిగి వస్తుంది.

301
00:18:16,560 --> 00:18:19,890
కాబట్టి ఎలా ఈ పనులు చూడటానికి. Well, మేము GetString ఉపయోగించి కనిపిస్తుంది

302
00:18:19,890 --> 00:18:22,550
లూప్, 166 లోపల ఈ మొదటి లైన్ లో.

303
00:18:22,550 --> 00:18:25,320
ఈ ఇప్పుడు మంచి పద్ధతి ఎందుకంటే ఏమి పరిస్థితుల్లో

304
00:18:25,320 --> 00:18:30,820
GetString ఈ ప్రత్యేక కీవర్డ్, NULL తిరిగి విధుల్లో?

305
00:18:30,820 --> 00:18:38,460
ఏదో తప్పు జరిగితే ఉంటే. మీరు GetString లాగ కాల్ చేసినప్పుడు తప్పు ఏం చేయాలో?

306
00:18:38,460 --> 00:18:42,550
Yeah? [స్టూడెంట్ సమాధానం, అపారదర్శక] >> అవును. కాబట్టి బహుశా malloc విఫలమైతే.

307
00:18:42,550 --> 00:18:45,310
ఎక్కడో హుడ్ GetString కింద, malloc కాల్

308
00:18:45,310 --> 00:18:48,210
ఇది కంప్యూటర్ స్టోర్ చేయడానికి అనుమతిస్తుంది, ఇది మెమరీ కేటాయించుకునే

309
00:18:48,210 --> 00:18:50,950
పాత్రలు ఆ కీబోర్డ్ లో యూజర్ రకాల.

310
00:18:50,950 --> 00:18:53,270
మరియు యూజర్ ఖాళీ సమయంలో మొత్తం చాల ఉన్నాయి అనుకుందాం

311
00:18:53,270 --> 00:18:56,470
మరియు 2 బిలియన్ కంటే ఎక్కువ అక్షరాలు, ఉదాహరణకు, ఎక్కువ టైప్.

312
00:18:56,470 --> 00:18:59,600
కంప్యూటర్ కంటే ఎక్కువ అక్షరాలు కూడా RAM కలిగి ఉంది.

313
00:18:59,600 --> 00:19:02,350
Well, GetString, మీరు ఆ సూచిస్తుంది సామర్థ్యాన్ని కలిగి ఉండాలి

314
00:19:02,350 --> 00:19:05,650
ఈ సూపర్, సూపర్ అసాధారణ మూలలో సందర్భంలో కూడా.

315
00:19:05,650 --> 00:19:08,490
ఇది ఏదో ఈ నిర్వహించడానికి సామర్థ్యాన్ని కలిగి ఉండాలి, మరియు అందువలన GetString

316
00:19:08,490 --> 00:19:11,850
మేము తిరిగి వెళ్లి తన డాక్యుమెంటేషన్ చదవండి ఉంటే, నిజానికి, NULL తిరిగి లేదు.

317
00:19:11,850 --> 00:19:16,150
GetString NULL రావడం ద్వారా విఫలమైతే ఇప్పుడు ఉంటే, GetInt విఫలం అన్నారు

318
00:19:16,150 --> 00:19:19,370
ఒక సెంటినెల్ వంటి, INT_MAX రావడం ద్వారా.

319
00:19:19,370 --> 00:19:22,650
ఇవి మానవ సమావేశాలు ఉంటాయి. మీరు ఈ తెలుసు మాత్రమే మార్గం సందర్భంలో

320
00:19:22,650 --> 00:19:24,840
డాక్యుమెంటేషన్ చదవడం ద్వారా ఉంది.

321
00:19:24,840 --> 00:19:28,200
కాబట్టి యొక్క Int వాస్తవానికి GotInt ఉన్న క్రిందికి స్క్రోల్ అనుమతిస్తుంది.

322
00:19:28,200 --> 00:19:34,220
>> నేను ఒక బిట్ మరింత స్క్రోల్ డౌన్ చేస్తే, లైన్ 170 లో మేము ఈ మార్గాల పైన వ్యాఖ్య ఉందా.

323
00:19:34,220 --> 00:19:38,470
కాబట్టి మేము, 172 లో, ఒక పూర్ణాంకానికి n మరియు ఒక చార్ సి, మరియు ఈ కొత్త ఫంక్షన్ డిక్లేర్

324
00:19:38,470 --> 00:19:41,870
మీరు కొన్ని ముందు అంతటా డెక్కన్ ఛార్జర్స్, కానీ sscanf చేశారు.

325
00:19:41,870 --> 00:19:44,190
ఈ స్ట్రింగ్ స్కాన్ F సూచిస్తుంది.

326
00:19:44,190 --> 00:19:48,580
ఇతర మాటలలో, నాకు స్ట్రింగ్ ఇవ్వాలని నేను ఆసక్తికరమైన సమాచారం ముక్కలు కోసం స్కాన్ చేస్తుంది.

327
00:19:48,580 --> 00:19:53,820
కాబట్టి ఆ అర్థం ఏమిటి? Well, నేను కీబోర్డ్ వద్ద 1 2 3, వాచ్యంగా, టైప్ చేసే ఉద్దేశం

328
00:19:53,820 --> 00:19:59,730
ఆపై ఎంటర్ నొక్కండి. GetString ద్వారా తిరిగి 1 2 3 యొక్క డేటా రకం ఏమిటి?

329
00:19:59,730 --> 00:20:05,010
ఇది కుడి, స్పష్టంగా ఒక స్ట్రింగ్ ఏమిటి? నేను ఒక స్ట్రింగ్ వచ్చింది, కాబట్టి 1 2 3 నిజంగా "1 2 3"

330
00:20:05,010 --> 00:20:07,260
అది ముగింపులో \ 0 తో. ఒక Int కాదు.

331
00:20:07,260 --> 00:20:10,420
ఒక సంఖ్య కాదు. ఇది అనేక కనిపిస్తోంది అయితే కాదు.

332
00:20:10,420 --> 00:20:14,680
సో వాట్ GetInt లేదు లేదు? ఇది ఎడమ ఆ స్ట్రింగ్ స్కాన్ ఉంటుంది

333
00:20:14,680 --> 00:20:19,010
1 2 3 \ 0, మరియు ఏదో ఒక వాస్తవ పూర్ణాంక మార్పు చేయండి.

334
00:20:19,010 --> 00:20:21,010
ఇప్పుడు, మీరు దీన్ని ఎలా పూర్తి చేయాలో అంచనా కాలేదు.

335
00:20:21,010 --> 00:20:24,240
మీరు pset 2 తిరిగి భావిస్తే, మీరు బహుశా కొద్దిగా సౌకర్యవంతమైన వచ్చింది

336
00:20:24,240 --> 00:20:26,810
సీజర్ లేదా విజెనెరే తో కాబట్టి మీరు ఒక స్ట్రింగ్ పైగా iterate చేయవచ్చు

337
00:20:26,810 --> 00:20:29,800
మీరు పిక్ ints కు అక్షరాలు మార్చవచ్చు. కృతి యొక్క మొత్తం చాలా పేర్కొంది.

338
00:20:29,800 --> 00:20:32,800
ఎందుకు మీరు ఆ చేసే sscanf వంటి ఫంక్షన్ కాల్?

339
00:20:32,800 --> 00:20:37,520
కాబట్టి sscanf స్ట్రింగ్ ఉన్న లైన్ అని ఈ సందర్భంలో, లో, ఒక వాదన ఆశించారు.

340
00:20:37,520 --> 00:20:41,310
అప్పుడు మీరు,, కోట్స్ లో, printf సమానమైన పేర్కొనండి

341
00:20:41,310 --> 00:20:44,960
మీరు ఈ స్ట్రింగ్ లో చూడటానికి ఏమి అనుకుంటున్నావా?

342
00:20:44,960 --> 00:20:52,980
నేను ఇక్కడ చెప్పడం నేను ఉంది, నేను ఒక దశాంశ సంఖ్య చేసి ఒక పాత్ర చూడాలనుకుంటున్నారా.

343
00:20:52,980 --> 00:20:54,990
ఈ ఒక్క నిమిషం లో కేసు ఎందుకు మరియు మేము చూస్తారు.

344
00:20:54,990 --> 00:20:58,440
ఈ సంజ్ఞామానం ఇప్పుడు stuff గుర్తుచేస్తుంది ఆ అవుతుంది

345
00:20:58,440 --> 00:21:00,840
మేము కేవలం ఒక వారం క్రితం మీద గురించి మాట్లాడటం మొదలుపెట్టాడు.

346
00:21:00,840 --> 00:21:05,430
>> ఏమిటి & n మరియు & సి ఇక్కడ మాకు చేయడం? [స్టూడెంట్ సమాధానాలు, అపారదర్శక]

347
00:21:05,430 --> 00:21:07,610
>> అవును. ఇది నాకు సి యొక్క n మరియు చిరునామా చిరునామా ఇచ్చి ఉన్నారు.

348
00:21:07,610 --> 00:21:10,440
ఇప్పుడు, ఎందుకు ముఖ్యమైనది? సరే, మీరు తెలుసు సి లో విధులు

349
00:21:10,440 --> 00:21:13,440
మీరు ఎల్లప్పుడూ అన్ని వద్ద ఒక విలువ లేదా సంఖ్య విలువ తిరిగి రావచ్చు.

350
00:21:13,440 --> 00:21:16,630
మీరు ఒక Int, ఒక స్ట్రింగ్, ఫ్లోట్, ఒక భస్మం, ఏ తిరిగి రావచ్చు.

351
00:21:16,630 --> 00:21:21,150
లేదా మీరు తప్ప తిరిగి, కానీ మీరు మాత్రమే గరిష్టంగా 1 విషయం తిరిగి రావచ్చు.

352
00:21:21,150 --> 00:21:26,100
కానీ ఇక్కడ మేము sscanf బహుశా ఒక Int, ఒక దశాంశ సంఖ్య, నాకు తిరిగి కావాలి

353
00:21:26,100 --> 00:21:29,240
మరియు ఒక చార్, మరియు నేను ఒక క్షణం లో ఎందుకు చార్ వివరించడానికి చేస్తాము.

354
00:21:29,240 --> 00:21:34,250
కాబట్టి మీరు సమర్థవంతంగా F 2 విషయాలు తిరిగి కావలసిన; ఆ C. కేవలం సాధ్యం కాదు

355
00:21:34,250 --> 00:21:38,460
కాబట్టి మీరు, 2 చిరునామాలలో పంపిస్తూ చుట్టూ పని చేయవచ్చు

356
00:21:38,460 --> 00:21:43,710
మీరు ఒక ఫంక్షన్ 2 చిరునామాలు చేతితో వెంటనే, ఆ ఫంక్షన్ వారితో ఏమి ఎందుకంటే?

357
00:21:43,710 --> 00:21:49,880
ఇది ఆ చిరునామాలను వ్రాయవచ్చు. మీరు * ఆపరేషన్ ఉపయోగించడానికి మరియు ఆ చిరునామాలను ప్రతి "అక్కడ వెళ్ళి" చేయవచ్చు.

358
00:21:49,880 --> 00:21:54,320
ఈ బ్యాక్డోర్ను యంత్రాంగం విధమైన, కానీ చరరాశులు యొక్క విలువలలో మార్చడానికి చాలా సాధారణ

359
00:21:54,320 --> 00:21:58,020
ఈ సందర్భంలో 2 కేవలం 1 స్థానంలో, కంటే ఎక్కువ లో.

360
00:21:58,020 --> 00:22:04,590
ఇప్పుడు నేను == to1 తనిఖీ, మరియు ఆ నిజానికి, నిజమైన విశ్లేషించదు ఒకవేళ n తిరిగి నేను గమనించి.

361
00:22:04,590 --> 00:22:09,340
కాబట్టి ఏం జరగబోతోంది? Well, సాంకేతికంగా, మేము నిజంగా GetInt లో ఏమి చేయాలనే ఈ ఉంది.

362
00:22:09,340 --> 00:22:12,340
మేము మాట్లాడటానికి, విశ్లేషించడం మీరు; మేము స్ట్రింగ్ చదవాలనుకుంటున్న

363
00:22:12,340 --> 00:22:16,210
"1 2 3" మరియు అక్కడ అనేక ఉంది కనిపిస్తుంది ఉంటే,

364
00:22:16,210 --> 00:22:21,360
మనం చెయ్యవలసింది sscanf చెప్పుకుంటున్నారు నాకు ఈ వేరియబుల్ n ఆ సంఖ్య, 1 2 3, పెట్టబడింది.

365
00:22:21,360 --> 00:22:26,060
ఎందుకు, అప్పుడు, నేను కూడా ఈ ఉందా?

366
00:22:26,060 --> 00:22:33,750
కూడా sscanf, మీరు కూడా ఇక్కడ ఒక పాత్ర పొందడానికి ఉండవచ్చు విధంగా పాత్ర ఏమిటి.

367
00:22:33,750 --> 00:22:36,890
[స్టూడెంట్ మాట్లాడే, అపారదర్శక] >> కాదు - ఒక దశాంశ బిందువు పనిచేస్తుంది.

368
00:22:36,890 --> 00:22:40,650
ఒక క్షణం ఆలోచన ఆ యొక్క కలిగి లెట్. ఏమి?

369
00:22:40,650 --> 00:22:42,570
[స్టూడెంట్, అపారదర్శక] >> కాబట్టి, మంచి ఆలోచన, అది NULL పాత్ర ఉంటుంది.

370
00:22:42,570 --> 00:22:44,970
ఈ సందర్భంలో, వాస్తవానికి కాదు. Yeah? [స్టూడెంట్, అపారదర్శక]

371
00:22:44,970 --> 00:22:47,100
>> >> ASCII. లేదా, నాకు మరింత క్రమపరచుట తెలియజేయండి.

372
00:22:47,100 --> 00:22:49,670
అక్కడ% సి కేవలం లోపం పరిశీలన మాత్రమే.

373
00:22:49,670 --> 00:22:52,510
మేము, సంఖ్య తర్వాత పాత్ర ఉన్నట్లు ఇష్టం లేదు

374
00:22:52,510 --> 00:22:54,980
కానీ ఈ నాకు అనుమతిస్తుంది ఇలా ఉంటాయి:

375
00:22:54,980 --> 00:23:01,270
ఇది ఆ sscanf, ఇక్కడ ఈ ఉదాహరణలో, n మరియు సి విలువలు నిల్వ పాటు, అవుతుంది

376
00:23:01,270 --> 00:23:08,170
అది కూడా వేరియబుల్స్ యొక్క సంఖ్యను చూపించే ఏమి అది సైన్ విలువలు ఉంచండి

377
00:23:08,170 --> 00:23:13,330
మీరు మాత్రమే అప్పుడు, 1 2 3 లో టైప్ చేస్తే మాత్రమే% d మ్యాచ్ అన్నారు

378
00:23:13,330 --> 00:23:18,830
మరియు మాత్రమే n 1 2 3 వంటి విలువ నిల్వ అవుతుంది మరియు ఏమీ సి ఉంచే;

379
00:23:18,830 --> 00:23:20,870
సి మాట్లాడటానికి, ఒక చెత్త విలువ ఉంది.

380
00:23:20,870 --> 00:23:23,550
అది కొన్ని విలువ initialized ఎప్పుడూ యొక్క చెత్త ఎందుకంటే.

381
00:23:23,550 --> 00:23:29,390
నేను ఆ గమనికలు ఒక జనాభా కనుక అలా ఆ సందర్భంలో, sscanf, 1 తిరిగి

382
00:23:29,390 --> 00:23:33,650
ఈ సందర్భంలో, గొప్ప. నేను ఒక పూర్ణాంకానికి కలిగి ఉంటాయి, కాబట్టి నేను మెమరీ అప్ విముక్తికై లైన్ విడిపించేందుకు

383
00:23:33,650 --> 00:23:37,150
ఆ GetString వాస్తవానికి కేటాయించింది, ఆ తరువాత n తిరిగి.

384
00:23:37,150 --> 00:23:42,210
ఆ మళ్ళీ పేరు మీరు ఆలోచిస్తున్నారా ఉంటే ఎల్స్, ప్రకటన నుండి వచ్చింది, ఇక్కడ నుండే వస్తుంది.

385
00:23:42,210 --> 00:23:45,770
ఉంటే దీనికి విరుద్ధంగా, నేను, 1 2 3 foo టైప్

386
00:23:45,770 --> 00:23:48,640
టెక్స్ట్ యొక్క కొన్ని యాదృచ్ఛిక క్రమంలో, sscanf, చూడండి అన్నారు

387
00:23:48,640 --> 00:23:51,500
F - ooh, ooh, సంఖ్య సంఖ్య ooh, సంఖ్య ooh.

388
00:23:51,500 --> 00:23:54,190
మరియు అది n లో 1 2 3 ఉంచాలి జరగబోతోంది.

389
00:23:54,190 --> 00:23:59,970
ఇది సి లో F ఉంచారు, మరియు అప్పుడు 2 తిరిగి వెళుతున్న.

390
00:23:59,970 --> 00:24:02,980
కాబట్టి మేము కేవలం scanf యొక్క ప్రవర్తన యొక్క ప్రాధమిక నిర్వచనం ఉపయోగించి కలిగి

391
00:24:02,980 --> 00:24:06,170
చాలా సులభమైన మార్గం - అదే, మొదటి చూపులో క్లిష్టమైన, కానీ రోజు చివరిలో,

392
00:24:06,170 --> 00:24:11,460
చెప్పడం యొక్క నిరాడంబర యంత్రాంగం అక్కడ ఒక Int, మరియు అలా అయితే, ఆ నేను దొరకలేదు మాత్రమే విషయం?

393
00:24:11,460 --> 00:24:14,950
మరియు ఇక్కడ వైట్ స్పేస్ ఉద్దేశపూర్వక ఉంది. మీరు sscanf కోసం డాక్యుమెంటేషన్, చదవడానికి ఉంటే

394
00:24:14,950 --> 00:24:18,690
ఆ మీరు ప్రారంభంలో లేదా చివరిలో వైట్ స్పేస్ భాగాన్ని కలిగి ఉంటే, మీరు చెబుతుంది

395
00:24:18,690 --> 00:24:24,990
sscanf చాలా spacebar 1 2 3 నొక్కండి, కారణము ఏదైనప్పటికీ, యూజర్ అనుమతిస్తుంది, మరియు ఆ చట్టబద్ధమైన ఉంటుంది.

396
00:24:24,990 --> 00:24:28,310
వారు ప్రారంభంలో లేదా చివరిలో spacebar నొక్కండి కనుక ఇది వినియోగదారు మీద అరుస్తుంటారు లేదు

397
00:24:28,310 --> 00:24:32,160
ఇది యూజర్ ఫ్రెండ్లీ కొంచెం ఎక్కువ.

398
00:24:32,160 --> 00:24:34,160
>> ఏదైనా ప్రశ్నలు, అప్పుడు, GetInts న? Yeah?

399
00:24:34,160 --> 00:24:36,820
[స్టూడెంట్ ప్రశ్న, అపారదర్శక]

400
00:24:36,820 --> 00:24:40,740
>> మంచి ప్రశ్న. మీరు ఒక చార్ లో టైప్ చేస్తే, f, మరియు విజయవంతమైన వంటి నమోదు ఏమిటి

401
00:24:40,740 --> 00:24:47,830
ఎప్పుడూ 1 2 3 టైప్ లేకుండా; మీరు కోడ్ ఈ రేఖ యొక్క ప్రవర్తన అప్పుడు ఉంటుంది ఏమి ఆలోచిస్తాడు?

402
00:24:47,830 --> 00:24:50,500
కాబట్టి sscanf, కూడా ఉంటాయి ఆ సందర్భంలో ఎందుకంటే,

403
00:24:50,500 --> 00:24:56,280
అది n లేదా సి పూర్తి మాత్రం కాదు; ఇది బదులుగా 0 తిరిగి వెళుతున్న.

404
00:24:56,280 --> 00:25:01,540
నేను మీరు ఊహించిన విలువ 1 ఎందుకంటే ఈ సందర్భంలో, నేను కూడా, ఆ దృష్టాంతంలో క్యాచింగ్ చేస్తున్నాను.

405
00:25:01,540 --> 00:25:07,310
నేను మాత్రమే 1 కావాలి, మరియు మాత్రమే 1 విషయం నింపవచ్చు. ప్రశ్న గుడ్. ఇతరులు?

406
00:25:07,310 --> 00:25:09,610
>> All right, కాబట్టి ఇక్కడ విధులు అన్ని ద్వారా వెళ్ళి వినియోగించవద్దు,

407
00:25:09,610 --> 00:25:11,820
కానీ మిగిలిన ఆసక్తి, బహుశా, కనబడుతోందని ఒక

408
00:25:11,820 --> 00:25:14,530
అది అవుతుంది ఎందుకంటే GetString అని GetFloat, GetInt,

409
00:25:14,530 --> 00:25:19,490
అన్ని రౌడీ GetString వారి కార్యాచరణను చాలా GetLongLong, GetDouble.

410
00:25:19,490 --> 00:25:22,860
కాబట్టి అతను ఇక్కడ అమలు ఎలా పరిశీలించి అనుమతిస్తుంది.

411
00:25:22,860 --> 00:25:27,040
ఈ ఒక చిన్న క్లిష్టమైన ఉంది కానీ అదే ఫండమెంటల్స్ ఉపయోగిస్తుంది

412
00:25:27,040 --> 00:25:29,680
మేము గత వారం గురించి మాట్లాడటం మొదలుపెట్టాడు ఆ. కాబట్టి GetString లో,

413
00:25:29,680 --> 00:25:32,670
ఇది ఇక్కడ తప్ప ప్రకారం ఏ వాదన పడుతుంది

414
00:25:32,670 --> 00:25:37,110
మరియు అది ఒక స్ట్రింగ్ పంపుతుంది; నేను బఫర్ అనే స్ట్రింగ్ ప్రకటించారు am.

415
00:25:37,110 --> 00:25:39,670
నేను నిజంగా ఆ ఇంకా ఉపయోగించకూడదు ఏమి తెలియదు, కానీ మేము చూస్తారు.

416
00:25:39,670 --> 00:25:42,950
సామర్థ్యం ఉన్నట్లు ఉంది డిఫాల్ట్, 0 ద్వారా, ఉంటుంది; ఈ వెళ్లి కౌంటీ చాలా ఖచ్చితంగా లేదు.

417
00:25:42,950 --> 00:25:44,920
కాదు n ఇంకా ఉపయోగించకూడదు ఏమి ఖచ్చితంగా.

418
00:25:44,920 --> 00:25:47,860
కానీ ఇప్పుడు, చాలా లైన్ 243 లో, ఒక చిన్న ఆసక్తికరమైన సంతరించుకోనుంది

419
00:25:47,860 --> 00:25:51,760
మేము ఒక పూర్ణాంకానికి సి, ఈ ఒక పెద్ద వివరాలు యొక్క విధమైన ఉంది ప్రకటిస్తాయి.

420
00:25:51,760 --> 00:25:58,080
ఒక చార్ 8 బిట్స్, మరియు 8 బిట్స్ ఎలా అనేక విలువలు నిల్వ చేయవచ్చు?

421
00:25:58,080 --> 00:26:03,310
256. మీరు 256 వివిధ ASCII అక్షరాలు అనుకుంటే సమస్య, ఉంది

422
00:26:03,310 --> 00:26:06,210
ఇది అక్కడ మీరు తిరిగి భావిస్తే, ఈ గుర్తుంచుకోవలసిన విషయం కాదు.

423
00:26:06,210 --> 00:26:09,100
మీరు పెద్ద ASCII చార్ట్ తిరిగి అనుకుంటే కానీ మేము వారాల క్రితం వచ్చింది,

424
00:26:09,100 --> 00:26:13,780
ఆ సందర్భంలో, 128 లేదా 256 ASCII అక్షరాలు లో ఉన్నాయి.

425
00:26:13,780 --> 00:26:16,220
మేము అన్ని 0 యొక్క నమూనాలు మరియు 1 ఇష్టం ఉపయోగిస్తారు.

426
00:26:16,220 --> 00:26:19,410
మీరు ఒక దోషాన్ని గుర్తించే సామర్థ్యం కోరుకుంటే ఒక సమస్య.

427
00:26:19,410 --> 00:26:23,290
మీరు ఇప్పటికే మీ అక్షరాలు కోసం 256 విలువలు ను ఉపయోగిస్తున్నట్లయితే ఎందుకంటే,

428
00:26:23,290 --> 00:26:26,390
ఇప్పుడు మీరు చెబుతున్న సంఖ్య మార్గం లేని కారణంగా మీరు నిజంగా,, ముందుకు ప్లాన్ లేదు

429
00:26:26,390 --> 00:26:29,750
"ఇది సక్రమం పాత్ర కాదు; ఈ కొన్ని తప్పుడు సందేశం."

430
00:26:29,750 --> 00:26:32,430
సో వాట్ ప్రపంచ ఉండదు, వారు తదుపరి అతిపెద్ద విలువ ఉపయోగించడానికి,

431
00:26:32,430 --> 00:26:35,790
ఒక పూర్ణాంకానికి లాగ మీరు బిట్స్ ఒక క్రేజీ ఉన్నాయి కాబట్టి,

432
00:26:35,790 --> 00:26:39,610
4 బిలియన్ విలువల కోసం 32, తద్వారా మీరు కేవలం ఉపయోగించి అవుతుంది

433
00:26:39,610 --> 00:26:44,800
ముఖ్యంగా, వాటిలో 257, 1 ఇది ఒక లోపం వంటి కొన్ని ప్రత్యేక అర్థం ఉంది.

434
00:26:44,800 --> 00:26:49,190
>> కాబట్టి ఎలా ఈ పనులు చూడటానికి. లైన్ 246 లో, ఈ పెద్ద సమయంలో లూప్ కలిగి

435
00:26:49,190 --> 00:26:54,530
ఆ fgetc కాల్; అప్పుడు F అర్థం ఫైలు, getc, మరియు stdin.

436
00:26:54,530 --> 00:26:59,030
ఇది చెప్పడం మరింత ఖచ్చితమైన మార్గం అవుతుంది "కీబోర్డ్ నుండి ఇన్పుట్ చదవండి."

437
00:26:59,030 --> 00:27:02,730
ప్రామాణిక ఇన్పుట్ అంటే కీబోర్డు, ప్రామాణిక అవుట్పుట్, స్క్రీన్ అర్థం

438
00:27:02,730 --> 00:27:06,920
మరియు మేము pset 4 లో చూస్తారు ఇది ప్రామాణిక తప్పు,,, స్క్రీన్ అర్థం

439
00:27:06,920 --> 00:27:09,670
కానీ స్క్రీన్ ప్రత్యేక భాగంగా కలిపారు లేదు, అందుచే

440
00:27:09,670 --> 00:27:13,760
మీరు ముద్రించడానికి ఉద్దేశించిన నిజమైన కృషిని; కానీ భవిష్యత్తులో ఆ మరింత.

441
00:27:13,760 --> 00:27:19,430
కాబట్టి fgetc కేవలం కీబోర్డ్ నుండి ఒక పాత్ర చదవండి, మరియు నిల్వ అంటే?

442
00:27:19,430 --> 00:27:24,000
సి లో నిల్వ చేసి, ఆపై తనిఖీ, కాబట్టి నేను ఇక్కడ కొన్ని బూలియన్ సముచ్ఛయాలు ఉపయోగించి నేను,

443
00:27:24,000 --> 00:27:28,430
అది n అందువల్ల వినియోగదారుడు ఎంటర్ నొక్కండి ఉంది \ సమానం కాదు చేసే తనిఖీ.

444
00:27:28,430 --> 00:27:31,510
మేము ఆ, లూప్ చివరిలో ఆపివేయాలనుకుంటున్నారా, మరియు మేము కూడా తనిఖీ మీరు

445
00:27:31,510 --> 00:27:36,170
కోసం మీకు లేదా ఊహించడం ఉంటే ప్రత్యేక స్థిరమైన, EOF, - ఇది ఏ స్టాండ్ లేదు?

446
00:27:36,170 --> 00:27:39,860
ఫైలు ముగింపు. నేను కీబోర్డ్ వద్ద టైప్ చేస్తున్నానని ఉంటే ఎందుకంటే ఈ, పిచ్చి రకం

447
00:27:39,860 --> 00:27:41,900
ఈ ప్రమేయం ఏ ఫైల్, నిజంగా ఉంది

448
00:27:41,900 --> 00:27:44,330
కానీ ఇది సూచించడానికి ఉపయోగిస్తారు సాధారణ పదం యొక్క క్రమం ఉంది

449
00:27:44,330 --> 00:27:50,320
ఇంకా ఆ ఏమీ మానవ యొక్క చేతి వేళ్ళ నుంచి వస్తోంది. EOF. ఫైలు ముగింపు.

450
00:27:50,320 --> 00:27:52,600
ఒక పక్కన, మీరు మీ కీబోర్డ్ లో నియంత్రణ d హిట్ ఉంటే,

451
00:27:52,600 --> 00:27:54,680
మీరు ఇంకా కాదు ఆ; మీరు కంట్రోల్ సి హిట్ చేసిన.

452
00:27:54,680 --> 00:27:57,920
కానీ కంట్రోల్ d ఈ ప్రత్యేక స్థిరంగా అని EOF పంపుతుంది.

453
00:27:57,920 --> 00:28:03,100
>> కాబట్టి ఇప్పుడు మేము కొన్ని డైనమిక్ మెమరీ కేటాయింపు ఉంది.

454
00:28:03,100 --> 00:28:06,460
N + 1> సామర్థ్యం, ​​ఇప్పుడు నేను n వివరించడానికి మీరు చేస్తున్నాను.

455
00:28:06,460 --> 00:28:09,380
n కేవలం ఎన్ని బైట్లు, బఫర్ ప్రస్తుతం ఉంటాయి

456
00:28:09,380 --> 00:28:11,970
మీరు ప్రస్తుతం వినియోగదారు నుండి రూపొందించడంలో చేస్తున్న స్ట్రింగ్.

457
00:28:11,970 --> 00:28:16,240
మీరు బఫర్ లో సామర్థ్యం కంటే మీ బఫర్ లో ఎక్కువ అక్షరాలు కలిగి ఉంటే,

458
00:28:16,240 --> 00:28:20,760
intuitively, అప్పుడు ఏమి చేయాలి మరింత సామర్థ్యం కేటాయించాలని ఉంది.

459
00:28:20,760 --> 00:28:24,490
నేను ఇక్కడ అంకగణితం యొక్క కొన్ని పైగా చెడిపోయిన వెళుతున్న

460
00:28:24,490 --> 00:28:26,900
మరియు ఇక్కడ మాత్రమే ఈ చర్య దృష్టి.

461
00:28:26,900 --> 00:28:29,170
మీరు malloc ఉంది ఏమి, లేదా కనీసం సాధారణంగా తెలిసిన.

462
00:28:29,170 --> 00:28:32,380
Realloc ఏమి ఒక అంచనా తీసుకోండి. [స్టూడెంట్ సమాధానం, అపారదర్శక]

463
00:28:32,380 --> 00:28:35,690
>> అవును. మరియు చాలా మెమరీ జోడించడం కాదు; అది ఈ కింది విధంగా మెమరీ reallocates:

464
00:28:35,690 --> 00:28:40,530
మీరు ఆ మెమరీ మరింత ఇవ్వాలని స్ట్రింగ్ చివరిలో గది ఇప్పటికీ ఉంది ఉంటే

465
00:28:40,530 --> 00:28:43,370
ఇది మొదట మీరు ఇస్తుంది కంటే, మీరు అదనపు మెమరీ పొందుతారు.

466
00:28:43,370 --> 00:28:46,640
కాబట్టి మీరు వెనక్కి తిరిగి తిరిగి తిరిగి తీగలను అక్షరాలు చూస్తూ చేయవచ్చు.

467
00:28:46,640 --> 00:28:49,290
ఆ సందర్భంలో కాదు అయితే, ఎందుకంటే మీరు చాలా పొడవుగా వేచి

468
00:28:49,290 --> 00:28:51,700
మరియు యాదృచ్ఛిక ఏదో మెమోరీలో plopped వచ్చింది, కానీ అదనపు లేదు

469
00:28:51,700 --> 00:28:56,480
ఇక్కడ డౌన్ మెమరీ, ఆ సరైందే. Realloc, మీరు అన్ని భారీ ట్రైనింగ్ చేయడానికి వెళ్తున్నారు

470
00:28:56,480 --> 00:28:58,810
, మీరు ఇప్పటివరకు ఇక్కడ నుండి చదివారు స్ట్రింగ్ తరలించడానికి

471
00:28:58,810 --> 00:29:02,550
అక్కడ దీనిని కాదని, ఆపై మీరు ఆ సమయంలో కొన్ని మరింత రన్వే ఇస్తాయి.

472
00:29:02,550 --> 00:29:05,610
కాబట్టి చేతి యొక్క కెరటంతో, నాకు ఏమి GetString చేస్తున్న ఆ అని పిలవబడు

473
00:29:05,610 --> 00:29:09,540
అది ఒక చిన్న బఫర్, బహుశా 1 సింగిల్ పాత్ర తో ప్రారంభమయ్యే అని

474
00:29:09,540 --> 00:29:12,300
మరియు 2 అక్షరాలు వినియోగదారు రకాల ఉంటే, GetString ముగుస్తుంది

475
00:29:12,300 --> 00:29:15,210
realloc కాల్ మరియు Ooh 'అన్నారు, 1 పాత్ర తగినంత లేదు.

476
00:29:15,210 --> 00:29:18,480
నాకు 2 అక్షరాలు ఇవ్వండి. ' మీరు, లూప్ యొక్క తర్కం ద్వారా రీడ్ అప్పుడు ఉంటే

477
00:29:18,480 --> 00:29:21,070
అది, Ooh ', 3 అక్షరాలు లో టైప్ యూజర్ చెప్పడానికి జరగబోతోంది.

478
00:29:21,070 --> 00:29:25,690
ఇప్పుడు కాదు 2 కాని 4 అక్షరాలు నాకు ఇవ్వండి, అప్పుడు నాకు 16 మరియు 32 ఇవ్వాలని తర్వాత, నాకు 8 ఇస్తాయి. '

479
00:29:25,690 --> 00:29:28,180
నేను సామర్థ్యం ప్రతి సమయం రెట్టింపు చేస్తున్నాను వాస్తవం

480
00:29:28,180 --> 00:29:30,320
బఫర్ నెమ్మదిగా వృద్ధి వెళ్ళడం లేదు అని అర్థం.

481
00:29:30,320 --> 00:29:35,870
ఇది సూపర్ ఫాస్ట్ పెరుగుతాయి అవకాశముంది, మరియు ఆ ప్రయోజనాన్ని కావచ్చు ఏమి?

482
00:29:35,870 --> 00:29:38,540
నేను యూజర్ అయినప్పటికీ, బఫర్ పరిమాణం రెట్టింపు am

483
00:29:38,540 --> 00:29:41,450
కేవలం కీబోర్డు నుండి 1 అదనపు పాత్ర అవసరం ఉండవచ్చు?

484
00:29:41,450 --> 00:29:44,830
[స్టూడెంట్ సమాధానం, అపారదర్శక]. >> అంటే ఆ?

485
00:29:44,830 --> 00:29:46,750
సరిగ్గా. మీరు తరచుగా పెరగడం లేదు.

486
00:29:46,750 --> 00:29:48,870
మరియు ఈ ఒక కేవలం రకం - you're ఇక్కడ మీ పందెం పరిమితం.

487
00:29:48,870 --> 00:29:54,150
దీనిని నెమ్మదిగా ఉంటుంది ఎందుకంటే మీరు, realloc చాలా కాల్ అనుకుంటున్న అనేది.

488
00:29:54,150 --> 00:29:56,840
మీరు వెంటనే చూస్తారు మీరు, మెమరీ కోసం ఆపరేటింగ్ సిస్టమ్ అడగండి ఏదైనా సమయం

489
00:29:56,840 --> 00:30:00,620
ఒక భవిష్యత్తు సమస్య సెట్ లో కొంత సమయం పడుతుంది ఉంటుంది.

490
00:30:00,620 --> 00:30:04,980
మీరు కొన్ని అంతరిక్ష వృధా చేసిన కూడా, సమయం ఆ మొత్తం తగ్గించడం కాబట్టి, ఒక మంచి విషయం ఉంటుంది.

491
00:30:04,980 --> 00:30:07,250
>> కానీ మేము ఇక్కడ GetString చివరి భాగం చదివి ఉంటే,

492
00:30:07,250 --> 00:30:10,880
మళ్ళీ ఇక్కడ ప్రతి లైన్ understanding నేడు అంత ముఖ్యమైనది కాదు.

493
00:30:10,880 --> 00:30:14,830
కానీ చివరికి మళ్ళీ malloc కాల్స్ అని గుర్తించలేకపోతే, మరియు అది కేటాయించుకునే

494
00:30:14,830 --> 00:30:16,980
అది స్ట్రింగ్ కోసం అనేక బైట్లు కావాలి వంటి ఖచ్చితంగా

495
00:30:16,980 --> 00:30:21,620
మరియు తర్వాత అతి భారీ బఫర్, ఉచిత కాల్ దూరంగా విసురుతాడు

496
00:30:21,620 --> 00:30:23,510
ఇది నిజంగానే చాలా సార్లు రెట్టింపు వస్తే.

497
00:30:23,510 --> 00:30:25,970
చిన్న లో, ఆ GetString ఈ సమయంలో పని చేస్తుంది ఎలా.

498
00:30:25,970 --> 00:30:30,100
అది మళ్లీ మళ్లీ మళ్లీ ఒకసారి ఒక పాత్ర చదవబడుతుంది

499
00:30:30,100 --> 00:30:37,930
మరియు అది కొన్ని అదనపు మెమరీ అవసరం ప్రతిసారీ, ఇది realloc కాల్ దాని కోసం ఆపరేటింగ్ సిస్టమ్ అడుగుతుంది.

500
00:30:37,930 --> 00:30:41,660
ఏదైనా ప్రశ్నలు? అన్ని కుడి.

501
00:30:41,660 --> 00:30:45,220
>> దాడి. మేము గమనికలు అర్థం ఇప్పుడు ఆ, లేదా కనీసం

502
00:30:45,220 --> 00:30:47,560
, గమనికలు విపరీతంగా తెలిసిన

503
00:30:47,560 --> 00:30:50,020
మొత్తం ప్రపంచం కూలిపోయింది మొదలవుతుంది ఎలా భావిస్తారు తెలియజేయండి

504
00:30:50,020 --> 00:30:53,160
మీరు చాలా పటిష్టమయిన వినియోగదారులు ఎదుర్కోవటానికి లేకపోతే,

505
00:30:53,160 --> 00:30:55,180
మీ వ్యవస్థ హాక్ ప్రయత్నిస్తున్న వ్యక్తులు.

506
00:30:55,180 --> 00:31:00,260
కొన్ని నమోదు కోడ్ అధిగమిస్తూ ద్వారా మీ సాఫ్ట్వేర్ దొంగిలించడానికి ప్రయత్నించిన వ్యక్తులు

507
00:31:00,260 --> 00:31:02,150
వారు సైన్ టైప్ చూపించే

508
00:31:02,150 --> 00:31:04,860
కేవలం సి కోడ్ ఇది ఇక్కడ ఈ ఉదాహరణ గమనించండి

509
00:31:04,860 --> 00:31:07,920
ఆ దిగువన ప్రధాన విధిగా కలిగి, ఆ, ఒక ఫంక్షన్ foo కాల్స్

510
00:31:07,920 --> 00:31:12,100
మరియు అది foo కు అక్కడ ఉన్న? [స్టూడెంట్] ఒక వాదన.

511
00:31:12,100 --> 00:31:15,660
>> సింగిల్ వాదన. కాబట్టి argv [1], ఇది వినియోగదారు టైప్ మొదటి పదం అర్థం

512
00:31:15,660 --> 00:31:19,150
a.out లేదా ఎలాగైనా తర్వాత కమాండ్ లైన్ వద్ద కార్యక్రమం.

513
00:31:19,150 --> 00:31:24,920
Foo కాబట్టి, ఎగువన, ఒక చార్ * లో జరుగుతుంది, కానీ చార్ * కేవలం ఏమిటి?

514
00:31:24,920 --> 00:31:28,860
స్ట్రింగ్. అక్కడ కొత్త ఏమీ ఇక్కడ, మరియు ఆ స్ట్రింగ్ ఏకపక్ష బార్ అని ఉంది.

515
00:31:28,860 --> 00:31:36,090
ఇక్కడ ఈ లైన్ లో చార్ సి [12], సెమీ సాంకేతిక ఆంగ్ల విధమైన లో, ఈ లైన్ ఏమి ఉంది?

516
00:31:36,090 --> 00:31:40,640
అర్రే -? అక్షరాలు. నాకు 12 అక్షరాలు యొక్క వ్యూహం ఇవ్వండి.

517
00:31:40,640 --> 00:31:44,970
కాబట్టి మేము ఈ ఒక బఫర్ కాల్ ఉండవచ్చు. ఇది సాంకేతికంగా సి అని, కానీ ప్రోగ్రామింగ్ ఒక బఫర్ యొక్క

518
00:31:44,970 --> 00:31:47,890
కేవలం మీరు కొన్ని విషయాలను సైన్ ఉంచవచ్చు ఆ స్థలాన్ని కొంత అర్థం

519
00:31:47,890 --> 00:31:49,940
>> అప్పుడు చివరగా, memcpy, మేము ముందు ఉపయోగిస్తారు చెయ్యలేదు.

520
00:31:49,940 --> 00:31:52,380
కానీ మీరు బహుశా దీన్ని ఏమి అంచనా. ఇది మెమరీ కాపీ చేస్తుంది.

521
00:31:52,380 --> 00:31:58,790
ఇది ఏమి చేస్తుంది? సరే, స్పష్టంగా, సి లోకి, దాని ఇన్పుట్, బార్ కాపీ

522
00:31:58,790 --> 00:32:03,420
కానీ మాత్రమే బార్ యొక్క పొడవు.

523
00:32:03,420 --> 00:32:07,440
కానీ ఇక్కడ ఒక బగ్ ఉంది.

524
00:32:07,440 --> 00:32:14,500
సరే, సాంకేతికంగా మేము నిజంగా (బార్) సరైన అని x sizeof (చార్), strlen చెయ్యాలి.

525
00:32:14,500 --> 00:32:17,920
కానీ ఇక్కడ చెత్త సందర్భంలో, ఆ యొక్క that's ఊహించుకోవటం తెలియజేయండి - కాబట్టి, సరే.

526
00:32:17,920 --> 00:32:23,760
అప్పుడు 2 దోషాలు ఉన్నాయి. కాబట్టి sizeof (చార్), హక్కు, యొక్క ఈ చిన్న విస్తృత తయారు చేద్దాము.

527
00:32:23,760 --> 00:32:28,860
కాబట్టి ఇప్పుడు ఏమి ఉంది బగ్, ఇప్పటికీ ఉంది?

528
00:32:28,860 --> 00:32:31,630
[స్టూడెంట్ సమాధానం, అపారదర్శక] దానికి >> చెక్? సరే, మేము తనిఖీ చేయాలి

529
00:32:31,630 --> 00:32:35,010
NULL కోసం, మీ పాయింటర్ NULL ఉన్నప్పుడు చెడు విషయాల జరిగే ఎందుకంటే,

530
00:32:35,010 --> 00:32:38,490
మీరు అక్కడ వెళ్ళటం ముగింపు పరిష్కారాలను, మరియు మీరు శూన్య వెళ్ళి చేయకూడదు ఎందుకంటే

531
00:32:38,490 --> 00:32:40,890
* ఆపరేటర్లు తో dereferencing ద్వారా.

532
00:32:40,890 --> 00:32:45,250
కాబట్టి మంచి, మరియు మేము ఏమి చేస్తున్నారు? తార్కికంగా ఒక దోషం చాలా ఇక్కడ ఉంది.

533
00:32:45,250 --> 00:32:47,650
[స్టూడెంట్ సమాధానం, అపారదర్శక]

534
00:32:47,650 --> 00:32:51,340
>> చేసుకుంటూ ఉంటే argc ≥ 2 తనిఖీ?

535
00:32:51,340 --> 00:32:54,130
సరే, ఈ కార్యక్రమంలో 3 దోషాలు ఇక్కడ ఉంది కాబట్టి.

536
00:32:54,130 --> 00:33:00,080
యూజర్ వాస్తవానికి argv [1], మంచి లోకి ఏదైనా టైప్ మేము తనిఖీ లేదు.

537
00:33:00,080 --> 00:33:02,240
కాబట్టి మూడవ బగ్ ఏది? Yeah?

538
00:33:02,240 --> 00:33:04,420
గుడ్ [స్టూడెంట్ సమాధానం, అపారదర్శక] >>.

539
00:33:04,420 --> 00:33:09,590
కాబట్టి మేము ఒక దృష్టాంతంలో తనిఖీ. మేము పరిపూర్ణంగా అధిక మెమరీ కాపీ లేదు తనిఖీ

540
00:33:09,590 --> 00:33:12,800
బార్ యొక్క పొడవు మించిపోతుంది కంటే.

541
00:33:12,800 --> 00:33:15,720
కాబట్టి స్ట్రింగ్ ఉంటే టైప్ యూజర్ 10 అక్షరాలు,

542
00:33:15,720 --> 00:33:18,260
ఈ 'మాత్రమే 10 అక్షరాలు కాపీ.', అని

543
00:33:18,260 --> 00:33:21,140
మరియు సరే, కానీ ఏం ప్రాంప్టులో పదం టైప్ యూజర్

544
00:33:21,140 --> 00:33:29,360
ఒక 20 పాత్ర పదం వంటి; ఈ విధంగా బార్ నుండి కాపీ 20 అక్షరాలు మాట్లాడుతూ, ఉంది?

545
00:33:29,360 --> 00:33:32,840
లేకపోతే మా బఫర్ అని పిలుస్తారు సి, ఇది మీరు డేటా రాశారు అర్థం

546
00:33:32,840 --> 00:33:35,950
మీరు స్వంతం కాని 8 బైట్ స్థానాలకు,

547
00:33:35,950 --> 00:33:38,320
మరియు మీరు వాటిని కేటాయించింది ఎప్పుడూ కోణంలో వాటిని కలిగి లేదు.

548
00:33:38,320 --> 00:33:41,190
కాబట్టి ఈ సాధారణంగా బఫర్ ఓవర్ఫ్లో దాడి గా పిలిచే ఏమిటి

549
00:33:41,190 --> 00:33:46,650
కోణంలో లేదా బఫర్ ఆక్రమిత దాడి, మరియు అది దాడి చేసే వినియోగదారు

550
00:33:46,650 --> 00:33:50,650
లేదా మీ చర్యను కాల్ చేసే కార్యక్రమం, హానికరమైన ఈ చేస్తోంది

551
00:33:50,650 --> 00:33:53,780
ఏ వాస్తవానికి తదుపరి చాలా చెడ్డ ఉంటుంది జరుగుతుంది.

552
00:33:53,780 --> 00:33:55,690
>> యొక్క ఇక్కడ ఈ చిత్రాన్ని చూసి లెట్.

553
00:33:55,690 --> 00:33:59,070
ఈ చిత్రం మెమరీ మీ స్టాక్ సూచిస్తుంది.

554
00:33:59,070 --> 00:34:01,050
మరియు, ప్రతిసారీ మీరు ఒక ఫంక్షన్ కాల్ గుర్తుచేసుకున్నారు

555
00:34:01,050 --> 00:34:04,520
మీరు స్టాక్ ఈ చిన్న Frame పొందండి మరియు వేరొక మరియు వేరొక మరియు వేరొక.

556
00:34:04,520 --> 00:34:07,250
మరియు ఇప్పటివరకు మేము కేవలం రకమైన మీరు దీర్ఘ చతురస్రాలు ఈ దూరంగా సంక్షిప్తమైన

557
00:34:07,250 --> 00:34:09,380
అక్కడ బోర్డులో లేదా ఇక్కడ తెరపై గాని.

558
00:34:09,380 --> 00:34:12,219
కానీ మేము ఆ దీర్ఘ చతురస్రాలు ఒక దగ్గరికి జూమ్ ఉంటే,

559
00:34:12,219 --> 00:34:16,460
మీరు ఒక ఫంక్షన్ foo కాల్, అది మరింత స్టాక్ న అక్కడ అవుతుంది

560
00:34:16,460 --> 00:34:18,739
ఆ ఫ్రేమ్ మరియు ఆ దీర్ఘ చతురస్రం యొక్క లోపల

561
00:34:18,739 --> 00:34:23,370
కంటే మేము swap గురించి మాట్లాడటం లేదు మాదిరిగా x మరియు y మరియు a మరియు b.

562
00:34:23,370 --> 00:34:25,949
ఇది కొన్ని తక్కువ స్థాయి వివరాలు ఉన్నాయి అవుతుంది

563
00:34:25,949 --> 00:34:27,780
వాటిలో చిరునామా తిరిగి.

564
00:34:27,780 --> 00:34:33,020
ప్రధాన foo కాల్స్ కనుక అది అవుతుంది, ప్రధాన foo సమాచారం ఉంటుంది

565
00:34:33,020 --> 00:34:36,760
కంప్యూటర్ యొక్క మెమరీ లో ఏం ప్రధాన యొక్క చిరునామా.

566
00:34:36,760 --> 00:34:40,659
లేకపోతే కనుక, వెంటనే foo వంటి, ఇక్కడ ఈ సందర్భంలో, అమలు చేయబడుతుంది

567
00:34:40,659 --> 00:34:43,790
ఒకసారి మీరు, foo చివరిలో ఈ దగ్గరి వంకర కలుపు చేరుకోవడానికి

568
00:34:43,790 --> 00:34:48,860
కార్యక్రమం యొక్క నియంత్రణను పడతాయని భావించబడుతోంది కౌంటీ ఎలా హెక్ foo తెలుసా?

569
00:34:48,860 --> 00:34:52,460
ఇది ఆ ప్రశ్నకు సమాధానం ఇక్కడ ఎరుపు దీర్ఘ చతురస్రం లో అని అవుతుంది.

570
00:34:52,460 --> 00:34:56,130
, ఈ ఒక పాయింటర్ సూచిస్తుంది, మరియు ఇది తాత్కాలికంగా నిల్వ చేయడానికి కంప్యూటర్ ఇష్టం

571
00:34:56,130 --> 00:35:00,250
అని పిలవబడే స్టాక్ న తద్వారా వెంటనే foo వంటి ప్రధాన యొక్క చిరునామా అమలు చేయబడుతుంది,

572
00:35:00,250 --> 00:35:04,110
కంప్యూటర్ పేరు మరియు వెళ్ళడానికి ప్రధాన లో ఏం లైన్ తెలుసు.

573
00:35:04,110 --> 00:35:06,900
సేవ్ ఫ్రేమ్ పాయింటర్ ఈ సమానంగా సంబంధం.

574
00:35:06,900 --> 00:35:09,620
ఇక్కడ చార్ * బార్ ఏమి సూచిస్తుంది?

575
00:35:09,620 --> 00:35:14,740
Well, ఇప్పుడు ఈ నీలం విభాగంలో ఇక్కడ foo యొక్క ఫ్రేమ్, బార్ ఏమిటి?

576
00:35:14,740 --> 00:35:18,300
సరే, బార్ foo ఫంక్షన్ కేవలం వాదన ఉంది.

577
00:35:18,300 --> 00:35:20,720
>> కాబట్టి ఇప్పుడు మేము తెలిసిన చిత్రాన్ని తిరిగి ఉన్నారు.

578
00:35:20,720 --> 00:35:22,960
స్క్రీన్ పై ఎక్కువ అంశాలను మరియు మరింత శుద్ధ ఉన్నాయి

579
00:35:22,960 --> 00:35:27,490
కానీ ఈ లేత నీలం విభాగంలో మేము swap వంటి వాటి కోసం సుద్ద బోర్డ్ పై చిత్రించడం చేసిన ఏమిటి.

580
00:35:27,490 --> 00:35:31,890
ఆ, బార్ ఇప్పుడు foo కోసం ఫ్రేమ్ మరియు అది మాత్రమే విషయం

581
00:35:31,890 --> 00:35:34,630
ఈ పారామితి ఉంది.

582
00:35:34,630 --> 00:35:39,840
కానీ ఏమి ఇక్కడ ఈ కోడ్ ప్రకారం, స్టాక్ ఉండాలి?

583
00:35:39,840 --> 00:35:44,280
చార్ సి [12]. కాబట్టి మేము కూడా, జ్ఞాపకశక్తి యొక్క 12 చతురస్రాలు చూస్తారు

584
00:35:44,280 --> 00:35:46,260
సి అనే వేరియబుల్ కు కేటాయించింది.

585
00:35:46,260 --> 00:35:48,340
నిజానికి మేము తెరపై ఆ ఉన్నాయి.

586
00:35:48,340 --> 00:35:51,650
చాలా టాప్ ఉంది సి [0] ఈ చిత్రం యొక్క, మరియు అప్పుడు రచయిత

587
00:35:51,650 --> 00:35:55,130
చతురస్రాలు అన్ని గీయడం కష్టం అయితే 12 నిజంగానే ఉన్నాయి లేదు

588
00:35:55,130 --> 00:36:00,120
ఎందుకంటే మీరు కుడి దిగువన చూడండి ఉంటే, సి [11], మీరు 0 నుండి COUNT ఉంటే, 12 అటువంటి బైట్లు.

589
00:36:00,120 --> 00:36:06,190
కానీ ఇక్కడ సమస్య: ఇది దిశలో సి పెరుగుతోంది?

590
00:36:06,190 --> 00:36:10,390
డౌన్ టాప్ క్రమీకరించు, కుడి? ఇది టాప్ మొదలవుతుంది మరియు దిగువ పెరుగుతాయి,

591
00:36:10,390 --> 00:36:13,480
మేము అన్ని వద్ద ఇక్కడ మేమే చాలా రన్వే వదిలి వలె కనిపించడం లేదు.

592
00:36:13,480 --> 00:36:15,320
మేము రకమైన, ఒక మూలలో మేమే పెయింట్ చేసిన

593
00:36:15,320 --> 00:36:20,210
మరియు ఆ C [11] స్టాక్ ఫ్రేమ్ పాయింటర్ వ్యతిరేకంగా హక్కు ఉంది దీనిలో బార్ పై కుడి అప్,

594
00:36:20,210 --> 00:36:23,800
ఇది తిరిగి చిరునామా వ్యతిరేకంగా హక్కు ఉంది; దీనిలో ఖాళీ లేదు.

595
00:36:23,800 --> 00:36:26,100
మీరు అప్ మేకు చేస్తే అంత, అప్పుడు, ఏది

596
00:36:26,100 --> 00:36:30,460
మరియు మీరు ఒక 12-బైట్ బఫర్ లోకి 20 బైట్లు reading ప్రయత్నించండి?

597
00:36:30,460 --> 00:36:33,460
ఎక్కడ ఆ 8 అదనపు బైట్లు వెళ్ళడానికి వెళ్తున్నారు?

598
00:36:33,460 --> 00:36:36,370
మిగతా వాటి లోపల, వీటిలో కొన్ని ముఖ్యమైన సూపర్ ఉంది.

599
00:36:36,370 --> 00:36:40,480
మరియు అతి ముఖ్యమైన విషయం, సమర్థవంతంగా, అక్కడ తిరిగి చిరునామా ఎరుపు బాక్స్ ఉంది.

600
00:36:40,480 --> 00:36:44,720
మీరు అనుకోకుండా లేదా adversarially అని అనుకుందాం ఎందుకంటే

601
00:36:44,720 --> 00:36:48,040
ఆ 4 బైట్లు, ఆ పాయింటర్ చిరునామా, తిరిగి రాస్తుంది

602
00:36:48,040 --> 00:36:53,190
కేవలం చెత్త తో, కాని మెమొరీ ఒక నిజమైన చిరునామా చేసేట్టు అనేక?

603
00:36:53,190 --> 00:36:55,930
తార్కికంగా implicaiton, ఏమిటి?

604
00:36:55,930 --> 00:36:59,080
[స్టూడెంట్ సమాధానాలు, అపారదర్శక] >> ఖచ్చితంగా. Foo వచ్చినప్పడు

605
00:36:59,080 --> 00:37:03,560
మరియు విజయవంతమైన వంకర కలుపు ఆ కార్యక్రమం, ప్రధాన తిరిగి ముందుకు అన్నారు

606
00:37:03,560 --> 00:37:08,320
ఆ ఎరుపు బాక్స్ లో ఉండే వస్తువు చిరునామా తిరిగి వెళుతున్న.

607
00:37:08,320 --> 00:37:11,560
>> ఇప్పుడు, మోసపూరిత సాఫ్ట్వేర్ నమోదు విషయంలో,

608
00:37:11,560 --> 00:37:14,400
కు తిరిగి చేసే చిరునామా ఏమిటి ఉంది

609
00:37:14,400 --> 00:37:18,820
సాధారణంగా మీరు సాఫ్ట్వేర్ చెల్లించిన తర్వాత అని మరియు మీ నమోదు కోడ్ ఇన్పుట్ పొందే?

610
00:37:18,820 --> 00:37:23,160
మీరు ఇక్కడ వెళ్ళడం లేదు లోకి ట్రిక్ కంప్యూటర్ యొక్క క్రమం, కానీ బదులుగా, ఇక్కడ వెళ్లి పోయింది.

611
00:37:23,160 --> 00:37:27,950
మీరు నిజంగా తెలివైన అయితే లేదా,, శత్రువులు నిజానికి, కీబోర్డ్ లో టైప్ చేయగలరు

612
00:37:27,950 --> 00:37:32,500
ఉదాహరణకు, వాస్తవ పదం, కాదు 20 అక్షరాలు, కాని అనుకుందాం అతను లేదా ఆమె

613
00:37:32,500 --> 00:37:36,200
కోడ్ ప్రాతినిధ్యం కొన్ని అక్షరాలు టైప్?

614
00:37:36,200 --> 00:37:38,860
మరియు అది సి కోడ్ మాత్రం కాదు, అది అక్షరాలు చేస్తాడు

615
00:37:38,860 --> 00:37:42,920
ఆ బైనరీ యంత్రం సంకేతాలు, 0 మరియు 1 యొక్క సూచిస్తాయి.

616
00:37:42,920 --> 00:37:46,740
కానీ వారు ఏదో GetString ప్రాంప్ట్ లోకి పేస్ట్, ఆ విధంగా చేయడానికి అంత తెలివైన ఉన్నారు అనుకుందాం

617
00:37:46,740 --> 00:37:49,460
ముఖ్యంగా కోడ్ కంపైల్ విధి,

618
00:37:49,460 --> 00:37:56,900
మరియు గత 4 బైట్లు ఆ తిరిగి చిరునామా తిరిగి రాస్తుంది, మరియు ఆ ఇన్పుట్ ఏమి చిరునామా చేస్తుంది?

619
00:37:56,900 --> 00:38:01,860
ఈ Red దీర్ఘ చతురస్రం బఫర్ యొక్క మొదటి బైట్ యొక్క చిరునామా లో నిల్వ చేస్తుంది.

620
00:38:01,860 --> 00:38:04,270
కాబట్టి మీరు నిజంగా తెలివైన ఉండాలి, మరియు ఈ విచారణ మరియు లోపం చాలా ఉంది

621
00:38:04,270 --> 00:38:08,500
చెడు అక్కడ ప్రజలు, కానీ మీరు ఈ బఫర్ ఎంత పెద్ద గుర్తించడానికి ఇస్తే, కోసం

622
00:38:08,500 --> 00:38:12,170
మీరు ప్రోగ్రామ్ ఇన్పుట్ లో గత కొన్ని బైట్లు అందించే అలాంటి

623
00:38:12,170 --> 00:38:15,970
మీ బఫర్ యొక్క ప్రారంభ చిరునామా సమానం కావడం,

624
00:38:15,970 --> 00:38:22,270
మీరు చేయవచ్చు. మేము చెప్పుకోవాలంటే, సాధారణంగా, హలో, మరియు \ 0, ఆ బఫర్ లో ముగుస్తుంది ఏమిటి.

625
00:38:22,270 --> 00:38:27,860
కానీ మాకు మరింత తెలివైన ఉన్నాము, మరియు మేము సామాన్యముగా దాడి కోడ్ పిలుస్తాను ఏమి ఆ బఫర్ పూర్తి ఉంటే,

626
00:38:27,860 --> 00:38:31,920
ఎ, ఎ, ఏ, A: ఎటాక్, దాడి, దాడి, దాడి, ఇది చెడు ఏదో చేసే ఏదో ఉంటుంది.

627
00:38:31,920 --> 00:38:35,190
Well, మీరు నిజంగా తెలివైన, మీరు దీన్ని ఉండవచ్చు జరుగుతుంది:

628
00:38:35,190 --> 00:38:41,740
80, CO, 35, 08: ఇక్కడ ఎరుపు బాక్స్ లో సంఖ్యల వరుస ఉంది.

629
00:38:41,740 --> 00:38:44,890
ఆ ఇక్కడ ఆ సంఖ్య సరిపోయే గమనించండి.

630
00:38:44,890 --> 00:38:47,280
ఇది రివర్స్ క్రమంలో, కానీ కొన్ని ఇతర సమయం ఎక్కువ.

631
00:38:47,280 --> 00:38:51,430
ఈ తిరిగి చిరునామా కావాలనే మార్పు అని గమనించండి

632
00:38:51,430 --> 00:38:54,970
ఇక్కడ చిరునామా అప్ సమం, ప్రధాన కాదు చిరునామా.

633
00:38:54,970 --> 00:39:00,170
చెడు వ్యక్తి సూపర్ స్మార్ట్ కాబట్టి, అతను లేదా ఆమె ఆ దాడి కోడ్ ఉన్నాయి అన్నారు

634
00:39:00,170 --> 00:39:02,890
ఏదో వంటి 'యూజర్ యొక్క ఫైళ్లు అన్ని తొలగించు.'

635
00:39:02,890 --> 00:39:06,320
లేదా 'నేను లాగిన్ ఒక వినియోగ ఖాతా సృష్టించుకోండి.' ', పాస్వర్డ్లను కాపీ' లేదా

636
00:39:06,320 --> 00:39:10,130
అన్ని వద్ద ఏదైనా; మరియు ఈ ప్రమాదంలో మరియు C. యొక్క శక్తి రెండూ

637
00:39:10,130 --> 00:39:12,900
మీరు గమనికలు ద్వారా మెమరీ ప్రాప్తి ఎందుకంటే

638
00:39:12,900 --> 00:39:15,950
మరియు మీరు కాబట్టి మీరు ఒక కంప్యూటర్ యొక్క మెమరీ లోనికి కావలసిన ఏదైనా వ్రాయవచ్చు.

639
00:39:15,950 --> 00:39:19,290
మీరు కంప్యూటర్ కేవలం మీరు ఏదైనా చే చేయవచ్చు

640
00:39:19,290 --> 00:39:22,780
తన సొంత మెమరీ ఖాళీలో చుట్టూ జంప్ అయ్యారు.

641
00:39:22,780 --> 00:39:27,230
కాబట్టి, ఈ రోజు, అనేక కార్యక్రమాలు మరియు రాజీ చాలా చాలా వెబ్ సైట్లు

642
00:39:27,230 --> 00:39:29,730
ఈ యొక్క ప్రయోజనాన్ని ప్రజలకు డౌన్ పొంగు.

643
00:39:29,730 --> 00:39:32,510
మరియు ఈ, సూపర్ ఆధునిక దాడులను వంటి కనిపిస్తుంది ఉండవచ్చు

644
00:39:32,510 --> 00:39:34,220
కానీ ఎప్పుడూ విధంగా మొదలు లేదు.

645
00:39:34,220 --> 00:39:36,770
>> రియాలిటీ, ఏ చెడ్డ వ్యక్తులు సాధారణంగా చేస్తుంది ఉంటుంది

646
00:39:36,770 --> 00:39:41,470
అది ఒక కమాండ్ లైన్ వద్ద ఒక కార్యక్రమం లేదా ఒక GUI ప్రోగ్రామ్ లేదా ఒక వెబ్సైట్, అయినా

647
00:39:41,470 --> 00:39:43,290
మీరు అర్ధంలేని అందించడం మొదలు ఉంది.

648
00:39:43,290 --> 00:39:46,940
మీరు, అన్వేషణ రంగంలో మరియు విజయవంతమైన ఎంటర్ ఒక నిజంగా పెద్ద పదం టైప్

649
00:39:46,940 --> 00:39:49,030
మరియు మీరు వెబ్సైట్ క్రాష్ చూడడానికి వేచి.

650
00:39:49,030 --> 00:39:53,270
లేదా మీరు ప్రోగ్రామ్ కొన్ని దోష సందేశం విశదపరుస్తుంది ఉంటే చూడటానికి వేచి.

651
00:39:53,270 --> 00:39:55,480
మీరు లక్కీ వస్తే, ఎందుకంటే చెడ్డ వ్యక్తి,

652
00:39:55,480 --> 00:39:59,610
మరియు మీరు, ప్రోగ్రామ్ కూలిపోతుంది కొన్ని క్రేజీ ఇన్పుట్ను అందించాలి

653
00:39:59,610 --> 00:40:02,280
ఆ ప్రోగ్రామర్ మీ ప్రవర్తనను ముందుగా లేదు అంటే

654
00:40:02,280 --> 00:40:05,420
ఇది తగినంత కృషి తో, మీరు బహుశా దీని అర్థం

655
00:40:05,420 --> 00:40:09,870
తగినంత విచారణ మరియు లోపం, మరింత ఖచ్చితమైన దాడి వేతనాన్ని ఎలా పూర్తి చేయాలో అంచనా.

656
00:40:09,870 --> 00:40:15,900
భద్రత కనుక చాలా భాగం కేవలం మొత్తంగా ఈ దాడులు తప్పించుకోవడం, కానీ వాటిని గుర్తించడం లేదు

657
00:40:15,900 --> 00:40:20,250
మరియు వాస్తవానికి లాగ్లను చూడటం మరియు క్రేజీ ఇన్పుట్లను మీ వెబ్సైట్లో టైప్ ప్రజలు ఏమి చూసిన.

658
00:40:20,250 --> 00:40:26,040
ఏ శోధన పదాలు కొన్ని బఫర్ పొంగిప్రవహిస్తున్న ఆశతో మీ వెబ్సైట్లో ప్రజలు టైప్ చేసిన తర్వాత?

659
00:40:26,040 --> 00:40:28,900
మరియు వ్యూహం ఏది సాధారణ బేసిక్స్ ఈ అన్ని దిమ్మల డౌన్,

660
00:40:28,900 --> 00:40:32,510
మరియు అది మెమరీని కేటాయించాల్సిన మరియు ఉపయోగించడానికి శతకము

661
00:40:32,510 --> 00:40:34,920
మరియు ఆ సంబంధించిన కూడా ఉంటుంది.

662
00:40:34,920 --> 00:40:37,520
>> కాబట్టి ఇంకా మళ్లీ హార్డు డ్రైవు యొక్క లోపల మెరుపు యొక్క అనుమతిస్తాయి.

663
00:40:37,520 --> 00:40:40,190
కాబట్టి మీరు రీకాల్ ఒక వారం లేదా రెండు క్రితం నుండి మీరు ఫైళ్ళను డ్రాగ్ ఉన్నప్పుడు

664
00:40:40,190 --> 00:40:45,470
మీ రీసైకిల్ బిన్ లేదా ట్రాష్ కెన్, ఏమి జరుగుతుంది?

665
00:40:45,470 --> 00:40:47,850
[స్టూడెంట్] ఏమీ లేదు. >> అవును, ఖచ్చితంగా ఏమీ. మీరు తక్కువ రన్ చివరికి ఉంటే

666
00:40:47,850 --> 00:40:51,370
డిస్క్ స్థలం మీద, Windows లేదా Mac OS మీరు ఫైళ్ళను తొలగించడంలో ప్రారంభమౌతుంది.

667
00:40:51,370 --> 00:40:53,670
మీరు అక్కడ ఏదో డ్రాగ్ అయితే, అది సురక్షితమైన అన్ని వద్ద కాదు.

668
00:40:53,670 --> 00:40:56,550
మీ roomate, స్నేహితుడు లేదా కుటుంబ సభ్యుడు చేయాలి డబుల్ క్లిక్ చేయండి, మరియు voila ఉంది.

669
00:40:56,550 --> 00:40:59,720
మీరు తొలగించాలనుకుంటున్నారా ప్రయత్నించిన అన్ని నమూనాలను ఫైళ్లు ఉన్నాయి.

670
00:40:59,720 --> 00:41:02,840
మాకు చాలా కాబట్టి కనీసం మీరు కుడి క్లిక్ చేయండి లేదా క్లిక్ నియంత్రించడానికి ఉందని మీకు

671
00:41:02,840 --> 00:41:05,320
మరియు ఖాళీ ట్రాష్, లేదా అలాంటిదే.

672
00:41:05,320 --> 00:41:07,900
అయితే అప్పుడు, అది చాలా ట్రిక్ విధంగా లేదు.

673
00:41:07,900 --> 00:41:11,340
మీరు మీ హార్డు డ్రైవు ఒక ఫైలుని కలిగి ఏమి జరుగుతుంది ఎందుకంటే

674
00:41:11,340 --> 00:41:14,590
కొన్ని పదం పత్రం లేదా కొన్ని JPEG సూచిస్తుంది?

675
00:41:14,590 --> 00:41:18,820
మరియు, ఈ మీ హార్డు డ్రైవు సూచిస్తుంది, మరియు లెట్స్ ఇక్కడ ఈ అంశం గురించి ఆలోచించారు ఫైల్ సూచిస్తుంది సే

676
00:41:18,820 --> 00:41:21,640
మరియు అది 0 మరియు 1 యొక్క మొత్తం బంచ్ కలిగివుంటుంది.

677
00:41:21,640 --> 00:41:25,470
మీరు మాత్రమే trashcan లేదా రీసైకిల్ బిన్ ఆ ఫైల్ డ్రాగ్ లేదు ఏమి, జరిగినప్పుడు

678
00:41:25,470 --> 00:41:30,390
కానీ ఖాళీ?

679
00:41:30,390 --> 00:41:32,820
ఏమీ అబ్బాయి. ఇది ఇప్పుడు పూర్తిగా ఏమీ కాదు.

680
00:41:32,820 --> 00:41:37,630
కొంచెం ఈ పట్టిక రూపంలో జరుగుతుంది ఎందుకంటే ఇప్పుడు అది కేవలం ఏమీ ఉంది.

681
00:41:37,630 --> 00:41:41,170
కాబట్టి ఒక కంప్యూటర్ యొక్క మెమరీ లోపల డేటాబేస్ లేదా పట్టిక యొక్క రకమైన లేదు

682
00:41:41,170 --> 00:41:44,470
ఆ ముఖ్యంగా, ఫైళ్లు పేర్లు 1 కాలమ్

683
00:41:44,470 --> 00:41:50,550
మరియు ఈ నగర 123, కేవలం ఒక యాదృచ్చిక సంఖ్య కావచ్చు ఫైల్ను యొక్క స్థానాన్ని, 1 కాలమ్.

684
00:41:50,550 --> 00:41:58,270
కాబట్టి మేము x.jpg లాగ, మరియు నగర 123 ఉండవచ్చు.

685
00:41:58,270 --> 00:42:02,870
మీరు మీ ట్రాష్ను ఖాళీ సమయంలో ఏది తర్వాత జరుగుతుంది?

686
00:42:02,870 --> 00:42:06,720
దూరంగా వెళ్ళే. కాని దూరంగా వెళ్ళి లేదు 0 మరియు 1 యొక్క ఉంటుంది.

687
00:42:06,720 --> 00:42:09,690
>> సో వాట్, అప్పుడు, కనెక్షన్ 4 pset చెయ్యాలో?

688
00:42:09,690 --> 00:42:13,460
Well, pset 4 తో, మేము అనుకోకుండా మాసిపోయిన చేసిన కనుక

689
00:42:13,460 --> 00:42:15,890
ఈ ఫోటోలు అన్ని ఉందని కాంపాక్ట్ ఫ్లాష్ కార్డ్,

690
00:42:15,890 --> 00:42:18,710
లేదా చెడు అదృష్టం అది పాడైన మారింది, ఎందుకంటే

691
00:42:18,710 --> 00:42:21,170
0 మరియు 1 యొక్క ఇప్పటికీ అక్కడ లేని కాదు.

692
00:42:21,170 --> 00:42:23,920
ఏదో పాడైన కాబట్టి బహుశా వాటిలో కొన్ని పోతాయి

693
00:42:23,920 --> 00:42:26,530
కొన్ని 0 యొక్క 1 మరియు 1 యొక్క మారింది కోణంలో 0 యొక్క మారింది.

694
00:42:26,530 --> 00:42:30,460
బగ్గీ సాఫ్ట్వేర్ లేదా హార్డ్వేర్ లోపాలు కారణంగా బాడ్ థింగ్స్ జరుగుతుంది.

695
00:42:30,460 --> 00:42:33,510
కానీ ఆ బైట్ల అనేక, బహుశా వాటిని కూడా 100%, ఇప్పటికీ

696
00:42:33,510 --> 00:42:38,330
అది JPEG 1 ప్రారంభించారు కంప్యూటర్ లేదా కెమెరా తెలియదని కేవలం యొక్క

697
00:42:38,330 --> 00:42:41,660
మరియు JPEG 2 ప్రారంభించారు, కాని మీరు, ప్రోగ్రామర్,

698
00:42:41,660 --> 00:42:45,800
ఆ JPEGs లేదా వారు వంటి చూడవచ్చు పేరు అవగాహన ఒక బిట్ తో, తెలిసిన,

699
00:42:45,800 --> 00:42:49,570
మీరు 0 మరియు 1 యొక్క విశ్లేషించేందుకు మరియు Ooh ', చెప్పగలదు. JPEG. , JPEG Ooh. '

700
00:42:49,570 --> 00:42:52,830
మీరు తప్పనిసరిగా ఒక కోసం ఒక ప్రోగ్రామ్ను రాయడం లేదా అయితే లూప్

701
00:42:52,830 --> 00:42:56,100
ఆ ఫైళ్ళను ప్రతి ఒక కోలుకుంటుంది.

702
00:42:56,100 --> 00:42:59,360
పాఠం తరువాత, "సురక్షితంగా" మీ ఫైళ్ళను erasing ప్రారంభించడానికి ఉంటుంది

703
00:42:59,360 --> 00:43:01,720
మీరు పూర్తిగా ఈ నివారించడానికి చెయ్యాలనుకుంటే. అవును?

704
00:43:01,720 --> 00:43:06,940
[స్టూడెంట్ ప్రశ్న, అపారదర్శక]

705
00:43:06,940 --> 00:43:11,150
>> మీరు ముందు కన్నా ఎక్కువ మెమొరి -

706
00:43:11,150 --> 00:43:14,790
ఓహ్! ప్రశ్న గుడ్. ఎందుకు, అప్పుడు, ట్రాష్ ను ఖాళీ తర్వాత,

707
00:43:14,790 --> 00:43:18,300
మీ కంప్యూటర్ మీరు ముందు కన్నా ఎక్కువ ఖాళీని కలిగి మీరు చెప్పండి లేదు?

708
00:43:18,300 --> 00:43:22,450
క్లుప్తంగా, అది అబద్ధం ఎందుకంటే. సాంకేతికంగా, మీరు మరింత ఖాళీని కలిగి ఉన్నారా.

709
00:43:22,450 --> 00:43:26,720
ఇప్పుడు మీరు చెప్పారు కాబట్టి ఆ ఫైల్ ఒకప్పుడు పేరు, మీరు ఇతర విషయాలను పెట్టవచ్చు,

710
00:43:26,720 --> 00:43:28,930
కానీ, బిట్స్ దూరంగా వెళ్తున్నారు కాదు

711
00:43:28,930 --> 00:43:33,070
మరియు ఆ బిట్స్ మీ రక్షణ కొరకు, ఉదాహరణకు, అన్ని 0 యొక్క మార్చబడింది ఉంటాయి కాదు.

712
00:43:33,070 --> 00:43:37,520
దీనికి విరుద్ధంగా, మీరు "సురక్షితంగా" చెరిపివేయి ఫైళ్లు, లేదా భౌతికంగా పరికరాన్ని నాశనం ఉంటే,

713
00:43:37,520 --> 00:43:40,810
ఆ నిజంగా ఆ చుట్టూ, కొన్నిసార్లు మాత్రమే మార్గం.

714
00:43:40,810 --> 00:43:45,300
ఎందుకు మేము ఆ సెమీ స్కేరీ గమనిక న విడిచి, మరియు మేము సోమవారం మీరు చూస్తారు.

715
00:43:45,300 --> 00:43:52,810
CS50.TV