1
00:00:00,000 --> 00:00:02,742

2
00:00:02,742 --> 00:00:05,680
>> SPEAKER 1 : 안녕하세요 여러분.

3
00:00:05,680 --> 00:00:07,530
우리는 시작하는 것입니다.

4
00:00:07,530 --> 00:00:09,330
나는 사람들이 아직도있을 거에요
에서 필터링 할 수 있습니다.

5
00:00:09,330 --> 00:00:12,840
그러나 시간의 관심, 우리가 할 수 있도록
시간에 여기서 너희들을 얻을,

6
00:00:12,840 --> 00:00:14,110
우리는 시작하는 것입니다.

7
00:00:14,110 --> 00:00:18,780
그래서 CS50 퀴즈 영 검토에 오신 것을 환영합니다.

8
00:00:18,780 --> 00:00:23,020
실현하지 않은 사람들을 위해
아직, 당신은 수요일에 질문이 있습니다.

9
00:00:23,020 --> 00:00:25,700
우 ~ 후.

10
00:00:25,700 --> 00:00:29,780
>> 아직 공부를 시작하지 않은 경우 또는
이 아직 존재한다는 것을 실현하지 않은,

11
00:00:29,780 --> 00:00:34,070
지난 퀴즈에 대한 모든 정보
퀴즈는 cs50.net/quizzes에 있습니다.

12
00:00:34,070 --> 00:00:38,090
꽤 좋은 물건이있을거야,
10 마지막에서 과거 퀴즈

13
00:00:38,090 --> 00:00:43,760
세 정보뿐만 아니라
이 퀴즈 및 주제에 대한

14
00:00:43,760 --> 00:00:46,250
그 다룹니다.

15
00:00:46,250 --> 00:00:48,980
그래서 시작하자.

16
00:00:48,980 --> 00:00:54,240
>> 그래서 너희들은, 첫째 기억하고있을
클래스 다윗의 일 그 램프에 있었다.

17
00:00:54,240 --> 00:00:59,650
그래서 기본적으로 모든 것이 들어가
컴퓨터가 후드 아래에

18
00:00:59,650 --> 00:01:00,860
이진에서 수행.

19
00:01:00,860 --> 00:01:04,080
바이너리는 소리가 무엇을 의미
같은 0과 1.

20
00:01:04,080 --> 00:01:09,290
이 두 값을 갖는다
표현 될 수있다.

21
00:01:09,290 --> 00:01:14,675
>> 그래서 막 부분의 첫 날에 추천
다윗은 빛의 전원을 켜거나

22
00:01:14,675 --> 00:01:21,990
전구는 우리의 컴퓨터에 표현, 또는 일하기
이해 0의 이진과

23
00:01:21,990 --> 00:01:24,110
하나의, 또는 해제.

24
00:01:24,110 --> 00:01:25,360
이진의 기초.

25
00:01:25,360 --> 00:01:29,440

26
00:01:29,440 --> 00:01:32,470
모든 장소가 표시됩니다
기본이있다.

27
00:01:32,470 --> 00:01:36,260
그래서 당신은에 0이 추가
한 모든 방법을 최대 2이다​​.

28
00:01:36,260 --> 00:01:41,970
>> 바이너리가 무엇인지 계산하기
진수, 당신은이 방정식을 따르

29
00:01:41,970 --> 00:01:42,840
형 일.

30
00:01:42,840 --> 00:01:49,510
당신은 그 장소의 어느 하나가있는 경우,
당신은 곱 어떤

31
00:01:49,510 --> 00:01:53,820
그것은에서의 기본, 그것을 추가하고,
당신은 소수를 얻을.

32
00:01:53,820 --> 00:01:57,930
그래서 이것은 당신이 계산하는 방법이다
이진 5.

33
00:01:57,930 --> 00:02:01,400
그냥 우리가 어떤 작업을하고 있었는지 등
마지막 슬라이드,이 방법은 것입니다

34
00:02:01,400 --> 00:02:02,650
5를 통해 하나를 나타냅니다.

35
00:02:02,650 --> 00:02:05,320

36
00:02:05,320 --> 00:02:09,660
>> 마찬가지로, 당신이 추가 할 수 있습니다 좋아하고
진수 뺄셈 10을 기준으로, 또는

37
00:02:09,660 --> 00:02:13,040
정말 어떤베이스에 추가 할 수 있습니다
이진에서 뺍니다.

38
00:02:13,040 --> 00:02:18,400
때 당신은 기대 정확히 무엇을
그것은 더 같으면,이 업을 추가

39
00:02:18,400 --> 00:02:24,220
일보다, 당신은 하나, 그것은 0 - 수행,
단지, 또한 그런 식으로 할

40
00:02:24,220 --> 00:02:29,910
같은 당신은 정기적으로 기대
소수 또는 다른베이스.

41
00:02:29,910 --> 00:02:30,970
쿨.

42
00:02:30,970 --> 00:02:35,140
>> 나는 모든 것을하기 전에 말했듯이 그래서
우리의 컴퓨터의 후드 아래에 간다

43
00:02:35,140 --> 00:02:37,560
0과 1의, 또는 바이너리로 수행됩니다.

44
00:02:37,560 --> 00:02:43,470
그래서 우리는 표현 어떻게, 예를 들어,
문자 나 숫자 또는 문자?

45
00:02:43,470 --> 00:02:45,560
그리고 그에 대한 대답은 ASCII입니다.

46
00:02:45,560 --> 00:02:49,380
>> ASCII 문자 사이의 매핑
우리는 일반적으로 볼 것

47
00:02:49,380 --> 00:02:53,360
의, B의 같은 영어,
C의, 밑줄, 대시 및

48
00:02:53,360 --> 00:02:54,910
그런 건.

49
00:02:54,910 --> 00:02:57,260
그리고 ASCII 값에 해당 매핑합니다.

50
00:02:57,260 --> 00:03:03,080
ASCII 값은 숫자에 불과하다
컴퓨터에 의해 이해 될 수있다.

51
00:03:03,080 --> 00:03:07,430
그리고 당신은 추가 할 수있는 것처럼하고
숫자 뺄셈을 수행 할 수 있습니다

52
00:03:07,430 --> 00:03:10,890
ASCII 값으로 그들.

53
00:03:10,890 --> 00:03:14,050
>> 이 예에서, 그래서
이 인쇄됩니까?

54
00:03:14,050 --> 00:03:26,790

55
00:03:26,790 --> 00:03:35,480
그래, 그래서 그냥 공간 B 공간 C 공간
D. 어디 내 마우스는 어디에 있습니까?

56
00:03:35,480 --> 00:03:39,200

57
00:03:39,200 --> 00:03:43,380
당신이 65에서 int를 정의 할 수 있습니다 알 수 있습니다.

58
00:03:43,380 --> 00:03:47,080
그리고 당신은 사용하여 해당를 인쇄 할 때
%의 C, 그것은 그와 같은 해석 거

59
00:03:47,080 --> 00:03:49,330
캐릭터와 A.를 인쇄합니다

60
00:03:49,330 --> 00:03:52,800
>> 마찬가지로 선언 할 수 있습니다
그것은 문자로.

61
00:03:52,800 --> 00:03:56,860
그리고 당신은 퍼센트를 사용하여 인쇄 할 때
C, 그것으로 그 해석합니다

62
00:03:56,860 --> 00:04:05,240
퍼센트 D. 그리고 당신은 추가 할 수 있습니다처럼
수, 당신은 문자는 추가 할 수 있습니다

63
00:04:05,240 --> 00:04:06,878
이 경우의 ASCII 값.

64
00:04:06,878 --> 00:04:11,370

65
00:04:11,370 --> 00:04:16,130
>> 모두를위한 그래서 약간의 포인터.

66
00:04:16,130 --> 00:04:19,610
5, 문자열로하지 않습니다
실제로 5와 동일.

67
00:04:19,610 --> 00:04:26,610
그래서 우리는 어떻게 변환 할 수 있습니다
정수 5 문자열 오?

68
00:04:26,610 --> 00:04:28,930
어떤 아이디어?

69
00:04:28,930 --> 00:04:31,630
그래.

70
00:04:31,630 --> 00:04:36,720
>> 그래서 우리는 문자열로 다섯이있는 경우,
우리는 공을 뺄 수 있습니다.

71
00:04:36,720 --> 00:04:37,820
그리고 그것은 우리에게 5주지.

72
00:04:37,820 --> 00:04:41,670
그리고 유사하게, 우리는로 5가있는 경우
정수, 문자열 0으로 그를 추가합니다.

73
00:04:41,670 --> 00:04:43,112
그리고 그것은 우리에게 문자열 다섯을 제공합니다.

74
00:04:43,112 --> 00:04:46,350

75
00:04:46,350 --> 00:04:48,350
쿨.

76
00:04:48,350 --> 00:04:52,940
>> 이제 한 곳을 강의를 다시 불러
우리는 알고리즘에 대해 이야기했다.

77
00:04:52,940 --> 00:04:57,260
그래서 우리는 실제로 컴퓨터를하려면 어떻게
재미있는 일을 할까?

78
00:04:57,260 --> 00:05:00,460
당신은 추가 및 감산, 알고
숫자와 인쇄 일 밖으로 아니다

79
00:05:00,460 --> 00:05:01,730
그 흥미 진진한.

80
00:05:01,730 --> 00:05:04,620
일반적으로, 우리는 우리의 컴퓨터를 원하는
알고리즘의 어떤 종류를 수행합니다.

81
00:05:04,620 --> 00:05:07,820
좀 더 복잡한 뭔가
단순한 산술 연산.

82
00:05:07,820 --> 00:05:11,930
>> 알고리즘은 단계 세트로 단 단계
수행하는 방법에 대한 지침

83
00:05:11,930 --> 00:05:14,640
특정 task--

84
00:05:14,640 --> 00:05:15,660
단지 조리법을 좋아한다.

85
00:05:15,660 --> 00:05:19,990
당신의 첫번째 일을 기억하고 있습니다
다윗은 우리가 방을 계산 한 클래스

86
00:05:19,990 --> 00:05:22,550
사람들이 얼마나 많은 사람들이
방에 있었다.

87
00:05:22,550 --> 00:05:24,480
당신은 계산에 사용될 수
하나씩.

88
00:05:24,480 --> 00:05:25,860
1, 2, 3, 4.

89
00:05:25,860 --> 00:05:28,010
이 경우에있어서, 선형 시간 알고리즘.

90
00:05:28,010 --> 00:05:31,710
>> 그러나 다윗은하는 알고리즘을 도입
당신이 방에있는 사람을 세는

91
00:05:31,710 --> 00:05:37,340
모두가이 자리에, 당신은 당신의 말을
다른 사람에게 수 있다는 추가

92
00:05:37,340 --> 00:05:39,200
수까지, 그리고 한 사람이 앉는 다.

93
00:05:39,200 --> 00:05:40,410
그리고 당신은 그것을 반복합니다.

94
00:05:40,410 --> 00:05:42,910
즉, 알고리즘의 한 유형이다.

95
00:05:42,910 --> 00:05:47,520
우리는 어떻게 효율적으로 분석 할 수 있습니다
그것은 실행 시간의 ON 알고리즘을 기반으로합니다.

96
00:05:47,520 --> 00:05:49,680
그러나 우리는 조금 얘기하자
그 이후에 대한 자세한.

97
00:05:49,680 --> 00:05:52,740

98
00:05:52,740 --> 00:05:57,090
>> 그래서 모든 알고리즘을 수행 할 수도 있습니다
의사 코드로 작성 될 수있다.

99
00:05:57,090 --> 00:06:01,120
의사 코드는 같은 영어입니다
구문을 표시하는 데 사용

100
00:06:01,120 --> 00:06:02,420
프로그래밍 언어.

101
00:06:02,420 --> 00:06:06,070
예를 들어, 사용자를 우리가 원하는 경우 물어
내가 좋아하는 번호를 추측하기 위해

102
00:06:06,070 --> 00:06:08,390
같은 의사가있을 수 있습니다.

103
00:06:08,390 --> 00:06:09,850
>> 사용자가 추측 가져옵니다.

104
00:06:09,850 --> 00:06:13,570
추측은 정확하면, 그들에게
그들은 맞아요, 다른 그들에게

105
00:06:13,570 --> 00:06:15,560
그들은 올바른 아니에요.

106
00:06:15,560 --> 00:06:22,530
그리고 의사가 쉽게의 방법
아이디어 또는 알고리즘을 나타내는.

107
00:06:22,530 --> 00:06:26,910
그래서 지금 우리가 실제로 작성 할 수 있습니다
이 언어로하는 컴퓨터

108
00:06:26,910 --> 00:06:27,980
이해는 할 수 있습니다.

109
00:06:27,980 --> 00:06:35,660
그래서 우리는 우리의 의사를 작성할 수 있으며,
소스 코드에 그 해석한다.

110
00:06:35,660 --> 00:06:41,320
>> 지금까지 소스 코드를 준수해야합니다
특정 구문

111
00:06:41,320 --> 00:06:42,490
프로그래밍 언어.

112
00:06:42,490 --> 00:06:45,430
그리고 지금까지, CS50, 우리는했습니다
대부분 C를 사용하고있다.

113
00:06:45,430 --> 00:06:48,320
그래서이 C 소스 코드 수 있습니다.

114
00:06:48,320 --> 00:06:51,440
나중에 과정에서, 당신은 밤에 와서
다른 프로그래밍과 접촉

115
00:06:51,440 --> 00:06:52,480
PHP와 같은 언어.

116
00:06:52,480 --> 00:06:57,540
아니면 당신도, 당신을 다른 수업을하는 경우
자바, 파이썬, 또는 OCML을 할 수 있습니다.

117
00:06:57,540 --> 00:07:01,570
그러나 우리의 C 프로그램 언어로, 여긴
우리의 소스 코드를 작성할 수있는 방법

118
00:07:01,570 --> 00:07:04,760
의사 알고리즘이
난 그냥 앞에서 설명한.

119
00:07:04,760 --> 00:07:08,630

120
00:07:08,630 --> 00:07:11,430
>> 그렇다면 실제로 컴퓨터 않습니다
그 이해?

121
00:07:11,430 --> 00:07:14,490
난 단지 정말, 그 전에 말했듯이
0과 1을 이해한다.

122
00:07:14,490 --> 00:07:17,880
그래서 어떻게 소스에서 얻을 않습니다
할 수있는 일에 대한 코드

123
00:07:17,880 --> 00:07:18,960
이해?

124
00:07:18,960 --> 00:07:22,920
음, 우리는 뭔가를
컴파일러했다.

125
00:07:22,920 --> 00:07:28,450
>> 당신은 대부분 다시 불러올 경우
psets를, 당신은 프로그램의 어떤 종류가 있었다

126
00:07:28,450 --> 00:07:30,370
도트 C의 파일에 기록.

127
00:07:30,370 --> 00:07:32,550
그리고 당신은 메이크업을 입력합니다.

128
00:07:32,550 --> 00:07:35,970
그래서 만들은거야?

129
00:07:35,970 --> 00:07:39,970
>> 당신은 컴파일 메이크업을 입력 할 수 있습니다
프로그램 누군가를 때문에

130
00:07:39,970 --> 00:07:42,730
누구든지 당신의 페이지 세트를 썼다;
아마 의원님

131
00:07:42,730 --> 00:07:44,190
메이크 파일을 만들었습니다.

132
00:07:44,190 --> 00:07:51,320
그리고 그 실행 알 수 있도록 알려줍니다 당신의
컴파일러라는 그 소리, 그 뜻

133
00:07:51,320 --> 00:07:55,560
다음 물체에 소스 코드를 컴파일
0과 1 인 코드,

134
00:07:55,560 --> 00:07:57,720
컴퓨터가 이해하는.

135
00:07:57,720 --> 00:08:01,610
그러나 나중에 조금, 우리는 갈 것입니다
컴파일러에 대한 깊이 더.

136
00:08:01,610 --> 00:08:05,640

137
00:08:05,640 --> 00:08:10,800
>> 그래서 기억 PSET 공은 .. 그래,
당신은 질문이 있다면?

138
00:08:10,800 --> 00:08:11,620
>> 청중 : [들리지?

139
00:08:11,620 --> 00:08:12,490
>> SPEAKER 1 : 예.

140
00:08:12,490 --> 00:08:14,960
사실 그들이 생각
온라인으로해야한다.

141
00:08:14,960 --> 00:08:15,120
그래.

142
00:08:15,120 --> 00:08:16,572
>> 청중 : 그것은 [INAUDIBLE] 같은가요?

143
00:08:16,572 --> 00:08:19,476

144
00:08:19,476 --> 00:08:20,830
>> SPEAKER 1 : 그것은 아닙니다.

145
00:08:20,830 --> 00:08:25,810
이 cs50.net/quizzes에 있습니다.

146
00:08:25,810 --> 00:08:32,900
>> 청중 : 슬래시 퀴즈, 2013 슬래시
0 슬래시, 단지 클릭을 통해

147
00:08:32,900 --> 00:08:35,956
퀴즈 2013 퀴즈 공,
섹션 슬라이드를 검토합니다.

148
00:08:35,956 --> 00:08:40,380
>> SPEAKER 1 : 그래, 그래서 너희들은 원하는 경우
그것을 당겨에보고하여

149
00:08:40,380 --> 00:08:42,740
자신의 컴퓨터, 너무 괜찮아요.

150
00:08:42,740 --> 00:08:43,130
다시 말해봐.

151
00:08:43,130 --> 00:08:44,546
>> 청중 : [들리지].

152
00:08:44,546 --> 00:08:48,780
>> SPEAKER 1 : 네, [INAUDIBLE]
더미 변수이다.

153
00:08:48,780 --> 00:08:49,644
오, 그래?

154
00:08:49,644 --> 00:08:51,372
>> 청중 : [들리지?

155
00:08:51,372 --> 00:08:54,300
>> SPEAKER 1 : 아니, 파업
시험에 없습니다.

156
00:08:54,300 --> 00:08:55,950
죄송합니다,이었다 그녀의 질문이었다
시험에 파업.

157
00:08:55,950 --> 00:08:59,530
그리고 그것은 아니다.

158
00:08:59,530 --> 00:09:05,780
그래서 PSET 0, 너희들은 모두이 있어야합니다
스크래치를 사용하여 뭔가를 구현했습니다.

159
00:09:05,780 --> 00:09:13,100
그리고 우리는 몇 가지 기본적인 프로그래밍을 배웠다
스크래치를 사용하여 빌딩 블록입니다.

160
00:09:13,100 --> 00:09:15,590
>> 그럼 몇 가지를 살펴 보자
이러한 빌딩 블록

161
00:09:15,590 --> 00:09:18,170
그 프로그램을 구성합니다.

162
00:09:18,170 --> 00:09:20,570
먼저 부울 식입니다.

163
00:09:20,570 --> 00:09:24,540
부울 표현식은 사람이며,
이 공의 또는 아무것도

164
00:09:24,540 --> 00:09:25,700
두 가지 값.

165
00:09:25,700 --> 00:09:30,320
이 경우, 참 또는 거짓,
또는 해제하고, 예, 아니오.

166
00:09:30,320 --> 00:09:35,390
매우 간단하고 단순한의 예
부울을 사용하여 프로그램

167
00:09:35,390 --> 00:09:39,140
여기에 표현입니다.

168
00:09:39,140 --> 00:09:43,220
>> 그래서 부울 식의 순서
유용, 우리는 부울 연산자가 있습니다.

169
00:09:43,220 --> 00:09:48,920
이들은 사용될 수있는 연산자
특정 값을 비교합니다.

170
00:09:48,920 --> 00:09:52,820
그래서 우리가 가지고 여부를 같 이하
보다보다 크거나, 같거나

171
00:09:52,820 --> 00:09:55,130
동등하고, 이하
보다 더 이상이다.

172
00:09:55,130 --> 00:09:59,060
그러나 이러한 연산자는 매우 유용하지 않다
우리는로 결합하지 않는 한

173
00:09:59,060 --> 00:10:00,320
조건.

174
00:10:00,320 --> 00:10:04,370
>> 그래서 너희들은 처음부터 기억하고 있습니다
당신의 페이지에서 우리 것을 설정

175
00:10:04,370 --> 00:10:05,400
조건을 가지고 있었다.

176
00:10:05,400 --> 00:10:09,710
그들은에서 포크처럼 본질적으로 아르
프로그램의 논리 그

177
00:10:09,710 --> 00:10:12,670
인지에 따라 실행
조건이 충족된다.

178
00:10:12,670 --> 00:10:18,150
우리가 가진 조건에 따라서 한
이 과정에서 여러 번 사용할 수 있습니다

179
00:10:18,150 --> 00:10:21,470
또, 경우, 그리고 다른 조건 경우.

180
00:10:21,470 --> 00:10:24,060
>> 그 방법의 예
당신은을 사용할 수 있습니다.

181
00:10:24,060 --> 00:10:28,430
사람의 차이를 알고 있나요
단지 문을 모든 경우에 사용

182
00:10:28,430 --> 00:10:32,530
경우, 다른 구절 내리막 길,
경우, 그리고 다른 결합?

183
00:10:32,530 --> 00:10:33,013
네?

184
00:10:33,013 --> 00:10:34,263
>> 청중 : [들리지].

185
00:10:34,263 --> 00:10:40,741

186
00:10:40,741 --> 00:10:42,160
>> SPEAKER 1 : 그렇지.

187
00:10:42,160 --> 00:10:50,210
그래서 나는이 있다면 경우이 끝까지
방법도이 조건을 반환하는 경우

188
00:10:50,210 --> 00:10:52,800
사실, 그것은 여전히​​ 계속
다음에이 테스트.

189
00:10:52,800 --> 00:11:00,120
반면, 다른 - 경우, 다른 사람과 함께
문 하나에 해당하는 반환하는 경우,

190
00:11:00,120 --> 00:11:02,640
다른 사람은 테스트되지 않습니다.

191
00:11:02,640 --> 00:11:05,955
그것에 대해 질문?

192
00:11:05,955 --> 00:11:06,890
쿨.

193
00:11:06,890 --> 00:11:12,240
>> 그래서 당신은 다른 사람의 경우 - 다른 사람을 사용
당신이 알고있는 경우 문 즉, 그것은 단지 수

194
00:11:12,240 --> 00:11:14,470
이러한 경우 중 하나.

195
00:11:14,470 --> 00:11:21,550
x는 0보다 작은 경우 그래서 우리는 그것의 알고
확실히 될 수 없습니다

196
00:11:21,550 --> 00:11:22,890
0보다 큰.

197
00:11:22,890 --> 00:11:26,940

198
00:11:26,940 --> 00:11:31,480
>> 다음에, 또 다른 빌딩 블록
우리가 배운 루프입니다.

199
00:11:31,480 --> 00:11:33,310
우리는 루프의 세 가지 유형이있다.

200
00:11:33,310 --> 00:11:35,830
루프, while 루프,
그리고 while 루프 않습니다.

201
00:11:35,830 --> 00:11:38,730
그리고 일반적으로, 당신은 때를 앉아서
뭔가를 작성, 당신은 결정해야

202
00:11:38,730 --> 00:11:40,060
당신이 사용하고자하는 세 가지있다.

203
00:11:40,060 --> 00:11:41,900
그렇다면 우리는 어떤 일을 결정합니까?

204
00:11:41,900 --> 00:11:44,920

205
00:11:44,920 --> 00:11:48,790
>> 우리가 알고있는 경우에 우리는 일반적으로 루프 사용
우리가 몇번이나 반복 할

206
00:11:48,790 --> 00:11:53,650
뭔가를 통해 또는 얼마나 많은 시간을
우리는 작업을 수행 할 수 있습니다.

207
00:11:53,650 --> 00:11:58,830
우리는 몇 가지를 필요로하는 경우 우리는 while 루프를 사용
조건을 계속 실행하는 사실입니다.

208
00:11:58,830 --> 00:12:03,730
그리고 우리는 매우 유사 동안 할 사용하십시오
동안,하지만 우리는 우리의 코드가 실행되도록 할

209
00:12:03,730 --> 00:12:04,880
적어도 한 시간입니다.

210
00:12:04,880 --> 00:12:09,410
>> 할 일에 무엇이든 그렇게하는 동안, 윌
항상 한 번 이상 실행합니다.

211
00:12:09,410 --> 00:12:13,120
반면, 동안과, 그것을
모든 경우 실행되지 않을 수 있습니다

212
00:12:13,120 --> 00:12:15,490
조건이 만족되지 않는다.

213
00:12:15,490 --> 00:12:16,740
그와 질문?

214
00:12:16,740 --> 00:12:20,480

215
00:12:20,480 --> 00:12:22,860
>> 루프의 그래서 구조.

216
00:12:22,860 --> 00:12:23,620
너희들은이 모든 것을 보았다.

217
00:12:23,620 --> 00:12:25,320
당신은 그것을 초기화합니다.

218
00:12:25,320 --> 00:12:26,600
당신은 조건의 어떤 종류가 있습니다.

219
00:12:26,600 --> 00:12:32,340
따라서, 예를 들어, 우리는 초기화 수도
에 관해서는 내가 공 같습니다.

220
00:12:32,340 --> 00:12:34,040
난 10 미만이다.

221
00:12:34,040 --> 00:12:35,442
그리고 난 + +.

222
00:12:35,442 --> 00:12:39,010
우리가 한 아주 간단한 일.

223
00:12:39,010 --> 00:12:42,210
>> while 루프의 경우와 마찬가지로, 당신은이
초기화의 일종을 가지고,

224
00:12:42,210 --> 00:12:44,980
조건이 어떤 종류의, 그리고
업데이트의 어떤 종류.

225
00:12:44,980 --> 00:12:51,990
그래서 우리는 또한 루프 우리를 구현할 수 있습니다
while 루프로이를 사용.

226
00:12:51,990 --> 00:12:56,000
그리고 마찬가지로 않지만 루프,
우리는 몇 가지 초기화를해야 할 수도 있습니다,

227
00:12:56,000 --> 00:12:58,640
뭔가를 실행하여 업데이트하고,
다음 조건을 확인합니다.

228
00:12:58,640 --> 00:13:03,500

229
00:13:03,500 --> 00:13:05,140
>> 이제 기능을합니다.

230
00:13:05,140 --> 00:13:06,460
우리는 모든 것을 함께 넣어.

231
00:13:06,460 --> 00:13:10,140
우리는 몇 가지를 작성 할 수 있습니다
기능을 가지.

232
00:13:10,140 --> 00:13:12,790
공통 기능을 할 수도 있고
이미 본 메인이다.

233
00:13:12,790 --> 00:13:13,770
주요 기능입니다.

234
00:13:13,770 --> 00:13:16,160
그것은 반환 유형 INT 있습니다.

235
00:13:16,160 --> 00:13:18,470
그것은 주요 함수 이름을 가지고 있습니다.

236
00:13:18,470 --> 00:13:20,810
그리고 인수 argc와 argv에 있습니다.

237
00:13:20,810 --> 00:13:24,040
그래서 주는 기능입니다.

238
00:13:24,040 --> 00:13:27,230
>> 당신이 사용하는 수도 기타 기능
printf--의 printf는 function--입니다

239
00:13:27,230 --> 00:13:29,330
getInt는,인지 toupper.

240
00:13:29,330 --> 00:13:32,010
그러나이 있었어 일이
에 의해 우리를 위해 구현

241
00:13:32,010 --> 00:13:33,270
라이브러리의 일종.

242
00:13:33,270 --> 00:13:37,400
너희들은 포함 기억한다면
이 CS50.h 라이브러리 또는

243
00:13:37,400 --> 00:13:38,510
표준 I / O 라이브러리.

244
00:13:38,510 --> 00:13:39,200
네, 질문?

245
00:13:39,200 --> 00:13:41,610
>> 관객 : C 단지 고유의 메인인가?

246
00:13:41,610 --> 00:13:44,740
그냥 가지 [INAUDIBLE]합니까?

247
00:13:44,740 --> 00:13:47,370
>> SPEAKER 1 : 질문은
메인하다면 C에 고유하다.

248
00:13:47,370 --> 00:13:51,460
그리고 네, 모든 기능
주요 기능을 가지고있다.

249
00:13:51,460 --> 00:13:55,290
그것은 종류의 컴퓨터의 필요이다
시작 위치를 알 수 있도록

250
00:13:55,290 --> 00:13:55,993
코드를 실행.

251
00:13:55,993 --> 00:13:58,108
>> 청중 : 그러니까 나하지 [들리지?

252
00:13:58,108 --> 00:13:59,480
>> SPEAKER 1 호

253
00:13:59,480 --> 00:14:00,760
다른 질문?

254
00:14:00,760 --> 00:14:03,430

255
00:14:03,430 --> 00:14:04,770
쿨.

256
00:14:04,770 --> 00:14:08,050
당신은 기능을 사용할 수 있도록처럼
그가 당신을 위해 쓰여, 당신도 할 수 있습니다

257
00:14:08,050 --> 00:14:10,380
자신의 함수를 작성합니다.

258
00:14:10,380 --> 00:14:17,050
이것은 그 사람이 수도있는 기능입니다
부피를 계산하는 쓴

259
00:14:17,050 --> 00:14:18,395
예컨대 Q의.

260
00:14:18,395 --> 00:14:21,300

261
00:14:21,300 --> 00:14:29,500
반환 유형이 경우에는 여기 있어요
중간, 우리의 함수 이름의 q 및 우리

262
00:14:29,500 --> 00:14:31,360
매개 변수의 목록입니다.

263
00:14:31,360 --> 00:14:34,550
>> 그리고 데이터를 쓸 필요가 있습니다
당신이 원하는 매개 변수의 유형

264
00:14:34,550 --> 00:14:38,660
사용하거나 기능을하지 않는 다른
어떤 종류의 알

265
00:14:38,660 --> 00:14:41,650
매개 변수는 내가 접수한다.

266
00:14:41,650 --> 00:14:48,110
그래서,이 경우에, 우리가 원하는
우리의 입력으로하는 정수입니다.

267
00:14:48,110 --> 00:14:50,390
그럼 왜 우리는 기능을 사용할 수 있습니다?

268
00:14:50,390 --> 00:14:52,800
>> 우선, 조직을 위해 중대한.

269
00:14:52,800 --> 00:14:56,350
그들은으로 당신의 코드를 풀어 라
더 청크를 조직하게

270
00:14:56,350 --> 00:14:57,960
그것은 쉽게 읽을 수 있습니다.

271
00:14:57,960 --> 00:14:59,760
단순화.

272
00:14:59,760 --> 00:15:01,740
이는 설계에 적합합니다.

273
00:15:01,740 --> 00:15:04,570
당신은 코드의 조각을 읽는 경우
및 주요 기능은, 정말로

274
00:15:04,570 --> 00:15:07,750
정말 긴, 그것은 더 어려울 수도
무슨 일이 일어나고 있는지에 대한 이유.

275
00:15:07,750 --> 00:15:11,710
그래서 당신은 함수로 분해하면,
그것은 쉽게 읽을 수 있습니다.

276
00:15:11,710 --> 00:15:12,750
그리고 다시 - 능력.

277
00:15:12,750 --> 00:15:16,940
당신이 코드의 덩어리가있는 경우되고있어 그
호출 또는 여러 번 실행,

278
00:15:16,940 --> 00:15:20,690
대신 그 코드 10 번을 재 작성
메인 함수에서, 당신은 수도

279
00:15:20,690 --> 00:15:21,440
재사용하려고합니다.

280
00:15:21,440 --> 00:15:25,740
그리고 때마다 당신은 것을 사용할 필요가
코드 조각 함수를 호출합니다.

281
00:15:25,740 --> 00:15:30,550

282
00:15:30,550 --> 00:15:35,380
>> 그래서 지금 우리가 처음에 기억한다면,
우리는 또한 몇 가지 개념에 대해 이야기

283
00:15:35,380 --> 00:15:37,680
중 하나 쓰레딩된다.

284
00:15:37,680 --> 00:15:41,120
스레드는 다수의 개념
코드 시퀀스

285
00:15:41,120 --> 00:15:43,040
동시에 실행.

286
00:15:43,040 --> 00:15:47,490
그래서 다윗이 있었다 일 하나 다시 생각
너희들의 수 오프 카운트

287
00:15:47,490 --> 00:15:48,440
방에있는 사람입니다.

288
00:15:48,440 --> 00:15:50,550
>> 기본적으로 무슨 일이가는
에 너희들 모두가 있었다

289
00:15:50,550 --> 00:15:52,370
별도의 스레드를 실행할 수 있습니다.

290
00:15:52,370 --> 00:15:55,540
그리고 그 스레드가 함께오고 있었다
어떤 대답이든 얻을 수 있습니다.

291
00:15:55,540 --> 00:15:58,890
마찬가지로, 스크래치, 당신은 때를
스프라이트, 당신은 수도

292
00:15:58,890 --> 00:16:01,070
고양이와 개를 가지고있다.

293
00:16:01,070 --> 00:16:08,770
그리고 그들은 동시에 것
자신의 스크립트를 실행.

294
00:16:08,770 --> 00:16:10,020
즉, 스레딩의 예입니다.

295
00:16:10,020 --> 00:16:12,860

296
00:16:12,860 --> 00:16:18,000
>> 그리고 다른 개념였습니다
처음에 소개 된 이벤트였다.

297
00:16:18,000 --> 00:16:22,550
그리고 이벤트의 여러 부분 아르
코드들은 서로 통신한다.

298
00:16:22,550 --> 00:16:26,840
만약을 사용할 경우 스크래치, 이것은이었다
방송 및 제어 할 때 I

299
00:16:26,840 --> 00:16:29,500
블록을받을 수 있습니다.

300
00:16:29,500 --> 00:16:35,170
>> 또한, 문제 설정 4, 우리는 보았다
물론 이벤트 조금.

301
00:16:35,170 --> 00:16:38,250
너희들이 사용했을 수 있습니다
Gevent 라이브러리.

302
00:16:38,250 --> 00:16:42,450
그리고 함수가 있었다 waitForClick
하는 당신이 기다리고 있었다

303
00:16:42,450 --> 00:16:44,300
사용자는 클릭하십시오.

304
00:16:44,300 --> 00:16:47,870
그리고 당신의 클릭,이 경우 될 것이다
클릭에 대한 이벤트 및 대기 당신입니다

305
00:16:47,870 --> 00:16:49,120
이벤트 핸들러.

306
00:16:49,120 --> 00:16:53,690

307
00:16:53,690 --> 00:16:58,630
>> 또한, 귀하의 psets를을 걸쳐 실행
당신의 psets를 작업하면

308
00:16:58,630 --> 00:17:01,920
과 접촉했을 수도
이 명령의 일부.

309
00:17:01,920 --> 00:17:05,579
이것은 당신이에 입력 한 내용과 당신의
터미널 창 또는 어떤 창

310
00:17:05,579 --> 00:17:12,119
즉, 당신의 g 편집에 나타
기본적으로 컴퓨터를 이동합니다.

311
00:17:12,119 --> 00:17:19,440
>> 그래서 예를 들어, LS가 나열
디렉토리의 내용을 표시합니다.

312
00:17:19,440 --> 00:17:22,510
디렉토리에 새 폴더를 생성합니다.

313
00:17:22,510 --> 00:17:24,819
CD 디렉토리를 변경합니다.

314
00:17:24,819 --> 00:17:28,400
RM은, 제거, 파일을 삭제
또는 일부 디렉토리.

315
00:17:28,400 --> 00:17:31,050
그리고 디렉토리를 제거
디렉토리를 제거합니다.

316
00:17:31,050 --> 00:17:32,300
>> 청중 : [들리지?

317
00:17:32,300 --> 00:17:36,978

318
00:17:36,978 --> 00:17:38,370
>> SPEAKER 1 : 네, 그럼요.

319
00:17:38,370 --> 00:17:42,530

320
00:17:42,530 --> 00:17:46,040
죄송 해요, 질문이었다 당신이 경우
이 퍼팅 제안

321
00:17:46,040 --> 00:17:48,840
컨닝 페이퍼에.

322
00:17:48,840 --> 00:17:49,440
그것은 도움이 될 수.

323
00:17:49,440 --> 00:17:51,490
당신이 방에있는 경우에, 당신은 그것을 넣을 수 있습니다.

324
00:17:51,490 --> 00:17:56,170
또한 충분한 그냥 일반적으로 좋은
당신이 그것을 사용하는 경우 때문에 기억

325
00:17:56,170 --> 00:17:59,060
당신은 할 수 있습니다 만
이 기억이있다.

326
00:17:59,060 --> 00:18:02,750
즉, 당신의 인생을 더 쉽게 만들 수 있습니다.

327
00:18:02,750 --> 00:18:04,000
나는 당신의 질문에 대답 했습니까?

328
00:18:04,000 --> 00:18:10,528

329
00:18:10,528 --> 00:18:14,290
>> 그래서 지금, 우리는 조금 이야기
라이브러리에 대한 간략.

330
00:18:14,290 --> 00:18:18,570
그러나 두 가지 것들은 우리가 봤는데 그
지금까지 과정에서 아르 사용

331
00:18:18,570 --> 00:18:20,860
표준 I / O 및 CS50.

332
00:18:20,860 --> 00:18:25,410
사물의 어떤 종류의 포함되어 있습니다
표준 I / O 라이브러리?

333
00:18:25,410 --> 00:18:28,410
>> 네, 지금까지 우리의 printf를 사용했습니다.

334
00:18:28,410 --> 00:18:31,150
CS50, 우리는 getInt는 사용했습니다
하고있는 getString.

335
00:18:31,150 --> 00:18:37,200
그리고 데이터 형식 문자열은 또한 일어날
이 CS50 라이브러리에 선언합니다.

336
00:18:37,200 --> 00:18:40,250
우리는에 대해 깊이에서 조금 더 이야기 할 것
어떻게 라이브러리를 작동하고 어떻게

337
00:18:40,250 --> 00:18:41,870
코드의 나머지 부분과 상호 작용합니다.

338
00:18:41,870 --> 00:18:46,220
그러나 사람들은 두 가지 주요 것들이 우리
지금까지의 접촉왔다

339
00:18:46,220 --> 00:18:48,430
과정.

340
00:18:48,430 --> 00:18:50,050
>> 유형.

341
00:18:50,050 --> 00:18:58,120
이 얼마나 기억하기 좋은
각 유형은 방법이나 표현된다

342
00:18:58,120 --> 00:19:02,840
바이트 유형의 각 requires--

343
00:19:02,840 --> 00:19:04,990
int를 4 바이트; 문자, 1 바이트.

344
00:19:04,990 --> 00:19:06,550
주식 비율은 4 바이트입니다.

345
00:19:06,550 --> 00:19:07,782
이중 무엇입니까?

346
00:19:07,782 --> 00:19:09,032
>> 청중 : [들리지].

347
00:19:09,032 --> 00:19:11,398

348
00:19:11,398 --> 00:19:16,240
>> SPEAKER 1 : 네, 플로트
하지만 크기를 두 배로.

349
00:19:16,240 --> 00:19:17,150
어떤 긴 어떻습니까?

350
00:19:17,150 --> 00:19:18,400
>> 청중 : [들리지].

351
00:19:18,400 --> 00:19:21,614

352
00:19:21,614 --> 00:19:24,680
>> SPEAKER 1 : OK.

353
00:19:24,680 --> 00:19:25,410
긴은 무엇입니까?

354
00:19:25,410 --> 00:19:26,660
>> 청중 : [들리지].

355
00:19:26,660 --> 00:19:29,400

356
00:19:29,400 --> 00:19:31,450
>> SPEAKER 1 : 그래, int를 두 배로.

357
00:19:31,450 --> 00:19:34,240

358
00:19:34,240 --> 00:19:34,705
예.

359
00:19:34,705 --> 00:19:36,100
>> 청중 : [들리지].

360
00:19:36,100 --> 00:19:38,030
>> SPEAKER 1 : 긴 [INAUDIBLE].

361
00:19:38,030 --> 00:19:41,860
그리고 오래 오래은 두 배입니다.

362
00:19:41,860 --> 00:19:42,814
>> 청중 : 아니, 아니.

363
00:19:42,814 --> 00:19:47,107
긴은 INT입니다.

364
00:19:47,107 --> 00:19:50,910
이 아키텍처에 따라 달라집니다
전에 [INAUDIBLE]

365
00:19:50,910 --> 00:19:52,922
및 INT는 동일한 크기를 갖는다.

366
00:19:52,922 --> 00:19:54,172
[INAUDIBLE].

367
00:19:54,172 --> 00:19:58,841

368
00:19:58,841 --> 00:20:00,920
>> SPEAKER 1 : 그래서 오랫동안
INT는 동일합니다.

369
00:20:00,920 --> 00:20:02,943
그리고 오래 오래
이중 INT입니다.

370
00:20:02,943 --> 00:20:03,910
쿨.

371
00:20:03,910 --> 00:20:05,550
그리고 마지막 유형은 무엇입니까?

372
00:20:05,550 --> 00:20:06,510
>> 청중 : 포인터.

373
00:20:06,510 --> 00:20:10,350
>> SPEAKER 1 : 네, 그래서 우리는 배웠다
포인터에 대해 조금.

374
00:20:10,350 --> 00:20:14,015
그리고 관계없이 포인터가 무엇인지
그것이로 ... 가리키는 문자 스타가 될 수있다

375
00:20:14,015 --> 00:20:15,880
또는 INT star--

376
00:20:15,880 --> 00:20:20,530
항상 포인터 4 바이트입니다.

377
00:20:20,530 --> 00:20:21,633
그에 대한 질문?

378
00:20:21,633 --> 00:20:22,116
네?

379
00:20:22,116 --> 00:20:24,531
>> 청중 : [들리지?

380
00:20:24,531 --> 00:20:29,530
>> SPEAKER 1 : 그래서 길고 INT가
이 CS50 기기에서 동일한.

381
00:20:29,530 --> 00:20:32,302
>> 청중 : 어플라이언스는 완전히 아르
교환.

382
00:20:32,302 --> 00:20:33,510
>> SPEAKER 1 : 그래.

383
00:20:33,510 --> 00:20:36,610
그럼이 오래 오래 두 번 정수이다.

384
00:20:36,610 --> 00:20:39,250
>> 청중 :이 32 비트입니까?

385
00:20:39,250 --> 00:20:40,620
>> SPEAKER 1 : 32 비트, 그래.

386
00:20:40,620 --> 00:20:43,572
>> 청중 : 그래서 [들리지?

387
00:20:43,572 --> 00:20:46,790
>> SPEAKER 1 : 예, 그것은하지 않는 경우
명시 적으로, 당신 말

388
00:20:46,790 --> 00:20:47,870
32 비트를 가정해야한다.

389
00:20:47,870 --> 00:20:50,040
>> 청중 : 그것은 뭔가를 말할 것입니다
가정 등

390
00:20:50,040 --> 00:20:51,498
장비 등의 건축입니다.

391
00:20:51,498 --> 00:20:58,800

392
00:20:58,800 --> 00:21:01,710
64 비트, 유일한 것들에 대한 그
변화는 정수 (Long) 및 포인터입니다.

393
00:21:01,710 --> 00:21:05,614
둘 다 [INAUDIBLE].

394
00:21:05,614 --> 00:21:06,590
>> SPEAKER 1 : 예?

395
00:21:06,590 --> 00:21:07,566
>> 청중 : 질문.

396
00:21:07,566 --> 00:21:10,982
연습 퀴즈 중 하나 그래서,
이 서명 int에 대해 묻는다.

397
00:21:10,982 --> 00:21:15,374
그래서 어떻게 결정된다
INT [INAUDIBLE]에서?

398
00:21:15,374 --> 00:21:18,140
>> SPEAKER 1 : 부호
에는 4 바이트입니다.

399
00:21:18,140 --> 00:21:21,172
그러나 서명에 대해 다른 무엇인가
정수 및 서명 int?

400
00:21:21,172 --> 00:21:22,422
>> 청중 : [들리지].

401
00:21:22,422 --> 00:21:24,868

402
00:21:24,868 --> 00:21:25,630
>> SPEAKER 1 : 오른쪽.

403
00:21:25,630 --> 00:21:27,570
하나는 음의 값을 나타낼 수 있습니다.

404
00:21:27,570 --> 00:21:28,580
하지만 어떻게 그 일을합니까?

405
00:21:28,580 --> 00:21:30,536
>> 청중 : [들리지].

406
00:21:30,536 --> 00:21:36,370
>> SPEAKER 1 : 그래, 한 저장
비트는 기호를 나타냅니다.

407
00:21:36,370 --> 00:21:40,910

408
00:21:40,910 --> 00:21:45,040
서명은 하나의 비트를 가지
부호를 나타냅니다.

409
00:21:45,040 --> 00:21:48,886
그리고 부호는 모든 긍정이다.

410
00:21:48,886 --> 00:21:50,365
>> 청중 : OK.

411
00:21:50,365 --> 00:21:54,230
그래서 당신은 두 번이라고 말할
플로트 크기의 두 배?

412
00:21:54,230 --> 00:21:58,202
>> SPEAKER 1 : 이중 두 배
플로트의 크기, 예.

413
00:21:58,202 --> 00:22:01,639
>> 청중 : 포인터를 수행하는 방법
긴 긴 [INAUDIBLE]?

414
00:22:01,639 --> 00:22:06,058

415
00:22:06,058 --> 00:22:10,870
>> SPEAKER 1 : 어떻게하는지 그래서 질문
긴 long-- 포인터

416
00:22:10,870 --> 00:22:13,800
방법은 만 4 바이트 때입니다
그 8 바이트 오래 오래.

417
00:22:13,800 --> 00:22:17,310
그래서 포인터입니다 기억,
본질적으로, 아주 기본 가치.

418
00:22:17,310 --> 00:22:19,046
>> 청중 : [들리지].

419
00:22:19,046 --> 00:22:22,670
>> SPEAKER 1 : 네, 포인터
단지 메모리 위치입니다.

420
00:22:22,670 --> 00:22:28,040
그래서 얼마나 많은 공간을 중요하지 않습니다
그 포인터가 가리키는.

421
00:22:28,040 --> 00:22:32,060
그것은 단지 추적하기 위해 4 바이트를 필요
해당 메모리 위치의.

422
00:22:32,060 --> 00:22:34,760

423
00:22:34,760 --> 00:22:36,010
다른 질문?

424
00:22:36,010 --> 00:22:39,800

425
00:22:39,800 --> 00:22:41,050
쿨.

426
00:22:41,050 --> 00:22:42,920

427
00:22:42,920 --> 00:22:47,460
>> 그래서 마지막으로 내가 가진
표준 출력이다.

428
00:22:47,460 --> 00:22:51,020
당신은 자주 사용해야
당신이 기억할 수있을만큼.

429
00:22:51,020 --> 00:22:54,800
우리가 사용하는 경우 그러나 이것은입니다
printf의 예를 들어.

430
00:22:54,800 --> 00:22:59,260
그리고 우리는이 자리를 가질 수
형식 코드라고했다.

431
00:22:59,260 --> 00:23:03,910
>> 그래서 인터넷 용 %의 C 숯불 퍼센트 나,
우리는 또한 퍼센트 D를 사용할 수 있습니다.

432
00:23:03,910 --> 00:23:05,130
이 같은 일입니다.

433
00:23:05,130 --> 00:23:08,200
그러나, 일반적으로 CS50의 우리
%의 난을 사용하려고합니다.

434
00:23:08,200 --> 00:23:09,860
플로트에 대한 백분율 바.

435
00:23:09,860 --> 00:23:15,620
오래 오래 된 백분율 LD와
문자열 퍼센트의.

436
00:23:15,620 --> 00:23:18,550
>> 마찬가지로, 우리는 몇 가지를 사용하고있다
이러한 이스케이프 시퀀스.

437
00:23:18,550 --> 00:23:22,431
예를 들어, 백 슬래시는 N 새로운 라인.

438
00:23:22,431 --> 00:23:26,910
이렇게하면 포맷 할 때 그냥입니다
인쇄 F에 대한 코드입니다.

439
00:23:26,910 --> 00:23:27,260
네?

440
00:23:27,260 --> 00:23:28,906
>> 대상 : %의 d는 무엇입니다?

441
00:23:28,906 --> 00:23:31,850
>> SPEAKER 1 : 그래서 질문
%의 D는 무엇입니다?

442
00:23:31,850 --> 00:23:33,270
퍼센트 (D)는 정수입니다.

443
00:23:33,270 --> 00:23:37,392
비율 D와 %는 내가 동일합니다.

444
00:23:37,392 --> 00:23:41,130
>> 청중 : 사이의 차이는 무엇
백 슬래시 n 및 백 슬래시 R?

445
00:23:41,130 --> 00:23:45,300
>> SPEAKER 1 : 그래서 질문은 무엇입니다
백래쉬 N과의 차이

446
00:23:45,300 --> 00:23:48,615
반발 R?

447
00:23:48,615 --> 00:23:50,906
나는 백 슬래시 R 생각은 ...

448
00:23:50,906 --> 00:23:54,340
>> 청중 : 그래서 백 슬래시 연구 단지 의미
줄의 처음으로 돌아갑니다

449
00:23:54,340 --> 00:23:56,670
실제로 새로운 라인에 가지 않고.

450
00:23:56,670 --> 00:24:01,000
그래서 당신은 백 슬래시 R을 인쇄하고있는 경우
라인의 처음으로 돌아가

451
00:24:01,000 --> 00:24:04,005
당신은 당신이 덮어 쓰기, 더 많은 물건을 인쇄
에 이미 물건

452
00:24:04,005 --> 00:24:04,390
[INAUDIBLE].

453
00:24:04,390 --> 00:24:06,725
반면, n은 실제로 새로 이동
라인은 [INAUDIBLE]로 이동합니다.

454
00:24:06,725 --> 00:24:10,525

455
00:24:10,525 --> 00:24:13,915
>> SPEAKER 1 : 글쎄, 다른 질문?

456
00:24:13,915 --> 00:24:15,430
좋아.

457
00:24:15,430 --> 00:24:18,617
나는에 그것을 넘겨거야
계속 댄.

458
00:24:18,617 --> 00:24:25,078
>> [박수]

459
00:24:25,078 --> 00:25:08,814

460
00:25:08,814 --> 00:25:09,720
>> DAN : 좋아요.

461
00:25:09,720 --> 00:25:18,590
그래서 다른 다양한 얘기 할 것
아르 클래스에서 아이디어의 범위

462
00:25:18,590 --> 00:25:23,220
대략 일주일에 두 대표
주일의 시작은 오프 시작

463
00:25:23,220 --> 00:25:28,690
단지 방법입니다 주조와
특정 유형의 값으로서 취급

464
00:25:28,690 --> 00:25:30,830
다른 타입의 값.

465
00:25:30,830 --> 00:25:34,110
그래서 우리는 문자로이 작업을 수행 할 수 있습니다
정수, 정수로 수레, 그리고

466
00:25:34,110 --> 00:25:35,360
긴 정수 (Long)은 두 배로.

467
00:25:35,360 --> 00:25:38,170

468
00:25:38,170 --> 00:25:44,500
>> 이러한 모든 것들이 여러 가지 방법으로 사용할 수 있습니다
일부 숫자 값의 처리

469
00:25:44,500 --> 00:25:48,370
다른 같은 마이너스 문자
숫자 값입니다.

470
00:25:48,370 --> 00:25:54,480
몇 가지 문제는이의에있다 그래서
당신이 캐스팅 할 때 온다 물론,

471
00:25:54,480 --> 00:25:57,860
정수로 플로트 같은 것들.

472
00:25:57,860 --> 00:26:00,500
그래서이 이상하다.

473
00:26:00,500 --> 00:26:03,170
우리는 1.31이다 플로트 있습니다.

474
00:26:03,170 --> 00:26:05,220
우리는 만 곱.

475
00:26:05,220 --> 00:26:08,380
그리고 우리는 int로서 인쇄 할 수 있습니다.

476
00:26:08,380 --> 00:26:09,630
이 출력은 무엇입니까?

477
00:26:09,630 --> 00:26:11,600

478
00:26:11,600 --> 00:26:14,020
10,000 시간 1.31.

479
00:26:14,020 --> 00:26:18,761
그래서 13000, 추측인가요?

480
00:26:18,761 --> 00:26:20,685
>> 청중 : 그것은 만 생각합니다.

481
00:26:20,685 --> 00:26:24,234
>> DAN : 그래서 만하여 곱 해요
나는 그것을 주조있어 전.

482
00:26:24,234 --> 00:26:25,202
>> 청중 : 아.

483
00:26:25,202 --> 00:26:27,622
이 한 구를하지 않을까요
일부 공 번호?

484
00:26:27,622 --> 00:26:29,270
>> DAN : 당신은 몇 가지 이상한 숫자가있을 수 있습니다.

485
00:26:29,270 --> 00:26:32,410

486
00:26:32,410 --> 00:26:37,670
그래서 오른쪽은 1.3 시간 만입니다.

487
00:26:37,670 --> 00:26:40,040
그래서 13000입니다.

488
00:26:40,040 --> 00:26:41,313
그리고이 여분의 weird--

489
00:26:41,313 --> 00:26:42,160
>> 관객 : 13,100.

490
00:26:42,160 --> 00:26:42,650
>> DAN : 13100.

491
00:26:42,650 --> 00:26:44,910
롭 주셔서 감사합니다.

492
00:26:44,910 --> 00:26:46,610
그리고이 여분의 weirdness--

493
00:26:46,610 --> 00:26:48,060
이 9,9--

494
00:26:48,060 --> 00:26:53,860
단순히이 캐스팅 때문에
결국 아래로 위치를 반올림

495
00:26:53,860 --> 00:26:55,394
그것은 필요가 없습니다.

496
00:26:55,394 --> 00:26:55,871
그래.

497
00:26:55,871 --> 00:26:58,256
>> 청중 : 주조 발생
다른 건 후?

498
00:26:58,256 --> 00:27:03,865
>> 댄 : 때문에 그래서 나는 그것을 인쇄이가
그 전에 곱셈을 수행

499
00:27:03,865 --> 00:27:05,230
이 캐스팅을 수행합니다.

500
00:27:05,230 --> 00:27:06,140
>> 청중 : [들리지].

501
00:27:06,140 --> 00:27:11,350
>> DAN : 나는, 처음 캐스팅 것이라고 생각
그래, 만하는 것입니다.

502
00:27:11,350 --> 00:27:12,610
다른 건?

503
00:27:12,610 --> 00:27:13,330
쿨.

504
00:27:13,330 --> 00:27:16,344
그래서이 13099입니다.

505
00:27:16,344 --> 00:27:17,840
그 이유는 무엇입니까?

506
00:27:17,840 --> 00:27:18,900
부정확.

507
00:27:18,900 --> 00:27:21,020
>> 수레는 완벽하지.

508
00:27:21,020 --> 00:27:27,550
그들은 단지까지의 숫자를 나타낼 수 있습니다
유효 숫자의 특정 번호입니다.

509
00:27:27,550 --> 00:27:35,120
우리는 8 시그 무화과를 인쇄 그래서 경우
이 Float, 우리는 가지를 얻을 수

510
00:27:35,120 --> 00:27:36,800
못생긴 찾고 번호.

511
00:27:36,800 --> 00:27:45,580
그리고 그 때문에 1.31 정확하게 할 수 없습니다
간단하게 표현 될

512
00:27:45,580 --> 00:27:49,000
기계 두의 힘.

513
00:27:49,000 --> 00:27:53,530
그것은 가장 가까운 복용 끝 그래서
어떤이 끝 추측

514
00:27:53,530 --> 00:27:55,710
약간 낮은 것을.

515
00:27:55,710 --> 00:27:57,730
이해가가?

516
00:27:57,730 --> 00:27:59,110
확인을 클릭합니다.

517
00:27:59,110 --> 00:28:05,840
>> 지금,이 전환의 다른 방법
조건문을 다하고

518
00:28:05,840 --> 00:28:09,900
우리는 하나의 변수에 대해 신경.

519
00:28:09,900 --> 00:28:16,570
그래서이 특정 예에서 우리는있어
사용자로부터 정수를 받고.

520
00:28:16,570 --> 00:28:21,070
그리고 우리는보고있다
그 정수는 무엇인지.

521
00:28:21,070 --> 00:28:23,500
아마, 그것은 수있어
하나 넷 사이.

522
00:28:23,500 --> 00:28:24,800
즉, 우리가 요구하는지입니다.

523
00:28:24,800 --> 00:28:28,450
>> 그래서 당신의 스위치를 할
변수 이름.

524
00:28:28,450 --> 00:28:34,290
그럼 당신은 가능한 사례를 설정
가 될 수있다 값.

525
00:28:34,290 --> 00:28:37,730
그래서 일을 구분, 그것은 낮은 말할.

526
00:28:37,730 --> 00:28:41,080
그리고 당신은 나가 휴식
스위치 상태이므로

527
00:28:41,080 --> 00:28:43,270
당신은 계속하지 않습니다.

528
00:28:43,270 --> 00:28:44,830
>> 다음 case--에서

529
00:28:44,830 --> 00:28:46,940
그래서 경우에이 케이스 셋 ...

530
00:28:46,940 --> 00:28:51,920
이 경우이 있다면 그것은 단지로 아래로 떨어진다
그와 같이보고 코드의 첫 번째 행

531
00:28:51,920 --> 00:28:55,400
그것은 휴식을 볼 때까지 셋을 구별.

532
00:28:55,400 --> 00:29:00,430
그래서 이유는 당신이에 경우 하나를 얻을
만 인쇄 낮은입니다 I 때문에

533
00:29:00,430 --> 00:29:01,890
여기이 휴식을해야합니다.

534
00:29:01,890 --> 00:29:05,360
I 경우, 말,이 break-- 무시
나는이 breakaway--을 던졌다 경우

535
00:29:05,360 --> 00:29:09,740
그것은 낮은 인쇄 것이고, 그때는 것
중간을 인쇄 한 다음 휴식 것입니다.

536
00:29:09,740 --> 00:29:12,200
>> 휴식은 중요한 부분입니다 그래서
의 조건을 전환

537
00:29:12,200 --> 00:29:14,340
그들은이 있어야합니다.

538
00:29:14,340 --> 00:29:20,070
명시 적으로 언급되지 않은 모든 경우
기본적으로 처리됩니다

539
00:29:20,070 --> 00:29:26,645
스위치의 경우 캐스팅해야합니다.

540
00:29:26,645 --> 00:29:31,363
>> 청중 : 그래서 1, 2, 3,
4는 N 것입니까?

541
00:29:31,363 --> 00:29:33,310
>> DAN : N이 될 수있는 값.

542
00:29:33,310 --> 00:29:34,654
예.

543
00:29:34,654 --> 00:29:35,146
그래?

544
00:29:35,146 --> 00:29:37,606
>> 청중 : 그래서 당신이
[들림] 그?

545
00:29:37,606 --> 00:29:44,002

546
00:29:44,002 --> 00:29:46,830
>> DAN : 당신은 다음 낮은 인쇄 및 것
이 가운데를 인쇄 할

547
00:29:46,830 --> 00:29:47,400
다음은 휴식 것입니다.

548
00:29:47,400 --> 00:29:50,244
>> 관객 : 왜 인쇄 할 것
중간 경우 [INAUDIBLE]?

549
00:29:50,244 --> 00:29:54,036

550
00:29:54,036 --> 00:30:00,550
>> DAN : 경우에 따라 그래서 모든
휴식 시간에 해당하기 전에.

551
00:30:00,550 --> 00:30:09,390
그래서 경우 ​​하나의 인쇄는 아래의 경우는
같은 일이 다음 인쇄합니다.

552
00:30:09,390 --> 00:30:09,890
그래?

553
00:30:09,890 --> 00:30:11,140
>> 청중 : [들리지?

554
00:30:11,140 --> 00:30:15,890

555
00:30:15,890 --> 00:30:22,170
>> DAN : 그래서이 숫자는 특정입니다
값이이 변수

556
00:30:22,170 --> 00:30:23,420
오른쪽 걸릴 수 있습니다?

557
00:30:23,420 --> 00:30:26,740

558
00:30:26,740 --> 00:30:28,490
그 의미가 있습니까?

559
00:30:28,490 --> 00:30:28,990
그래.

560
00:30:28,990 --> 00:30:31,490
>> 청중 : [들리지?

561
00:30:31,490 --> 00:30:34,130
>> DAN : 예, 경우이 인쇄 것
중간 후 휴식.

562
00:30:34,130 --> 00:30:35,380
>> 청중 : [들리지?

563
00:30:35,380 --> 00:30:37,954

564
00:30:37,954 --> 00:30:40,050
>> DAN : 어떤 생각?

565
00:30:40,050 --> 00:30:43,855
어떤 다른 데이터 유형
당신은 전환 할 수 있습니다?

566
00:30:43,855 --> 00:30:46,320
>> 청중 : 당신은 전환 할 수 있습니다
모든 데이터 유형을 통해.

567
00:30:46,320 --> 00:30:50,905
그러나 그것은 단지 문자 이상 아무것도 의미
및 정수와 같은 물건 때문에

568
00:30:50,905 --> 00:30:55,600
당신은 포인터를 통해 전환하는 경우
그것은 정말 이해가되지 않습니다

569
00:30:55,600 --> 00:30:59,555
심지어하자 경우, 부하를 통해 전환
당신은, 부동 점의, 그렇게

570
00:30:59,555 --> 00:31:02,840
정밀도, 당신은 정말 않을 것
어쨌든 그렇게하고 싶다.

571
00:31:02,840 --> 00:31:07,320
그래서 꽤 많은 단지 정수와
같은 문자와 재료.

572
00:31:07,320 --> 00:31:12,360
>> DAN : 당신이 명시 적으로있을 때 그래, 그건
당신이 알고있는 값이, 내 생각이 될 수 있습니다

573
00:31:12,360 --> 00:31:14,250
하는 스위치가 실제로 유용합니다.

574
00:31:14,250 --> 00:31:17,094

575
00:31:17,094 --> 00:31:18,990
좋은?

576
00:31:18,990 --> 00:31:21,370
확인을 클릭합니다.

577
00:31:21,370 --> 00:31:26,180
>> 범위가 선언 된 범위
변수는 확장된다.

578
00:31:26,180 --> 00:31:32,190
내가 가진 코드의이 작은 덩어​​리에 따라서,
이 오류로 가득 할 것이다.

579
00:31:32,190 --> 00:31:41,450
그리고 그 이유는이 정수를 선언하다
내가 루프에 대한이의 범위 내에서.

580
00:31:41,450 --> 00:31:46,390
그리고 나는 것을 참조하기 위해 노력하고있어
내가 루프 범위에 대한 그 이외의.

581
00:31:46,390 --> 00:31:50,330
>> 그러니까 기본적으로, 당신은 범위에 대해 생각 할 수 있습니다
당신이 선언 더없이

582
00:31:50,330 --> 00:31:59,750
중괄호 세트 안에 만
그 중괄호 내에 존재합니다.

583
00:31:59,750 --> 00:32:04,990
그리고 당신은 시도하고 그 변수를 사용하는 경우
그 중괄호의 외부, 당신은거야

584
00:32:04,990 --> 00:32:08,356
컴파일러에서 오류가 발생합니다.

585
00:32:08,356 --> 00:32:08,812
그래?

586
00:32:08,812 --> 00:32:09,724
>> 청중 : 그래서이 하나가 작동하지 않는 이유는 무엇입니까?

587
00:32:09,724 --> 00:32:11,790
>> DAN :이 예, 작동하지 않습니다.

588
00:32:11,790 --> 00:32:17,190

589
00:32:17,190 --> 00:32:18,660
문자열.

590
00:32:18,660 --> 00:32:19,780
문자열 문자 *.

591
00:32:19,780 --> 00:32:22,250
그들은 정확히 같은거야.

592
00:32:22,250 --> 00:32:25,540
그들은 단지 문자에 대한 포인터입니다.

593
00:32:25,540 --> 00:32:33,000
그리고 당신이 가진 모든 문자열은 끝나야한다
단지입니다 백 슬래시 제로로

594
00:32:33,000 --> 00:32:34,410
C 규칙.

595
00:32:34,410 --> 00:32:36,680
>> 그것은 NULL 종료라고합니다.

596
00:32:36,680 --> 00:32:39,050
그리고 NULL--

597
00:32:39,050 --> 00:32:41,670
자본 N, 자본 U, 자본
L, 자본 전 ...

598
00:32:41,670 --> 00:32:44,290
와 동일하지
NULL 종료.

599
00:32:44,290 --> 00:32:46,640
이 포인터입니다.

600
00:32:46,640 --> 00:32:48,280
이것은 문자입니다.

601
00:32:48,280 --> 00:32:49,530
그들은 매우 구분된다.

602
00:32:49,530 --> 00:32:50,200
그것을 기억하십시오.

603
00:32:50,200 --> 00:32:52,320
아마, 퀴즈에있을 것입니다.

604
00:32:52,320 --> 00:32:54,040
나는 퀴즈를 보지 못했어요.

605
00:32:54,040 --> 00:32:57,880

606
00:32:57,880 --> 00:32:58,840
그래?

607
00:32:58,840 --> 00:33:01,232
>> 청중 : 그래서 NULL 포인터, 말입니까?

608
00:33:01,232 --> 00:33:01,995
>> DAN : 예.

609
00:33:01,995 --> 00:33:05,170
>> 청중 : 무엇 [들리지]합니까?

610
00:33:05,170 --> 00:33:10,050
>> DAN은 : 말을하면, malloc을 호출 할 때를
얻을 수있는 메모리가 충분하지 않습니다

611
00:33:10,050 --> 00:33:14,400
당신이 무엇을 요구하고 크기,
의 malloc는 NULL을 반환합니다.

612
00:33:14,400 --> 00:33:19,550
함수가있을 때마다 그것은 기본적이다
포인터를 반환하는데, 당신

613
00:33:19,550 --> 00:33:22,600
NULL 때문에에 대해 확인해야
NULL은 꽤 소용이입니다

614
00:33:22,600 --> 00:33:25,260
그것은 일종의 가비지 값입니다.

615
00:33:25,260 --> 00:33:27,050
그것은 지금까지 포인터를 이동하면서 0입니다.

616
00:33:27,050 --> 00:33:29,630

617
00:33:29,630 --> 00:33:32,250
>> 할 때마다이 함수를 호출
그 포인터를 반환한다.

618
00:33:32,250 --> 00:33:35,960
당신은 것으로 확인하려는거야
그 포인터가 NULL이 아닌지 확인

619
00:33:35,960 --> 00:33:37,760
NULL은 매우 일반적이기 때문이다.

620
00:33:37,760 --> 00:33:40,160
그것은 쓰레기 반환의 일종.

621
00:33:40,160 --> 00:33:44,902
뭔가를 잘하지 않은 경우 그래서,
단지 대신 NULL을 반환합니다.

622
00:33:44,902 --> 00:33:45,898
>> 청중 : [들리지?

623
00:33:45,898 --> 00:33:48,922
>> DAN : 네, 그리고이 있습니다.

624
00:33:48,922 --> 00:33:51,750
>> 청중 : [들리지?

625
00:33:51,750 --> 00:33:52,800
>> DAN :이로 철자.

626
00:33:52,800 --> 00:33:54,150
그것은 NULL 종료합니다.

627
00:33:54,150 --> 00:33:56,560
그것은 소문자 N-U-L-L 경우이다
당신은 그것을 맞춤법 검사를하고 있습니다.

628
00:33:56,560 --> 00:33:59,860
>> 청중 : 그리고 난 그냥 갔다
다시 그것을 시험했다.

629
00:33:59,860 --> 00:34:03,010
그리고 당신은 부동 소수점을 넣어하려고하면
스위치에 값, 그것은 당신을 소리 것

630
00:34:03,010 --> 00:34:05,916
말, 문은 식을 필요로
정수 유형의.

631
00:34:05,916 --> 00:34:07,166
>> DAN : 거기 당신은 간다.

632
00:34:07,166 --> 00:34:09,639

633
00:34:09,639 --> 00:34:12,246
하지만 그래, 문제는 다시 무엇인가?

634
00:34:12,246 --> 00:34:13,496
>> 청중 : [들리지?

635
00:34:13,496 --> 00:34:16,150

636
00:34:16,150 --> 00:34:23,679
>> DAN : 그래서 자본 N, 자본 U, 자본
L은 자본 L 실제 C의 것입니다.

637
00:34:23,679 --> 00:34:29,719
그것은 NULL 포인터이며 것
그러한으로 처리.

638
00:34:29,719 --> 00:34:33,530
당신은 이제까지 시도하고 철자하지 않습니다
NULL 문자 및 참조

639
00:34:33,530 --> 00:34:35,630
이 이외의 방법.

640
00:34:35,630 --> 00:34:36,610
그래?

641
00:34:36,610 --> 00:34:42,490
>> 관객 : 그래서 최대는 char 반환 또는
노트에 뭔가, 그것은 것

642
00:34:42,490 --> 00:34:43,960
동일한 기능을 구현
[INAUDIBLE]로?

643
00:34:43,960 --> 00:34:50,655

644
00:34:50,655 --> 00:34:54,949
>> 청중 : 그래서 당신이 언급하는
에서는 GetChar에서 문자 최대를 반환하거나,

645
00:34:54,949 --> 00:34:55,444
무엇이든 그것은 무엇입니까?

646
00:34:55,444 --> 00:34:55,940
>> 청중 : 그래.

647
00:34:55,940 --> 00:34:58,620
>> 청중 : 네, 일반적으로 너무
그 모든 것들에 대한 용어

648
00:34:58,620 --> 00:34:59,920
센티넬 값입니다.

649
00:34:59,920 --> 00:35:03,640
그래서의 getInt에서 INT 최대를 반환 등
과에서는 GetChar에서 문자 최대, 그것은이다

650
00:35:03,640 --> 00:35:06,010
경우, 모든 권리, 같이 있어야
이러한 일들이 우리에게 돌아오고 있습니다

651
00:35:06,010 --> 00:35:07,210
문제가 발생했습니다.

652
00:35:07,210 --> 00:35:09,950
>> 포인터를 들어, 우리는이 일이
이 감시 값이 모두

653
00:35:09,950 --> 00:35:10,750
시 동의합니다.

654
00:35:10,750 --> 00:35:13,210
그리고 이것은 당신이 반환 것입니다
일이 잘못 갈 때.

655
00:35:13,210 --> 00:35:15,910
그래서 문자 최대 우리가 사용하고있는 것입니다
뭔가를 표현하기

656
00:35:15,910 --> 00:35:18,100
NULL 또는에서는 GetChar 등을들 수있다.

657
00:35:18,100 --> 00:35:23,420
>> 청중 : 당신 getchar가를 테스트하는 경우에 따라서,
당신은 NULL을 넣을 수 있을까?

658
00:35:23,420 --> 00:35:23,910
그 차이를 만들까요?

659
00:35:23,910 --> 00:35:25,400
>> DAN : 당신은 그냥 NULL을 확인하지 못했습니다.

660
00:35:25,400 --> 00:35:30,130
당신은 때문에 문자 최대를 확인해야 할 것이다
함수의 반환 값은

661
00:35:30,130 --> 00:35:35,416
문자가 아닌 포인터.

662
00:35:35,416 --> 00:35:35,888
그래?

663
00:35:35,888 --> 00:35:38,248
>> 청중 :이 질문은 묻는다
문자열의 길이.

664
00:35:38,248 --> 00:35:40,136
NULL 문자를 포함이됩니까?

665
00:35:40,136 --> 00:35:41,000
>> DAN : 아니오

666
00:35:41,000 --> 00:35:45,930
그리고 그 방법 문자열 길이 사실이다
이 통과하기 때문에 중지 알고

667
00:35:45,930 --> 00:35:49,070
문자의 배열까지
그것은 NULL 문자를 볼 수 있습니다.

668
00:35:49,070 --> 00:35:51,030
그리고 모든처럼,
좋아, 내가 다 했어.

669
00:35:51,030 --> 00:35:52,130
>> 청중 : [들리지] 오?

670
00:35:52,130 --> 00:35:53,990
>> DAN : 안녕하세요 오 될 것입니다.

671
00:35:53,990 --> 00:35:55,240
네.

672
00:35:55,240 --> 00:35:59,580

673
00:35:59,580 --> 00:36:02,880
그래서 배열은 연속
메모리 블록.

674
00:36:02,880 --> 00:36:08,480
그들은 말에 즉시 액세스 할 수 있습니다
곱슬에, 배열의 이름을 지정하고 다음

675
00:36:08,480 --> 00:36:16,720
당신이 가고 원하는 인덱스 중괄호,
이들은 통해 제로에서 인덱싱하는 것

676
00:36:16,720 --> 00:36:20,100
한 마이너스 배열의 길이.

677
00:36:20,100 --> 00:36:23,070
>> 그리고는의 형식에 의해 선언되고
당신이에 저장하는 것은

678
00:36:23,070 --> 00:36:29,750
어레이, 어레이의 이름 다음
어떤 크기가 해당 배열이다.

679
00:36:29,750 --> 00:36:36,660
그래서이 길이의 문자 배열이다
이 값이 육.

680
00:36:36,660 --> 00:36:42,050

681
00:36:42,050 --> 00:36:42,700
그래?

682
00:36:42,700 --> 00:36:43,950
>> 청중 : [들리지?

683
00:36:43,950 --> 00:36:47,980

684
00:36:47,980 --> 00:36:48,460
>> DAN : 그래.

685
00:36:48,460 --> 00:36:51,340
>> 청중 : [들리지?

686
00:36:51,340 --> 00:36:56,700
>> DAN : 당신은 무슨 일이있는 경우
배열에 이미했다.

687
00:36:56,700 --> 00:37:02,260
그래서 대신이 지정 수로,
의 말, 문자, 어떤 이름 당신의

688
00:37:02,260 --> 00:37:12,200
배열이 빈 괄호 곱슬 동일입니다
H 쉼표 E 쉼표 L 쉼표 L 쉼표를 지탱

689
00:37:12,200 --> 00:37:16,290
O 콤마 NULL 문자
와 중괄호.

690
00:37:16,290 --> 00:37:18,180
그것도 선언으로 작동합니다.

691
00:37:18,180 --> 00:37:20,886
>> 청중 : [들리지?

692
00:37:20,886 --> 00:37:23,110
>> DAN : 그럼 당신이 필요합니다
크기는 이미했다.

693
00:37:23,110 --> 00:37:23,896
>> 청중 : [들리지?

694
00:37:23,896 --> 00:37:25,146
>> DAN : 예.

695
00:37:25,146 --> 00:37:30,114

696
00:37:30,114 --> 00:37:32,420
좋아요.

697
00:37:32,420 --> 00:37:36,430
명령 줄 인수의 방법입니다
사용자로의 입력을 받고

698
00:37:36,430 --> 00:37:39,380
주요 인수.

699
00:37:39,380 --> 00:37:40,600
주요 2 개의 인수를 취하는.

700
00:37:40,600 --> 00:37:47,680
되고있는 인수의 수
명령 라인을 따라 전달

701
00:37:47,680 --> 00:37:55,340
문자열 벡터 또는 문자열 배열
모든 인수의.

702
00:37:55,340 --> 00:38:07,840
>> 그래서, 말, 같은 함수를 호출 한 경우
한 공간이 공간을 세 밖으로 점,

703
00:38:07,840 --> 00:38:10,110
는 argc는 4 것입니다.

704
00:38:10,110 --> 00:38:17,370
그리고 argv에 공은 밖으로 점 것입니다.

705
00:38:17,370 --> 00:38:19,130
Argv1는 일이 될 것이다.

706
00:38:19,130 --> 00:38:23,030
argv2 2 argv3이 될 것입니다
3, 특정 경우에.

707
00:38:23,030 --> 00:38:23,310
그래?

708
00:38:23,310 --> 00:38:25,400
>> 청중 : [들리지?

709
00:38:25,400 --> 00:38:34,010
>> DAN : 배열의 마지막 요소
배열 길이는 argc이므로 플러스

710
00:38:34,010 --> 00:38:41,050
하에 중 하나, 마지막 요소
NULL 포인터입니다.

711
00:38:41,050 --> 00:38:42,580
그것은는 argc 플러스 1입니다.

712
00:38:42,580 --> 00:38:46,210

713
00:38:46,210 --> 00:38:52,150
난 그냥, 그것을했다 경우에 따라서
0 argv를 될 것은 밖으로 점이다.

714
00:38:52,150 --> 00:38:56,330
변수는 argv 1은 1 argv2 3가 3 2 argv를보기입니다.

715
00:38:56,330 --> 00:39:03,490
하나의 큰 변수는 argv 4,
는 argc보다 NULL이 될 것이다.

716
00:39:03,490 --> 00:39:04,870
>> 그리고는 NULL 포인터입니다.

717
00:39:04,870 --> 00:39:06,590
예.

718
00:39:06,590 --> 00:39:11,250
문자열이기 때문에 그건
문자 스타 포인터입니다.

719
00:39:11,250 --> 00:39:14,102
그래서 동일한 유형이어야합니다.

720
00:39:14,102 --> 00:39:14,595
그래?

721
00:39:14,595 --> 00:39:16,074
>> 청중 : 두 가지 질문.

722
00:39:16,074 --> 00:39:21,004
그래서 하나의 차이 사이는 무엇입니까
한 종류가 아닌 다른이와있는 getString

723
00:39:21,004 --> 00:39:22,483
사용자 엔진?

724
00:39:22,483 --> 00:39:25,934
그리고이, 그 안에 저장된
최근 메모리?

725
00:39:25,934 --> 00:39:28,399
그래서 같은,있는 getString는 것
[INAUDIBLE] 수?

726
00:39:28,399 --> 00:39:31,357

727
00:39:31,357 --> 00:39:33,650
>> DAN : 어디에 저장됩니까?

728
00:39:33,650 --> 00:39:34,905
이 저장되어 어디 있는지 모르겠어요.

729
00:39:34,905 --> 00:39:40,000
>> 청중 : 그래서, 실제로 어떻게 어떤 알
당신이 인수의 부름 기능

730
00:39:40,000 --> 00:39:42,170
스택에 저장됩니다?

731
00:39:42,170 --> 00:39:46,610
그래서 argc와 argv를 인수 메인에 아르
그들은 스택에, 또는 정말

732
00:39:46,610 --> 00:39:49,131
당신이로 생각하는 위
스택의 시작.

733
00:39:49,131 --> 00:39:53,490
다른 부분 무엇
질문?

734
00:39:53,490 --> 00:39:56,821
>> 청중 : 그래서 무엇 [들리지?

735
00:39:56,821 --> 00:40:00,990
>> DAN : 네, 그냥 다른 방법
사용자로부터의 입력을 받고.

736
00:40:00,990 --> 00:40:06,030
이 일의 조금 더 효율적이고
이 스크립트에 대한보다 간편한입니다 당신 때문에

737
00:40:06,030 --> 00:40:10,070
그냥 메인에 인수를 전달할 수 있습니다
기능보다는 기다릴 필요 이상

738
00:40:10,070 --> 00:40:13,400
사용자는 모든 사용자가없는 경우.

739
00:40:13,400 --> 00:40:16,280
>> 청중 : 그리고 네, 문자열을 얻을
[INAUDIBLE]이 될 것이다.

740
00:40:16,280 --> 00:40:17,922
그것은 당신이 필요로하는 물건을 저장하는 것입니다.

741
00:40:17,922 --> 00:40:18,834
>> DAN : 그래?

742
00:40:18,834 --> 00:40:21,114
>> 청중 : [들리지?

743
00:40:21,114 --> 00:40:27,545
>> DAN : 예, argv와 공은 항상 포함
도트는 함수 호출 슬래시.

744
00:40:27,545 --> 00:40:28,042
그래?

745
00:40:28,042 --> 00:40:29,292
>> 청중 : [들리지?

746
00:40:29,292 --> 00:40:33,509

747
00:40:33,509 --> 00:40:37,310
>> DAN : 예, 각 인수가
NULL 문자로 끝났다들이 있기 때문에

748
00:40:37,310 --> 00:40:38,310
문자열입니다.

749
00:40:38,310 --> 00:40:40,892
>> 청중 : [들리지?

750
00:40:40,892 --> 00:40:44,116
>> DAN : 예,의 argv는 argc는 NULL 포인터이다.

751
00:40:44,116 --> 00:40:45,112
>> 청중 : [들리지?

752
00:40:45,112 --> 00:40:47,104
>> DAN : 오, 그래.

753
00:40:47,104 --> 00:40:48,100
네, 죄송합니다.

754
00:40:48,100 --> 00:40:49,594
>> 청중 : 그래서 [들리지?

755
00:40:49,594 --> 00:41:08,518

756
00:41:08,518 --> 00:41:16,340
>> DAN : 당신은이 있다면 질문은 그래서
명령 줄 점, 2, 1에서 점을 슬래시

757
00:41:16,340 --> 00:41:20,410
것 커맨드 라인의 개수
인수는이 수 또는 세 것입니까?

758
00:41:20,410 --> 00:41:24,420

759
00:41:24,420 --> 00:41:28,240
>> 청중 : 나는 그것을하지 않습니다 생각
정말 중요.

760
00:41:28,240 --> 00:41:31,370
나는 아, 그리고 만약 당신이 통과하지 못한, 말을하는 경향이
때 명령 줄 인수,

761
00:41:31,370 --> 00:41:32,730
분명히, 당신은 함수를 호출.

762
00:41:32,730 --> 00:41:37,950
그래서 음성으로 제외하는 경향이
명령 줄에서 함수

763
00:41:37,950 --> 00:41:40,350
그것이 비록 인수
변수는 argv에 포함되어 있습니다.

764
00:41:40,350 --> 00:41:42,600
>> DAN :하지만 test--에 있다면

765
00:41:42,600 --> 00:41:46,550
생각났어 또한 당신이 뭔가를 말한다면
는 argc는 3에 해당처럼,

766
00:41:46,550 --> 00:41:48,512
당신은 안전 서에있어.

767
00:41:48,512 --> 00:41:49,416
그래?

768
00:41:49,416 --> 00:41:50,666
>> 청중 : [들리지?

769
00:41:50,666 --> 00:42:00,990

770
00:42:00,990 --> 00:42:09,510
>> DAN : 나는 경우이 대신 호출하는 생각
argc와 문자열 argv를 괄호 안에

771
00:42:09,510 --> 00:42:14,350
하지만 같은 유형을 유지하고 방금 전화
같은 다른 그 무엇인가

772
00:42:14,350 --> 00:42:16,640
및 B가 작동은 것인지?

773
00:42:16,640 --> 00:42:18,790
그리고 그것은 여전히​​ 작동합니다,
당신은 그냥 ... 것

774
00:42:18,790 --> 00:42:21,520
대신 argc-- 사용
당신은 A와 B를 사용하는 것입니다.

775
00:42:21,520 --> 00:42:24,436

776
00:42:24,436 --> 00:42:25,408
그래?

777
00:42:25,408 --> 00:42:26,658
>> 청중 : [들리지?

778
00:42:26,658 --> 00:42:34,642

779
00:42:34,642 --> 00:42:38,850
>> DAN : 그래서 질문이있는 getString이입니다
힙에서 메모리를 저장하는 것

780
00:42:38,850 --> 00:42:42,280
getString는이 문자 때문에 *.

781
00:42:42,280 --> 00:42:47,530
그것은 때문에 힙에 메모리를 저장
실제 내 지금의 malloc 호출

782
00:42:47,530 --> 00:42:49,258
getString에의 구현입니다.

783
00:42:49,258 --> 00:42:53,210

784
00:42:53,210 --> 00:42:55,090
OK,에 이동.

785
00:42:55,090 --> 00:42:55,950
>> 보안.

786
00:42:55,950 --> 00:43:01,090
그래서 진정으로 안전한 것으로, 당신은에 의존
한 당신은 아무 한 액세스를 허용하지 않습니다

787
00:43:01,090 --> 00:43:04,540
귀하의 정보를, 어떤 이유입니다
모두가 자신의 시스템을 구축

788
00:43:04,540 --> 00:43:09,580
자신의 운영 체제, 모든
처음부터 프로그램 및 분명히

789
00:43:09,580 --> 00:43:13,410
다른 컴퓨터에 연결하지 마십시오
인터넷을 통한.

790
00:43:13,410 --> 00:43:17,350
그래서 컴퓨터는 불안하다.

791
00:43:17,350 --> 00:43:19,200
그들은 정말이다.

792
00:43:19,200 --> 00:43:20,940
우리는 다른 사람을 신뢰해야합니다.

793
00:43:20,940 --> 00:43:26,500
>> 그리고 보안의 아이디어는 걸이다
의 양을 제한하려고

794
00:43:26,500 --> 00:43:27,540
당신이 필요로하는 신뢰합니다.

795
00:43:27,540 --> 00:43:32,080
그리고 수단의 하나는 그렇게
암호화하는 것입니다.

796
00:43:32,080 --> 00:43:34,950
암호화는, 본질적으로, 인
우리는 비밀을 가지고있다.

797
00:43:34,950 --> 00:43:38,880
>> 때때로 우리는 우리의 비밀을 통과해야
따라서 내지 말하자면, 인터넷 또는

798
00:43:38,880 --> 00:43:39,980
다른 것들.

799
00:43:39,980 --> 00:43:43,180
그리고 우리는 사람을 원하지 않는
이 비밀을 알고있다.

800
00:43:43,180 --> 00:43:50,100
그래서 우리는 방법으로 우리의 비밀을 암호화
것을 우리는 아무도 알아낼 수 있기를 바랍니다.

801
00:43:50,100 --> 00:43:51,600
>> 그래서 우리는 used--

802
00:43:51,600 --> 00:43:54,340
이 class--의 과정을 통해

803
00:43:54,340 --> 00:44:00,750
시저 암호 같은 것들과
모두 아주이다 [INAUDIBLE]

804
00:44:00,750 --> 00:44:03,200
것들을 암호화 불안 방법.

805
00:44:03,200 --> 00:44:07,930
그들은 파악하기 쉽다 그들이
그리고 당신의 비밀은 무엇인가.

806
00:44:07,930 --> 00:44:12,130
현실 세계는 훨씬 더 사용
복잡한 암호화 방식.

807
00:44:12,130 --> 00:44:13,880
그리고 우리는 들어갈 수 없습니다
그 이상.

808
00:44:13,880 --> 00:44:18,280

809
00:44:18,280 --> 00:44:19,430
>> 디버깅.

810
00:44:19,430 --> 00:44:20,785
GDB는 최고입니다.

811
00:44:20,785 --> 00:44:24,014

812
00:44:24,014 --> 00:44:25,810
나는 이것을 다시 강조하는거야.

813
00:44:25,810 --> 00:44:30,920
GDB 모든 시간 모든를 사용하여
시간 당신은 문제가있다.

814
00:44:30,920 --> 00:44:36,030
GDB에 유용한 명령은
당신이 줄을 통과하는 휴식

815
00:44:36,030 --> 00:44:41,330
번호, 함수명 본질적
여기서 코드에서 중지 할,

816
00:44:41,330 --> 00:44:45,600
및 제어 할 수 있습니다.

817
00:44:45,600 --> 00:44:54,140
>> 인쇄 변수를 받아 출력한다
그 변수는에 무엇이든

818
00:44:54,140 --> 00:44:55,990
당신의 실행의 포인트입니다.

819
00:44:55,990 --> 00:45:00,130
다음 당신의 실행을 이동
한 단계를 따라.

820
00:45:00,130 --> 00:45:05,050
그리고 함수 내에서 단계 단계
당신의 실행에.

821
00:45:05,050 --> 00:45:10,480
>> 다른 가지 방법 인 실행
당신은 실제로 코드를 실행합니다.

822
00:45:10,480 --> 00:45:16,630
계속 필요한 모든 단계를 수행
다음 브레이크 포인트에 도착합니다.

823
00:45:16,630 --> 00:45:18,300
그리고 많은, 많은 사람들이 있습니다.

824
00:45:18,300 --> 00:45:19,040
그들을 봐.

825
00:45:19,040 --> 00:45:19,901
아주 좋아요.

826
00:45:19,901 --> 00:45:20,863
그래?

827
00:45:20,863 --> 00:45:22,113
>> 청중 : [들리지?

828
00:45:22,113 --> 00:45:26,635

829
00:45:26,635 --> 00:45:28,200
>> DAN : 네, 디버거이다.

830
00:45:28,200 --> 00:45:34,230
그래서 디버거는 프로그램입니다
당신이 당신의 프로그램을 디버깅 할 수 있습니다.

831
00:45:34,230 --> 00:45:39,931
그것은을 위해 버그를 발견하는 프로그램이 아니다
당신은,하지만 그 위대한 것입니다.

832
00:45:39,931 --> 00:45:43,020

833
00:45:43,020 --> 00:45:46,040
>> 그리고 검색은 나에게 마지막이다.

834
00:45:46,040 --> 00:45:51,470
우리가 이야기 검색의 종류 그래서
이 클래스에 대한 선형 검색 아르,

835
00:45:51,470 --> 00:45:55,960
어떤 각을 조회 단지입니다
검색 공간의 요소 번

836
00:45:55,960 --> 00:46:00,410
한 번에 요소, 당신은 무엇을 찾을 때까지
당신은 또는 당신이 도달 할 때까지 찾고

837
00:46:00,410 --> 00:46:03,350
검색 공간의 끝에있는
당신이 찾을 수 없다는 말을 가리

838
00:46:03,350 --> 00:46:06,360
당신이 찾고있는 요소입니다.

839
00:46:06,360 --> 00:46:13,450
그리고 이것은 기껏해야 일정한 시간이 소요
어떤 하나의 공이고, 최악의 선형에서

840
00:46:13,450 --> 00:46:16,070
n은 0입니다 시간.

841
00:46:16,070 --> 00:46:19,250
>> 필요 이진 검색,
지저분한 요소입니다.

842
00:46:19,250 --> 00:46:24,230
당신은 요소의 중앙으로 이동
볼 경우 당신이 찾고있는 요소

843
00:46:24,230 --> 00:46:30,120
요소보다 크거나 작은
당신은 중간에 걸.

844
00:46:30,120 --> 00:46:36,510
그것은이 더 크다, 당신은 바닥이 말
검색의 공간은 당신입니다

845
00:46:36,510 --> 00:46:41,550
현재 위치, 중간,
당신은 프로세스를 다시 시작합니다.

846
00:46:41,550 --> 00:46:46,150
작을 경우, 당신은 말을 보면
그래, 무슨 일이야 엥은?

847
00:46:46,150 --> 00:46:47,400
>> 청중 : [들리지?

848
00:46:47,400 --> 00:46:51,000

849
00:46:51,000 --> 00:46:54,260
>> DAN : 예.

850
00:46:54,260 --> 00:46:58,360
로 진행 됐어요 종류의 모든 종류의
클래스는 테스트를위한 공정한 게임이다.

851
00:46:58,360 --> 00:47:01,504

852
00:47:01,504 --> 00:47:04,920
>> [웃음]

853
00:47:04,920 --> 00:47:10,260
>> DAN : 그리고 당신은 없었어요 사실
문제 설정을 위해 그것을하기 위해서는 공평

854
00:47:10,260 --> 00:47:12,420
테스트 용 게임.

855
00:47:12,420 --> 00:47:15,186
>> 청중 : 우리가 그것을 통해 갈 수 방법을 아 -

856
00:47:15,186 --> 00:47:17,052
>> DAN : 그것은 이상 사라질 것입니다.

857
00:47:17,052 --> 00:47:20,496
>> SPEAKER 2 :위한 실제 코드
[INAUDIBLE] study.cs50.net에 있습니다.

858
00:47:20,496 --> 00:47:25,910

859
00:47:25,910 --> 00:47:32,680
당신이 연습 문제를 보면 그래서
의 병합 정렬 페이지

860
00:47:32,680 --> 00:47:35,880
study.cs50.net 코드가있다
정렬 병합 구현.

861
00:47:35,880 --> 00:47:38,550
그래서 당신은 구현할 필요가 없습니다
그것은 자신을 오늘 밤.

862
00:47:38,550 --> 00:47:42,090
그러나 당신이 아니라 그것을 이해하게
보다 그냥 기억.

863
00:47:42,090 --> 00:47:45,035
>> 청중 : [들리지?

864
00:47:45,035 --> 00:47:49,720
>> 스피커 2 :에 병합 정렬 페이지
study.cs50.net, 연습이

865
00:47:49,720 --> 00:47:53,570
당신은을 통해 클릭하면, 문제
문제는 맨 마지막에있다

866
00:47:53,570 --> 00:47:56,280
병합이 솔루션,
정렬의 구현입니다.

867
00:47:56,280 --> 00:47:58,510
그러나 확인 당신은 그것을 이해
오히려 그냥 암기보다

868
00:47:58,510 --> 00:47:59,760
또는 아래로 복사.

869
00:47:59,760 --> 00:48:02,870

870
00:48:02,870 --> 00:48:06,340
>> 청중 : 그리고 완벽하게 유효한
시험 문제가 될 것

871
00:48:06,340 --> 00:48:07,990
여기에 같은은 목록입니다.

872
00:48:07,990 --> 00:48:12,100
이 목록은 이후에 생겼는데 어떻게
선택 정렬의 한 단계 또는

873
00:48:12,100 --> 00:48:13,330
삽입 정렬 또는 무엇이든.

874
00:48:13,330 --> 00:48:14,940
리스트의 하나의 전체 반복.

875
00:48:14,940 --> 00:48:18,530
당신은 할 필요가 끝나지 않은 없더라도
그것을위한 코드, 당신은 그것을 이해할 필요가

876
00:48:18,530 --> 00:48:20,440
그것이 무슨 알만한
이 배열을 수정합니다.

877
00:48:20,440 --> 00:48:24,144

878
00:48:24,144 --> 00:48:25,394
>> DAN : 그것은 나를 위해 그것을이다.

879
00:48:25,394 --> 00:48:30,604

880
00:48:30,604 --> 00:48:32,588
>> [박수]

881
00:48:32,588 --> 00:49:06,316

882
00:49:06,316 --> 00:49:07,410
>> LUCAS : ​​안녕 여러분.

883
00:49:07,410 --> 00:49:08,390
내 이름은 루카스입니다.

884
00:49:08,390 --> 00:49:16,840
나는 모든 재귀에 대해 말할 것입니다
우리가 배운 종류 및

885
00:49:16,840 --> 00:49:18,050
모든 포인터의 약간.

886
00:49:18,050 --> 00:49:18,740
OK?

887
00:49:18,740 --> 00:49:20,340
모든 그래서 첫째, 재귀.

888
00:49:20,340 --> 00:49:22,951
그것은 그 말을 무엇을 의미 하는가
함수는 재귀?

889
00:49:22,951 --> 00:49:24,675
>> 관객 : 자신을 호출합니다.

890
00:49:24,675 --> 00:49:26,500
>> 루카스 : OK, 그래, 자신을 호출합니다.

891
00:49:26,500 --> 00:49:27,700
그래서 예를 들어이 그림​​처럼.

892
00:49:27,700 --> 00:49:30,280
그것은 내부의 사진처럼
사진 등등.

893
00:49:30,280 --> 00:49:35,740
그래서 예를 들어, 댄로 있거든요 수 있습니다
즉, 이진 검색에 대해 얘기했다.

894
00:49:35,740 --> 00:49:41,840
한 가지 방법은있는 이진 검색은
재귀 당신이있어 사실이다

895
00:49:41,840 --> 00:49:43,130
번호를 찾기 위해 노력.

896
00:49:43,130 --> 00:49:44,250
그래서 당신은 중간으로 이동합니다.

897
00:49:44,250 --> 00:49:47,130
이 숫자한다면 당신은 확인
왼쪽과 오른쪽에서.

898
00:49:47,130 --> 00:49:49,650
>> 그리고 당신은 숫자가 알 경우
왼쪽에있을 것, 동일한 야

899
00:49:49,650 --> 00:49:53,340
다시 검색을 수행 같은 것은 있지만,
다만 목록의 왼쪽.

900
00:49:53,340 --> 00:49:57,350
그것이 소리가 얼마나 그래서 그건
같은 재귀입니다.

901
00:49:57,350 --> 00:50:01,870
너희들이 재귀가 이유야
병합 정렬을위한 솔루션을 제공합니다.

902
00:50:01,870 --> 00:50:04,270
>> OK, 그래서 여기에 예입니다.

903
00:50:04,270 --> 00:50:07,280
그래서 내가 선택하려는 가정 해 봅시다
1에서 N까지 모든 숫자.

904
00:50:07,280 --> 00:50:13,790
나는 실현할 수 N의 합
수는 N 플러스 N 마이너스 1 일까지이다​​.

905
00:50:13,790 --> 00:50:17,810
하지만, 내가 N 마이너스 1을 보면 플러스
n은 음이 플러스 일, 즉 동일합니다

906
00:50:17,810 --> 00:50:20,680
합산 번호와 같은 것
n에 마이너스 일까지.

907
00:50:20,680 --> 00:50:25,890
그래서 동일한 금액의 합계를 말할 수있다
n은 마이너스 1의 N 플러스 합 같습니다.

908
00:50:25,890 --> 00:50:28,010
그 의미가 있습니까?

909
00:50:28,010 --> 00:50:32,630
>> 그리고 또한 다른 뭔가를해야
인 것이, 기본 케이스라고

910
00:50:32,630 --> 00:50:37,440
최대 수의 합
제로 제로가 될 것이다.

911
00:50:37,440 --> 00:50:42,770
그래서 최대한 빨리 수를 얻을로
제로, 내가 계산 중지합니다.

912
00:50:42,770 --> 00:50:45,330
그 의미가 있습니까?

913
00:50:45,330 --> 00:50:48,120
>> 그래서 여기에 방법의 예
나는 그것을 구현할 수 있습니다.

914
00:50:48,120 --> 00:50:49,860
그래서 일부에서이 기능을 가지고있다.

915
00:50:49,860 --> 00:50:51,700
즉, 정수 n이 걸립니다.

916
00:50:51,700 --> 00:50:56,300
n은 경우에 따라서 여기에 내가 먼저 확인
작거나 0으로 동일합니다.

917
00:50:56,300 --> 00:51:00,310
그래서 0으로 작거나 같은 내가 만약
우리의 기본 케이스 인 0을 반환.

918
00:51:00,310 --> 00:51:05,690
그렇지 않으면, 난 그냥 반환 할 수 있습니다 N 플러스
숫자의 합으로부터

919
00:51:05,690 --> 00:51:07,190
N 마이너스 일 한.

920
00:51:07,190 --> 00:51:09,360
이해가가?

921
00:51:09,360 --> 00:51:10,100
확인을 클릭합니다.

922
00:51:10,100 --> 00:51:11,610
>> 그래서 여기의 모습입니다.

923
00:51:11,610 --> 00:51:15,260
당신은이 등호의 합이
이 플러스 1의 합.

924
00:51:15,260 --> 00:51:18,930
그리고 일의 일부는 플러스 1
0 0의 합.

925
00:51:18,930 --> 00:51:20,216
이해가가?

926
00:51:20,216 --> 00:51:25,342
우리가 스택 보면 그래서
프로그램은이는 모습이다.

927
00:51:25,342 --> 00:51:26,820
>> 첫째, 우리는 주요 기능을 가지고있다.

928
00:51:26,820 --> 00:51:30,320
그리고 주요 기능
합이했다.

929
00:51:30,320 --> 00:51:36,690
그리고 합이 오 말할 것입니다, 합
이 2 더하기 하나의 합계와 동일합니다.

930
00:51:36,690 --> 00:51:39,460
그래서 스택에 하나의 합을 추가합니다.

931
00:51:39,460 --> 00:51:43,860
그리고 1의 합이 합을 호출하려고
공은, 어떤도 추가 될 것입니다

932
00:51:43,860 --> 00:51:44,630
스택.

933
00:51:44,630 --> 00:51:49,240
그리고 아르 이러한 것들의 각
위에 다른 반환해야

934
00:51:49,240 --> 00:51:52,020
다른 사람은 계속하기 전에.

935
00:51:52,020 --> 00:51:56,240
>> 그래서 예를 들어, 다음, 공의 합,
첫째, 0을 반환하는 것입니다.

936
00:51:56,240 --> 00:51:58,320
그리고 하나의 합을 선택합니다.

937
00:51:58,320 --> 00:52:00,850
그런 다음 하나의 합을 것입니다
둘의 합이 1을 반환합니다.

938
00:52:00,850 --> 00:52:03,900
그리고 마지막으로, 둘의 합계는 것입니다
주 3을 반환합니다.

939
00:52:03,900 --> 00:52:05,320
그 의미가 있습니까?

940
00:52:05,320 --> 00:52:09,496
>> 이 방법을 이해하는 것이 정말 중요합니다
스택이 작동하고 시도한다

941
00:52:09,496 --> 00:52:11,980
그것이 의미가 있는지.

942
00:52:11,980 --> 00:52:13,260
좋아, 그럼 정렬.

943
00:52:13,260 --> 00:52:16,170
그럼 왜 중요 정렬됩니다
먼저?

944
00:52:16,170 --> 00:52:18,260
왜 우리가 관심을 가져야?

945
00:52:18,260 --> 00:52:20,310
누구?

946
00:52:20,310 --> 00:52:20,695
예를 한번 들어 봐요?

947
00:52:20,695 --> 00:52:21,040
그래?

948
00:52:21,040 --> 00:52:22,968
>> 청중 : [들리지].

949
00:52:22,968 --> 00:52:24,700
>> LUCAS : ​​OK, 그래.

950
00:52:24,700 --> 00:52:26,090
그래서 당신은보다 효율적으로 검색 할 수 있습니다.

951
00:52:26,090 --> 00:52:28,580
그건 좋은 방법입니다.

952
00:52:28,580 --> 00:52:32,462
따라서, 예를 들어, 우리가 많이있을
가지 사실에서 우리의 삶 그

953
00:52:32,462 --> 00:52:32,920
분류되어 있습니다.

954
00:52:32,920 --> 00:52:34,830
예를 들어, 사전.

955
00:52:34,830 --> 00:52:39,210
>> 그것은 모두가 매우 중요합니다
위해 어떤 종류의 단어가 우리

956
00:52:39,210 --> 00:52:41,970
쉽게 액세스 할 수 있습니다.

957
00:52:41,970 --> 00:52:43,280
그래서 그가 한 말입니다.

958
00:52:43,280 --> 00:52:45,530
당신은보다 효율적으로 검색 할 수 있습니다.

959
00:52:45,530 --> 00:52:48,740
그것은을하는 것입니다 얼마나 열심히 생각
단어에있는 사전

960
00:52:48,740 --> 00:52:49,500
임의의 순서.

961
00:52:49,500 --> 00:52:53,120
당신은 꽤 많이,보고 할 것
모든 단어를 찾을 때까지

962
00:52:53,120 --> 00:52:54,720
당신이 찾고있는 단어입니다.

963
00:52:54,720 --> 00:52:58,710
>> 당신은 또한 페이스 북을 사용하는 경우 때
당신의 친구를 찾고있어, 당신은있어

964
00:52:58,710 --> 00:53:03,540
페이스 북 넣어 보게 될 당신의
가까운 친구가 사람의 위에입니다

965
00:53:03,540 --> 00:53:05,470
당신은 많은 것을 이야기하지 않는 것이.

966
00:53:05,470 --> 00:53:08,080
당신의 바닥에 모든 길을 갈 경우
친구 목록, 당​​신은 보게 될

967
00:53:08,080 --> 00:53:11,250
당신은 아마하지 않는 사람들
당신이 친구 야 기억 해요.

968
00:53:11,250 --> 00:53:14,590
그리고 페이스 북의 종류 때문이다
방법에 따라 친구

969
00:53:14,590 --> 00:53:16,472
당신이 그들에게 아르 닫습니다.

970
00:53:16,472 --> 00:53:17,930
>> 따라서 데이터를 구성.

971
00:53:17,930 --> 00:53:18,450
또한 포켓몬.

972
00:53:18,450 --> 00:53:21,400
그래서 당신은 모든 Pokemons들은 볼
번호를 가지고있다.

973
00:53:21,400 --> 00:53:27,210
그리고 그것은 쉬운처럼
데이터를 액세스하는 방법.

974
00:53:27,210 --> 00:53:29,050
>> 청중 : 포켓몬 액세스.

975
00:53:29,050 --> 00:53:29,890
>> LUCAS : ​​그래.

976
00:53:29,890 --> 00:53:32,395
>> 청중 : [들리지].

977
00:53:32,395 --> 00:53:33,460
>> LUCAS : ​​그래.

978
00:53:33,460 --> 00:53:35,140
좋아, 그럼 선택 정렬.

979
00:53:35,140 --> 00:53:41,610
선택의 종류를 선택하는 것입니다
목록의 작은 분류되지 않은 값을 각

980
00:53:41,610 --> 00:53:43,300
각 반복의 시간입니다.

981
00:53:43,300 --> 00:53:46,800
그것은 가지 당신이 정렬처럼
당신의 머리에서 당신이하려고 할 때

982
00:53:46,800 --> 00:53:48,430
반면에 목록을 정렬 할 수 있습니다.

983
00:53:48,430 --> 00:53:51,990
>> 기본적으로, 당신이 모든 당신이 보는 것입니다
최소 번호.

984
00:53:51,990 --> 00:53:54,280
당신은 정렬 된 목록에 넣어.

985
00:53:54,280 --> 00:53:56,230
그리고 당신은 찾아
다음으로 작은 수입니다.

986
00:53:56,230 --> 00:54:00,080
그리고 당신은 일을 계속
그 등등.

987
00:54:00,080 --> 00:54:04,600
>> 그래서 선택의 종류는 기본적으로
때마다 가장 작은 선택

988
00:54:04,600 --> 00:54:05,750
정렬되지 않은 값입니다.

989
00:54:05,750 --> 00:54:10,840
정렬의 단부에 넣어
목록의 일부입니다.

990
00:54:10,840 --> 00:54:12,370
그리고 그 일을 계속.

991
00:54:12,370 --> 00:54:15,890
그래서 빨리 보자 어떤
이처럼 보인다.

992
00:54:15,890 --> 00:54:19,340
그래서 여기에 정렬 된입니다
분류되지 않은 목록입니다.

993
00:54:19,340 --> 00:54:23,350
>> 목록의 분류에 대한 그래서,
그것은 처음에 비어 있습니다.

994
00:54:23,350 --> 00:54:26,760
그리고 난을 선택하려고 해요
이 여기에 가장 작은 수입니다.

995
00:54:26,760 --> 00:54:30,650
그래서 나는 숫자 2를 얻을 내가 넣어
리스트의 앞에.

996
00:54:30,650 --> 00:54:34,910
그리고 난 다음 작은 찾아
3 요소입니다.

997
00:54:34,910 --> 00:54:37,050
그래서 마지막에 넣어
정렬 된 목록의.

998
00:54:37,050 --> 00:54:38,140
그리고 그 일을 계속.

999
00:54:38,140 --> 00:54:40,040
I는 4 찾아 끝에 넣어.

1000
00:54:40,040 --> 00:54:41,360
5를 찾아 마지막에 넣습니다.

1001
00:54:41,360 --> 00:54:44,830
>> 그리고 그 시간의 방법을 모두 살펴 그
나는 끝이에 넣어 말하는거야

1002
00:54:44,830 --> 00:54:46,850
기본적으로,이 값을 스와핑.

1003
00:54:46,850 --> 00:54:48,100
OK?

1004
00:54:48,100 --> 00:54:50,140

1005
00:54:50,140 --> 00:54:52,825
그리고 마지막, 당신 만
또 하나의 요소를 가지고있다.

1006
00:54:52,825 --> 00:54:55,870
그래서 그것은 이미 정렬입니다.

1007
00:54:55,870 --> 00:54:57,800
>> 좋아, 그럼 삽입 정렬.

1008
00:54:57,800 --> 00:55:03,180
삽입 정렬은 또한 할거야
정렬 한의 일 및

1009
00:55:03,180 --> 00:55:04,690
정렬되지 않은 목록입니다.

1010
00:55:04,690 --> 00:55:14,540
유일한 것은 할 때마다 그
당신은 분류에 요소를 추가하는

1011
00:55:14,540 --> 00:55:18,170
목록, 당​​신은 단지 요소를 선택하는
정렬되지 않은 목록의 앞에 있습니다.

1012
00:55:18,170 --> 00:55:20,880
그리고 당신은 무엇을 찾을거야
위치는 정렬에 있어야합니다

1013
00:55:20,880 --> 00:55:22,300
목록의 일부입니다.

1014
00:55:22,300 --> 00:55:25,840
>> 의이 그렇게 무엇인지 살펴 보자
이 더 의미가 있습니다.

1015
00:55:25,840 --> 00:55:29,360
그래서 처음에 예를 들어, 내가 노력하고있어
에 3 번을 삽입 할

1016
00:55:29,360 --> 00:55:30,680
목록의 정렬 된 부분.

1017
00:55:30,680 --> 00:55:31,800
그래서 목록은 아무것도하지 않습니다.

1018
00:55:31,800 --> 00:55:34,160
그래서 난 그냥 숫자 3을 넣을 수 있습니다.

1019
00:55:34,160 --> 00:55:37,480
>> 지금, 나는에 숫자 5를 추가 할
목록의 정렬 된 부분.

1020
00:55:37,480 --> 00:55:38,900
그래서 5 번 봐.

1021
00:55:38,900 --> 00:55:40,450
나는 세 이상입니다 것을 알 수 있습니다.

1022
00:55:40,450 --> 00:55:41,980
그래서 나는 세 이후 여야한다는 것을 알고있다.

1023
00:55:41,980 --> 00:55:44,100
그래서 3과 5를 넣어.

1024
00:55:44,100 --> 00:55:45,940
>> 그 때 나는 숫자 2를 삽입 할 수 있습니다.

1025
00:55:45,940 --> 00:55:51,630
나는 숫자 2가 실제로 있음을 알
다음,도 3 및도 5를 모두 마지막.

1026
00:55:51,630 --> 00:55:54,580
그래서 실제로 모든 넣어 가지고
목록의 시작 부분에있는 방법입니다.

1027
00:55:54,580 --> 00:55:59,030
그래서, 가지, 모든 이동해야
정렬 된 목록 그래서 내가 할 수있는 요소

1028
00:55:59,030 --> 00:56:01,970
숫자 2를위한 공간을 확인합니다.

1029
00:56:01,970 --> 00:56:03,160
>> 그럼 난 숫자 6을 참조하십시오.

1030
00:56:03,160 --> 00:56:05,450
나는 오 후해야합니다 것을 알 수있다.

1031
00:56:05,450 --> 00:56:06,240
그래서 나는 거기에 넣어.

1032
00:56:06,240 --> 00:56:07,965
그리고 마지막으로, 나는 4 번 봐.

1033
00:56:07,965 --> 00:56:11,030
그리고 나는 그것이해야 알
(3, 5) 사이.

1034
00:56:11,030 --> 00:56:14,870
그리고 나는 거기에 넣고 이동
다른 모든 요소.

1035
00:56:14,870 --> 00:56:16,120
이해가가?

1036
00:56:16,120 --> 00:56:17,880

1037
00:56:17,880 --> 00:56:19,150
>> 버블 정렬.

1038
00:56:19,150 --> 00:56:25,730
그래서 거품 정렬은 말이있어 기본적으로
가는 우리가 거​​품 호출하더라도 -합니다

1039
00:56:25,730 --> 00:56:30,113
당신은 list-- 통과 종류 때문에
난 그냥 보여 주면 실제로는 더 나은

1040
00:56:30,113 --> 00:56:32,300
당신은이 겁니다 좋아

1041
00:56:32,300 --> 00:56:35,030
당신은 비교하는거야
인접 번호.

1042
00:56:35,030 --> 00:56:38,410
그리고 당신은 교환거야 자신의
위치가하지 않으면

1043
00:56:38,410 --> 00:56:39,190
올바른 순서.

1044
00:56:39,190 --> 00:56:42,570
>> 그래서 기본적으로 무엇을 것입니다
여기에서 발생, 예를 들면,

1045
00:56:42,570 --> 00:56:44,160
당신은 8과 6있다.

1046
00:56:44,160 --> 00:56:47,270
당신은 정렬 된 순서를 알 잖아
실제로 오른쪽 6 및 05 일 수?

1047
00:56:47,270 --> 00:56:49,540
그래서 당신은 주문을 바꿀 것입니다.

1048
00:56:49,540 --> 00:56:51,370
그럼 여기 8과 4를 참조하십시오.

1049
00:56:51,370 --> 00:56:52,250
그리고 같은 일을.

1050
00:56:52,250 --> 00:56:53,400
다시 교환합니다.

1051
00:56:53,400 --> 00:56:55,070
그리고 마지막으로, 2, 8.

1052
00:56:55,070 --> 00:56:56,670
나는 또한 그들을 교환합니다.

1053
00:56:56,670 --> 00:57:01,690
>> 그것은 버블 정렬 때문에 이후라고
이러한 반복의 각, 사실,

1054
00:57:01,690 --> 00:57:05,910
리스트에서 가장 큰 숫자는 모든 도착
리스트의 마지막 방법.

1055
00:57:05,910 --> 00:57:06,940
그 의미가 있습니까?

1056
00:57:06,940 --> 00:57:11,880
그것을 계속 교환하기 때문에
및 오른쪽으로 이동.

1057
00:57:11,880 --> 00:57:14,440
>> 좋아, 그럼이 두 번째 반복입니다.

1058
00:57:14,440 --> 00:57:17,200
이 같은 일이 될 것이다.

1059
00:57:17,200 --> 00:57:20,190
내가 한 스왑을 다하겠습니다
다음 마지막.

1060
00:57:20,190 --> 00:57:23,290
더 스왑이 없습니다 I 것을
그리고 목록이 정렬됩니다.

1061
00:57:23,290 --> 00:57:27,460
버블 분류 그래서, 우리는 기본적으로 유지
목록을 가서 교환

1062
00:57:27,460 --> 00:57:32,310
일이 내가하지도 않은 것을 알 때까지
그 반복을 수행하는 모든 스왑, 어떤

1063
00:57:32,310 --> 00:57:34,270
목록이 이미 정렬되어 있다는 것을 의미한다.

1064
00:57:34,270 --> 00:57:35,520
이해가가?

1065
00:57:35,520 --> 00:57:38,400

1066
00:57:38,400 --> 00:57:40,870
>> 의 조금을 얘기하자
시간을 실행하는 방법에 대한.

1067
00:57:40,870 --> 00:57:45,165
그래서 너희들은 빅을 기억
O, 오메가, 세타?

1068
00:57:45,165 --> 00:57:49,290

1069
00:57:49,290 --> 00:57:50,990
그래?

1070
00:57:50,990 --> 00:57:53,070
OK, 빅 O는 모든 첫째, 무엇입니까?

1071
00:57:53,070 --> 00:57:54,315
>> 청중 : [들리지].

1072
00:57:54,315 --> 00:57:59,070
>> LUCAS : ​​그래, 최악의 경우라고
단지 그것의 의미합니다 런타임,

1073
00:57:59,070 --> 00:58:03,470
얼마나 많은 프로그램을 기대
실행 촬영합니다.

1074
00:58:03,470 --> 00:58:04,910
마찬가지로, 측면에서 어디의

1075
00:58:04,910 --> 00:58:06,660
이 case-- n을한다.

1076
00:58:06,660 --> 00:58:09,150
의 요소 수
최악의 경우 목록입니다.

1077
00:58:09,150 --> 00:58:12,520
마찬가지로, 최악의 경우에는.

1078
00:58:12,520 --> 00:58:17,100
>> 버블 정렬을위한 따라서, 예를 들면,
우리는 n 개의 사각형의 큰 O가있다.

1079
00:58:17,100 --> 00:58:20,580
우리가 왜해야합니까?

1080
00:58:20,580 --> 00:58:24,716
왜 거품 빅 O n 개의 사각형 정렬입니까?

1081
00:58:24,716 --> 00:58:27,614
>> 청중 : [들리지].

1082
00:58:27,614 --> 00:58:35,670
>> LUCAS : ​​네, 최악의 경우가 될 것입니다
것을 나는 n 개의 반복을해야 할 것이다.

1083
00:58:35,670 --> 00:58:39,260
그래서 반복의 각각에 가고
끝으로 큰 요소를 가지고

1084
00:58:39,260 --> 00:58:40,290
리스트.

1085
00:58:40,290 --> 00:58:44,230
그래서 최악의 경우 내가 가지고있다
그 일 n 번을 할 수 있습니다.

1086
00:58:44,230 --> 00:58:48,550
그리고 그 시간의 각각에 대해, 내가해야만
나는 비교해야하기 때문에 N 스왑을

1087
00:58:48,550 --> 00:58:49,870
각각의 두 요소.

1088
00:58:49,870 --> 00:58:53,730
이 N 제곱 왜 그래서입니다
이 n 번 N 때문.

1089
00:58:53,730 --> 00:59:00,120
>> 그런 다음, 선택 정렬은 n 개의 정사각형
때문에, 각 반복에 대해, 내가해야만

1090
00:59:00,120 --> 00:59:02,650
모든 단일 요소를 보면
목록.

1091
00:59:02,650 --> 00:59:04,980
그리고, 가장 작은 찾을
이는 내가해야 함을 의미

1092
00:59:04,980 --> 00:59:06,130
n 개의 요소를 찾습니다.

1093
00:59:06,130 --> 00:59:11,750
그리고 때문 N 번해야
나는 모든 n 개의 요소를 선택해야합니다.

1094
00:59:11,750 --> 00:59:18,273
>> 삽입 정렬은 n 개의 정사각형
최악의 시나리오는 때문

1095
00:59:18,273 --> 00:59:20,950
, 일하고, 내가 삽입해야
N 번호, 오른쪽?

1096
00:59:20,950 --> 00:59:22,765
그래서 난 이미거야 알고
n 개의 반복을해야합니다.

1097
00:59:22,765 --> 00:59:25,466

1098
00:59:25,466 --> 00:59:29,840
하지만 내가 가지고있는 각 숫자를 들어,
모든 숫자에 보는

1099
00:59:29,840 --> 00:59:34,380
정렬 된 목록과 모든 방법을 넣어
앞에, 즉 n 개의 정사각형이 될 것입니다

1100
00:59:34,380 --> 00:59:36,230
이 n 번 N 다시 될 것입니다 때문입니다.

1101
00:59:36,230 --> 00:59:38,280
이해가가?

1102
00:59:38,280 --> 00:59:41,512
무엇 오메가에 대한?

1103
00:59:41,512 --> 00:59:42,886
>> 청중 : [들리지].

1104
00:59:42,886 --> 00:59:44,620
>> LUCAS : ​​그것은 최상의 시나리오입니다.

1105
00:59:44,620 --> 00:59:48,810
그래서 많은 시간을위한에서처럼,
최상의 시나리오이며, 정렬

1106
00:59:48,810 --> 00:59:50,660
목록이 이미 정렬됩니다.

1107
00:59:50,660 --> 00:59:52,670
그래서 당신이 정말로 필요가 없습니다
아무것도 할 수 있습니다.

1108
00:59:52,670 --> 00:59:56,290
버블 정렬 최선을 가지고
N의 시나리오.

1109
00:59:56,290 --> 00:59:58,820
너희들은 이유를 알고 있습니까?

1110
00:59:58,820 --> 01:00:00,620
>> 청중 : [들리지].

1111
01:00:00,620 --> 01:00:05,640
>> LUCAS : ​​그래, 당신은 추적을 계속하는 경우
데이터 배급 어떤 스왑을했다 여부

1112
01:00:05,640 --> 01:00:10,533
당신이 뭔가를이 아닌 경우로 설정처럼
반복하는 경우가 발생했을 경우에 해당

1113
01:00:10,533 --> 01:00:15,140
목록이 이미 기본적으로 정렬
어떤 일이 일어날 것은 내가 갈거야입니다

1114
01:00:15,140 --> 01:00:17,890
이 각을 교환하려고
인접하는 요소.

1115
01:00:17,890 --> 01:00:19,920
나는 것을 볼거야
더 스왑이 없습니다.

1116
01:00:19,920 --> 01:00:21,230
그리고 난 그냥 바로 돌아갑니다.

1117
01:00:21,230 --> 01:00:24,240
>> 그래서 난 그냥했다는 것을 의미한다
목록 한 시간을 통해 이동합니다.

1118
01:00:24,240 --> 01:00:28,990
내가 보이기 때문에 그래서 N이다
n 개의 요소에서.

1119
01:00:28,990 --> 01:00:30,930
왜 선택 종류의 N 제곱?

1120
01:00:30,930 --> 01:00:35,150

1121
01:00:35,150 --> 01:00:45,520
>> 네,리스트가 정렬되는 경우에도, 대
선택 정렬의 모든 반복, I

1122
01:00:45,520 --> 01:00:47,590
최소의 요소를 선택해야합니다.

1123
01:00:47,590 --> 01:00:49,980
그래서 내가 볼 아웃해야 함을 의미
정렬되지 않은 모든 요소에

1124
01:00:49,980 --> 01:00:53,350
나열하고 최소 찾을
각 반복합니다.

1125
01:00:53,350 --> 01:00:54,600
그 의미가 있습니까?

1126
01:00:54,600 --> 01:00:56,880

1127
01:00:56,880 --> 01:01:04,690
>> 그리고 삽입 칼에 있기 때문에 n은
내가 삽입하기 위해 노력하고있어 경우

1128
01:01:04,690 --> 01:01:09,320
숫자 및 숫자 모두 때 I
를 삽입하려고, 나는 그들이 볼

1129
01:01:09,320 --> 01:01:10,510
오른쪽 위치에 있습니다.

1130
01:01:10,510 --> 01:01:15,120
나는 다른 모든를 확인 갈 필요가 없습니다
정렬되지 않은 목록에서 번호.

1131
01:01:15,120 --> 01:01:17,170
이 N 될 것입니다 그래서 그입니다.

1132
01:01:17,170 --> 01:01:19,480
이해가가?

1133
01:01:19,480 --> 01:01:21,035
그리고 세타는 무엇인가?

1134
01:01:21,035 --> 01:01:23,410
>> 청중 : [들리지].

1135
01:01:23,410 --> 01:01:24,380
>> LUCAS : ​​뭐, 뭐라고?

1136
01:01:24,380 --> 01:01:24,960
다시 말해봐.

1137
01:01:24,960 --> 01:01:25,666
>> 청중 : [들리지].

1138
01:01:25,666 --> 01:01:26,490
>> LUCAS : ​​그렇지.

1139
01:01:26,490 --> 01:01:31,280
그래서 당신은 만 선택을 볼 수 있습니다
병합에 저장된 일종의 쎄 있습니다.

1140
01:01:31,280 --> 01:01:39,920
당신은 단지 세타가 있기 때문에 그건
빅 O와 오메가는 모두 동일합니다.

1141
01:01:39,920 --> 01:01:41,520
확인을 클릭합니다.

1142
01:01:41,520 --> 01:01:44,210
그리고 마지막으로, 로그 N에 일종의 병합합니다.

1143
01:01:44,210 --> 01:01:48,910
>> 댄 말했듯이 그리고, 정렬 병합
가지 같은 방법으로 같은입니다

1144
01:01:48,910 --> 01:01:50,320
당신은 이진 검색을한다.

1145
01:01:50,320 --> 01:01:53,530
그래서 당신은 목록을 얻을.

1146
01:01:53,530 --> 01:01:55,170
그리고 당신은 반으로 잘라 것입니다.

1147
01:01:55,170 --> 01:02:00,580
그리고 당신은 그들을 잘라
작은 반쪽에서.

1148
01:02:00,580 --> 01:02:01,730
그리고 당신은 그들을 병합합니다.

1149
01:02:01,730 --> 01:02:02,960
너희들은 오른쪽 기억?

1150
01:02:02,960 --> 01:02:04,960
OK, 그는 얘기로.

1151
01:02:04,960 --> 01:02:08,330
>> OK 포인터.

1152
01:02:08,330 --> 01:02:11,078
그래서 포인터는 무엇인가?

1153
01:02:11,078 --> 01:02:12,050
>> 청중 : [들리지].

1154
01:02:12,050 --> 01:02:12,820
>> LUCAS : ​​주소입니다.

1155
01:02:12,820 --> 01:02:13,720
확인을 클릭합니다.

1156
01:02:13,720 --> 01:02:18,530
나는 다윗의 무리를 보여주는 것을 알고있다
빙키의 동영상과 사물을 가리키는

1157
01:02:18,530 --> 01:02:19,080
서로.

1158
01:02:19,080 --> 01:02:22,960
하지만 포인터로 생각하고 싶어요
단지 주소.

1159
01:02:22,960 --> 01:02:26,110
그래서 것입니다 변수입니다
주소를 저장합니다.

1160
01:02:26,110 --> 01:02:31,940
>> 그래서 그냥이 특별한 변수
즉, 4 바이트 길이입니다.

1161
01:02:31,940 --> 01:02:36,550
아무것도 그 포인터가 기억
우리의 32 비트 긴 항상 4 바이트

1162
01:02:36,550 --> 01:02:39,370
기계 경우와 너무
장비.

1163
01:02:39,370 --> 01:02:41,920

1164
01:02:41,920 --> 01:02:47,050
그리고 그것은 단지 위치가
그것의 내부 변수.

1165
01:02:47,050 --> 01:02:50,240
>> OK, 그래서 기본적으로,이 메모리가 있습니다.

1166
01:02:50,240 --> 01:02:57,420
그래서 메모리의 각 블록이 실제로있다
의 주소 라벨,

1167
01:02:57,420 --> 01:02:58,890
slotty 메모리.

1168
01:02:58,890 --> 01:03:02,370
그래서 내가 할 수 있다는 것을 의미
행 포인터가 가리키는

1169
01:03:02,370 --> 01:03:03,380
이 주소 중.

1170
01:03:03,380 --> 01:03:09,930
그래서 우리는 포인터를 사용합니다 이유는
나는 위치를 기억해야하는 경우

1171
01:03:09,930 --> 01:03:12,300
것을 특정 변수 메모리이다.

1172
01:03:12,300 --> 01:03:16,560
>> 그리고 너희들은 기억 그 중 하나가
내가하는 기능이있는 경우 경우가 있었다

1173
01:03:16,560 --> 01:03:20,820
실제로이있는 경우에 당신을 원해요
실수에 대한 스왑, I 실제로

1174
01:03:20,820 --> 01:03:22,110
포인터를 보낼 수 있습니다.

1175
01:03:22,110 --> 01:03:23,460
아니 변수입니다.

1176
01:03:23,460 --> 01:03:25,200
너희들은 기억하십니까?

1177
01:03:25,200 --> 01:03:26,450
차이 between--

1178
01:03:26,450 --> 01:03:33,350

1179
01:03:33,350 --> 01:03:34,120
이름은 무엇입니까?

1180
01:03:34,120 --> 01:03:36,010
값 호출하여 호출
참조로, 오른쪽?

1181
01:03:36,010 --> 01:03:36,840
>> 네, 확인을 클릭합니다.

1182
01:03:36,840 --> 01:03:38,330
그래서 값으로 호출합니다.

1183
01:03:38,330 --> 01:03:43,570
당신은 변수를 보낼 때
당신이 값을 보내는 기능을 수행합니다.

1184
01:03:43,570 --> 01:03:45,610
그래서 당신은 실제로 보내는
변수의 사본.

1185
01:03:45,610 --> 01:03:49,720
그리고 당신의 프로그램이 더 마음에 없습니다
실제로 같은 변수 경우에 대한

1186
01:03:49,720 --> 01:03:51,650
복사본을 만듭니다.

1187
01:03:51,650 --> 01:03:56,330
>> 그리고 참조 것을 의미한다 호출
사실의 사본을 보내고있다

1188
01:03:56,330 --> 01:03:57,550
그 변수의 포인터.

1189
01:03:57,550 --> 01:04:00,970
그래서 난을 보내고있다 것을 의미한다
그 변수의 위치입니다.

1190
01:04:00,970 --> 01:04:04,440
그래서 난의 위치를​​ 감지
변수, I 전화 기능

1191
01:04:04,440 --> 01:04:09,700
포인터, 사실을 수 있어요
메인에 있던 데이터를 변경합니다.

1192
01:04:09,700 --> 01:04:12,050
이해가가?

1193
01:04:12,050 --> 01:04:17,560
>> 비록 포인터가 복사본이고,
여전히 포인터의 실제 주소를 가지고

1194
01:04:17,560 --> 01:04:20,090
내가 변경하고자하는 변수입니다.

1195
01:04:20,090 --> 01:04:21,920
이해가가?

1196
01:04:21,920 --> 01:04:24,290
>> 그래서 포인터를 생성.

1197
01:04:24,290 --> 01:04:28,410
항상 포인터를 기억
그것이 가리키는 것 유형

1198
01:04:28,410 --> 01:04:29,890
스타와 다음.

1199
01:04:29,890 --> 01:04:31,030
그리고 당신은 이름을 넣어.

1200
01:04:31,030 --> 01:04:35,765
그래서 당신이있을 때마다 기억
어떤 스타, 그것은에 대한 포인터처럼

1201
01:04:35,765 --> 01:04:38,990
어떤 변수가
당신이 한 것으로 입력합니다.

1202
01:04:38,990 --> 01:04:42,850
>> 그래서 여기 스타, 예를 들어, 야
포인터와 정수입니다.

1203
01:04:42,850 --> 01:04:47,680
그리고 문자 스타 포인터입니다
문자 스타 등.

1204
01:04:47,680 --> 01:04:47,960
그래?

1205
01:04:47,960 --> 01:04:52,710
>> 청중 : 우리가있는 경우
N 포인터는 X 스타입니다.

1206
01:04:52,710 --> 01:04:55,255
나는 그것이 X에 대한 포인터를 생성 알고있다.

1207
01:04:55,255 --> 01:04:59,432
또한 정수 x를 선언 하는가?

1208
01:04:59,432 --> 01:05:05,170
>> LUCAS : ​​OK, 그래서 당신은 n 개의 스타 x를 말할 때,
당신은에 대한 포인터를 생성하지 않을

1209
01:05:05,170 --> 01:05:06,000
변수 x에.

1210
01:05:06,000 --> 01:05:08,170
당신은 X라는 이름의 포인터를 만들고 있습니다.

1211
01:05:08,170 --> 01:05:09,396
>> 청중 : [들리지].

1212
01:05:09,396 --> 01:05:14,250
>> LUCAS : ​​나는 N 스타 x를 말할 때, 난
이봐, 메모리에, 내가 갈거야, 말

1213
01:05:14,250 --> 01:05:16,390
이 세 개의 상자 중 하나를 얻을.

1214
01:05:16,390 --> 01:05:20,750
그리고 그 그런 말을하는거야
인, 배 될 것입니다

1215
01:05:20,750 --> 01:05:22,000
가는 포인터가 될 수 있습니다.

1216
01:05:22,000 --> 01:05:26,860

1217
01:05:26,860 --> 01:05:30,640
그리고 포인터에 대한 흥미로운
우리는 그들이 가지고 말할 것입니다

1218
01:05:30,640 --> 01:05:32,620
32 비트 시스템에 대해 4 바이트.

1219
01:05:32,620 --> 01:05:36,320
그 이유가 있기 때문이다
4 바이트는 32 비트입니다.

1220
01:05:36,320 --> 01:05:40,490
>> 64 비트는 실제로 그리고 기계
포인터 주소가

1221
01:05:40,490 --> 01:05:43,480
64 비트 길이됩니다.

1222
01:05:43,480 --> 01:05:49,820
그래서 그냥 의미의 크기
기계의 주소는 다릅니다.

1223
01:05:49,820 --> 01:05:52,270
>> 그래서 참조하는과를 참조 해제.

1224
01:05:52,270 --> 01:05:54,310
이 운영자는이 있음
너희들이 기억해야합니다.

1225
01:05:54,310 --> 01:05:55,450
제 앰퍼샌드이다.

1226
01:05:55,450 --> 01:05:56,810
제 스타이다.

1227
01:05:56,810 --> 01:06:05,060
그 별이에 의해 혼동하지 마십시오
때문에에, 기억 스타

1228
01:06:05,060 --> 01:06:06,950
이 경우, 당신은 n 개의 별이있다.

1229
01:06:06,950 --> 01:06:08,700
>> 그것은 함께 모든 것을 같아요.

1230
01:06:08,700 --> 01:06:10,720
없음 해당 공간 별은 없습니다.

1231
01:06:10,720 --> 01:06:12,070
그래서 그것은 종류인지 의미한다.

1232
01:06:12,070 --> 01:06:14,870
당신이 때 기억
변수 스타, 당신이있어

1233
01:06:14,870 --> 01:06:16,230
유형에 대해 얘기.

1234
01:06:16,230 --> 01:06:20,540
>> 당신은 단지 스타와있을 때
변수의 이름은, 그 의미

1235
01:06:20,540 --> 01:06:24,100
당신은 포인터를 역 참조하고있는
당신이보고있는 것을 의미한다

1236
01:06:24,100 --> 01:06:28,290
포인터가 어드레스를 찾는 그건
, 가리키는 그 주소로 이동,

1237
01:06:28,290 --> 01:06:30,850
언제보고
당신은 거기에있다.

1238
01:06:30,850 --> 01:06:34,310
그래서 난 당신이있을 때 나의 학생들에게
스타, 당신은 그것이라고 생각한다

1239
01:06:34,310 --> 01:06:36,850
컨텐츠의 약어.

1240
01:06:36,850 --> 01:06:39,770
>> 당신이 포인터를 가지고 있다면 그래서 당신
스타 포인터를 수행, 그것은이다

1241
01:06:39,770 --> 01:06:41,720
포인터의 내용.

1242
01:06:41,720 --> 01:06:44,580
그래서 당신은 그것을 가리키는 것의로 이동
및 일정 내용을 확인합니다.

1243
01:06:44,580 --> 01:06:47,730
그리고 앰퍼샌드는 동일합니다
의 주소와 같은 것.

1244
01:06:47,730 --> 01:06:52,560
>> 내가 좋아 할까 .. 변수가 경우에 따라서,하자
INT의 같음 내가 한 말 3--

1245
01:06:52,560 --> 01:06:56,900
그의 주소를 찾으려면
변수 메모리, I는 할 수

1246
01:06:56,900 --> 01:06:58,240
를 앰퍼샌드.

1247
01:06:58,240 --> 01:07:00,280
그래서 주소입니다.

1248
01:07:00,280 --> 01:07:01,530
이해가가?

1249
01:07:01,530 --> 01:07:03,790

1250
01:07:03,790 --> 01:07:05,040
>> 그래서 여기에 예입니다.

1251
01:07:05,040 --> 01:07:08,370

1252
01:07:08,370 --> 01:07:11,530
이것은 INT B와 C INT가 없습니다.

1253
01:07:11,530 --> 01:07:16,520
3 수단에 해당 INT 그래서 그
나는 메모리에 갈거야.

1254
01:07:16,520 --> 01:07:19,870
그리고 슬롯을 찾을거야
여기에 숫자 3을 넣어.

1255
01:07:19,870 --> 01:07:22,200
>> 그리고 INT B는 4와 동일합니다.

1256
01:07:22,200 --> 01:07:23,100
나는 같은 일을 할거야.

1257
01:07:23,100 --> 01:07:25,840
메모리에 가서 번호를 넣어
상자 중 하나에서 넷.

1258
01:07:25,840 --> 01:07:27,100
그리고 INT는 5와 같습니다.

1259
01:07:27,100 --> 01:07:29,740
또 다른 상자를 찾아 숫자 5를 넣어.

1260
01:07:29,740 --> 01:07:36,160
>> 그래서 뭘하고이 라인은 무엇입니까?
n 개의 스타 PA는 앰퍼샌드 같습니다.

1261
01:07:36,160 --> 01:07:37,800
그래서 우선, N 스타 파.

1262
01:07:37,800 --> 01:07:39,050
그것은 무엇을하고 있습니까?

1263
01:07:39,050 --> 01:07:40,930

1264
01:07:40,930 --> 01:07:42,298
>> 청중 : [들리지].

1265
01:07:42,298 --> 01:07:47,890
>> LUCAS : ​​네, N 스타 파, 첫째,
PA라는 포인터를 선언합니다.

1266
01:07:47,890 --> 01:07:53,720
그리고, 그 값을 할당하는 것
그 포인터의 주소가 될 수 있습니다.

1267
01:07:53,720 --> 01:07:55,790
따라서를 앰퍼샌드.

1268
01:07:55,790 --> 01:07:58,510
그럼, 스타 PB를 할 경우,
스타 PB는 무엇인가?

1269
01:07:58,510 --> 01:08:02,418

1270
01:08:02,418 --> 01:08:03,150
>> 아, 죄송합니다.

1271
01:08:03,150 --> 01:08:06,330
이것은 또한 없습니다. n 개의 스타 PB.

1272
01:08:06,330 --> 01:08:07,905
나는 스타 PC를 의미한다.

1273
01:08:07,905 --> 01:08:11,200
미안 해요.

1274
01:08:11,200 --> 01:08:11,940
이 같은 일입니다.

1275
01:08:11,940 --> 01:08:16,408
하지만 지금은 포인터를 생성 AR 잘 해요
다음 C에 대한 포인터를 B와 있습니다.

1276
01:08:16,408 --> 01:08:16,886
그래?

1277
01:08:16,886 --> 01:08:18,136
>> 청중 : [들리지?

1278
01:08:18,136 --> 01:08:25,490

1279
01:08:25,490 --> 01:08:26,670
>> LUCAS : ​​예.

1280
01:08:26,670 --> 01:08:32,630
그래서 당신은 메모리에 가서 당신은에 가면
PA에 대한 지정자입니다 상자,

1281
01:08:32,630 --> 01:08:37,149
실제로 갈거야
의 주소를 참조하십시오.

1282
01:08:37,149 --> 01:08:38,399
OK?

1283
01:08:38,399 --> 01:08:42,970

1284
01:08:42,970 --> 01:08:43,300
그래?

1285
01:08:43,300 --> 01:08:45,605
>> 청중 : [들리지?

1286
01:08:45,605 --> 01:08:49,260
>> LUCAS : ​​네, 포인터가 주소입니다.

1287
01:08:49,260 --> 01:08:50,120
잊지 마십시오.

1288
01:08:50,120 --> 01:08:52,800
그것은 가장 중요한처럼
포인터에 대한 부분입니다.

1289
01:08:52,800 --> 01:08:56,180
저장 및 주소 있습니다
일부 변수.

1290
01:08:56,180 --> 01:08:56,890
다른 건?

1291
01:08:56,890 --> 01:08:58,370
다른 질문?

1292
01:08:58,370 --> 01:08:59,189
확인을 클릭합니다.

1293
01:08:59,189 --> 01:09:00,399
>> 그래서 배열, 포인터 등이 포함된다.

1294
01:09:00,399 --> 01:09:08,189
기억이 나는 배열 세를 int로 할 때,
기본적으로, 내가 일을하고있어 나는 종류 해요입니다

1295
01:09:08,189 --> 01:09:12,779
의 포인터를 선언.

1296
01:09:12,779 --> 01:09:18,960
그래서 배열은 가지에 대한 포인터처럼
메모리의 특정 위치하는 I

1297
01:09:18,960 --> 01:09:21,999
정수에 대한 3 개의 슬롯을 할당.

1298
01:09:21,999 --> 01:09:23,430
그 의미가 있습니까?

1299
01:09:23,430 --> 01:09:30,250
>> 내가 int 배열 삼을 때, 내가 뭘 해요
하고, 기본적으로 세 가지를 만드는 것입니다

1300
01:09:30,250 --> 01:09:31,479
메모리 슬롯.

1301
01:09:31,479 --> 01:09:33,899
그래서 난 그냥 메모리에 3 개의 슬롯을 찾을 수 있습니다.

1302
01:09:33,899 --> 01:09:38,810
그래서, 다음, 스타 배열을 할 경우
기본적 어레이의 콘텐츠를 의미

1303
01:09:38,810 --> 01:09:46,180
이는 내가 가서, 내가 포인터를 삭제 의미
그것이 가리키는있어 그 장소에,

1304
01:09:46,180 --> 01:09:47,939
나는 숫자 1을 넣어.

1305
01:09:47,939 --> 01:09:53,729
>> 그리고, 나는 스타 배열에 1을 더한 할 경우,
그 배열을하고 같은 일이

1306
01:09:53,729 --> 01:09:59,690
그냥으로 이동을 의미하는 하나의 브라켓
이 가리키는 장소.

1307
01:09:59,690 --> 01:10:03,000
그리고 더하기 하나 만든다
나 하나의 위치를​​ 이동.

1308
01:10:03,000 --> 01:10:06,510
그래서, 실제로,이 위치로 이동
그리고 두 번째했습니다.

1309
01:10:06,510 --> 01:10:10,900
>> 그리고, 마지막으로, 나는 때 할
배열 플러스 2, 난 곳으로 이동

1310
01:10:10,900 --> 01:10:11,825
에서 배열의 가리키는.

1311
01:10:11,825 --> 01:10:14,690
그리고 나서 메모리 블록으로 이동합니다.

1312
01:10:14,690 --> 01:10:16,240
그리고 여기서 3 번을 넣어.

1313
01:10:16,240 --> 01:10:16,600
그래?

1314
01:10:16,600 --> 01:10:21,400
>> 청중 : 그래서 스타 배열이 단순히
첫 번째 점을 말.

1315
01:10:21,400 --> 01:10:25,090
그리고 당신은 그냥 있기 때문에, 하나를 추가 할 수 있습니다
우리는 정말이야

1316
01:10:25,090 --> 01:10:27,295
그 첫 번째 주소를 참조.

1317
01:10:27,295 --> 01:10:28,545
>> LUCAS : ​​그래.

1318
01:10:28,545 --> 01:10:32,720

1319
01:10:32,720 --> 01:10:36,020
왜 우리는 예를 들어, 배열을 말합니까
0, 어레이 (1) 및 어레이 (2)?

1320
01:10:36,020 --> 01:10:38,970

1321
01:10:38,970 --> 01:10:42,790
나는 왜 당신이 공을 하는가, 말하는거야
1, 2, 3 대신에 1, 2, 3?

1322
01:10:42,790 --> 01:10:46,550
그 이유 중 하나는, 하나의 컴퓨터이며
프로그래머가 시작하는 것을 선호

1323
01:10:46,550 --> 01:10:47,750
0부터 계산.

1324
01:10:47,750 --> 01:10:52,370
당신이 배열 공을 수행 할 때 때문에 두이며,
그것은 배열을하고 같은 일이

1325
01:10:52,370 --> 01:10:56,330
의미 플러스 영, 나는로 이동
그 위치, 그리고 난 몰라

1326
01:10:56,330 --> 01:10:59,320
모든 메모리 블록을 건너 뜁니다.

1327
01:10:59,320 --> 01:11:01,750
그래서 나는 모든 메모리 블록을 이동하지 않습니다.

1328
01:11:01,750 --> 01:11:02,015
그래?

1329
01:11:02,015 --> 01:11:03,265
>> 청중 : [들리지?

1330
01:11:03,265 --> 01:11:05,928

1331
01:11:05,928 --> 01:11:12,670
>> LUCAS : ​​그래서 그녀는 무엇을이 묻는 데요
하 차이

1332
01:11:12,670 --> 01:11:14,000
이 또는 malloc에​​ 일을.

1333
01:11:14,000 --> 01:11:17,550
차이점 중 하나 인 것을
int 배열 (3)을 만드는 것입니다

1334
01:11:17,550 --> 01:11:19,260
스택에 배열입니다.

1335
01:11:19,260 --> 01:11:23,080
그리고 malloc을 할 때, 그것을
힙에 생성합니다.

1336
01:11:23,080 --> 01:11:25,250
그 의미가 있습니까?

1337
01:11:25,250 --> 01:11:28,870
>> 어떻게 malloc에​​ 실제로 작동합니까?

1338
01:11:28,870 --> 01:11:32,245
그럼 왜 우리는 심지어의 malloc을 사용해야합니까?

1339
01:11:32,245 --> 01:11:35,730

1340
01:11:35,730 --> 01:11:39,700
인물의 컴파일러 종류 밖으로 모든
당신이 선언 된 변수.

1341
01:11:39,700 --> 01:11:44,040
그리고 그는 모두를위한 공간을 만듭니다
스택에서의 그들.

1342
01:11:44,040 --> 01:11:47,180
그래서 모든 변수가는거야
어딘가에 스택합니다.

1343
01:11:47,180 --> 01:11:49,460
그래서 여기에 환경 변수이다.

1344
01:11:49,460 --> 01:11:53,850
>> 이 변수에 대한 그러니까 기본적으로, 공간
메모리에 할당

1345
01:11:53,850 --> 01:11:55,080
시간을 컴파일합니다.

1346
01:11:55,080 --> 01:11:58,790
그래서 그것은 당신의 컴퓨터에있는 것을 의미한다
그 모든 변수를 알고

1347
01:11:58,790 --> 01:11:59,790
사전.

1348
01:11:59,790 --> 01:12:02,500
그것은 어떤 값을 알 필요가 없습니다
당신이 그들에 넣어 것입니다.

1349
01:12:02,500 --> 01:12:05,490
그러나 방법을 알 필요가있다
당신이 필요로하는 메모리의 양.

1350
01:12:05,490 --> 01:12:09,380
>> 하지만 지금의 예를 들어 그 말을하자
당신은 배열을 만들거나 새고

1351
01:12:09,380 --> 01:12:13,430
당신이 복용하고 있는지 문자열
사용자로부터.

1352
01:12:13,430 --> 01:12:17,300
당신은 몰라 얼마나 오래 문자열
예를 들어, 될 것입니다.

1353
01:12:17,300 --> 01:12:20,600
그래서 당신은 정확히 얼마나 많은 몰라
메모리 블록은 오른쪽 할당?

1354
01:12:20,600 --> 01:12:24,120
>> 그래서 정말 맞지 않는 것
당신은 100 문자를 넣어 대답.

1355
01:12:24,120 --> 01:12:26,420
그리고 사용자는 150를 기록 무슨 경우?

1356
01:12:26,420 --> 01:12:27,670
당신은 망하는 것입니다.

1357
01:12:27,670 --> 01:12:30,160

1358
01:12:30,160 --> 01:12:34,620
>> 그러니까 기본적으로, 당신은 어떻게 확신 할 수 없다
당신이 할당해야 많은 메모리

1359
01:12:34,620 --> 01:12:35,960
때 프로그램을 컴파일합니다.

1360
01:12:35,960 --> 01:12:38,240
당신은 실행 시간에 그 알고있다.

1361
01:12:38,240 --> 01:12:39,950
당신이 힙을 왜 그래서입니다.

1362
01:12:39,950 --> 01:12:47,610
그래서 힙 메모리를해야 할 것입니다
당신은 동안 할당하고 있는지

1363
01:12:47,610 --> 01:12:50,810
프로그램 실행 기간.

1364
01:12:50,810 --> 01:12:55,780
>> 그러니까 기본적으로, 당신이 malloc을 할 때, 무엇을
당신은 메모리를 할당되어하고있는

1365
01:12:55,780 --> 01:13:00,160
당신이있어 것을 의미 런타임,
그 순간에 권리를 결정하는 당신을

1366
01:13:00,160 --> 01:13:02,670
해당 메모리가 있어야합니다.

1367
01:13:02,670 --> 01:13:04,210
당신이 그것을 할당 할 때 그래서입니다.

1368
01:13:04,210 --> 01:13:06,430
그 의미가 있습니까?

1369
01:13:06,430 --> 01:13:11,690
>> 따라서 스택 변수가 기억
즉, 컴파일 시간에 생성됩니다.

1370
01:13:11,690 --> 01:13:14,560
그리고 힙이 변수가
당신이가는로 생성되는

1371
01:13:14,560 --> 01:13:15,600
예를 들어 mal​​loc에​​와.

1372
01:13:15,600 --> 01:13:16,850
>> 청중 : [들리지?

1373
01:13:16,850 --> 01:13:19,179

1374
01:13:19,179 --> 01:13:24,340
>> LUCAS : ​​그래서있는 getString입니다
의 malloc를 호출하는 것.

1375
01:13:24,340 --> 01:13:26,710
내가 malloc에​​ 대해 얘기하자, 그리고
나는있는 getString을 설명 할 것이다.

1376
01:13:26,710 --> 01:13:32,000
그래서 malloc에​​ 같은 일이다
메모리 할당 등.

1377
01:13:32,000 --> 01:13:34,600
그래서 할당 할 것
힙에 메모리.

1378
01:13:34,600 --> 01:13:40,010
그리고 그것은에 대한 포인터를 반환 것
어디에 메모리에 할당되었다.

1379
01:13:40,010 --> 01:13:43,090
>> 그래서 당신은 아니야 때

1380
01:13:43,090 --> 01:13:44,910
여기 example--에 대한

1381
01:13:44,910 --> 01:13:45,830
n 개의 스타 포인터.

1382
01:13:45,830 --> 01:13:50,520
그리고 포인터는 malloc에​​ 동일
인치 10 배의 크기입니다.

1383
01:13:50,520 --> 01:13:52,110
나는 포인터를 만드는거야.

1384
01:13:52,110 --> 01:13:59,020
그리고 나서 해당 포인터를 할당 해요
포인터의 malloc의 값

1385
01:13:59,020 --> 01:13:59,680
저를주고있다.

1386
01:13:59,680 --> 01:14:04,150
>> 그래서 부탁 해요 malloc에​​ 당신은 할당 할 수 있습니다
10 정수를위한 공간입니다.

1387
01:14:04,150 --> 01:14:05,390
즉, 무슨 말을합니다.

1388
01:14:05,390 --> 01:14:09,020
그리고 malloc에​​ 날 다시 제공
그 곳의 포인터.

1389
01:14:09,020 --> 01:14:11,460
이해가가?

1390
01:14:11,460 --> 01:14:12,270
확인을 클릭합니다.

1391
01:14:12,270 --> 01:14:17,940
내가 그리고있는 getString는 기본적를하고있다
당신이 할당 할 수 있도록의 malloc에​​ 전화

1392
01:14:17,940 --> 01:14:21,680
런타임 중에 메모리.

1393
01:14:21,680 --> 01:14:26,460
>> 항상 널 (null)를 확인하기 위해 기억
때 malloc ()은 널 포인터를 반환하는 것입니다 때문에

1394
01:14:26,460 --> 01:14:28,200
이는 메모리를 할당 할 수없는 경우.

1395
01:14:28,200 --> 01:14:31,660
의 당신이 말도 안되는 요청한다고 가정 해 봅시다
메모리의 양입니다.

1396
01:14:31,660 --> 01:14:33,950
컴퓨터가 될 수 없습니다
그 정도를 할당 할 수.

1397
01:14:33,950 --> 01:14:36,410
>> 그래서 malloc에​​는 것입니다
널 (null)으로 돌아갑니다.

1398
01:14:36,410 --> 01:14:42,210
그래서 항상 있는지 확인하는 기억
당신이 malloc을에서 얻은 포인터입니다

1399
01:14:42,210 --> 01:14:45,640
널 여부는 경우에, 당신은 수도 있기 때문에
포인터를 역 참조 할 수 및

1400
01:14:45,640 --> 01:14:48,340
면 결함의 원인.

1401
01:14:48,340 --> 01:14:50,930
그리고 마지막으로, 잊지 마세요
무료 메모리.

1402
01:14:50,930 --> 01:14:57,800

1403
01:14:57,800 --> 01:15:00,560
>> MALLOC 힙 메모리를 만드는 것입니다.

1404
01:15:00,560 --> 01:15:03,436
그리고 당신은 메모리를 해제해야
프로그램이 종료하기 전에.

1405
01:15:03,436 --> 01:15:05,370
좋아, 나를 위해 모든입니다.

1406
01:15:05,370 --> 01:15:07,900
죄송합니다, 롭.

1407
01:15:07,900 --> 01:15:07,950
감사합니다.

1408
01:15:07,950 --> 01:15:09,878
>> [박수]

1409
01:15:09,878 --> 01:15:12,679
>> LUCAS : ​​모두 마지막 질문
롭이 오기 전에?

1410
01:15:12,679 --> 01:15:13,138
아니?

1411
01:15:13,138 --> 01:15:13,597
그래?

1412
01:15:13,597 --> 01:15:15,892
>> 청중 : 나는 보지 않았다
이 일 온라인.

1413
01:15:15,892 --> 01:15:17,269
당신은 아직 업로드 된 적이 있습니까?

1414
01:15:17,269 --> 01:15:19,106
>> LUCAS : ​​나는 데이브 생각
곧 업로드.

1415
01:15:19,106 --> 01:15:19,880
>> DAVE :이 게시 될 것입니다.

1416
01:15:19,880 --> 01:15:20,310
>> LUCAS : ​​그것은 온라인 알 수있을 것입니다.

1417
01:15:20,310 --> 01:15:21,175
>> 청중 : 그것은이야.

1418
01:15:21,175 --> 01:15:22,090
>> LUCAS : ​​그것은이야?

1419
01:15:22,090 --> 01:15:23,157
확인을 클릭합니다.

1420
01:15:23,157 --> 01:15:23,644
그래?

1421
01:15:23,644 --> 01:15:27,053
>> 청중 : [들리지?

1422
01:15:27,053 --> 01:15:30,285
>> LUCAS : ​​예, 당신은 해제해야 모든
힙에 배치 된 메모리.

1423
01:15:30,285 --> 01:15:31,535
>> 청중 : [들리지?

1424
01:15:31,535 --> 01:15:34,518

1425
01:15:34,518 --> 01:15:36,160
>> LUCAS : ​​예.

1426
01:15:36,160 --> 01:15:39,980
당신은 문화의 malloc을 할 때마다,
당신은 무료로 문화를 가지고 있어야

1427
01:15:39,980 --> 01:15:42,640
한 후 그 변수를 사용 중지합니다.

1428
01:15:42,640 --> 01:15:44,800
그래서 malloc을 무료 아르
항상 함께.

1429
01:15:44,800 --> 01:15:45,410
그들의 가장 친한 친구.

1430
01:15:45,410 --> 01:15:46,720
그래.

1431
01:15:46,720 --> 01:15:47,970
롭?

1432
01:15:47,970 --> 01:15:55,595

1433
01:15:55,595 --> 01:15:56,850
>> ROB : 나는 빨리 갈 수 있습니다.

1434
01:15:56,850 --> 01:16:00,466
또한 비디오가 올려집니다.

1435
01:16:00,466 --> 01:16:01,716
나는에 마이크가있다.

1436
01:16:01,716 --> 01:16:24,060

1437
01:16:24,060 --> 01:16:26,230
>> 좋아, 그럼 주 오 물건.

1438
01:16:26,230 --> 01:16:27,970
우리가 먼저 스택이다.

1439
01:16:27,970 --> 01:16:33,390
그래서 하나의 스택이 있다는 것을 기억
활성화 함수 호출 당 프레임.

1440
01:16:33,390 --> 01:16:34,710
우리는 두번째에 해당를 볼 수 있습니다.

1441
01:16:34,710 --> 01:16:37,850
또한 실제로 어떤 일이 일어나는지 기억
각 스택 프레임에있을거야

1442
01:16:37,850 --> 01:16:41,880
우리 함수의 로컬 변수
로 전달되는 인수 우리

1443
01:16:41,880 --> 01:16:43,880
부부와 함께 기능,
다른 것들 당신은 정말하지 않습니다

1444
01:16:43,880 --> 01:16:45,260
걱정 할 필요가있다.

1445
01:16:45,260 --> 01:16:50,950
>> 그래서 여기 어디 예를 들어 프로그램입니다,
통지, 메인은 반환을 printfing된다

1446
01:16:50,950 --> 01:16:52,830
foo는 4의 값입니다.

1447
01:16:52,830 --> 01:16:57,930
foo는 단지를 반환하는 것입니다
바 (4) 쉼표 6의 값입니다.

1448
01:16:57,930 --> 01:17:02,380
그리고 바는 일부 지역을 설정하는 것입니다
4 내지 6 배와 동일 변수 (n).

1449
01:17:02,380 --> 01:17:03,920
그리고 N 돌아갑니다.

1450
01:17:03,920 --> 01:17:09,130
>> 그럼에 걸쳐 스택을 살펴 보자
이 프로그램의 실제 반복.

1451
01:17:09,130 --> 01:17:10,500
그래서 우리의 스택의 바닥이있다.

1452
01:17:10,500 --> 01:17:12,620
스택이 자라는 것을 기억하십시오.

1453
01:17:12,620 --> 01:17:15,370
우리의 스택의 맨 아래에있는 그래서 우리
메인위한 스택 프레임을 가지고있다.

1454
01:17:15,370 --> 01:17:17,000
하면 프로그램이 시작, 주
항상에있을 것입니다

1455
01:17:17,000 --> 01:17:18,560
우리의 스택의 바닥.

1456
01:17:18,560 --> 01:17:20,880
>> 그리고 내부에 무엇을 우리의
주에 대한 프레임을 스택?

1457
01:17:20,880 --> 01:17:23,810
그래서 로컬가 없더라도
주요 변수로는 내가 전에 말했듯이, 같은

1458
01:17:23,810 --> 01:17:29,670
우리는 argc와 RGV는 공간을 차지했습니다
주요 스택 프레임의 내부.

1459
01:17:29,670 --> 01:17:33,260
지금 것입니다 그래서 주
foo 함수를 호출합니다.

1460
01:17:33,260 --> 01:17:35,125
그리고 그 푸에가는 의미
자신의 스택 프레임을 얻을.

1461
01:17:35,125 --> 01:17:36,970
>> 그래서 지금 우리는 내부에있어
함수 foo.

1462
01:17:36,970 --> 01:17:38,610
그리고 무엇에 갈 필요가
foo는의 스택 프레임?

1463
01:17:38,610 --> 01:17:41,100
음, 푸 n 인수가 있습니다.

1464
01:17:41,100 --> 01:17:45,440
그 이후, n은 4와 동일한 것을
메인은 ​​foo는의 인수로 전달합니다.

1465
01:17:45,440 --> 01:17:48,490
>> 이제 foo는 막대를 호출하는 것입니다.

1466
01:17:48,490 --> 01:17:52,070
무슨 일이 바 안에해야 할 것입니다
그 '스택 프레임의?

1467
01:17:52,070 --> 01:17:55,610
그것은 여섯 동일한 4 Y와 같은 X이 있습니다.

1468
01:17:55,610 --> 01:17:58,540
그게 우리가 할 거 야 그 모두가 아니다
바 때문에 스택 프레임

1469
01:17:58,540 --> 01:18:00,580
또한 로컬 변수 N이 있습니다.

1470
01:18:00,580 --> 01:18:03,370
그리고 N 우리는 24과 동일하게 설정하는 것입니다.

1471
01:18:03,370 --> 01:18:05,750
>> 그래서 지금 바는 N을 반환하는 것입니다.

1472
01:18:05,750 --> 01:18:09,300
그래서 바는 24을 반환
스택 프레임 foo는.

1473
01:18:09,300 --> 01:18:12,560
그리고 바는 지금, 반환되기 때문에
우리는 스택 프레임을 보여주고있어 의미

1474
01:18:12,560 --> 01:18:14,250
스택의 오프 바.

1475
01:18:14,250 --> 01:18:18,430
바 있었다 있도록 모든 메모리
사용하는 스택에서 지금이다.

1476
01:18:18,430 --> 01:18:21,550
>> 이제 foo는 또한 것입니다
주요 24을 반환합니다.

1477
01:18:21,550 --> 01:18:25,470
그래서 지금 foo는이 메모리를 반환
그 foo는 그 '에 사용 된

1478
01:18:25,470 --> 01:18:27,550
스택 프레임도 사라 졌어요.

1479
01:18:27,550 --> 01:18:29,660
그리고 지금, 주요의 printf를 호출하는 것입니다.

1480
01:18:29,660 --> 01:18:31,660
그래서 printf와는 또 다른 기능입니다.

1481
01:18:31,660 --> 01:18:35,320
우리는 printf의 호출하면 될 것
printf의 또 다른 스택 프레임

1482
01:18:35,320 --> 01:18:36,470
함수 호출.

1483
01:18:36,470 --> 01:18:37,990
>> 우리는 무엇의 printf를 전달하는?

1484
01:18:37,990 --> 01:18:40,090
즉 갈 일이지
그 스택 프레임에.

1485
01:18:40,090 --> 01:18:44,970
적어도, 우리는 통과하고
그 퍼센트 내가 N 백 슬래시 및

1486
01:18:44,970 --> 01:18:47,180
인수 24.

1487
01:18:47,180 --> 01:18:50,370
이 스택 프레임 년대에이 더있을 수 있습니다
printf의 일부를 사용하는 것으로 발생하는 경우

1488
01:18:50,370 --> 01:18:51,200
지역 변수.

1489
01:18:51,200 --> 01:18:51,920
우리는 모른다.

1490
01:18:51,920 --> 01:18:53,810
>> 그러나 모든이의 printf의에 간다
프레임을 스택.

1491
01:18:53,810 --> 01:18:55,740
그것은의 printf를 실행하는 것입니다.

1492
01:18:55,740 --> 01:18:56,830
다음의 printf를 이루어집니다.

1493
01:18:56,830 --> 01:18:57,820
그것은 반환합니다.

1494
01:18:57,820 --> 01:18:58,960
마지막으로, 메인이 완료됩니다.

1495
01:18:58,960 --> 01:18:59,860
주요 반환합니다.

1496
01:18:59,860 --> 01:19:02,020
그리고 우리의 프로그램이 완료됩니다.

1497
01:19:02,020 --> 01:19:02,480
그래?

1498
01:19:02,480 --> 01:19:04,505
>> 관객 : 당신이보고있는 [INAUDIBLE]

1499
01:19:04,505 --> 01:19:05,900
인수 [INAUDIBLE]

1500
01:19:05,900 --> 01:19:06,830
매개 변수?

1501
01:19:06,830 --> 01:19:09,970
>> ROB : 그래서 미묘한 차이가 있습니다
인수와 매개 변수 사이.

1502
01:19:09,970 --> 01:19:14,400
그리고 정말, 일반적인 이야기에서, 사람들은 경향
그냥 모든 시간을 섞는다합니다.

1503
01:19:14,400 --> 01:19:17,550
하지만 파라미터 형식적
물건의 이름을 지정합니다.

1504
01:19:17,550 --> 01:19:20,180
>> 그래서 argc와 argv를 아르
메인에 매개 변수를 설정합니다.

1505
01:19:20,180 --> 01:19:23,440
인수는 무엇을 실제로
이러한 매개 변수로 전달합니다.

1506
01:19:23,440 --> 01:19:28,340
그래서 전 4의 foo는, 4 호출 할 때
내가 전달하고있어 인수입니다.

1507
01:19:28,340 --> 01:19:31,460
그리고 내부 파라미터 N,
foo는, 값 4를 취한다

1508
01:19:31,460 --> 01:19:32,880
4 년 이후 인수했다.

1509
01:19:32,880 --> 01:19:35,826
>> 청중 : [들리지?

1510
01:19:35,826 --> 01:19:37,880
>> ROB는 : N은 막대 할 수있는 지역 변수입니다.

1511
01:19:37,880 --> 01:19:41,420

1512
01:19:41,420 --> 01:19:44,960
n은 여전히​​ foo는 로컬하지만
그것은 foo는 할 수있는 매개 변수입니다.

1513
01:19:44,960 --> 01:19:48,190
그것은 지역 변수 아니다.

1514
01:19:48,190 --> 01:19:48,546
그래?

1515
01:19:48,546 --> 01:19:51,180
>> 청중 : [들리지?

1516
01:19:51,180 --> 01:19:55,400
>> ROB : foo는 그냥 호출하는 바,
어떤 바 수익률을 반환.

1517
01:19:55,400 --> 01:19:56,786
>> 청중 : [들리지?

1518
01:19:56,786 --> 01:19:59,591
>> ROB : 네, 여러 볼
스택 프레임.

1519
01:19:59,591 --> 01:20:00,082
그래?

1520
01:20:00,082 --> 01:20:03,519
>> 관객 : 왜 f​​oo는 호출 된
printf의 전?

1521
01:20:03,519 --> 01:20:05,920
>> ROB : 왜 푸의 printf 전에 호출했다?

1522
01:20:05,920 --> 01:20:10,740
내가 가질 수 있도록하는 대신, 뭔가 할
INT와 같은 × 4의 foo는 동일

1523
01:20:10,740 --> 01:20:12,980
다음 X를 출력한다.

1524
01:20:12,980 --> 01:20:17,900
하지만 그 대신, 나는 기능을 결합
printf의 인수로 호출합니다.

1525
01:20:17,900 --> 01:20:23,670
>> 그러나주의하는 것이 우리가 실제로 할 수 없습니다
우리까지의 p​​rintf 호출을 실행

1526
01:20:23,670 --> 01:20:25,610
4의 foo는이 무엇인지 알아.

1527
01:20:25,610 --> 01:20:27,480
그래서 우리는 이것을 평가하는 것입니다.

1528
01:20:27,480 --> 01:20:32,504
그리고 그 일을 끝낼 번만가는거야
다시 와서이 평가한다.

1529
01:20:32,504 --> 01:20:32,990
그래?

1530
01:20:32,990 --> 01:20:37,364
>> 청중 : 두 줄 이후 [INAUDIBLE]

1531
01:20:37,364 --> 01:20:41,738
값은, 왜 우리는 [INAUDIBLE] 없어요?

1532
01:20:41,738 --> 01:20:44,400
>> ROB : 그들은 완전히 INT해야한다.

1533
01:20:44,400 --> 01:20:46,260
즉, 이상 발견되지 않았습니다
다중 패스.

1534
01:20:46,260 --> 01:20:49,010
그래서 INT 바 INT해야
그 두 사람 foo는

1535
01:20:49,010 --> 01:20:50,460
정수를 반환합니다.

1536
01:20:50,460 --> 01:20:54,214
그들이가는하지 않는 경우 무효가 아니라
실제 값을 반환합니다.

1537
01:20:54,214 --> 01:20:54,692
그래?

1538
01:20:54,692 --> 01:20:58,038
>> 청중 : 당신이 라인을 가지고 있다면 위
반환, [INAUDIBLE]?

1539
01:20:58,038 --> 01:21:01,862

1540
01:21:01,862 --> 01:21:03,730
>> ROB : 리턴 위의 라인?

1541
01:21:03,730 --> 01:21:04,410
>> 청중 : 그래.

1542
01:21:04,410 --> 01:21:10,780
마찬가지로 당신의 printf와 [INAUDIBLE]를 한 경우에,
이 두 번 인쇄 할 것인가?

1543
01:21:10,780 --> 01:21:12,992
>> ROB : foo는 내부 그래서?

1544
01:21:12,992 --> 01:21:15,945
우리는 여기에서 printf가 있다면?

1545
01:21:15,945 --> 01:21:16,750
>> 청중 : 그래.

1546
01:21:16,750 --> 01:21:19,510
>> ROB : 그래서 만약 우리의 printf 권리가
여기서, 한 번 인쇄 할 것이다.

1547
01:21:19,510 --> 01:21:23,400
우리는 한 번 오른쪽 foo는 호출되기 때문에
여기에, 우리는 printf와 충돌합니다.

1548
01:21:23,400 --> 01:21:24,620
그 다음 우리는 줄을 전화 할께.

1549
01:21:24,620 --> 01:21:25,710
그리고 푸 반환합니다.

1550
01:21:25,710 --> 01:21:26,275
그리고 그게 다예요.

1551
01:21:26,275 --> 01:21:30,985
우리는 오직 발생
한번의 printf.

1552
01:21:30,985 --> 01:21:31,482
그래?

1553
01:21:31,482 --> 01:21:32,973
>> 청중 : [들리지]

1554
01:21:32,973 --> 01:21:37,950
우리가 처음이기 때문에 printf의 foo는 호출
의 printf를 호출하고 우리는 통과하고

1555
01:21:37,950 --> 01:21:38,580
인수.

1556
01:21:38,580 --> 01:21:40,960
>> ROB : 이론 그래서이 아니다
printf의 foo는 호출?

1557
01:21:40,960 --> 01:21:42,220
그래서 안돼.

1558
01:21:42,220 --> 01:21:47,360
C가가는 것을 그냥 순서
우리가 할 수있는 전에 이런 일을한다 실행

1559
01:21:47,360 --> 01:21:49,800
, 모든 인수를 함수를 호출
기능에있다

1560
01:21:49,800 --> 01:21:51,600
완전하게 평가.

1561
01:21:51,600 --> 01:21:53,540
따라서이 완전히 평가?

1562
01:21:53,540 --> 01:21:54,610
네, 그냥 문자열입니다.

1563
01:21:54,610 --> 01:21:55,480
그냥 값입니다.

1564
01:21:55,480 --> 01:21:57,200
>> 그 다음 우리는 완전히을해야만
이 평가하고 있습니다.

1565
01:21:57,200 --> 01:21:59,720
이 지금보다도, 작업이 완료되면
인수가 평가됩니다.

1566
01:21:59,720 --> 01:22:01,982
그리고 지금 우리는 만들 수 있습니다
의 printf 호출합니다.

1567
01:22:01,982 --> 01:22:02,478
그래?

1568
01:22:02,478 --> 01:22:03,966
>> 청중 : 질문 하나.

1569
01:22:03,966 --> 01:22:06,942
당신이 무효 기능이있는 경우, 반드시
당신은 반환 세미콜론이?

1570
01:22:06,942 --> 01:22:09,910
>> ROB : 당신은 반환 세미콜론하지 않습니다
당신은 무효 기능이있는 경우.

1571
01:22:09,910 --> 01:22:13,370

1572
01:22:13,370 --> 01:22:14,780
확인을 클릭합니다.

1573
01:22:14,780 --> 01:22:15,830
그래서 지금 일부 힙 물건.

1574
01:22:15,830 --> 01:22:19,640
그래서 힙은 우리가 처리하는거야 방법이다
동적 메모리 관리와 함께.

1575
01:22:19,640 --> 01:22:23,100
그리고이 직접 대조
우리는 자동으로 부를 것이다 스택

1576
01:22:23,100 --> 01:22:24,100
메모리 관리.

1577
01:22:24,100 --> 01:22:27,140
>> 스택에 그래서, 당신은 정말 결코
어떻게 지역 변수를 다루는

1578
01:22:27,140 --> 01:22:30,400
밀어 모든 태어 났죠되고있다
이 스택 프레임과 모든 물건.

1579
01:22:30,400 --> 01:22:31,070
당신은 그것에 대해 걱정할 필요가 없습니다.

1580
01:22:31,070 --> 01:22:32,070
그것은 자동입니다.

1581
01:22:32,070 --> 01:22:36,990
그래서 힙은 수동이다.

1582
01:22:36,990 --> 01:22:38,070
그리고 [INAUDIBLE]

1583
01:22:38,070 --> 01:22:41,260
이러한 기능에서 온다
malloc에​​ 무료.

1584
01:22:41,260 --> 01:22:43,550
>> 그래서 여기에 다른 프로그램입니다.

1585
01:22:43,550 --> 01:22:47,145
우리가하고있는 모든 mallocing입니다
정수.

1586
01:22:47,145 --> 01:22:49,360
우리는 스타 X에 저장하고 있습니다.

1587
01:22:49,360 --> 01:22:52,520
물론, 우리는 확인해야
x는 null의 경우 볼 수 있습니다.

1588
01:22:52,520 --> 01:22:56,400
그럼 우리는 무엇을 만들 것이다
X는 50를 가리키고 있습니다.

1589
01:22:56,400 --> 01:23:00,350

1590
01:23:00,350 --> 01:23:03,260
, 가리키는 어떤 X 인쇄
인쇄 X, 다음 무료 X.

1591
01:23:03,260 --> 01:23:08,920
>> 그래서 실제로 어떻게 볼 것입니다
우리는 우리의 스택과 힙 보면?

1592
01:23:08,920 --> 01:23:10,950
그래서 우리는 다시 시작합니다.

1593
01:23:10,950 --> 01:23:12,580
이전과 같이 우리의 스택의 바닥.

1594
01:23:12,580 --> 01:23:15,930
그대가 바로 힙 기억
스택에 반대?

1595
01:23:15,930 --> 01:23:18,850
그래서 우리는이 겁니다
거기 우리의 힙 맨.

1596
01:23:18,850 --> 01:23:22,590
>> 우리의 스택의 하단 그래서, 우리가
주에 대한 우리의 스택 프레임.

1597
01:23:22,590 --> 01:23:28,000
그것은는 argc, argv를위한 공간을 갖고, 우리
이제 로컬 변수 x를 가지고있는

1598
01:23:28,000 --> 01:23:30,030
INT 스타이다.

1599
01:23:30,030 --> 01:23:32,240
그래서 우리는 반복하는거야
이 프로그램을 통해.

1600
01:23:32,240 --> 01:23:34,420
우리가 우선이다
malloc을 호출.

1601
01:23:34,420 --> 01:23:36,250
>> 그래서 우리의 malloc를 호출하는 것입니다.

1602
01:23:36,250 --> 01:23:37,100
MALLOC는 기능입니다.

1603
01:23:37,100 --> 01:23:38,770
그것은 스택 프레임을 얻을 것입니다.

1604
01:23:38,770 --> 01:23:40,180
우리는 MALLOC하기 위해 전달하는?

1605
01:23:40,180 --> 01:23:41,610
그 안에 갈거야
스택 프레임.

1606
01:23:41,610 --> 01:23:45,130
우리는 4 N의 크기를 전달하고 있습니다.

1607
01:23:45,130 --> 01:23:49,700
그래서는 malloc에​​ 전달됩니다.

1608
01:23:49,700 --> 01:23:50,910
>> malloc에​​ 기능은 무엇입니까?

1609
01:23:50,910 --> 01:23:53,820
그것은 우리에게 힙의 일부 공간을 잡으십시오.

1610
01:23:53,820 --> 01:23:55,320
그래서 우리는 힙에 갈 것입니다.

1611
01:23:55,320 --> 01:23:57,990
그리고 우리는 잡아거야
힙에서 4 바이트.

1612
01:23:57,990 --> 01:24:01,500
그래서 그냥 그 시간을 가집시다
임의의 주소입니다.

1613
01:24:01,500 --> 01:24:06,680
0x123 그냥 그 척
힙에 주소를 입력합니다.

1614
01:24:06,680 --> 01:24:12,300
>> 그래서 내부에 실제로 무엇인가
주소 Ox123에서 메모리의 영역?

1615
01:24:12,300 --> 01:24:13,080
쓰레기.

1616
01:24:13,080 --> 01:24:15,270
그래서 우리는 아무것도 저장하지 않았습니다.

1617
01:24:15,270 --> 01:24:18,830
그래서 지금까지 우리가 알고있는
무엇이든 될 수있다.

1618
01:24:18,830 --> 01:24:20,560
당신은 제로되어 있다고 가정해서는 안된다.

1619
01:24:20,560 --> 01:24:23,870
이 제로가 아닌 가장 가능성이 높습니다.

1620
01:24:23,870 --> 01:24:26,260
>> 그래서 지금의 malloc 돌아갑니다.

1621
01:24:26,260 --> 01:24:28,020
그리고 우리는 때 malloc에​​ 반환을 어떻게해야합니까?

1622
01:24:28,020 --> 01:24:29,800
우리는 반환 무엇을 설정합니다.

1623
01:24:29,800 --> 01:24:32,290
우리는 동일한 X를 설정할 것을
이 반환됩니다.

1624
01:24:32,290 --> 01:24:33,690
그래서 그것은 반환?

1625
01:24:33,690 --> 01:24:38,150
즉이 때문에이 0x123을 돌아오고
메모리 블록의 어드레스가 그것이

1626
01:24:38,150 --> 01:24:40,850
바로 힙에 할당.

1627
01:24:40,850 --> 01:24:47,160
>> 그래서 0x123 x는 이제 설정 될 것입니다 반환
0x123에 해당하는 그림으로,

1628
01:24:47,160 --> 01:24:52,940
우리는 자주 실제를 갖는 X로 그릴
그 블록을 가리키는 화살표.

1629
01:24:52,940 --> 01:24:55,820
그러나 X는 그 주소를 저장한다.

1630
01:24:55,820 --> 01:24:58,670
그래서 지금 우리는 X가 null인지 확인해야합니다.

1631
01:24:58,670 --> 01:24:59,120
그것은 널 (null)이 아닙니다.

1632
01:24:59,120 --> 01:25:02,170
우리는 malloc에​​ 성공 척.

1633
01:25:02,170 --> 01:25:04,950
>> 그래서 지금 스타 X 50와 같습니다.

1634
01:25:04,950 --> 01:25:08,450
그래서 별은 그 의미 기억
해당 주소로 이동합니다.

1635
01:25:08,450 --> 01:25:12,700
그래서 0x123 우리는에 갈거야
해당 주소로 이동합니다.

1636
01:25:12,700 --> 01:25:14,660
그래서이 우리를 제공합니다.

1637
01:25:14,660 --> 01:25:16,310
우리는 그 주소에 뭐하는거야?

1638
01:25:16,310 --> 01:25:19,020
우리는 50를 저장하고 있습니다.

1639
01:25:19,020 --> 01:25:22,500
>> 그래서이 선 후, 그게 무슨입니다
가지처럼 보이는 것입니다.

1640
01:25:22,500 --> 01:25:24,640
그래서 지금은 더 이상 없다
이 쓰레기입니다.

1641
01:25:24,640 --> 01:25:28,910
이제 우리는 50가에있는 것을 알고
특정 주소 때문에

1642
01:25:28,910 --> 01:25:32,410
우리는로 설​​정합니다.

1643
01:25:32,410 --> 01:25:32,790
OK?

1644
01:25:32,790 --> 01:25:34,370
그래서 지금 우리는 F를 인쇄하는 것입니다.

1645
01:25:34,370 --> 01:25:38,490
>> 그래서 우리는 먼저 스타 X를 인쇄 할 것입니다.

1646
01:25:38,490 --> 01:25:39,640
그래서 스타 X는 무엇인가?

1647
01:25:39,640 --> 01:25:44,300
다시 말하지만, 스타 X는로 이동을 의미
X가 가리키는 것을 것.

1648
01:25:44,300 --> 01:25:47,140
그래서 X는 그에게 0x123 이동 저장됩니다.

1649
01:25:47,140 --> 01:25:48,490
우리는 50를 얻는다.

1650
01:25:48,490 --> 01:25:50,540
그래서 f를 인쇄 할 수 있습니다.

1651
01:25:50,540 --> 01:25:54,900
그리고 그것이 50를 인쇄 할 것을 의미한다.

1652
01:25:54,900 --> 01:25:56,850
그리고 반환합니다.

1653
01:25:56,850 --> 01:25:58,340
>> 그리고 우리는 두 번째의 printf 있습니다.

1654
01:25:58,340 --> 01:25:59,370
우리는 지금 %의 페이지이야.

1655
01:25:59,370 --> 01:26:01,680
당신이 그것을 볼 수없는 경우, 그건
당신은 포인터를 인쇄하는 방법.

1656
01:26:01,680 --> 01:26:04,960
그래서 우리는 퍼센트 %의 난이
F, 이미 그 모든.

1657
01:26:04,960 --> 01:26:07,160
그래서 %의 p는 포인터를 인쇄 할 수 있습니다.

1658
01:26:07,160 --> 01:26:08,920
>> 따라서 X는 포인터이다.

1659
01:26:08,920 --> 01:26:13,440
그래서 우리는 자체 x를 인쇄 할 거라면,
우리는 내부에 실제로 무엇을 인쇄하는

1660
01:26:13,440 --> 01:26:19,220
그래서 첫번째 0x123 인 X
인쇄 F (50)를 인쇄하는 것입니다.

1661
01:26:19,220 --> 01:26:23,620
두 번째 인쇄 F는 것입니다
네 0x123을 인쇄?

1662
01:26:23,620 --> 01:26:27,460
>> 청중 : 당신이 퍼센트를 사용하십니까
X 포인터를 인쇄하려면?

1663
01:26:27,460 --> 01:26:31,200
>> ROB : 그래서 당신은 퍼센트를 사용합니까
X 포인터를 인쇄하려면?

1664
01:26:31,200 --> 01:26:38,350
그래서, 당신은 할 수 있지만 퍼센트 x는 단지입니다
일반적으로, 대한 등 일부있는 경우

1665
01:26:38,350 --> 01:26:40,325
정수 및 인쇄하려는
그것은 진수로.

1666
01:26:40,325 --> 01:26:43,250

1667
01:26:43,250 --> 01:26:44,880
당신이 어떻게 그건 그냥입니다.

1668
01:26:44,880 --> 01:26:47,160
>> 반면, %의 D는 것
소수로 인쇄 할 수 있습니다.

1669
01:26:47,160 --> 01:26:50,310
우리가 퍼센트를 얻을 수 있다고이다
라. 난 그냥 정수입니다.

1670
01:26:50,310 --> 01:26:52,690
퍼센트 p는 구체적이며
포인터합니다.

1671
01:26:52,690 --> 01:26:54,060
>> 따라서 X는 포인터이다.

1672
01:26:54,060 --> 01:26:56,360
우리는 %의 페이지를 사용하고 싶습니다.

1673
01:26:56,360 --> 01:26:57,937
그러나 %의 x는 일할 수 있습니다.

1674
01:26:57,937 --> 01:26:58,414
그래?

1675
01:26:58,414 --> 01:26:59,664
>> 청중 : [들리지?

1676
01:26:59,664 --> 01:27:04,138

1677
01:27:04,138 --> 01:27:05,388
>> ROB : 그래.

1678
01:27:05,388 --> 01:27:07,870

1679
01:27:07,870 --> 01:27:13,440
여기에는 적어도 그렇게 다시 전화 I
여기에 포함되지 않았다.

1680
01:27:13,440 --> 01:27:19,850
그러나이 두 개의 인수가 필요하다
이 스택 프레임의 내부

1681
01:27:19,850 --> 01:27:23,040
로컬 변수와 함께
printf와는 사용하는 것으로 발생합니다.

1682
01:27:23,040 --> 01:27:27,020
그리고 그 다음 호출은 지금의 printf
printf의 내부 스택 프레임이다

1683
01:27:27,020 --> 01:27:33,960
퍼센트 P는 백 슬래시 n 및 어떤
X의 값이 0x123 인이다.

1684
01:27:33,960 --> 01:27:34,425
그래?

1685
01:27:34,425 --> 01:27:35,675
>> 청중 : [들리지?

1686
01:27:35,675 --> 01:27:38,145

1687
01:27:38,145 --> 01:27:40,880
>> ROB : 그것은 뭔가를 인쇄 해드립니다
즉, 다음과 같습니다.

1688
01:27:40,880 --> 01:27:41,846
>> 청중 : [들리지].

1689
01:27:41,846 --> 01:27:44,510
>> ROB : 그래서 그것은 주소 형태로 인쇄됩니다.

1690
01:27:44,510 --> 01:27:47,003
이 주소처럼 보인다.

1691
01:27:47,003 --> 01:27:47,494
그래?

1692
01:27:47,494 --> 01:27:49,458
>> 청중 : [들리지?

1693
01:27:49,458 --> 01:27:51,075
>> ROB : 왜 무엇입니까?

1694
01:27:51,075 --> 01:27:52,920
>> 청중 : [들리지?

1695
01:27:52,920 --> 01:27:55,240
>> ROB : 왜이​​ 포인터는 4 바이트?

1696
01:27:55,240 --> 01:27:58,500
그래서 전체 무리가있다
이 앞의 0.

1697
01:27:58,500 --> 01:28:03,740
그래서 정말 0x0000000123입니다.

1698
01:28:03,740 --> 01:28:06,510
64 비트 시스템에서있을 것입니다
더 제로의 전체 무리.

1699
01:28:06,510 --> 01:28:11,410

1700
01:28:11,410 --> 01:28:11,900
그래?

1701
01:28:11,900 --> 01:28:13,150
>> 청중 : [들리지].

1702
01:28:13,150 --> 01:28:17,290

1703
01:28:17,290 --> 01:28:21,130
>> ROB : 그래서 첫 번째의 printf
글씨 것입니다

1704
01:28:21,130 --> 01:28:21,980
>> 청중 : [들리지].

1705
01:28:21,980 --> 01:28:24,420
>> ROB : 예, 그것은 인쇄 할 것
어떤 X를 가리키고 있습니다.

1706
01:28:24,420 --> 01:28:27,030

1707
01:28:27,030 --> 01:28:29,070
별이 무엇인지 말한다
일을 가리키는.

1708
01:28:29,070 --> 01:28:30,300
그것을 잡아.

1709
01:28:30,300 --> 01:28:31,455
그래서 가리키는 무엇?

1710
01:28:31,455 --> 01:28:31,850
50.

1711
01:28:31,850 --> 01:28:32,410
그것을 잡아.

1712
01:28:32,410 --> 01:28:33,390
즉, 우리가 인쇄 할거야거야.

1713
01:28:33,390 --> 01:28:37,020
다음 하나, 반면에, 우리는있어
단지 자체 x를 인쇄.

1714
01:28:37,020 --> 01:28:38,850
F의 내부에 무엇입니까?

1715
01:28:38,850 --> 01:28:43,710
0x123.

1716
01:28:43,710 --> 01:28:44,500
확인을 클릭합니다.

1717
01:28:44,500 --> 01:28:46,620
>> 그리고, 마지막으로, 우리는 자유가 있습니다.

1718
01:28:46,620 --> 01:28:48,040
우리는 무료로 전달하는?

1719
01:28:48,040 --> 01:28:49,470
우리는 X를 전달하고 있습니다.

1720
01:28:49,470 --> 01:28:52,380
실제로 표시 시간
그것은 스택 프레임.

1721
01:28:52,380 --> 01:28:56,370
>> 그래서 우리는 값을 전달하고
0x123은 무료입니다.

1722
01:28:56,370 --> 01:28:59,070
그래서 지금 알고 무료, 모든 권리,
나는 힙까지 가야

1723
01:28:59,070 --> 01:29:00,050
그 메모리 무료입니다.

1724
01:29:00,050 --> 01:29:03,920
그것은 더 이상 사용하지 않는 무엇을
주소 0x123에있다.

1725
01:29:03,920 --> 01:29:07,010
>> 그래서 무료로 출시 할 예정이다
힙에서 해당.

1726
01:29:07,010 --> 01:29:09,490
이제 우리의 힙을 다시 비어 있습니다.

1727
01:29:09,490 --> 01:29:11,120
우리는 메모리 누수가 없다.

1728
01:29:11,120 --> 01:29:12,940
지금 무료로 반환합니다.

1729
01:29:12,940 --> 01:29:16,130
x가 여전히 0x123입니다 알 수 있습니다.

1730
01:29:16,130 --> 01:29:18,240
하지만 지금은 유효 메모리 아니다.

1731
01:29:18,240 --> 01:29:21,220

1732
01:29:21,220 --> 01:29:23,986
우리는 더 이상 역 참조 x를해야한다.

1733
01:29:23,986 --> 01:29:24,440
그래?

1734
01:29:24,440 --> 01:29:27,240
>> 관객 : 0 중복을 반환인가?

1735
01:29:27,240 --> 01:29:28,290
>> 롭 : 0 중복을 returen 있습니까?

1736
01:29:28,290 --> 01:29:31,110
예.

1737
01:29:31,110 --> 01:29:33,950
우리는 그냥 그 때문에 넣어
우리는 공기 반환 일이있다.

1738
01:29:33,950 --> 01:29:36,830
그래서 그래, 할 수처럼,
반환 0을 포함한다.

1739
01:29:36,830 --> 01:29:37,310
그래?

1740
01:29:37,310 --> 01:29:38,560
>> 청중 : [들리지?

1741
01:29:38,560 --> 01:29:42,110

1742
01:29:42,110 --> 01:29:45,580
>> ROB : 그래서 무료 X 후, 어떻게하면 어떻게
우리는 포인터를 역 참조하려고?

1743
01:29:45,580 --> 01:29:47,240
아무것도 잘못하지 가능성이 있습니다.

1744
01:29:47,240 --> 01:29:49,330
우리는 여전히 50을 얻을 것이다 것을이 가능합니다.

1745
01:29:49,330 --> 01:29:53,590
>> 그것은 그 메모리가 있음을, 또한 가능
지금은 다른 것에 사용된다.

1746
01:29:53,590 --> 01:29:57,140
그래서 정의되지 않은 동작입니다.

1747
01:29:57,140 --> 01:30:00,772
그리고 정의는 무​​슨 의미
발생할 수 있습니다.

1748
01:30:00,772 --> 01:30:01,250
그래?

1749
01:30:01,250 --> 01:30:02,500
>> 청중 : [들리지?

1750
01:30:02,500 --> 01:30:07,942

1751
01:30:07,942 --> 01:30:10,830
>> ROB : 아니, 그래서 당신이 할당 한 경우
뭔가 다른 X.

1752
01:30:10,830 --> 01:30:15,870
그래서 여기 경우 우리는 x는 동일했다
malloc에​​ 뭔가 다른 걸 가져 오세요

1753
01:30:15,870 --> 01:30:17,100
malloc에​​ 크기가되면 ..

1754
01:30:17,100 --> 01:30:20,180
그 원래의 블록
메모리 해제되지 않습니다.

1755
01:30:20,180 --> 01:30:21,490
그리고 우리는 공식적를 잃었다.

1756
01:30:21,490 --> 01:30:23,150
즉, 메모리 누출이다.

1757
01:30:23,150 --> 01:30:25,090
우리는 모든 참조를 잃었습니다
메모리의 블록.

1758
01:30:25,090 --> 01:30:26,827
그래서 우리가 그것을 확보 할 수있는 방법은 없습니다.

1759
01:30:26,827 --> 01:30:32,074

1760
01:30:32,074 --> 01:30:36,630
좋아, 그럼 다음 수행 영 수단을 반환합니다.

1761
01:30:36,630 --> 01:30:37,900
>> 좋아요, 스택 오버 플로우.

1762
01:30:37,900 --> 01:30:39,320
여기에서 아이디어는 무엇입니까?

1763
01:30:39,320 --> 01:30:41,210
그래서 기억, 힙 내리고 있습니다.

1764
01:30:41,210 --> 01:30:43,480
스택은 올라가고있다.

1765
01:30:43,480 --> 01:30:48,000
그래서이 강의의 예는 있었다
어디서 주요 단지에 가고, 생각

1766
01:30:48,000 --> 01:30:51,380
것입니다이 함수 foo를 호출
를 통해 자신을 재귀 적으로 호출하고,

1767
01:30:51,380 --> 01:30:52,320
또 다시.

1768
01:30:52,320 --> 01:30:55,370
>> 그래서 프레임에가는 스택
동일한 작동합니다.

1769
01:30:55,370 --> 01:30:58,130
그래서 우리는 주와 함께 시작하는거야
하부 스택 프레임으로서.

1770
01:30:58,130 --> 01:31:02,000
그리고 메인은 foo는 호출하려고하는
스택 프레임을 얻을 것입니다.

1771
01:31:02,000 --> 01:31:04,260
>> 그런 다음 foo는 foo는 전화 것입니다
다시, 어떤 얻을 것입니다

1772
01:31:04,260 --> 01:31:05,500
다른 스택 프레임.

1773
01:31:05,500 --> 01:31:08,270
그리고 또 다시, 다시,
다시 때까지, 결국, 우리는 실행

1774
01:31:08,270 --> 01:31:09,190
힙에.

1775
01:31:09,190 --> 01:31:11,990
그래서 우리가 얻는 방법이다
스택 오버 플로우.

1776
01:31:11,990 --> 01:31:14,910
그리고이 시점에서, 당신은 세그먼트 오류.

1777
01:31:14,910 --> 01:31:17,335
아니면 정말 독방 감금하기 전에 결함 것
이 시점하지만 그래.

1778
01:31:17,335 --> 01:31:19,660
>> 청중 : 코어 덤프입니다
독방 ​​감금 오류와 동일?

1779
01:31:19,660 --> 01:31:26,140
>> ROB : 그래서 당신은 분할을 볼 수 있습니다
결함 코어 덤프.

1780
01:31:26,140 --> 01:31:28,760
당신은 코어 덤프 때 얻을
당신은 세그먼트 오류.

1781
01:31:28,760 --> 01:31:32,580
그리고 그것은 모두의 덤프처럼
현재 메모리의 내용이 너무

1782
01:31:32,580 --> 01:31:36,670
당신이 시도하고 식별 할 수
왜 오류가 발생한 SEG.

1783
01:31:36,670 --> 01:31:37,135
그래?

1784
01:31:37,135 --> 01:31:38,385
>> 청중 : [들리지?

1785
01:31:38,385 --> 01:31:40,855

1786
01:31:40,855 --> 01:31:45,460
>> ROB : 그래서 세그먼트 오류 수단
스택 오버플로가있다.

1787
01:31:45,460 --> 01:31:47,060
그래서 반드시.

1788
01:31:47,060 --> 01:31:49,880
세그먼트 오류는 걸 의미
방법 만지고 메모리

1789
01:31:49,880 --> 01:31:50,880
당신은 안됩니다.

1790
01:31:50,880 --> 01:31:54,750
그래서 일어나는 하나의 방법은, 때입니다
당신은 우리가 접촉을 시작, 스택 오버플로

1791
01:31:54,750 --> 01:31:58,736
우리가하지 않아야하는 방식으로 메모리.

1792
01:31:58,736 --> 01:31:59,208
그래?

1793
01:31:59,208 --> 01:32:00,458
>> 청중 : [들리지?

1794
01:32:00,458 --> 01:32:03,456

1795
01:32:03,456 --> 01:32:05,830
>> ROB : 무한 루프 내부에 그래서.

1796
01:32:05,830 --> 01:32:08,770
마찬가지로,이 재귀 무한 같다
루프 그래서 우리는 서로를 얻을

1797
01:32:08,770 --> 01:32:09,770
스택마다 프레임.

1798
01:32:09,770 --> 01:32:13,540
하지만 그냥 일반의 내부
무한 보이면 동안

1799
01:32:13,540 --> 01:32:16,390
음, 심지어 인쇄 할 수 있도록 저게 ...

1800
01:32:16,390 --> 01:32:17,040
뭔가.

1801
01:32:17,040 --> 01:32:18,390
무엇이든.

1802
01:32:18,390 --> 01:32:20,610
>> 우리는 얻지 않을 것
다른 스택 프레임.

1803
01:32:20,610 --> 01:32:22,530
우리는 단지 루프를 유지하는거야
이 단일 명령어를 통해.

1804
01:32:22,530 --> 01:32:23,920
스택은 성장하지 않습니다.

1805
01:32:23,920 --> 01:32:27,290
각 재귀 그 사실
호출은 우리에게 스택 프레임을주고있다.

1806
01:32:27,290 --> 01:32:31,231
우리는 스택 오버 플로우를 얻을 이유입니다.

1807
01:32:31,231 --> 01:32:31,728
그래?

1808
01:32:31,728 --> 01:32:38,189
>> 관객 : 그래서 만약 당신이를 얻을 수 있다고
루프 잠시 후, [INAUDIBLE]?

1809
01:32:38,189 --> 01:32:42,000
>> ROB : 경우 while 루프의 내부 그래서
printf의 거기, 당신은 여전히​​ 것

1810
01:32:42,000 --> 01:32:42,790
독방 ​​감금 과실이 없음.

1811
01:32:42,790 --> 01:32:46,090
난 그냥 일을 혼동하고 싶지 않았다.

1812
01:32:46,090 --> 01:32:46,610
그것은 루프 것이다.

1813
01:32:46,610 --> 01:32:48,225
단일 스택을 얻을 것
printf의 프레임입니다.

1814
01:32:48,225 --> 01:32:49,580
>> 다음의 printf는 반환합니다.

1815
01:32:49,580 --> 01:32:50,280
그럼 당신은 다시 루프를 것입니다.

1816
01:32:50,280 --> 01:32:51,460
단일 스택을 얻을 것
printf의 프레임입니다.

1817
01:32:51,460 --> 01:32:52,850
그것은 반환합니다.

1818
01:32:52,850 --> 01:32:54,060
단일 스택 프레임.

1819
01:32:54,060 --> 01:33:00,215
그래서 당신은이 무한한를 얻을 수는 없을 겁니다
스택 프레임을 쌓아.

1820
01:33:00,215 --> 01:33:03,185
>> 청중 : [들리지?

1821
01:33:03,185 --> 01:33:04,040
>> ROB : 예.

1822
01:33:04,040 --> 01:33:09,360
그래서이 스택 오버 플로우가 발생
이 중 어느 것도 있기 때문에

1823
01:33:09,360 --> 01:33:11,600
foo는 호출이 반환됩니다.

1824
01:33:11,600 --> 01:33:15,250
우리가 반환하는 경우, 우리는 것 그래서
스택 프레임을 잃고 시작합니다.

1825
01:33:15,250 --> 01:33:17,870
그리고 우리는 스택 오버 플로우하지 않을 것이다.

1826
01:33:17,870 --> 01:33:20,070
당신은 기본 케이스가 필요 이유입니다
개인 기능에 대한.

1827
01:33:20,070 --> 01:33:22,992

1828
01:33:22,992 --> 01:33:23,479
그래?

1829
01:33:23,479 --> 01:33:27,375
>> 관객 : 잠재적 인 크기와인가
힙 동일위한 스택

1830
01:33:27,375 --> 01:33:29,880
모든 프로그램?

1831
01:33:29,880 --> 01:33:31,910
>> ROB : 대략.

1832
01:33:31,910 --> 01:33:35,090
가요 스택의 잠재적 인 크기와
모든 프로그램에 대해 동일한 힙?

1833
01:33:35,090 --> 01:33:37,180
대략.

1834
01:33:37,180 --> 01:33:40,080
일부 무작위로가
여기서 스택 시작될

1835
01:33:40,080 --> 01:33:42,400
여기서 힙이 시작됩니다.

1836
01:33:42,400 --> 01:33:45,870
당신의 전체를 많이해야하는 일이 있다면
전역 변수와 가지, 당신은 수도

1837
01:33:45,870 --> 01:33:49,520
일부 공간에서 빼앗아
당신의 힙.

1838
01:33:49,520 --> 01:33:54,060
>> 64 비트 시스템에서, 거의
무한한 메모리를 가지고있다.

1839
01:33:54,060 --> 01:33:55,820
너무 많이있다.

1840
01:33:55,820 --> 01:33:59,250
32 비트와 64 비트, 그 사이
유의 한 차이가있다.

1841
01:33:59,250 --> 01:34:02,350
>> 좀 더 전체를 많이받을거야
64 비트 스택과 힙 공간

1842
01:34:02,350 --> 01:34:05,810
시스템 그냥 더있어 때문에
그들이 사용할 수있는 주소.

1843
01:34:05,810 --> 01:34:09,360
그러나 개별 시스템에, 그것은 것
스택의 거의 같은 금액

1844
01:34:09,360 --> 01:34:10,785
힙 공간입니다.

1845
01:34:10,785 --> 01:34:13,635

1846
01:34:13,635 --> 01:34:15,530
좋아.

1847
01:34:15,530 --> 01:34:18,220
>> 그래서 마지막 것은 편집이다.

1848
01:34:18,220 --> 01:34:19,810
그래서 당신은이 과정을 알고 있어야합니다.

1849
01:34:19,810 --> 01:34:22,240
4 개의 큰 단계가 있습니다.

1850
01:34:22,240 --> 01:34:24,400
따라서 첫 번째해야
기억하기 쉬운합니다.

1851
01:34:24,400 --> 01:34:25,085
사전 처리.

1852
01:34:25,085 --> 01:34:28,390
그것은에 미리 접두사가 있습니다.

1853
01:34:28,390 --> 01:34:32,080
그래서 다른 모든 전에 온다.

1854
01:34:32,080 --> 01:34:34,000
>> 기억해야 할 점은 해시입니다.

1855
01:34:34,000 --> 01:34:37,250
그래서 해시 정의하고 해시 포함
모든 이들의.

1856
01:34:37,250 --> 01:34:39,560
그 이전의 모든 프로세서 아르
지시어.

1857
01:34:39,560 --> 01:34:42,030
이러한 것들입니다
프리 프로세서의 처리합니다.

1858
01:34:42,030 --> 01:34:43,680
>> 그래서 미리 프로세서는 무엇을합니까?

1859
01:34:43,680 --> 01:34:44,850
그것은 정말 바보 같은 일입니다.

1860
01:34:44,850 --> 01:34:49,380
그것의 능력을 모든이 모든 아르
복사, 잘라 내기 및 붙여 넣기 작업.

1861
01:34:49,380 --> 01:34:51,790
>> 그래서 해시 표준 I0 도트 시간을 포함한다.

1862
01:34:51,790 --> 01:34:52,990
일하는거야?

1863
01:34:52,990 --> 01:34:56,610
이것은 표준 I0 도트 시간을 잡는 것
파일 상단에 붙여

1864
01:34:56,610 --> 01:34:58,960
어디는 해시 포함 말한다
표준 I0 도트 시간.

1865
01:34:58,960 --> 01:35:02,480
>> 그리고 어떤 해시는 우리가했다고 정의
볼, 무엇을하고 있는지?

1866
01:35:02,480 --> 01:35:06,730
그 해시 값을 해당 복사
로 붙여 넣기 정의 정의 된

1867
01:35:06,730 --> 01:35:08,500
어디든지 값을 사용하고 있습니다.

1868
01:35:08,500 --> 01:35:13,400
그래서 처리기는 진짜로
간단한 텍스트 기반 작업.

1869
01:35:13,400 --> 01:35:15,870
그것은 스마트 아무것도하지 않는다.

1870
01:35:15,870 --> 01:35:18,920
그래서 다른 모든 것들입니다
더 복잡합니다.

1871
01:35:18,920 --> 01:35:22,970
>> 그래서 지금 처리기입니다
완료, 우리가 실제로 컴파일합니다.

1872
01:35:22,970 --> 01:35:24,320
그래서 컴파일은 무엇을 의미 하는가?

1873
01:35:24,320 --> 01:35:27,310
우리는 지금 C 코드에서거야
어셈블리 코드에 관한 것이다.

1874
01:35:27,310 --> 01:35:27,570
그래?

1875
01:35:27,570 --> 01:35:28,820
>> 청중 : [들리지?

1876
01:35:28,820 --> 01:35:32,390

1877
01:35:32,390 --> 01:35:34,220
>> ROB : 그래, 우리는 그것을 붙 잡았다.

1878
01:35:34,220 --> 01:35:36,880

1879
01:35:36,880 --> 01:35:38,660
그래서 컴파일.

1880
01:35:38,660 --> 01:35:40,310
우리는 어셈블리 C에서거야.

1881
01:35:40,310 --> 01:35:42,470
이것이 실제 언어 변경이다.

1882
01:35:42,470 --> 01:35:45,240
자신을 컴파일에서가는 의미
에 더 높은 수준의 언어

1883
01:35:45,240 --> 01:35:47,340
낮은 수준의 언어입니다.

1884
01:35:47,340 --> 01:35:50,720
>> c는 하이 레벨 언어
조립에 비해.

1885
01:35:50,720 --> 01:35:52,320
어셈블리는 무엇입니까?

1886
01:35:52,320 --> 01:35:56,440
아르 그 지침, 꽤
많은 당신의 CPU에했다.

1887
01:35:56,440 --> 01:35:59,130
하지만 당신의 컴퓨터는 않습니다
어셈블리를 이해하지.

1888
01:35:59,130 --> 01:36:01,570
그것은 단지 1과 0을 이해한다.

1889
01:36:01,570 --> 01:36:06,160
그렇다면 다음 단계는, 조립 된
이 지침에서 우리를 가져온다

1890
01:36:06,160 --> 01:36:08,760
당신의 CPU가 이해하고 실제로
으로 그들을 변환

1891
01:36:08,760 --> 01:36:10,820
1과 0.

1892
01:36:10,820 --> 01:36:13,570
>> 이진 어셈블리 C 그래서.

1893
01:36:13,570 --> 01:36:15,870
하지만 아직 실행이되지 않습니다.

1894
01:36:15,870 --> 01:36:19,550
그래서 CS50 라이브러리 생각합니다.

1895
01:36:19,550 --> 01:36:23,070
우리는 진에 대한 당신을 제공 한
있는 getString이이 CS50 라이브러리

1896
01:36:23,070 --> 01:36:24,400
과의 getInt와 모든 것을.

1897
01:36:24,400 --> 01:36:25,700
>> 그러나 CS50 library--

1898
01:36:25,700 --> 01:36:27,650
와 itself--의 것은 실행되지 않습니다.

1899
01:36:27,650 --> 01:36:29,570
그것은 주요 기능을 가지고 있지 않습니다.

1900
01:36:29,570 --> 01:36:32,230
그것은 이진의 무리 일 뿐이야
당신이 사용할 수있다.

1901
01:36:32,230 --> 01:36:41,730
그래서 링크는 우리가 모두 함께 가지고하는 방법이다
서로 다른 이진 파일의

1902
01:36:41,730 --> 01:36:43,110
실제 실행에.

1903
01:36:43,110 --> 01:36:45,900
입력 할 수있는 하나의
점은 점을 슬래시.

1904
01:36:45,900 --> 01:36:51,660
>> 그래서이 파일처럼 당신을
썼다 - 어떤 프로그램은 ...

1905
01:36:51,660 --> 01:36:53,620
Ceaser 도트 다.

1906
01:36:53,620 --> 01:36:55,100
하지만 지금은 컴파일 된 것
진에 이르기까지.

1907
01:36:55,100 --> 01:36:56,480
그래서 Ceaser 도트 오.

1908
01:36:56,480 --> 01:36:59,620
그리고 이것은 우리의 CS50 바이너리 라이브러리를합니다.

1909
01:36:59,620 --> 01:37:02,284
그리고 그들은 결합되고있어
단일 실행에.

1910
01:37:02,284 --> 01:37:02,758
그래?

1911
01:37:02,758 --> 01:37:04,008
>> 청중 : [들리지?

1912
01:37:04,008 --> 01:37:08,800

1913
01:37:08,800 --> 01:37:12,710
>> ROB : 그래서 첫째 포함, 기억
실제로 포함되는 해쉬

1914
01:37:12,710 --> 01:37:13,810
전처리 단계를 포함한다.

1915
01:37:13,810 --> 01:37:14,750
하지만 별도입니다.

1916
01:37:14,750 --> 01:37:20,730
당신은 어떤 기능을 사용하지 않는 경우 해당
다음 단일 파일의 외부에,

1917
01:37:20,730 --> 01:37:26,100
아니, 당신은 아무것도 연결하지 않아도
당신은 모든 것을 가지고 있기 때문이다.

1918
01:37:26,100 --> 01:37:30,310
>> 그 말의 printf는에 연결되고있다.

1919
01:37:30,310 --> 01:37:32,820
당신이 이제까지의 p​​rintf를 사용하는 경우, 그 뭔가
즉에 링크 될 필요

1920
01:37:32,820 --> 01:37:35,740
당신이 작성하지 않은 때문이다.

1921
01:37:35,740 --> 01:37:39,530
그리고, 사실, printf의 자동입니다
에 연결됩니다.

1922
01:37:39,530 --> 01:37:42,760
당신이 알고있는 방법 명령 줄에서 또는 때
당신은 당신이 가지고 참조 make를 입력

1923
01:37:42,760 --> 01:37:46,690
링크가 대시 리터의 CS50,
CS50 라이브러리?

1924
01:37:46,690 --> 01:37:49,070
그런 PRINTF하고, 물건, 것입니다
자동으로 연결합니다.

1925
01:37:49,070 --> 01:37:51,730

1926
01:37:51,730 --> 01:37:53,930
아무것도에 대한 다른 질문?

1927
01:37:53,930 --> 01:37:56,280
>> 청중 : [들리지?

1928
01:37:56,280 --> 01:37:58,300
>> ROB : 연결?

1929
01:37:58,300 --> 01:38:03,450
우리의 모두가
다른 이진 파일.

1930
01:38:03,450 --> 01:38:06,410
이것은 표준적인 예이다
우리가 사용하는이 CS50 라이브러리입니다.

1931
01:38:06,410 --> 01:38:09,960
우리는 컴파일과에 준
이 CS50 라이브러리에 대한 진.

1932
01:38:09,960 --> 01:38:12,410
>> 당신은있는 getString을 사용하려면
프로그램에서.

1933
01:38:12,410 --> 01:38:14,750
그래서 당신은 가서있는 getString를 사용합니다.

1934
01:38:14,750 --> 01:38:19,700
하지만 내 바이너리 코드가없는
getString에, 당신은 당신의 코드를 컴파일 할 때

1935
01:38:19,700 --> 01:38:23,140
아래로, 당신은 실제로 실행되지 수 있습니다
프로그램에서 getString 문자열이기 때문에

1936
01:38:23,140 --> 01:38:25,080
아직 완전히 정의되지.

1937
01:38:25,080 --> 01:38:29,220
>> 당신이 내 진에 연결할 때 그것은 단지이다
그 모든 것을 지금있는 getString이 포함되어

1938
01:38:29,220 --> 01:38:31,130
바로, 사실은 수
있는 getString을 실행합니다.

1939
01:38:31,130 --> 01:38:32,330
내 파일이 완료됩니다.

1940
01:38:32,330 --> 01:38:34,208
그리고 나는이 프로그램을 실행할 수 있습니다.

1941
01:38:34,208 --> 01:38:34,697
그래?

1942
01:38:34,697 --> 01:38:37,631
>> 청중 : 변환 링킹 않음
바이너리 실행 파일?

1943
01:38:37,631 --> 01:38:42,032
당신은 다른 필요가 없습니다 경우에도
라이브러리는 여전히되지 않을 것

1944
01:38:42,032 --> 01:38:44,477
번역 할 필요
[INAUDIBLE]?

1945
01:38:44,477 --> 01:38:48,640
>> ROB : 그래서 실행
이진 아직도있다.

1946
01:38:48,640 --> 01:38:51,750
그냥 전체를 결합하는 것
바이너리의 무리입니다.

1947
01:38:51,750 --> 01:38:55,124

1948
01:38:55,124 --> 01:38:56,591
>> 관객 : 정말 감사합니다.

1949
01:38:56,591 --> 01:38:58,560
>> ROB : 문제 없음.

1950
01:38:58,560 --> 01:38:59,540
다른 질문?

1951
01:38:59,540 --> 01:39:02,001
그렇지 않으면, 우리는 모두 준비.

1952
01:39:02,001 --> 01:39:02,690
좋아.

1953
01:39:02,690 --> 01:39:02,990
감사합니다.

1954
01:39:02,990 --> 01:39:03,590
>> [박수]

1955
01:39:03,590 --> 01:39:04,490
>> 청중 : 감사합니다.

1956
01:39:04,490 --> 01:39:05,740
>> ROB : 그래.

1957
01:39:05,740 --> 01:39:06,582