1
00:00:00,000 --> 00:00:00,499

2
00:00:00,499 --> 00:00:11,261
[음악 연주]

3
00:00:11,261 --> 00:00:12,640
>> 데이비드 J. 마란 : 좋습니다.

4
00:00:12,640 --> 00:00:14,525
이 CS50이다.

5
00:00:14,525 --> 00:00:16,009
그리고 이것은 주 5의 시작이다.

6
00:00:16,009 --> 00:00:18,050
그리고 당신은 눈치 챘을 것이다으로,
재료의 일부

7
00:00:18,050 --> 00:00:21,050
조금 더 받고있다
단지, 좀 더 조밀 한.

8
00:00:21,050 --> 00:00:24,560
>> 그리고 특히, 매우 쉽게
당신은 몇 시간 동안 습관을 봤는데

9
00:00:24,560 --> 00:00:28,600
가장 아​​래로 낙서하려고합니다
우리가 무엇이든, 우리는 수업 시간에 말을하는지.

10
00:00:28,600 --> 00:00:31,626
하지만 그건 아마도 아니라, 실현
이상적인 교육 학적 접근

11
00:00:31,626 --> 00:00:34,250
소재의이 종류를 학습,
재질보다 일반적으로.

12
00:00:34,250 --> 00:00:37,250
그래서 우리는 기쁘게
그 CS50 자신의 Gheng 발표

13
00:00:37,250 --> 00:00:39,780
공을 준비하기 시작했다
노트의 정식 세트

14
00:00:39,780 --> 00:00:42,100
코스의 희망
이는 이들도 그 하나이다

15
00:00:42,100 --> 00:00:44,030
뿐만 역할
참조 및 리소스

16
00:00:44,030 --> 00:00:47,410
자료를 검토하고가는 대한
다시 자료를 통해있을 수 있습니다 그

17
00:00:47,410 --> 00:00:51,230
주위에 당신에게 처음으로 탈출하지만,
또한 귀하의 머리가 될 수 더

18
00:00:51,230 --> 00:00:53,740
아래, 때를보다 최대
강의 시간을 제공,

19
00:00:53,740 --> 00:00:56,960
당신이 참여할 수 있도록
더 신중, 같은

20
00:00:56,960 --> 00:00:59,170
더 scribbly에 반대했다.

21
00:00:59,170 --> 00:01:02,510
>> 그렇게 말한다면, 당신은에서 확인할 수있는 것들
웹 사이트는이 같은 문서입니다.

22
00:01:02,510 --> 00:01:04,660
그리고주의 사항, 좌측 상단에, 거기에
뿐만 아니라, 콘텐츠의 테이블,

23
00:01:04,660 --> 00:01:06,920
뿐만 아니라, 그 타임 코드
바로 점프합니다

24
00:01:06,920 --> 00:01:09,077
해당 부분
비디오 온라인에서.

25
00:01:09,077 --> 00:01:11,410
그리고 여기에 어떤 장 수행 한
본질적으로 설명되어 있습니다

26
00:01:11,410 --> 00:01:13,340
어떤이 일어난
특히 강의.

27
00:01:13,340 --> 00:01:16,370
그리고 강의의 대부분은 아르
이미 온라인 지금이 URL과 함께.

28
00:01:16,370 --> 00:01:20,110
그리고 우리는 나머지를 이어갈 것
이번 주 말까지 사람들의,

29
00:01:20,110 --> 00:01:22,380
그래서 자원을 활용 않습니다.

30
00:01:22,380 --> 00:01:25,740
>> 그래서 소동,
우리는 벗겨 시작

31
00:01:25,740 --> 00:01:28,180
경우에, 계층
시간에 대한 문자열입니다.

32
00:01:28,180 --> 00:01:30,670
그리고 우리는 문자열을 말 했는가
실제로 지난 주입니까?

33
00:01:30,670 --> 00:01:31,720

34
00:01:31,720 --> 00:01:32,900
그래서 문자 스타.

35
00:01:32,900 --> 00:01:34,900
그리고 문자 스타, 그럼,
그건 정말 뜻 이죠?

36
00:01:34,900 --> 00:01:37,150
음,이 모든 시간, 우리는했습니다 경우
함수를 호출하고,

37
00:01:37,150 --> 00:01:40,450
있는 getString 및 저장 등
소위 복귀

38
00:01:40,450 --> 00:01:42,910
에있는 getString의 값
variable-- 그것은이라고

39
00:01:42,910 --> 00:01:47,721
우리가 쓰고있어 string--의 유형
거기 위의 코드의 라인.

40
00:01:47,721 --> 00:01:49,970
내가 볼 때 그것은 단지의 내
필기 여기 확대

41
00:01:49,970 --> 00:01:51,930
나는이 얼마나 형편 실현 않습니다.

42
00:01:51,930 --> 00:01:54,180
>> 그러나 이제 그 가정 해 봅시다,
우변

43
00:01:54,180 --> 00:01:57,070
그럼에도 불구하고, 합리적이다
무엇 묘사

44
00:01:57,070 --> 00:01:58,880
이 모든 것들이 한
getString에와 시간입니다.

45
00:01:58,880 --> 00:02:00,380
있는 getString는 물론, 문자열을 가져옵니다.

46
00:02:00,380 --> 00:02:01,691
하지만 정말 무엇을 의미 하는가?

47
00:02:01,691 --> 00:02:04,190
그것은의 덩어리를 얻는다 수단
운영 시스템으로부터 메모리

48
00:02:04,190 --> 00:02:06,040
함수를 호출하여, malloc을 불렀다.

49
00:02:06,040 --> 00:02:07,390
그러나 더 자세한 내용은 나중에 다루겠습니다.

50
00:02:07,390 --> 00:02:09,139
그리고, 그것은 웁니다
메모리의 덩어리

51
00:02:09,139 --> 00:02:11,764
문자로 사용자가있다
에 입력 한 후, 물론

52
00:02:11,764 --> 00:02:14,800
널 문자 또는 백 슬래시
맨 마지막에서 0.

53
00:02:14,800 --> 00:02:18,280
>> 한편, 왼쪽에
이 이야기의 모든 시간,

54
00:02:18,280 --> 00:02:20,850
우리의 같은 변수를 선언했습니다.

55
00:02:20,850 --> 00:02:24,770
그리고 그 변수는 이제 무엇을이다
포인터를 호출 시작합니다.

56
00:02:24,770 --> 00:02:29,190
그것은있는 내부 상자 아니다
우리는 문자열을 넣어 Daven, 그 자체,

57
00:02:29,190 --> 00:02:32,550
오히려 우리는 광장에 넣어
왼쪽 정확히 무엇에 상자?

58
00:02:32,550 --> 00:02:34,890

59
00:02:34,890 --> 00:02:35,390
그래?

60
00:02:35,390 --> 00:02:37,118
>> 청중 :의 주소
어디 메모리에 위치하고.

61
00:02:37,118 --> 00:02:38,118
>> 데이비드 J. 마란 : 그렇지.

62
00:02:38,118 --> 00:02:40,690
Daven의 주소
메모리에 있습니다.

63
00:02:40,690 --> 00:02:44,650
그리고 Daven의 모두가 위치한 곳이 아니
본질적으로, 그러나 구체적으로는 어드레스

64
00:02:44,650 --> 00:02:45,150
무엇을?

65
00:02:45,150 --> 00:02:46,311

66
00:02:46,311 --> 00:02:46,810
그래?

67
00:02:46,810 --> 00:02:47,460
>> 청중 : 첫 번째 문자.

68
00:02:47,460 --> 00:02:50,209
>> 데이비드 J. 마란 : 첫 번째 문자
이 경우 Daven,에서,

69
00:02:50,209 --> 00:02:53,820
내가 임의로했다 제안했다
그리고 비현실적 일, OX1,

70
00:02:53,820 --> 00:02:55,910
이는 단지 의미
하나의 16 진수.

71
00:02:55,910 --> 00:02:57,993
그러나 그것은 아마거야
훨씬 더 큰 숫자 여야합니다

72
00:02:57,993 --> 00:03:01,260
우리는 그릴 수 있음
접두사로 0X와,

73
00:03:01,260 --> 00:03:02,806
진수 문자를 나타내는.

74
00:03:02,806 --> 00:03:05,930
그리고 우리는 위치를 알 필요가 없기 때문에
Daven의 문자의 나머지

75
00:03:05,930 --> 00:03:09,860
때문에의, 무엇 심플한 디자인
결정 몇 년 전에 만들어 졌다고?

76
00:03:09,860 --> 00:03:10,548
그래?

77
00:03:10,548 --> 00:03:11,651
>> 청중 : 백​​ 슬래시 0.

78
00:03:11,651 --> 00:03:12,900
데이비드 J. 마란 : 네, 맞습니다.

79
00:03:12,900 --> 00:03:18,100
백 슬래시 0에서이기는하지만, 당신이 할 수 있습니다
선형 시간 문자열을 통과하고,

80
00:03:18,100 --> 00:03:20,400
왼쪽에서 오른쪽으로 걸어
루프 또는 동안 함께

81
00:03:20,400 --> 00:03:22,608
루프 또는 뭔가처럼
즉, 여기에, 오, 결정

82
00:03:22,608 --> 00:03:24,751
특정 문자열의 끝에있다.

83
00:03:24,751 --> 00:03:27,000
에서 그냥 주소 그래서
문자열의 시작,

84
00:03:27,000 --> 00:03:30,290
우리의 전체를 액세스 할
그것은이 모든 동안 때문에,

85
00:03:30,290 --> 00:03:32,030
문자열은 문자 별이었다.

86
00:03:32,030 --> 00:03:36,370
>> 그래서 계속 사용하려면 확실히 괜찮아요
CS50 라이브러리와이 추상화,

87
00:03:36,370 --> 00:03:38,440
말하자면, 그러나 우리는거야합니다
정확히보기 시작

88
00:03:38,440 --> 00:03:41,230
무슨 일 됐어요
모든 시간 아래.

89
00:03:41,230 --> 00:03:45,260
그래서 당신은이 예제를 불러올 수있다,
역시 마지막에서, 0 비교,

90
00:03:45,260 --> 00:03:47,300
이는 실제로 비교하지 않았다.

91
00:03:47,300 --> 00:03:49,070
그러나 우리는이 문제를 해결하기 시작했다.

92
00:03:49,070 --> 00:03:52,020
>> 그러나 같은 아마 재교육,
나는 누군가 관심을 수 있습니다

93
00:03:52,020 --> 00:03:54,261
분홍 코끼리 오늘날,
또한 장에 의해 만들어?

94
00:03:54,261 --> 00:03:55,760
어떻게 앞의 당신은? [INAUDIBLE].

95
00:03:55,760 --> 00:03:56,660
올라 와요.

96
00:03:56,660 --> 00:03:58,740
>> 그리고 그 동안,
당신이 와서 같이하자

97
00:03:58,740 --> 00:04:01,670
단지 잠시 동안 무슨 생각
이 코드는 실제로 일을했다.

98
00:04:01,670 --> 00:04:04,917
이 두 변수를 선언하는 것
위, s 및 t, 및있는 getString을 호출.

99
00:04:04,917 --> 00:04:08,250
이것은, 매우 사용하기 쉬운 프로그램 아니다
당신을 말하지 않기 때문에 무엇을 할 수 있습니다.

100
00:04:08,250 --> 00:04:10,541
그러나 단지 우리가있어 가정하자
육즙이 부분에 초점을 맞추고.

101
00:04:10,541 --> 00:04:14,470
의이 동일한 경우 그리고 우리는 할
그것은 printf의 말을해야 t에 해당,

102
00:04:14,470 --> 00:04:16,170
당신은 같은 일을 입력했습니다.

103
00:04:16,170 --> 00:04:16,670
안녕하세요.

104
00:04:16,670 --> 00:04:17,050
당신의 이름은 무엇입니까?

105
00:04:17,050 --> 00:04:17,779
>> 쟈넬 : 쟈넬.

106
00:04:17,779 --> 00:04:19,529
데이비드 J. 마란 : 쟈넬,
만나서 반갑습니다.

107
00:04:19,529 --> 00:04:21,800
에서 당신의 도전 그래서
이 코끼리 손

108
00:04:21,800 --> 00:04:25,230
첫째 우리에게 무엇의 그림을 그릴 수있다
그 첫번째이 표현되는

109
00:04:25,230 --> 00:04:25,970
선.

110
00:04:25,970 --> 00:04:28,139
그래서 s와 t는 다음과 같을 수 있습니다
어떻게 화면에 표시?

111
00:04:28,139 --> 00:04:30,680
그리고 당신은 그것을 그릴 수 있습니다
이 대형 스크린에 손가락.

112
00:04:30,680 --> 00:04:31,780

113
00:04:31,780 --> 00:04:34,510
>> 그래서 두 개의 반쪽을 거기에
그 방정식의 각면.

114
00:04:34,510 --> 00:04:37,760
그래서이 왼쪽에들, 그리고
다음 오른쪽에있는 getString.

115
00:04:37,760 --> 00:04:40,540
그리고 t의 왼쪽에있다
다음 오른쪽에있는 getString.

116
00:04:40,540 --> 00:04:42,630
그래서 우리는 어떻게 시작 있습니다
그림을 그리기가

117
00:04:42,630 --> 00:04:46,340
무슨 일이 일어나고 있는지 나타냅니다
여기에 메모리에, 당신은 말할 것?

118
00:04:46,340 --> 00:04:49,150
그리고 내가 당신이 설명합시다
당신이 가서 당신은 무엇을하고 있어요.

119
00:04:49,150 --> 00:04:49,820
>> 쟈넬 : OK.

120
00:04:49,820 --> 00:04:58,890
음, 첫째, 그것은 묻는 것
당신은 입력 문자열을 얻을 수 있습니다.

121
00:04:58,890 --> 00:05:00,439
그리고 아, 미안 store-- 것이다.

122
00:05:00,439 --> 00:05:01,230
데이비드 J. 마란 : OK.

123
00:05:01,230 --> 00:05:01,730
좋은.

124
00:05:01,730 --> 00:05:03,330
그리고 이것은 무엇이라고?

125
00:05:03,330 --> 00:05:03,950
아, 그렇군요.

126
00:05:03,950 --> 00:05:04,450
계속하세요.

127
00:05:04,450 --> 00:05:05,575
내가 방해 할 생각은하지 않았다.

128
00:05:05,575 --> 00:05:07,060
쟈넬 : 죄송합니다.

129
00:05:07,060 --> 00:05:14,237
그래서 입력을에 것
주소가 확실하지 집게 리아.

130
00:05:14,237 --> 00:05:17,320
나는 수를 정확하게 기억할 수 없다,
하지만 난 그것을 0으로 시작했다 생각합니다.

131
00:05:17,320 --> 00:05:18,420
>> 데이비드 J. 마란 : 그건, 괜찮아
내가 번호를 만들었 기 때문에,

132
00:05:18,420 --> 00:05:19,650
그래서 정답은 없습니다.

133
00:05:19,650 --> 00:05:22,105
>> 쟈넬 : 0 호를 시작으로.

134
00:05:22,105 --> 00:05:24,000
>> 데이비드 J. 마란 : OK, 그래서 요소 0.

135
00:05:24,000 --> 00:05:24,765
물론.

136
00:05:24,765 --> 00:05:28,295
>> 쟈넬 : 그리고 경우
단지 두 letter-- 추천

137
00:05:28,295 --> 00:05:30,496
>> 데이비드 J. 마란 : OK, 다시 당신에게.

138
00:05:30,496 --> 00:05:33,629
>> 쟈넬 : 그래서 요소 0, 그리고
다음 요소 일 또는 요소 2.

139
00:05:33,629 --> 00:05:36,670
어떤 조각 그리고 : 데이비드 J. 마란
그림은 지금 그리는?

140
00:05:36,670 --> 00:05:37,690
getString에 대한 호출?

141
00:05:37,690 --> 00:05:38,830
또는 S의 선언?

142
00:05:38,830 --> 00:05:42,890
>> 쟈넬 : 선언
의, 나는 믿는다.

143
00:05:42,890 --> 00:05:45,980
아, getString에,이 때문에
각각의 [에 입력 할 수? 영역입니다. ?]

144
00:05:45,980 --> 00:05:46,510
>> 데이비드 J. 마란 : 좋은.

145
00:05:46,510 --> 00:05:47,051
정확히.

146
00:05:47,051 --> 00:05:49,300
심지어이 효과적으로하지만
배열 회수 반환,

147
00:05:49,300 --> 00:05:53,300
우리는 문자열을 다시 얻을 때, 우리는 할 수
01과 2를 사용하여 해당 문자열로 인덱스입니다.

148
00:05:53,300 --> 00:05:56,180
기술적으로, 이들은 아마
개별 주소로 대표

149
00:05:56,180 --> 00:05:57,100
하지만 괜찮아요.

150
00:05:57,100 --> 00:06:00,170
>> 그래서, 생각하면 그냥 빨리 할 수
우리가 중단 된 부분에 전달

151
00:06:00,170 --> 00:06:04,320
마지막으로, 중 하나가
문자열, B 전자 g이었다

152
00:06:04,320 --> 00:06:10,337
백 슬래시 공함으로써 대표 게이브의의
입력, 우리는 어떻게들 이제 나타낼 수 있는가?

153
00:06:10,337 --> 00:06:12,670
이있어 메모리가 있으면
getString에 의해 반환 된?

154
00:06:12,670 --> 00:06:14,415

155
00:06:14,415 --> 00:06:17,610
>> 쟈넬 : 그것은 있을까
원호로 표시?

156
00:06:17,610 --> 00:06:18,750
>> 데이비드 J. 마란 : 아크?

157
00:06:18,750 --> 00:06:19,130
아, 아니.

158
00:06:19,130 --> 00:06:21,171
, 그냥 그림으로, 가정 해 봅시다
나 그냥 앞으로 가자

159
00:06:21,171 --> 00:06:25,710
이 s의 경우,이 것을 제안
getString에의 반환 값입니다.

160
00:06:25,710 --> 00:06:29,482
그리고 당신은 0, 1, 2,로이 그려 놨하는
완벽하게 합리적이다 우리 때문에

161
00:06:29,482 --> 00:06:30,940
같은 문자열로 인덱스, 할 수있다.

162
00:06:30,940 --> 00:06:33,340
그러나 단지와 일치합니다
마지막으로, 내가 앞서 가자

163
00:06:33,340 --> 00:06:37,310
임의로이 제안합니다
주소 하나이며,이 주소 2,

164
00:06:37,310 --> 00:06:39,597
본 등등 어드레스 3,이다.

165
00:06:39,597 --> 00:06:41,430
그래서, 그냥 슈퍼 영웅이 될 수 있습니다
분명, 무슨 일이야

166
00:06:41,430 --> 00:06:44,580
그 결과들에 이동합니다
코드의 첫 번째 줄, 당신은 말할 것?

167
00:06:44,580 --> 00:06:45,420
>> 쟈넬 : 주소 하나?

168
00:06:45,420 --> 00:06:46,420
>> 데이비드 J. 마란 : 그렇지.

169
00:06:46,420 --> 00:06:47,190
그래서 0x1로를 해결합니다.

170
00:06:47,190 --> 00:06:48,220

171
00:06:48,220 --> 00:06:51,230
그리고 그 사이에, 내가 가서하자
당신이 한 일의 대부분을 중복

172
00:06:51,230 --> 00:06:52,740
여기에 내 자신의 t을 추가합니다.

173
00:06:52,740 --> 00:06:56,340
나는 게이브을 입력한다면
또, 두 번째로,

174
00:06:56,340 --> 00:07:01,530
getString에 묻는 메시지가 언제, 어디서,
물론, 게이브 갈거야?

175
00:07:01,530 --> 00:07:02,280
음, presumably--

176
00:07:02,280 --> 00:07:04,935

177
00:07:04,935 --> 00:07:05,975
>> 쟈넬 : 여기에처럼?

178
00:07:05,975 --> 00:07:06,850
데이비드 J. 마란 : 그래.

179
00:07:06,850 --> 00:07:08,516
쟈넬 : 또는 동일한 상자도있어?

180
00:07:08,516 --> 00:07:11,940
데이비드 J. 마란은 : 내가 그래, 제안하자
정확히 이러한 추가 상자에 이렇게.

181
00:07:11,940 --> 00:07:15,230
하지만 지금은 키 것은 심지어 것입니다
나는이 아주 가까이를 그려 놨지만

182
00:07:15,230 --> 00:07:18,650
랑 같이 0x1로,이
실제로 0x2--되고,

183
00:07:18,650 --> 00:07:25,750
이것은 지금, 주소 0x10을 수 있습니다
예를 들면,과하게 0x11 및 0x12를,

184
00:07:25,750 --> 00:07:26,870
등등.

185
00:07:26,870 --> 00:07:29,955
그래서, 그런 경우가 있다면,
어떤 t 여기에 끝낼거야?

186
00:07:29,955 --> 00:07:30,830
>> 쟈넬 : 0x10을?

187
00:07:30,830 --> 00:07:31,830
데이비드 J. 마란 : 그렇지.

188
00:07:31,830 --> 00:07:33,180
그래서 0x10을.

189
00:07:33,180 --> 00:07:34,570
그리고 이제 마지막 질문.

190
00:07:34,570 --> 00:07:37,510
당신은 지금까지의 일을해야했다
지금까지 코끼리 어려운.

191
00:07:37,510 --> 00:07:42,650
지금까지, 나는 코드를 당기면
다시, 내가 할 때, 선 셋에,

192
00:07:42,650 --> 00:07:47,630
의 같음 t에 해당하는 경우, 사실은 무엇을 어디로
우리는 여기에 그려 놨 비교하는 것을?

193
00:07:47,630 --> 00:07:49,271
>> 쟈넬 : 두 개의 주소?

194
00:07:49,271 --> 00:07:50,270
데이비드 J. 마란 : 그렇지.

195
00:07:50,270 --> 00:07:53,350
그래서 t 같지 동일한 s입니다 말인지?

196
00:07:53,350 --> 00:07:56,210
즉, 10과 동일한 동일한 1?

197
00:07:56,210 --> 00:07:59,710
그리고 물론,
확실한 대답은 이제 더있다.

198
00:07:59,710 --> 00:08:02,920
그래서이 프로그램은 궁극적으로
당신이 말하는 것이 무엇 인쇄 할 것?

199
00:08:02,920 --> 00:08:05,770

200
00:08:05,770 --> 00:08:08,405
>> 쟈넬 : 그것은, 수 있을까요
당신은 같은 일을 입력?

201
00:08:08,405 --> 00:08:11,446
>> 데이비드 J. 마란 : 그래서 만약
의 1이며, t는 10?

202
00:08:11,446 --> 00:08:13,320
>> 쟈넬 : 당신은 다른 일을 입력했습니다.

203
00:08:13,320 --> 00:08:13,570
>> 데이비드 J. 마란 : 그렇지.

204
00:08:13,570 --> 00:08:14,480
당신은 다른 일을 입력했습니다.

205
00:08:14,480 --> 00:08:14,850
좋아.

206
00:08:14,850 --> 00:08:16,714
그래서 박수,
여기, 우리가 할 수있는 경우.

207
00:08:16,714 --> 00:08:17,214
[박수]

208
00:08:17,214 --> 00:08:17,708
즉 고통이었다.

209
00:08:17,708 --> 00:08:18,208
나는 알고있다.

210
00:08:18,208 --> 00:08:19,684
멋지게 수행.

211
00:08:19,684 --> 00:08:24,690
그래서 지금 보자 경우 우리는 할 수 없습니다
수정이 무엇인지 떨어져 애타게.

212
00:08:24,690 --> 00:08:28,040
그리고 물론, 우리는이 겁니다 고정 할 때
이는 지금 green--를 대표합니다

213
00:08:28,040 --> 00:08:29,690
우리는 여기에 개선의 몇했다.

214
00:08:29,690 --> 00:08:32,409
첫째, 단지 정신으로
내가 먼저 알아보고 있어요 확인

215
00:08:32,409 --> 00:08:35,110
의 널 같고 t은 널 (null)과 동일합니다.

216
00:08:35,110 --> 00:08:39,440
그리고 그냥 명확하게, 경우는 수도
s 또는 t이 같은 코드에서 null이?

217
00:08:39,440 --> 00:08:43,140

218
00:08:43,140 --> 00:08:44,490
때 s 또는 t는 널이 될 수 있습니다.

219
00:08:44,490 --> 00:08:44,990
그래?

220
00:08:44,990 --> 00:08:45,990
>> 청중 : [들리지].

221
00:08:45,990 --> 00:08:49,490

222
00:08:49,490 --> 00:08:50,510
>> 데이비드 J. 마란 : 그렇지.

223
00:08:50,510 --> 00:08:52,840
문자열 사용자가 해당하는 경우
에 입력 너무 깁니다

224
00:08:52,840 --> 00:08:56,140
메모리에 맞게, 또는합니다
그런 이상한 코너 케이스,

225
00:08:56,140 --> 00:08:59,010
우리가 볼 수 있습니다 말 그대로,있는 getString
오늘, 자사의 문서,

226
00:08:59,010 --> 00:09:02,330
그것은뿐만 null를 돌려줍니다 말한다
특별 감시 값

227
00:09:02,330 --> 00:09:05,417
하거나 종류의 특수 기호
그 뭔가 잘못을 의미합니다.

228
00:09:05,417 --> 00:09:07,500
그래서 우리는 확인하려는
알고 보니 때문에, 그

229
00:09:07,500 --> 00:09:09,720
이 널 (null)은 매우 위험한 값입니다.

230
00:09:09,720 --> 00:09:14,250
>> 종종, 당신은 뭔가를하려고하면
널 (null)을 통과하는 function--을 포함

231
00:09:14,250 --> 00:09:17,470
입력으로, 그 기능을 instance--에 대한
아주 그것으로, 충돌 것이다 있습니다,

232
00:09:17,470 --> 00:09:19,090
당신의 전체 프로그램을 내려.

233
00:09:19,090 --> 00:09:22,570
따라서이 세 번째 줄은 이제 단지 정신입니다
당신이 경우, 오류 검사를 확인합니다.

234
00:09:22,570 --> 00:09:25,450
즉, 지금 좋은 습관이야
우리는 시간에 얻을 수 있습니다 우리

235
00:09:25,450 --> 00:09:28,050
값을 사용하려고하는
잠재적으로, 널 (null)이 될 수 있습니다.

236
00:09:28,050 --> 00:09:32,000
>> 지금, 여기에 네 번째 줄에서,
"만약 strcmp와 (S, t),"잘​​,

237
00:09:32,000 --> 00:09:33,180
무엇을 말하는 것을입니까?

238
00:09:33,180 --> 00:09:36,750
음, 우리는 이것이 매우 간결을했다
문자열 비교 명명 된 함수입니다.

239
00:09:36,750 --> 00:09:40,370
그리고 인생의 목적은 비교하는 것입니다
둘째 반대의 첫 번째 인수,

240
00:09:40,370 --> 00:09:44,640
하지만 자신의 주소의 관점에서,
우리는 잠시 의도했던 것처럼

241
00:09:44,640 --> 00:09:48,270
전 빨간색 코드 만
오히려 그 두 가지를 비교

242
00:09:48,270 --> 00:09:53,210
인간적으로 직관적 인 문자열
이에 대해,이를 비교하여 방법

243
00:09:53,210 --> 00:09:56,690
이,이에 대한, 그리고에 대한
다음 중지 할 때 한 경우 및

244
00:09:56,690 --> 00:09:59,590
또는 내 손가락의 두
백 슬래시 공을 안타.

245
00:09:59,590 --> 00:10:04,530
그래서 누군가 년 전에 구현을 strcmp
기능을 우리를 위해 구현

246
00:10:04,530 --> 00:10:08,890
우리는 우리가받은 것 바란다고
단지 간단한 두 값을 비교하여.

247
00:10:08,890 --> 00:10:14,929
>> 지금 솔직히 도면을 유지
이러한 다양한 모든 숫자.

248
00:10:14,929 --> 00:10:17,470
그러나 현실은 내가 봤는데입니다
전체 시간이을 만들기.

249
00:10:17,470 --> 00:10:19,580
그래서 내가 그냥 앞으로 가자
이러한를 낙서

250
00:10:19,580 --> 00:10:23,100
포인트를 만들기 위해 그, 말
일의 전진,

251
00:10:23,100 --> 00:10:30,160
우리가 정말 걱정하지 않을거야
무슨 일이 실제로 해결

252
00:10:30,160 --> 00:10:30,790
메모리.

253
00:10:30,790 --> 00:10:34,320
그래서 나는이를 그릴 않을거야
너무 더 이상 숫자 가지,

254
00:10:34,320 --> 00:10:38,970
난 도망이 단지 추상적 해요
그냥 화살표가 더 친절한 약간.

255
00:10:38,970 --> 00:10:42,060
>> 즉, (S)가 포인터이면,
음,, 그냥 문자 그대로를 그려 보자

256
00:10:42,060 --> 00:10:45,430
포인터로, 화살표가 가리키는
, 뭔가 다른 자체에서

257
00:10:45,430 --> 00:10:48,280
약을 너무 많이 더 걱정
이 주소의 특징점

258
00:10:48,280 --> 00:10:49,910
이는 다시, 나는 어쨌든했다.

259
00:10:49,910 --> 00:10:52,680
그러나 우리는 그 주소를 볼 수있을 것이다
때로는 코드를 디버깅 할 때.

260
00:10:52,680 --> 00:10:56,450
>> 이제 한편,이 프로그램
여기까지 수정은 물론,

261
00:10:56,450 --> 00:10:58,720
비교하여 그 문제
두 문자열.

262
00:10:58,720 --> 00:11:00,260
그러나 우리는 또 다른 문제 다 퉜다.

263
00:11:00,260 --> 00:11:03,180
이 복사본이었다
, 마지막으로 프로그램

264
00:11:03,180 --> 00:11:06,880
이에, 내가 투자하려고했다
문자열에서 단지 첫 번째 문자.

265
00:11:06,880 --> 00:11:09,620
그러나 증상이 무엇 이었습니까
우리는 때 마지막으로 본

266
00:11:09,620 --> 00:11:14,150
사용자는 같은 값에 입력
소문자 게이브,의에 대한,

267
00:11:14,150 --> 00:11:19,310
우리는 t에의 할당
이 세 번째 행에서와 같이,

268
00:11:19,310 --> 00:11:22,900
그리고, 나는에 시도
t 브래킷 공을 활용?

269
00:11:22,900 --> 00:11:25,950
의 효과가 무엇인가
t 브래킷 공 여기를 변경?

270
00:11:25,950 --> 00:11:27,150
>> 청중 : 그것은의 변경.

271
00:11:27,150 --> 00:11:29,360
>> 데이비드 J. 마란 : 네,
나뿐만 아니라,의를 변경했습니다.

272
00:11:29,360 --> 00:11:31,050
정말 무슨 일이 있었는지 때문에?

273
00:11:31,050 --> 00:11:34,130
음, 청소 수 있다면 어디 보자
이 사진을 최대로는 다음과 같다.

274
00:11:34,130 --> 00:11:41,390
>> (S) 인 경우, 다시, 워드 g,
A, B, E, 슬래시, 0, 및 S

275
00:11:41,390 --> 00:11:44,084
우리는 상자로 그림을 계속해서
여기에, 그러나 더 이상 주소.

276
00:11:44,084 --> 00:11:45,250
의 물건을 생산을 중단하자.

277
00:11:45,250 --> 00:11:47,510
그냥 그림을 그려 보자
세계를 단순화합니다.

278
00:11:47,510 --> 00:11:52,640
>> 내가 문자열 t와 t를 선언 할 때,
즉, 메모리의 덩어리를 만듭니다.

279
00:11:52,640 --> 00:11:55,850
광장은 32을 될 일이
대부분의 컴퓨터의 비트.

280
00:11:55,850 --> 00:11:59,530
사실, 경우에 당신은 들었어요
컴퓨터는 32 비트 구조를 갖는

281
00:11:59,530 --> 00:12:03,000
정말 멋진 발언, 즉 단지
그것은 32 비트 주소를 사용 수단.

282
00:12:03,000 --> 00:12:05,370
그리고 옆으로 기술로,
당신이 궁금해 한 경우

283
00:12:05,370 --> 00:12:09,630
왜 오래된 컴퓨터, 실제로 경우
RAM의 많은 수프 그들을하려

284
00:12:09,630 --> 00:12:12,360
단을 가질 수있는 최대
RAM 4GB의의,

285
00:12:12,360 --> 00:12:14,860
물론 그 말 그대로 때문이다,
이전 컴퓨터가 할 수 만

286
00:12:14,860 --> 00:12:17,250
4만큼 높은 카운트
억, 40 억 바이트,

287
00:12:17,250 --> 00:12:20,590
그 때문에 32 비트를 사용했다
주소 번호.

288
00:12:20,590 --> 00:12:23,260
>> 그러나 어떤 경우에는,이 목록
예를 들어, 이야기의 훨씬 간단.

289
00:12:23,260 --> 00:12:27,250
t는 또 다른 포인터, 또는
정말 문자 스타, 일명 문자열입니다.

290
00:12:27,250 --> 00:12:30,860
그리고 어떻게이 사진을 업데이트 하시겠습니까
이제 코드의 두번째 라인,

291
00:12:30,860 --> 00:12:31,950
도트 후, 점, 점?

292
00:12:31,950 --> 00:12:35,845
내가 할 때 문자열 t는의 세미콜론과 동일
이 그림은 어떻게 변경합니까?

293
00:12:35,845 --> 00:12:37,500

294
00:12:37,500 --> 00:12:38,000
그래?

295
00:12:38,000 --> 00:12:38,916
>> 청중 : [들리지].

296
00:12:38,916 --> 00:12:41,087

297
00:12:41,087 --> 00:12:42,020
>> 데이비드 J. 마란 : 그래.

298
00:12:42,020 --> 00:12:42,600
정확히.

299
00:12:42,600 --> 00:12:45,620
나는 단지에서 화살표를 넣어
같은 주소에 t 상자,

300
00:12:45,620 --> 00:12:47,570
에서 같은 첫 글자했다.

301
00:12:47,570 --> 00:12:50,850
또는 기술적으로, 만약이
남자는 0x1로 여전히했다

302
00:12:50,850 --> 00:12:53,052
내가 가진 것처럼입니다
여기 0x1에서 0x1로 여기.

303
00:12:53,052 --> 00:12:54,760
그러나 다시, 무슨 상관이야
주소에 대한?

304
00:12:54,760 --> 00:12:56,345
이제 중요한 그냥 생각입니다.

305
00:12:56,345 --> 00:12:57,720
따라서이 여기서 무슨 일이 일어나고 있습니다.

306
00:12:57,720 --> 00:13:02,690
물론, 당신이 경우에 t 브래킷 그래서
배열 표기법이다 영,

307
00:13:02,690 --> 00:13:05,650
의 course-- 그리고 솔직히, 그것은 본다
여기에 배열이있는 것처럼,

308
00:13:05,650 --> 00:13:07,340
하지만 지금은 이상한 일이있다.

309
00:13:07,340 --> 00:13:11,160
그 프로그래밍 언어를 알고,
C는, 당신에게이 기능을 제공합니다

310
00:13:11,160 --> 00:13:14,650
이에 의해, t는 경우에도
포인터, 또는 S는 포인터이고,

311
00:13:14,650 --> 00:13:18,050
당신은 여전히​​ 익숙한을 사용할 수 있습니다
편안한 대괄호

312
00:13:18,050 --> 00:13:22,520
표기는 첫 번째 요소로 이동합니다,
두번째 요소, 또는 임의의 소자 나

313
00:13:22,520 --> 00:13:26,130
그 포인터가 가리키는 것을
행 아마도 때문에, 그것을

314
00:13:26,130 --> 00:13:29,410
이 경우에서와 같이, 인
일부 배열을 가리키는.

315
00:13:29,410 --> 00:13:30,340
>> 그래서 우리는 어떻게이 문제를 해결합니까?

316
00:13:30,340 --> 00:13:33,660
그것이 어디서 났는지 솔직히,이입니다
첫눈에 약간의 압도적.

317
00:13:33,660 --> 00:13:35,340
하지만, 여기에 새롭게 향상된 버전입니다.

318
00:13:35,340 --> 00:13:37,460
>> 그래서 첫째, 내가 받고 있어요
CS50 라이브러리를 제거,

319
00:13:37,460 --> 00:13:41,170
다만 실제로 그 s의 폭로
문자 스타, 그냥 동의어.

320
00:13:41,170 --> 00:13:43,540
그리고 t는 문자 별이다.

321
00:13:43,540 --> 00:13:48,290
그러나에 무슨 일이 일어나고 있는지
그 라인의 오른쪽

322
00:13:48,290 --> 00:13:49,970
t은 값이 할당되는 경우?

323
00:13:49,970 --> 00:13:50,790
>> malloc에​​ 무엇입니까?

324
00:13:50,790 --> 00:13:51,630
그것은 무엇을 나 strlen입니까?

325
00:13:51,630 --> 00:13:52,547
를 sizeof (문자) 란 무엇입니까?

326
00:13:52,547 --> 00:13:54,380
왜 도대체이 작업을 수행
회선 너무 복잡?

327
00:13:54,380 --> 00:13:55,713
그것은 무엇 높은 수준에서 뭐하는거야?

328
00:13:55,713 --> 00:13:56,482

329
00:13:56,482 --> 00:13:57,440
무슨 일이 t에 저장하는거야?

330
00:13:57,440 --> 00:13:58,646
그래?

331
00:13:58,646 --> 00:14:01,104
청중 : 그것은 할당하는 것
메모리 공간의 일정량.

332
00:14:01,104 --> 00:14:03,032
그것은 저장하는 데있어 것 같아요,
편지 [INAUDIBLE].

333
00:14:03,032 --> 00:14:04,032
>> 데이비드 J. 마란 : 완벽 한.

334
00:14:04,032 --> 00:14:04,540
완벽 한.

335
00:14:04,540 --> 00:14:06,650
그것은 특정 할당있어
메모리 공간의 양

336
00:14:06,650 --> 00:14:08,940
아마도 미래의 편지를 저장합니다.

337
00:14:08,940 --> 00:14:11,310
특히, malloc에
따라서 무엇을 반환?

338
00:14:11,310 --> 00:14:13,114

339
00:14:13,114 --> 00:14:14,851
>> 청중 : [들리지]를 갈까요?

340
00:14:14,851 --> 00:14:15,850
데이비드 J. 마란 : 그렇지.

341
00:14:15,850 --> 00:14:18,850
해당 메모리의 주소를 반환
하는 말의 멋진 방법입니다,

342
00:14:18,850 --> 00:14:21,640
의 주소를 반환
해당 메모리의 첫 번째 바이트.

343
00:14:21,640 --> 00:14:25,460
내가 기억하기에 부담이다
얼마나 많은 메모리 I 실제로

344
00:14:25,460 --> 00:14:27,140
할당 또는 위해 malloc을 요청했다.

345
00:14:27,140 --> 00:14:28,384
>> 이제 얼마입니까?

346
00:14:28,384 --> 00:14:30,550
음, 비록
여기에 괄호를 많이,

347
00:14:30,550 --> 00:14:32,970
malloc에​​ 단지 하나의 인자를합니다.

348
00:14:32,970 --> 00:14:37,250
그리고 난의의 strlen 함수를 지정하여 드리 해요
저 많은 바이트의에 있기 때문에,

349
00:14:37,250 --> 00:14:37,800
하지만 하나를 추가 할 수 있습니다.

350
00:14:37,800 --> 00:14:38,300
왜?

351
00:14:38,300 --> 00:14:39,030

352
00:14:39,030 --> 00:14:39,530
그래?

353
00:14:39,530 --> 00:14:40,840
>> 청중 : 백​​ 슬래시 0.

354
00:14:40,840 --> 00:14:41,840
데이비드 J. 마란 : 그렇지.

355
00:14:41,840 --> 00:14:43,423
우리는 약간의 가사를 할 수있어.

356
00:14:43,423 --> 00:14:45,970
백 슬래시가 있기 때문에 그래서
영, 우리는 더 나은 기억 것입니다.

357
00:14:45,970 --> 00:14:47,310
그렇지 않으면, 우리는거야
문자열을 만드는 그

358
00:14:47,310 --> 00:14:49,170
특별한 터미네이터가 없습니다.

359
00:14:49,170 --> 00:14:52,640
>> 한편, 단지 슈퍼 영웅이 될 수 있습니다
항문, 나는를 sizeof (문자)가

360
00:14:52,640 --> 00:14:55,730
단지의 경우 누군가가 내 실행
하지 CS50 어플라이언스 코드

361
00:14:55,730 --> 00:14:58,220
하지만 어쩌면 다른 컴퓨터
모두 문자

362
00:14:58,220 --> 00:15:01,470
관례 적으로, 한 바이트이지만 둘
바이트 또는 그보다 더 큰 것을.

363
00:15:01,470 --> 00:15:04,490
그냥 슈퍼 수있어,
오류 슈퍼 싫어.

364
00:15:04,490 --> 00:15:06,940
비록 실제로, 이건
가장 가능성이 하나 될 것.

365
00:15:06,940 --> 00:15:11,490
>> 지금, 그 사이에, 내가 가서 복사
문자열, t 브래킷 i는 t 브래킷의 동일합니다.

366
00:15:11,490 --> 00:15:14,962
그리고 지난 주에 연기합니다
소스 코드는 무슨 일이 일어나고 있는지 볼 수 있습니다.

367
00:15:14,962 --> 00:15:17,670
키 테이크 아웃하고, 그러나
이유는 녹색에서 이제 코드를 입력

368
00:15:17,670 --> 00:15:22,520
, 바로 그 마지막 줄에 있기 때문이다
t 브래킷 0,인지 toupper와 동일

369
00:15:22,520 --> 00:15:25,230
의 효과를 갖는다
활용되는 문자열?

370
00:15:25,230 --> 00:15:26,960
t 및 / 또는 S?

371
00:15:26,960 --> 00:15:29,280

372
00:15:29,280 --> 00:15:30,580
코드의 마지막 줄.

373
00:15:30,580 --> 00:15:32,930

374
00:15:32,930 --> 00:15:35,560
>> 무엇 때문에 그냥 t
이 시간을 무슨 일이 있었

375
00:15:35,560 --> 00:15:41,500
나는 약간 그 마지막 단계를 취소하는 경우,
내가 malloc을 호출 할 때 무슨 일이, 무슨 일이 있었있어

376
00:15:41,500 --> 00:15:45,380
나는 기본적으로 메모리의 덩어리를 얻을
즉, 원본과 동일한 크기이며,

377
00:15:45,380 --> 00:15:47,020
즉 산술 때문에 나는했다.

378
00:15:47,020 --> 00:15:50,920
나는 주소 t에 저장하고있어
메모리의 청크의.

379
00:15:50,920 --> 00:15:53,370
심지어이 좋은 보이지만
그리고, 꽤 좋은 빈,

380
00:15:53,370 --> 00:15:56,882
현실은 우리가 지네된다
여기에, 호출 쓰레기 값을 유지합니다.

381
00:15:56,882 --> 00:15:59,340
메모리의 청크 수도 매우
물론 이전에 사용되었습니다

382
00:15:59,340 --> 00:16:00,940
몇 초, 몇 분 전에.

383
00:16:00,940 --> 00:16:04,410
그래서 절대적으로 숫자가있을 수 있습니다
그냥 우연히이 또는 문자.

384
00:16:04,410 --> 00:16:08,580
그러나 그들은 내가 때까지 유효하지있어
나 자신이 메모리 덩어리를 채 웁니다

385
00:16:08,580 --> 00:16:12,510
실제 문자와 같은 I
이 for 루프에서 수행.

386
00:16:12,510 --> 00:16:13,180
좋아?

387
00:16:13,180 --> 00:16:16,180
>> 그래서 지금의 절정
이 세 가지 예

388
00:16:16,180 --> 00:16:20,730
즉, 겉으로는, 지난 번 졌 있었다
이 스왑 예를 들어,이 기능

389
00:16:20,730 --> 00:16:23,670
의미에서 일
이는 A와 B를 바꾼 것이다.

390
00:16:23,670 --> 00:16:25,620
그러나 그것은 어떤 다른 의미에서 작동하지 않았다?

391
00:16:25,620 --> 00:16:27,616

392
00:16:27,616 --> 00:16:28,614
그래?

393
00:16:28,614 --> 00:16:29,612
>> 청중 : [들리지].

394
00:16:29,612 --> 00:16:35,600

395
00:16:35,600 --> 00:16:36,700
>> 데이비드 J. 마란 : 그렇지.

396
00:16:36,700 --> 00:16:39,530
나는이 함수를 호출한다면
예를 들어 another--에서,

397
00:16:39,530 --> 00:16:42,870
여기서 주요 같은 함수에서
나는 같은 변수 X와 Y가

398
00:16:42,870 --> 00:16:46,160
지난 주 한, 동일한 코드,
나는 X와 Y에 전달

399
00:16:46,160 --> 00:16:49,860
로 교체 한 다음 Swap--이 전화를 걸려면
물론, 올바른 버전입니다

400
00:16:49,860 --> 00:16:52,220
우리가 할 거니까 무엇인가
보라고 그것은 작동하지 않았다.

401
00:16:52,220 --> 00:16:53,770
그래서 수정은 무엇입니까?

402
00:16:53,770 --> 00:16:56,850
>> 음, 그래서 그냥 할 수
분명, 내가 앞서 가자

403
00:16:56,850 --> 00:17:05,450
그리고 ... 두번째 여기 나에게 하나를주고, 참조
나는 당신에게 마지막으로 하나를 표시 할 수있는 경우

404
00:17:05,450 --> 00:17:12,464
내가 찾을 수 있는지 보자 받 것
이 진짜 빨리 ... OK, [INAUDIBLE].

405
00:17:12,464 --> 00:17:18,440

406
00:17:18,440 --> 00:17:19,240
OK, 거기입니다.

407
00:17:19,240 --> 00:17:21,000
그래서 난 그냥 입력 해요 명령을 무시합니다.

408
00:17:21,000 --> 00:17:23,780
나는에서 검색 할
마지막 순간 예

409
00:17:23,780 --> 00:17:27,960
마지막으로,로부터의
이제 더 스왑라고하지 않습니다.

410
00:17:27,960 --> 00:17:30,200
>> 그래서 더 스왑 곳 없다
우리는 지난 시간에 중단

411
00:17:30,200 --> 00:17:32,930
이에, 내가 초기화
1 x와 2 y를 입력합니다.

412
00:17:32,930 --> 00:17:35,840
I는 1, 2를 전달, 교환을 호출합니다.

413
00:17:35,840 --> 00:17:37,930
그리고이 기능
어떤 의미에서 일

414
00:17:37,930 --> 00:17:40,750
그러나 영구 없었다
(X, Y)에 영향을.

415
00:17:40,750 --> 00:17:45,430
그래서 손을 문제는 어떻게 지금이다
우리는 실제로이 문제를 해결하는 방법은 무엇입니까?

416
00:17:45,430 --> 00:17:47,820
손의 해결책은 무엇인가?

417
00:17:47,820 --> 00:17:53,150
>> 음, 오늘은 새로운 swap.c에서,
두 가지 점을 알 수 있습니다.

418
00:17:53,150 --> 00:17:54,700
X와 Y는 동일합니다.

419
00:17:54,700 --> 00:17:57,250
하지만이 명확하게
25 행에 대해 다른?

420
00:17:57,250 --> 00:17:58,880

421
00:17:58,880 --> 00:18:01,715
당신이 기억하면 어떻게 거기에 새로운
그것은 초 전에 어떻게 생겼는지?

422
00:18:01,715 --> 00:18:02,565
>> 청중 : [들리지].

423
00:18:02,565 --> 00:18:03,440
>> 데이비드 J. 마란 : 그래.

424
00:18:03,440 --> 00:18:06,680
그래서 앰퍼샌드는 새로운 조각 아르
구문뿐만 아니라이 프로그램에,

425
00:18:06,680 --> 00:18:08,560
뿐만 아니라,보다 일반적으로 CS50있다.

426
00:18:08,560 --> 00:18:10,680
지금까지, 나는 생각하지 않습니다
우리는 예제를 본 적이

427
00:18:10,680 --> 00:18:14,070
또는 정말 어떤에서 그들에 대해 이야기
어쩌면, 선제 적으로, 이외의 세부 사항,

428
00:18:14,070 --> 00:18:16,467
섹션에서이 같은 앰퍼샌드.

429
00:18:16,467 --> 00:18:19,300
음, 앰퍼샌드 하나입니다 밝혀
새로운 신택스의 마지막 조각

430
00:18:19,300 --> 00:18:20,174
우리는 배울 것입니다.

431
00:18:20,174 --> 00:18:23,500
간단히 말해이
일부 변수의 주소입니다.

432
00:18:23,500 --> 00:18:25,070
어떤 주소에서 X는 살고 있습니까?

433
00:18:25,070 --> 00:18:26,510
그러나 Y는 어떤 주소를 살고 있습니까?

434
00:18:26,510 --> 00:18:28,700
때문에 경우
전에 근본적인 문제

435
00:18:28,700 --> 00:18:32,970
그 x와 y를 전달되고 있었다되었다
우리가 정말 무엇을 원하는 사본 등

436
00:18:32,970 --> 00:18:38,780
보물 등으로 스왑을 제공한다
여기서 x는 실제로 y로 리드지도

437
00:18:38,780 --> 00:18:41,910
그래서, RAM에
스왑은지도를 따를 수 있습니다

438
00:18:41,910 --> 00:18:47,760
X 또는 Y가 자리를 표시 어디서나로 이동
그리고 실제 값을 변경 한 2

439
00:18:47,760 --> 00:18:48,270
가.

440
00:18:48,270 --> 00:18:50,710
>> 그래서 스왑도 약간 변경해야합니다.

441
00:18:50,710 --> 00:18:53,760
그리고 첫눈에,이 힘
문자 스타에 조금 비슷한 것 같다.

442
00:18:53,760 --> 00:18:54,850
그리고 실제로 그것은이다.

443
00:18:54,850 --> 00:18:59,635
그래서이 어떤 유형의 데이터에 대한 포인터이며,
이 강조 부분에 따라?

444
00:18:59,635 --> 00:19:00,810

445
00:19:00,810 --> 00:19:01,620
그래서 정수입니다.

446
00:19:01,620 --> 00:19:04,880
>> 그래서 더 이상 INT 없습니다,
그것은 정수의 주소입니다.

447
00:19:04,880 --> 00:19:07,910
그리고 유사하게, 나 지금 것입니다
int 형의 주소가 될 수 있습니다.

448
00:19:07,910 --> 00:19:12,470
그래서 지금은 홈페이지에서 스왑을 호출 할 때,
나는 스왑 1 및 2 줄 않을거야.

449
00:19:12,470 --> 00:19:15,540
나는처럼 주겠어
황소 뭔가 황소 뭔가

450
00:19:15,540 --> 00:19:19,820
이끌이 주소
실제 위치로 스왑

451
00:19:19,820 --> 00:19:21,310
내 컴퓨터의 메모리에.

452
00:19:21,310 --> 00:19:25,580
>> 그래서 지금, 내 나머지 구현
조금을 변경해야합니다.

453
00:19:25,580 --> 00:19:28,650
이제 어떻게 분명히 다르다
코드의 세 가지 라인?

454
00:19:28,650 --> 00:19:31,350
모든 빌어 먹을 별이있다
여기 저기, 알았지?

455
00:19:31,350 --> 00:19:33,014
그래서 무슨 일이 일어나고?

456
00:19:33,014 --> 00:19:33,514
그래?

457
00:19:33,514 --> 00:19:35,055
>> 청중 : 그것은 [INAUDIBLE] 분명합니다.

458
00:19:35,055 --> 00:19:36,832

459
00:19:36,832 --> 00:19:37,990
>> 데이비드 J. 마란 : 그렇지.

460
00:19:37,990 --> 00:19:41,560
이 context--에 따라서이 아니었다
최고의 디자인 결정, 인정 하듯이,

461
00:19:41,560 --> 00:19:42,530
전 년.

462
00:19:42,530 --> 00:19:45,110
이러한 맥락에서,
당신은 별이,

463
00:19:45,110 --> 00:19:48,240
당신은 데이터 유형이없는,
INT와 같은, 바로 왼쪽에,

464
00:19:48,240 --> 00:19:53,146
대신 당신이 명확하게 등호가,
이러한 맥락에서, 당신이 말을 할 때 스타,

465
00:19:53,146 --> 00:19:56,980
그로 이동을 의미
에서의 주소.

466
00:19:56,980 --> 00:19:58,870
말하자면 보물지도를 따르십시오.

467
00:19:58,870 --> 00:20:01,720
>> 그리고 그 사이에, 37 행에서,
이 같은 일을 의미한다.

468
00:20:01,720 --> 00:20:05,460
주소로 이동하고, 무엇을 거기에 넣어?

469
00:20:05,460 --> 00:20:09,520
무슨 일이에있다
B가 지정하는 위치입니다.

470
00:20:09,520 --> 00:20:10,980
즉, b에 이동합니다.

471
00:20:10,980 --> 00:20:12,130
그 값을 가져옵니다.

472
00:20:12,130 --> 00:20:15,620
동일 당에 가서
서명, 대입 연산자,

473
00:20:15,620 --> 00:20:17,010
거기에 그 값을 넣어.

474
00:20:17,010 --> 00:20:19,272
>> 마찬가지로, INT 온도는 정수이다.

475
00:20:19,272 --> 00:20:20,730
아무것도 온도에 대해 변경할 필요가 없습니다.

476
00:20:20,730 --> 00:20:24,810
그것은 아넨 버그에서 단지 예비 유리하다
우유 나 오렌지 주스.

477
00:20:24,810 --> 00:20:27,630
하지만, 말을 B에 갈 필요가 없습니다.

478
00:20:27,630 --> 00:20:31,449
해당 대상으로 이동
이 온도의 값을 넣어.

479
00:20:31,449 --> 00:20:32,490
그럼 무슨 일이 일어나고 있는지?

480
00:20:32,490 --> 00:20:36,540
사실 경우이 시간을 바꿔 호출 할 때
이 첫 번째 트레이, 여기에 주를 나타냅니다

481
00:20:36,540 --> 00:20:42,270
이 두 번째 트레이가 스왑을 나타냅니다 때
나는 앰퍼샌드 x와 앰퍼샌드 (Y)을 통과

482
00:20:42,270 --> 00:20:47,150
주요 스왑에서, 그냥, 명확하게
이 스택 프레임 수신은 무엇입니까?

483
00:20:47,150 --> 00:20:48,700

484
00:20:48,700 --> 00:20:49,200
그래?

485
00:20:49,200 --> 00:20:50,180
>> 청중 : [들리지].

486
00:20:50,180 --> 00:20:51,180
데이비드 J. 마란 : 그렇지.

487
00:20:51,180 --> 00:20:53,129
X의 주소와 y의 주소.

488
00:20:53,129 --> 00:20:55,170
그리고 당신이 생각할 수있는
우편 주소 등을들 수있다.

489
00:20:55,170 --> 00:20:58,772
33 옥스포드 스트리트 (Oxford Street) 및 35
옥스포드 스트리트 (Oxford Street), 그리고

490
00:20:58,772 --> 00:21:01,230
이 건물을 이동할
그 위치에 있는지.

491
00:21:01,230 --> 00:21:04,680
>> 그것은 말도 안되는 아이디어의 일종,
하지만 우리가 주소를 의미하는 전부입니다.

492
00:21:04,680 --> 00:21:07,000
세계 어디에 수
당신은 그 두 개의 정수를 찾을?

493
00:21:07,000 --> 00:21:09,470
세계 어디에 할 수 있습니다
이 두 건물을 찾을?

494
00:21:09,470 --> 00:21:15,170
그래서 마침내 경우, 모든이 시간 I 후
오늘의 소스 코드로 가서 컴파일

495
00:21:15,170 --> 00:21:22,110
스왑 및 런 ./swap 최종적 대
처음으로 우리는 실제로 보는가

496
00:21:22,110 --> 00:21:25,330
내 값은 참이
성공적으로 교체되었다.

497
00:21:25,330 --> 00:21:30,860
그리고 지금, 우리는 심지어 걸릴 수 있습니다
이것으로 말하자면, GDB의 노트.

498
00:21:30,860 --> 00:21:32,740
>> 그래서 나 같은 파일로 가자.

499
00:21:32,740 --> 00:21:35,010
내가 가서 ./swap의 GDB를 실행하자.

500
00:21:35,010 --> 00:21:36,590

501
00:21:36,590 --> 00:21:40,547
그리고 지금, 스왑에, 내가 갈거야
앞서와 메인에 브레이크 포인트를 설정합니다.

502
00:21:40,547 --> 00:21:42,630
지금은 갈거야
앞서 프로그램을 실행합니다.

503
00:21:42,630 --> 00:21:45,810
그리고 지금 우리는 코드를 참조
그 줄에서 일시 중지되었습니다.

504
00:21:45,810 --> 00:21:48,330
>> 나는 앞서 인쇄 가면
X는 여기서 무엇을 볼 것인가?

505
00:21:48,330 --> 00:21:49,314

506
00:21:49,314 --> 00:21:49,980
그것은 질문입니다.

507
00:21:49,980 --> 00:21:51,030

508
00:21:51,030 --> 00:21:51,530
다시 말해?

509
00:21:51,530 --> 00:21:52,295
>> 청중 : [들리지].

510
00:21:52,295 --> 00:21:53,910
>> 데이비드 J. 마란 : 그래서
임의의 숫자, 아마.

511
00:21:53,910 --> 00:21:56,010
어쩌면 내가 행운, 그것은이다
공처럼 좋은 간단.

512
00:21:56,010 --> 00:21:57,230
하지만 어쩌면 그것은 어떤 임의의 숫자입니다.

513
00:21:57,230 --> 00:21:58,090
이 경우, 나는 운이 좋았죠.

514
00:21:58,090 --> 00:21:59,030
그냥 0으로 발생합니다.

515
00:21:59,030 --> 00:22:00,780
그러나, 참으로 행운입니다
하지 때까지 때문에 I

516
00:22:00,780 --> 00:22:06,280
다음 입력 한 다음 인쇄 x는 것이있다
코드 라인, 라인 (19)는, 실행 된.

517
00:22:06,280 --> 00:22:10,942
>> 한편, 내가 입력하면 다음 다시, 그리고
지금은 2 참조거야, Y를 인쇄 할 수 있습니다.

518
00:22:10,942 --> 00:22:13,900
내가 옆에 입력하면 지금, 그것은에 무슨
약간 혼란 스러울 지금 때문에,

519
00:22:13,900 --> 00:22:17,250
printf의은에 나타날 것입니다
화면은 않았다있다. 여기서 x는 1입니다.

520
00:22:17,250 --> 00:22:18,606
>> 다시 한 번이 작업을 수행 할 수 있습니다.

521
00:22:18,606 --> 00:22:20,480
그리고 지금, 여기 어디 있어요
일이 흥미있어.

522
00:22:20,480 --> 00:22:21,580

523
00:22:21,580 --> 00:22:26,580
나는 스왑 또는 단계를 호출하기 전에
그것으로, 이제 조금 들여다 보자.

524
00:22:26,580 --> 00:22:28,980
X는, 또, 1이다.

525
00:22:28,980 --> 00:22:33,240
Y는 물론, 빠른 온건함이며
너무 어렵지도, 2를 확인합니다.

526
00:22:33,240 --> 00:22:35,740
그러나 앰퍼샌드 x는 무엇인가?

527
00:22:35,740 --> 00:22:36,760

528
00:22:36,760 --> 00:22:39,350
답변, 그것은 가지 펑키 찾고 있습니다.

529
00:22:39,350 --> 00:22:43,500
그러나 괄호 안의 INT 스타 단지입니다
이 말의 GDP의 방법은 주소입니다.

530
00:22:43,500 --> 00:22:48,290
그것은, 그것의 포인터를 int이다 아니에요
INT는, 또는 다른 주소로도 알려져 있습니다.

531
00:22:48,290 --> 00:22:49,742
>> 이 미친 것은 무엇입니까?

532
00:22:49,742 --> 00:22:51,825
우리는 무언가를 본 적이
이전에는 이런있다.

533
00:22:51,825 --> 00:22:53,650

534
00:22:53,650 --> 00:22:58,120
그래서 이것은 내 컴퓨터의 주소입니다
x는 사는 일이 곳의 메모리.

535
00:22:58,120 --> 00:22:59,040
그것은 황소 뭔가.

536
00:22:59,040 --> 00:23:01,290
그리고 솔직히, 왜,이다
나는 화살표를 그리기 시작했습니다,

537
00:23:01,290 --> 00:23:03,340
숫자 대신,
누가 정말 걱정 때문에

538
00:23:03,340 --> 00:23:06,890
당신 INT는 특정에 있음
큰 것을의 주소.

539
00:23:06,890 --> 00:23:12,160
bffff0c4 그러나, 이들은 모두
실제로 16 진수,

540
00:23:12,160 --> 00:23:13,720
f를 통해 공을있는.

541
00:23:13,720 --> 00:23:16,590
>> 그래서 우리는 너무 연연하지 않을거야
그 일이 무엇인지에 긴.

542
00:23:16,590 --> 00:23:19,400
하지만 Y를 인쇄하는 경우,
물론, 나는 2를 참조하십시오.

543
00:23:19,400 --> 00:23:22,440
그러나 앰퍼샌드 y를,이 주소를 참조하십시오.

544
00:23:22,440 --> 00:23:26,527
그리고 예고, 호기심에 대한,
떨어져 X 및 Y는 얼마나 멀리 있는가?

545
00:23:26,527 --> 00:23:27,985
당신은 주소의 대부분을 무시할 수 있습니다.

546
00:23:27,985 --> 00:23:29,330

547
00:23:29,330 --> 00:23:29,920
4 바이트.

548
00:23:29,920 --> 00:23:33,510
그리고 그와 일치있어 우리
이전 INT 얼마나 큰이라고 주장?

549
00:23:33,510 --> 00:23:34,130
4 바이트.

550
00:23:34,130 --> 00:23:37,420
그래서 모든 게 안감까지처럼 보이는
잘, 당신은 메모리에 희망 수있다.

551
00:23:37,420 --> 00:23:40,010
>> 그래서 지금 그냥 빨리 감기하자
본편의 끝까지.

552
00:23:40,010 --> 00:23:43,290
, 이제 가서 단계를 입력하자
스왑 기능으로 다이빙합니다.

553
00:23:43,290 --> 00:23:46,880
지금은 입력하면, 그것의, 알
(X)의 주소와 동일.

554
00:23:46,880 --> 00:23:52,130
나는 B를 입력하면 동일하다
Y의 어드레스.

555
00:23:52,130 --> 00:23:57,020
그래서 내가하면 무엇을 볼 수
, 주소로 이동 말할?

556
00:23:57,020 --> 00:23:58,120
그래서 스타 인쇄 할 수 있습니다.

557
00:23:58,120 --> 00:24:00,130
그래서 별은 이러한 맥락에서, 거기에 갈 것을 의미한다.

558
00:24:00,130 --> 00:24:02,730
앰퍼샌드의 주소 무엇을 의미합니다.

559
00:24:02,730 --> 00:24:05,000
그래서 수단 일 스타.

560
00:24:05,000 --> 00:24:09,590
그리고 인쇄 스타 나 나에게이 있습니다.

561
00:24:09,590 --> 00:24:15,750
>> 그리고 내가 잠시 동안 가정하자,
적어도 코드가 그

562
00:24:15,750 --> 00:24:18,950
할 수 있습니다 지금 실행 진행
그런 식으로 통해 추론.

563
00:24:18,950 --> 00:24:21,150
그러나 우리는 오래 전에이 아이디어를 다시 방문합니다.

564
00:24:21,150 --> 00:24:23,850
스왑의 그래서이 버전
이제 정확하고 있습니다

565
00:24:23,850 --> 00:24:26,650
우리는 특정 데이터 타입을 교환한다.

566
00:24:26,650 --> 00:24:29,120
>> 그래서 질문이 다음 스왑에?

567
00:24:29,120 --> 00:24:29,890
스타?

568
00:24:29,890 --> 00:24:30,690
주소에?

569
00:24:30,690 --> 00:24:33,270
그리고 당신과 함께 볼 수 있습니다
문제는, 일종의, 4 세트

570
00:24:33,270 --> 00:24:37,310
하지만 문제는 오, 확실히, 어떻게 이러한 설정
가지 유용한 얻을 훨씬 더

571
00:24:37,310 --> 00:24:39,584
결과적으로, 그들을 편안.

572
00:24:39,584 --> 00:24:40,430
전혀 없나요?

573
00:24:40,430 --> 00:24:40,930
좋아.

574
00:24:40,930 --> 00:24:44,350
그래서 malloc에​​이 기능을 다시한다
그건 그냥 메모리, 메모리를 할당

575
00:24:44,350 --> 00:24:45,330
할당.

576
00:24:45,330 --> 00:24:47,024
왜이 유용합니다?

577
00:24:47,024 --> 00:24:48,940
음,이 모든 시간,
당신의 malloc을 사용하고있다.

578
00:24:48,940 --> 00:24:52,230
당신이 지금하는 방법을 고려하는 경우
작품을 getString는, 아마도, 그건

579
00:24:52,230 --> 00:24:56,140
덩어리 누군가를 요구하고
메모리, 언제든지 사용자가 입력 문자열

580
00:24:56,140 --> 00:24:59,040
에, 확실히 우리 때문에
몰랐 CS50 직원으로,

581
00:24:59,040 --> 00:25:02,710
얼마나 큰 그 문자열 즉 인간
수 있습니다 입력 할 것입니다.

582
00:25:02,710 --> 00:25:07,910
>> 그럼, 처음에 시작하자
껍질 다시 어떻게 CS50 라이브러리 작품,

583
00:25:07,910 --> 00:25:10,990
예를 몇 가지의 방법으로
그가 우리를 이끌 것입니다.

584
00:25:10,990 --> 00:25:15,300
나는 gedit를 열어 그래서 경우
그리고, scanf와 공을 열어

585
00:25:15,300 --> 00:25:17,055
우리는 다음과 같은 코드를 볼 것입니다.

586
00:25:17,055 --> 00:25:18,720

587
00:25:18,720 --> 00:25:23,530
의 웹 사이트에서 확인할 수 scanf와 공,
오늘, 코드의 상대적으로 적은 선이

588
00:25:23,530 --> 00:25:25,351
여기, 20을 통해 14.

589
00:25:25,351 --> 00:25:26,600
그리고 이제 그것이 무엇을하고 있는지 보자.

590
00:25:26,600 --> 00:25:28,920
그것은 중간,라는 X를 선언합니다.

591
00:25:28,920 --> 00:25:30,850
그것은 뭔가 같은 번호하시기 바랍니다 말했다.

592
00:25:30,850 --> 00:25:33,940
그리고 지금은 scanf와의 %의 난, 및 X 말했다.

593
00:25:33,940 --> 00:25:35,620
그래서 거기에서 새로운 물건의 무리가있다.

594
00:25:35,620 --> 00:25:38,420
>> 그러나 scanf와, 당신은 가지 생각할 수
printf와의 반대로서.

595
00:25:38,420 --> 00:25:40,090
printf의 물론 스크린 인쇄.

596
00:25:40,090 --> 00:25:44,410
사용자의에서 검사의 scanf와 종류
키보드 무언가는 그 또는 그녀가 입력되었습니다.

597
00:25:44,410 --> 00:25:46,550
>> %의 난 그냥 printf와 같다.

598
00:25:46,550 --> 00:25:49,410
이것은 기대 수단
사용자는 int를 입력합니다.

599
00:25:49,410 --> 00:25:52,820
그리고 지금, 왜 내가 생각
scanf와 및 X를 통과 할 수 있는가?

600
00:25:52,820 --> 00:25:54,030

601
00:25:54,030 --> 00:25:57,770
만약 scanf와의 삶의 목적
사용자로부터 무언가를 얻을 수 있습니다,

602
00:25:57,770 --> 00:26:02,480
의 의미는 무엇인가
지금 그것을 전달 및 X?

603
00:26:02,480 --> 00:26:02,980
그래?

604
00:26:02,980 --> 00:26:03,896
>> 청중 : [들리지].

605
00:26:03,896 --> 00:26:05,540

606
00:26:05,540 --> 00:26:06,540
데이비드 J. 마란 : 그렇지.

607
00:26:06,540 --> 00:26:12,900
어쨌든 나는 인간, 내 입력을 입력
해당 위치에 저장 될 것입니다.

608
00:26:12,900 --> 00:26:17,660
그것은 단지를하려면 불러 오기 충분하지입니다
우리가 이미 본 적이 있기 때문에, 배를 전달,

609
00:26:17,660 --> 00:26:21,630
언제 당신은 단지 원시 변수를 전달
INT와 같은, 다른 기능,

610
00:26:21,630 --> 00:26:25,640
확인, 그 변경할 수 있습니다
가변 아니라 영구적.

611
00:26:25,640 --> 00:26:27,360
그것은 메인에 영향을 미칠 수 없습니다.

612
00:26:27,360 --> 00:26:29,420
그것은 단지 자신의 로컬 복사본을 변경할 수 있습니다.

613
00:26:29,420 --> 00:26:32,560
하지만, 대신에, 당신은하지 않습니다
나에게 실제 INT를 제공,

614
00:26:32,560 --> 00:26:36,640
하지만 당신은 나에게 방향을 제공
그 정수는, 지금, scanf와 인

615
00:26:36,640 --> 00:26:41,050
확실히, 나는 그것을 따를 수 있습니다
해결하고 거기에 숫자를 넣어

616
00:26:41,050 --> 00:26:43,280
그래서 당신은뿐만 아니라 그것을에 액세스 할 수 있습니다.

617
00:26:43,280 --> 00:26:45,120
>> 나는이 프로그램을 실행할 때, 어디 보자.

618
00:26:45,120 --> 00:26:49,660
scanf와 0 점 슬래시를 확인, 0을 scanf.

619
00:26:49,660 --> 00:26:54,030
그리고 지금은 숫자를 입력하는 경우
50 등, 50 주셔서 감사합니다.

620
00:26:54,030 --> 00:26:58,150
지금 같은 번호를 입력하면
음수 대 1, 1 음.

621
00:26:58,150 --> 00:27:04,200
지금 흠, 1.5과 같은 번호를 입력합니다.

622
00:27:04,200 --> 00:27:06,030
왜 내 프로그램은 날 무시 했어?

623
00:27:06,030 --> 00:27:07,300

624
00:27:07,300 --> 00:27:09,880
음, 때문에 단순히, 나는 말했다
그것은 int를 만 기대합니다.

625
00:27:09,880 --> 00:27:10,380
좋아.

626
00:27:10,380 --> 00:27:11,630
그래서이 한 버전이다.

627
00:27:11,630 --> 00:27:16,600
의 한 단계를 일을 보자하고
이 좋지 않은 것을 제안한다.

628
00:27:16,600 --> 00:27:20,530
그리고 여기에 아주 간단한 예를 속인다
우리는 코드 작성을 시작할 수있는 방법

629
00:27:20,530 --> 00:27:24,450
다른 사람들이 악용 할 수있는 나
나쁜 일을 수행하여 손상.

630
00:27:24,450 --> 00:27:28,336
그래서 라인 (16), 그래서 유사한
정신 이전에,

631
00:27:28,336 --> 00:27:29,960
그러나 나는이 시간을 int로 선언 아니에요.

632
00:27:29,960 --> 00:27:32,970
나는 문자열 일명, 그것은 문자 스타를 선언하고 있습니다.

633
00:27:32,970 --> 00:27:35,190
>> 하지만 정말 무엇을 의미 하는가?

634
00:27:35,190 --> 00:27:38,790
그래서 주소인데를 지정하지 않는 경우
내가 임의로 전화 해요, 버퍼

635
00:27:38,790 --> 00:27:43,370
하지만 simple--로,이 부르심 수
다음 나는 이렇게 나에게 설명,

636
00:27:43,370 --> 00:27:48,630
이전에 따라, 할 수 있다면
논리, scanf와 라인 (18)에 무엇을하고 있는지,

637
00:27:48,630 --> 00:27:55,000
패스 % s 및 버퍼 경우,
주소는 무엇입니까?

638
00:27:55,000 --> 00:27:58,210
당신을 적용하는 경우는 scanf는 무엇입니까
버전 0으로 동일한 로직,

639
00:27:58,210 --> 00:28:00,640
여기에서하려고가는 경우
에서 사용자 유형 뭔가?

640
00:28:00,640 --> 00:28:02,630

641
00:28:02,630 --> 00:28:03,409
그래?

642
00:28:03,409 --> 00:28:04,407
>> 청중 : [들리지].

643
00:28:04,407 --> 00:28:07,401

644
00:28:07,401 --> 00:28:08,890
>> 데이비드 J. 마란 : 그렇지.

645
00:28:08,890 --> 00:28:11,577
scanf와, 이전의 논리에 의해,
문자열을 걸릴 것입니다

646
00:28:11,577 --> 00:28:13,410
인간의 입력했는지
, 지금 문자열이다 받

647
00:28:13,410 --> 00:28:15,790
그것은 아마도, 수 아니다
그 또는 그녀가 cooperates-- 경우

648
00:28:15,790 --> 00:28:19,310
그리고 그 전환하려고 것
어떤 주소의 메모리에 문자열

649
00:28:19,310 --> 00:28:20,340
버퍼를 지정합니다.

650
00:28:20,340 --> 00:28:23,870
그리고 이것은 대단한 버퍼 때문에
실제로 IP 주소를 입력하기위한 것입니다.

651
00:28:23,870 --> 00:28:30,470
>> 그러나 나는이 프로그램에 버그가 주장
매우 심각한 방법, 가치가 무엇 때문에

652
00:28:30,470 --> 00:28:31,330
기본적으로 버퍼?

653
00:28:31,330 --> 00:28:33,380

654
00:28:33,380 --> 00:28:34,790
나는 무엇을로 초기화 한?

655
00:28:34,790 --> 00:28:35,770
메모리의 어떤 덩어리?

656
00:28:35,770 --> 00:28:37,480

657
00:28:37,480 --> 00:28:38,620
내가하지 않은, 오른쪽?

658
00:28:38,620 --> 00:28:42,265
>> 그래서 할당 한 경우에도
더 이상의라고 문자 스타,

659
00:28:42,265 --> 00:28:48,030
그 대신이라고, 그래서 buffer--
의 변수의 이름을 그려 보자

660
00:28:48,030 --> 00:28:53,380
내가하지 않은 경우 지금과 같이 buffer--
여기에서 getString 또는 malloc을 호출,

661
00:28:53,380 --> 00:28:56,030
그 효과적으로 것을 의미한다
버퍼는 그냥 쓰레기 값입니다.

662
00:28:56,030 --> 00:28:57,030
>> 지금 그게 무슨 뜻 이죠?

663
00:28:57,030 --> 00:29:00,220
내가 scanf를 말했다 것을 의미
사용자로부터 문자열을 기대합니다.

664
00:29:00,220 --> 00:29:01,300
그리고 당신이 뭘 알아?

665
00:29:01,300 --> 00:29:03,883
어쨌든이 일이 가리키는
바꿔 .. 내가 물음표를 그려

666
00:29:03,883 --> 00:29:07,060
그러나 실제로, 그것은 될 것
OX1, 2, 3, 같은 맞죠?

667
00:29:07,060 --> 00:29:10,730
그것은 어떤 가짜 값 난 그냥
앞에서가 발생합니다.

668
00:29:10,730 --> 00:29:13,440
그래서 다른 방법을 넣어, 그것은이다
버퍼가 단지 인 것처럼

669
00:29:13,440 --> 00:29:16,180
메모리에 뭔가를 가리키는.

670
00:29:16,180 --> 00:29:17,610
나는 생각이 없다.

671
00:29:17,610 --> 00:29:24,130
>> 지금 게이브에 입력하면 그래서, 무슨
이 g-A-B-E / 공을 넣어하려고합니다.

672
00:29:24,130 --> 00:29:25,530
하지만 누가 그게 뭔지 아는 사람?

673
00:29:25,530 --> 00:29:27,480
과거에, 어떤
우리가 터치 시도한 시간

674
00:29:27,480 --> 00:29:29,770
속하지 않는 메모리
우리에게 무슨 일이 일어 났는가?

675
00:29:29,770 --> 00:29:31,020

676
00:29:31,020 --> 00:29:32,870
또는 거의 모든 시간입니다.

677
00:29:32,870 --> 00:29:34,310
분할의 오류, 오른쪽?

678
00:29:34,310 --> 00:29:37,829
>> 그것은 어디이 화살표, 나는 아무 생각이
가리키는. 그냥 어떤 임의의 값입니다.

679
00:29:37,829 --> 00:29:40,370
그리고 물론, 당신은 해석하는 경우
어드레스로서 임의의 값,

680
00:29:40,370 --> 00:29:42,610
당신은에 가서
어떤 임의의 대상.

681
00:29:42,610 --> 00:29:46,810
그래서 게이브 충돌 참으로 수도
여기이 경우 내 프로그램.

682
00:29:46,810 --> 00:29:50,600
>> 그래서 우리는 거의 나쁜 무엇을 할 수 있는가?

683
00:29:50,600 --> 00:29:52,660
이 셋째을 고려하여
scanf와의 최종 예.

684
00:29:52,660 --> 00:29:53,890

685
00:29:53,890 --> 00:29:56,870
이 버전은 어떤 의미에서 더 나은 무엇입니까?

686
00:29:56,870 --> 00:29:57,990

687
00:29:57,990 --> 00:30:01,400
당신은 편안하게하는 경우
이전 문제는이 낫다.

688
00:30:01,400 --> 00:30:02,250
왜?

689
00:30:02,250 --> 00:30:03,250
>> 청중 : [들리지].

690
00:30:03,250 --> 00:30:06,235

691
00:30:06,235 --> 00:30:07,110
데이비드 J. 마란 : 좋은.

692
00:30:07,110 --> 00:30:09,970
라인 (16)의 그래서이 경우
점에서 더 낫다

693
00:30:09,970 --> 00:30:12,030
우리는 명시 적으로 걸
일부 메모리를 할당.

694
00:30:12,030 --> 00:30:14,190
우리는 malloc을 사용하지 않을
우리는 주이 사용하는

695
00:30:14,190 --> 00:30:16,060
단지 배열을 선언하는 방법.

696
00:30:16,060 --> 00:30:18,130
그리고 우리는 그 문자열 전에 말한
단지 문자의 배열입니다,

697
00:30:18,130 --> 00:30:19,690
그래서 이것은 완전히 합법적이다.

698
00:30:19,690 --> 00:30:22,910
하지만 그만큼 물론이다
당신은 16, 고정 된 크기를 확인합니다.

699
00:30:22,910 --> 00:30:25,440
>> 따라서이 프로그램은
완전히 안전, 내가 입력 한 경우

700
00:30:25,440 --> 00:30:29,760
한 문자열에서 두 개의 문자
문자열, 15 문자열.

701
00:30:29,760 --> 00:30:34,970
하지만 최대한 빨리 16 입력을 시작,
17, 18, 1000 문자열,

702
00:30:34,970 --> 00:30:37,390
여기서 해당 문자열이 끝날까요?

703
00:30:37,390 --> 00:30:39,570
그것은 부분적으로 여기에서 끝낼거야.

704
00:30:39,570 --> 00:30:42,820
그러나 누가 어떤 다른 알고
경계를 넘어

705
00:30:42,820 --> 00:30:44,270
이 특정한 배열의?

706
00:30:44,270 --> 00:30:48,015
>> 나는했습니다 것처럼 그것은이다
여기에 16 상자를 선언했다.

707
00:30:48,015 --> 00:30:49,300

708
00:30:49,300 --> 00:30:52,690
그래서 모든 16을 그리는 것이 아니라, 우리는거야
그냥 16를 그려 놨 척.

709
00:30:52,690 --> 00:30:56,540
하지만 다음 문자열을 읽으려고하면
즉, 50 자처럼, 더 이상이다,

710
00:30:56,540 --> 00:31:01,270
나는 퍼팅을 시작하려고 해요
A, B, C, D, X, Y, Z.

711
00:31:01,270 --> 00:31:04,916
그리고 이것은 아마도입니다
다른 메모리 세그먼트

712
00:31:04,916 --> 00:31:06,790
즉, 다시 발생할 수 있습니다
내 프로그램이 충돌합니다

713
00:31:06,790 --> 00:31:10,600
나는 요구하지했기 때문에
단지 16 바이트보다 더 아무것도.

714
00:31:10,600 --> 00:31:12,260
>> 그래서 무슨 상관이야?

715
00:31:12,260 --> 00:31:13,880
음, 여기 CS50 라이브러리입니다.

716
00:31:13,880 --> 00:31:17,220
그리고 대부분의 단지입니다
맨 위로 지침 등을들 수있다.

717
00:31:17,220 --> 00:31:21,670
CS50 라이브러리, 모든 시간,
라인 (52)이 선을했다.

718
00:31:21,670 --> 00:31:23,680
우리는 형식 정의 본, 또는 한
당신은 typedef를 볼 수 있습니다

719
00:31:23,680 --> 00:31:27,930
단지를 생성하여 pset 사에
동의어 문자 별 이상이 될 수있다

720
00:31:27,930 --> 00:31:29,290
단순히 문자열로 함.

721
00:31:29,290 --> 00:31:31,540
그래서이 중 하나입니다
몇 훈련 바퀴

722
00:31:31,540 --> 00:31:34,120
우리는 후드 아래에 비밀리에 사용했습니다.

723
00:31:34,120 --> 00:31:36,490
>> 한편, 여기에서는 GetChar 함수입니다.

724
00:31:36,490 --> 00:31:38,190
이제 분명히, 여기에 시체가 없습니다.

725
00:31:38,190 --> 00:31:40,273
그리고 사실, 나는 계속하는 경우
스크롤, 사실은 그렇지

726
00:31:40,273 --> 00:31:42,080
어떤 구현을 참조
이러한 기능.

727
00:31:42,080 --> 00:31:43,140

728
00:31:43,140 --> 00:31:45,516
전성 검사로서, 그 이유는?

729
00:31:45,516 --> 00:31:46,795
>> 청중 : [들리지].

730
00:31:46,795 --> 00:31:47,670
데이비드 J. 마란 : 그래.

731
00:31:47,670 --> 00:31:48,950
그래서이 헤더 파일입니다.

732
00:31:48,950 --> 00:31:52,520
그리고 헤더 파일 프로토 타입을 포함,
에 몇 가지 다른 것들, 그것은 보인다

733
00:31:52,520 --> 00:31:53,780
형식 정의 등을들 수있다.

734
00:31:53,780 --> 00:31:56,910
그러나 CS50.c, 우리는했습니다있는
무조건 당신을 준 적이,

735
00:31:56,910 --> 00:32:02,100
하지만 CS50 어플라이언스에왔다 모든
이 때, 깊은 그 폴더 안에

736
00:32:02,100 --> 00:32:04,990
전체 발견 할 수있을
여기에 기능을 무리.

737
00:32:04,990 --> 00:32:06,720
>> 사실, 이제 아래로 스크롤 할 수 있습니다.

738
00:32:06,720 --> 00:32:08,810
의 지금은, 대부분 무시하자.

739
00:32:08,810 --> 00:32:12,670
그러나 getInt는 아래로 스크롤
및 getInt와 작동 방법을 참조하십시오.

740
00:32:12,670 --> 00:32:13,890
그래서 여기의 getInt입니다.

741
00:32:13,890 --> 00:32:17,727
혹시 정말 딸이 걱정된다면 어떻게 얻을
INT, 여기에 작동 설명서입니다.

742
00:32:17,727 --> 00:32:19,560
그리고 무엇보다도
그것은 당신을 알려줍니다 말한다

743
00:32:19,560 --> 00:32:21,340
값의 범위가 반환 할 수있는.

744
00:32:21,340 --> 00:32:24,400
그것은 본질적으로 부정적 2000000000
긍정적 인 2,000,000,000로 제공하거나 걸릴.

745
00:32:24,400 --> 00:32:26,420
>> 그리고이 모든 것이 밝혀
시간, 우리는 한 번도에도 불구하고

746
00:32:26,420 --> 00:32:28,570
당신이 그것을 확인했다,
뭔가 잘못되면,

747
00:32:28,570 --> 00:32:30,680
모든 것이 밝혀
이번에는의 getInt에는

748
00:32:30,680 --> 00:32:33,600
특별한 반환 된
, 널 (null), 일정하지

749
00:32:33,600 --> 00:32:36,760
오히려, 이는 INT_MAX
다만 프로그래머의 규칙.

750
00:32:36,760 --> 00:32:38,846
그것은 여기에 의미 특수 값입니다.

751
00:32:38,846 --> 00:32:41,470
그냥이 있는지 확인하십시오
경우에 뭔가 잘못 간다.

752
00:32:41,470 --> 00:32:43,261
그러나 우리는 귀찮게 적이
지금까지 그와 함께,

753
00:32:43,261 --> 00:32:45,200
또,이 때문에
단순화하기위한 것입니다.

754
00:32:45,200 --> 00:32:46,950
>> 하지만 어떻게 getInt는 구현됩니까?

755
00:32:46,950 --> 00:32:48,450
음, 한, 그것은 인수를 사용하지 않습니다.

756
00:32:48,450 --> 00:32:49,390
우리는 알고있다.

757
00:32:49,390 --> 00:32:50,820
그것은 int를 반환합니다.

758
00:32:50,820 --> 00:32:51,950
우리는 알고있다.

759
00:32:51,950 --> 00:32:54,460
그래서 어떻게 후드 아래에 작동합니까?

760
00:32:54,460 --> 00:32:58,290
>> 그래서 분명히 무한있다
루프, 적어도 하나의 등장.

761
00:32:58,290 --> 00:33:00,290
우리가있는 getString을 사용하는 것을 알 수 있습니다.

762
00:33:00,290 --> 00:33:04,000
그래서 재미있다. 의 getInt
우리 자신의 기능, getString에 호출합니다.

763
00:33:04,000 --> 00:33:05,645
그리고 지금 왜이 경우 될 수 있을까요?

764
00:33:05,645 --> 00:33:07,400

765
00:33:07,400 --> 00:33:09,842
이유는 방어라고 할 수 있죠
한 줄에 165?

766
00:33:09,842 --> 00:33:11,390

767
00:33:11,390 --> 00:33:15,639
어떤 라인에 일어날 수
164, 그냥 명확하게하는 방법?

768
00:33:15,639 --> 00:33:16,930
그것은 이전과 같은 대답입니다.

769
00:33:16,930 --> 00:33:18,660

770
00:33:18,660 --> 00:33:20,089
단지 메모리가 부족 될 수 있습니다.

771
00:33:20,089 --> 00:33:23,130
뭔가, getString에로 잘못
우리는 그것을 처리 할 수​​있어.

772
00:33:23,130 --> 00:33:27,070
그리고 그 이유는 내가 널 (null)는 반환하지 않습니다
즉, 기술적으로, 널 포인터이다.

773
00:33:27,070 --> 00:33:29,120
의 getInt는 int를 반환합니다.

774
00:33:29,120 --> 00:33:31,060
그래서 임의로했습니다
본질적으로, 결정

775
00:33:31,060 --> 00:33:34,600
2000000000 있다는 것입니다이나 걸릴 부여
특수 값이 될 것을 나는 결코 할 수

776
00:33:34,600 --> 00:33:35,970
실제로 사용자로부터 얻을.

777
00:33:35,970 --> 00:33:39,930
내가 갈거야 단지 하나의 값이다
에러 코드를 나타내는 데 낭비.

778
00:33:39,930 --> 00:33:41,540
>> 그래서 지금 상황이 조금 공상을 얻을.

779
00:33:41,540 --> 00:33:44,670
그리고 그것은 아주 동일한 기능이 아니다
이전과 같이, 그러나 비슷한데.

780
00:33:44,670 --> 00:33:50,120
그래서 라인에, 여기 선언, 주목
172, 정수 n을 입력하고 문자 (c)과 함께.

781
00:33:50,120 --> 00:33:53,600
그리고 나는이 펑키 줄을 사용
알고 보니 sscanf에서,

782
00:33:53,600 --> 00:33:55,990
키보드에서 문자열을 검색하지 않습니다.

783
00:33:55,990 --> 00:33:59,226
그것은 기존의 문자열을 의미하는
사용자가 이미 입력했다.

784
00:33:59,226 --> 00:34:02,100
그래서 이미있는 getString을 호출하는
I 메모리에 문자열을 의미합니다.

785
00:34:02,100 --> 00:34:05,020
sscanf에서는 당신이 좋겠입니다
구문 분석 함수를 호출합니다.

786
00:34:05,020 --> 00:34:07,760
그것은 내가 지금 문자열 본다
, 문자로, 문자의 입력

787
00:34:07,760 --> 00:34:09,250
그리고 무엇인가 유용한 기능을 실행합니다.

788
00:34:09,250 --> 00:34:10,969
즉, 캐릭터 라인에 저장됩니다.

789
00:34:10,969 --> 00:34:13,560
그리고 나는 단지로가는 것을 알고있다
OK, 오, 여기 말하는 백업,

790
00:34:13,560 --> 00:34:15,143
못의이 시간 만 줄이라고 불렀다.

791
00:34:15,143 --> 00:34:15,989

792
00:34:15,989 --> 00:34:18,080
>> 그리고 지금이 약간 다릅니다.

793
00:34:18,080 --> 00:34:22,480
그러나 이것은 효과적으로 이유로 수단
우리는 다소, 오늘에 우리의 손을 흔들 것이다

794
00:34:22,480 --> 00:34:26,070
우리는에 체크되어 있는지
에 사용자가 입력 한 경우 참조

795
00:34:26,070 --> 00:34:29,909
와 int는 아마 다른 문자.

796
00:34:29,909 --> 00:34:33,610
사용자가 정수에 입력 한 경우입니다
난 때문에 갈은 N에 포함 할 수

797
00:34:33,610 --> 00:34:36,739
주소로이를 전달
오늘 우리가 본 적이 새로운 마술.

798
00:34:36,739 --> 00:34:41,570
사용자는 또한 입력 한 경우
같은 123x에서, 그 X

799
00:34:41,570 --> 00:34:45,060
를 끝낼 것입니다
문자 c의 편지입니다.

800
00:34:45,060 --> 00:34:48,739
>> 지금은 그 sscanf에서 밝혀
지능적으로, 저를 말할 것이다,

801
00:34:48,739 --> 00:34:54,750
얼마나 많은 변수 위해 sscanf했다
채울 성공적으로 수.

802
00:34:54,750 --> 00:34:58,770
이 논리에 의해, 경우에 따라서 기능
나는, 나 getInt입니다 구현하고있어

803
00:34:58,770 --> 00:35:00,900
하지만 난 알아보고 있어요,
잠재적으로, 사용자

804
00:35:00,900 --> 00:35:04,190
INT에 입력 한합니다
뭔가 다음에,

805
00:35:04,190 --> 00:35:08,580
내가 sscanf를 년대 싶어
반환 값은 진정 될?

806
00:35:08,580 --> 00:35:10,950
목적은 얻을 경우
단지 사용자의 INT?

807
00:35:10,950 --> 00:35:13,980

808
00:35:13,980 --> 00:35:19,300
>> 그래서 sscanf를 반환하는 경우
이, 그게 무슨 뜻 이죠?

809
00:35:19,300 --> 00:35:21,660
사용자는에 입력
뭔가 같은, 말 그대로,

810
00:35:21,660 --> 00:35:24,770
그냥 말도 123x.

811
00:35:24,770 --> 00:35:27,490
이는 에러 상태이고,
그 확인하고 싶다.

812
00:35:27,490 --> 00:35:32,960
>> 그래서이있는 경우 사용자 유형에 의하여
이 논리 반환 sscanf에서 무엇을하는지,

813
00:35:32,960 --> 00:35:33,740
당신은 말을?

814
00:35:33,740 --> 00:35:35,070

815
00:35:35,070 --> 00:35:39,130
그래서 때문에 2를 반환 할 것
(123)는, 여기에 갈 것입니다

816
00:35:39,130 --> 00:35:41,580
그리고 X는 여기에서 생을 마감 할 것이다.

817
00:35:41,580 --> 00:35:43,970
하지만 X가 가득하고 싶지 않습니다.

818
00:35:43,970 --> 00:35:48,580
난 단지에서 성공하기 위해 sscanf 할
그 변수의 제 작성.

819
00:35:48,580 --> 00:35:52,490
그리고 그 이유 I
sscanf에서 1을 반환하려면.

820
00:35:52,490 --> 00:35:55,750
>> 그리고이 머리 위에 비트 인 경우
순간, 그건 완전히 괜찮아요.

821
00:35:55,750 --> 00:36:00,030
하지만 그 일을 실현
getInt는과에서 getString 값

822
00:36:00,030 --> 00:36:03,630
우리의 지옥을하고있는 것입니다
이과 같이 오류 검사의 많은

823
00:36:03,630 --> 00:36:07,130
즉, 지금까지, 당신은 꽤 많은 수
키보드에서 아무 것도 입력,

824
00:36:07,130 --> 00:36:08,490
우리는 그것을 잡을 것입니다.

825
00:36:08,490 --> 00:36:10,592
그리고 우리는 확실히
직원이 아닌은 확실히

826
00:36:10,592 --> 00:36:13,300
의 버그의 원인이 될 당신의
프로그램, 우리는 수비에있어 때문에

827
00:36:13,300 --> 00:36:16,270
바보의 모든 검사
사용자가 할 수있는 일,

828
00:36:16,270 --> 00:36:18,900
때 문자열을 입력하는 등의
당신은 정말 INT를 원했다.

829
00:36:18,900 --> 00:36:21,350
그래서 우리는 올 거 아니예요에 대한
다시이에 long-- 전

830
00:36:21,350 --> 00:36:23,710
하지만이 모든 시간,
있는 getString과의 getInt는이

831
00:36:23,710 --> 00:36:29,950
이것을 이용하여 후드 밑이었다
메모리 주소의 기본 개념.

832
00:36:29,950 --> 00:36:32,580
>> 그래서 지금의 일을 만들어 보자
사용자 친화적 조금 더.

833
00:36:32,580 --> 00:36:38,740
당신은 빙키 마지막에서 호출 할 수 있습니다으로
외엔 내 마우스가 너무 cooperate-- 경우

834
00:36:38,740 --> 00:36:42,560
우리는이 코드를 가지고있는
솔직히 상당히 무의미하다.

835
00:36:42,560 --> 00:36:45,330
이 코드는 아무것도 달성하지
유용하지만, 예였다

836
00:36:45,330 --> 00:36:48,330
그 교수 Parlante
표현하기 위해 사용

837
00:36:48,330 --> 00:36:51,840
무슨에 무슨 일이 있었
메모리를 포함하는 프로그램입니다.

838
00:36:51,840 --> 00:36:54,850
>> 그래서이 작업을 되풀이하자
이야기 슈퍼 잠시.

839
00:36:54,850 --> 00:36:58,720
이러한 처음 두 줄에
영어, 당신은 무엇을, 말을합니까?

840
00:36:58,720 --> 00:37:01,230

841
00:37:01,230 --> 00:37:05,430
그냥 합리적 인간, 그러나
약간의 기술 용어는 자상을.

842
00:37:05,430 --> 00:37:06,346
청중 : [들리지].

843
00:37:06,346 --> 00:37:07,705

844
00:37:07,705 --> 00:37:11,080
>> 데이비드 J. 마란 : OK, 당신은 설정하고
당신의 X와 Y 변수의 주소.

845
00:37:11,080 --> 00:37:15,520
확실히, x와 y는되지 않기 때문에
전통적인 의미의 변수.

846
00:37:15,520 --> 00:37:18,054
X 및 Y는 어드레스 아르
또는 주소를 저장합니다.

847
00:37:18,054 --> 00:37:19,220
그래서이 한 번 더 시도 할 수 있습니다.

848
00:37:19,220 --> 00:37:21,010
나쁜 시작하지만.

849
00:37:21,010 --> 00:37:21,510
그래?

850
00:37:21,510 --> 00:37:22,426
>> 청중 : [들리지].

851
00:37:22,426 --> 00:37:23,966

852
00:37:23,966 --> 00:37:24,840
데이비드 J. 마란 : 좋은.

853
00:37:24,840 --> 00:37:26,173
그 조금 청소기 생각합니다.

854
00:37:26,173 --> 00:37:28,630
이 포인터, 두 개의 정수를 선언.

855
00:37:28,630 --> 00:37:30,150
그리고 우리는 그들에게 X와 Y를 호출하고 있습니다.

856
00:37:30,150 --> 00:37:32,790
아니면 우리가 인 경우에 그립니다
이 그림으로, 다시

857
00:37:32,790 --> 00:37:36,410
아주 간단하게 모든 기억
우리는 그 첫 번째 줄에하고있는

858
00:37:36,410 --> 00:37:39,690
이 같은 상자를 끌고있다,
그것에 일부 쓰레기 값,

859
00:37:39,690 --> 00:37:41,920
한 다음 x를 호출하고,
이 같은 또 다른 상자

860
00:37:41,920 --> 00:37:43,880
일부 쓰레기 값
거기에, Y를 호출.

861
00:37:43,880 --> 00:37:45,810
우리는이 선언 한
포인터가 궁극적으로

862
00:37:45,810 --> 00:37:47,860
int 형의 주소를 저장합니다.

863
00:37:47,860 --> 00:37:49,170
그래서 모든있다.

864
00:37:49,170 --> 00:37:53,290
>> 빙키 이런 짓을 그래서 때,
점토는이처럼 보였다.

865
00:37:53,290 --> 00:37:55,350
그리고 닉 그냥 가지
화살표를 싸서

866
00:37:55,350 --> 00:37:57,590
비록 그들은 어디를 가리키는하지 않을
특히 때문에 그저

867
00:37:57,590 --> 00:37:58,250
쓰레기 값.

868
00:37:58,250 --> 00:38:01,670
그들은 명시 적으로 초기화하지 않을
어디 특히.

869
00:38:01,670 --> 00:38:03,980
>> 지금의 다음 행
코드, 리콜이이었다.

870
00:38:03,980 --> 00:38:07,510
합리적으로 사용자 친화적 너무
하지만 다소 기술적 인 영어,

871
00:38:07,510 --> 00:38:09,790
코드가 수행하는이 라인은 무엇입니까?

872
00:38:09,790 --> 00:38:10,391
그래?

873
00:38:10,391 --> 00:38:11,333
>> 청중 : [들리지].

874
00:38:11,333 --> 00:38:12,746

875
00:38:12,746 --> 00:38:13,950
>> 데이비드 J. 마란 : 완벽 한.

876
00:38:13,950 --> 00:38:17,016
이 청크를 할당하는 것
int 형의 크기의 메모리.

877
00:38:17,016 --> 00:38:18,140
그리고 그 절반 대답이야.

878
00:38:18,140 --> 00:38:20,056
당신이 바로 그 대답
식의 절반입니다.

879
00:38:20,056 --> 00:38:22,473
무엇에 무슨 일이 일어나고
등호의 왼쪽?

880
00:38:22,473 --> 00:38:22,972
그래?

881
00:38:22,972 --> 00:38:24,814
청중 : 그리고 양수인
그 변수 x에?

882
00:38:24,814 --> 00:38:27,690
>> 데이비드 J. 마란 : 그리고 양수인
그 변수 x에.

883
00:38:27,690 --> 00:38:31,650
요점을 되풀이하다, 오른쪽의 할당에 따라서
메모리가 부족 int를 저장합니다.

884
00:38:31,650 --> 00:38:34,150
하지만 malloc을 구체적으로
주소를 반환

885
00:38:34,150 --> 00:38:37,270
당신이했습니다 메모리의 청크의
그냥 X에 저장됩니다 제안했다.

886
00:38:37,270 --> 00:38:42,560
>> 그래서 닉 빙키와 함께 지난 시간에했던 것은
그가 그 포인터를 끌고, 점토

887
00:38:42,560 --> 00:38:46,820
메모리의 흰색 덩어리에서 지금 가리
그 int 형의 크기와 같습니다.

888
00:38:46,820 --> 00:38:49,360
그리고 실제로 그 의미가 있어요
4 바이트를 나타냅니다.

889
00:38:49,360 --> 00:38:55,310
>> 코드 이제, 다음 행
이했다, 스타 X 42을 가져옵니다.

890
00:38:55,310 --> 00:38:58,530
그래서 42에 간단합니다
오른쪽, 삶의 의미.

891
00:38:58,530 --> 00:39:00,500
왼쪽 편은, 스타 X는 무엇을 의미?

892
00:39:00,500 --> 00:39:01,600

893
00:39:01,600 --> 00:39:03,280
괜찮아 gone-- 그것도있을 수 있습니다.

894
00:39:03,280 --> 00:39:04,220
확인을 클릭합니다.

895
00:39:04,220 --> 00:39:06,875
>> 대상 : 기본적으로,
[INAUDIBLE]로 이동

896
00:39:06,875 --> 00:39:07,750
데이비드 J. 마란 : 좋은.

897
00:39:07,750 --> 00:39:08,760
청중 : [들리지].

898
00:39:08,760 --> 00:39:09,760
데이비드 J. 마란 : 그렇지.

899
00:39:09,760 --> 00:39:11,979
왼쪽은 X로 이동을 의미한다.

900
00:39:11,979 --> 00:39:12,520
X는 주소입니다.

901
00:39:12,520 --> 00:39:15,520
그것은 33 옥스포드 스트리트 (Oxford Street), 또는 OX1 같아요.

902
00:39:15,520 --> 00:39:18,690
그리고 스타 X는로 이동을 의미
해결하고 무엇을 거기에 넣어?

903
00:39:18,690 --> 00:39:19,520
42.

904
00:39:19,520 --> 00:39:21,290
>> 그래서 사실은, 그 닉이 한 정확히입니다.

905
00:39:21,290 --> 00:39:23,740
그는에 의해 시작
본질적으로, 정신적으로

906
00:39:23,740 --> 00:39:26,270
손가락으로 가리키는
X, 화살표 다음

907
00:39:26,270 --> 00:39:30,670
오른쪽에있는 흰색 상자에
측면, 그리고이 숫자 42을 넣어.

908
00:39:30,670 --> 00:39:34,120
하지만 일이있어
약간의 위험, 맞죠?

909
00:39:34,120 --> 00:39:35,860
빙키의 머리를 잃게.

910
00:39:35,860 --> 00:39:39,465
>> 스타 Y는 무엇을 의미, 13, 불운 같다?

911
00:39:39,465 --> 00:39:43,620
그래서 스타 Y 수단을 y 주소로 이동합니다.

912
00:39:43,620 --> 00:39:45,630
그러나 Y의 주소는 무엇인가?

913
00:39:45,630 --> 00:39:47,899

914
00:39:47,899 --> 00:39:49,440
좋아, 그것은 쓰레기 값, 안그래?

915
00:39:49,440 --> 00:39:50,800
나는 물음표로 그렸습니다.

916
00:39:50,800 --> 00:39:54,850
닉은 웅크 리고 화살표로 그렸습니다.

917
00:39:54,850 --> 00:39:59,600
그리고 가능한 빨리 시도로
거기에 가지 말, 스타 Y를 수행

918
00:39:59,600 --> 00:40:03,872
하지만, 합법적이 아닌
주소가 어떤 가짜 위치이야

919
00:40:03,872 --> 00:40:05,080
프로그램이 충돌하는 것입니다.

920
00:40:05,080 --> 00:40:08,580
그리고 빙키의 머리는 것입니다
이 그랬던 것처럼, 여기에 날아합니다.

921
00:40:08,580 --> 00:40:12,130
>> 결국,이 프로그램에 따라서
그냥 플랫 아웃 결함이었다.

922
00:40:12,130 --> 00:40:13,540
그것은 버그가 프로그램이었다.

923
00:40:13,540 --> 00:40:14,760
그리고 그것은 고정 될 필요가 있었다.

924
00:40:14,760 --> 00:40:18,260
그리고 유일한 방법은, 정말, 그것을 해결하기 위해
것, 예를 들어,이 라인,

925
00:40:18,260 --> 00:40:21,010
우리는 심지어에 도착하지 않았다 때문에
이 프로그램은 너무 빨리 추락했다.

926
00:40:21,010 --> 00:40:26,170
그러나 우리는이 문제를 해결한다면, 무엇을
효과는 Y와 동일한 x는이 일을합니까?

927
00:40:26,170 --> 00:40:30,010
음, 기본적으로 y에 포인트
어떤 값 X 가리키는.

928
00:40:30,010 --> 00:40:32,430
>> 닉의 이야기 그래서,
또는 빙키의 이야기, 모두

929
00:40:32,430 --> 00:40:34,640
x와 y를 가리키는했다
메모리의 흰색 덩어리

930
00:40:34,640 --> 00:40:38,300
그래서, 마지막으로, 때를
y는 다시 13에 해당 스타 않습니다,

931
00:40:38,300 --> 00:40:43,080
당신은 13을 가하고 결국
적절한 위치.

932
00:40:43,080 --> 00:40:47,640
그래서 모든 줄이 완벽하다
합법적 인,이 일을 제외하고,

933
00:40:47,640 --> 00:40:51,730
그것은 전에 일어 났을 때
실제로 Y 몇 가지 값을 할당.

934
00:40:51,730 --> 00:40:54,290
>> 이제 다행히도, 당신은하지 않습니다
모든 통해 추론해야

935
00:40:54,290 --> 00:40:56,560
자신에 대한 이러한 종류의 문제의.

936
00:40:56,560 --> 00:40:59,310
내가 가서 풀어 보자
여기에 터미널 창 최대

937
00:40:59,310 --> 00:41:03,050
단지 잠시, 문 열어,
슈퍼 쇼트 프로그램이

938
00:41:03,050 --> 00:41:04,360
또한 종류의 무의미.

939
00:41:04,360 --> 00:41:05,152
그것은 추한.

940
00:41:05,152 --> 00:41:06,610
유용 아무것도 달성하지 않습니다.

941
00:41:06,610 --> 00:41:10,180
그러나 문제를 보여 않습니다
메모리, 그래서 살펴 보자.

942
00:41:10,180 --> 00:41:11,830
>> 주, 슈퍼 간단.

943
00:41:11,830 --> 00:41:14,830
그것은 분명히 함수를 호출,
F는 다음 0을 반환합니다.

944
00:41:14,830 --> 00:41:16,310
그것은 엉망이 최대로 가지 어렵다.

945
00:41:16,310 --> 00:41:18,540
그래서 메인은 지금까지 아주 좋은 것입니다.

946
00:41:18,540 --> 00:41:20,100
>> 따라서 F는 문제가있다.

947
00:41:20,100 --> 00:41:22,120
그리고 그냥 많이 넣지 않았다
그것을 이름에 노력

948
00:41:22,120 --> 00:41:23,990
여기에서, 코드에 초점을 유지한다.

949
00:41:23,990 --> 00:41:25,740
F는 두 줄이 있습니다.

950
00:41:25,740 --> 00:41:27,610
그리고의 지금 무슨 일이 일어나고 있는지 볼 수 있습니다.

951
00:41:27,610 --> 00:41:29,840
그래서 한편
이곳에 나를 만들어 보자

952
00:41:29,840 --> 00:41:32,680
이전이 일치
한편 example--,

953
00:41:32,680 --> 00:41:35,830
왼쪽은
영어에서 일을?

954
00:41:35,830 --> 00:41:36,493
이 놈은 ...

955
00:41:36,493 --> 00:41:37,701
청중 : 포인터를 작성.

956
00:41:37,701 --> 00:41:40,830
데이비드 J. 마란은 : 포인터 만들기
int로 및 호출이 X.

957
00:41:40,830 --> 00:41:43,789
그래서 그 상자 중 하나를 만드는 것
나는 터치 스크린에 그리기 계속.

958
00:41:43,789 --> 00:41:45,913
그리고 지금, 오른쪽에
측의 malloc 물론

959
00:41:45,913 --> 00:41:47,420
메모리 청크를 할당한다.

960
00:41:47,420 --> 00:41:49,989
그리고 단지 명확하게하는 방법
많은 메모리는 분명히이다

961
00:41:49,989 --> 00:41:52,030
할당, 당신이 경우 단지
가지 여기에 수학을?

962
00:41:52,030 --> 00:41:53,200

963
00:41:53,200 --> 00:41:54,040
>> 그래서 40 바이트입니다.

964
00:41:54,040 --> 00:41:57,400
그리고 내가 알고 내가 알고 때문
중간, CS50 어플라이언스, 적어도,

965
00:41:57,400 --> 00:41:58,060
4 바이트이다.

966
00:41:58,060 --> 00:41:59,610
그래서 10 배 4는 40이다.

967
00:41:59,610 --> 00:42:04,924
그래서 이것은 X를 저장하고, 주소
40 정수의 첫번째 아웃의

968
00:42:04,924 --> 00:42:07,340
다시 공간을 할당 된,
뒷면에, 백업하려면 백업합니다.

969
00:42:07,340 --> 00:42:08,470
>> 그리고 그 malloc에​​ 대한 주요 것이죠.

970
00:42:08,470 --> 00:42:11,261
그것은 약간의 메모리를 고려하지 않습니다
여기, 여기 조금, 조금 여기.

971
00:42:11,261 --> 00:42:14,220
그것은 당신에게 메모리의 청크를 제공합니다
연속적으로 운영에서

972
00:42:14,220 --> 00:42:15,240
시스템.

973
00:42:15,240 --> 00:42:18,500
>> 이제 이것에 대해 무엇을,
X 브래킷 (10)는 0에 해당?

974
00:42:18,500 --> 00:42:19,470
코드의 임의의 라인입니다.

975
00:42:19,470 --> 00:42:21,100
유용 아무것도 달성하지 않습니다.

976
00:42:21,100 --> 00:42:26,128
하지만, 재미있다
X 브래킷 10-- 때문에?

977
00:42:26,128 --> 00:42:26,628
그래?

978
00:42:26,628 --> 00:42:27,912
>> 청중 : [들리지?

979
00:42:27,912 --> 00:42:30,500
>> 데이비드 J. 마란 : X 브래킷
열은 널 (null) 일 필요는 없습니다.

980
00:42:30,500 --> 00:42:35,070
널 (null)의 세부 사항을 게임에 제공
문자열, 문자열의 끝에.

981
00:42:35,070 --> 00:42:36,700
하지만 좋은 생각.

982
00:42:36,700 --> 00:42:39,615
>> 얼마나 큰 것은도,이 배열이다
나는 40 바이트를 할당했습니다 불구하고?

983
00:42:39,615 --> 00:42:42,560

984
00:42:42,560 --> 00:42:43,690
그것은 바로, 구를 통해 공입니까?

985
00:42:43,690 --> 00:42:45,120
그것은 총 10 정수를합니다.

986
00:42:45,120 --> 00:42:48,790
40 바이트 만 10 정수,
공을 통해 공을 색인.

987
00:42:48,790 --> 00:42:50,930
>> 그래서 X 브래킷 (10)는 무엇인가?

988
00:42:50,930 --> 00:42:53,090
그것은 사실입니다 일부
알 수없는 쓰레기 값입니다.

989
00:42:53,090 --> 00:42:54,780
그것은 나에게 속하지 않는 메모리입니다.

990
00:42:54,780 --> 00:42:59,650
나는 것을 만지지 수 없습니다
바이트 번호 41, 42, 43, 44.

991
00:42:59,650 --> 00:43:01,420
나는 너무 멀리 약간거야.

992
00:43:01,420 --> 00:43:04,490
>> 그리고 실제로, 나는 실행하는 경우이
프로그램을 아주 잘 충돌 할 수 있습니다.

993
00:43:04,490 --> 00:43:05,790
하지만 가끔은, 우리는 운이 좋은거야.

994
00:43:05,790 --> 00:43:07,706
그래서 그냥 보여주기 위해
이 항아리 솔직히,

995
00:43:07,706 --> 00:43:11,000
당신은 당신이 전에 결코 알지 못할
이게 뭐지의이 작업을 실행할 수 없습니다.

996
00:43:11,000 --> 00:43:12,480
실제로 충돌하지 않았다.

997
00:43:12,480 --> 00:43:15,032
>> 그러나 나는이를 변경하는 경우
인스턴스는, 1000처럼되고

998
00:43:15,032 --> 00:43:16,740
정말 만들려면
신중하고 보자

999
00:43:16,740 --> 00:43:18,710
우리가 얻을 수있는 경우이 시간을 충돌합니다.

1000
00:43:18,710 --> 00:43:20,070
OK, 그것은 충돌하지 않았다.

1001
00:43:20,070 --> 00:43:22,600
어떻게 100000 어떻습니까?

1002
00:43:22,600 --> 00:43:25,000
현실을 리메이크하자, 지금을 다시 실행하십시오.

1003
00:43:25,000 --> 00:43:25,500
확인을 클릭합니다.

1004
00:43:25,500 --> 00:43:25,960
휴.

1005
00:43:25,960 --> 00:43:26,460
좋아.

1006
00:43:26,460 --> 00:43:29,090
그래서 분명히 다시,이
메모리의 세그먼트는, 그래서, 말하자면

1007
00:43:29,090 --> 00:43:32,660
그래서 우리가 할 수있는 합리적으로 큰 아르
또 다시 운.

1008
00:43:32,660 --> 00:43:36,510
하지만 결국, 한 번 당신은 비웃음
정말 화면에 멀리 이동

1009
00:43:36,510 --> 00:43:39,120
당신은 그 정말 메모리를 만지지
정말 당신에 속하지 않습니다.

1010
00:43:39,120 --> 00:43:40,870
>> 하지만 솔직히,이
버그의 종류 가고있다

1011
00:43:40,870 --> 00:43:43,020
힘들어 할 수
스스로 알아 내야합니다.

1012
00:43:43,020 --> 00:43:47,880
그러나 다행히도, 프로그래머, 우리는이
우리가 우리를 위해이 작업을 수행 할 수있는 도구.

1013
00:43:47,880 --> 00:43:50,140
그래서 이것은 아마, 하나
추악한 프로그램,

1014
00:43:50,140 --> 00:43:52,060
GDB의 출력보다 못 생겼어.

1015
00:43:52,060 --> 00:43:55,670
하지만 항상 선이 나
슈퍼 유용 이아르.

1016
00:43:55,670 --> 00:44:00,310
>> Valgrind의 도움 프로그램입니다
사용자가 프로그램을 디버깅 할, 그 자체

1017
00:44:00,310 --> 00:44:03,500
그러나 메모리 관련 발견
문제, 특히.

1018
00:44:03,500 --> 00:44:07,590
그것은 자동으로 코드를 실행합니다
당신은 적어도 두 가지를 찾습니다.

1019
00:44:07,590 --> 00:44:10,680
하나, 당신이 뭔가를 짓
터치 메모리와 같은 실수

1020
00:44:10,680 --> 00:44:11,980
그게 당신에 속하지 않았다?

1021
00:44:11,980 --> 00:44:13,590
그것은 당신이 이런 경우를 찾는 데 도움이됩니다.

1022
00:44:13,590 --> 00:44:15,710
>> 그리고이, 그것은 도움이 될 것입니다
당신은라는 것을 발견

1023
00:44:15,710 --> 00:44:19,270
메모리 누수, 우리가
완전히 무시, 순진,

1024
00:44:19,270 --> 00:44:21,380
약간의 시간과 행복하게.

1025
00:44:21,380 --> 00:44:23,140
그러나 모든 밝혀
이 때, 때마다

1026
00:44:23,140 --> 00:44:26,620
당신이있는 getString에서 호출 한
우리의 프로그램의 많은,

1027
00:44:26,620 --> 00:44:28,930
당신은 운영을 요구하고
메모리 시스템,

1028
00:44:28,930 --> 00:44:32,070
하지만 당신은 어떤 기억을 가지고
의 이제까지 그것을 제공

1029
00:44:32,070 --> 00:44:36,169
다시 일을 unalloc 또는
무료,이 호출로.

1030
00:44:36,169 --> 00:44:37,960
아니, 때문에 우리는 한 번도
그렇게하기를 요구했다.

1031
00:44:37,960 --> 00:44:41,250
>> 그러나이 모든 시간, 프로그램
당신은 C로 작성했습니다

1032
00:44:41,250 --> 00:44:43,800
메모리가 누수되고,
운영 요청

1033
00:44:43,800 --> 00:44:46,190
더 이상 시스템
문자열과 이것 저것 메모리,

1034
00:44:46,190 --> 00:44:47,870
하지만 다시 전달하지 않습니다.

1035
00:44:47,870 --> 00:44:50,080
그리고 지금이 비트입니다
지나친 단순화의,

1036
00:44:50,080 --> 00:44:53,550
그러나 당신이 이제까지했습니다 경우 것이 Mac을 실행하거나
꽤 많은 시간, 열기 위해 사용자의 PC

1037
00:44:53,550 --> 00:44:55,790
많은 프로그램,
어쩌면, 프로그램을 닫

1038
00:44:55,790 --> 00:44:57,795
그리고 비록 당신의
컴퓨터가 추락하지 않았습니다,

1039
00:44:57,795 --> 00:45:01,690
그것은, 너무 느린지고있어
정말 비록로

1040
00:45:01,690 --> 00:45:04,290
많은 메모리를 사용하거나
자원에도 불구하고,

1041
00:45:04,290 --> 00:45:06,070
당신이하지 않으면도
키보드를 만지고,

1042
00:45:06,070 --> 00:45:10,430
그건 나중에 ...하지만 always-- 수 있습니다
프로그램이 실행중인 것을 수

1043
00:45:10,430 --> 00:45:11,920
스스로 메모리 누수가 있습니다.

1044
00:45:11,920 --> 00:45:15,645
그리고 그들은 더를위한 OS 질문을 계속
더 많은 메모리,하지만 그것에 대해 잊고,

1045
00:45:15,645 --> 00:45:18,470
실제로는, 사용하지 않을 수 있지만
따라서 멀리 메모리를 복용

1046
00:45:18,470 --> 00:45:20,500
그것을 할 수있는 다른 프로그램에서.

1047
00:45:20,500 --> 00:45:23,940
그래서 일반적인 설명입니다.

1048
00:45:23,940 --> 00:45:25,940
지금 여기 어디 Valgrind의의입니다
출력은 완전히

1049
00:45:25,940 --> 00:45:29,290
그 이하로 극악한
그리고 모두 더 편안하게.

1050
00:45:29,290 --> 00:45:32,690
하지만 흥미를
물건은 바로 여기까지입니다.

1051
00:45:32,690 --> 00:45:37,060
이 날의 잘못된 기록을 말하고있다
네 크기는,이 프로그램에서 일어나는

1052
00:45:37,060 --> 00:45:40,640
특히, memory.c에 라인 (21).

1053
00:45:40,640 --> 00:45:45,450
>> 나는 흠,이 사실은, 21 행으로 이동하는 경우
크기 네의 잘못된 기록이다.

1054
00:45:45,450 --> 00:45:46,250
이유는 크기 네?

1055
00:45:46,250 --> 00:45:49,500
음,이 번호도하고
증거를 없애 될 수하는 정수입니다.

1056
00:45:49,500 --> 00:45:50,450
그래서 4 바이트입니다.

1057
00:45:50,450 --> 00:45:52,550
그래서 4 바이트를 걸었습니다
그들은 어디에서 속하지 않습니다.

1058
00:45:52,550 --> 00:45:55,080
즉, 어떤 Valgrind의이야
실제로 저를 말하고있다.

1059
00:45:55,080 --> 00:45:57,600
게다가, 그것은 또한 것
우리가 볼 수 있습니다로 말해,

1060
00:45:57,600 --> 00:46:01,490
당신이 미래의 pset에서 실행으로, 경우 및
당신은 참으로 메모리를 유출했을 때

1061
00:46:01,490 --> 00:46:05,300
나는라고했기 때문에 나는이
malloc을하지만 실제로하지 않은

1062
00:46:05,300 --> 00:46:08,010
자유,이 경우라고
저희는 결국 볼 수 있습니다

1063
00:46:08,010 --> 00:46:09,830
malloc에​​의 반대입니다.

1064
00:46:09,830 --> 00:46:10,860

1065
00:46:10,860 --> 00:46:12,930
>> 그래서 지금은, 마지막 예제를 생각합니다.

1066
00:46:12,930 --> 00:46:14,050

1067
00:46:14,050 --> 00:46:16,690
그래서이 일이 조금 더
비전하지만 아마도 야

1068
00:46:16,690 --> 00:46:19,180
가장 큰 이유
메모리에주의

1069
00:46:19,180 --> 00:46:24,490
그리고 이유는 그 많은 프로그램
심지어이 일에 / 또는 웹 서버,

1070
00:46:24,490 --> 00:46:28,200
어딘가에 나쁜 놈들에 의해 점령된다
인터넷에 어떻게 든 누구

1071
00:46:28,200 --> 00:46:33,390
서버에 가짜 패킷을 전송
계정을 손상 노력

1072
00:46:33,390 --> 00:46:36,420
또는 데이터를 가지고, 아니면 그냥
일반적으로 기계를 인수.

1073
00:46:36,420 --> 00:46:38,910
버퍼 오버 플로우로
이름이 제시 수단

1074
00:46:38,910 --> 00:46:40,740
int가 아닌,하지만, 버퍼 오버 플로우.

1075
00:46:40,740 --> 00:46:43,490
그리고 버퍼는 멋진 방법입니다
말하는 이는 메모리의 무리입니다.

1076
00:46:43,490 --> 00:46:46,710
>> 그리고 실제로, 나는 문자열이라고
대신의의 버퍼 전에.

1077
00:46:46,710 --> 00:46:49,234
이 버퍼의 경우 때문에,
유튜브 의미에서처럼,

1078
00:46:49,234 --> 00:46:52,400
또는 동영상을보고있어 언제,
당신은 단어 버퍼링을 볼수있을 것이다,

1079
00:46:52,400 --> 00:46:53,040
점, 점 점.

1080
00:46:53,040 --> 00:46:54,240
그것은 매우 짜증나.

1081
00:46:54,240 --> 00:46:55,990
그리고 그것은 단지 의미
비디오 플레이어가

1082
00:46:55,990 --> 00:46:58,710
많은 다운로드를 시도한다
바이트 바이트, 많은

1083
00:46:58,710 --> 00:47:00,170
인터넷에서 동영상에서.

1084
00:47:00,170 --> 00:47:02,920
하지만 느린, 그래서하려고
그들의 무리를 다운로드

1085
00:47:02,920 --> 00:47:06,430
그래서 버퍼, 컨테이너를 채우는
당신은 그 다음 할 수있는 충분한 바이트가

1086
00:47:06,430 --> 00:47:09,174
당신에게 비디오를 보여
지속적으로 일시 정지하지 않고.

1087
00:47:09,174 --> 00:47:11,340
그러나 그것은 당신이 할 수있는 밝혀
이 큰에 버퍼를 가지고있다.

1088
00:47:11,340 --> 00:47:15,710
그러나이 많은 데이터를 넣어 시도
그것은, 매우 나쁜 일이 일어날 수 있습니다.

1089
00:47:15,710 --> 00:47:22,780
예를 들어 자, 살펴 보자
일례의 마지막 티저.

1090
00:47:22,780 --> 00:47:24,720
이것은 또 다른 프로그램입니다
즉, 첫눈에,

1091
00:47:24,720 --> 00:47:26,540
슈퍼 유용한 아무것도하지 않습니다.

1092
00:47:26,540 --> 00:47:29,590
그것은 주요 기능을 가지고있다
즉, F, 그 함수를 호출합니다.

1093
00:47:29,590 --> 00:47:36,640
그리고 그 함수 f를, 여기까지,이
문자 배열은, 크기 (12), C했다.

1094
00:47:36,640 --> 00:47:39,340
그리고, 그것은이를 사용하고
새로운 기능의 strncpy를했다.

1095
00:47:39,340 --> 00:47:40,430

1096
00:47:40,430 --> 00:47:45,190
>> 그것은,이 간단한으로 밝혀
코드의 간단한 라인, 두 라인,

1097
00:47:45,190 --> 00:47:49,130
우리는 내 전체 프로그램을 만들었습니다
따라서, 내 전체 컴퓨터,

1098
00:47:49,130 --> 00:47:54,000
내 사용자 계정 및 내 하드
사람에게 잠재적으로 취약한 드라이브

1099
00:47:54,000 --> 00:47:58,170
누가 알고 실행하는 데 충분
특정 명령 줄 프로그램

1100
00:47:58,170 --> 00:47:58,900
인수.

1101
00:47:58,900 --> 00:48:03,400
즉, 만약이 나쁜 사람
입력하여 argvargv [1]의 내부에 둔다

1102
00:48:03,400 --> 00:48:08,750
키보드 매우 특수하게 조작 된보기에서
문자열이 아닌 abc 방송, 123, 그러나 본질적으로,

1103
00:48:08,750 --> 00:48:15,180
실행 나타내는 이진 기호
코드, 그 또는 그녀가 쓴 프로그램

1104
00:48:15,180 --> 00:48:19,190
이다이 간단한 프로그램과
프로그램의 수천의 대표

1105
00:48:19,190 --> 00:48:23,610
즉, daresay 마찬가지로 취약
그 또는 그녀는 궁극적으로, 전체 삭제 기능을 사용할 수 있습니다

1106
00:48:23,610 --> 00:48:26,680
내 하드 드라이브에있는 파일은 얻을
그 또는 그녀가 할 수 있도록 프롬프트를 깜박

1107
00:48:26,680 --> 00:48:30,170
자신에 명령을 입력
자신에게 모든 파일을 전자 메일을 보내주십시오.

1108
00:48:30,170 --> 00:48:34,660
내가 할 수있는 건, 그가
또는 그녀는이 코드를 수행 할 수 있습니다.

1109
00:48:34,660 --> 00:48:36,575
>> 우리는 아직은이 문제를 해결하지 않을 것이다.

1110
00:48:36,575 --> 00:48:38,700
그리고 사실, 그것은에 무슨
작은 그림을 포함

1111
00:48:38,700 --> 00:48:41,470
이런 식으로, 우리는 곧 올 거하는
모두가 더 잘 이해합니다.

1112
00:48:41,470 --> 00:48:44,480
그러나 오늘,의가 종료하자
, 조금 더 희망, 무엇을

1113
00:48:44,480 --> 00:48:48,360
이해할 수 XKCD 농담,
우리는 다음 시간을 재개 할 때까지.

1114
00:48:48,360 --> 00:48:51,100

1115
00:48:51,100 --> 00:48:51,600
좋아.

1116
00:48:51,600 --> 00:48:53,446
수요일에 당신을 참조하십시오.

1117
00:48:53,446 --> 00:48:54,754
>> [음악 연주]

1118
00:48:54,754 --> 00:48:57,790
>> 스피커 : 그리고 지금, 깊은
Daven 판햄으로 생각.

1119
00:48:57,790 --> 00:49:00,890

1120
00:49:00,890 --> 00:49:04,770
메모리의 더미로 점프처럼
일요일 오후에 황금 나뭇잎.

1121
00:49:04,770 --> 00:49:09,000
바람 불고, 요동 당신의
오 hair--, 나는 일 먼저 ... 그리워

1122
00:49:09,000 --> 00:49:11,100

1123
00:49:11,100 --> 00:49:12,650
>> [웃음]

1124
00:49:12,650 --> 00:49:13,750