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

2
00:00:02,860 --> 00:00:04,860
[డేవిడ్ J. మలన్ - హార్వర్డ్ యూనివర్శిటీ]

3
00:00:04,860 --> 00:00:07,260
[ఈ CS50 ఉంది. - CS50.TV]

4
00:00:07,260 --> 00:00:09,740
>> ఈ CS50, వీక్ 5 ఉంది.

5
00:00:09,740 --> 00:00:12,900
నేడు మరియు ఈ వారం, మేము ఫోరెన్సిక్స్ ప్రపంచం యొక్క కొద్దిగా పరిచయం

6
00:00:12,900 --> 00:00:14,850
సమస్య యొక్క సందర్భంలో 4 సెట్ చెయ్యండి.

7
00:00:14,850 --> 00:00:18,480
ఇక్కడ ఒక ప్రత్యేక సంఘటన తర్వాత అక్కడ ఎందుకంటే నేడు ఒక సంక్షిప్త ప్రసంగం ఉంటుంది.

8
00:00:18,480 --> 00:00:21,940
కాబట్టి మేము ఒక పరికించండి మరియు విద్యార్థులు మరియు అలైక్ తల్లిదండ్రులు నేడు రెండు బాధించటం చేస్తాము

9
00:00:21,940 --> 00:00:24,600
హోరిజోన్ మీద ఉన్న కొన్ని విషయాలు తో.

10
00:00:24,600 --> 00:00:29,050
>> వాటిలో, సోమవారం నాటికి, మీరు కొన్ని సహ విద్యార్థులను ఉంటుంది.

11
00:00:29,050 --> 00:00:32,980
edX, హార్వర్డ్ మరియు ఓపెన్ కోర్స్ వేర్ మరియు మరిన్ని కోసం MIT యొక్క కొత్త ఆన్లైన్ చొరవ,

12
00:00:32,980 --> 00:00:36,730
సోమవారం వచ్చి దాని సోమవారం, న హార్వర్డ్ యొక్క ప్రాంగణంలో ప్రారంభించాయి

13
00:00:36,730 --> 00:00:40,930
మీరు, గత లెక్కింపు యొక్క, 86,000 అదనపు సహ విద్యార్థులను ఉంటుంది

14
00:00:40,930 --> 00:00:43,680
CS50 యొక్క ఉపన్యాసాలు మరియు విభాగాలు తో చేసిన పాటు క్రింది విధంగా కనిపిస్తుంది

15
00:00:43,680 --> 00:00:45,890
మరియు పూర్తి వివరణలు మరియు సమస్య సెట్లు.

16
00:00:45,890 --> 00:00:51,870
మరియు ఈ భాగంగా, మీరు CS50 మరియు ఇప్పుడు CS50x ప్రారంభ స్థాయి సభ్యుల అవుతుంది.

17
00:00:51,870 --> 00:00:56,150
ఈ భాగంగా ఇప్పుడు అలాగే కొన్ని చేయబడనపుడు ఉంటుంది అని తెలుసుకోవటం.

18
00:00:56,150 --> 00:01:00,620
విద్యార్ధులు భారీ సంఖ్యలో, ఈ కోసం సిద్ధంగా ఉండటానికి,

19
00:01:00,620 --> 00:01:03,820
చెప్పడానికి అది తగినంత మేము 108 TFS మరియు CA ల లేనప్పటికీ,

20
00:01:03,820 --> 00:01:07,560
మేము విద్యార్ధులు 80,000 హిట్ ఒకసారి చాలా ఉత్తమ విద్యార్థుల గురువు నిష్పత్తి కాదు.

21
00:01:07,560 --> 00:01:09,830
మేము, మానవీయంగా సెట్స్ చాలా సమస్య శ్రేణి కావడం లేదు

22
00:01:09,830 --> 00:01:13,050
కాబట్టి సమస్య సెట్ లో ఈ వారం పరిచయం, CS50 చెక్ ఉంటుంది

23
00:01:13,050 --> 00:01:15,410
ఉపకరణం లోపల ఆదేశ పంక్తి సౌలభ్యాన్ని మాత్రం ఇది

24
00:01:15,410 --> 00:01:17,880
మీరు ఈ వారాంతంలో తరువాత అప్డేట్ ఒకసారి మీరు పొందుతారు ఆ.

25
00:01:17,880 --> 00:01:21,030
మీరు, మీ స్వంత pset ఒక ఆదేశం, check50, అమలు చేయగలరు

26
00:01:21,030 --> 00:01:24,770
మరియు మీరు మీ కార్యక్రమాన్ని సరైన లేదా తప్పు అన్నది తక్షణ చూడు పొందుతారు

27
00:01:24,770 --> 00:01:27,980
మేము అందించిన వివిధ డిజైన్ లక్షణాలు ప్రకారం.

28
00:01:27,980 --> 00:01:30,310
సమస్య సెట్ వివరణలో ఆ మరింత.

29
00:01:30,310 --> 00:01:34,220
CS50x సహ విద్యార్థులను కూడా ఈ ఉపయోగించారు.

30
00:01:34,220 --> 00:01:36,170
>> సమస్య సెట్ 4, అన్ని ఫోరెన్సిక్స్ గురించి

31
00:01:36,170 --> 00:01:38,630
మరియు ఈ pset నిజంగా కొన్ని వాస్తవ విషయాలను ప్రేరణతో

32
00:01:38,630 --> 00:01:41,210
దానిద్వారా నేను గ్రాడ్యుయేట్ పాఠశాలలో ఉన్నప్పుడు నేను కొంతకాలం ఖైదు

33
00:01:41,210 --> 00:01:45,270
మిడిల్సెక్స్ కౌంటీ యొక్క జిల్లా అటార్నీ కార్యాలయం ఫోరెన్సిక్ పని తో

34
00:01:45,270 --> 00:01:47,660
వారి ప్రధాన ఫోరెన్సిక్ పరిశోధకుడిని తో.

35
00:01:47,660 --> 00:01:50,280
నేను కొన్ని వారాలు పేర్కొన్నారు ఆలోచించినట్లు ఈ, మొత్తం

36
00:01:50,280 --> 00:01:52,720
మాస్ రాష్ట్ర పోలీసు లేదా ఇతరులు వస్తాయి ఉంది

37
00:01:52,720 --> 00:01:56,150
వారు, హార్డ్ డ్రైవ్లు మరియు CD లు మరియు ఫ్లాపీ డిస్కుల మరియు వంటి వంటి వాటిని ఆఫ్ పడిపోతాయనే

38
00:01:56,150 --> 00:01:58,770
ఆపై ఫోరెన్సిక్స్ కార్యాలయం గోల్ నిర్ధారించేందుకు ఉంది

39
00:01:58,770 --> 00:02:01,470
ఉంది లేదా కొన్ని రకాల ఆధారాలు కాదని.

40
00:02:01,470 --> 00:02:04,730
ఈ స్పెషల్ ఇన్వెస్టిగేషన్స్ యూనిట్, అందువలన ఇది వైట్ కాలర్ నేరం జరిగింది.

41
00:02:04,730 --> 00:02:10,949
ఈ నేరాలు ఎక్కువగా ఇబ్బంది పెట్టే విధమైన, డిజిటల్ మీడియా రకమైన పాల్గొన్న ఏదైనా ఉంది.

42
00:02:10,949 --> 00:02:16,450
ఇది చాలా మంది చెప్పడం ఇమెయిల్ వ్రాయటం లేదు అని, "నేను చేసింది." ఆ అవుతుంది

43
00:02:16,450 --> 00:02:20,490
కాబట్టి తరచూ, ఈ ఫోరెన్సిక్ శోధనలు, అన్ని ఎక్కువ పండు వైపు లేదు

44
00:02:20,490 --> 00:02:22,820
కానీ కొన్నిసార్లు ప్రజలు ఇమెయిళ్ళు రాస్తుంది.

45
00:02:22,820 --> 00:02:25,240
కాబట్టి కొన్నిసార్లు ప్రయత్నాలు దక్కించుకున్నారు.

46
00:02:25,240 --> 00:02:31,210
>> కానీ ఈ ఫోరెన్సిక్ pset, మేము pset4 లో గ్రాఫిక్స్ ఒక బిట్ పరిచయం అవుతారు అప్ దారితీసింది.

47
00:02:31,210 --> 00:02:35,410
బహుశా మీరు ఆమోదింపబడిన ఈ విషయాలను తీసుకుని - JPEGs, GIF లు, మరియు వంటి - ఈ రోజులు.

48
00:02:35,410 --> 00:02:38,320
కానీ మీరు నిజంగా దాని గురించి అనుకుంటే, ఒక చిత్రం, చాలా రాబ్ ముఖం వంటి,

49
00:02:38,320 --> 00:02:41,270
చుక్కలు లేదా పిక్సెళ్ళు క్రమం వలె తయారు చేయవచ్చు.

50
00:02:41,270 --> 00:02:43,380
రాబ్ ముఖం యొక్క సందర్భంలో, రంగులు అన్ని రకాల ఉన్నది

51
00:02:43,380 --> 00:02:46,760
మరియు మేము, లేకపోతే పిక్సెళ్ళు అని పిలుస్తారు వ్యక్తి చుక్కలు, చూడండి ప్రారంభించారు

52
00:02:46,760 --> 00:02:48,610
ఒకసారి మేము సైన్ జూమ్ ప్రారంభించారు

53
00:02:48,610 --> 00:02:54,660
కానీ ప్రపంచంలో ఒక బిట్ సులభతరం మరియు ఈ ఇక్కడ నలుపు మరియు తెలుపు రాబ్ అని చెప్పుకోవాలంటే,

54
00:02:54,660 --> 00:02:57,490
నలుపు మరియు తెలుపు ప్రాతినిధ్యం, మేము బైనరీ ఉపయోగించవచ్చు.

55
00:02:57,490 --> 00:03:01,660
మరియు మేము బైనరీ ఉపయోగించడానికి వెళుతున్న ఉంటే, 1 లేదా 0, మేము ఈ అదే చిత్రం వ్యక్తీకరించవచ్చు

56
00:03:01,660 --> 00:03:06,140
బిట్స్ ఈ నమూనాతో రాబ్ యొక్క నవ్వే ముఖం యొక్క.

57
00:03:06,140 --> 00:03:12,100
11000011 తెలుపు, తెలుపు, నలుపు, నలుపు, నలుపు, నలుపు, తెలుపు, తెలుపు సూచిస్తుంది.

58
00:03:12,100 --> 00:03:16,150
మరియు అందువలన, రంగురంగుల ఛాయాచిత్రాలను గురించి మాట్లాడటం మొదలు తర్వాత భారీ లీపు కాదు

59
00:03:16,150 --> 00:03:18,600
మీరు Facebook లో చూడండి లేదా ఒక డిజిటల్ కెమెరా తో తీసుకోవాలని భావిస్తున్నట్టు విషయాలు.

60
00:03:18,600 --> 00:03:21,410
కానీ ఖచ్చితంగా అది రంగులు విషయానికి వస్తే, మీరు మరింత బిట్స్ అవసరం.

61
00:03:21,410 --> 00:03:25,690
మరియు ఛాయాచిత్రాల ప్రపంచంలో చాలా సాధారణ, 1-bit రంగు ఉపయోగిస్తారు

62
00:03:25,690 --> 00:03:29,560
ఈ సూచించును, అయితే 24-bit రంగు, మీరు నిజంగా రంగులు మిలియన్ల చోటే. వంటి

63
00:03:29,560 --> 00:03:32,250
కాబట్టి మేము రాబ్ యొక్క కంటికి జూమ్ చేసినప్పుడు సందర్భంలో,

64
00:03:32,250 --> 00:03:36,370
వివిధ రంగుల అవకాశాలను మిలియన్ల ఏ సంఖ్య.

65
00:03:36,370 --> 00:03:39,040
కాబట్టి మేము, ప్రాబ్లం సెట్ 4 పాటు walkthrough ఈ పరిచయం చేస్తాము

66
00:03:39,040 --> 00:03:43,370
ఎందుకంటే ఇక్కడ శుక్రవారం ఉపన్యాసం యొక్క సాధారణ 2.30 బదులుగా 3:30 వద్ద నేడు అవుతుంది.

67
00:03:43,370 --> 00:03:46,620
కానీ వీడియో సాధారణ రేపు వంటి ఆన్లైన్ ఉంటుంది.

68
00:03:46,620 --> 00:03:48,820
>> మేము కూడా మరొక ఫైల్ ఫార్మాట్ మీరు పరిచయం చేస్తాము.

69
00:03:48,820 --> 00:03:51,270
ఈ ఉద్దేశపూర్వకంగా, మొదటి వద్ద భయపెట్టడం చూడండి ఉద్దేశించబడింది

70
00:03:51,270 --> 00:03:55,670
కానీ ఈ ఒక సి struct కోసం కొన్ని డాక్యుమెంటేషన్ ఉంది.

71
00:03:55,670 --> 00:03:58,940
ఇది Microsoft సంవత్సరాల క్రితం ఈ ఫార్మాట్ ప్రసిద్ధం చేసింది ఆ అవుతుంది

72
00:03:58,940 --> 00:04:05,150
Bitmap ఫైల్ ఫార్మాట్, BMP, మరియు ఈ ఒక సూపర్ సాధారణ, రంగురంగుల గ్రాఫికల్ ఫైల్ ఫార్మాట్ చెయ్యబడింది

73
00:04:05,150 --> 00:04:10,150
ఆ డెస్క్టాప్లు న సంక్రాంతి కొన్నిసార్లు ఇంకా కొంత సమయం కోసం ఉపయోగిస్తారు మరియు జరిగినది.

74
00:04:10,150 --> 00:04:14,760
మీరు Windows XP మరియు కొండలు, నీలి ఆకాశం తిరిగి భావిస్తే,

75
00:04:14,760 --> 00:04:17,170
సాధారణంగా ఒక bmp లేదా బిట్మ్యాప్ చిత్రం ఉంది.

76
00:04:17,170 --> 00:04:19,959
వారు ఒక బిట్ మరింత సంక్లిష్టత ఎందుకంటే బిట్ మ్యాప్ చిత్రాలన్నీ మా ఆహ్లాదకరమైన.

77
00:04:19,959 --> 00:04:22,610
ఇది చాలా 0 సె మరియు 1s ఈ గ్రిడ్ వంటి సాధారణము ఉంది.

78
00:04:22,610 --> 00:04:27,510
బదులుగా, మీరు ఒక ఫైల్ ప్రారంభంలో ఒక శీర్షిక వంటి వాటిని కలిగి ఉంటాయి.

79
00:04:27,510 --> 00:04:31,990
కాబట్టి లోపల. BMP ఫైల్ ఇతర పదాలు లో 0 సె మరియు 1s యొక్క మొత్తం బంచ్, ఉంది

80
00:04:31,990 --> 00:04:34,910
అయితే కొన్ని అదనపు 0 సె మరియు 1s ఉంది.

81
00:04:34,910 --> 00:04:38,220
మరియు అది సంవత్సరాలు మంజూరు కోసం మనం బహుశా తీసిన చేసిన అవుతుంది -

82
00:04:38,220 --> 00:04:45,170
. డిఓసి లేదా. xls లేదా. mp3, వంటి ఫైల్ ఫార్మాట్లు. mp4, ఏ ఫైల్ ఫార్మాట్లు

83
00:04:45,170 --> 00:04:48,480
మీకు తెలిసిన ఆ - ఏది కూడా, ఒక ఫైల్ ఫార్మాట్ అని అర్థం లేదు

84
00:04:48,480 --> 00:04:52,480
రోజు చివరిలో ఈ ఫైళ్ల యొక్క అన్ని మేము 0 సె మరియు 1s ఉపయోగాన్ని ఎందుకంటే.

85
00:04:52,480 --> 00:04:56,810
మరియు ఇంకా ఆ 0 సె మరియు 1s ASCII ద్వారా ABC లేదా ఇలాంటి ప్రాతినిధ్యం

86
00:04:56,810 --> 00:04:58,820
కానీ రోజు చివరిలో, అది ఇప్పటికీ కేవలం 0 సె మరియు 1s ఉంది.

87
00:04:58,820 --> 00:05:02,100
కాబట్టి మానవులు కేవలం అప్పుడప్పుడు కొత్త ఫైల్ ఫార్మాట్ కనుగొనడమే నిర్ణయించుకుంటారు

88
00:05:02,100 --> 00:05:06,420
వారు బిట్స్ క్రమాలు వాస్తవానికి ప్రభావితం చేస్తుంది ప్రామాణికంగా పేరు.

89
00:05:06,420 --> 00:05:09,220
మరియు ఇక్కడ ఈ సందర్భంలో, ఫొల్క్స్ Bitmap ఫైల్ ఫార్మాట్ ఆకృతి చేసిన

90
00:05:09,220 --> 00:05:15,620
ఒక Bitmap ఫైల్ లో మొట్టమొదటి బైట్ వద్ద, అక్కడ ఆఫ్సెట్ 0 చే సూచిస్తారు చెప్పారు,

91
00:05:15,620 --> 00:05:18,940
కొన్ని cryptically అనే వేరియబుల్ అని bfType, ఉన్నట్లు అన్నారు

92
00:05:18,940 --> 00:05:23,080
కేవలం Bitmap ఫైల్ రకం కోసం నిలుచునే, ఏ Bitmap ఫైల్ రకం ఉంటుంది.

93
00:05:23,080 --> 00:05:27,700
మీరు 2 ఆఫ్సెట్ ఆ రెండవ వరుసలో, బైట్ సంఖ్య 2, బహుశా ప్రతిపాదించే చేయవచ్చు

94
00:05:27,700 --> 00:05:33,740
ఏ ప్రాతినిధ్యం 0 సె మరియు 1s ఒక ఆకృతిని కలిగి ఉంటుంది? ఏదో యొక్క పరిమాణం.

95
00:05:33,740 --> 00:05:35,310
మరియు అది అక్కడి నుండి వెళ్లి.

96
00:05:35,310 --> 00:05:37,410
కాబట్టి సమస్య సెట్ 4 లో, మీరు ఈ విషయాలు కొన్ని సంచరించింది వస్తారు.

97
00:05:37,410 --> 00:05:39,520
మేము వాటిని అన్ని గురించి caring కొనసాగిస్తున్నాను కనిపిస్తుంది.

98
00:05:39,520 --> 00:05:47,510
కానీ బైట్ 54 చుట్టూ ఆసక్తికరమైన పొందడానికి మొదలవుతుంది గ్రహించండి: rgbtBlue, గ్రీన్, మరియు Red.

99
00:05:47,510 --> 00:05:52,110
మీరు విన్న ఉంటే ఎక్రోనిం RGB - ఎరుపు, ఆకుపచ్చ, నీలం - ఈ కు సూచన

100
00:05:52,110 --> 00:05:54,610
అది అవుతుంది ఎందుకంటే మీరు ఇంద్రధనుస్సు రంగులు అన్ని చిత్రీకరించాడు

101
00:05:54,610 --> 00:05:58,180
ఎరుపు మరియు నీలం మరియు ఆకుపచ్చ కొన్ని కలిపి.

102
00:05:58,180 --> 00:06:03,320
నిజానికి, గదిలో తల్లిదండ్రులు ప్రారంభ ప్రొజెక్టర్లు కొన్ని గుర్తు ఉండవచ్చు.

103
00:06:03,320 --> 00:06:05,890
ఈ రోజుల్లో, మీరు, ఒక ప్రకాశవంతమైన కాంతి ఒక కటకాల రావడం చూడండి

104
00:06:05,890 --> 00:06:09,800
అయితే తన రోజు లో మీరు, ఎరుపు లెన్స్, నీలం లెన్స్, మరియు ఆకుపచ్చ లెన్స్ కలిగి

105
00:06:09,800 --> 00:06:13,380
మరియు కలిసి వారు ఒక స్క్రీన్ లక్ష్యంగా మరియు ఒక రంగుల చిత్రాన్ని ఏర్పాటు.

106
00:06:13,380 --> 00:06:16,270
మరియు తరచూ, మాధ్యమిక పాఠశాలలు మరియు ఉన్నత పాఠశాలలు ఆ కటకములు ఉంటుంది

107
00:06:16,270 --> 00:06:19,720
ఇంత కొద్దిగా వంకరగా, కాబట్టి మీరు డబుల్ లేదా ట్రిపుల్ చిత్రాలు చూసిన యొక్క విధమైన.

108
00:06:19,720 --> 00:06:24,100
కానీ ఆ ఆలోచన. మీరు ఒక చిత్రాన్ని పెయింట్ ఎరుపు మరియు ఆకుపచ్చ మరియు నీలం కాంతి కలిగి.

109
00:06:24,100 --> 00:06:26,590
అదే సూత్రాన్ని కంప్యూటర్లు ఉపయోగిస్తారు.

110
00:06:26,590 --> 00:06:30,230
>> కాబట్టి సమస్య మీ కోసం అప్పుడు సవాళ్లు మధ్య సెట్ 4 కొన్ని అంశాలను వెళ్తున్నారు.

111
00:06:30,230 --> 00:06:34,800
ఒకటి ఏమిటంటే ఒక చిత్రం పరిమాణాన్ని చెప్పవచ్చు, 0 సె మరియు 1s ఒక నమూనాలో తీసుకోవాలని,

112
00:06:34,800 --> 00:06:40,200
, 0 సె మరియు 1s యొక్క భాగాలు నిర్మాణంలో ఈ వంటి ప్రాతినిధ్యం ఇది గుర్తించడానికి

113
00:06:40,200 --> 00:06:43,630
రెడ్స్, బ్లూస్, ఆకుకూరలు - మరియు తర్వాత పిక్సెళ్ళు నకలు ఎలా పూర్తి చేయాలో అంచనా -

114
00:06:43,630 --> 00:06:46,660
లోపల కాబట్టి చిత్రాన్ని మొదట ఈ కనిపిస్తోంది ఉన్నప్పుడు,

115
00:06:46,660 --> 00:06:49,210
ఆ తర్వాత బదులుగా ఇలా ఉండవచ్చు.

116
00:06:49,210 --> 00:06:53,640
ఇతర సవాళ్ళను మధ్య చాలా మీరు ఒక ఫోరెన్సిక్ చిత్రం జారీ చేస్తాము అని అన్నారు

117
00:06:53,640 --> 00:06:56,030
ఒక డిజిటల్ కెమెరా నుండి ఒక నిజమైన ఫైల్.

118
00:06:56,030 --> 00:06:58,960
మరియు ఆ కెమెరా, ఒకసారి ఒక సమయం మీద, ఫోటోలను మొత్తం బంచ్ ఉన్నారు.

119
00:06:58,960 --> 00:07:03,760
సమస్య మేము అనుకోకుండా మాసిపోయిన లేదా చిత్రం ఏదో పాడైన కలిగి ఉంది.

120
00:07:03,760 --> 00:07:05,750
బాడ్ థింగ్స్ డిజిటల్ కెమెరాలు తో జరిగే.

121
00:07:05,750 --> 00:07:09,150
కాబట్టి మేము త్వరగా మీకు, ఆ కార్డు యొక్క 0 సె మరియు 1s ఆఫ్ అన్ని కాపీ

122
00:07:09,150 --> 00:07:13,610
4 సెట్ ఒక పెద్ద ఫైలు వాటిని సేవ్, మరియు అప్పుడు మేము సమస్య అవి మీకు చేతితో చేస్తాము

123
00:07:13,610 --> 00:07:19,320
మీరు ఆదర్శంగా ఆ JPEGs అన్ని పునరుద్ధరించడానికి తో సి ఒక ప్రోగ్రామ్ను రాయడం చేయవచ్చు.

124
00:07:19,320 --> 00:07:23,330
మరియు వారు ఒక క్లిష్టమైన ఫైల్ ఆకృతి యొక్క కొంతవరకు ఉన్నప్పటికీ, ఆ JPEGs అవుతుంది -

125
00:07:23,330 --> 00:07:26,360
వారు చాలా క్లిష్టమైన ఇక్కడ ఈ నవ్వే ముఖం కంటే మీరే -

126
00:07:26,360 --> 00:07:31,160
ప్రతి JPEG 0 సె మరియు 1s అదే నమూనాలను తో ప్రారంభమయ్యే అవుతుంది.

127
00:07:31,160 --> 00:07:35,630
కాబట్టి ఉపయోగించి, చివరకు, లూప్ లేదా ఇలాంటి కోసం కొంత లూప్ లేదా,

128
00:07:35,630 --> 00:07:38,880
మీరు, ఈ ఫోరెన్సిక్ చిత్రం అన్ని 0 సె మరియు 1s పైగా iterate చేయవచ్చు

129
00:07:38,880 --> 00:07:43,150
మరియు మీరు సమస్య సెట్ స్పెసిఫికేషన్ లో నిర్వచించబడింది చేసే ప్రత్యేక నమూనా చూడండి ప్రతి సమయం,

130
00:07:43,150 --> 00:07:47,880
మీరు చాలా ఎక్కువ సంభావ్యత ఒక JPEG ప్రారంభంలో ఇక్కడ పొందవచ్చు.

131
00:07:47,880 --> 00:07:51,230
మరియు వెంటనే మీకు ఇదే పంధాను బైట్లు కొన్ని సంఖ్య కనుగొనేందుకు వంటి

132
00:07:51,230 --> 00:07:55,430
లేదా లు లేదా మెగాబైట్ల తరువాత, మీరు ఇక్కడ పొందవచ్చు, రెండో JPEG ఉంది

133
00:07:55,430 --> 00:07:57,380
ఫోటో నేను మొదటి ఒక తర్వాత పట్టింది.

134
00:07:57,380 --> 00:08:01,370
నాకు ఆ మొదటి ఫైల్ చదవడం ఆపి లెట్, ఈ కొత్త రాయటం మొదలుపెట్టాలని

135
00:08:01,370 --> 00:08:06,310
మరియు pset4 మీ ప్రోగ్రామ్ అవుట్పుట్ చాలా 50 JPEGs అని అన్నారు.

136
00:08:06,310 --> 00:08:09,270
50 JPEGs కాదు ఉంటే, మీరు ఒక లూప్ యొక్క ఒక బిట్ కలిగి ఉంటాయి.

137
00:08:09,270 --> 00:08:12,490
మీరు JPEGs ఒక అనంతమైన ఉంటే, మీరు ఒక అనంతమైన లూప్ ఉన్నాయి.

138
00:08:12,490 --> 00:08:14,910
కాబట్టి ఆ చాలా చాలా సాధారణ విషయం ఉంటుంది.

139
00:08:14,910 --> 00:08:16,600
కాబట్టి ఆ క్షితిజాన్ని ఆన్ ఏమిటి.

140
00:08:16,600 --> 00:08:21,310
>> మాకు వెనుక 0 క్విజ్, హ్యాపీ రెండు వారు వారిని స్థిరముగా ఉన్నాయి నా ఇమెయిల్ శాతం తెలుసుకుంటారు

141
00:08:21,310 --> 00:08:23,640
తటస్థ, మరియు క్విజ్ చుట్టూ విచారంగా 0 సమయంలో అబ్బాయి.

142
00:08:23,640 --> 00:08:26,800
మరియు తల TF Zamyla, మీ స్వంత TF, నాకు చేరుకోవడానికి దయచేసి

143
00:08:26,800 --> 00:08:31,180
మీరు విషయాలను వెళ్లి ఎలా చర్చించడానికి అని మీరు తెలుసు CA ల లేదా ఒక.

144
00:08:31,180 --> 00:08:35,539
>> కాబట్టి గది లో ఇక్కడ తల్లిదండ్రులు ఆకట్టుకోవడానికి, CS50 లైబ్రరీ ఏమిటి?

145
00:08:36,429 --> 00:08:40,390
[నవ్వు] గుడ్ జాబ్.

146
00:08:40,390 --> 00:08:48,340
CS50 లైబ్రరీ ఏమిటి? అవును. >> [విద్యార్థి] ఇది కోడ్ యొక్క ముందుగా రాసిన సెట్ యొక్క [వినబడని]

147
00:08:48,340 --> 00:08:49,750
సరే, మంచి.

148
00:08:49,750 --> 00:08:53,240
ఇది మేము సిబ్బంది రాసిన కోడ్ యొక్క ముందుగా రాసిన సెట్ కు, మేము, మీకు అందించడానికి

149
00:08:53,240 --> 00:08:55,030
ఆ, కొన్ని సాధారణ కార్యాచరణ అందిస్తుంది

150
00:08:55,030 --> 00:08:59,020
నాకు స్ట్రింగ్ పొందండి వంటి అంశాలు, నాకు పొందండి ఒక పూర్ణాంకానికి - ఇక్కడ జాబితా చేసిన పనులను అన్ని.

151
00:08:59,020 --> 00:09:02,260
>> ఇప్పుడు మొదలు, మేము నిజంగా ఈ శిక్షణ చక్రాలు టేకాఫ్ ప్రారంభించండి.

152
00:09:02,260 --> 00:09:05,050
మీరు ఒక స్ట్రింగ్ దూరంగా తీసుకుని ఆరంభమవుతుంది చేస్తున్నారు

153
00:09:05,050 --> 00:09:08,870
ఇది రీకాల్ ఏమి వాస్తవ డేటా రకం కోసం ఒక పర్యాయపదంగా ఉంది? >> [బహుళ విద్యార్థులు] చార్ *.

154
00:09:08,870 --> 00:09:12,730
చార్ *. తల్లిదండ్రులు కోసం, ఆ బహుశా [చేస్తుంది whooshing ధ్వని] ఉంది. ఆ బావుంటుంది.

155
00:09:12,730 --> 00:09:17,550
చార్ * మేము, మేము మా పదజాలం నుండి స్ట్రింగ్ తొలగించడానికి అన్ని మరింత తెరపై చూడడానికి మీరు

156
00:09:17,550 --> 00:09:19,730
వాస్తవానికి కోడ్ రాయడం దానిని వస్తుంది కనీసం ఉన్నప్పుడు.

157
00:09:19,730 --> 00:09:22,840
అదేవిధంగా, మేము ఈ విధులను కొన్ని ఎక్కువ ఉపయోగించి ఆపడానికి ఉంటాం

158
00:09:22,840 --> 00:09:25,280
మా కార్యక్రమాలు మరింత అధునాతన పొందగలిగిన ఎందుకంటే.

159
00:09:25,280 --> 00:09:28,480
కంటే, ఒక ప్రాంప్టు మెరిసే తో అక్కడ కూర్చుని ప్రోగ్రాములను వ్రాయటానికి

160
00:09:28,480 --> 00:09:31,870
ఏదో టైప్ వినియోగదారు వేచి, మరొకచోట నుండి మీరు మీ ఇన్పుట్లను పొందుతారు.

161
00:09:31,870 --> 00:09:35,490
ఉదాహరణకు, మీరు స్థానిక హార్డు డ్రైవు బిట్స్ వరుస నుండి పొందుతారు.

162
00:09:35,490 --> 00:09:38,580
మీరు బదులుగా, ఒక నెట్వర్క్ కనెక్షన్ నుండి భవిష్యత్తులో వాటిని పొందుతారు

163
00:09:38,580 --> 00:09:40,230
ఎక్కడో కొన్ని వెబ్సైట్.

164
00:09:40,230 --> 00:09:44,110
>> కాబట్టి మొదటి సారి తిరిగి ఈ పొర చర్మము యొక్క Let మరియు CS50 ఉపకరణం పుల్ అప్

165
00:09:44,110 --> 00:09:49,010
మీరు # వారాలు సహా చేసిన ఇది cs50.h అని మరియు ఈ ఫైలు,,

166
00:09:49,010 --> 00:09:51,140
కానీ వాస్తవానికి యొక్క ఈ లోపల ఏమి చూడటానికి.

167
00:09:51,140 --> 00:09:54,430
నీలం లో ఫైల్ టాప్ కేవలం వ్యాఖ్యల మొత్తం బంచ్ ఉంది:

168
00:09:54,430 --> 00:09:57,050
వారంటీ సమాచారం మరియు లైసెన్సింగ్.

169
00:09:57,050 --> 00:09:59,050
ఈ సాఫ్ట్వేర్ ఒక సాధారణ ఉదాహరణ యొక్క విధమైన ఉంది

170
00:09:59,050 --> 00:10:01,580
సాఫ్ట్వేర్ చాలా ఈ రోజులు ఓపెన్ సోర్స్ అని ఏమి ఎందుకంటే,

171
00:10:01,580 --> 00:10:05,220
ఇది ఎవరైనా కోడ్ రాసిన మరియు స్వేచ్ఛగా అందుబాటులో ఉంది అంటే

172
00:10:05,220 --> 00:10:10,470
కేవలం అమలు చేయడానికి మరియు ఉపయోగించడానికి కానీ చదివి మార్పు మరియు మీ స్వంత కృతి కలిసిపోవడానికి.

173
00:10:10,470 --> 00:10:14,660
తద్వారా మీరు చాలా చిన్న రూపంలో అయితే, ఓపెన్ సోర్స్ సాఫ్ట్ వేర్ ఉపయోగించి చేసిన ఏమిటి.

174
00:10:14,660 --> 00:10:18,560
నేను వ్యాఖ్యలను గత స్క్రోల్ డౌన్ ఉంటే, అయితే, మేము కొన్ని మరింత చేరువైన విషయాలు చూడండి మొదలుపెడతారు.

175
00:10:18,560 --> 00:10:25,010
Cs50.h ఫైల్ హెడర్ ఫైళ్ళ మొత్తం బంచ్ కలిగి ఇక్కడ ఎగువన నోటీసు.

176
00:10:25,010 --> 00:10:28,560
వీటిలో చాలా మేము ముందు చూడని, కానీ ఒక సుపరిచితమే.

177
00:10:28,560 --> 00:10:32,270
ఈ ఏది మేము ఇప్పటివరకు, క్లుప్తంగా, అయినప్పటికీ చూసిన? >> [విద్యార్థి] ప్రామాణిక లైబ్రరీ.

178
00:10:32,270 --> 00:10:35,810
అవును, ప్రామాణిక లైబ్రరీ. stdlib.h malloc ఉంది.

179
00:10:35,810 --> 00:10:38,320
ఒకసారి మేము, డైనమిక్ మెమరీ కేటాయింపు గురించి మాట్లాడటం మొదలుపెట్టాడు

180
00:10:38,320 --> 00:10:41,650
మేము అదే వచ్చే వారం తిరిగి వచ్చి మేము, ఆ ఫైల్ను సహా ప్రారంభించారు.

181
00:10:41,650 --> 00:10:46,640
ఇది bool మరియు నిజమైన మరియు తప్పుడు వాస్తవానికి సి కేవలంగా లో లేని అవుతుంది

182
00:10:46,640 --> 00:10:49,440
మీరు ఇక్కడ ఈ ఫైలు ఉన్నాయి తప్ప.

183
00:10:49,440 --> 00:10:52,710
మేము వారాలు stdbool.h సహా చేశారు

184
00:10:52,710 --> 00:10:55,620
మీరు ఒక, bool ఒప్పు లేదా తప్పు. భావన ఉపయోగించడానికి ఆ

185
00:10:55,620 --> 00:10:58,620
ఈ లేకుండా, మీరు నకిలీ అది యొక్క క్రమం మరియు ఒక పూర్ణాంకానికి ఉపయోగించవలసి వస్తుంది

186
00:10:58,620 --> 00:11:02,610
మరియు కేవలం ఏకపక్ష 0 తప్పుగా మరియు 1 నిజమైన భావించవలసి.

187
00:11:02,610 --> 00:11:07,150
మేము మరింత స్క్రోల్ డౌన్ ఉంటే, ఇక్కడ ఒక స్ట్రింగ్ యొక్క మా నిర్వచనం ఉంది.

188
00:11:07,150 --> 00:11:11,390
ఈ నక్షత్రం పేరు నిజంగా ప్రాధాన్యత లేదు, మేము ముందు చెప్పారు చేసిన వంటి, అవుతుంది.

189
00:11:11,390 --> 00:11:13,720
మీరు కూడా అన్ని చుట్టూ ఖాళీ చేయవచ్చు.

190
00:11:13,720 --> 00:11:16,740
మేము ఈ సెమిస్టర్ స్పష్టంగా ఈ గా ప్రచారం చేశారు

191
00:11:16,740 --> 00:11:18,620
స్టార్, రకం సంబంధం కలిగి ఉంటుంది, ఆ

192
00:11:18,620 --> 00:11:21,700
కొంచెం సాధారణంగా అయితే, కేవలం వంటి సాధారణ తెలుసుకుంటారు

193
00:11:21,700 --> 00:11:24,430
అక్కడ ఉంచారు, కానీ క్రియాశీలంగా ఒకే విషయం.

194
00:11:24,430 --> 00:11:27,720
మేము మరింత డౌన్ చదవండి అయితే ఇప్పుడు, యొక్క GetInt పరిశీలించి తెలియజేయండి

195
00:11:27,720 --> 00:11:32,190
మేము ఏదైనా ఈ సెమిస్టర్ ముందు బహుశా మొదటి ఉపయోగిస్తారు ఎందుకంటే.

196
00:11:32,190 --> 00:11:37,440
ఇక్కడ GetInt ఉంది. ఈ ఏమిటి? >> [విద్యార్థి] ఒక నమూనా. >> ఇది ఒక నమూనా ఉంది.

197
00:11:37,440 --> 00:11:41,410
తరచుగా, మేము మా యొక్క టాప్స్ వద్ద నమూనాలను నిలబెట్టాయి. సి ఫైళ్లు,

198
00:11:41,410 --> 00:11:46,690
కానీ మీరు కూడా ఇక్కడ ఈ విధంగా శీర్షిక ఫైళ్లు,. h ఫైళ్లు, ప్రోటోటైప్స్ ఉంచవచ్చు

199
00:11:46,690 --> 00:11:50,840
తద్వారా మీరు కొన్ని విధులు రాయడానికి మీరు, ఇతర వ్యక్తులు ఉపయోగించవచ్చు చేయదలిచిన

200
00:11:50,840 --> 00:11:53,550
ఇది ఖచ్చితంగా CS50 లైబ్రరీ సందర్భంలో

201
00:11:53,550 --> 00:11:57,040
మీరు, cs50.c లాగ మీ విధులు అమలు మాత్రమే

202
00:11:57,040 --> 00:12:02,790
మీరు కూడా లేదు ఫైల్ ఎగువన కానీ శీర్షికా ఫైలును ఎగువన నమూనాలను ఉంచండి.

203
00:12:02,790 --> 00:12:07,170
ఆ శీర్షికా ఫైలును స్నేహితులు మరియు సహచరులు హాజరవుతారు ఏమిటి

204
00:12:07,170 --> 00:12:09,760
తో # వారి స్వంత కోడ్ చేర్చండి.

205
00:12:09,760 --> 00:12:12,210
ఈ సమయంలో, మీరు, ఈ నమూనాలను అన్ని సహా చేసిన

206
00:12:12,210 --> 00:12:16,580
సమర్థవంతంగా మీ ఫైల్ ఎగువన కానీ ఈ మార్గం ద్వారా # యంత్రాంగం ఉన్నాయి

207
00:12:16,580 --> 00:12:20,070
మీ స్వంత లోకి ఇది అత్యవసరంగా కాపీలు మరియు ముద్ద ఈ ఫైలు.

208
00:12:20,070 --> 00:12:23,070
ఇక్కడ కొన్ని విశదమైన డాక్యుమెంటేషన్ ఉంది.

209
00:12:23,070 --> 00:12:25,640
GetInt ఒక పూర్ణాంకానికి అందుతుంది అని మంజూరు కోసం మేము చాలా చక్కని తీసుకున్నారు,

210
00:12:25,640 --> 00:12:27,640
కొన్ని సందర్భాలలో మూలలో ఉన్నాయి అవుట్ కానీ మారుతుంది.

211
00:12:27,640 --> 00:12:31,810
నా quintillion, మార్గం చాలా పెద్దది ఒక సంఖ్య లోని యూజర్ రకాల ఉంటే,

212
00:12:31,810 --> 00:12:35,490
కేవలం ఒక పూర్ణాంకానికి లోపలి సరిపోవు? ఊహించిన ప్రవర్తన ఏమిటి?

213
00:12:35,490 --> 00:12:38,020
ఆదర్శవంతంగా, ఊహించదగిన ఉంది.

214
00:12:38,020 --> 00:12:40,280
కాబట్టి ఈ విషయంలో, మీరు నిజంగా, ఫైన్ ప్రింట్ చదివినట్లయితే

215
00:12:40,280 --> 00:12:44,500
మీరు నిజంగా ఆ లైన్ తెలుసుకోలేదు ఉంటే, ఈ రాబడి INT_MAX చూస్తారు.

216
00:12:44,500 --> 00:12:48,320
మేము ఈ గురించి మాట్లాడారు, కానీ దాని పెట్టుబడి ఆధారంగా అది ఏ కావచ్చు ఎప్పుడూ చేసిన?

217
00:12:48,320 --> 00:12:50,640
[విద్యార్థి] స్థిరమైన. >> అది స్థిరమైన ఉంది.

218
00:12:50,640 --> 00:12:54,770
ఇది బహుశా ఆ శీర్షిక ఫైళ్లు ఒక ప్రకటించబడిన కొన్ని ప్రత్యేక స్థిరంగా ఉంది

219
00:12:54,770 --> 00:13:00,090
, ఆ ఫైల్ లో ఎక్కువ, మరియు INT_MAX సుమారు 2 బిలియన్ వంటి బహుశా విషయం

220
00:13:00,090 --> 00:13:04,990
మేము ఏదో ఏదో సూచిస్తుంది అవసరం ఎందుకంటే దీనికి ఆలోచన, తప్పు జరిగింది

221
00:13:04,990 --> 00:13:10,700
మేము, అవును, మా పారవేయడం వద్ద 4 బిలియన్ సంఖ్యలు ఉంటాయి: -2 బిలియన్ 2 బిలియన్ న, ఇవ్వాలని లేదా పడుతుంది.

222
00:13:10,700 --> 00:13:14,710
Well, ఏ ప్రోగ్రామింగ్ కూడా సాధారణం, మీరు ఆ సంఖ్యల ఒక దొంగతనం ఉంది

223
00:13:14,710 --> 00:13:18,920
బహుశా 0, బహుశా 2 బిలియన్, బహుశా -2 బిలియన్,

224
00:13:18,920 --> 00:13:23,280
మీరు ప్రపంచానికి కమిట్ విధంగా కాబట్టి మీరు మీ సాధ్యమయ్యే విలువలను ఒకటి ఖర్చు

225
00:13:23,280 --> 00:13:26,820
ఏదో తప్పు పోతే, నేను ఈ సూపర్ పెద్ద విలువ అందిస్తుంది.

226
00:13:26,820 --> 00:13:31,030
కానీ మీరు యూజర్ 234 వంటి నిగూఢ ఏదో టైప్ అనుకోవడం లేదు ..., చాల పెద్ద సంఖ్య.

227
00:13:31,030 --> 00:13:34,060
మీరు స్థిరమైన వంటి బదులుగా క్రమపరచుట.

228
00:13:34,060 --> 00:13:38,060
మీరు గత కొన్ని వారాల ఆసన అనే చేస్తే నిజంగా, ఏ సమయంలో మీరు, GetInt అని

229
00:13:38,060 --> 00:13:42,900
పరిస్థితి INT_MAX వినియోగదారు టైప్ చేశారా మీరు ఒక తో తనిఖీ వుండాలి,

230
00:13:42,900 --> 00:13:46,590
లేదా, మరింత ప్రత్యేకంగా, అది చేస్తే ఎందుకంటే, GetInt తిరిగి INT_MAX చేశాడు,

231
00:13:46,590 --> 00:13:51,830
వాస్తవానికి వారు టైపు లేదు అని అర్థం. ఏదో ఈ విషయంలో తప్పు జరిగింది.

232
00:13:51,830 --> 00:13:56,080
కాబట్టి ఈ సాధారణంగా కేవలం ప్రత్యేక అంటే ఒక సెంటినెల్ విలువ, గా పిలిచే దాన్ని ఉంది.

233
00:13:56,080 --> 00:13:58,120
>> . సి ఫైలు మారిపోతాయి ఇప్పుడు చూద్దాం.

234
00:13:58,120 --> 00:14:01,340
సి ఫైల్ కొంత సమయం కోసం పరికరంలోని ఉనికిలో ఉంది.

235
00:14:01,340 --> 00:14:06,840
నిజానికి, ఉపకరణం ఇది పూర్వ సంకలనం మేము వస్తువు కోడ్ అనే విషయం లోకి మీరు కలిగి

236
00:14:06,840 --> 00:14:09,540
సిస్టమ్ తెలుసు ఎందుకంటే అది ఎక్కడ కానీ అది కేవలం మీకు సంబంధించిన లేదు

237
00:14:09,540 --> 00:14:11,730
ఈ సందర్భంలో అది ఎక్కడ ఉంది: ఉపకరణం.

238
00:14:11,730 --> 00:14:17,400
ఈ సమయంలో GetInt మరియు GetInt పని ఎలా ఇప్పుడు స్క్రోల్ డౌన్ లెట్ యొక్క.

239
00:14:17,400 --> 00:14:19,460
ఇక్కడ మేము ముందు నుంచి సారూప్య వ్యాఖ్యలు ఉన్నాయి.

240
00:14:19,460 --> 00:14:21,660
నాకు కేవలం కోడ్ భాగం లో జూమ్ లెట్.

241
00:14:21,660 --> 00:14:23,900
మరియు మేము GetInt కోసం కింది ఉంది.

242
00:14:23,900 --> 00:14:25,700
ఇది ఇన్పుట్ పడుతుంది.

243
00:14:25,700 --> 00:14:29,510
, ఇది (నిజమైన) అయితే, ఒక పూర్ణాంకానికి తిరిగి, కాబట్టి మేము ఒక ఉద్దేశపూర్వక అనంతమైన లూప్ కలిగి

244
00:14:29,510 --> 00:14:33,180
కానీ బహుశా మేము ఏదో ఈ యొక్క బయటకు లేదా ఈ లోపల నుండి తిరిగి వస్తుంది.

245
00:14:33,180 --> 00:14:34,870
>> ఎలా ఈ పనులు చూసేలా.

246
00:14:34,870 --> 00:14:39,240
మేము, లూప్ లోపల ఈ మొదటి లైన్ లో 166 GetString ఉపయోగించి కనిపిస్తుంది.

247
00:14:39,240 --> 00:14:43,780
ఏ పరిస్థితుల్లో GetString తిరిగి ఎందుకంటే ఈ ఇప్పుడు మంచి పద్ధతి

248
00:14:43,780 --> 00:14:47,660
ప్రత్యేక కీవర్డ్ NULL? >> [విద్యార్థి] ఏదో తప్పు జరిగితే ఉంటే.

249
00:14:47,660 --> 00:14:51,630
ఏదో తప్పు జరిగితే ఉంటే. మరియు మీరు GetString లాగ కాల్ చేసినప్పుడు తప్పు ఏ?

250
00:14:54,960 --> 00:14:57,640
అవును. >> [విద్యార్థి] malloc అది ints ఇవ్వాలని విఫలమైతే.

251
00:14:57,640 --> 00:14:59,150
అవును. బహుశా malloc విఫలమైతే.

252
00:14:59,150 --> 00:15:03,190
ఎక్కడో హుడ్ కింద, GetString మెమరీ కేటాయించుకునే ఇది malloc, కాల్

253
00:15:03,190 --> 00:15:06,020
వర్ణాల అన్ని కంప్యూటర్ స్టోర్ చేయడానికి అనుమతిస్తుంది

254
00:15:06,020 --> 00:15:07,750
ఆ కీబోర్డ్ లో యూజర్ రకాల.

255
00:15:07,750 --> 00:15:11,590
మరియు, యూజర్ ఖాళీ సమయంలో మొత్తం చాల ఉన్నాయి మరియు ఉదాహరణకు, ఎక్కువ టైప్ అనుకుందాం

256
00:15:11,590 --> 00:15:16,160
కంప్యూటర్ కంటే ఎక్కువ అక్షరాలు, కంటే 2 బిలియన్ అక్షరాలు కూడా RAM కలిగి ఉంది.

257
00:15:16,160 --> 00:15:19,250
GetString మీరు ఆ సూచిస్తుంది సామర్థ్యాన్ని కలిగి ఉండాలి.

258
00:15:19,250 --> 00:15:22,560
ఈ సూపర్, సూపర్ అసాధారణ మూలలో కేసు కూడా ఉంటే

259
00:15:22,560 --> 00:15:24,340
ఇది ఏదో ఈ నిర్వహించడానికి సామర్థ్యాన్ని కలిగి ఉండాలి

260
00:15:24,340 --> 00:15:28,750
అందువలన మేము తిరిగి వెళ్లి తన డాక్యుమెంటేషన్ చదవండి ఉంటే, GetString, నిజానికి తిరిగి NULL లో చేస్తుంది.

261
00:15:28,750 --> 00:15:34,460
GetString NULL రావడం ద్వారా విఫలమైతే కాబట్టి ఇప్పుడు ఉంటే, GetInt INT_MAX రావడం ద్వారా విఫలం అన్నారు

262
00:15:34,460 --> 00:15:37,690
ఒక సెంటినెల్ వంటి. ఇవి మానవ సమావేశాలు ఉంటాయి.

263
00:15:37,690 --> 00:15:41,450
ఇదే తెలుసు మాత్రమే మార్గం డాక్యుమెంటేషన్ చదవడం ద్వారా ఉంది.

264
00:15:41,450 --> 00:15:45,040
>> Int వాస్తవానికి సంపాదించిన కౌంటీ క్రిందికి స్క్రోల్ లెట్ యొక్క.

265
00:15:45,040 --> 00:15:51,160
నేను ఒక బిట్ మరింత స్క్రోల్ డౌన్ ఉంటే, లైన్ 170 లో, మేము ఈ మార్గాల పైన వ్యాఖ్య ఉందా.

266
00:15:51,160 --> 00:15:55,100
మేము 172 లో ఒక Int, n, మరియు ఒక చార్, సి, మరియు ఈ కొత్త ఫంక్షన్, డిక్లేర్

267
00:15:55,100 --> 00:15:58,930
మీరు కొన్ని, sscanf ముందు అంతటా డెక్కన్ ఛార్జర్స్ చేశారు.

268
00:15:58,930 --> 00:16:00,870
ఈ స్ట్రింగ్ scanf సూచిస్తుంది.

269
00:16:00,870 --> 00:16:05,700
ఇతర మాటలలో, నాకు స్ట్రింగ్ ఇవ్వాలని నేను ఆసక్తికరమైన సమాచారం ముక్కలు కోసం స్కాన్ చేస్తుంది.

270
00:16:05,700 --> 00:16:07,360
ఆ శతకము

271
00:16:07,360 --> 00:16:11,800
నేను Enter ని అప్పుడు కీబోర్డ్ వద్ద 123, వాచ్యంగా, టైపు ఆ అనుకుందాం.

272
00:16:11,800 --> 00:16:16,470
GetString ద్వారా తిరిగి 123 యొక్క డేటా రకం ఏమిటి? >> [విద్యార్థి] స్ట్రింగ్.

273
00:16:16,470 --> 00:16:18,380
ఇది కుడి, స్పష్టంగా ఒక స్ట్రింగ్ ఏమిటి? నేను ఒక స్ట్రింగ్ వచ్చింది.

274
00:16:18,380 --> 00:16:23,220
కాబట్టి 123, నిజంగా కోట్-unquote, అది ముగింపులో \ 0 తో 123 ఉంది.

275
00:16:23,220 --> 00:16:27,110
ఒక Int కాదు. ఒక సంఖ్య కాదు. ఇది అనేక కనిపిస్తోంది అయితే కాదు.

276
00:16:27,110 --> 00:16:29,080
సో వాట్ GetInt లేదు లేదు?

277
00:16:29,080 --> 00:16:35,750
123 \ 0 - - మరియు ఏదో ఒక వాస్తవ పూర్ణాంక మీరు మార్చిన ఇది ఎడమ ఆ స్ట్రింగ్ స్కాన్ ఉంటుంది.

278
00:16:35,750 --> 00:16:37,850
మీరు దీన్ని ఎలా పూర్తి చేయాలో అంచనా కాలేదు.

279
00:16:37,850 --> 00:16:41,450
మీరు pset2 తిరిగి భావిస్తే, మీరు బహుశా సీజర్ గల చిన్న సౌకర్యవంతమైన వచ్చింది

280
00:16:41,450 --> 00:16:44,820
లేదా విజెనెరే, కాబట్టి మీరు స్ట్రింగ్ పైగా iterate, మీరు ints కు అక్షరాలు మార్చవచ్చు.

281
00:16:44,820 --> 00:16:46,710
కానీ హెక్, ఇది మొత్తం పలు అంశాలు.

282
00:16:46,710 --> 00:16:49,860
ఎందుకు మీరు ఆ చేసే sscanf వంటి ఫంక్షన్ కాల్?

283
00:16:49,860 --> 00:16:54,230
కాబట్టి sscanf ఒక వాదన ఆశిస్తున్నట్లు - ఈ సందర్భంలో లైన్ స్ట్రింగ్ ఇది అని.

284
00:16:54,230 --> 00:17:01,840
అప్పుడు మీరు ఈ స్ట్రింగ్ లో చూడాలనుకుంటున్నారా ఏమి, సమానమైన కు printf, కోట్స్ లో పేర్కొనండి.

285
00:17:01,840 --> 00:17:09,000
మరియు నేను ఏ ఇక్కడ చెప్పడం నేను నేను దశాంశ సంఖ్య చేసి ఒక పాత్ర చూడాలనుకుంటున్నారా ఉంది.

286
00:17:09,000 --> 00:17:12,000
ఈ ఒక్క నిమిషం లో కేసు ఎందుకు మరియు మేము చూస్తారు.

287
00:17:12,000 --> 00:17:15,869
మరియు ఈ సంజ్ఞామానం ఇప్పుడు stuff గుర్తుచేస్తుంది ఆ అవుతుంది మేము గురించి మాట్లాడటం మొదలుపెట్టాడు

288
00:17:15,869 --> 00:17:17,619
ఒక వారం క్రితం మీద.

289
00:17:17,619 --> 00:17:21,740
ఏమిటి & n మరియు & సి ఇక్కడ మాకు చేయడం? >> [విద్యార్థి] n యొక్క చిరునామా మరియు సి యొక్క చిరునామా.

290
00:17:21,740 --> 00:17:25,400
అవును. ఇది నాకు సి యొక్క n మరియు చిరునామా చిరునామా ఇచ్చి ఉన్నారు. ఎందుకు ముఖ్యమైనది?

291
00:17:25,400 --> 00:17:30,220
మీరు C లో విధులు, మీరు ఎల్లప్పుడూ అన్ని వద్ద ఒక విలువ లేదా సంఖ్య విలువ తిరిగి ఆ తెలుసు.

292
00:17:30,220 --> 00:17:34,530
మీరు ఒక Int, ఒక స్ట్రింగ్, ఫ్లోట్, ఒక భస్మం, ఏ, లేదా మీరు తప్ప తిరిగి, తిరిగి

293
00:17:34,530 --> 00:17:38,030
కానీ మీరు మాత్రమే గరిష్టంగా ఒక విషయం తిరిగి రావచ్చు.

294
00:17:38,030 --> 00:17:42,760
కానీ ఇక్కడ మేము sscanf బహుశా ఒక Int, ఒక దశాంశ సంఖ్య, నాకు తిరిగి కావాలి

295
00:17:42,760 --> 00:17:46,220
మరియు ఒక చార్, మరియు నేను ఒక క్షణం లో ఎందుకు చార్ వివరించడానికి చేస్తాము.

296
00:17:46,220 --> 00:17:51,460
మీరు సమర్థవంతంగా sscanf రెండు విషయాలు తిరిగి కావాలి, కాని ఆ C. కేవలం సాధ్యం కాదు

297
00:17:51,460 --> 00:17:55,200
మీరు రెండు చిరునామాలు లో పంపిస్తూ చుట్టూ పని చేయవచ్చు

298
00:17:55,200 --> 00:17:57,370
వెంటనే మీకు ఒక ఫంక్షన్ రెండు చిరునామాలు చేతితో ఎందుకంటే,

299
00:17:57,370 --> 00:18:00,470
ఆ ఫంక్షన్ వారితో ఏమి చెయ్యగలను? >> [విద్యార్థి] ఆ చిరునామాలకు వ్రాయండి.

300
00:18:00,470 --> 00:18:02,010
ఇది ఆ చిరునామాలను వ్రాయవచ్చు.

301
00:18:02,010 --> 00:18:05,770
మీరు స్టార్ ఆపరేషన్ ఉపయోగించడానికి మరియు ఆ చిరునామాలను ప్రతి, అక్కడ వెళ్ళవచ్చు.

302
00:18:05,770 --> 00:18:11,260
ఇది చరరాశులు యొక్క విలువలలో మార్చినందుకు విధమైన ఈ అక్రమ యంత్రాంగం కాని సాధారణ యొక్క

303
00:18:11,260 --> 00:18:14,870
ఈ సందర్భంలో, రెండు - కేవలం ఒకే చోట కంటే ఎక్కువ.

304
00:18:14,870 --> 00:18:21,340
ఇప్పుడు నేను == 1 తనిఖీ మరియు ఆ నిజానికి, నిజమైన విశ్లేషించదు ఒకవేళ n తిరిగి నేను గమనించి.

305
00:18:21,340 --> 00:18:26,170
కాబట్టి ఏం జరగబోతోంది? సాంకేతికంగా, మేము నిజంగా GetInt లో ఏమి చేయాలనే ఈ ఉంది.

306
00:18:26,170 --> 00:18:30,740
కోట్-unquote 123 - మేము మాట్లాడటానికి, అన్వయించడం కావాలి, మేము స్ట్రింగ్ చదవాలనుకుంటున్న -

307
00:18:30,740 --> 00:18:34,560
మరియు మేము sscanf చెప్పడం ఏమి అక్కడ అనేక ఉన్నది కనిపిస్తుంది ఉంటే

308
00:18:34,560 --> 00:18:38,190
ఈ వేరియబుల్ n నాకు - 123 - ఆ సంఖ్యను జారీ చేస్తారు.

309
00:18:38,190 --> 00:18:42,090
కాబట్టి ఎందుకు వాస్తవానికి ఈ అదే ఉందా?

310
00:18:42,090 --> 00:18:48,220
మీరు కూడా ఇక్కడ ఒక పాత్ర పొందడానికి ఉండవచ్చు చెప్పడం sscanf పాత్ర ఏమిటి?

311
00:18:48,220 --> 00:18:53,470
[వినబడని విద్యార్థి ప్రతిస్పందన] >> ఒక దశాంశ బిందువు వాస్తవానికి పనిచేస్తుంది.

312
00:18:53,470 --> 00:18:56,330
ఒక క్షణం ఆలోచన ఆ యొక్క కలిగి లెట్. ఏమి?

313
00:18:56,330 --> 00:18:59,270
[విద్యార్థి] ఇది NULL ఉంటుంది. >> గుడ్ ఆలోచన. ఇది శూన్య పాత్ర ఉంటుంది.

314
00:18:59,270 --> 00:19:01,660
ఈ సందర్భంలో వాస్తవానికి కాదు. అవును. >> [విద్యార్థి] ASCII.

315
00:19:01,660 --> 00:19:04,340
ASCII. లేదా నాకు మరింత క్రమపరచుట తెలియజేయండి.

316
00:19:04,340 --> 00:19:06,640
అక్కడ% సి కేవలం దోష పరిశీలన మాత్రమే.

317
00:19:06,640 --> 00:19:09,300
మేము, సంఖ్య తర్వాత ఒక పాత్ర ఉన్నట్లు ఇష్టం లేదు

318
00:19:09,300 --> 00:19:11,870
కానీ ఈ నాకు అనుమతిస్తుంది అనుసరిస్తున్నారు.

319
00:19:11,870 --> 00:19:18,210
ఇది ఆ sscanf, ఇక్కడ ఈ ఉదాహరణలో n మరియు సి విలువలు నిల్వ పాటు, అవుతుంది

320
00:19:18,210 --> 00:19:24,890
అది కూడా వేరియబుల్స్ యొక్క సంఖ్యను చూపించే ఏమి అది సైన్ విలువలు ఉంచండి

321
00:19:24,890 --> 00:19:30,260
మీరు మాత్రమే 123 లో టైప్ చేస్తే, అప్పుడు మాత్రమే% d, మ్యాచ్ అన్నారు

322
00:19:30,260 --> 00:19:33,880
మరియు మాత్రమే n, 123 వంటి విలువ నిల్వ అవుతుంది

323
00:19:33,880 --> 00:19:35,640
ఏమీ సి ఉంచే.

324
00:19:35,640 --> 00:19:37,620
సి మాట్లాడటానికి, ఒక చెత్త విలువ ఉంది -

325
00:19:37,620 --> 00:19:40,730
చెత్త ఎందుకంటే కొన్ని విలువ initialized ఎప్పటికీ.

326
00:19:40,730 --> 00:19:45,520
నేను, ఆ గమనికలు యొక్క 1 జనాభా కనుక అలా ఆ సందర్భంలో, sscanf 1 తిరిగి

327
00:19:45,520 --> 00:19:50,190
నేను మెమరీ అప్ విముక్తికై లైన్ విడిపించేందుకు కాబట్టి ఇది గొప్ప సందర్భంలో, నేను ఒక పూర్ణాంకానికి కలిగి

328
00:19:50,190 --> 00:19:54,000
ఆ GetString వాస్తవానికి కేటాయించింది, ఆ తరువాత, n తిరిగి

329
00:19:54,000 --> 00:19:58,500
ఆ ప్రకటన నుండి వచ్చింది మళ్ళీ ప్రయత్నించండి పేరు మీరు ఆలోచిస్తున్నారా else, అది ఇక్కడ నుండే వస్తుంది.

330
00:19:58,500 --> 00:20:04,390
అయితే, దీనికి భిన్నంగా, నేను 123foo టైప్ - టెక్స్ట్ యొక్క కొన్ని యాదృచ్ఛిక క్రమంలో -

331
00:20:04,390 --> 00:20:08,490
sscanf సంఖ్య, సంఖ్య, సంఖ్య, f, చూడండి అన్నారు

332
00:20:08,490 --> 00:20:16,410
మరియు అది n లో 123 పరుగులు చేసి, జరగబోతోంది ఇది సి లో F ఉంచారు మరియు తర్వాత 2 తిరిగి వెళుతున్న.

333
00:20:16,410 --> 00:20:20,640
కాబట్టి మేము కేవలం sscanf యొక్క ప్రవర్తన, చాలా సులభమైన మార్గం యొక్క ప్రాధమిక నిర్వచనం ఉపయోగించి కలిగి -

334
00:20:20,640 --> 00:20:23,900
అలాగే, మొదటి చూపులో కానీ రోజు చాలా సులభం విధానం చివరిలో క్లిష్టమైన -

335
00:20:23,900 --> 00:20:28,320
చెప్పడం ఒక Int ఉంది మరియు కనుక అని నేను దొరకలేదు మాత్రమే విషయం?

336
00:20:28,320 --> 00:20:29,860
మరియు ఇక్కడ ఖాళీలు ఉద్దేశపూర్వక ఉంది.

337
00:20:29,860 --> 00:20:34,000
మీరు sscanf కోసం డాక్యుమెంటేషన్ చదవండి ఉంటే, మీరు తెల్లని భాగాన్ని కలిగి ఉంటే మీరు చెబుతుంది

338
00:20:34,000 --> 00:20:38,810
ప్రారంభంలో లేదా చివరిలో, sscanf కూడా కారణం ఏదైనా వినియోగదారు అనుమతిస్తుంది

339
00:20:38,810 --> 00:20:41,860
స్పేస్ బార్ 123 నొక్కండి మరియు చట్టబద్ధమైన ఉంటుంది.

340
00:20:41,860 --> 00:20:44,150
వారు ఖాళీ బార్ హిట్ కనుక మీరు యూజర్ అరుస్తుంటారు లేదు

341
00:20:44,150 --> 00:20:48,640
ప్రారంభంలో లేదా చివరిలో, ఇది వినియోగదారు అనుకూలమైన కొంచెం ఎక్కువ.

342
00:20:48,640 --> 00:20:52,300
>> అప్పుడు ఏదైనా ప్రశ్నలు GetInt న? అవును. >> [విద్యార్థి] మీరు ఒక చార్ ఉంచారు ఏమి?

343
00:20:52,300 --> 00:20:54,030
ప్రశ్న గుడ్.

344
00:20:54,030 --> 00:20:59,890
ఏం మీరు F వంటి చార్ లో టైప్ మరియు ఎప్పుడూ 123 టైప్ లేకుండా నమోదు కొట్టినప్పుడు?

345
00:20:59,890 --> 00:21:02,420
మీరు ఈ కోడ్ యొక్క లైన్ ప్రవర్తన అప్పుడు ఉంటుంది ఏమి ఆలోచిస్తాడు?

346
00:21:02,420 --> 00:21:04,730
[వినబడని విద్యార్థి ప్రతిస్పందన]

347
00:21:04,730 --> 00:21:08,790
ఆ సందర్భంలో, అది n లేదా సి పూర్తి మాత్రం కాదు ఎందుకంటే అవును, కాబట్టి sscanf కూడా ఉంటాయి.

348
00:21:08,790 --> 00:21:15,310
ఇది సందర్భంలో, నేను కూడా ఆ దృష్టాంతంలో క్యాచింగ్ నేను బదులుగా, 0 తిరిగి వెళుతున్న

349
00:21:15,310 --> 00:21:18,750
నేను మీరు ఊహించిన విలువ 1 ఎందుకంటే.

350
00:21:18,750 --> 00:21:22,000
నాకు ఒకే ఒక అనుకుంటున్నారా మరియు మాత్రమే ఒక విషయం నింపవచ్చు. ప్రశ్న గుడ్.

351
00:21:22,000 --> 00:21:24,290
>> ఇతరులు? అన్ని కుడి.

352
00:21:24,290 --> 00:21:26,250
>> ఇక్కడ విధులు అన్ని ద్వారా వెళ్ళి యొక్క లెట్ లేదు,

353
00:21:26,250 --> 00:21:29,500
కానీ మిగిలిన ఆసక్తి బహుశా కనబడుతోందని ఒక GetString ఉంది

354
00:21:29,500 --> 00:21:32,790
అది GetLongLong, GetFloat, GetInt, GetDouble ఆ అవుతుంది ఎందుకంటే

355
00:21:32,790 --> 00:21:36,260
అన్ని రౌడీ GetString వారి కార్యాచరణను చాలా.

356
00:21:36,260 --> 00:21:39,750
కాబట్టి అతను ఇక్కడ అమలు ఎలా పరిశీలించి అనుమతిస్తుంది.

357
00:21:39,750 --> 00:21:43,630
ఈ ఒక చిన్న క్లిష్టమైన ఉంది, కానీ అది అదే ఫండమెంటల్స్ ఉపయోగిస్తుంది

358
00:21:43,630 --> 00:21:45,670
మేము గత వారం గురించి మాట్లాడటం మొదలుపెట్టాడు ఆ.

359
00:21:45,670 --> 00:21:49,490
GetString లో, ఇది ఇక్కడ తప్ప ప్రకారం ఏ వాదన పడుతుంది

360
00:21:49,490 --> 00:21:53,730
మరియు నేను స్పష్టంగా బఫర్ అనే స్ట్రింగ్ ప్రకటించారు am, ఒక స్ట్రింగ్ తిరిగి.

361
00:21:53,730 --> 00:21:56,270
నేను నిజంగా ఆ ఇంకా ఉపయోగించకూడదు ఏమి తెలియదు, కానీ మేము చూస్తారు.

362
00:21:56,270 --> 00:21:58,390
సామర్థ్యం డిఫాల్ట్ 0 ద్వారా ఉన్నట్లు తెలుస్తుంది.

363
00:21:58,390 --> 00:22:01,350
కాదు ఖచ్చితంగా పేరు ఈ n ఇంకా ఉపయోగించవచ్చు అన్నారు ఏమి ఖచ్చితంగా, కాదు అంటే,

364
00:22:01,350 --> 00:22:03,590
కానీ ఇప్పుడు అది కొంచెం ఆసక్తికరమైన సంతరించుకోనుంది.

365
00:22:03,590 --> 00:22:06,520
లైన్ 243 లో, మేము ఒక Int, సి ప్రకటిస్తాయి.

366
00:22:06,520 --> 00:22:08,800
ఈ ఒక పెద్ద వివరాలు యొక్క విధమైన ఉంది.

367
00:22:08,800 --> 00:22:15,820
ఒక చార్ 8 బిట్స్, మరియు 8 బిట్స్ ఎలా అనేక విలువలు నిల్వ చేయవచ్చు? >> [విద్యార్థి] 256. >> 256.

368
00:22:15,820 --> 00:22:20,730
మీరు ఉంటాయి 256 వివిధ ASCII అక్షరాలు కలిగి అనుకుంటే సమస్య

369
00:22:20,730 --> 00:22:23,340
మీరు తిరిగి అనుకుంటే - మరియు ఈ గుర్తుంచుకోవలసిన విషయం కాదు.

370
00:22:23,340 --> 00:22:25,710
మీరు పెద్ద ASCII చార్ట్ తిరిగి అనుకుంటే కానీ మేము వారాల క్రితం వచ్చింది,

371
00:22:25,710 --> 00:22:30,600
128 లేదా 256 ASCII అక్షరాలు ఆ సందర్భంలో ఉన్నాయి.

372
00:22:30,600 --> 00:22:32,940
మేము 0 సె మరియు 1s అప్ అన్ని నమూనాలు ఉపయోగిస్తారు.

373
00:22:32,940 --> 00:22:36,210
మీరు ఒక దోషాన్ని గుర్తించే సామర్థ్యం కోరుకుంటే ఒక సమస్య

374
00:22:36,210 --> 00:22:40,190
మీరు ఇప్పటికే మీ అక్షరాలు కోసం 256 విలువలు ను ఉపయోగిస్తున్నట్లయితే ఎందుకంటే,

375
00:22:40,190 --> 00:22:43,050
ఇప్పుడు మీరు చెబుతున్న సంఖ్య మార్గం లేని కారణంగా మీరు నిజంగా, ముందుకు ప్లాన్ లేదు

376
00:22:43,050 --> 00:22:46,270
ఈ ఒక సక్రమం అక్షరం, ఈ కొన్ని తప్పుడు సందేశం.

377
00:22:46,270 --> 00:22:50,270
సో వాట్ ప్రపంచ చేస్తుంది వారు తదుపరి అతిపెద్ద విలువ, ఒక పూర్ణాంకానికి లాగ, ఉపయోగిస్తారు

378
00:22:50,270 --> 00:22:54,720
మీరు 4 బిలియన్ విలువల కోసం, బిట్స్, 32 యొక్క ఒక క్రేజీ సంఖ్య కలిగి ఉంటారు

379
00:22:54,720 --> 00:22:58,860
మీరు కేవలం, ముఖ్యంగా 257 వాటిలో ఉపయోగించి అవుతుంది కాబట్టి

380
00:22:58,860 --> 00:23:01,720
1 ఇది ఒక లోపం వంటి కొన్ని ప్రత్యేక అర్థం ఉంది.

381
00:23:01,720 --> 00:23:03,120
>> కాబట్టి ఎలా ఈ పనులు చూడటానికి.

382
00:23:03,120 --> 00:23:07,760
లైన్ 246 లో, నేను, fgetc కాల్ ఈ పెద్ద సమయంలో లూప్ కలిగి

383
00:23:07,760 --> 00:23:11,090
F అర్థం ఫైలు, కాబట్టి getc, ఆపై stdin.

384
00:23:11,090 --> 00:23:15,520
ఈ కేవలం కీబోర్డ్ నుండి ఇన్పుట్ చదవండి చెప్పడం మరింత ఖచ్చితమైన మార్గం అవుతుంది.

385
00:23:15,520 --> 00:23:19,300
ప్రామాణిక ఇన్పుట్ అంటే కీబోర్డు, ప్రామాణిక అవుట్పుట్, స్క్రీన్ అర్థం

386
00:23:19,300 --> 00:23:23,310
మరియు మేము pset4 లో చూస్తారు ఇది ప్రామాణిక తప్పు, స్క్రీన్ అర్థం

387
00:23:23,310 --> 00:23:27,490
కానీ వాస్తవమైన ఉత్పత్తి తో స్క్రీన్ ప్రత్యేక భాగంగా కలిపారు లేదు, అందుచే

388
00:23:27,490 --> 00:23:30,750
మీరు ముద్రించడానికి ఉద్దేశించి. భవిష్యత్తులో ఆ మరింత.

389
00:23:30,750 --> 00:23:34,440
కాబట్టి fgetc కేవలం కీబోర్డ్ నుండి ఒక పాత్ర చదివి పేరు నిల్వ అంటే?

390
00:23:34,440 --> 00:23:37,350
సి లో నిల్వ.

391
00:23:37,350 --> 00:23:41,360
మరియు తర్వాత తనిఖీ - కాబట్టి నేను ఇక్కడ కొన్ని బూలియన్ సముచ్ఛయాలు ఉపయోగించి వెబ్ -

392
00:23:41,360 --> 00:23:46,000
అది సమానం కాదు చేసే తనిఖీ - \ n అందువల్ల వినియోగదారుడు నమోదు సాధించాడు, ఆ సమయంలో ఆపివేయాలనుకుంటున్నారా,

393
00:23:46,000 --> 00:23:49,850
లూప్ అయిపోయాయి - మరియు మేము కూడా ప్రత్యేక స్థిరంగా EOF తనిఖీ మీరు,

394
00:23:49,850 --> 00:23:53,610
మీకు తెలిసిన లేదా ఊహించడం, అది ఏ ఏ నిలబడటానికి లేదు? ఫైల్ >> [విద్యార్థి] ముగింపు. ఫైల్ >> ముగింపు.

395
00:23:53,610 --> 00:23:56,560
ఈ రకమైన పిచ్చి ఎందుకంటే నేను కీబోర్డ్ వద్ద టైప్ చేస్తున్నానని ఉంటే,

396
00:23:56,560 --> 00:23:58,870
ఈ ప్రమేయం ఏ ఫైల్, నిజంగా ఉంది

397
00:23:58,870 --> 00:24:01,150
కానీ ఇది సూచించడానికి ఉపయోగిస్తారు సాధారణ పదం యొక్క క్రమం ఉంది

398
00:24:01,150 --> 00:24:04,220
ఇంకా ఆ ఏమీ మానవ యొక్క చేతి వేళ్ళ నుంచి వస్తోంది.

399
00:24:04,220 --> 00:24:06,460
EOF - ఫైలు యొక్క ముగింపు.

400
00:24:06,460 --> 00:24:09,920
మీరు మీ కీబోర్డు వద్ద కంట్రోల్ D నొక్కండి ఉంటే ఒక పక్కన, మీరు ఇంకా కాదు అని -

401
00:24:09,920 --> 00:24:15,230
మీరు కంట్రోల్ సి హిట్ చేసిన - కంట్రోల్ D EOF అని ఈ ప్రత్యేక స్థిరంగా పంపుతుంది.

402
00:24:15,230 --> 00:24:19,850
కాబట్టి ఇప్పుడు మేము కొన్ని డైనమిక్ మెమరీ కేటాయింపు ఉంది.

403
00:24:19,850 --> 00:24:23,440
>> అయితే (n + 1> సామర్థ్యం). ఇప్పుడు నేను n వివరించడానికి చేస్తాము.

404
00:24:23,440 --> 00:24:26,100
N కేవలం ఎన్ని బైట్లు, బఫర్ ప్రస్తుతం ఉంటాయి

405
00:24:26,100 --> 00:24:28,620
మీరు ప్రస్తుతం వినియోగదారు నుండి రూపొందించడంలో చేస్తున్న స్ట్రింగ్.

406
00:24:28,620 --> 00:24:33,450
మీరు బఫర్ లో సామర్థ్యం కంటే మీ బఫర్ లో ఎక్కువ అక్షరాలు కలిగి ఉంటే,

407
00:24:33,450 --> 00:24:37,410
intuitively మేము అప్పుడు ఏమి చేయాలి మరింత సామర్థ్యం కేటాయించాలని ఉంది.

408
00:24:37,410 --> 00:24:43,330
నేను ఇక్కడ అంకగణితం యొక్క కొన్ని పైగా చెడిపోయిన మరియు ఇక్కడ మాత్రమే ఈ చర్య దృష్టి వెళుతున్న.

409
00:24:43,330 --> 00:24:46,070
మీరు malloc తెలుసు లేదా కనీసం సాధారణంగా తెలిసిన.

410
00:24:46,070 --> 00:24:48,970
Realloc ఏమి ఒక అంచనా తీసుకోండి. >> [విద్యార్థి] మెమరీ జోడిస్తుంది.

411
00:24:48,970 --> 00:24:52,920
ఇది చాలా మెమరీ జోడించడం కాదు. ఇది ఈ కింది విధంగా మెమరీ reallocates.

412
00:24:52,920 --> 00:24:57,220
మీరు ఆ మెమరీ మరింత ఇవ్వాలని స్ట్రింగ్ చివరిలో గది ఇప్పటికీ ఉంది ఉంటే

413
00:24:57,220 --> 00:25:00,000
ఇది మొదట మీరు ఇస్తుంది కంటే, మీరు అదనపు మెమరీ పొందుతారు.

414
00:25:00,000 --> 00:25:03,460
కాబట్టి మీరు వెనక్కి తిరిగి తిరిగి తిరిగి స్ట్రింగ్ యొక్క అక్షరాలు చూస్తూ ఉంచుకోవచ్చు.

415
00:25:03,460 --> 00:25:05,830
ఆ సందర్భంలో కాదు అయితే మీరు చాలా పొడవుగా వేచి ఎందుకంటే

416
00:25:05,830 --> 00:25:07,940
మరియు యాదృచ్ఛిక ఏదో మెమరీలో plopped పొందిన

417
00:25:07,940 --> 00:25:10,290
కానీ అదనపు మెమరీ ఇక్కడ డౌన్ ఉంది, ఆ సరైందే.

418
00:25:10,290 --> 00:25:13,100
Realloc, మీరు అన్ని భారీ ట్రైనింగ్ చేయడానికి వెళ్తున్నారు

419
00:25:13,100 --> 00:25:16,750
, మీరు ఇప్పటివరకు ఇక్కడ నుండి చదివారు స్ట్రింగ్ తరలించడానికి అది అణిచివేసేందుకు,

420
00:25:16,750 --> 00:25:19,460
మరియు మీరు ఆ సమయంలో కొన్ని మరింత రన్వే ఇస్తాయి.

421
00:25:19,460 --> 00:25:22,550
>> కాబట్టి చేతి యొక్క కెరటంతో, నాకు ఏమి GetString చేస్తున్న ఆ అని పిలవబడు

422
00:25:22,550 --> 00:25:26,330
అది ఒక చిన్న బఫర్, బహుశా ఒక్క పాత్ర తో ప్రారంభమయ్యే అని

423
00:25:26,330 --> 00:25:30,820
మరియు రెండు అక్షరాలు వినియోగదారు రకాల ఉంటే, GetString realloc కాల్ ముగుస్తుంది మరియు చెప్పారు

424
00:25:30,820 --> 00:25:33,150
ఒక పాత్ర సరిపోలేదు; నాకు రెండు అక్షరాలు ఇస్తాయి.

425
00:25:33,150 --> 00:25:35,950
మీరు లూప్ యొక్క తర్కం ద్వారా రీడ్ అప్పుడు, అది చెప్పడానికి జరగబోతోంది

426
00:25:35,950 --> 00:25:39,600
3 అక్షరాలు లో టైప్ యూజర్;, ఇప్పుడు కాదు 2 కాని 4 అక్షరాలు నాకు ఇవ్వండి

427
00:25:39,600 --> 00:25:42,320
అప్పుడు నాకు 16 మరియు 32 ఇవ్వాలని తర్వాత, నాకు 8 ఇస్తాయి.

428
00:25:42,320 --> 00:25:45,000
నేను సామర్థ్యం ప్రతి సమయం రెట్టింపు చేస్తున్నాను వాస్తవం

429
00:25:45,000 --> 00:25:48,570
బఫర్ నెమ్మదిగా వృద్ధి వెళ్ళడం లేదు అంటే, అది సూపర్ ఫాస్ట్ పెరగడం జరగబోతోంది.

430
00:25:48,570 --> 00:25:51,380
మరియు ఆ ప్రయోజనాన్ని కావచ్చు?

431
00:25:51,380 --> 00:25:54,600
నేను బఫర్ పరిమాణం రెట్టింపు am

432
00:25:54,600 --> 00:25:58,020
యూజర్ కేవలం కీబోర్డ్ నుండి ఒక అదనపు పాత్ర అవసరం ఉండవచ్చు అయినప్పటికీ?

433
00:25:58,020 --> 00:26:01,750
[వినబడని విద్యార్థి ప్రతిస్పందన] >> ఆ ఏమిటి? >> [విద్యార్థి] మీరు తరచుగా పెరగడం లేదు.

434
00:26:01,750 --> 00:26:03,300
సరిగ్గా. మీరు తరచుగా పెరగడం లేదు.

435
00:26:03,300 --> 00:26:05,510
మరియు ఈ మీరు కేవలం రకం, ఇక్కడ మీ పందెం పరిమితం చేసిన

436
00:26:05,510 --> 00:26:10,850
దీనిని నెమ్మదిగా ఉంటుంది ఎందుకంటే మీరు realloc చాలా కాల్ అనుకుంటున్న అనేది.

437
00:26:10,850 --> 00:26:12,910
మీరు, మెమరీ కోసం ఆపరేటింగ్ సిస్టమ్ అడగండి ఏదైనా సమయం

438
00:26:12,910 --> 00:26:16,990
మీరు వెంటనే భవిష్య సమస్య సెట్ లో చూస్తారు, అది కొంత సమయం పడుతుంది ఉంటుంది.

439
00:26:16,990 --> 00:26:20,010
కాబట్టి మీరు కొన్ని అంతరిక్ష వృధా చేసిన కూడా, సమయం ఆ మొత్తం తగ్గించడం,

440
00:26:20,010 --> 00:26:21,900
ఒక మంచి విషయం ఉంటుంది.

441
00:26:21,900 --> 00:26:24,060
>> కానీ మేము ఇక్కడ GetString చివరి భాగం చదివి ఉంటే -

442
00:26:24,060 --> 00:26:27,950
మళ్ళీ ఇక్కడ ప్రతి లైన్ understanding నేడు అంత ముఖ్యమైనది కాదు -

443
00:26:27,950 --> 00:26:30,530
అది చివరకు మళ్ళీ malloc కాల్స్ అని గుర్తించలేకపోతే

444
00:26:30,530 --> 00:26:33,880
అది స్ట్రింగ్ అవసరమైన మరియు చాలా బైట్లు వంటి సరిగ్గా కేటాయించుకునే

445
00:26:33,880 --> 00:26:38,060
మరియు తర్వాత ఫ్రీ అతి భారీ బఫర్ కాల్ దూరంగా విసురుతాడు

446
00:26:38,060 --> 00:26:40,080
ఇది నిజంగానే చాలా సార్లు రెట్టింపు వస్తే.

447
00:26:40,080 --> 00:26:42,730
కాబట్టి చిన్న లో, ఆ GetString ఈ సమయంలో పని చేస్తుంది ఎలా.

448
00:26:42,730 --> 00:26:47,060
అది, మళ్ళీ, మళ్ళీ, మళ్ళీ ఒకసారి ఒక పాత్ర చదవబడుతుంది లేదు

449
00:26:47,060 --> 00:26:50,750
మరియు అది కొన్ని అదనపు మెమరీ అవసరం ప్రతిసారీ, ఇది కోసం ఆపరేటింగ్ సిస్టమ్ అడుగుతుంది

450
00:26:50,750 --> 00:26:53,670
realloc కాల్.

451
00:26:53,670 --> 00:26:57,890
>> ఏదైనా ప్రశ్నలు? అన్ని కుడి.

452
00:26:57,890 --> 00:26:59,270
>> దాడి.

453
00:26:59,270 --> 00:27:04,060
, ఇప్పుడు మేము గమనికలు అర్థం లేదా కనీసం గమనికలు విపరీతంగా తెలిసిన

454
00:27:04,060 --> 00:27:06,700
మొత్తం ప్రపంచం కూలిపోయింది మొదలవుతుంది ఎలా భావిస్తారు తెలియజేయండి

455
00:27:06,700 --> 00:27:10,030
మీరు చాలా పటిష్టమయిన వినియోగదారులు ఎదుర్కోవటానికి లేకపోతే,

456
00:27:10,030 --> 00:27:11,850
మీ వ్యవస్థ హాక్ ప్రయత్నిస్తున్న వ్యక్తులు,

457
00:27:11,850 --> 00:27:16,890
కొన్ని నమోదు కోడ్ అధిగమిస్తూ ద్వారా మీ సాఫ్ట్వేర్ దొంగిలించడానికి ప్రయత్నించిన వ్యక్తులు

458
00:27:16,890 --> 00:27:19,090
వారు సైన్ టైప్ చూపించే

459
00:27:19,090 --> 00:27:22,990
>> దిగువన ప్రధాన విధిగా కలిగి కేవలం సి కోడ్ ఇది ఇక్కడ ఈ ఉదాహరణ గమనించండి

460
00:27:22,990 --> 00:27:26,380
ఒక చర్యను foo పిలుస్తుంది. మరియు దానిని foo కు అక్కడ ఉన్న?

461
00:27:26,380 --> 00:27:29,680
[విద్యార్థి] ఒక వాదన. >> [మలన్] ఒక వాదన.

462
00:27:29,680 --> 00:27:33,450
కాబట్టి argv [1], ఇది వినియోగదారు కమాండ్ లైన్ వద్ద టైప్ చేసి మొదటి పదం అర్థం

463
00:27:33,450 --> 00:27:36,360
a.out లేదా ఎలాగైనా ఆ కార్యక్రమం అని పిలుస్తారు.

464
00:27:36,360 --> 00:27:41,680
ఎగువన foo ఒక చార్ * లో జరుగుతుంది కాబట్టి. కానీ చార్ * కేవలం ఏమిటి? >> [విద్యార్థి] ఒక స్ట్రింగ్.

465
00:27:41,680 --> 00:27:43,350
[మలన్] ఒక స్ట్రింగ్, కొత్త ఏమీ ఇక్కడ ఉంది కాబట్టి.

466
00:27:43,350 --> 00:27:45,420
ఆ స్ట్రింగ్ ఏకపక్ష బార్ అని ఉంది.

467
00:27:45,420 --> 00:27:51,430
ఇక్కడ ఈ లైన్ లో చార్ సి [12]; సెమీ సాంకేతిక ఆంగ్ల విధమైన లో, ఈ లైన్ ఏమి ఉంది?

468
00:27:51,430 --> 00:27:55,220
యొక్క [విద్యార్థి] ఒక అమరిక - యొక్క >> అర్రే? >> [విద్యార్థి] అక్షరాలు. >> అక్షరాలు.

469
00:27:55,220 --> 00:27:58,870
నాకు 12 అక్షరాలు యొక్క వ్యూహం ఇవ్వండి. కాబట్టి మేము ఈ ఒక బఫర్ కాల్ ఉండవచ్చు.

470
00:27:58,870 --> 00:28:02,920
ఇది సాంకేతికంగా సి అని, కానీ ప్రోగ్రామింగ్ ఒక బఫర్ కేవలం స్థలం కొంత అర్థం యొక్క

471
00:28:02,920 --> 00:28:04,800
మీరు కొన్ని విషయాలను సైన్ ఉంచవచ్చు ఆ

472
00:28:04,800 --> 00:28:07,940
అప్పుడు చివరగా, memcpy మేము ముందు ఉపయోగించరు, కానీ మీరు బహుశా దీన్ని ఏమి అంచనా.

473
00:28:07,940 --> 00:28:10,480
ఇది మెమరీ కాపీ చేస్తుంది. ఇది ఏమి చేస్తుంది?

474
00:28:10,480 --> 00:28:19,270
ఇది స్పష్టంగా సి లోకి, దాని ఇన్పుట్, బార్ కాపీ కాని మాత్రమే బార్ యొక్క పొడవు.

475
00:28:19,270 --> 00:28:24,930
కానీ ఇక్కడ ఒక బగ్ ఉంది. >> [విద్యార్థి] మీరు sizeof పాత్ర అవసరం. సరే >>.

476
00:28:24,930 --> 00:28:30,860
సాంకేతికంగా, మేము నిజంగా strlen చేయండి (బార్) * sizeof (చార్)). ఉండాలి ఆ సరైన ఉంటుంది.

477
00:28:30,860 --> 00:28:33,930
కానీ ఇక్కడ చెత్త సందర్భంలో, ఆ యొక్క that's ఊహించుకోవటం తెలియజేయండి -

478
00:28:33,930 --> 00:28:35,950
సరే. అప్పుడు రెండు దోషాలు ఉన్నాయి.

479
00:28:35,950 --> 00:28:39,160
కాబట్టి sizeof (చార్));

480
00:28:39,160 --> 00:28:41,290
యొక్క ఈ చిన్న విస్తృత తయారు చేద్దాము.

481
00:28:41,290 --> 00:28:44,910
కాబట్టి ఇప్పుడు ఏమి ఉంది బగ్, ఇప్పటికీ ఉంది? >> [వినబడని విద్యార్థి ప్రతిస్పందన]

482
00:28:44,910 --> 00:28:46,990
ఏ తనిఖీ? >> [విద్యార్థి] NULL కోసం తనిఖీ చెయ్యండి.

483
00:28:46,990 --> 00:28:50,270
చెడు విషయాల జరిగే ఎందుకంటే మేము సాధారణంగా NULL తనిఖీ చేయాలి

484
00:28:50,270 --> 00:28:53,200
మీరు, అక్కడ వెళ్ళి ముగుస్తుంది కాబట్టి మీ పాయింటర్ NULL ఉన్నప్పుడు

485
00:28:53,200 --> 00:28:57,630
మరియు మీరు స్టార్ ఆపరేటర్లు తో dereferencing ద్వారా శూన్య వెళ్ళి లేదు.

486
00:28:57,630 --> 00:29:01,050
కాబట్టి ఆ బావుంటుంది. మరియు మేము ఏమి చేస్తున్నారు? తార్కికంగా, ఒక దోషం చాలా ఇక్కడ ఉంది.

487
00:29:01,050 --> 00:29:04,450
[విద్యార్థి] argc> = 2 అని తనిఖీ.

488
00:29:04,450 --> 00:29:10,550
Argc> = 2 ఉంటే కాబట్టి తనిఖీ. సరే, ఈ కార్యక్రమంలో మూడు దోషాలు ఇక్కడ ఉంది కాబట్టి.

489
00:29:10,550 --> 00:29:16,630
యూజర్ వాస్తవానికి argv లోకి ఏదైనా టైప్ మేము ఇప్పుడు తనిఖీ చేస్తున్నాము [1]. గుడ్.

490
00:29:16,630 --> 00:29:20,950
కాబట్టి మూడవ బగ్ ఏది? అవును. >> [విద్యార్థి] సి తగినంత పెద్ద కాదు.

491
00:29:20,950 --> 00:29:23,320
గుడ్. మేము ఒక దృష్టాంతంలో తనిఖీ.

492
00:29:23,320 --> 00:29:29,520
మేము పరిపూర్ణంగా బార్ యొక్క పొడవు మించిపోతుంది కంటే మరింత మెమరీని కాపీ లేదు తనిఖీ.

493
00:29:29,520 --> 00:29:32,510
కాబట్టి స్ట్రింగ్ ఉంటే టైప్ యూజర్ 10 అక్షరాలు,

494
00:29:32,510 --> 00:29:36,020
ఈ మాత్రమే 10 అక్షరాలు కాపీ అని. మరియు ఆ సరైందే.

495
00:29:36,020 --> 00:29:39,940
కానీ వినియోగదారు 20 పాత్ర పదం వంటి ప్రాంప్టులో పదం లో ఏం టైప్ ఉంటే?

496
00:29:39,940 --> 00:29:44,900
ఈ విధంగా బార్ నుండి కాపీ 20 అక్షరాలు అని?

497
00:29:44,900 --> 00:29:49,750
లేకపోతే మా బఫర్ అని పిలుస్తారు సి, ఇది మీరు డేటా రాశారు అర్థం

498
00:29:49,750 --> 00:29:52,540
మీరు స్వంతం కాని 8 బైట్ స్థానాలకు,

499
00:29:52,540 --> 00:29:54,870
మరియు మీరు వాటిని కేటాయించింది ఎప్పుడూ కోణంలో వాటిని కలిగి లేదు.

500
00:29:54,870 --> 00:30:00,370
కాబట్టి ఈ సాధారణంగా బఫర్ ఓవర్ఫ్లో దాడి లేదా బఫర్ ఆక్రమిత దాడి గా పిలిచే దాన్ని ఉంది.

501
00:30:00,370 --> 00:30:05,580
మరియు అది కోణంలో దాడి అని, వినియోగదారు లేదా మీ చర్యను కాల్ చేసే కార్యక్రమం

502
00:30:05,580 --> 00:30:10,490
వాస్తవానికి తదుపరి ఏమి, హానికరమైన ఈ చేస్తోంది నిజానికి చాలా చెడ్డ ఉంటుంది.

503
00:30:10,490 --> 00:30:12,450
>> కాబట్టి యొక్క ఇక్కడ ఈ చిత్రాన్ని చూసి తెలియజేయండి.

504
00:30:12,450 --> 00:30:16,060
ఈ చిత్రం మెమరీ మీ స్టాక్ సూచిస్తుంది.

505
00:30:16,060 --> 00:30:19,580
మీరు ఒక ఫంక్షన్ కాల్ ప్రతిసారీ మీరు స్టాక్ ఈ చిన్న Frame పొందండి గుర్తుచేసుకున్నారు

506
00:30:19,580 --> 00:30:21,520
మరియు వేరొక మరియు వేరొక మరియు మరొక.

507
00:30:21,520 --> 00:30:24,300
మరియు ఇప్పటివరకు, మేము కేవలం రకమైన మీరు ఈ దీర్ఘ చతురస్రాలు గా సంగ్రహించబడింది

508
00:30:24,300 --> 00:30:26,290
బోర్డు మీద లేదా ఇక్కడ తెరపై గాని.

509
00:30:26,290 --> 00:30:30,580
కానీ మీరు ఒక ఫంక్షన్ foo కాల్ చేసినప్పుడు దీర్ఘ చతురస్రాలు ఒక, లో జూమ్ ఉంటే,

510
00:30:30,580 --> 00:30:35,880
అంతకన్నా దీర్ఘ చతురస్రం లో ఆ ఫ్రేమ్ యొక్క స్టాక్ లోపల అక్కడ అవుతుంది

511
00:30:35,880 --> 00:30:40,060
కంటే మేము swap గురించి మాట్లాడటం లేదు మాదిరిగా x మరియు y మరియు a మరియు b.

512
00:30:40,060 --> 00:30:44,410
ఇది కొన్ని తక్కువ స్థాయి వివరాలు రిటర్న్ చిరునామా, వాటిలో అక్కడ అవుతుంది.

513
00:30:44,410 --> 00:30:49,550
ప్రధాన foo కాల్స్ కనుక అది అవుతుంది, ప్రధాన foo సమాచారం ఉంటుంది

514
00:30:49,550 --> 00:30:53,520
ఏ ప్రధాన యొక్క చిరునామా కంప్యూటర్ యొక్క మెమరీ లో ఉంది

515
00:30:53,520 --> 00:30:57,770
లేకపోతే ఎందుకంటే, వెంటనే foo వంటి, ఇక్కడ ఈ సందర్భంలో, అమలు చేయబడుతుంది

516
00:30:57,770 --> 00:31:00,830
ఒకసారి మీరు, foo చివరిలో ఈ మూసి వంకర కలుపు చేరుకోవడానికి

517
00:31:00,830 --> 00:31:05,310
కార్యక్రమం యొక్క నియంత్రణను పడతాయని భావించబడుతోంది కౌంటీ ఎలా హెక్ foo తెలుసా?

518
00:31:05,310 --> 00:31:08,970
ఇది ఆ ప్రశ్నకు సమాధానం ఇక్కడ ఈ Red దీర్ఘ చతురస్రం లో అని అవుతుంది.

519
00:31:08,970 --> 00:31:12,670
ఈ ఒక పాయింటర్ సూచిస్తుంది, మరియు ఇది తాత్కాలికంగా నిల్వ చేయడానికి కంప్యూటర్ ఇష్టం

520
00:31:12,670 --> 00:31:17,030
అని పిలవబడే స్టాక్ న తద్వారా వెంటనే foo వంటి ప్రధాన యొక్క చిరునామా అమలు చేయబడుతుంది,

521
00:31:17,030 --> 00:31:21,120
కంప్యూటర్ పేరు మరియు వెళ్ళడానికి ప్రధాన లో ఏం లైన్ తెలుసు.

522
00:31:21,120 --> 00:31:23,940
సేవ్ Frame పాయింటర్ ఈ సమానంగా సంబంధం.

523
00:31:23,940 --> 00:31:26,310
ఇక్కడ చార్ * బార్ ఏమి సూచిస్తుంది?

524
00:31:26,310 --> 00:31:31,350
ఇప్పుడు ఈ నీలం విభాగంలో ఇక్కడ foo యొక్క ఫ్రేమ్. బార్ ఏమిటి?

525
00:31:31,570 --> 00:31:35,010
బార్ కేవలం foo కు వాదన ఉంది.

526
00:31:35,010 --> 00:31:37,500
కాబట్టి ఇప్పుడు మేము తెలిసిన చిత్రం విధమైన వద్ద వెనక్కి వచ్చారు.

527
00:31:37,500 --> 00:31:39,850
స్క్రీన్ పై ఎక్కువ అంశాలను మరియు మరింత వ్యాపకాలు, ఉన్నాయి

528
00:31:39,850 --> 00:31:43,380
కానీ ఈ లేత నీలం విభాగంలో కేవలం మేము సుద్ద బోర్డ్ పై చిత్రించడం చేసిన ఏమిటి

529
00:31:43,380 --> 00:31:45,790
swap వంటి వాటి కోసం. ఆ foo కోసం ఫ్రేమ్.

530
00:31:45,790 --> 00:31:51,490
మరియు అది మాత్రమే విషయం ప్రస్తుతం ఈ పారామితి ఇది బార్.

531
00:31:51,490 --> 00:31:55,220
కానీ ఏమి ఇక్కడ ఈ కోడ్ ప్రకారం స్టాక్ ఉండాలి?

532
00:31:55,220 --> 00:31:57,760
[విద్యార్థి] చార్ సి [12]. >> [మలన్] చార్ సి [12].

533
00:31:57,760 --> 00:32:02,810
మేము కూడా, సి అనే వేరియబుల్ కు కేటాయించిన మెమొరీ యొక్క 12 చతురస్రాలు చూస్తారు

534
00:32:02,810 --> 00:32:04,970
నిజానికి మేము తెరపై ఆ ఉన్నాయి.

535
00:32:04,970 --> 00:32:08,480
చాలా టాప్ ఉంది సి [0] ఈ చిత్రం యొక్క, మరియు అప్పుడు రచయిత

536
00:32:08,480 --> 00:32:11,850
చతురస్రాలు అన్ని గీయడం కష్టం, అయితే 12 నిజంగానే ఉన్నాయి లేదు

537
00:32:11,850 --> 00:32:16,590
ఎందుకంటే మీరు కుడి దిగువన చూడండి ఉంటే, సి [11] మీరు 0 నుండి COUNT ఉంటే 12 వ అటువంటి బైట్ ఉంది.

538
00:32:16,590 --> 00:32:18,400
కానీ ఇక్కడ సమస్య.

539
00:32:18,400 --> 00:32:22,390
సి ఇది దిశలో పెరుగుతోంది?

540
00:32:22,390 --> 00:32:27,080
క్రమీకరించు ఇది టాప్ మొదలవుతుంది మరియు దిగువ పెరుగుతాయి డౌన్ టాప్.

541
00:32:27,080 --> 00:32:30,110
మేము అన్ని వద్ద ఇక్కడ మేమే చాలా రన్వే వదిలి కనిపించడం లేదు.

542
00:32:30,110 --> 00:32:32,090
మేము రకమైన, ఒక మూలలో మేమే పెయింట్ చేసిన

543
00:32:32,090 --> 00:32:36,940
మరియు ఆ C [11] సేవ్ Frame పాయింటర్ వ్యతిరేకంగా హక్కు ఉంది దీనిలో బార్ పై కుడి అప్,

544
00:32:36,940 --> 00:32:39,960
ఇది రిటర్న్ చిరునామా వ్యతిరేకంగా హక్కు ఉంది. దీనిలో ఖాళీ లేదు.

545
00:32:39,960 --> 00:32:42,810
మీరు అప్ మేకు చేస్తే అంత అప్పుడు ఏమి

546
00:32:42,810 --> 00:32:46,500
మరియు మీరు ఒక 12-బైట్ బఫర్ లోకి 20 బైట్లు reading ప్రయత్నించండి?

547
00:32:46,500 --> 00:32:50,060
ఎక్కడ ఆ 8 అదనపు బైట్లు వెళ్ళడానికి వెళ్తున్నారు? >> [విద్యార్థి] ఇన్సైడ్ -

548
00:32:50,060 --> 00:32:53,200
మిగతా వాటి లోపల, వీటిలో కొన్ని ముఖ్యమైన సూపర్ ఉంది.

549
00:32:53,200 --> 00:32:57,260
మరియు అతి ముఖ్యమైన విషయం, సమర్థవంతంగా, అక్కడ తిరిగి చిరునామా ఎరుపు బాక్స్

550
00:32:57,260 --> 00:33:03,560
ఎందుకంటే, మీరు అనుకోకుండా లేదా adversarially ఆ 4 బైట్లు తిరిగి రాస్తుంది ఆ అనుకుందాం

551
00:33:03,560 --> 00:33:07,260
చెత్త కానీ అనేక కేవలం ఆ పాయింటర్ చిరునామా,

552
00:33:07,260 --> 00:33:09,810
ఆ స్మృతి ఒక నిజమైన చిరునామా నిర్మాణము.

553
00:33:09,810 --> 00:33:13,880
తార్కికంగా సూత్రప్రాయంగా, ఏమిటి? >> [విద్యార్థి] ఫంక్షన్ వేరే స్థానంలో తిరిగి అన్నారు.

554
00:33:13,880 --> 00:33:15,250
సరిగ్గా.

555
00:33:15,250 --> 00:33:19,170
Foo తిరిగి మరియు హిట్స్ వంకర కలుపు ఆ కార్యక్రమం ముందుకు వెళ్ళడం చేసినప్పుడు

556
00:33:19,170 --> 00:33:25,060
ప్రధాన తిరిగి, ఆ ఎర్ర బాక్స్ లో ఉండే వస్తువు చిరునామా తిరిగి వెళుతున్న.

557
00:33:25,060 --> 00:33:28,600
>> మోసపూరిత సాఫ్ట్వేర్ నమోదు విషయంలో,

558
00:33:28,600 --> 00:33:32,260
తిరిగి చేయబడిన ఆ చిరునామా సాధారణంగా అని చెపుతాడు ఆ విధి ఏం

559
00:33:32,260 --> 00:33:35,690
మీరు సాఫ్ట్వేర్ చెల్లించిన మరియు మీ నమోదు కోడ్ ఇన్పుట్? తర్వాత

560
00:33:35,690 --> 00:33:39,870
మీరు ఇక్కడ వెళ్ళడం లేదు లోకి ట్రిక్ కంప్యూటర్ యొక్క క్రమం కానీ బదులుగా ఇక్కడ వెళ్లి చేయవచ్చు.

561
00:33:39,870 --> 00:33:45,100
మీరు నిజంగా తెలివైన అయితే లేదా, శత్రువులు నిజానికి, ఉదాహరణకు, కీబోర్డ్ లో టైప్ చేయగలరు

562
00:33:45,100 --> 00:33:50,690
వాస్తవ పదం, కాదు 20 అక్షరాలు, కాని అతను లేదా ఆమె నిజానికి రకాల అనుకుందాం

563
00:33:50,690 --> 00:33:52,770
కోడ్ ప్రాతినిధ్యం కొన్ని అక్షరాలు.

564
00:33:52,770 --> 00:33:55,320
మరియు అది సి కోడ్ మాత్రం కాదు, అది నిజంగా అక్షరాలు చేస్తాడు

565
00:33:55,320 --> 00:33:59,290
ఆ 0 సె మరియు 1s బైనరీ యంత్రం కోడ్, సూచిస్తాయి.

566
00:33:59,290 --> 00:34:01,290
కానీ, అలా తగినంత తెలివైన ఉన్నారు అనుకుందాం

567
00:34:01,290 --> 00:34:06,500
ఏదో ముఖ్యంగా సంకలనం కోడ్ అని GetString ప్రాంప్ట్ దానిని పేస్ట్,

568
00:34:06,500 --> 00:34:09,980
మరియు గత 4 బైట్లు ఆ తిరిగి చిరునామా తిరిగి రాస్తుంది.

569
00:34:09,980 --> 00:34:13,360
మరియు ఆ ఇన్పుట్ ఏమి చిరునామా చేస్తుంది?

570
00:34:13,360 --> 00:34:18,630
ఇది వాస్తవానికి ఈ Red దీర్ఘ చతురస్రం బఫర్ యొక్క మొదటి బైట్ యొక్క చిరునామా లో నిల్వ చేస్తుంది.

571
00:34:18,630 --> 00:34:23,070
, కాబట్టి మీరు నిజంగా తెలివైన ఉండాలి, మరియు ఈ అక్కడ చెడు వ్యక్తులు కోసం విచారణ మరియు లోపం చాలా ఉంది

572
00:34:23,070 --> 00:34:25,639
కానీ మీరు ఈ బఫర్ ఎలా పెద్దది గుర్తించడానికి లేదో

573
00:34:25,639 --> 00:34:28,820
ఇన్పుట్ లో గత కొన్ని బైట్లు మీరు ప్రోగ్రామ్ అందించే అటువంటి

574
00:34:28,820 --> 00:34:33,540
మీ బఫర్ యొక్క ప్రారంభ చిరునామా సమానం కావడం, మీరు చేయవచ్చు.

575
00:34:33,540 --> 00:34:39,320
మేము సాధారణంగా హలో మరియు \ 0 చెప్పుకోవాలంటే, ఆ బఫర్ లో ముగుస్తుంది ఏమిటి.

576
00:34:39,320 --> 00:34:44,420
కానీ మాకు మరింత తెలివైన ఉన్నారు మరియు మేము సామాన్యముగా దాడి కోడ్ పిలుస్తాను ఏమి ఆ బఫర్ పూర్తి ఉంటే -

577
00:34:44,420 --> 00:34:48,860
AAA, దాడి, దాడి, దాడి - ఇది చెడు ఏదో చేసే ఏదో ఉంటుంది,

578
00:34:48,860 --> 00:34:51,820
మీరు నిజంగా తెలివైన అయితే ఏమి, మీరు దీన్ని ఉండవచ్చు.

579
00:34:51,820 --> 00:34:58,610
80, C0, 35, 08 - ఇక్కడ ఎరుపు బాక్స్ లో సంఖ్యల వరుస ఉంది.

580
00:34:58,610 --> 00:35:01,610
ఆ ఇక్కడ ఆ సంఖ్య సరిపోయే గమనించండి.

581
00:35:01,610 --> 00:35:04,430
ఇది రివర్స్ క్రమంలో, కానీ కొన్ని ఇతర సమయం ఎక్కువ.

582
00:35:04,430 --> 00:35:08,140
ఈ తిరిగి చిరునామా కావాలనే మార్పు అని గమనించండి

583
00:35:08,140 --> 00:35:12,020
ఇక్కడ చిరునామా అప్ సమం, ప్రధాన కాదు చిరునామా.

584
00:35:12,020 --> 00:35:17,500
చెడు వ్యక్తి సూపర్ స్మార్ట్ కాబట్టి, అతను లేదా ఆమె ఆ దాడి కోడ్ ఉన్నాయి అన్నారు

585
00:35:17,500 --> 00:35:20,930
యూజర్ యొక్క ఫైళ్ళను తొలగించడానికి లేదా పాస్వర్డ్లను కాపీ ఏదో వంటి

586
00:35:20,930 --> 00:35:24,680
లేదా నేను మీరు లాగిన్ ఒక వినియోగదారు ఖాతా సృష్టించు - ఏదైనా అన్ని వద్ద.

587
00:35:24,680 --> 00:35:26,950
>> మరియు ఈ ప్రమాదంలో మరియు C. యొక్క శక్తి రెండూ

588
00:35:26,950 --> 00:35:29,840
మీరు గమనికలు ద్వారా మెమరీ ప్రాప్తి ఎందుకంటే

589
00:35:29,840 --> 00:35:32,520
మరియు మీరు అందువలన, కంప్యూటర్ యొక్క మెమరీ లోనికి మీరు ఏదైనా వ్రాయవచ్చు

590
00:35:32,520 --> 00:35:35,080
మీరు ఒక కంప్యూటర్ మీరు ఏదైనా చేయవచ్చు

591
00:35:35,080 --> 00:35:39,550
కేవలం ద్వారా దాని స్వంత మెమరీ ఖాళీలో చుట్టూ జంప్ అయ్యారు.

592
00:35:39,550 --> 00:35:44,650
కాబట్టి ఈ రోజు చాలా కార్యక్రమాలు మరియు చాలా వెబ్ సైట్లు రాజీ చేసే

593
00:35:44,650 --> 00:35:46,200
ఈ యొక్క ప్రయోజనాన్ని ప్రజలకు డౌన్ పొంగు.

594
00:35:46,200 --> 00:35:50,760
మరియు ఈ ఒక సూపర్ ఆధునిక దాడులను వంటి కనిపిస్తుంది, కానీ ఇది ఎల్లప్పుడూ విధంగా మొదలు లేదు.

595
00:35:50,760 --> 00:35:53,560
రియాలిటీ, ఏ చెడ్డ వ్యక్తులు సాధారణంగా చేస్తుంది ఉంటుంది

596
00:35:53,560 --> 00:35:58,200
అది ఒక కమాండ్ లైన్ వద్ద ఒక కార్యక్రమం లేదా ఒక GUI ప్రోగ్రామ్ లేదా ఒక వెబ్సైట్, అయినా

597
00:35:58,200 --> 00:35:59,940
మీరు అర్ధంలేని అందించడం మొదలు.

598
00:35:59,940 --> 00:36:03,980
మీరు, అన్వేషణ రంగంలో మరియు హిట్ నమోదు ఒక నిజంగా పెద్ద పదం టైప్

599
00:36:03,980 --> 00:36:05,780
మరియు మీరు వెబ్సైట్ క్రాష్ చూడడానికి వేచి

600
00:36:05,780 --> 00:36:09,990
లేదా మీరు ప్రోగ్రామ్ కొన్ని దోష సందేశం విశదపరుస్తుంది ఉంటే చూడటానికి వేచి

601
00:36:09,990 --> 00:36:14,330
మీరు చెడ్డ వ్యక్తిగా లక్కీ పొందండి మరియు మీరు కొన్ని క్రేజీ ఇన్పుట్ను అందించాలి ఎందుకంటే

602
00:36:14,330 --> 00:36:18,980
ప్రోగ్రామర్ మీ ప్రవర్తనను ముందుగా లేదు అంటే కార్యక్రమం, కూలిపోతుంది అని

603
00:36:18,980 --> 00:36:23,630
ఇది మీరు తగినంత కృషి విచారణ మరియు లోపం తో బహుశా దీని అర్థం

604
00:36:23,630 --> 00:36:26,650
మరింత ఖచ్చితమైన దాడి వేతనాన్ని ఎలా పూర్తి చేయాలో అంచనా.

605
00:36:26,650 --> 00:36:31,410
భద్రత కనుక చాలా భాగం కేవలం మొత్తంగా ఈ దాడులు తప్పించుకోవడం లేదు

606
00:36:31,410 --> 00:36:34,100
కానీ వాటిని గుర్తించడం మరియు వాస్తవానికి లాగ్లను చూడటం

607
00:36:34,100 --> 00:36:36,780
మరియు క్రేజీ ఇన్పుట్లను మీ వెబ్సైట్లో టైప్ ప్రజలు ఏమి చూసిన,

608
00:36:36,780 --> 00:36:38,960
ఏ శోధన పదాలు మీ వెబ్సైట్లో ప్రజలు టైప్ చేసిన తర్వాత

609
00:36:38,960 --> 00:36:42,870
కొన్ని బఫర్ పొంగిప్రవహిస్తున్న ఆశతో.

610
00:36:42,870 --> 00:36:45,500
మరియు సాధారణ బేసిక్స్ ఈ అన్ని దిమ్మల డౌన్ వ్యూహం యొక్క

611
00:36:45,500 --> 00:36:49,080
మరియు అది మెమరీని కేటాయించాల్సిన మరియు ఉపయోగించడానికి అర్థం లేదు.

612
00:36:49,080 --> 00:36:51,710
>> ఆ తర్వాత చాలా ఇది సంబంధించినది.

613
00:36:51,710 --> 00:36:54,280
యొక్క ఇంకా మళ్లీ హార్డు డ్రైవు యొక్క లోపల మెరుపు లెట్.

614
00:36:54,280 --> 00:36:58,440
మీరు క్రితం వారం లేదా రెండు నుండి రీకాల్ మీ రీసైకిల్ బిన్ లేదా ట్రాష్ కెన్ ఫైళ్ళను డ్రాగ్ ఉన్నప్పుడు

615
00:36:58,440 --> 00:37:03,710
ఏమి జరుగుతుంది? >> [విద్యార్థి] ఏమీ లేదు. >> ఖచ్చితంగా ఏమీ, కుడి?

616
00:37:03,710 --> 00:37:05,740
మీరు డిస్కు ఖాళీ తక్కువగా అమలు, చివరికి ఉంటే

617
00:37:05,740 --> 00:37:08,190
Windows లేదా Mac OS మీరు ఫైళ్ళను తొలగించడంలో ప్రారంభమౌతుంది.

618
00:37:08,190 --> 00:37:10,390
మీరు అక్కడ ఏదో డ్రాగ్ అయితే, అన్ని సురక్షితంగా వద్ద లేదు.

619
00:37:10,390 --> 00:37:13,800
మీ చదరపు గజం లేదా స్నేహితుడు లేదా కుటుంబ సభ్యుడు చేయాలి డబుల్ క్లిక్ చేయండి మరియు, voila, ఉంది

620
00:37:13,800 --> 00:37:16,310
మీరు తొలగించాలనుకుంటున్నారా ప్రయత్నించిన అన్ని నమూనాలను ఫైళ్లను ఉంది.

621
00:37:16,310 --> 00:37:19,590
మాకు చాలా కనీసం మీరు కుడి క్లిక్ చేయండి లేదా క్లిక్ నియంత్రణ ఉందని మీకు

622
00:37:19,590 --> 00:37:22,310
మరియు ఆ వంటి చెత్త లేదా ఏదో ఖాళీ.

623
00:37:22,310 --> 00:37:25,000
అయితే అప్పుడు చాలా ట్రిక్ విధంగా లేదు అని

624
00:37:25,000 --> 00:37:28,010
మీరు మీ హార్డు డ్రైవు ఒక ఫైలుని కలిగి ఏమి జరుగుతుంది ఎందుకంటే

625
00:37:28,010 --> 00:37:32,770
, కొన్ని పద పత్రం లేదా కొన్ని JPEG సూచిస్తుంది, మరియు ఇది మీ హార్డుడ్రైవు సూచిస్తుంది

626
00:37:32,770 --> 00:37:35,350
మరియు లెట్స్ ఇక్కడ ఈ అంశం గురించి ఆలోచించారు, ఆ ఫైల్ సూచిస్తుంది సే

627
00:37:35,350 --> 00:37:38,390
మరియు అది 0 సె మరియు 1s యొక్క మొత్తం బంచ్ కలిగివుంటుంది.

628
00:37:38,390 --> 00:37:42,470
ఏం మీరు మాత్రమే ట్రాష్ ఆ ఫైల్ డ్రాగ్ లేదు జరుగుతుంది లేదా బిన్ రీసైకిల్ చేయవచ్చు

629
00:37:42,470 --> 00:37:48,020
కానీ ఖాళీ? ఏమీ అబ్బాయి.

630
00:37:48,020 --> 00:37:49,640
ఇది ఇప్పుడు పూర్తిగా ఏమీ కాదు.

631
00:37:49,640 --> 00:37:54,290
కొంచెం ఈ పట్టిక రూపంలో జరుగుతుంది ఎందుకంటే ఇప్పుడు అది కేవలం ఏమీ ఉంది.

632
00:37:54,290 --> 00:37:58,370
కాబట్టి ఒక కంప్యూటర్ యొక్క మెమరీ లోపల డేటాబేస్ లేదా పట్టిక యొక్క రకమైన లేదు

633
00:37:58,370 --> 00:38:03,850
ఆ ముఖ్యంగా, ఫైళ్లను ఒక కాలమ్ 'పేర్లు మరియు ఫైళ్లను ఒక కాలమ్' నగర ఉంది

634
00:38:03,850 --> 00:38:07,720
పేరు ఈ నగర 123, కేవలం ఒక యాదృచ్చిక సంఖ్య కావచ్చు.

635
00:38:07,720 --> 00:38:14,560
కాబట్టి మేము x.jpeg మరియు నగర 123 వంటి ఏదైనా కలిగి ఉండవచ్చు.

636
00:38:14,560 --> 00:38:18,800
మీరు నిజంగా మీ ట్రాష్ను ఖాళీ ఏమి అప్పుడు జరుగుతుంది?

637
00:38:18,800 --> 00:38:20,330
దూరంగా వెళ్ళే.

638
00:38:20,330 --> 00:38:23,610
కాని దూరంగా వెళ్ళి లేదు 0 సె మరియు 1s ఉంది.

639
00:38:23,610 --> 00:38:26,270
>> కాబట్టి pset4 కు కనెక్షన్ తర్వాత ఏమిటి?

640
00:38:26,270 --> 00:38:31,240
Well, pset4, కేవలం మేము అనుకోకుండా కాంపాక్ట్ ఫ్లాష్ కార్డ్ మాసిపోయిన చేసిన ఎందుకంటే

641
00:38:31,240 --> 00:38:35,750
చెడు అదృష్టం ఈ ఫోటోలను అన్ని లేదా అది ఎందుకంటే కలిగి పాడైన మారింది

642
00:38:35,750 --> 00:38:38,000
0 సె మరియు 1s ఇప్పటికీ అక్కడ లేని కాదు.

643
00:38:38,000 --> 00:38:40,410
ఏదో పాడైన కాబట్టి బహుశా వాటిలో కొన్ని పోతాయి

644
00:38:40,410 --> 00:38:43,320
కొన్ని 0 సె 1s మారింది మరియు 1s 0 సె మారింది కోణంలో.

645
00:38:43,320 --> 00:38:47,240
బగ్గీ సాఫ్ట్వేర్ లేదా హార్డ్వేర్ లోపాలు కారణంగా బాడ్ థింగ్స్ జరుగుతుంది.

646
00:38:47,240 --> 00:38:50,370
కానీ ఆ బైట్ల అనేక, బహుశా వాటిని కూడా 100%, ఇప్పటికీ.

647
00:38:50,370 --> 00:38:55,050
ఇది JPEG1 ప్రారంభించారు కంప్యూటర్ లేదా కెమెరా తెలియదని కేవలం యొక్క

648
00:38:55,050 --> 00:38:56,910
మరియు JPEG2 ప్రారంభించారు.

649
00:38:56,910 --> 00:39:01,070
కానీ మీరు, ప్రోగ్రామర్, ఆ JPEGs ఎక్కడ అవగాహన ఒక బిట్ తెలిసిన

650
00:39:01,070 --> 00:39:06,010
లేదా వారు ఎలా కాబట్టి మీరు 0 సె మరియు 1s మరియు చెప్పడానికి JPEG, JPEG, విశ్లేషిస్తుంది

651
00:39:06,010 --> 00:39:09,440
మీరు తప్పనిసరిగా ఒక కోసం ఒక ప్రోగ్రామ్ను రాయడం లేదా అయితే లూప్

652
00:39:09,440 --> 00:39:12,820
ఆ ఫైళ్లను ప్రతి ఒక కోలుకుంటుంది.

653
00:39:12,820 --> 00:39:16,030
పాఠం తరువాత సురక్షితంగా మీ ఫైళ్ళను erasing ప్రారంభించడానికి ఉంటుంది

654
00:39:16,030 --> 00:39:18,340
మీరు పూర్తిగా ఈ నివారించడానికి చెయ్యాలనుకుంటే. అవును.

655
00:39:18,340 --> 00:39:21,010
>> [విద్యార్థి] ఎలా వస్తుందని మీ కంప్యూటర్ చెప్పాడు

656
00:39:21,010 --> 00:39:23,550
మీరు ముందు కన్నా ఎక్కువ మెమొరీ కలిగి?

657
00:39:23,550 --> 00:39:27,820
మీరు ముందు కన్నా ఎక్కువ మెమొరీ కలిగి - >> [విద్యార్థి] మరింత మెమరీ.

658
00:39:27,820 --> 00:39:29,630
ఓహ్. ప్రశ్న గుడ్.

659
00:39:29,630 --> 00:39:32,360
కాబట్టి ఎందుకు ఖాళీ తర్వాత మీ కంప్యూటర్ తెలుస్తుంది లేదు

660
00:39:32,360 --> 00:39:34,910
మీరు ముందు కన్నా ఎక్కువ ఖాళీని కలిగి?

661
00:39:34,910 --> 00:39:36,770
క్లుప్తంగా, అది అబద్ధం ఎందుకంటే.

662
00:39:36,770 --> 00:39:40,740
ఇప్పుడు మీరు చెప్పారు ఎందుకంటే సాంకేతికంగా, మీరు మరింత ఖాళీని కలిగి ఉన్నారా

663
00:39:40,740 --> 00:39:43,680
ఫైల్ ఒకప్పుడు పేరు మీరు ఇతర విషయాలను ఉంచవచ్చు.

664
00:39:43,680 --> 00:39:45,450
కానీ, బిట్స్ దూరంగా వెళ్తున్నారు కాదు

665
00:39:45,450 --> 00:39:48,590
మరియు ఆ బిట్స్, ఉదాహరణకు, అన్ని 0 సె మార్చారు చేస్తున్నారు కాదు

666
00:39:48,590 --> 00:39:50,150
మీ రక్షణ కొరకు.

667
00:39:50,150 --> 00:39:54,640
కాబట్టి దీనికి విరుద్ధంగా, మీరు సురక్షితంగా ఫైళ్ళు వేయండి లేదా భౌతికంగా పరికరాన్ని నాశనం ఉంటే,

668
00:39:54,640 --> 00:39:57,300
ఆ నిజంగా ఆ చుట్టూ కొన్నిసార్లు మాత్రమే మార్గం.

669
00:39:57,300 --> 00:40:02,020
>> ఎందుకు మేము ఆ సెమీ స్కేరీ గమనిక న విడిచి, మరియు మేము సోమవారం మీరు చూస్తారు.

670
00:40:02,020 --> 00:40:07,000
[చప్పట్లు]

671
00:40:07,780 --> 00:40:10,000
>> [CS50.TV]