1
00:00:00,000 --> 00:00:03,000
[Powered by Google Translate] [리뷰] [퀴즈 0]

2
00:00:03,000 --> 00:00:05,000
>> [Lexi 로스, 토미 MacWilliam, 루카스 프레이 타스, 조셉 옹] [하버드 대학]

3
00:00:05,000 --> 00:00:08,000
>> [이 CS50 수 있습니다.] [CS50.TV]

4
00:00:08,000 --> 00:00:10,000
>> 안녕하세요.

5
00:00:10,000 --> 00:00:15,000
이번 주 수요일 일어나고 퀴즈 0,에 대한 검토 세션에 오신 것을 환영합니다.

6
00:00:15,000 --> 00:00:19,000
우리가 오늘 밤 어떻게 할 거냐, 나는, 3 다른 TFS 함께 있어요

7
00:00:19,000 --> 00:00:24,000
함께 우리는 지금까지 과정에서 무슨 짓을했는지에 대한 리뷰를 통해 갈거야.

8
00:00:24,000 --> 00:00:27,000
그것은 100 % 포괄적 않을거야,하지만 당신에게 더 나은 아이디어를 줄 것이다

9
00:00:27,000 --> 00:00:31,000
이미 다운이 무엇과 그래도 수요일 전에 공부를해야합니다.

10
00:00:31,000 --> 00:00:34,000
우리가 함께가는거야 때, 질문이 손을 들어 주시기 바랍니다

11
00:00:34,000 --> 00:00:38,000
하지만 우리는 또한에 시간을 좀해야한다는 점에 유의 최종

12
00:00:38,000 --> 00:00:41,000
우리가 일반적인 질문을 할 예비 -에 몇 분을 통해 얻을한다면,

13
00:00:41,000 --> 00:00:47,000
그래서 염두에 유지, 그래서 우리는 주 0 초에 시작할 거에요.

14
00:00:47,000 --> 00:00:50,000
>> 우리가 먼저 [0 리뷰 퀴즈!] [제 0] [Lexi 로스]하지만 그건 이야기하는

15
00:00:50,000 --> 00:00:53,000
퀴즈의 물류.

16
00:00:53,000 --> 00:00:55,000
>> [물류] [퀴즈 강의 대신 수요일 10분의 10에 개최됩니다]

17
00:00:55,000 --> 00:00:57,000
>> [(자세한 내용은 http://cdn.cs50.net/2012/fall/quizzes/0/about0.pdf을 참조하십시오)]는 10월 10일 (수요일)에 있습니다.

18
00:00:57,000 --> 00:01:00,000
>> 그게이 수요일이고, 당신이 여기이 URL로 이동하는 경우,

19
00:01:00,000 --> 00:01:03,000
어떤은 또한에 링크 CS50.net -이 적힌에서 액세스 할 IT-

20
00:01:03,000 --> 00:01:06,000
당신은을 기반 위치에 대한 정보를 볼 수

21
00:01:06,000 --> 00:01:10,000
마지막 이름 또는 학교 제휴뿐만 아니라,

22
00:01:10,000 --> 00:01:14,000
이 약 정확히 퀴즈 당신이 얻을 수 있다는 덮어 질문의 유형에 무엇을 알려줍니다.

23
00:01:14,000 --> 00:01:19,000
여러분은 또한 섹션에서 퀴즈에 대한 검토 할 수있는 기회를해야한다는 점을 명심,

24
00:01:19,000 --> 00:01:21,000
있도록 TFS는 연습 문제를 통해 갈거야

25
00:01:21,000 --> 00:01:29,000
그리고 그 말은 당신이 여전히 퀴즈에 공부해야 할 곳을보고하는 또 다른 좋은 기회입니다.

26
00:01:29,000 --> 00:01:32,000
비트 앤 바이트로 처음부터 시작하자.

27
00:01:32,000 --> 00:01:35,000
비트 만 0 또는 1입니다 기억

28
00:01:35,000 --> 00:01:38,000
와 바이트 이러한 비트 8 모음입니다.

29
00:01:38,000 --> 00:01:42,000
여기에 비트의 컬렉션을 살펴 보자.

30
00:01:42,000 --> 00:01:44,000
우리가 얼마나 많은 비트를 파악 할 수 있어야합니다.

31
00:01:44,000 --> 00:01:48,000
우리가 계산 어디서 8, 여덟 0 또는 1 단위는 그냥 있습니다.

32
00:01:48,000 --> 00:01:51,000
그리고 이후 8 비트, 1 바이트이야,이

33
00:01:51,000 --> 00:01:53,000
과의 16 진수로 변환 보자.

34
00:01:53,000 --> 00:01:58,000
진수는 기본 16이며, 변환 쉽죠

35
00:01:58,000 --> 00:02:01,000
이진의 숫자가있는 16 진수의 숫자로, 그게 뭔지이다.

36
00:02:01,000 --> 00:02:04,000
우리가해야할 일은 우리가 4 그룹 보는 것입니다

37
00:02:04,000 --> 00:02:07,000
우리는 적절한 16 진수 숫자로 변환합니다.

38
00:02:07,000 --> 00:02:11,000
우리는 정말 0011, 4의 가장 오른쪽 그룹 시작합니다.

39
00:02:11,000 --> 00:02:16,000
정말 함께 3으로 만드는 하나 하나 하나 둘거야.

40
00:02:16,000 --> 00:02:19,000
그리고의는 4의 다른 블록 살펴 보도록하겠습니다.

41
00:02:19,000 --> 00:02:24,000
1101. 그 중 하나가 1, 4 하나 하나 팔거야.

42
00:02:24,000 --> 00:02:28,000
함께 그 디하게하는, 13 될거야

43
00:02:28,000 --> 00:02:32,000
그리고 우리는 16 진수 우리가 0 - 9 가지 않는 기억됩니다.

44
00:02:32,000 --> 00:02:36,000
우리는, 그래서 9시, F를 통해 10 상응 0 이동

45
00:02:36,000 --> 00:02:40,000
F는 15 11 B까지, 등등.

46
00:02:40,000 --> 00:02:44,000
여기 13 D입니다

47
00:02:44,000 --> 00:02:49,000
그래서 우리가 모두 우리 실제로 십진수로 변환

48
00:02:49,000 --> 00:02:52,000
2 전원 각 위치를 취급합니다.

49
00:02:52,000 --> 00:02:58,000
그 중 하나가 1, 2 하나 영 4S, 제로 8s, 한 16, 등등 이예요

50
00:02:58,000 --> 00:03:03,000
그리고 머리에 계산하기가 어렵이지만, 우리는 다음 슬라이드로 이동하는 경우

51
00:03:03,000 --> 00:03:05,000
우리가에 대한 답변을 볼 수 있습니다.

52
00:03:05,000 --> 00:03:09,000
>> 기본적으로 우리는 왼쪽으로 돌아 오른쪽 맞은 편에가는거야

53
00:03:09,000 --> 00:03:14,000
우리는 (2)의 해당 능력으로 각 숫자를 곱한하고 있습니다.

54
00:03:14,000 --> 00:03:19,000
그리고 기억 16 진수 우리는 처음에 0x로이 숫자를 나타냅니다

55
00:03:19,000 --> 00:03:23,000
그래서 우리는 10 진수로 혼동하지 마십시오.

56
00:03:23,000 --> 00:03:29,000
에 계속,이 ASCII 표입니다

57
00:03:29,000 --> 00:03:35,000
그리고 우리가 사용하는 ASCII 문자의 숫자 값에 매핑하는 것입니다.

58
00:03:35,000 --> 00:03:39,000
암호화 pset에 기억 우리는 ASCII 표 광범위하게 사용했다

59
00:03:39,000 --> 00:03:43,000
암호화의 다양한 방법을 사용하기 위해서는하면,

60
00:03:43,000 --> 00:03:47,000
다른 문자를 변환 할 수있는 시저와 Vigenère의 암호,

61
00:03:47,000 --> 00:03:52,000
사용자가 지정한 키에 따라 문자열 인치

62
00:03:52,000 --> 00:03:56,000
가 ASCII 수학 약간 살펴 보도록하겠습니다.

63
00:03:56,000 --> 00:04:02,000
Q 될 문자 형태로, 'P'에 + 1을 보면

64
00:04:02,000 --> 00:04:07,000
와 '5 '가 ≠ 5 기억.

65
00:04:07,000 --> 00:04:10,000
그리고 어떻게 우리가 정확히 그 두 형태 사이의 변환을까요?

66
00:04:10,000 --> 00:04:13,000
사실은 너무 복잡하지 않아서 좋아.

67
00:04:13,000 --> 00:04:16,000
5 얻기 위해서 우리는 '0을 빼야 '

68
00:04:16,000 --> 00:04:20,000
때문에 '0 사이의 5 개 지역이 있습니다 '와 '5가.'

69
00:04:20,000 --> 00:04:23,000
우리가 0을 추가 다른 방법으로 이동하기 위해하는 것은

70
00:04:23,000 --> 00:04:25,000
그래서 일반 산술 같은 종류의입니다.

71
00:04:25,000 --> 00:04:29,000
그냥 뭔가 주위 따옴표가있는 경우는 캐릭터 기억

72
00:04:29,000 --> 00:04:37,000
그래서 ASCII 테이블의 값에 해당합니다.

73
00:04:37,000 --> 00:04:40,000
보다 일반적인 컴퓨터 과학 주제로 이동.

74
00:04:40,000 --> 00:04:43,000
우리는 우리가 프로그래밍 사용하는 알고리즘은 무엇이며 어떻게 배웠습니다

75
00:04:43,000 --> 00:04:45,000
알고리즘을 구현합니다.

76
00:04:45,000 --> 00:04:48,000
알고리즘의 예로는 같은 정말 간단한 무언가

77
00:04:48,000 --> 00:04:51,000
번호도 또는 홀수인지 여부를 확인.

78
00:04:51,000 --> 00:04:54,000
그 점은 우리가 2로 번호를 MOD하고 그 결과가 0인지 확인 기억 해요.

79
00:04:54,000 --> 00:04:57,000
그렇다면도 있습니다. 그렇지 않으면 이상해.

80
00:04:57,000 --> 00:04:59,000
그리고 그건 정말 기본 알고리즘의 예입니다.

81
00:04:59,000 --> 00:05:02,000
>> 더 많은 참여 하나의 작은 비트 이진 검색입니다

82
00:05:02,000 --> 00:05:05,000
어떤 우리가 검토 세션에서 나중에 갈거야.

83
00:05:05,000 --> 00:05:09,000
그리고 프로그램은 우리가 알고리즘을 주셔서 사용되는 용어입니다

84
00:05:09,000 --> 00:05:15,000
하고 컴퓨터를 코딩로 변환하기 읽을 수 있습니다.

85
00:05:15,000 --> 00:05:20,000
프로그래밍 2 예, 스크래치입니다

86
00:05:20,000 --> 00:05:22,000
이는 우리가 주 0에 무슨 짓을했는지입니다.

87
00:05:22,000 --> 00:05:25,000
우리가 실제로 코드를 입력하지 않더라도 그 구현 방법

88
00:05:25,000 --> 00:05:29,000
숫자가 1-10 인쇄하는이 알고리즘,

89
00:05:29,000 --> 00:05:32,000
여기 우리는 C 프로그래밍 언어에서 동일한 작업을 수행.

90
00:05:32,000 --> 00:05:41,000
이것들은 서로 다른 언어 나 문법으로 작성, 기능상으로 동등한 있습니다.

91
00:05:41,000 --> 00:05:44,000
우리는, 부울 표현에 대해 배웠습니다

92
00:05:44,000 --> 00:05:48,000
와 부울은 true 또는 false입니다 값

93
00:05:48,000 --> 00:05:51,000
여기 자주 논리 표현

94
00:05:51,000 --> 00:05:55,000
그렇다면 (X ≤ 5),이 조건에 들어가

95
00:05:55,000 --> 00:06:00,000
그래, 우리가 이미 조건이 true로 평가하는 것이다 X = 5 수 있도록 설정합니다.

96
00:06:00,000 --> 00:06:03,000
그게 사실이라면 그리고 어떤 코드는 조건 아래에 있습니다

97
00:06:03,000 --> 00:06:08,000
컴퓨터에 의해 평가 될 것입니다, 그래서 문자열은 인쇄 할 것입니다

98
00:06:08,000 --> 00:06:12,000
표준 출력 및 용어 조건에

99
00:06:12,000 --> 00:06:16,000
if 문에서 괄호 안에 무엇이든을 의미합니다.

100
00:06:16,000 --> 00:06:20,000
모든 연산자를 기억하십시오.

101
00:06:20,000 --> 00:06:26,000
| 우리가하려고 할 때 결합 2 개 이상 조건 | 그건 &&와 기억

102
00:06:26,000 --> 00:06:30,000
== not = 2 일 동일 여부를 확인합니다.

103
00:06:30,000 --> 00:06:36,000
== 부울 연산자 반면 =이 임무를위한 것입니다 기억하십시오.

104
00:06:36,000 --> 00:06:41,000
≤, ≥ 후 최종 2 자기 설명입니다.

105
00:06:41,000 --> 00:06:45,000
여기에 부울 논리의 일반적인 검토.

106
00:06:45,000 --> 00:06:48,000
그리고 부울 표현은 루프에서도 중요한

107
00:06:48,000 --> 00:06:50,000
어떤 이제 갈거야.

108
00:06:50,000 --> 00:06:56,000
우리는 동안을 위해 CS50에 지금까지 루프에 대한 3 가지 유형을 알게하고, 동시에 마십시오.

109
00:06:56,000 --> 00:06:59,000
그리고 알고하는 것이 중요합니다 대부분의 목적을 위해 잠시

110
00:06:59,000 --> 00:07:02,000
우리는 실제로 일반적으로 루프의 모든 종류를 사용할 수 있습니다

111
00:07:02,000 --> 00:07:06,000
목적이나 일반적인 패턴의 특정 유형이 있습니다

112
00:07:06,000 --> 00:07:09,000
구체적으로 이러한 루프 중 하나에 전화 프로그래밍

113
00:07:09,000 --> 00:07:13,000
그하는 것을 가장 효율적이나 방법에 코드를 우아한.

114
00:07:13,000 --> 00:07:18,000
의 이러한 루프의 각각 가장 많이 사용하는 경향이 일로 가자.

115
00:07:18,000 --> 00:07:21,000
>> 에서 루프를 위해 우리는 일반적으로 이미 우리가 반복 할 횟수를 알아요.

116
00:07:21,000 --> 00:07:24,000
우리가 조건에 넣어거야.

117
00:07:24,000 --> 00:07:28,000
를 들어, I = 0, 나는 <10, 예를 들어.

118
00:07:28,000 --> 00:07:31,000
우리는 이미 우리가 뭔가 10 배를하려는 알아요.

119
00:07:31,000 --> 00:07:34,000
이제 잠시 루프를 들어, 일반적으로 우리는 반드시하지 않습니다

120
00:07:34,000 --> 00:07:36,000
우리는 루프를 실행하려면 몇 번 알아요.

121
00:07:36,000 --> 00:07:39,000
그러나 우리는 우리가 원하는 것을 조건 일종의 알아요

122
00:07:39,000 --> 00:07:41,000
항상 사실이 나 항상 거짓.

123
00:07:41,000 --> 00:07:44,000
예를 들어, 동안이 설정되어 있습니다.

124
00:07:44,000 --> 00:07:46,000
하자 부울 변수가 있다고.

125
00:07:46,000 --> 00:07:48,000
그게 사실이지만 우리는 코드가 평가하려는

126
00:07:48,000 --> 00:07:52,000
그래서 조금 더 확장, 루프에 대한보다 일반적인 약간,

127
00:07:52,000 --> 00:07:55,000
하지만 루프에 대한도 잠시 루프로 변환 할 수 있습니다.

128
00:07:55,000 --> 00:08:00,000
마지막으로, 수행하는 동안 바로 이해하기 trickiest 수 있습니다 루프,

129
00:08:00,000 --> 00:08:04,000
먼저 코드를 평가 할 때 자주 사용됩니다

130
00:08:04,000 --> 00:08:06,000
처음으로 이전 우리는 조건을 확인하십시오.

131
00:08:06,000 --> 00:08:09,000
의 일반적인 사용 케이스는 않지만 루프

132
00:08:09,000 --> 00:08:12,000
당신이 사용자 입력을 할 때이고, 당신이 사용자에게 물어보고 싶은 알고

133
00:08:12,000 --> 00:08:15,000
입력을위한 최소 한 번,하지만 그들은 당신에게 좋은 입력을 제공하지 않을 경우 즉시

134
00:08:15,000 --> 00:08:18,000
당신은 그들이 당신에게 좋은 의견을 줄 때까지 물어 보는 싶습니다.

135
00:08:18,000 --> 00:08:21,000
동안 루프의 가장 일반적인 사용은, 그렇게

136
00:08:21,000 --> 00:08:23,000
과의 이러한 루프의 실제 구조를 살펴 보도록하겠습니다.

137
00:08:23,000 --> 00:08:27,000
그들은 일반적으로 항상 패턴에 따라하는 경향이 있습니다.

138
00:08:27,000 --> 00:08:30,000
>> 내부에 루프에서는 3 구성 요소를 가지고 :

139
00:08:30,000 --> 00:08:35,000
초기화 일반적으로 무언가 같이 INT 난 ... 카운터이다 = 0,

140
00:08:35,000 --> 00:08:40,000
우리가이 조건이 여전히 보유하고있는 한 루프에 대해이를 실행하고 싶은 말은 조건,

141
00:08:40,000 --> 00:08:44,000
우리는 증가하는 방법입니다 제가 마지막으로 한 후 <10, 그리고, 업데이트, 등

142
00:08:44,000 --> 00:08:47,000
루프의 각 지점에서 카운터 변수.

143
00:08:47,000 --> 00:08:50,000
거기에 볼 수있는 일반적인 문제는, 내가 + + is

144
00:08:50,000 --> 00:08:52,000
이는 1 때마다 i를 증가 의미합니다.

145
00:08:52,000 --> 00:08:55,000
당신은 또한, 내가 + = 2와 같은 뭔가를 할 수있을

146
00:08:55,000 --> 00:08:58,000
그래서 내가로는 루프 통과 할 때마다 2 추가 의미합니다.

147
00:08:58,000 --> 00:09:03,000
그리고이 작업을 수행하는 것은 단지 실제로 루프의 일부로 실행되는 코드를 의미합니다.

148
00:09:03,000 --> 00:09:09,000
그리고 잠시 루프를 들어,이 시간 우리는 실제로는 루프의 외부 초기화가

149
00:09:09,000 --> 00:09:12,000
그래서 예를 들어, 우리가 방금 설명한대로 루프의 동일한 유형을 위해 노력하고한다고 가정 해 봅시다.

150
00:09:12,000 --> 00:09:16,000
우리는 INT가 내가 = 0 루프가 시작되기 전에 말 것입니다.

151
00:09:16,000 --> 00:09:20,000
내가 <10이 작업을 수행하는 동안 다음 우리는 말할 수

152
00:09:20,000 --> 00:09:22,000
이전과 같은 코드 때문에 동일한 블록

153
00:09:22,000 --> 00:09:26,000
이 시간 예를 들어, 코드의 업데이트 부분, 내가 + +,

154
00:09:26,000 --> 00:09:29,000
실제로 루프의 안쪽에갑니다.

155
00:09:29,000 --> 00:09:33,000
그리고 마지막으로,에, 그것은 동안 루프와 비슷한 일 때 수행,

156
00:09:33,000 --> 00:09:36,000
하지만 우리는 코드가 한 번 평가 기억해야

157
00:09:36,000 --> 00:09:40,000
조건을 선택하기 전에, 그래서 더 많은 의미가

158
00:09:40,000 --> 00:09:44,000
당신은 위에서 아래로 순서에 봐. 경우

159
00:09:44,000 --> 00:09:49,000
에서 당신은 심지어 동안 상태보고하기 전에 루프 코드를 평가하는 동안 수행,

160
00:09:49,000 --> 00:09:55,000
잠시 루프 반면, 그건 먼저 확인합니다.

161
00:09:55,000 --> 00:09:59,000
명세서와 변수.

162
00:09:59,000 --> 00:10:04,000
우리는 새로운 변수를 만들 때 우리는 먼저 초기화하고 싶습니다.

163
00:10:04,000 --> 00:10:07,000
>> 예를 들어, INT 바, 변수 표시 줄을 초기화

164
00:10:07,000 --> 00:10:10,000
하지만 지금은 바의 값은 너무, 그것을 값을 제공하지 않는 이유는 무엇입니까?

165
00:10:10,000 --> 00:10:12,000
우리는 몰라요.

166
00:10:12,000 --> 00:10:14,000
그것은 이전에이 메모리에 저장 된 일부 쓰레기 값이 될 수 있습니다

167
00:10:14,000 --> 00:10:16,000
우리는 그 변수를 사용하지 않으

168
00:10:16,000 --> 00:10:19,000
우리는 실제로에게 가치를 제공, 할 때까지

169
00:10:19,000 --> 00:10:21,000
그래서 우리는 여기에 선언합니다.

170
00:10:21,000 --> 00:10:24,000
그런 다음 우리는 다음 42로 초기화합니다.

171
00:10:24,000 --> 00:10:28,000
지금, 물론, 우리는이 한 행에, INT 바 = 42 수행 할 수 있습니다 알아요.

172
00:10:28,000 --> 00:10:30,000
하지만, 진정으로 일어나는 여러 단계를 지우 할

173
00:10:30,000 --> 00:10:34,000
선언과 초기화는 여기 별도로 발생합니다.

174
00:10:34,000 --> 00:10:38,000
그것은 그 다음 INT Baz도 = 바 + 1, 한 단계에서 발생하고,

175
00:10:38,000 --> 00:10:44,000
그래서이 코드 블록의 끝 부분에 아래 문, 그 단위의 Baz도,

176
00:10:44,000 --> 00:10:48,000
우리가 Baz도의 가치를 인쇄 할 경우 그 44 것

177
00:10:48,000 --> 00:10:52,000
우리는 선언하고 1> 바로 그것을 초기화 because

178
00:10:52,000 --> 00:10:58,000
그리고 우리는 함께 한 번 더를 증가 + +.

179
00:10:58,000 --> 00:11:02,000
우리는이 프로그램이 매우 짧게 갔는데,하지만 일반적인가있어서 좋다

180
00:11:02,000 --> 00:11:04,000
스레드와 이벤트가 무엇인지에 대한 이해.

181
00:11:04,000 --> 00:11:06,000
우리는 주로, 스크래치에 이런 짓을

182
00:11:06,000 --> 00:11:09,000
그래서 당신은 코드의 여러 시퀀스로 스레드 생각할 수

183
00:11:09,000 --> 00:11:11,000
동시에 실행할 수 있습니다.

184
00:11:11,000 --> 00:11:14,000
실제로, 아마 같은 시간에 실행되지 않습니다

185
00:11:14,000 --> 00:11:17,000
하지만 종류의 추상적 우리는 그 방법으로 생각할 수 있습니다.

186
00:11:17,000 --> 00:11:20,000
>> 스크래치에서 예를 들어, 우리는 여러 스프라이트했다.

187
00:11:20,000 --> 00:11:22,000
그것은 동시에 다른 코드를 실행 할 수있다.

188
00:11:22,000 --> 00:11:26,000
다른 무언가 말을하는 동안 하나는 도보 될 수 있습니다

189
00:11:26,000 --> 00:11:29,000
화면의 다른 부분 인치

190
00:11:29,000 --> 00:11:34,000
이벤트 논리를 분리의 또 다른 방법입니다

191
00:11:34,000 --> 00:11:37,000
코드의 다른 요소 사이에,

192
00:11:37,000 --> 00:11:40,000
그리고 스크래치에 우리는 방송을 사용하여 이벤트를 시뮬레이션 할 수 있었다

193
00:11:40,000 --> 00:11:43,000
제가받을 때 그 내가 듣지 때, 사실이야

194
00:11:43,000 --> 00:11:47,000
하지만 본질적으로는 정보를 전송하는 방법

195
00:11:47,000 --> 00:11:49,000
한 요정에서 다른.

196
00:11:49,000 --> 00:11:52,000
예를 들어, 당신은 게임을 통해 전송 할 수 있습니다

197
00:11:52,000 --> 00:11:56,000
다른 스프라이트가 넘는 게임을받을 때,

198
00:11:56,000 --> 00:11:58,000
이 특정 방식으로 응답합니다.

199
00:11:58,000 --> 00:12:03,000
이 프로그램에 대해 이해할 수있는 중요한 모델입니다.

200
00:12:03,000 --> 00:12:07,000
그냥 기본 주 영에 가서하기 위해, 우리가 지금까지 살펴 봤는데,

201
00:12:07,000 --> 00:12:10,000
의이 간단한 C 프로그램을 살펴 보자.

202
00:12:10,000 --> 00:12:14,000
텍스트는 여기에서 작은 조금있을 수 있습니다,하지만 난 그 위에 정말 빠르게 갈거야.

203
00:12:14,000 --> 00:12:20,000
우리는 위, cs50.h과 stdio.h 2 헤더 파일을 포함하고 있습니다.

204
00:12:20,000 --> 00:12:23,000
우리는 100으로 상수라는 한계를 정의하고 있습니다.

205
00:12:23,000 --> 00:12:26,000
우리는 우리의 주요 기능을 구현하고 있습니다.

206
00:12:26,000 --> 00:12:29,000
우리가 명령 줄 인수를 사용하지 않는 때문에 우리는 빈 공간을 둘 필요가

207
00:12:29,000 --> 00:12:32,000
주에 대한 인수 있습니다.

208
00:12:32,000 --> 00:12:38,000
우리는 주 위의 정수를 참조하십시오. 반환 형식이야, 따라서 하단에 0을 반환합니다.

209
00:12:38,000 --> 00:12:41,000
그리고 우리는 INT 얻을 CS50 라이브러리 함수를 사용하는

210
00:12:41,000 --> 00:12:45,000
입력을위한 사용자를 부탁하고, 우리가이 변수 x에 저장하려면,

211
00:12:45,000 --> 00:12:51,000
그래서 우리는 위의 x를 선언, 우리는 X = GetInt로 초기화합니다.

212
00:12:51,000 --> 00:12:53,000
>> 우리는 사용자가 우리에게 좋은 의견을 주신 있는지 확인하십시오.

213
00:12:53,000 --> 00:12:59,000
이 ≥ 제한 있다면 우리는 하나의 에러 코드를 반환하고 오류 메시지를 인쇄하고 싶습니다.

214
00:12:59,000 --> 00:13:02,000
그리고 마지막으로, 사용자가 우리에게 주신 경우에 유용 입력

215
00:13:02,000 --> 00:13:08,000
우리는 번호를 광장과 그 결과를 인쇄거야.

216
00:13:08,000 --> 00:13:11,000
확실히하기 위해 그 사람들은 히트 집 모두

217
00:13:11,000 --> 00:13:17,000
여기 코드의 다른 부분의 라벨을 볼 수 있습니다.

218
00:13:17,000 --> 00:13:19,000
나는 일정, 헤더 파일을 언급.

219
00:13:19,000 --> 00:13:21,000
아, INT X. 지역 변수 아니라는 점을 기억해야합니다.

220
00:13:21,000 --> 00:13:24,000
그건 우리가 얘기하자있는 전역 변수에서 대조

221
00:13:24,000 --> 00:13:27,000
조금 나중에 검토 세션에서,

222
00:13:27,000 --> 00:13:30,000
우리는, printf 라이브러리 함수를 호출 아르

223
00:13:30,000 --> 00:13:34,000
우리는 stdio.h 헤더 파일을 포함하지 않았 만약 그렇다면

224
00:13:34,000 --> 00:13:37,000
우리는 printf 호출 할 수 없을 것입니다.

225
00:13:37,000 --> 00:13:42,000
그리고 여기 끊겼다 화살표가 % d 개를 가리키고 있다고 생각

226
00:13:42,000 --> 00:13:45,000
printf의 서식 문자열되는 것입니다.

227
00:13:45,000 --> 00:13:52,000
이 번호 % d 개 등이 변수를 인쇄 말합니다.

228
00:13:52,000 --> 00:13:58,000
그리고 그 주 0 야.

229
00:13:58,000 --> 00:14:06,000
지금 루카스 계속 예정이다.

230
00:14:06,000 --> 00:14:08,000
안녕, 얘들 아. 내 이름은 루카스입니다.

231
00:14:08,000 --> 00:14:10,000
나는, 캠퍼스, 메이에서 가장 집에 2 학년

232
00:14:10,000 --> 00:14:14,000
그리고 주 1 및 2.1에 대해 조금 얘기 할 겁니다.

233
00:14:14,000 --> 00:14:16,000
[주 1 2.1!] [루카스 프레이 타스]

234
00:14:16,000 --> 00:14:19,000
우리가 처음부터 C로 코드를 번역 시작할 때 Lexi이 말한 것처럼

235
00:14:19,000 --> 00:14:23,000
우리가 발견 한 것 중 하나는 단지 수 있다는 것입니다

236
00:14:23,000 --> 00:14:26,000
코드를 작성하고 더 이상 녹색 깃발을 사용하여 실행합니다.

237
00:14:26,000 --> 00:14:30,000
사실, 당신은 C 프로그램을 만들기 위해 몇 가지 단계를 수행해야

238
00:14:30,000 --> 00:14:33,000
실행 파일이됩니다.

239
00:14:33,000 --> 00:14:36,000
기본적으로 만약 당신이 프로그램을 쓸 때 당신이 할 일은입니다

240
00:14:36,000 --> 00:14:40,000
당신은 컴파일러가 이해할 수있는 언어로 아이디어를 번역

241
00:14:40,000 --> 00:14:44,000
당신은 C에서 프로그램을 작성하고 있으므로 때

242
00:14:44,000 --> 00:14:47,000
당신이하고있는 것은 실제로 컴파일러가 이해하는 것입니다 뭔가를 쓰는되고,

243
00:14:47,000 --> 00:14:50,000
그리고 컴파일러는 그 코드를 번역 것입니다

244
00:14:50,000 --> 00:14:53,000
컴퓨터가 이해하는 걸로.

245
00:14:53,000 --> 00:14:55,000
>> 그리고 문제는, 컴퓨터가 실제로 매우 바보입니다.

246
00:14:55,000 --> 00:14:57,000
컴퓨터 만 0s와 1S 이해할 수

247
00:14:57,000 --> 00:15:01,000
그래서 실제로 첫 번째 컴퓨터에 사람들은 보통 프로그래밍

248
00:15:01,000 --> 00:15:04,000
더 이상 0s와 1S 아니라 사용 하나님 께 감사를드립니다.

249
00:15:04,000 --> 00:15:07,000
우리는 0s와 1 초에 시퀀스를 기억 할 필요가 없습니다

250
00:15:07,000 --> 00:15:10,000
루프 또는 잠시 동안 루프 등의하십시오.

251
00:15:10,000 --> 00:15:13,000
우리가 컴파일러가 이유입니다.

252
00:15:13,000 --> 00:15:17,000
어떤 컴파일러가 수행하는 것은, 그것이 기본적으로 C 코드를 번역합니다

253
00:15:17,000 --> 00:15:21,000
우리의 경우, 컴퓨터가 이해할 수있는 언어로,

254
00:15:21,000 --> 00:15:25,000
이는 개체 코드, 우리가 사용하고있는 컴파일러입니다

255
00:15:25,000 --> 00:15:30,000
그 소리라고,이 사실은 그 소리의 상징입니다.

256
00:15:30,000 --> 00:15:33,000
당신의 프로그램이 때, 2 일을해야합니다.

257
00:15:33,000 --> 00:15:37,000
먼저 프로그램을 컴파일해야하고, 다음이 프로그램을 실행하려고하고 있습니다.

258
00:15:37,000 --> 00:15:41,000
이렇게하는 옵션이 많은 프로그램을 컴파일합니다.

259
00:15:41,000 --> 00:15:44,000
첫번째는 그 소리를 program.c을하는 것입니다

260
00:15:44,000 --> 00:15:47,000
있는 프로그램은 프로그램의 이름입니다.

261
00:15:47,000 --> 00:15:51,000
이 경우 당신은 그들이 그냥 말하는 거죠 볼 수 있습니다 "이봐, 내 프로그램을 컴파일합니다."

262
00:15:51,000 --> 00:15:56,000
당신은이나 뭐 "나는 내 프로그램이 이름을 싶다"말한 게 아니에요.

263
00:15:56,000 --> 00:15:58,000
>> 두 번째 옵션은 프로그램에 이름을 제공하고 있습니다.

264
00:15:58,000 --> 00:16:02,000
그런 다음 그 소리-O하고 원하는 이름 말할 수

265
00:16:02,000 --> 00:16:06,000
실행 파일과 같은 후 program.c 이름입니다.

266
00:16:06,000 --> 00:16:11,000
그리고 당신은 프로그램을 수행하는 방법과 처음 2의 경우에 볼 수 있습니다

267
00:16:11,000 --> 00:16:15,000
나는. C를 넣어, 그리고 세번째는 하나 밖에 프로그램이?

268
00:16:15,000 --> 00:16:18,000
네, 실제로 넣어 수 없습니다. C를 당신이 할을 사용할 때.

269
00:16:18,000 --> 00:16:22,000
그렇지 않으면 컴파일러는 실제로 당신 소리 것입니다.

270
00:16:22,000 --> 00:16:24,000
너희가 기억 또한, 난 잘 모르겠어

271
00:16:24,000 --> 00:16:29,000
그러나 우리는 또한 사용되는 lcs50 또는 LM 많은 시간.

272
00:16:29,000 --> 00:16:31,000
그는 링크라고합니다.

273
00:16:31,000 --> 00:16:35,000
단지, 당신이 바로 그 라이브러리를 사용하는 컴파일러를 알려줍니다

274
00:16:35,000 --> 00:16:39,000
당신이 cs50.h를 사용하고 싶다면 당신은 실제로 입력해야

275
00:16:39,000 --> 00:16:43,000
그 소리 program.c - lcs50.

276
00:16:43,000 --> 00:16:45,000
당신이하지 않으면, 컴파일러는 알 않을 것이다

277
00:16:45,000 --> 00:16:50,000
당신은 cs50.h.에서 그 기능을 사용하고

278
00:16:50,000 --> 00:16:52,000
그리고 당신은 2 가지 옵션이 있습니다 당신의 프로그램을 실행하려고 할 때.

279
00:16:52,000 --> 00:16:57,000
당신은 그 소리를 program.c 짓을하는 경우 귀하의 프로그램에 이름을 밝히지 않았다.

280
00:16:57,000 --> 00:17:01,000
당신은. / a.out를 사용하여 실행해야합니다.

281
00:17:01,000 --> 00:17:06,000
A.out 당신이 이름을 제공하지 않으면 그 소리가 프로그램을 제공하는 표준 이름입니다.

282
00:17:06,000 --> 00:17:11,000
이 프로그램에 이름을 주면 그렇지 않으면 당신은. / 프로그램을 할 수있는 것,

283
00:17:11,000 --> 00:17:15,000
이 프로그램의 이름을 한 경우 또한이 프로그램은 얻을 수 있다는

284
00:17:15,000 --> 00:17:23,000
이미 C 파일로 같은 이름을 프로그래밍 할 예정이다.

285
00:17:23,000 --> 00:17:26,000
그럼 우리가 데이터 유형 및 데이터에 대해 얘기.

286
00:17:26,000 --> 00:17:31,000
>> 기본적으로 데이터 유형은 사용 작은 박스와 같은거다

287
00:17:31,000 --> 00:17:35,000
값을 저장하므로 데이터 유형은 Pokémons처럼 실제로 있습니다.

288
00:17:35,000 --> 00:17:39,000
모두 크기와 종류가 있습니다.

289
00:17:39,000 --> 00:17:43,000
그 비유가 적합한 지 나도 몰라.

290
00:17:43,000 --> 00:17:46,000
데이터 크기는 실제로 컴퓨터 아키텍처에 따라 달라집니다.

291
00:17:46,000 --> 00:17:49,000
여기서 보여 주겠다 모든 데이터 크기

292
00:17:49,000 --> 00:17:53,000
우리 어플라이언스의 경우 32 비트 기계, 사실은 아르

293
00:17:53,000 --> 00:17:56,000
하지만 실제로 Mac 또는 Windows에서도 코딩하는 경우

294
00:17:56,000 --> 00:17:59,000
아마도 당신은 64 비트 시스템을 할거야

295
00:17:59,000 --> 00:18:03,000
그래서 갈거야있는 데이터 크기는 여기에 표시 할 기억

296
00:18:03,000 --> 00:18:06,000
32 비트 시스템위한 것입니다.

297
00:18:06,000 --> 00:18:08,000
우리가 처음 본 사람은, 정수였다

298
00:18:08,000 --> 00:18:10,000
어떤 아주 간단합니다.

299
00:18:10,000 --> 00:18:13,000
당신은 정수를 저장할 수 정수 사용합니다.

300
00:18:13,000 --> 00:18:16,000
우리는 또한 문자, 문자를 보았다.

301
00:18:16,000 --> 00:18:20,000
당신은 편지 나 작은 기호를 사용하려면 당신은 아마 숯불을 사용하는거야.

302
00:18:20,000 --> 00:18:26,000
문자는 Lexi 말과 같은 8 비트를 의미 1 바이트를 가지고 있습니다.

303
00:18:26,000 --> 00:18:31,000
기본적으로 우리는 256이 ASCII 표를

304
00:18:31,000 --> 00:18:34,000
0s와 1S의 가능한 조합

305
00:18:34,000 --> 00:18:37,000
다음 문자를 입력하면이 번역거야

306
00:18:37,000 --> 00:18:44,000
문자 입력하면이 Lexi처럼, ASCII 표에 있다는 숫자가 말했다.

307
00:18:44,000 --> 00:18:48,000
우리는 또한 우리가 십진수 숫자를 저장하는 데 사용하는 수레를 갖추고 있습니다.

308
00:18:48,000 --> 00:18:53,000
당신은 3.14을 선택하려는 경우 예를 들어, 당신은 수레를 사용하는 것

309
00:18:53,000 --> 00:18:55,000
이상 정밀도를 가진 두.

310
00:18:55,000 --> 00:18:57,000
float이 4 바이트가 있습니다.

311
00:18:57,000 --> 00:19:01,000
이중 8 바이트가 있으므로 유일한 차이는 정밀도입니다.

312
00:19:01,000 --> 00:19:04,000
또한, 정수에 사용되는 긴이

313
00:19:04,000 --> 00:19:09,000
그리고 당신은 정수와 긴이 같은 크기가 32 비트 컴퓨터에 대해 볼 수 있습니다

314
00:19:09,000 --> 00:19:13,000
그래서 정말 32 비트 시스템에서 긴을 사용하는 의미가 없습니다.

315
00:19:13,000 --> 00:19:17,000
>> 당신은 Mac 및 64 비트 시스템을 사용하는 경우 그러나, 실제로 긴, 크기 8이

316
00:19:17,000 --> 00:19:19,000
그래서 정말 아키텍처에 따라 달라집니다.

317
00:19:19,000 --> 00:19:22,000
32 비트 시스템의 경우 정말 오랜를 사용하는 의미가 없습니다.

318
00:19:22,000 --> 00:19:25,000
그리고 긴 긴 반면, 8 바이트가

319
00:19:25,000 --> 00:19:30,000
당신은 더 이상 정수를하려는 경우 때문에 아주 좋은 것입니다.

320
00:19:30,000 --> 00:19:34,000
그리고 마지막으로, 우리는 실제로 숯불 *이있는 문자열을 가지고

321
00:19:34,000 --> 00:19:37,000
이는 문자에 대한 포인터입니다.

322
00:19:37,000 --> 00:19:40,000
이 문자열의 크​​기가 같은 것입니다 생각하는 것은 매우 간단합니다

323
00:19:40,000 --> 00:19:42,000
당신이 거기 있다는 문자의 수,

324
00:19:42,000 --> 00:19:45,000
하지만 실제로 숯불 * 자체

325
00:19:45,000 --> 00:19:49,000
4 바이트 인 문자에 대한 포인터의 크기가 있습니다.

326
00:19:49,000 --> 00:19:52,000
숯불 *의 크기는 4 바이트입니다.

327
00:19:52,000 --> 00:19:56,000
당신은 작은 단어 또는 문자 나가 있다면 그건 중요하지 않습니다.

328
00:19:56,000 --> 00:19:58,000
은 4 바이트거야.

329
00:19:58,000 --> 00:20:01,000
또한, 주조에 대해 조금 배웠습니다

330
00:20:01,000 --> 00:20:04,000
당신이 경우 당신이 볼 수있는만큼, 예를 들어, 프로그램이하는 말

331
00:20:04,000 --> 00:20:08,000
INT X = 3 후 printf ( "% d 개", X / 2)

332
00:20:08,000 --> 00:20:12,000
당신들이이 화면에 인쇄 할 무슨 일이 벌어지고있는 거죠?

333
00:20:12,000 --> 00:20:14,000
>> 사람? >> [학생] 2.

334
00:20:14,000 --> 00:20:16,000
1. >> 1 네.

335
00:20:16,000 --> 00:20:20,000
당신이 3 / 2 할 때마다, 1.5를 얻을거야

336
00:20:20,000 --> 00:20:24,000
우리는 정수를 사용하고 있기 때문에하지만, 소수 부분을 무시하는거야

337
00:20:24,000 --> 00:20:26,000
당신은 1 할 겁니다.

338
00:20:26,000 --> 00:20:29,000
당신도, 예를 들어, 당신이 할 수있는 일을 일하지 않으려면

339
00:20:29,000 --> 00:20:33,000
수레를 선언합니다 Y = X.

340
00:20:33,000 --> 00:20:40,000
3 다음으로 사용하는 X는 이제 Y에서 3.000가 될 것입니다.

341
00:20:40,000 --> 00:20:44,000
그리고 당신은 Y / 2를 인쇄 할 수 있습니다.

342
00:20:44,000 --> 00:20:50,000
사실, 2이 있어야합니다. 저기.

343
00:20:50,000 --> 00:20:55,000
그것은 3.00/2.00을 할거야

344
00:20:55,000 --> 00:20:58,000
당신은 1.5를받을거야.

345
00:20:58,000 --> 00:21:06,000
그리고 우리는 소수 부분을 2 진수 단위를 요청할이 0.2 F가 있습니다.

346
00:21:06,000 --> 00:21:12,000
당신은 0.3 F가있는 경우 실제로 1.500을거야.

347
00:21:12,000 --> 00:21:16,000
만약 그게 2는 1.50거야.

348
00:21:16,000 --> 00:21:18,000
우리는 또한 여기에이 사건을 수 있습니다.

349
00:21:18,000 --> 00:21:22,000
당신은 부동 소수점 작업을 수행 할 경우 X = 3.14 다음 printf X

350
00:21:22,000 --> 00:21:24,000
당신은 3.14를 얻을거야.

351
00:21:24,000 --> 00:21:29,000
그리고 당신은하지 않으면 X X의 = INT,

352
00:21:29,000 --> 00:21:34,000
정수로 x를 치료 의미하며 이제 X를 인쇄하는

353
00:21:34,000 --> 00:21:36,000
당신은 3.00 할 겁니다.

354
00:21:36,000 --> 00:21:38,000
그게 말이나 돼?

355
00:21:38,000 --> 00:21:41,000
먼저 정수로 x를 취급하는 때문에, 그래서 당신은, 소수 부분을 무시합니다

356
00:21:41,000 --> 00:21:45,000
그리고 당신은 x를 인쇄하고 있습니다.

357
00:21:45,000 --> 00:21:47,000
그리고 마지막으로, 당신은 또한 이렇게 할 수 있습니다

358
00:21:47,000 --> 00:21:52,000
INT X = 65, 다음 숯불 C = X를 선언,

359
00:21:52,000 --> 00:21:56,000
당신은 C를 인쇄하면 다음은 실제로받을거야

360
00:21:56,000 --> 00:21:59,000
A, 여기서 이렇게 기본적으로 무슨 일을하는지

361
00:21:59,000 --> 00:22:02,000
, 문자로 정수를 번역하고 있습니다

362
00:22:02,000 --> 00:22:05,000
처럼 ASCII 표는 않습니다.

363
00:22:05,000 --> 00:22:08,000
우리는 또한 수학 연산자에 대해 얘기.

364
00:22:08,000 --> 00:22:14,000
그들 대부분은 매우 간단하므로, +, -, *, /,

365
00:22:14,000 --> 00:22:20,000
또한 우리는 2 숫자의 부문의 나머지 부분입니다 MOD,에 대해 얘기.

366
00:22:20,000 --> 00:22:23,000
당신은 예를 들어 10 % 3,있는 경우

367
00:22:23,000 --> 00:22:27,000
그것은 3 10 분할 의미하며, 나머지는 무엇인가?

368
00:22:27,000 --> 00:22:30,000
그것은 1 질거야, 그래서 프로그램의 많은 사실은 매우 유용합니다.

369
00:22:30,000 --> 00:22:38,000
Vigenère과 황제에 나는 너희 모두는 모드를 사용하는 확신합니다.

370
00:22:38,000 --> 00:22:43,000
* 및 /를 결합 할 때 수학 연산자에 대해 매우주의해야합니다.

371
00:22:43,000 --> 00:22:48,000
>> 당신이 예를 들어, (3 / 2) * 2가 뭘 얻을 수 있습니까?

372
00:22:48,000 --> 00:22:50,000
[학생] 2.

373
00:22:50,000 --> 00:22:54,000
네, 2, 2분의 3 인해 1.5 될 것입니다,

374
00:22:54,000 --> 00:22:57,000
하지만 두 정수 사이에 작업을하고 있기 때문에

375
00:22:57,000 --> 00:22:59,000
당신은 실제로 1을 고려하는 것

376
00:22:59,000 --> 00:23:03,000
그리고 1 * 2는 2가 될 것입니다, 매우, 매우 조심해야

377
00:23:03,000 --> 00:23:07,000
정수와 연산을 수행 할 때 때문에

378
00:23:07,000 --> 00:23:12,000
그 경우, 그 2 = 3받을 수 있습니다.

379
00:23:12,000 --> 00:23:14,000
또한 우선 순위에 대한 매우주의해야합니다.

380
00:23:14,000 --> 00:23:21,000
당신은 일반적으로 당신이 지금 무슨 짓을하는지 알고 있는지 확인하려면 괄호를 사용해야합니다.

381
00:23:21,000 --> 00:23:27,000
유용한 단축키 물론, 하나는 내가 + + 또는 난 + = 1

382
00:23:27,000 --> 00:23:30,000
또는 사용 + =.

383
00:23:30,000 --> 00:23:34,000
그건 내가 = 나는 + 1을하고 같은 것입니다.

384
00:23:34,000 --> 00:23:39,000
당신은 또한 내가 할 수 - 아니면 - = 1,

385
00:23:39,000 --> 00:23:42,000
이것은, 내가 = 나는 -1과 같은 일이

386
00:23:42,000 --> 00:23:46,000
무언가 너희들이 적어도 루프에에서 많이 사용합니다.

387
00:23:46,000 --> 00:23:52,000
또한, *를 들어, * = 및 당신이 할 경우, 예를 들어 사용하는 경우,

388
00:23:52,000 --> 00:23:57,000
전 * = 2 I = I * 2 말과 같은 것입니다

389
00:23:57,000 --> 00:23:59,000
와 본부 같은 일.

390
00:23:59,000 --> 00:24:08,000
당신은 I / = 2 일 경우 내가 = 나는 / 2와 같은 일이야.

391
00:24:08,000 --> 00:24:10,000
>> 지금 기능에 대한.

392
00:24:10,000 --> 00:24:13,000
당신들은 기능이 코드를 저장하는 아주 좋은 전략임을 알게

393
00:24:13,000 --> 00:24:16,000
당신이 프로그래밍하는 동안, 그래서 당신은 같은 작업을 수행하려는 경우

394
00:24:16,000 --> 00:24:20,000
코드에서 또 한번, 또 한번, 아마도 당신은 기능을 사용하려면

395
00:24:20,000 --> 00:24:25,000
그냥 다시 반복 코드를 복사 및 붙여 넣기 할 필요가 없습니다.

396
00:24:25,000 --> 00:24:28,000
사실, 주는 기능입니다, 내가 당신에게 함수의 형식을 게재하는 경우

397
00:24:28,000 --> 00:24:32,000
그 아주 명백한 것을 만날 수있을 거예요.

398
00:24:32,000 --> 00:24:35,000
우리는 또한 일부 라이브러리에서 함수를 사용

399
00:24:35,000 --> 00:24:39,000
예를 들어, printf, CS50 라이브러리에서입니다 GetIn,

400
00:24:39,000 --> 00:24:43,000
와 toupper 같은 다른 기능.

401
00:24:43,000 --> 00:24:46,000
이러한 기능의 모든 사실은, 다른 도서관에서 구현

402
00:24:46,000 --> 00:24:49,000
당신은 프로그램의 시작 부분에 이러한 테 더링 파일을 넣을 때

403
00:24:49,000 --> 00:24:53,000
당신은 나에게 그 기능에 대한 코드를 줄래 말

404
00:24:53,000 --> 00:24:57,000
그래서 내 자신을 기준으로 결과를 구현 할 필요가 없습니다?

405
00:24:57,000 --> 00:25:00,000
그리고 당신은 또한 프로그래밍을 시작 할 때, 자신의 기능을 쓸 수 있습니다

406
00:25:00,000 --> 00:25:04,000
당신은 라이브러리를 당신이 필요로하는 모든 기능을 가지고 있지 않다는 걸 알고 있습니다.

407
00:25:04,000 --> 00:25:10,000
마지막 pset를 들어, 예를 들어, 우리는, 출격 그릴, 그리고 조회를 작성

408
00:25:10,000 --> 00:25:13,000
그리고 기능을 쓸 수 있도록 매우 중요합니다

409
00:25:13,000 --> 00:25:17,000
그들은 유용합니다, 우리는 그들에게 프로그래밍의 모든 시간을 사용하기 때문에하는 것은

410
00:25:17,000 --> 00:25:19,000
그리고 코드를 많이 절약 할 수 있습니다.

411
00:25:19,000 --> 00:25:21,000
함수의 형식이 하나입니다.

412
00:25:21,000 --> 00:25:24,000
우리는 처음에 반환 형식을 갖추고 있습니다. 반환 유형은 무엇입니까?

413
00:25:24,000 --> 00:25:27,000
당신의 함수가 반환 할 때 뿐이야.

414
00:25:27,000 --> 00:25:29,000
당신은 요소 예를 들어, 기능을,,,이있는 경우

415
00:25:29,000 --> 00:25:31,000
즉, 정수의 계승을 계산하는 것이다

416
00:25:31,000 --> 00:25:34,000
아마도 또한 정수를 반환하는거야.

417
00:25:34,000 --> 00:25:37,000
그런 다음 반환 유형은 정수가 될 것입니다.

418
00:25:37,000 --> 00:25:41,000
Printf 실제로 반환 유형 무효가

419
00:25:41,000 --> 00:25:43,000
당신은 아무것도를 반환하지 때문입니다.

420
00:25:43,000 --> 00:25:45,000
당신은 화면에 물건을 인쇄하는

421
00:25:45,000 --> 00:25:48,000
그리고 나중에 기능을 종료.

422
00:25:48,000 --> 00:25:51,000
그런 다음 당신이 선택할 수있는 기능의 이름을 수 있습니다.

423
00:25:51,000 --> 00:25:55,000
XYZ 같은 이름을 선택하지 않는 것처럼 좀 합리적인해야

424
00:25:55,000 --> 00:25:58,000
또는 x2f처럼.

425
00:25:58,000 --> 00:26:02,000
맞는 이름을 확인하려고합니다.

426
00:26:02,000 --> 00:26:04,000
>> 예를 들어,이 요인이라면, 계승 말한다.

427
00:26:04,000 --> 00:26:08,000
그건 뭔가를 그릴 것입니다 기능면, 그림을 그리는 이름을 지정합니다.

428
00:26:08,000 --> 00:26:11,000
그리고 우리는 또한 인자라고하는 매개 변수를 있습니다

429
00:26:11,000 --> 00:26:14,000
당신의 함수가 필요로하는 자원과 같은 뭐지?

430
00:26:14,000 --> 00:26:17,000
코드에서의 작업을 수행합니다.

431
00:26:17,000 --> 00:26:20,000
당신은 숫자의 계승을 계산하려면

432
00:26:20,000 --> 00:26:23,000
아마도 당신은 계승을 계산하는 숫자가 필요합니다.

433
00:26:23,000 --> 00:26:27,000
당신이 봐야한다는 주장 중 하나는 숫자 자체입니다.

434
00:26:27,000 --> 00:26:31,000
그리고 그 일을해야하고 마지막에있는 값을 반환거야

435
00:26:31,000 --> 00:26:35,000
그것은 무효 기능 아니라면.

436
00:26:35,000 --> 00:26:37,000
가 예를 보자.

437
00:26:37,000 --> 00:26:40,000
나는 정수의 배열에있는 모든 숫자를 표현하는 함수를 작성하려면

438
00:26:40,000 --> 00:26:43,000
우선, 반환 유형은 정수가 될거야

439
00:26:43,000 --> 00:26:46,000
나는 정수의 배열을 가지고 있기 때문에.

440
00:26:46,000 --> 00:26:51,000
그리고 나서, sumArray 같은 함수 이름을 가지고 간다

441
00:26:51,000 --> 00:26:54,000
다음은 INT nums까지, 배열 자체를 받아 들일거야

442
00:26:54,000 --> 00:26:58,000
그리고 내가 요약해야 얼마나 많은 숫자 알 수 있도록 배열의 길이입니다.

443
00:26:58,000 --> 00:27:02,000
그럼 난 0 예를 들어라는 변수 합계를,,, 초기화해야

444
00:27:02,000 --> 00:27:08,000
내가 배열의 요소를 볼 때마다 나는 금액에 추가해야합니다, 그래서 루프에 대한 했어요.

445
00:27:08,000 --> 00:27:15,000
Lexi가 말한대로, 당신은 INT I = 0, 나는 <길이와 난 + +.

446
00:27:15,000 --> 00:27:20,000
그리고 배열의 모든 요소에 나는 합계 + = nums [I]를 했어,

447
00:27:20,000 --> 00:27:24,000
그리고는 합계를 반환하기 때문에 매우 간단하고, 코드를 많이 절약 할 수

448
00:27:24,000 --> 00:27:28,000
이 기능 번을 많이 사용하는 경우.

449
00:27:28,000 --> 00:27:32,000
그럼 우리가 조건을 살펴했습니다.

450
00:27:32,000 --> 00:27:38,000
우리는 다른, 경우에 있고, 다른 경우.

451
00:27:38,000 --> 00:27:42,000
그 차이입니다 알아 보자.

452
00:27:42,000 --> 00:27:45,000
이 두 코드를 살펴보십시오. 그들 사이의 차이점은 무엇입니까?

453
00:27:45,000 --> 00:27:49,000
첫번째는 - 기본적으로 한 코드는 말하고 싶어

454
00:27:49,000 --> 00:27:51,000
, 또는 0 - 숫자 + 인 경우.

455
00:27:51,000 --> 00:27:55,000
첫 번째는> 0면 그때는 양성 말합니다.

456
00:27:55,000 --> 00:28:00,000
는 0 =면 다음은 0이고,이 <0이라면 다음은 음수입니다.

457
00:28:00,000 --> 00:28:04,000
>> 다른, 만약 다른, 경우와 다른 하나는하고있다.

458
00:28:04,000 --> 00:28:07,000
둘 사이의 차이는 사람이 실제로에 갈 것입니다

459
00:28:07,000 --> 00:28:13,000
선택하면> 0, <0 또는 = 0 세 번

460
00:28:13,000 --> 00:28:17,000
당신은 숫자 2를하면, 예를 들어, 여기에 와서 말을 겁니다

461
00:28:17,000 --> 00:28:21,000
이 승락을거야 (x> 0) 경우, 그리고, 그래서 긍정적 인쇄 할 수 있습니다.

462
00:28:21,000 --> 00:28:25,000
하지만 그게> 0라고 알고는 0 또는 <0가 안하더라도

463
00:28:25,000 --> 00:28:29,000
나는 아직도이 0 그렇게 할거야, 그것은 <0입니다

464
00:28:29,000 --> 00:28:33,000
그래서 실제로 내가해야만하지 않은 IFS의 내부에 갈거야

465
00:28:33,000 --> 00:28:38,000
나는 이미 이러한 조건 중 하나를 만족시키지 못할 거예요 알 때문입니다.

466
00:28:38,000 --> 00:28:41,000
나는 진술 다른, 경우 다른, 경우에 사용할 수 있습니다.

467
00:28:41,000 --> 00:28:45,000
X = 0 나는 긍정적를 인쇄하면 기본적으로 말합니다.

468
00:28:45,000 --> 00:28:48,000
그렇지 않은 경우, 나는 또한이를 테스트 할거야.

469
00:28:48,000 --> 00:28:51,000
지금은 2면이 일을 갈 수 없습니다.

470
00:28:51,000 --> 00:28:54,000
나는 X = 2가 있으면 기본적으로 말 것

471
00:28:54,000 --> 00:28:57,000
(X> 0) 경우, 예,이 인쇄 할 수 있습니다.

472
00:28:57,000 --> 00:29:00,000
지금은이> 0이라고 알고 그 처음하면 만족

473
00:29:00,000 --> 00:29:02,000
난이 코드를 실행하지 않을거야.

474
00:29:02,000 --> 00:29:09,000
당신이 이것을 사용하는 경우 코드는 3 배 빠른, 사실은, 빠르게 실행됩니다.

475
00:29:09,000 --> 00:29:11,000
우리는 또한 및 및 또는 배웠습니다.

476
00:29:11,000 --> 00:29:15,000
나는 Lexi 이미 그들에 대해 이야기하기 때문에이 통과하지 않을거야.

477
00:29:15,000 --> 00:29:17,000
| 연산자 | 단지 &&와입니다.

478
00:29:17,000 --> 00:29:21,000
>> 나도 그래 건 당신이 세 조건이있을 때주의해야합니다.

479
00:29:21,000 --> 00:29:24,000
매우 혼란 스러워요 때문에 조건이있을 때 괄호를 사용

480
00:29:24,000 --> 00:29:27,000
다른 하나 또는 다른.

481
00:29:27,000 --> 00:29:30,000
당신의 조건이 이해가 있는지 확인하려면 괄호를 사용

482
00:29:30,000 --> 00:29:34,000
이 경우 예를 들어, 당신이 상상할 수 있기 때문에 그

483
00:29:34,000 --> 00:29:38,000
처음 상태와 하나 또는 다른 될 수

484
00:29:38,000 --> 00:29:41,000
또는 2에서 결합 조건과

485
00:29:41,000 --> 00:29:45,000
또는 제 3 사람은, 그래서주의해야합니다.

486
00:29:45,000 --> 00:29:48,000
그리고 마지막으로, 우리는 스위치에 대한 이야기​​.

487
00:29:48,000 --> 00:29:53,000
당신은 변수가있을 때 스위치는 매우 유용합니다.

488
00:29:53,000 --> 00:29:55,000
자, 당신은 N과 같은 변수가 그런 말을

489
00:29:55,000 --> 00:29:59,000
그 0, 1, 또는 2가 될 수 있으며, 이러한 경우에 대한 각각의

490
00:29:59,000 --> 00:30:01,000
당신은 작업을 수행거야.

491
00:30:01,000 --> 00:30:04,000
당신은 변수를 전환 말할 수 있으며,을 나타냅니다

492
00:30:04,000 --> 00:30:08,000
값은 다음 값 1처럼 내가 할 수있는 것거든요

493
00:30:08,000 --> 00:30:12,000
그리고 이별, 그 내가 다른 경우의 볼 않을거야 의미

494
00:30:12,000 --> 00:30:15,000
우리는 이미 그 가방을 만족하기 때문에

495
00:30:15,000 --> 00:30:20,000
그리고 VALUE2 등, 게다가 기본 스위치를 할 수 있습니다.

496
00:30:20,000 --> 00:30:24,000
그것은 내가했던 사건 중 하나를 만족하지 않는 경우 그 의미

497
00:30:24,000 --> 00:30:29,000
내가 다른 일을 할거야,하지만 그건 선택 사항이라고.

498
00:30:29,000 --> 00:30:36,000
나를 위해 모든입니다. 이번에는 토미를 보자.

499
00:30:36,000 --> 00:30:41,000
좋아,이 주 3 살쯤 될 것입니다.

500
00:30:41,000 --> 00:30:45,000
이러한 우리가, 기타 등등 암호, 범위, 배열을 다루는됩니다 항목 중 일부입니다.

501
00:30:45,000 --> 00:30:49,000
암호화에 잠깐 한마디 만. 우리는이 집에 해머 않을거야.

502
00:30:49,000 --> 00:30:52,000
>> 우리는 pset 2 이런 짓을하지만, 퀴즈에 당신이 그 차이를 알고 있어야합니다

503
00:30:52,000 --> 00:30:54,000
카이사르 암호문과 Vigenère의 암호 사이,

504
00:30:54,000 --> 00:30:57,000
이러한 암호 작업의 두과는 그 암호화하는 같은 방법을

505
00:30:57,000 --> 00:30:59,000
지난 2 암호를 사용하고 암호 해독 텍스트입니다.

506
00:30:59,000 --> 00:31:03,000
단, 카이사르 암호는 단순히 동일한 금액으로 각 문자를 회전

507
00:31:03,000 --> 00:31:06,000
알파벳의 문자 수에 의해이 모드 확인하는.

508
00:31:06,000 --> 00:31:09,000
그리고 Vigenère의 암호, 반면에, 각 문자를 회전

509
00:31:09,000 --> 00:31:12,000
다른 한 금액을 기준으로, 그래서 오히려 말보다

510
00:31:12,000 --> 00:31:15,000
3 Vigenère의 모든 문자 회전 각 문자를 회전합니다

511
00:31:15,000 --> 00:31:17,000
일부 키워드에 따라 다른 금액을 기준으로

512
00:31:17,000 --> 00:31:20,000
키워드의 각 문자는 좀 다른 양을 나타냅니다

513
00:31:20,000 --> 00:31:26,000
하여 일반 텍스트를 회전합니다.

514
00:31:26,000 --> 00:31:28,000
변수 범위에 대한 첫번째 이야기하자.

515
00:31:28,000 --> 00:31:30,000
변수의 2 가지 종류가 있습니다.

516
00:31:30,000 --> 00:31:33,000
우리는 지역 변수를 가지고 있고, 이것들은 정의 할 거예요

517
00:31:33,000 --> 00:31:36,000
이외의 주요 또는 함수 나 블록 바깥에 있고,

518
00:31:36,000 --> 00:31:39,000
이러한이 프로그램에 어디서나 액세스 할 수 있습니다.

519
00:31:39,000 --> 00:31:41,000
당신은 기능이 그 기능에 잠시 루프가있는 경우

520
00:31:41,000 --> 00:31:44,000
큰 전역 변수는 모든 액세스 할 수 있습니다.

521
00:31:44,000 --> 00:31:48,000
지역 변수는 반면에,이 정의되어있는 곳으로 범위를 지정합니다.

522
00:31:48,000 --> 00:31:53,000
>> 여기에 기능이있는 경우, 예를 들어, 우리는이 함수 g이

523
00:31:53,000 --> 00:31:56,000
와 g의 내부 Y 불리는 변수가 있습니다

524
00:31:56,000 --> 00:31:58,000
그리고이 지역 변수 있다는 것을 의미합니다.

525
00:31:58,000 --> 00:32:00,000
이 변수는 Y라고하더라도

526
00:32:00,000 --> 00:32:03,000
이 변수는이 두 기능을 Y라고합니다

527
00:32:03,000 --> 00:32:06,000
서로의 지역 변수가 아무 생각이 없습니다.

528
00:32:06,000 --> 00:32:10,000
한편, 여기까지 우리는 INT X = 5라고

529
00:32:10,000 --> 00:32:12,000
이은 함수의 범위 밖에 있습니다.

530
00:32:12,000 --> 00:32:16,000
이 메인의 범위 밖에,이는 글로벌 변수입니다.

531
00:32:16,000 --> 00:32:20,000
또는 X + + - 내가 X를 말 때이 두 기능의 내부를 의미

532
00:32:20,000 --> 00:32:26,000
이 Y이 y는 다른 변수 상기 같은 x를 액세스거야.

533
00:32:26,000 --> 00:32:30,000
전역 변수와 지역 변수의 차이점은 기록이다.

534
00:32:30,000 --> 00:32:33,000
까지 디자인에 관한 한, 가끔 아마도 더 나은 생각

535
00:32:33,000 --> 00:32:37,000
당신이 할 수 있는지 할 때마다 변수가 지역 유지하기

536
00:32:37,000 --> 00:32:39,000
문제부터 전역 변수의 무리 정말 혼란받을 수 있습니다.

537
00:32:39,000 --> 00:32:42,000
이 함수의 무리가있는 경우 모두 같은 일을 수정

538
00:32:42,000 --> 00:32:45,000
이 함수가 실수로이 글로벌 수정 한 거라면 당신은 잊지 수 있습니다

539
00:32:45,000 --> 00:32:47,000
이 다른 기능은, 그것에 대해 알고하지 않습니다

540
00:32:47,000 --> 00:32:50,000
더 많은 코드를 받으면하고 상당히 혼란 얻을 않습니다.

541
00:32:50,000 --> 00:32:53,000
당신이 할 수 있는지 할 때마다 변수가 지역 유지

542
00:32:53,000 --> 00:32:56,000
그냥 좋은 디자인입니다.

543
00:32:56,000 --> 00:33:00,000
배열은 기억, 단순히 같은 종류의 요소의 목록입니다.

544
00:33:00,000 --> 00:33:04,000
CI의 내부 인사, 1, 2.0과 같은 목록을 포함 할 수 없습니다.

545
00:33:04,000 --> 00:33:06,000
우리는 그렇게 할 수 없습니다.

546
00:33:06,000 --> 00:33:11,000
>> 우리가 C에서 배열을 선언 할 때 모든 요소는 동일한 유형이어야합니다.

547
00:33:11,000 --> 00:33:14,000
나 여기 3 정수의 배열을 갖추고 있습니다.

548
00:33:14,000 --> 00:33:18,000
난 여기 배열의 길이를 가지고,하지만 난 그냥이 구문에 선언하고있는 경우

549
00:33:18,000 --> 00:33:21,000
나는 모든 요소 내가 기술적으로이 3 필요하지 않습니다 무엇인지 지정 위치.

550
00:33:21,000 --> 00:33:25,000
컴파일러는 배열이 있어야 얼마나 큰 알만큼 충분히 똑똑합니다.

551
00:33:25,000 --> 00:33:28,000
지금은 배열의 값을 얻거나 설정 할 때

552
00:33:28,000 --> 00:33:30,000
이 것을을 할 수있는 구문입니다.

553
00:33:30,000 --> 00:33:33,000
기억하기 때문에 실제로는 배열의 두 번째 요소를 수정합니다,

554
00:33:33,000 --> 00:33:36,000
번호는 1에서하지, 0에서 시작합니다.

555
00:33:36,000 --> 00:33:42,000
그 값을 읽으려면 나 같은 말을 할 수 있습니다 INT X = 배열​​ [1].

556
00:33:42,000 --> 00:33:44,000
그 값을 설정하려는 경우처럼 내가 여기하고 있어요

557
00:33:44,000 --> 00:33:47,000
나는 배열 [1] 말할 수 = 4.

558
00:33:47,000 --> 00:33:50,000
자신의 색인 요소를 액세스 할 그 때

559
00:33:50,000 --> 00:33:52,000
또는 위치 또는 위치가 배열에 포함되어 있습니다

560
00:33:52,000 --> 00:33:57,000
그 목록은 0에서 시작합니다.

561
00:33:57,000 --> 00:34:00,000
또한, 배열의 배열을 할 수 있습니다

562
00:34:00,000 --> 00:34:03,000
이는 다차원 배열이라고합니다.

563
00:34:03,000 --> 00:34:05,000
우리는 다차원 배열이있을 때

564
00:34:05,000 --> 00:34:07,000
우리가 행과 열 같은 것을 할 수 있습니다 의미

565
00:34:07,000 --> 00:34:11,000
이이 시각화하거나 생각의 한 방법입니다.

566
00:34:11,000 --> 00:34:14,000
나는 다차원 배열이있을 때 그것이 내가 필요 시작할거야 의미

567
00:34:14,000 --> 00:34:17,000
개 이상의 인덱스 때문에 그리드가있는 경우

568
00:34:17,000 --> 00:34:19,000
당신이 어떤 건지 행 말하는 우리에게 번호를 제공하지 않습니다.

569
00:34:19,000 --> 00:34:22,000
그건 정말 우리에게 번호 목록을 제공거야.

570
00:34:22,000 --> 00:34:25,000
자, 여기이 배열 있다고 가정 해 봅시다.

571
00:34:25,000 --> 00:34:30,000
나는 그리드라는 배열을 가지고 있고, 난 그의 2 행과 3 열을 말하는거야

572
00:34:30,000 --> 00:34:32,000
그래서이 그것을 시각화하는 방법 중 하나입니다.

573
00:34:32,000 --> 00:34:37,000
내가 [1]에서 요소를 얻고 자 할 말을 할 때 [2]

574
00:34:37,000 --> 00:34:41,000
그 이러한 행을 먼저 한 다음 열 때문에 의미

575
00:34:41,000 --> 00:34:44,000
나는 1 말부터 1 행으로 이동합니다 겠어.

576
00:34:44,000 --> 00:34:49,000
>> 그럼 내가 열 2에 여기에 온거야, 나는 가치를 6 가져다 드리죠.

577
00:34:49,000 --> 00:34:51,000
이해가가?

578
00:34:51,000 --> 00:34:55,000
다차원 배열은, 기억, 기술적으로 배열 중 배열입니다.

579
00:34:55,000 --> 00:34:57,000
우리는 배열의 배열의 배열을 할 수 있습니다.

580
00:34:57,000 --> 00:35:00,000
우리는 계속 할 수 있지만 생각 정말 한 가지 방법에

581
00:35:00,000 --> 00:35:03,000
이것은 배치되고 있으며 무슨 일이야 어떻게하면 그것을 시각화하는 것입니다

582
00:35:03,000 --> 00:35:09,000
이와 같은 그리드 인치

583
00:35:09,000 --> 00:35:12,000
우리가 함수에 배열을 통과 할 때, 그들은 행동 할거야

584
00:35:12,000 --> 00:35:16,000
우리가 함수에 일반 변수를 통과 할 때보다 다르게 조금

585
00:35:16,000 --> 00:35:18,000
정수 또는 부동 소수점을 통과처럼.

586
00:35:18,000 --> 00:35:21,000
우리는 정수 나 문자 또는 다른 데이터의 종류에 통과 할 때

587
00:35:21,000 --> 00:35:24,000
우리는 함수가 수정하는 경우를 살펴 봤네

588
00:35:24,000 --> 00:35:28,000
변화가 전파하지 않을 것을 그 변수의 값

589
00:35:28,000 --> 00:35:32,000
함수 호출합니다.

590
00:35:32,000 --> 00:35:35,000
배열 반면에, 그런 일이됩니다.

591
00:35:35,000 --> 00:35:39,000
좀 함수에 배열에 합격하고 그 함수는 요소의 일부를 변경하는 경우

592
00:35:39,000 --> 00:35:43,000
난라는 기능까지 돌아 왔을 때

593
00:35:43,000 --> 00:35:47,000
내 배열은 이제 달라질거야, 그리고 그것 때문에 어휘 is

594
00:35:47,000 --> 00:35:50,000
우리가 나중에 보게 될 것입니다 배열은 참조에 의해 전달됩니다.

595
00:35:50,000 --> 00:35:53,000
이것은 어떻게 포인터 작업이 기본 데이터 형식으로 관련되어

596
00:35:53,000 --> 00:35:55,000
반면에, 값에 의해 전달됩니다.

597
00:35:55,000 --> 00:35:59,000
>> 우리는 어떤 변수의 사본을 만들고 다음 사본을 전달로 그 생각을 할 수 있습니다.

598
00:35:59,000 --> 00:36:01,000
우리가 그 변수 뭘해도 상관하지 않습니다.

599
00:36:01,000 --> 00:36:06,000
전화 기능은이 변경되었습니다된다는 사실을 인식하지 않습니다.

600
00:36:06,000 --> 00:36:10,000
배열 그 점에 관해서는 다른 조금 있습니다.

601
00:36:10,000 --> 00:36:13,000
우리가 본대로 예를 들어, 메인은 단순히 기능입니다

602
00:36:13,000 --> 00:36:15,000
우리가 2 인자에 걸릴 수 있습니다.

603
00:36:15,000 --> 00:36:20,000
메인 함수의 첫 번째 인수는, argc, 또는 인수의 수입니다

604
00:36:20,000 --> 00:36:23,000
두 번째 인자는 변수는 argv라고합니다

605
00:36:23,000 --> 00:36:27,000
그리고 그 그 인자의 실제 값입니다.

606
00:36:27,000 --> 00:36:30,000
자, 내가 this.c라는 프로그램을 말

607
00:36:30,000 --> 00:36:34,000
그리고이 말을, 내가 명령 줄에서이 실행거야.

608
00:36:34,000 --> 00:36:38,000
지금 내 프로그램에 몇 가지 인자를 전달하려면이라고

609
00:36:38,000 --> 00:36:42,000
난 뭔가 이렇게 말할 수 있습니다. /이 CS 50입니다.

610
00:36:42,000 --> 00:36:45,000
이것은 우리가 터미널에서 매일 데이비드 어떻게 생각 일 것입니다.

611
00:36:45,000 --> 00:36:48,000
해당 프로그램의 그러나 지금은 main () 함수 내부

612
00:36:48,000 --> 00:36:52,000
이 값을 가지고 있으므로 argc는 4입니다.

613
00:36:52,000 --> 00:36:56,000
정말 우리는 CS 50에 전달 있기 때문에 조금 혼란 될 수 있습니다.

614
00:36:56,000 --> 00:36:58,000
그 불과 3입니다.

615
00:36:58,000 --> 00:37:02,000
그러나 기억 변수는 argv의 첫번째 요소 또는 첫 번째 인수

616
00:37:02,000 --> 00:37:05,000
기능 자체의 이름입니다.

617
00:37:05,000 --> 00:37:07,190
그래서 우리가 여기에 4 가지가 있다는 것을 의미

618
00:37:07,190 --> 00:37:10,530
그리고 첫 번째 요소는. /이 될 것입니다.

619
00:37:10,530 --> 00:37:12,970
그리고이는 문자열로 표현됩니다.

620
00:37:12,970 --> 00:37:18,590
그런 다음 나머지 요소는 우리가 프로그램의 이름 이후에 입력 한 내용입니다.

621
00:37:18,590 --> 00:37:22,720
그럼 옆 마찬가지로, 우리가 pset 2 본으로

622
00:37:22,720 --> 00:37:28,780
문자열 50 정수 50 ≠ 것을 기억 해요.

623
00:37:28,780 --> 00:37:32,520
그래서 우리는, 같은 말을 할 수 없습니다 '정수 X = 변수는 argv 3.'

624
00:37:32,520 --> 00:37:36,470
>> 이 문자열이기 때문 그냥 이해하지 않을거야, 그리고이 정수입니다.

625
00:37:36,470 --> 00:37:38,510
당신은 2 사이의 변환을하고 싶다면 명심 해, 우리가가는거야

626
00:37:38,510 --> 00:37:40,810
atoi이라는 마법 기능을 갖추고 있습니다.

627
00:37:40,810 --> 00:37:46,270
그건 문자열을 소요하고 문자열의 내부 대표 정수를 반환합니다.

628
00:37:46,270 --> 00:37:48,360
그럼, 퀴즈에 수 있도록 쉬운 실수

629
00:37:48,360 --> 00:37:51,590
이번이 자동으로 올바른 유형 될 것이라고 생각.

630
00:37:51,590 --> 00:37:53,860
그러나 단지이 항상 문자열이어야합니다 알고

631
00:37:53,860 --> 00:38:00,920
문자열은 정수 또는 문자 또는 수레가 포함되어 경우에도 마찬가지입니다.

632
00:38:00,920 --> 00:38:03,380
그래서 지금의 시간을 실행하는 방법에 대한 이야기​​를 할 수있게 해 주시오.

633
00:38:03,380 --> 00:38:06,700
우리 모두가이 미친 짓을 모든 알고리즘이 때,

634
00:38:06,700 --> 00:38:11,580
그것은 질문을 정말 유용하게된다 "그들이 얼마나 걸리죠?"

635
00:38:11,580 --> 00:38:15,500
우리는 점근 표기법이라는 뭔가 그런 나타냅니다.

636
00:38:15,500 --> 00:38:18,430
음, 우리는 알고리즘을 제공한다고 가정 해 보겠습니다 - 그럼이 있다는 것을 의미

637
00:38:18,430 --> 00:38:20,840
일부 정말, 정말, 정말 큰 입력.

638
00:38:20,840 --> 00:38:23,840
우리는 질문을하고 싶다 "얼마나 걸릴까요?

639
00:38:23,840 --> 00:38:26,370
얼마나 많은 단계가 실행하기 위해 알고리즘을 취할 것

640
00:38:26,370 --> 00:38:29,980
입력의 크기의 함수로? "

641
00:38:29,980 --> 00:38:33,080
그래서 우리는 실행 시간을 설명 할 수있는 첫 번째 방법은 큰 O.과 함께

642
00:38:33,080 --> 00:38:35,380
그리고이 최악의 실행 시간입니다.

643
00:38:35,380 --> 00:38:38,590
우리가 배열을 정렬하고 싶다면, 우리는 우리의 알고리즘 배열을 제공

644
00:38:38,590 --> 00:38:41,000
가 오름차순이어야합니다 때는 내림차순에

645
00:38:41,000 --> 00:38:43,130
그 최악의 경우가 생길거야.

646
00:38:43,130 --> 00:38:49,800
이것은 우리의 알고리즘이 소요됩니다 시간의 최대 길이에 행의 상단입니다.

647
00:38:49,800 --> 00:38:54,740
한편,이 Ω는 최선의 실행 시간을 설명하는 것이다.

648
00:38:54,740 --> 00:38:58,210
우리가 정렬 알고리즘에 이미 정렬 된 배열을 제공한다면은,

649
00:38:58,210 --> 00:39:00,940
를 정렬하는 방법을 걸립니까?

650
00:39:00,940 --> 00:39:06,610
그리고이 다음 시간을 실행에 낮은 바운드에 대해 설명합니다.

651
00:39:06,610 --> 00:39:10,980
그래서 여기 몇 가지 일반적인 실행 시간을 설명하는 단순한 단어입니다.

652
00:39:10,980 --> 00:39:13,120
이러한 오름차순입니다.

653
00:39:13,120 --> 00:39:16,060
우리가 가장 빠른 실행 시간이 일정이라고합니다.

654
00:39:16,060 --> 00:39:19,800
>> 우리는 알고리즘을 제공 얼마나 많은 요소에 상관없이, 의미도없는 그

655
00:39:19,800 --> 00:39:22,280
우리의 배열을 정렬, 얼마나 크 상관없이

656
00:39:22,280 --> 00:39:26,510
또는 우리가 배열에 뭘하는 진 몰라도하는 것은 항상 같은 시간이 소요됩니다.

657
00:39:26,510 --> 00:39:30,270
그래서 우리는 일정 1과 그를 대표 할 수 있습니다.

658
00:39:30,270 --> 00:39:32,410
우리는 또한 로그 런타임 바라 보았다.

659
00:39:32,410 --> 00:39:34,800
따라서 이진 검색과 같은 일이, 로그입니다

660
00:39:34,800 --> 00:39:37,140
우리 반은 모든 시간에 문제를 파멸시키는 곳

661
00:39:37,140 --> 00:39:40,970
그리고 일이 거기에서 더 높아질.

662
00:39:40,970 --> 00:39:43,580
그리고 당신이 과거의 어떤 요소 알고리즘의 O을 작성하는 경우,

663
00:39:43,580 --> 00:39:47,850
당신은 아마 하루 작업으로이를 고려해서는 안됩니다.

664
00:39:47,850 --> 00:39:53,910
우리가 실행 시간을 비교했을 때 그 마음에 이런 일을 유지하는 것이 중요합니다.

665
00:39:53,910 --> 00:39:57,760
나는 O (n)이의 알고리즘, 그리고 다른 사람이면

666
00:39:57,760 --> 00:40:03,590
O의 알고리즘은 (2N)이 사실은 점근 동일했다.

667
00:40:03,590 --> 00:40:06,590
우리는 eleventy 억 같은 큰 숫자로 습니 상상한다면 :

668
00:40:06,590 --> 00:40:13,090
우리가 eleventy 억 같은 + 3 eleventy 억을 비교 할 때,

669
00:40:13,090 --> 00:40:17,640
갑자기 셋 정말 더 이상 큰 차이를하지 않습니다.

670
00:40:17,640 --> 00:40:20,980
우리가이 일들이 동등한 것으로 생각 시작할 거에요 이유입니다.

671
00:40:20,980 --> 00:40:24,220
여기에 상수 같은 것을 그래서,이 X이, 아니면 3을 추가

672
00:40:24,220 --> 00:40:27,180
이는 상수이며,이가 떨어질 것입니다.

673
00:40:27,180 --> 00:40:32,480
이러한 실행 시간의 3가 O (n)이 말하는과 동일합니다 그래서 그입니다.

674
00:40:32,480 --> 00:40:37,490
우리가이 다른 실행 시간이 있다면 마찬가지로, O (N ³ + 2N ²), 우리는 추가 할 수 있습니다 가정 해 봅시다

675
00:40:37,490 --> 00:40:42,070
그런 다음 + N, + 7, 그래서 우리는 단지 O가 다른 런타임 (N의 ³)를 갖추고 있습니다.

676
00:40:42,070 --> 00:40:46,290
이이 같은하지 않습니다 -이 있기 때문 다시이 같은 일입니다.

677
00:40:46,290 --> 00:40:49,840
이는 같은 거, 미안 해요. 따라서 이것들은 동일합니다 때문에

678
00:40:49,840 --> 00:40:53,090
이 N 개의 ³이 2N ²을 지배 예정이다.

679
00:40:53,090 --> 00:40:59,130
>> 우리가 O (N 개의 ³) 및 O 같은 시간을 실행 한 경우 어떻게하면 같은 일이 아닙니다 (N ²)

680
00:40:59,130 --> 00:41:02,820
이 N 개의 ³이 N 개의 ²보다 훨씬 큰 때문입니다.

681
00:41:02,820 --> 00:41:05,470
우리가 지수를 갖고 있으면, 갑자기이 문제가 시작

682
00:41:05,470 --> 00:41:08,280
우리가 여기있는 한 우리는 방금 요소를 처리 할 때

683
00:41:08,280 --> 00:41:12,810
다음 그들은 단지 포기하려고하기 때문에 문제가 없을거야.

684
00:41:12,810 --> 00:41:16,760
의 우리가 지금까지 본 적이 알고리즘의 일부를 살펴 보자

685
00:41:16,760 --> 00:41:19,260
및 런타임에 대해 이야기.

686
00:41:19,260 --> 00:41:23,850
목록에있는 숫자를 찾는 첫 번째 방법은 우리가 본, 선형 검색했습니다.

687
00:41:23,850 --> 00:41:26,950
그리고 선형 검색의 구현은 슈퍼 간단합니다.

688
00:41:26,950 --> 00:41:30,490
우리는 목록을 가지고 있고, 우리는 목록에있는 모든 단일 요소 보는거야

689
00:41:30,490 --> 00:41:34,260
우리가 번호를 찾을 때까지 우리는을 찾고 있습니다.

690
00:41:34,260 --> 00:41:38,370
말하자면 그 최악의 경우에,이 O (n)이.

691
00:41:38,370 --> 00:41:40,860
요소 인 경우 여기 최악의 경우가 될 수

692
00:41:40,860 --> 00:41:45,710
마지막 요소 다음, 선형 검색을 사용하여 우리는 모든 단일 요소를보고해야

693
00:41:45,710 --> 00:41:50,180
우리는 목록에 실제로 있다는 사실을 알게하기 위해 마지막 하나까지.

694
00:41:50,180 --> 00:41:52,910
우리는 단지 중간 포기하고 말 할 수 없다 "는 없을지도 몰라."

695
00:41:52,910 --> 00:41:55,980
선형 검색을 통해 우리는 모든 것을 살펴해야합니다.

696
00:41:55,980 --> 00:41:59,090
가장의 경우 실행 시간은, 반면에, 일정

697
00:41:59,090 --> 00:42:04,200
가장 좋은 경우에 우리가 찾는 요소는 목록의 첫 번째이기 때문이다.

698
00:42:04,200 --> 00:42:08,930
그래서 우리에게 정확히 1 단계, 목록가 얼마나 커에 상관없이 걸릴 거예요

699
00:42:08,930 --> 00:42:12,140
우리는 첫 번째 요소마다 찾고 있다면.

700
00:42:12,140 --> 00:42:15,390
>> 그래서 당신은 검색 할 때, 기억, 우리의 목록을 정렬 할 것을 요구하지 않습니다.

701
00:42:15,390 --> 00:42:19,430
우리는 간단하게 모든 단일 요소를 통해 보는거야, 그리고 정말 문제가되지 않기 때문에

702
00:42:19,430 --> 00:42:23,560
어떤 순서 요소 인치 아르

703
00:42:23,560 --> 00:42:28,110
보다 지능적인 검색 알고리즘은 이진 검색과 같은 일입니다.

704
00:42:28,110 --> 00:42:31,500
당신이에 갈 때 단, 이진 검색의 구현입니다

705
00:42:31,500 --> 00:42:34,320
목록의 중간 계속 쳐다 보는.

706
00:42:34,320 --> 00:42:38,000
우리가 중간보고 때문에, 우리는 목록이 정렬됩니다 것을 요구

707
00:42:38,000 --> 00:42:40,580
그렇지 않으면 중간 어디 있는지 몰라, 우리가 그쪽으로 봐야

708
00:42:40,580 --> 00:42:44,480
을 찾을 수있는 전체 목록과 해당 시점에서 우리는 시간을 낭비하고 있습니다.

709
00:42:44,480 --> 00:42:48,480
우리가 정렬 목록을 가지고 우리가 중앙을 찾는다면 그래서, 우리는 우리가 중앙을 비교하는 것

710
00:42:48,480 --> 00:42:51,590
요소에 우리는을 찾고 있습니다.

711
00:42:51,590 --> 00:42:54,640
너무 높은이라면, 우리는 오른쪽 절반을 잊을 수

712
00:42:54,640 --> 00:42:57,810
우리는 알고 있기 때문에 우리의 요소가 이미 너무 높은 경우

713
00:42:57,810 --> 00:43:01,080
이 요소의 오른쪽에있는 모든 더 높은이며,

714
00:43:01,080 --> 00:43:02,760
그러면 우리는 더 이상이 볼 필요가 없습니다.

715
00:43:02,760 --> 00:43:05,430
어디 반면에, 우리의 요소가 너무 낮은 경우는,

716
00:43:05,430 --> 00:43:08,700
우리는 그 요소의 왼쪽에있는 모든도 너무 낮 알고

717
00:43:08,700 --> 00:43:11,390
그래서 정말 그 쪽은 확인하는 의미하지 않습니다.

718
00:43:11,390 --> 00:43:15,760
이 방법 목록의 중간 지점에서 모든 단계 우리가 볼때마다와 함께

719
00:43:15,760 --> 00:43:19,060
갑자기 우리가 알고 있기 때문에 우리는 반으로 우리의 문제를 줄일 것

720
00:43:19,060 --> 00:43:23,040
우리가 찾고있는 하나가 될 수없는 숫자의 모든것.

721
00:43:23,040 --> 00:43:26,950
>> 의사에서는이는 다음과 같이 것

722
00:43:26,950 --> 00:43:30,990
때문에 우리는 반마다 한 번에 목록을 절단하고

723
00:43:30,990 --> 00:43:34,920
로그 to 선형에서의 최악의 런타임 점프.

724
00:43:34,920 --> 00:43:39,260
갑자기 우리는이 로그인 목록에서 요소를 찾을 수 있도록 단계.

725
00:43:39,260 --> 00:43:42,460
가장의 경우 실행 시간은,하지만 여전히 일정

726
00:43:42,460 --> 00:43:45,180
지금은 때문에 우리가 찾고있는 요소는 말의하자

727
00:43:45,180 --> 00:43:48,380
원래 목록의 항상 정확한 중간.

728
00:43:48,380 --> 00:43:52,080
그래서, 우리는 우리가 우리가 원하는만큼 큰 목록을 확장 할 수 있지만 우리가 찾는 요소는 중간에있는 경우

729
00:43:52,080 --> 00:43:54,910
다음은 우리에게 한 조치를 취할 겁니다.

730
00:43:54,910 --> 00:44:00,920
우리가 O (로그 n)이 있으며 Ω (1) 또는 일정한 이유 그래서입니다.

731
00:44:00,920 --> 00:44:04,510
의 실제로이 목록에 이진 검색을 실행할 수 있습니다.

732
00:44:04,510 --> 00:44:08,020
그럼 우리가 요소 164을 찾고했다고 가정합시다.

733
00:44:08,020 --> 00:44:11,650
우리가 어떻게 할 거예요 제일 먼저이 목록의 중간 지점을 찾을 수 있습니다.

734
00:44:11,650 --> 00:44:15,060
그건 아주, 중간 지점이 두 숫자 사이에 빠지게 할 것이라는 일

735
00:44:15,060 --> 00:44:18,960
그래서 중간 지점 2 숫자 사이에 떨어지는 때마다, 그냥 임의로 가정하자

736
00:44:18,960 --> 00:44:21,150
그냥 정신을 차릴 보자.

737
00:44:21,150 --> 00:44:24,330
우리는 우리가이에게 방법의 모든 단계를 수행했는지 확인해야합니다.

738
00:44:24,330 --> 00:44:29,040
그래서 우리는 정신을 차릴거야, 우리는 161이 목록의 중간이라고 말할거야.

739
00:44:29,040 --> 00:44:34,640
따라서 161 <164, 그리고 161의 왼쪽에있는 모든 요소

740
00:44:34,640 --> 00:44:39,120
또한 <164이기 때문에 우리는 전혀 도움이되지 않을 거라는 것 알지

741
00:44:39,120 --> 00:44:42,690
우리가 할 수 없습니다 찾고있는 요소 때문에 이곳 찾아 시작합니다.

742
00:44:42,690 --> 00:44:47,060
그래서 우리가 할 수있는 것은 우리가 목록의 전체 왼쪽 절반 정도 잊을 수있다

743
00:44:47,060 --> 00:44:51,700
지금은 161 이후의 오른쪽에서 생각합니다.

744
00:44:51,700 --> 00:44:54,050
>> 그러니 다시이 중간 지점이며 그냥 정신을 차릴 보자.

745
00:44:54,050 --> 00:44:56,260
지금 175 너무 큽니다.

746
00:44:56,260 --> 00:44:59,180
그래서 우리는, 우리가 여기에 또는 여기를보고 도움이 안 될 거예요 알고

747
00:44:59,180 --> 00:45:06,610
그래서 우리는 그 던져 버릴 수 있으며, 결국 우리는 164를 누르됩니다.

748
00:45:06,610 --> 00:45:10,560
이진 검색에 대한 질문?

749
00:45:10,560 --> 00:45:14,180
하자 이미 정렬 된 목록을 검색 할 이동

750
00:45:14,180 --> 00:45:17,660
실제로 임의의 순서로 번호 목록을 마련하기 위해

751
00:45:17,660 --> 00:45:20,960
하고 오름차순으로 그 목록을.

752
00:45:20,960 --> 00:45:24,060
우리가 바라 보았다 첫 번째 알고리즘은 버블 정렬 불렀습니다.

753
00:45:24,060 --> 00:45:27,300
그리고 우리가 본 알고리즘의 간단한 것입니다.

754
00:45:27,300 --> 00:45:32,970
거품 정렬은 목록 내의 어떤 두 요소는 여길 때 있다고

755
00:45:32,970 --> 00:45:36,500
높은 번호가 낮은 번호의 왼쪽에있다 즉,

756
00:45:36,500 --> 00:45:40,190
그 목록이 될 것이라고 뜻 이지요 그러면 우리는 그들을 교환 할거야

757
00:45:40,190 --> 00:45:42,860
게 예전보다 "더 정렬".

758
00:45:42,860 --> 00:45:45,180
그리고 우리가 다시 다시 다시이 과정을 계속하려하고

759
00:45:45,180 --> 00:45:52,100
결국 요소의 정확한 위치에 거품 종류의 우리는 정렬 목록을 때까지.

760
00:45:52,100 --> 00:45:57,230
>> 이 실행 시간이 O이 될 것입니다 (N ²). 이유는 무엇입니까?

761
00:45:57,230 --> 00:46:00,370
음, 최악의 경우에 때문에, 우리는 모든 요소를​​ 데려 갈 거 고요

762
00:46:00,370 --> 00:46:04,570
우리는 목록에있는 다른 요소를 비교 결국거야.

763
00:46:04,570 --> 00:46:08,030
그러나 가장 좋은 경우에, 우리는 이미 정렬 목록을, 풍선 정렬의

764
00:46:08,030 --> 00:46:12,230
한 번만 통과하기 위해 말 것 "아니다. 나는 어떤 스왑을하지 않은, 그래서 내가 다 했어."

765
00:46:12,230 --> 00:46:17,410
그래서 우리는 Ω (N)의 최선의 실행 시간이 있습니다.

766
00:46:17,410 --> 00:46:20,680
의이 목록에 거품 정렬을 실행합니다.

767
00:46:20,680 --> 00:46:23,560
또는 일단, 정말 빠르고 어떤 의사 살펴 보도록하겠습니다.

768
00:46:23,560 --> 00:46:28,160
우리는 우리가 루프의 모든 반복에서의 추적하려는 싶은 말

769
00:46:28,160 --> 00:46:32,190
우리가 어떤 요소를 변경할지 여부를 관리 할 수​​ 있습니다.

770
00:46:32,190 --> 00:46:37,610
을 위해 할 수있는 이유 그래서, 우리는 모든 요소를​​ 바꿔 치기하지 않은 경우 중지거야.

771
00:46:37,610 --> 00:46:41,980
그럼 우리 루프의 시작에서 우리는 아무 것도 바꿔 치기하지 않은, 그래서 우리는 허위가 있다고합니다.

772
00:46:41,980 --> 00:46:47,170
이제, 우리는 목록을 가서 내가 요소 내가 + 1에 요소를 비교하는 것

773
00:46:47,170 --> 00:46:50,310
그리고 더 큰 숫자가 작은 숫자의 왼쪽에 있다는 한 경우는,

774
00:46:50,310 --> 00:46:52,310
그리고 우리가 그들을 교환거야.

775
00:46:52,310 --> 00:46:54,490
>> 그리고 우리는 요소를 바꾼 기억거야.

776
00:46:54,490 --> 00:46:58,900
우리가 목록을 최소 1 시간을 더 이동해야한다는 것을 의미합니다

777
00:46:58,900 --> 00:47:02,160
전체 목록이 이미 정렬 될 때 우리가 중지되는 조건이 있기 때문에,

778
00:47:02,160 --> 00:47:04,890
우리가 어떤 스왑을하지 않은 의미합니다.

779
00:47:04,890 --> 00:47:09,960
우리의 조건이 여기 왜 그것 때문에 '일부 요소가 교체되었습니다 동안.'

780
00:47:09,960 --> 00:47:13,720
그래서 지금은 그냥 목록에서 실행 살펴 보도록하겠습니다.

781
00:47:13,720 --> 00:47:16,640
난 목록 5,0,1,6,4 있습니다.

782
00:47:16,640 --> 00:47:19,850
버블 정렬은 왼쪽에있는 모든 방법을 시작하는 것이다, 그것은 비교하는거야

783
00:47:19,850 --> 00:47:24,700
내가 요소이므로 요소 1 0 난 + 1.

784
00:47:24,700 --> 00:47:29,020
, 그것은 잘 5> 0을 말할거야,하지만 지금 5 왼쪽에

785
00:47:29,020 --> 00:47:32,500
그래서 5 0를 교체해야합니다.

786
00:47:32,500 --> 00:47:35,470
내가 그들을 교환 할 때, 갑자기이 다른 목록을.

787
00:47:35,470 --> 00:47:38,260
이제 5> 1, 그래서 우리는 그들을 교환거야.

788
00:47:38,260 --> 00:47:42,160
5> 6 아니기 때문에 우리가 여기 아무것도 할 필요가 없습니다.

789
00:47:42,160 --> 00:47:46,690
그러나 6> 4, 우리는 교체해야합니다.

790
00:47:46,690 --> 00:47:49,740
다시 말하지만, 우리는 결국 발견 할 수있는 전체 목록을 실행해야

791
00:47:49,740 --> 00:47:52,330
이것들은 순서 것을, 우리는 그들을 교환,

792
00:47:52,330 --> 00:47:57,120
이 시점에서 우리는 목록을 하나 더 많은 시간을 실행하는 데 필요한

793
00:47:57,120 --> 00:48:05,390
모든의 순서이고,이 시점 버블 정렬에 완료되었는지 확인합니다.

794
00:48:05,390 --> 00:48:10,720
일부 요소를 복용하고 정렬하기위한 다른 알고리즘 선택 정렬입니다.

795
00:48:10,720 --> 00:48:15,740
선택 정렬 뒤에 아이디어는 우리가 목록의 정렬 부분을 구축 할거야 있다는 것입니다

796
00:48:15,740 --> 00:48:18,150
한 번에 한 요소입니다.

797
00:48:18,150 --> 00:48:23,170
>> 그리고 우리가 할 수있는 것하는 방법은 목록의 왼쪽 부분을 구축하는 것입니다.

798
00:48:23,170 --> 00:48:27,510
그리고 기본적으로, 모든 - 각 단계에서, 우리는 남아있는 가장 작은 요소를 데려 갈거야

799
00:48:27,510 --> 00:48:32,310
그 아직 정렬되지 않은, 우리는 정렬 세그먼트로 이동거야.

800
00:48:32,310 --> 00:48:35,850
즉, 우리는 지속적으로 최소 정렬되지 않은 요소를 찾아야

801
00:48:35,850 --> 00:48:40,720
그리고 최소한의 요소를 가지고 어떤로 교체

802
00:48:40,720 --> 00:48:45,090
가장 왼쪽에있는 요소는 정렬되지 않는.

803
00:48:45,090 --> 00:48:50,890
이 실행 시간은 O가 될 것입니다 (N ²) 때문에 최악의 경우에

804
00:48:50,890 --> 00:48:55,070
우리는 다른 모든 요소 하나 하나 요소를 비교해야합니다.

805
00:48:55,070 --> 00:48:59,250
우리는 목록의 왼쪽 이분의 일에 시작하면, 우리가 필요로하는 것을 말하는 거거든요

806
00:48:59,250 --> 00:49:02,970
가장 작은 요소를 찾기 위해 전체 오른쪽 세그먼트를 통해 이동합니다.

807
00:49:02,970 --> 00:49:05,430
그리고, 다시, 우리는 전체 오른쪽 세그먼트를 통해 이동해야합니다

808
00:49:05,430 --> 00:49:08,210
다시 이상 이상 이상이 넘어가요.

809
00:49:08,210 --> 00:49:11,350
그 N 개의 ²거야. 우리는 루프의 또 다른의 루프 내부에 대한이 필요 해요

810
00:49:11,350 --> 00:49:13,350
이는 N의 ²을 제안합니다.

811
00:49:13,350 --> 00:49:16,530
가장 좋은 케이스 생각에, 그럼 우리는 그것을 이미 정렬 된 목록을 제공한다고 가정 해 봅시다,

812
00:49:16,530 --> 00:49:19,270
우리는 실제로 N 개의 ²보다 더 나은을하지 않습니다.

813
00:49:19,270 --> 00:49:21,730
선택이 그래요 알 수있는 방법이 없기 때문에

814
00:49:21,730 --> 00:49:25,540
최소 요소는 내가보고 할 일입니다.

815
00:49:25,540 --> 00:49:28,970
아직이 실제로 최소 있는지 확인해야합니다.

816
00:49:28,970 --> 00:49:31,670
>> 그리고이 알고리즘을 사용하여이 최소라고 확신 할 수있는 유일한 방법은,

817
00:49:31,670 --> 00:49:34,640
다시 모든 단일 요소 보는 것입니다.

818
00:49:34,640 --> 00:49:38,420
그럼 정말 당신은을 주면 - 당신은 선택 정렬에게 이미 정렬 된 목록을 제공하는 경우,

819
00:49:38,420 --> 00:49:42,720
그것은 그것을 아직 정렬되지 않은 목록을 제공 통하지 않을거야.

820
00:49:42,720 --> 00:49:46,320
이 경우로 무슨 일이 생기면 그건 그렇고, 무슨 일이 O (일)입니다

821
00:49:46,320 --> 00:49:50,640
그리고 무언가 오메가, 우리는 더 많은 간결은 뭔가의 θ한다고 할 수 있습니다.

822
00:49:50,640 --> 00:49:52,760
이는 걸 방금 무슨 뜻한다는 어디서나 와서 볼 수 있도록합니다.

823
00:49:52,760 --> 00:49:57,580
>> 무언가가 n의 세타 경우 ², 그것은 둘 다 O (N ²)와 Ω (N ²)입니다.

824
00:49:57,580 --> 00:49:59,790
최고의 케이스와 최악의 경우 그래서 그것은 소용 없어요

825
00:49:59,790 --> 00:50:04,400
알고리즘은 같은 일 때마다 일을 할거야.

826
00:50:04,400 --> 00:50:06,610
그래서이 선택 정렬에 대한 의사의 모습을 수있는 건입니다.

827
00:50:06,610 --> 00:50:10,630
우리는 기본적으로 내가 목록을 통해 반복 할 말을 할거야

828
00:50:10,630 --> 00:50:15,180
오른쪽에, 그리고 루프의 각 반복에서 왼쪽에서, 움직일거야

829
00:50:15,180 --> 00:50:19,780
목록이 정렬 부분에 최소한의 요소입니다.

830
00:50:19,780 --> 00:50:23,260
그리고 내가 한 번이 뭔가를 이동, 또 그 요소를 볼 필요가 없습니다.

831
00:50:23,260 --> 00:50:28,600
최대한 빨리 목록의 왼쪽 세그먼트에서 요소를 교체로, 그것은 정렬 때문

832
00:50:28,600 --> 00:50:32,600
우리는 최소를 사용하여 오름차순으로 최선을 다하고 때문입니다.

833
00:50:32,600 --> 00:50:38,740
그래서 우리는 좋아, 우리가 위치 i를에있을거야, 우리는에서 모든 요소를​​ 볼 필요했다

834
00:50:38,740 --> 00:50:42,260
최소를 찾기 위해 전의 오른쪽에 있습니다.

835
00:50:42,260 --> 00:50:46,150
그게 우리가 목록의 끝으로 난 + 1에서보고 싶어요 의미합니다.

836
00:50:46,150 --> 00:50:51,610
이제, 우리가 현재보고있는 요소는 지금까지 최소보다 작다면

837
00:50:51,610 --> 00:50:54,190
기억, 우리가 할 최소 오프를 시작하고있는

838
00:50:54,190 --> 00:50:57,020
어떤 요소 우리는에 현재이야, 나는 최소이야 가정합니다.

839
00:50:57,020 --> 00:51:00,270
그보다 작은 요소를 찾을 수 있다면, 나는, 좋아, 말할거야

840
00:51:00,270 --> 00:51:02,700
글쎄, 난 새로운 최소 발견했습니다.

841
00:51:02,700 --> 00:51:06,080
나는 최소가있는 곳 기억거야.

842
00:51:06,080 --> 00:51:09,560
>> 그래서 지금, 내가 한 번 맞아 정렬되지 않은 세그먼트을 겪었어요

843
00:51:09,560 --> 00:51:16,690
나는 위치 i를에있는 요소의 최소 요소를 교환거야 말할 수 있습니다.

844
00:51:16,690 --> 00:51:21,100
그건 내 목록을 구축하는거야, 왼쪽에서 오른쪽으로 목록의 내 정렬 부분,

845
00:51:21,100 --> 00:51:25,190
우리는 한번도 그 부분에 다시 한번 요소를 볼 필요가 없습니다.

846
00:51:25,190 --> 00:51:27,930
일단 우리가 바꿔 치기했습니다.

847
00:51:27,930 --> 00:51:30,260
그럼이 목록에 선택 정렬 실행할 수 있습니다.

848
00:51:30,260 --> 00:51:38,220
여기에 파란색 요소는 내가 될 것입니다, 그리고 빨간색 요소는 최소 요소가 될 것입니다.

849
00:51:38,220 --> 00:51:41,570
그래서 5시 때문에, 목록의 왼쪽에있는 모든 방법을 시작합니다.

850
00:51:41,570 --> 00:51:44,610
이제 우리는 최소한의 정렬되지 않은 요소를 찾아야합니다.

851
00:51:44,610 --> 00:51:49,480
그래서 우리는 0 <5이므로 0 나의 새로운 최소 말한다.

852
00:51:49,480 --> 00:51:53,820
>> 우리가 0 가장 작은 것을 인식 할 수 있더라도 때문에 거기서 그만 둘 수 없어

853
00:51:53,820 --> 00:51:59,390
우리는 확인 할 수있는 목록의 다른 모든 요소를​​ 통해 실행해야합니다.

854
00:51:59,390 --> 00:52:01,760
, 6 크다 크다 1 그래서 4 큽니다.

855
00:52:01,760 --> 00:52:05,850
그래서 이러한 요소를 모두 검토 한 결과, 0은 가장 작은 판별 된 것을 의미합니다.

856
00:52:05,850 --> 00:52:09,800
그래서 5 0 교환거야.

857
00:52:09,800 --> 00:52:15,480
일단 그를 교환, 새로운 목록을 얻을 수, 나는 내가 다시 0에서 볼 필요가 없습니다 알고

858
00:52:15,480 --> 00:52:19,380
일단 제가 바꿔 치기했기 때문, 내가 정렬 한 우리이 완​​료됩니다.

859
00:52:19,380 --> 00:52:22,730
이제 그냥, 파란색 요소가 다시 5 것을 어떻게

860
00:52:22,730 --> 00:52:26,030
우리는 그 일을 결정하기 위해, 1를보고 6과 4가 필요

861
00:52:26,030 --> 00:52:31,520
가장 작은 최소 요소이기 때문에 우리는 1과 5를 교환합니다.

862
00:52:31,520 --> 00:52:36,890
다시 말하지만, 우리는 ... 필요 - 6 4 5 비교

863
00:52:36,890 --> 00:52:39,830
우리는 4 5 교환하려고, 그리고 마지막으로, 비교하고

864
00:52:39,830 --> 00:52:45,740
지난 2 번호와 우리의 정렬 목록을 얻을 때까지 그들을 교체.

865
00:52:45,740 --> 00:52:49,730
선택 정렬에 대한 질문?

866
00:52:49,730 --> 00:52:56,420
좋아요. - 여기서 마지막 주제로 이동하자, 그리고 그 재귀입니다.

867
00:52:56,420 --> 00:52:59,810
>> 재귀는 기억이 정말 메타 것입니다 기능

868
00:52:59,810 --> 00:53:02,740
반복적으로 자체 호출합니다.

869
00:53:02,740 --> 00:53:05,620
그런 점에서, 우리의 fuction가 반복 자체를 호출하는 동안,

870
00:53:05,620 --> 00:53:10,100
우리가 우리 자신을 호출 중지되는 어느 시점이있을 필요합니다.

871
00:53:10,100 --> 00:53:13,670
우리가하지 않으면, 우리는 영원히 이렇게 계속 할거야 때문에,

872
00:53:13,670 --> 00:53:16,660
우리의 프로그램은 종료하지 않을 수 있습니다.

873
00:53:16,660 --> 00:53:19,200
우리는이 조건 기본 케이스 전화하십시오.

874
00:53:19,200 --> 00:53:22,570
그리고 기본 사건이 아니라 다시 함수를 호출하지 않고 있다고

875
00:53:22,570 --> 00:53:25,330
난 그냥 어떤 값을 반환하는거야.

876
00:53:25,330 --> 00:53:28,080
우리가 값을 반환 한 후에 그래서, 우리는 자신을 호출 중단

877
00:53:28,080 --> 00:53:32,550
그리고 우리가 지금까지 한 통화의 나머지 부분도 돌아갈 수 있습니다.

878
00:53:32,550 --> 00:53:36,050
기본 케이스의 반대는 재귀 경우가 있습니다.

879
00:53:36,050 --> 00:53:39,050
그리고 우리가 인치 현재임을 기능에 다른 전화를하고 싶은데요 때입니다

880
00:53:39,050 --> 00:53:44,690
그리고 우리는 아마가 항상 있지만, 다른 인수를 사용하고 싶습니다.

881
00:53:44,690 --> 00:53:48,940
>> 우리는 F라는 함수를 가지고 있고, F는, 1 인자를 호출한다면

882
00:53:48,940 --> 00:53:52,010
그리고 우리는 F (1), F (1), F (1)를 호출 유지하고, 그냥하는 일이

883
00:53:52,010 --> 00:53:56,510
인수 1 재귀 경우에 다음날, 우리는 여전히 중지 할 수 없어.

884
00:53:56,510 --> 00:54:01,620
우리가 기본 케이스를 경우에도, 우리는 결국 우리가 기본 케이스를 공격 할거야 있는지 확인해야합니다.

885
00:54:01,620 --> 00:54:04,250
우리는이 재귀 경우에 머무는 보관하지 않습니다.

886
00:54:04,250 --> 00:54:09,870
일반적으로, 우리는 자신을 호출 할 때, 우리는 아마 다른 인수 할 때마다 할 겁니다.

887
00:54:09,870 --> 00:54:12,700
여기 정말 간단한 재귀 함수입니다.

888
00:54:12,700 --> 00:54:15,090
그래서이 숫자의 계승을 계산합니다.

889
00:54:15,090 --> 00:54:17,790
최대 우리는 기본 가방을 가지고 여기에 맨.

890
00:54:17,790 --> 00:54:22,330
n은 ≤ 1, 우리가 다시 계승 전화도 안하고있는 경우.

891
00:54:22,330 --> 00:54:26,490
우리는 멈춰서, 우리가 어떤 값을 반환거야.

892
00:54:26,490 --> 00:54:30,170
이 사실이 아닌 경우, 우리는 우리의 재귀 사례를 공격 할거야.

893
00:54:30,170 --> 00:54:33,550
그 매우 도움이 될 싶지 않아 그냥 계승 (N)를 호출하지 않는 것으로 여기납니다.

894
00:54:33,550 --> 00:54:36,810
우리는 다른 무언가가 계승 전화거야.

895
00:54:36,810 --> 00:54:40,850
>> 그리고 당신은, 우리가 계승 (5)라도 통과 결국 경우, 볼 수 있습니다

896
00:54:40,850 --> 00:54:45,900
우리는 요소 (4) 등 전화를하고, 결국 우리는이 기본 케이스를 공격 할거야.

897
00:54:45,900 --> 00:54:51,730
그래서이 좋아 보여요. 우리가 실제로를 실행할 때 어떤 일이 벌어지는 지 알아 보자.

898
00:54:51,730 --> 00:54:57,840
이 스택이며, 우선은 메인이 인수 (4)와 함께이 함수를 호출 할 것을 말한다.

899
00:54:57,840 --> 00:55:02,200
일단 요소보고 = 4, 계승은 자신을 호출합니다.

900
00:55:02,200 --> 00:55:05,010
이제 갑자기, 우리는 (3) 요소가 있습니다.

901
00:55:05,010 --> 00:55:10,780
따라서 이러한 기능은 결국 우리의 기본 케이스를 나오기 전까지 계속 성장해 갈 수 있습니다.

902
00:55:10,780 --> 00:55:17,830
이 시점에서,이 반환 값은 수익 (NX이의 반환 값)입니다

903
00:55:17,830 --> 00:55:21,290
이 반환 값은이 NX 반환 값입니다.

904
00:55:21,290 --> 00:55:23,290
결국 우리는 번호를 누르해야합니다.

905
00:55:23,290 --> 00:55:26,560
여기에 상단에, 우리는 수익 1 말한다.

906
00:55:26,560 --> 00:55:30,650
일단 그 번호를 반환 있다는 것을 의미 즉, 우리는 스택에서이 열어 수 있습니다.

907
00:55:30,650 --> 00:55:36,570
그래서이 요소는 (1) 이루어집니다.

908
00:55:36,570 --> 00:55:41,190
때 한 반품이 계승 (1) 수익, 1이 돌아갑니다.

909
00:55:41,190 --> 00:55:46,910
이 반환 값은, 기억,이 반환 값 NX했다.

910
00:55:46,910 --> 00:55:50,720
갑자기,이 사람은 내가 2를 반환하려는 알고 있습니다.

911
00:55:50,720 --> 00:55:55,910
>> 그래서 기억이 값이 여기에 리턴 값 만 NX 달려 있습니다 반환합니다.

912
00:55:55,910 --> 00:56:01,160
이제 우리는 3 할 X 2라고 할 수 있으며, 마지막으로, 우리가 말을 할 수

913
00:56:01,160 --> 00:56:04,010
이 단 4 × 3 곱하기 2는 될 것입니다.

914
00:56:04,010 --> 00:56:09,570
그리고이 반환되면, 우리는 주요의 단일 정수 안쪽으로 내려.

915
00:56:09,570 --> 00:56:15,460
재귀에 대한 질문?

916
00:56:15,460 --> 00:56:17,090
괜찮아요. 따라서 질문에 대한 더 많은 시간이 끝이

917
00:56:17,090 --> 00:56:23,360
지금 요셉은 나머지 주제를 다룹니다.

918
00:56:23,360 --> 00:56:25,590
>> [요셉 옹 좋아. 그래서 지금 우리가 recursions에 대해 이야기하는,

919
00:56:25,590 --> 00:56:27,840
가 정렬이 병합 대해 조금 얘기 좀하자.

920
00:56:27,840 --> 00:56:31,740
병합 정렬은 기본적으로 숫자의 목록을 정렬의 또 다른 방법입니다.

921
00:56:31,740 --> 00:56:36,430
그리고 병합 정렬과 어떻게 동작하는지 당신은 목록을, 그리고 우리가 할 것은

922
00:56:36,430 --> 00:56:39,120
우리는의 2 반쪽으로이 분할 해, 말한다.

923
00:56:39,120 --> 00:56:42,750
우리는 먼저 왼쪽 부분에 다시 정렬 병합 실행됩니다

924
00:56:42,750 --> 00:56:45,040
그러면 우리는, 오른쪽 절반에 정렬 병합 실행됩니다

925
00:56:45,040 --> 00:56:50,240
그리고 이제 우리에게 정렬되어 두 반쪽을 제공합니다, 이제 우리가 함께 그 반쪽을 결합거야.

926
00:56:50,240 --> 00:56:55,010
그것은 예를 들어없이 볼 조금 어렵습니다, 그래서 우리는 못해서 무슨 일이 일어나는지 볼 수 있습니다.

927
00:56:55,010 --> 00:56:59,590
그래서 당신은이 목록에, 우리는 2 반쪽으로 분리 시작합니다.

928
00:56:59,590 --> 00:57:02,300
우리는 먼저 왼쪽 부분에 정렬 병합 실행합니다.

929
00:57:02,300 --> 00:57:06,660
그래서는 왼쪽 반, 이제 우리는 다시이 목록을 통해 실행

930
00:57:06,660 --> 00:57:09,800
어떤 우리가 다시 봐 후 병합 정렬에 전달하고,됩니다

931
00:57:09,800 --> 00:57:13,270
이 목록의 왼쪽에 우리는 거기에 정렬 병합 실행합니다.

932
00:57:13,270 --> 00:57:15,880
이제, 우리는 2 숫자의 목록에 내려

933
00:57:15,880 --> 00:57:19,010
지금 왼쪽 절반은 단 1 요소 길이, 우리는 수 없습니다

934
00:57:19,010 --> 00:57:23,380
이분의 일에 단 1 요소의 목록을 분할, 그래서 우리가 한 번 우리가 50을 가지고 말

935
00:57:23,380 --> 00:57:26,400
이는 단 1 요소입니다, 그건 이미 정렬있어.

936
00:57:26,400 --> 00:57:29,860
>> 우리가 그와 함께 완료되면, 우리는 우리가 할 수있는 볼 수 있습니다

937
00:57:29,860 --> 00:57:32,230
이 목록의 오른쪽 절반에 이동

938
00:57:32,230 --> 00:57:36,480
3도 그래서 지금이 목록의 두 절반이 정렬되는 정렬되어

939
00:57:36,480 --> 00:57:39,080
우리는 함께이 번호를 가입 할 수 있습니다.

940
00:57:39,080 --> 00:57:45,320
그래서 우리는 50 세 보면, 3이 50보다 작이므로 먼저 끼 우고 후 50 들어 오면

941
00:57:45,320 --> 00:57:49,340
자, 이제 다 됐어, 우리는 오른쪽 절반이야 목록 정렬까지 돌아갑니다.

942
00:57:49,340 --> 00:57:52,440
42 그 자신의 번호이므로 이미 정렬있어.

943
00:57:52,440 --> 00:57:57,850
이제 우리는 처음에 넣어하면 그 때문에, 2, 3는 42보다 작은이를 비교

944
00:57:57,850 --> 00:58:02,340
지금 42에 넣어됩니다, 그리고 50 박됩니다

945
00:58:02,340 --> 00:58:07,220
이제 정렬 것은, 우리는 다시 처음으로 돌아 1337 15 먼 길을 이동합니다.

946
00:58:07,220 --> 00:58:14,560
자, 이제이 목록의 왼쪽 이분의 일 보면, 1337 자체입니다 그래서 15으로 정렬하고 같은거야.

947
00:58:14,560 --> 00:58:19,020
이제 우리는 그 원본 목록, 15 <1337를 정렬하려면 다음 두 숫자를 결합

948
00:58:19,020 --> 00:58:23,060
그래서 처음에 갔다가 1337 들어갑니다

949
00:58:23,060 --> 00:58:26,640
그리고 지금 우리는 꼭대기의 원본 목록의 두 반쪽을 정렬.

950
00:58:26,640 --> 00:58:30,440
그리고 우리가해야 할 모든이를 결합합니다.

951
00:58:30,440 --> 00:58:36,890
이 목록의 첫 2 숫자, 3 <15을 봐 때문에 먼저 정렬 배열로 들어갑니다.

952
00:58:36,890 --> 00:58:44,460
15 <42, 그래서 지금 인치갑니다 42 <1337, 그 들어갑니다

953
00:58:44,460 --> 00:58:51,010
50 <1337는, 그래서 들어갑니다 그리고 우리가이 목록의 2 숫자를 벗은 것을 확인할 수 있습니다.

954
00:58:51,010 --> 00:58:53,640
그래서 우리는 단지 2 목록 사이에 교대하지.

955
00:58:53,640 --> 00:58:56,050
우리는 시작에 불과보고, 우리는 요소를 복용

956
00:58:56,050 --> 00:59:00,270
그 작은 그런 다음 배열에 넣고 있습니다.

957
00:59:00,270 --> 00:59:04,080
이제 우리는 모두 절반을 통합 한 우리이 완​​료됩니다.

958
00:59:04,080 --> 00:59:07,780
>> 에 대한 질문은 정렬을 병합? 그래?

959
00:59:07,780 --> 00:59:14,190
[학생]는 서로 다른 그룹으로 분할이라면, 왜 그냥 한번을 분할하지 않습니다

960
00:59:14,190 --> 00:59:19,970
그리고 당신은 그룹에 3 2 있나요? [질문 이해할 수없는의 휴식]

961
00:59:19,970 --> 00:59:24,940
그 이유는 - 그래서 질문은, 우리가 그것들을 갖고 난 후에는 왜 우리가 그 첫 걸음에 그들을 병합 할 수 없습니다?

962
00:59:24,940 --> 00:59:29,530
우리가이 일을 할 수있는 이유는, 양쪽 모두의 가장 왼쪽에있는 요소에서 시작

963
00:59:29,530 --> 00:59:33,040
그리고, 작은 하나를 수행하고 뒀을 우리가이 알고 있다는 것입니다

964
00:59:33,040 --> 00:59:35,290
개인 목록 정렬 명령입니다.

965
00:59:35,290 --> 00:59:37,290
나는 두 반쪽의 가장 왼쪽에있는 요소를보고하면,

966
00:59:37,290 --> 00:59:40,490
나는 그들이 그 목록의 가장 작은 요소가 될 거라는 거 알아요.

967
00:59:40,490 --> 00:59:43,930
그래서이 큰 목록의 가장 작은 요소 명소에 넣어 넣을 수 있습니다.

968
00:59:43,930 --> 00:59:47,810
한편, 전 저쪽에 두 번째 수준에있는 2 목록 보면,

969
00:59:47,810 --> 00:59:51,640
50, 3, 42, 1337, 15이 사람들은 정렬되지 않습니다.

970
00:59:51,640 --> 00:59:55,770
나는 50 1,337 볼한다면, 우선 내 목록에 50 넣어거야.

971
00:59:55,770 --> 01:00:00,130
하지만 그건 정말 3 그의 모든에서 가장 작은 요소이기 때문에, 이해하지 않습니다.

972
01:00:00,130 --> 01:00:04,390
그래서 우리가이 결합 단계를 할 수있는 유일한 이유는 우리 목록이 이미 정렬됩니다 때문입니다.

973
01:00:04,390 --> 01:00:07,010
우리가 아래로 모든 방법을 내려 가야 이유가 어떤 거죠

974
01:00:07,010 --> 01:00:09,800
우리가 하나의 숫자가있을 때, 당신이 하나의 번호를 알고 있기 때문에

975
01:00:09,800 --> 01:00:14,120
과 자체는 이미 정렬 목록입니다.

976
01:00:14,120 --> 01:00:19,360
>> 질문? 아냐?

977
01:00:19,360 --> 01:00:24,260
복잡성? 글쎄, 당신은 각 단계에서 끝 번호가 것을 알 수 있습니다

978
01:00:24,260 --> 01:00:27,590
우리는, 반 로그 n 번에 목록을 나눌 수 있습니다

979
01:00:27,590 --> 01:00:31,700
우리가이 N X 로그 N 복잡성을 잡는 곳이 어디있는 것입니다.

980
01:00:31,700 --> 01:00:34,940
그리고 당신은 병합 정렬에 가장 적합한 경우가 N 로그 N 지 알거야, 그리고 우연히도

981
01:00:34,940 --> 01:00:39,340
최악의 경우, 또는 저쪽 Ω는 또한 N n을 로그온.

982
01:00:39,340 --> 01:00:42,480
염두에 두어야 할 일.

983
01:00:42,480 --> 01:00:45,750
에 이동,의 일부 슈퍼 기본 파일 I / O에 가자

984
01:00:45,750 --> 01:00:48,830
당신이 출격을 바라 보았다 경우, 당신은 우리가 시스템을 보셨 것을 알 수

985
01:00:48,830 --> 01:00:51,270
당신은 코드를 읽을 경우 로그 파일에 쓸 수있는 곳.

986
01:00:51,270 --> 01:00:53,730
가 당신이 그렇게하는 방법을 보자.

987
01:00:53,730 --> 01:00:57,450
음, 우리는 fprintf이, 당신은 똑같이 printf 생각 할 수있는

988
01:00:57,450 --> 01:01:01,720
하지만 시작에 불과에서 F 따라서 대신 파일로 인쇄합니다.

989
01:01:01,720 --> 01:01:07,570
여기까지 코드의이 종류의, 당신은 스크램블에서 볼 수도로서 만약 잘못된 것은이다,

990
01:01:07,570 --> 01:01:12,310
이 숫자가 무엇인지 행의 행 밖으로 2 차원 배열 인쇄를 진행합니다.

991
01:01:12,310 --> 01:01:17,850
이 경우 printf 여러분의 터미널에 출력 또는 우리는 섹션의 표준 출력 부르는.

992
01:01:17,850 --> 01:01:22,170
>> 그리고 지금,이 경우에, 우리가해야 할 일은이 fprintf와 printf 바뀝니다

993
01:01:22,170 --> 01:01:26,770
당신이 인쇄하고자하는 파일을 알려,이 경우는 그 파일에 출력

994
01:01:26,770 --> 01:01:32,230
대신 터미널에 출력.

995
01:01:32,230 --> 01:01:36,500
그럼, 그건 문제는 남죠 우리가 어디에 오른쪽에서 파일의 종류를 어떻게해야합니까?

996
01:01:36,500 --> 01:01:39,840
우리는이 fprintf fuction에 로그인을 통과하지만, 우리는 온 몰랐어요.

997
01:01:39,840 --> 01:01:43,980
음, 초기 코드에서, 우리가 가진 것은, 이쪽이 코드 덩어리였다

998
01:01:43,980 --> 01:01:48,340
기본적으로 열려있는 파일이 Log.txt를 호출 있다고된다.

999
01:01:48,340 --> 01:01:53,220
그 후 우리가 할 우리는 파일이 실제로 성공적으로 오픈되어 있는지 확인해야합니다.

1000
01:01:53,220 --> 01:01:57,070
그래서 여러 가지 이유로 실패 할 수 있습니다, 당신은 예를 들어, 컴퓨터에 공간이 충분하지 않습니다.

1001
01:01:57,070 --> 01:01:59,790
당신은 파일과 모든 작업을 수행하기 전에 항상 중요

1002
01:01:59,790 --> 01:02:03,300
우리는 그 파일이 성공적으로 오픈되었는지 여부를 확인하는 것이.

1003
01:02:03,300 --> 01:02:09,330
그래서, 그게 fopen에 인수이라고, 그래, 우리는 다양한 방법으로 파일을 열 수 있습니다.

1004
01:02:09,330 --> 01:02:13,510
우리가 할 수있는 일, 우리는이 종료하면 이미 파일을 덮어 즉, 그것을 w를 전달할 수 있습니다

1005
01:02:13,510 --> 01:02:18,070
우리는 사람들이 대신을 대체의 파일의 끝 부분에 추가하는을 전달할 수 있습니다

1006
01:02:18,070 --> 01:02:22,730
또는 우리가 즉, r을 지정할 수 있습니다, 어디 파일 읽기 전용으로 열 수 있습니다.

1007
01:02:22,730 --> 01:02:24,890
프로그램은 파일에 대한 변경 사항을 확인하려고한다면

1008
01:02:24,890 --> 01:02:30,140
그들을 소리하고 그것을 허락하지 않습니다.

1009
01:02:30,140 --> 01:02:33,320
마지막으로, 우리는 그것에 작업을하고 완료, 파일을 완료

1010
01:02:33,320 --> 01:02:35,860
우리는 파일을 닫습니다 있는지 확인해야합니다.

1011
01:02:35,860 --> 01:02:38,830
그리고 프로그램의 끝 부분에, 당신은 다시 전달하려고

1012
01:02:38,830 --> 01:02:42,120
당신은 오픈, 다시 한번을 닫고이 파일을 것을.

1013
01:02:42,120 --> 01:02:44,650
그래서이 집이 당신이 당신이 확인해야하는 중요한 일입니다.

1014
01:02:44,650 --> 01:02:47,180
그래서 파일을 열 수 있습니다 기억하고 당신이 파일에 쓸 수 있습니다

1015
01:02:47,180 --> 01:02:51,270
파일에 작업을 수행하지만, 다음은 끝에서 파일을 닫해야합니다.

1016
01:02:51,270 --> 01:02:53,270
>> 기본 파일에 대한 질문 I / O? 그래?

1017
01:02:53,270 --> 01:02:58,050
[학생 질문 이해할 수없는]

1018
01:02:58,050 --> 01:03:02,480
바로 여기. 질문이 Log.txt를 파일을 어디에 표시됩니까입니까?

1019
01:03:02,480 --> 01:03:07,890
, 좀 Log.txt를을 주면 음, 그것은 실행과 같은 디렉토리에 생성됩니다.

1020
01:03:07,890 --> 01:03:10,500
그럼 넌 경우 - >> [학생 질문 이해할 수없는]

1021
01:03:10,500 --> 01:03:18,830
예. 같은 폴더에, 또는 같은 디렉토리에 당신이 전화로.

1022
01:03:18,830 --> 01:03:21,400
지금 메모리, 스택, 그리고 힙.

1023
01:03:21,400 --> 01:03:23,400
따라서 컴퓨터에 배치 메모리는 어때?

1024
01:03:23,400 --> 01:03:26,270
글쎄, 당신은 여기에 블록의 종류로 메모리를 상상할 수 있습니다.

1025
01:03:26,270 --> 01:03:30,260
그리고 메모리에 우리는 거기 붙어 힙, 그리고 저 아래 스택을 불리는 게 있습니다.

1026
01:03:30,260 --> 01:03:34,480
그리고 힙 아래로 성장하고 스택은 위쪽으로 자랍니다.

1027
01:03:34,480 --> 01:03:38,620
토미가 언급 있도록 - 오, 그래, 우리는 제가 두번째로로 연결됩니다 다른 네 세그먼트를 가지고 -

1028
01:03:38,620 --> 01:03:42,890
토미 앞에서 말했듯이, 당신은 그의 기능이 스스로 전화를 서로 전화를 어떻게 알아?

1029
01:03:42,890 --> 01:03:44,930
그들은 스택 프레임의 종류를 구축 할 수 있습니다.

1030
01:03:44,930 --> 01:03:47,360
음, 주요 통화 foo는, foo는이 스택에 넣어 온다면.

1031
01:03:47,360 --> 01:03:52,430
foo는 호출 바, 바가 스택에 넣어 받고, 후 스택에 넣어하면 그.

1032
01:03:52,430 --> 01:03:57,040
그들은 돌아봤을 때, 그들은 각 스택을 나는 걸.

1033
01:03:57,040 --> 01:04:00,140
이러한 각각의 위치와 메모리는 무엇을 보유합니까?

1034
01:04:00,140 --> 01:04:03,110
음, 텍스트 세그먼트의 최상위는 프로그램 자체가 포함되어 있습니다.

1035
01:04:03,110 --> 01:04:06,390
기계 코드 그래서이 많아 일단 프로그램을 컴파일합니다.

1036
01:04:06,390 --> 01:04:08,520
다음으로, 모든 글로벌 변수를 초기화.

1037
01:04:08,520 --> 01:04:12,660
>> 그래서 당신은 당신의 프로그램에서 전역 변수를 가지고 있고, 당신은 = 5, 이렇게 말할 수

1038
01:04:12,660 --> 01:04:15,260
해당 세그먼트에 놓고 오른쪽으로 아래됩니다 즉,

1039
01:04:15,260 --> 01:04:18,990
당신은 단지를 INT되는 모든 초기화되지 않은 전역 데이터를 가지고

1040
01:04:18,990 --> 01:04:20,990
하지만 당신은 아무 것도 그 자체라고하지 않습니다.

1041
01:04:20,990 --> 01:04:23,870
이러한 전역 변수이며, 그래서 그들은 주요 이외의 실감합니다.

1042
01:04:23,870 --> 01:04:28,560
그래서이 선언되어 있지만 초기화되지 않은 전역 변수를 의미합니다.

1043
01:04:28,560 --> 01:04:32,310
그래서 힙에 뭐야? 메모리는 우리가 조금에로 연결됩니다 malloc를 사용하여 할당.

1044
01:04:32,310 --> 01:04:35,990
그리고 마지막으로, 스택 함께 어떤 지역 변수가

1045
01:04:35,990 --> 01:04:39,950
와 기능은 자신의 매개 변수 중 하나에 전화 할 수 있습니다.

1046
01:04:39,950 --> 01:04:43,720
마지막으로, 당신은 정말 환경 변수 뭘 알 필요는 없습니다

1047
01:04:43,720 --> 01:04:46,700
하지만 프로그램을 실행 할 때마다 관련된 일이 같은이

1048
01:04:46,700 --> 01:04:49,550
이 프로그램을 실행하는 사용자의 사용자 이름입니다.

1049
01:04:49,550 --> 01:04:51,550
그리고 그 하단에 정렬 될거야.

1050
01:04:51,550 --> 01:04:54,540
16 진수 값 아르 메모리 주소의 측면에서,

1051
01:04:54,540 --> 01:04:58,170
0에서 맨 처음에 가치, 그리고 아래로 쭉 이동합니다.

1052
01:04:58,170 --> 01:05:00,440
이 경우, 당신은 32 비트 시스템에 있다면,

1053
01:05:00,440 --> 01:05:05,390
맨 아래에있는 주소는 32 비트이기 때문에, AF에 이어, 0x 될 것입니다

1054
01:05:05,390 --> 01:05:10,890
이는 8 바이트이며,이 경우에는 8 바이트는 8 진수 숫자에 해당합니다.

1055
01:05:10,890 --> 01:05:20,110
여기로 당신이 좋아 0xffffff를받을거야, 그리고 거기에 당신은 공을거야.

1056
01:05:20,110 --> 01:05:23,660
그래서 포인터 무엇입니까? 당신의 일부는 이전 섹션에서이 적용되지 않을 수 있습니다.

1057
01:05:23,660 --> 01:05:26,660
하지만 우리가 강의에 갔었 죠, 포인터가 그냥 데이터 유형 때문에

1058
01:05:26,660 --> 01:05:34,030
대신 50과 같은 가치의 어떤 종류의,이 메모리의 일부 위치의 주소를 저장하는 상점.

1059
01:05:34,030 --> 01:05:36,020
그 기억처럼 불륜].

1060
01:05:36,020 --> 01:05:41,120
따라서이 경우에, 우리는 것을, 우리는 정수 또는 정수 *에 대한 포인터를 가지고

1061
01:05:41,120 --> 01:05:46,210
그리고 0xDEADBEEF의 진수 주소가 포함되어 있습니다.

1062
01:05:46,210 --> 01:05:50,880
>> 그래서 우리가하는 메모리의 일부 위치에서이 포인터가 가리키는,, 지금은,

1063
01:05:50,880 --> 01:05:56,020
그 단지 야 값이 50이 메모리 위치에 있습니다.

1064
01:05:56,020 --> 01:06:01,810
일부 32 비트 시스템에서 32 비트 시스템에서 포인터는 32 비트 또는 4 바이트를 차지합니다.

1065
01:06:01,810 --> 01:06:06,020
그러나 예를 들어, 64 비트 시스템에서 포인터는 64 비트입니다.

1066
01:06:06,020 --> 01:06:08,040
그럼 그 말은 당신이 염두에 두어야하는 것이 좋습니다 뭔가.

1067
01:06:08,040 --> 01:06:12,310
따라서 최종 비트 시스템에서 포인터의 최종 비트 길이이다.

1068
01:06:12,310 --> 01:06:17,320
포인터는, 여분의 물건없이 종류의 소화하기 어려운

1069
01:06:17,320 --> 01:06:20,300
그러니 동적 메모리 할당의 예를 통해 가자.

1070
01:06:20,300 --> 01:06:25,130
무슨 동적 메모리 할당은 당신을합니까, 아니면 malloc 부르는

1071
01:06:25,130 --> 01:06:29,280
당신이 세트의 외부 데이터의 어떤 종류를 할당 할 수 있습니다.

1072
01:06:29,280 --> 01:06:31,830
그래서이 데이터는 종류의 프로그램의 기간에 대한 더 많은 영구적이다.

1073
01:06:31,830 --> 01:06:36,430
당신도 알다시피 때문에, 당신은 함수의 내부 X 및 그 함수가 반환을 선언하는 경우

1074
01:06:36,430 --> 01:06:40,910
더 이상 X에 저장 된 데이터에 액세스 할 수 없습니다.

1075
01:06:40,910 --> 01:06:44,420
어떤 포인터 우리가하자 것은 그들이 우리가 메모리 또는 상점 값을 저장하게됩니다

1076
01:06:44,420 --> 01:06:46,840
즉 메모리의 다른 부분, 힙 인치

1077
01:06:46,840 --> 01:06:49,340
지금 우리가 '만큼 우리가 포인터를 가지고 같은 기능에서 반환

1078
01:06:49,340 --> 01:06:54,960
메모리에서 해당 위치로, 우리는 할 수있는 일을 우리는 그냥 값을 볼 수 있습니다.

1079
01:06:54,960 --> 01:06:58,020
가 예를 들어 보자 :이도 다시 한 번 우리의 메모리 레이아웃입니다.

1080
01:06:58,020 --> 01:07:00,050
그리고 우리는 주,이 기능을 갖추고 있습니다.

1081
01:07:00,050 --> 01:07:06,870
만약 성공하지 것은 - 그래, 그렇게 간단 맞지? - INT X = 5, 그냥 메인에있는 스택에 변수입니다.

1082
01:07:06,870 --> 01:07:12,450
>> 한편, 이제 우리는 함수 giveMeThreeInts를 호출하는 포인터를 선언합니다.

1083
01:07:12,450 --> 01:07:16,800
그리고 지금 우리는이 함수로 가서 우리는을위한 새로운 스택 프레임을 만들 수 있습니다.

1084
01:07:16,800 --> 01:07:20,440
그러나,이 스택 프레임에, 우리는 INT * 온도 선언

1085
01:07:20,440 --> 01:07:23,210
있는 우리 mallocs 세 정수 인치

1086
01:07:23,210 --> 01:07:25,880
따라서 정수의 크기,이 정수는 얼마나 많은 바이트 저희를 제공합니다

1087
01:07:25,880 --> 01:07:29,620
그리고 malloc 우리를 제공합니다 그 힙에 공간이 많은 바이트.

1088
01:07:29,620 --> 01:07:32,890
따라서이 경우에는, 우리는, 3 정수에 대한 충분한 공간을 만들었습니다

1089
01:07:32,890 --> 01:07:36,830
그리고 힙 내가 에게라도을 도출 한 이유입니다, 거기에 방법입니다.

1090
01:07:36,830 --> 01:07:42,900
우리가 완료되면, 우리가 여기 다시 올, 당신은 단 3 ints 반환해야

1091
01:07:42,900 --> 01:07:47,000
그리고 그 기억이있는 곳으로이 경우 주소를 반환합니다.

1092
01:07:47,000 --> 01:07:51,250
그리고 우리는 포인터 = 스위치를 설정하고 거기에 우리가 또 다른 포인터가 있습니다.

1093
01:07:51,250 --> 01:07:54,550
그런데 함수가 리턴이 여기에 스택과 사라입니다.

1094
01:07:54,550 --> 01:07:59,250
따라서 온도가 사라지하지만, 우리는 여전히의 주소를 유지

1095
01:07:59,250 --> 01:08:01,850
그 세 정수는 전원의 내부입니다.

1096
01:08:01,850 --> 01:08:06,180
따라서이 설정에서, 포인터는 스택 프레임에 로컬로 범위를 지정 아르

1097
01:08:06,180 --> 01:08:09,860
하지만 그 사람들이 참조 할 수있는 메모리는 힙에 있습니다.

1098
01:08:09,860 --> 01:08:12,190
>> 그게 말이나 돼?

1099
01:08:12,190 --> 01:08:14,960
[학생] 다시 말씀해 주실 래요? >> [요셉] 예.

1100
01:08:14,960 --> 01:08:20,270
내가 다시 조금 가면 그래서 온도가 할당 알

1101
01:08:20,270 --> 01:08:23,500
거기에 힙에 대한 몇 가지 메모리.

1102
01:08:23,500 --> 01:08:28,680
따라서이 기능은 giveMeThreeInts 수익을, 여기있는이 스택이 사라질 때.

1103
01:08:28,680 --> 01:08:35,819
그리고이 경우 변수의, 스택 프레임에 할당 된이 포인터.

1104
01:08:35,819 --> 01:08:39,649
우리는 온도를 반환 이후로 이사를 가려고되지만,

1105
01:08:39,649 --> 01:08:46,330
우리는 = temp를 ​​포인터가 현재 임시이어서 위치의 같은 메모리를 가리 키도록거야 포인터를 설정합니다.

1106
01:08:46,330 --> 01:08:50,370
이제, 우리는 온도, 해당 지역의 포인터를 잃게하더라도

1107
01:08:50,370 --> 01:08:59,109
우리는 여전히 그 변수 포인터의 내부를 가리키는 지의 메모리 주소를 유지합니다.

1108
01:08:59,109 --> 01:09:03,740
질문이 있으십니까? 절에서 초과하지 않은 경우 그 혼란 주제의 종류가 될 수 있습니다.

1109
01:09:03,740 --> 01:09:09,240
우리는 당신의 TF 확실히 그 위에 이동합니다 수 있으며, 물론 우리가 질문에 답변 할 수 있습니다

1110
01:09:09,240 --> 01:09:11,500
이것에 대한 검토 세션의 끝에서.

1111
01:09:11,500 --> 01:09:14,220
그러나 이것은 복잡한 주제의 일종이며, 나는 거기있을 꺼 더 많은 예제를

1112
01:09:14,220 --> 01:09:18,790
그 포인터가 실제로 무엇인지 명확히하는 데 도움이됩니다.

1113
01:09:18,790 --> 01:09:22,500
>> 이 경우 포인터는 배열과 같습니다

1114
01:09:22,500 --> 01:09:25,229
그래서 그냥 정수 배열로 같은 일로 포인터를 사용할 수 있습니다.

1115
01:09:25,229 --> 01:09:29,840
그래서, 0에 색인을 생성하고, 1 첫 번째 정수를 바꿀 게요

1116
01:09:29,840 --> 01:09:39,689
2 번째 정수를 변경하고, 3 정수 3.

1117
01:09:39,689 --> 01:09:44,210
포인터에 따라서 더. 음, 빙키 기억.

1118
01:09:44,210 --> 01:09:48,319
이 경우, 우리는 포인터를 할당 한, 또는 우리는 포인터를 선언

1119
01:09:48,319 --> 01:09:52,760
하지만 처음에, 난 그냥 포인터를 선언 할 때, 어느 메모리에 가리키는 않아.

1120
01:09:52,760 --> 01:09:54,930
그것은 내부 그냥 쓰레기 값입니다.

1121
01:09:54,930 --> 01:09:56,470
그래서이 포인터가 가리키는 아무 생각이 없습니다.

1122
01:09:56,470 --> 01:10:01,630
단지 공의와 1의 처음에 선언 된 곳으로 가득 주소가 있습니다.

1123
01:10:01,630 --> 01:10:04,810
내가에 malloc를 호출 할 때까지 난이 아무것도 할 수가 없어

1124
01:10:04,810 --> 01:10:08,390
다음 날 내가 안에 값을 넣을 수 있습니다 힙에 약간의 공간을 제공합니다.

1125
01:10:08,390 --> 01:10:11,980
다시,이 메모리 안에 건지 모르겠어요.

1126
01:10:11,980 --> 01:10:16,780
그래서 내가해야 할 첫 번째 것은 시스템이 충분한 메모리를 가지고 있는지 체크!

1127
01:10:16,780 --> 01:10:20,850
나에게 이런 일이 확인하고있는 이유 첫 번째 장소에서 1 정수를 돌려 줄 수 있습니다.

1128
01:10:20,850 --> 01:10:25,020
포인터가 null 경우, 그, 그건 충분한 공간이 또는 다른 오류가 발생했습니다이 없다는 걸 의미합니다

1129
01:10:25,020 --> 01:10:26,320
그래서 내 프로그램을 종료해야합니다.

1130
01:10:26,320 --> 01:10:29,400
 이 성공했다고한다면, 지금은 그 포인터를 사용할 수 있습니다

1131
01:10:29,400 --> 01:10:35,020
과 * 포인터가 수행하는 주소가있는 곳은 다음입니다

1132
01:10:35,020 --> 01:10:38,480
곳이 값은이며, 1은 동일한 설정합니다.

1133
01:10:38,480 --> 01:10:41,850
그 메모리가 존재한다면 그래서 여기를 통해, 우리는 확인하고 있습니다.

1134
01:10:41,850 --> 01:10:45,380
>> 당신이 존재 알겠지만, 당신은에 넣을 수 있습니다

1135
01:10:45,380 --> 01:10:50,460
어떤 값을 당신은 투입 할,이 경우 1인치

1136
01:10:50,460 --> 01:10:53,060
우리가 그것으로 완료되면 해당 포인터를 자유롭게 할 필요가

1137
01:10:53,060 --> 01:10:57,160
이 시스템은 처음부터 부탁 해당 메모리에 돌아 가야 할 때문입니다.

1138
01:10:57,160 --> 01:10:59,690
때문에 컴퓨터는 우리가 그 짓을 할 때 알고하지 않습니다.

1139
01:10:59,690 --> 01:11:02,510
이 경우 우리가 명시 적으로 말하는거야, 그래, 우리는 그 기억을 모두 마쳤습니다.

1140
01:11:02,510 --> 01:11:10,780
다른 프로세스가 필요한 경우, 다른 프로그램이 필요, 가서 가져 주시기 바랍니다.

1141
01:11:10,780 --> 01:11:15,110
우리는 또한 할 수있는 것은 우리가 세트로 지역 변수의 주소를 얻을 수 있습니다.

1142
01:11:15,110 --> 01:11:19,080
따라서 정수 x는 메인의 스택 프레임 안에 있습니다.

1143
01:11:19,080 --> 01:11:23,060
그리고 우리가이 앰퍼샌드를 사용하면, 이것과 교환, 만약 잘못된 것은

1144
01:11:23,060 --> 01:11:27,310
이 X를 차지하며 x는 메모리에 그냥 데이터이지만, 주소가 있습니다.

1145
01:11:27,310 --> 01:11:33,790
그것은 어딘가에 위치하고 있습니다. 이 무엇을 전화 & x가있다하여 그래서 우리에게 X의 주소를 제공합니다.

1146
01:11:33,790 --> 01:11:38,430
이렇게함으로써, 우리는 x가 메모리에 위치로 포인터 지점을하고 있어요.

1147
01:11:38,430 --> 01:11:41,710
이제 우리는 * 같은은 x, 우리가 5을 되찾아 와야 해 않습니다.

1148
01:11:41,710 --> 01:11:43,820
성급를 dereferencing라고합니다.

1149
01:11:43,820 --> 01:11:46,640
이 주소를 따라 당신은 거기에 그것의 값을 얻을.

1150
01:11:51,000 --> 01:11:53,310
>> 질문? 그래?

1151
01:11:53,310 --> 01:11:56,500
당신이 3 뾰족한 일을하지 않는 경우 [학생]는, 아직 컴파일합니까?

1152
01:11:56,500 --> 01:11:59,490
예. 은 3 포인터 일을하지 않으면, 그것은 여전히​​ 컴파일 할거야

1153
01:11:59,490 --> 01:12:02,720
하지만, 두 번째에 무슨 일이 보여, 그 일을하지 않고합니다

1154
01:12:02,720 --> 01:12:04,860
우리가 메모리 누수 불러. 당신은 시스템에서 제공하지

1155
01:12:04,860 --> 01:12:07,850
의 메모리를 백업하므로 후 프로그램이 축적하려고하는 동안

1156
01:12:07,850 --> 01:12:10,940
그것은 사용하지이고, 다른 무엇도 그것을 사용할 수 없습니다 메모리 것을.

1157
01:12:10,940 --> 01:12:15,750
아빠는 항상 컴퓨터에 1백50만킬로바이트와 파이어 폭스를 발견 한 경우

1158
01:12:15,750 --> 01:12:17,840
작업 관리자에서, 그 무슨 일이 일어나고 있는지입니다.

1159
01:12:17,840 --> 01:12:20,760
당신은 그들이 감당 못해하는 프로그램에서 메모리 누수가 있습니다.

1160
01:12:23,080 --> 01:12:26,240
그럼 포인터 산술 작동합니까?

1161
01:12:26,240 --> 01:12:29,480
음, 포인터 산술 배열에 같은 색인을 생성 일종의입니다.

1162
01:12:29,480 --> 01:12:36,370
이 경우, 내가 포인터를 가지고 있고, 내가 할 건 첫 번째 요소로 포인터 지점을 만드는

1163
01:12:36,370 --> 01:12:42,100
제가 할당 한 세 정수의 배열의.

1164
01:12:42,100 --> 01:12:46,670
그래서 지금 내가하는 일, 스타 포인터는 목록의 첫 번째 요소를 변경합니다.

1165
01:12:46,670 --> 01:12:49,140
여기에 스타 포인터가 한 점.

1166
01:12:49,140 --> 01:12:53,140
따라서 포인터가 여기에 있으며, 포인터 하나 여기에 있으며, 포인터 +2는 여기에 있습니다.

1167
01:12:53,140 --> 01:12:56,610
>> 따라서 단 1를 추가하면이 배열을 따라 이동과 같은 것입니다.

1168
01:12:56,610 --> 01:12:59,880
우리가 할 것은, 우리가 포인터 일을 할 때, 여기에 주소를

1169
01:12:59,880 --> 01:13:04,180
그리고 여기에서 값을 얻을하기 위해, 당신은 전체 표현에서 별표를 넣어

1170
01:13:04,180 --> 01:13:05,990
를 역 참조합니다.

1171
01:13:05,990 --> 01:13:09,940
그래서,이 경우에, 난 1이 배열의 첫 번째 위치를 설정 해요

1172
01:13:09,940 --> 01:13:13,970
2 초 위치, 및 3에 대한 제 위치를 지정합니다.

1173
01:13:13,970 --> 01:13:18,180
그리고 내가 여기서 뭐하는거야, 나는 우리 포인터 하나를 인쇄하려고하는데

1174
01:13:18,180 --> 01:13:19,970
이는 나에게 두를 제공합니다.

1175
01:13:19,970 --> 01:13:23,650
자, 포인터를 증가이야, 그러니 포인터가 포인터 +1 동일

1176
01:13:23,650 --> 01:13:26,780
이는 앞으로를 이동합니다.

1177
01:13:26,780 --> 01:13:30,810
그리고 지금은 포인터 하나를 인쇄하는 경우, 포인터 하나, 지금 3

1178
01:13:30,810 --> 01:13:33,990
이 경우 어느 3를 출력합니다.

1179
01:13:33,990 --> 01:13:36,560
그리고 무료로 뭔가, 내가주는 포인터에 대한 순서

1180
01:13:36,560 --> 01:13:40,540
나는 malloc에​​서 돌아 왔을 배열의 시작 부분에서 지적해야합니다.

1181
01:13:40,540 --> 01:13:43,430
바로 여기 3 전화 할 경우 따라서이 경우,이 수는 없죠

1182
01:13:43,430 --> 01:13:45,070
그 배열의 중간에 있기 때문.

1183
01:13:45,070 --> 01:13:48,820
나는 원래 위치로 이동 낮출 필요

1184
01:13:48,820 --> 01:13:50,420
제가 확보하기 전에 초기 첫번째 장소.

1185
01:13:56,300 --> 01:13:58,450
그럼 여기서 좀 더 관여 예입니다.

1186
01:13:58,450 --> 01:14:03,360
이 경우, 우리는 문자 배열에서 7 문자를 할당하고 있습니다.

1187
01:14:03,360 --> 01:14:06,480
>> 그리고이 경우에 우리가하는 일 우리가 그 중 첫번째 6 위에 반복하고 있습니다

1188
01:14:06,480 --> 01:14:09,900
우리는 Z.로 설정하는

1189
01:14:09,900 --> 01:14:13,350
따라서 INT에 I = 0, i>을 6 전 + +,

1190
01:14:13,350 --> 01:14:16,220
그럼, 포인터가 + 난 그냥,이 경우 우리를 제공합니다

1191
01:14:16,220 --> 01:14:20,860
포인터, 포인터 +1, 포인터 2, 마우스 포인터 3 등 등등 루프 인치

1192
01:14:20,860 --> 01:14:24,040
만약해야 할 일이에요 것은, 그것이 가치를 얻으려면 dereferences를 해당 주소를 얻을 수 있습니다

1193
01:14:24,040 --> 01:14:27,440
Z.과 그 변화 값을

1194
01:14:27,440 --> 01:14:30,350
그런 다음 끝 부분에 오른쪽이 문자열입니다 기억나요?

1195
01:14:30,350 --> 01:14:33,560
모든 문자열은 널 (null) 종료 문자로 끝날 수 있습니다.

1196
01:14:33,560 --> 01:14:38,620
그럼, 내가하는 일은 포인터를 6 전 인치 널 종료 문자를 넣어 수 있습니다

1197
01:14:38,620 --> 01:14:43,980
그리고 지금은 기본적으로 여기에 내가 뭘은 문자열을 printf 권리를 구현 무엇입니까?

1198
01:14:43,980 --> 01:14:46,190
>> 그럼 언제 printf 지금은 문자열의 끝을 도달 있어요 않을 때?

1199
01:14:46,190 --> 01:14:48,230
가 널 종료 문자를 돌 때.

1200
01:14:48,230 --> 01:14:52,030
그래서,이 경우,이 배열의 시작 부분에 원래의 포인터를 가리 킵니다.

1201
01:14:52,030 --> 01:14:56,410
나는 첫 번째 문자를 인쇄 할 수 있습니다. 한 이상을 이동합니다.

1202
01:14:56,410 --> 01:14:58,420
난 그 문자를 인쇄 할 수 있습니다. 제가 그것을 이동합니다.

1203
01:14:58,420 --> 01:15:02,180
그리고 제가 마지막에 도달 할 때까지이 일을 계속.

1204
01:15:02,180 --> 01:15:07,750
이제 끝 * 포인터 역 참조됩니다 이것과 널 종료 문자를 다시.

1205
01:15:07,750 --> 01:15:11,780
그리고 내 동안 루프는 값이 널 종료 문자 경우에만 실행됩니다.

1206
01:15:11,780 --> 01:15:13,770
그럼 이제이 루프에서 종료합니다.

1207
01:15:18,780 --> 01:15:21,180
그래서 난,이 포인터로부터 6을 빼야하는 경우

1208
01:15:21,180 --> 01:15:22,860
나는 처음부터 다시 모든 방법을 이동합니다.

1209
01:15:22,860 --> 01:15:27,880
제가 확보하기 위해 처음으로 이동하기 때문에 기억 나지, 내가이 일을거야.

1210
01:15:27,880 --> 01:15:30,270
>> 그래서 그런 일이 많은 걸. 질문이 있습니까?

1211
01:15:30,270 --> 01:15:31,870
제발, 네?

1212
01:15:31,870 --> 01:15:36,610
[학생 질문 이해할 수없는]

1213
01:15:36,610 --> 01:15:38,190
당신은 크게 그런 말을 할 수 있습니까? 미안 해요.

1214
01:15:38,190 --> 01:15:44,140
[학생] 당신은 당신의 포인터를 해제 직전 마지막 슬라이드에서

1215
01:15:44,140 --> 01:15:47,300
정말로 당신은 어디 포인터의 값을 변경 되었습니까?

1216
01:15:47,300 --> 01:15:50,370
[요셉] 지금, 여기. >> [학생] 아, 그래요.

1217
01:15:50,370 --> 01:15:51,890
[요셉]이 그래서, 지금, 포인터 마이너스 마이너스을 가지고

1218
01:15:51,890 --> 01:15:54,140
이것은, 내가 해방 후 다시 하나 일을 이동하고,

1219
01:15:54,140 --> 01:15:57,000
이 포인터는 배열의 시작 부분을 지적해야합니다 때문입니다.

1220
01:15:57,000 --> 01:16:00,420
당신이 줄 끝에서 중단 [학생]하지만 필요하지 않아요.

1221
01:16:00,420 --> 01:16:03,130
난이 이후 중단 된 경우 [요셉이] 그래서, 이것은, 메모리 누수로 간주됩니다

1222
01:16:03,130 --> 01:16:04,810
나는 자유를 실행하지 않았기 때문입니다.

1223
01:16:04,810 --> 01:16:11,290
[학생] 내가 불륜]이 포인터 일 불륜]를 맡은 첫 번째 세 줄 이후.

1224
01:16:11,290 --> 01:16:13,140
[요셉] 어 - 허. 그래서, 거기에 질문이 뭐야?

1225
01:16:13,140 --> 01:16:14,780
미안 해요. 아냐, 아냐. 제발,가,가.

1226
01:16:14,780 --> 01:16:16,870
[학생] 그래서, 포인터의 값을 변경하지.

1227
01:16:16,870 --> 01:16:19,130
당신은 포인터 마이너스 마이너스을 할 수 밖에없는 않았을 것이다.

1228
01:16:19,130 --> 01:16:19,730
[요셉] 예, 맞아요.

1229
01:16:19,730 --> 01:16:21,890
그래서, 포인터 +1 및 포인터 2를 수행하면,

1230
01:16:21,890 --> 01:16:24,410
제가 포인터를 안하는거야 포인터 +1 같습니다.

1231
01:16:24,410 --> 01:16:27,260
그래서, 포인터는 배열의 시작 부분에 포인팅 유지됩니다.

1232
01:16:27,260 --> 01:16:31,460
내가 플러스 할 때 그건 오로지 플러스는 포인터 안으로 값을 설정하는

1233
01:16:31,460 --> 01:16:33,550
실제로 함께이 이동하는.

1234
01:16:36,860 --> 01:16:37,780
괜찮아요.

1235
01:16:40,550 --> 01:16:42,030
더 질문?

1236
01:16:44,680 --> 01:16:47,790
>> 이 압도적 인 일종의 경우 다시, 이것은 세션에서 다룹니다.

1237
01:16:47,790 --> 01:16:50,710
그것에 대해 당신의 교육 동료에게 물어, 우리는 말에 질문에 답 할 수 있습니다.

1238
01:16:53,510 --> 01:16:56,600
그리고 일반적으로 우리는이 마이너스 일을 좋아하지 않아.

1239
01:16:56,600 --> 01:16:59,760
이 내가이 배열에 오프셋 얼마나 많은을 추적하는 데 필요합니다.

1240
01:16:59,760 --> 01:17:04,520
그래서, 일반적으로,이 포인터 연산의 작동 방식을 설명 한 것입니다.

1241
01:17:04,520 --> 01:17:07,970
하지만 우리가 일반적으로 수행 할 것은 우리가 포인터의 복사본을 만들 같은 거라도

1242
01:17:07,970 --> 01:17:11,640
우리가 문자열에 움직이는 때 그리고 우리는 그 사본을 사용합니다.

1243
01:17:11,640 --> 01:17:14,660
따라서,이 경우에 당신은 복사, 전체 문자열을 인쇄하는 데 사용할

1244
01:17:14,660 --> 01:17:19,040
하지만 우리는 포인터가 마이너스 6처럼해야 해, 안 그러면 우리가이 일에 이사를 얼마나를 추적하지 않습니다

1245
01:17:19,040 --> 01:17:22,700
우리는 우리의 원래의 지점이 여전히 목록의 시작 부분으로 지적되는 알해서

1246
01:17:22,700 --> 01:17:25,340
그리고 우리가 변경 한 모든이 복사했습니다.

1247
01:17:25,340 --> 01:17:28,250
그래서, 일반적으로 원래 포인터의 복사본을 변경합니다.

1248
01:17:28,250 --> 01:17:32,350
같은 정렬하지 마세요 - 원본 사본을 변경 마.

1249
01:17:32,350 --> 01:17:35,290
원래 만 사본을 변경하는 중입니다.

1250
01:17:41,540 --> 01:17:44,870
우리가 printf로 문자열을 통과 할 때, 당신은 발견

1251
01:17:44,870 --> 01:17:48,990
당신은 우리가 다른 모든 dereferences했던 것처럼 그 앞에 별표를 넣어 권한을 가지고 있지 않은거야?

1252
01:17:48,990 --> 01:17:54,180
당신은 전체 문자열 % s은 예상 출력 경우, 주소

1253
01:17:54,180 --> 01:17:57,610
이 경우 포인터 또는 문자의 배열 같은 이번 케이스는 아니군요.

1254
01:17:57,610 --> 01:18:00,330
>> 문자, 문자 * s 님과 배열은 같은 것이다.

1255
01:18:00,330 --> 01:18:03,690
포인터가 문자로하며, 문자 배열은 같은 것이다.

1256
01:18:03,690 --> 01:18:05,720
그리고, 우리가해야 할 모든 포인터에 전달됩니다.

1257
01:18:05,720 --> 01:18:08,150
우리는 * 포인터 나 그런 건처럼 통과 할 필요가 없습니다.

1258
01:18:13,110 --> 01:18:14,930
그래서, 배열과 포인터는 같은 일입니다.

1259
01:18:14,930 --> 01:18:19,160
당신이 X 같은 짓을 할 때 여기에 배열 [Y]

1260
01:18:19,160 --> 01:18:21,960
무슨 일이 후드 아래 짓을하​​면 그 말하는거야거야, 알 겠지, 이건 문자 배열

1261
01:18:21,960 --> 01:18:23,690
그래서 포인터입니다.

1262
01:18:23,690 --> 01:18:26,510
그리고 x가 같은거다

1263
01:18:26,510 --> 01:18:28,650
그래서 그게 무슨, 이건 x에 y를 추가합니다

1264
01:18:28,650 --> 01:18:31,820
그렇게 많이 메모리에 전진과 같은 일이되는 것입니다.

1265
01:18:31,820 --> 01:18:34,930
그리고 지금 X + y는 우리에게 주소의 일종을 제공합니다

1266
01:18:34,930 --> 01:18:37,570
우리는 주소를 역 참조하거나 화살표를 따라

1267
01:18:37,570 --> 01:18:41,640
있는 메모리에서 해당 위치는 우리는 메모리에서 해당 위치의 값을 가져옵니다.

1268
01:18:41,640 --> 01:18:43,720
정말 정말이 두 사람은 정확히 같은 일입니다.

1269
01:18:43,720 --> 01:18:45,840
그건 단지 구문 설탕입니다.

1270
01:18:45,840 --> 01:18:48,090
그들은 같은 일을 할. 그들은 서로 그냥 다른 syntactics하고 있습니다.

1271
01:18:51,500 --> 01:18:57,590
>> 그럼, 포인터와 무슨 수 있나요? 많은처럼. 좋아요. 자, 나쁜 일.

1272
01:18:57,590 --> 01:19:02,410
귀하의 malloc 호출은 null을 마우스 오른쪽 반환하면 당신이 할 수있는 나쁜 일들이 확인되지 않습니까?

1273
01:19:02,410 --> 01:19:06,560
이 경우, 나는 저를 보내기 위해 시스템을 부탁 해요 - 그 번호가 무엇입니까?

1274
01:19:06,560 --> 01:19:11,200
정수의 크기가 4 바이트이기 때문에, 2,000,000,000 회 사처럼.

1275
01:19:11,200 --> 01:19:13,810
난 8 억 바이트처럼을 위해 물어 보는거야.

1276
01:19:13,810 --> 01:19:17,270
물론 내 컴퓨터 나 한테 그렇게 많이 메모리를 다시 제공 할 수있을 것하지 않습니다.

1277
01:19:17,270 --> 01:19:20,960
이 null이면 우리는 우리가 저기에서 역 참조를하려고 할 때, 그래서 확인하지 않았어요 -

1278
01:19:20,960 --> 01:19:24,270
가로 가는지에있는 화살표를 따라 - 우리는 그 기억이 없어요.

1279
01:19:24,270 --> 01:19:27,150
이것은 우리가 널 포인터를 dereferencing라고 부릅니다.

1280
01:19:27,150 --> 01:19:29,710
그리고이 본질적으로 당신이 segfault하게됩니다.

1281
01:19:29,710 --> 01:19:31,790
이렇게하면 segfault 수있는 방법 중 하나입니다.

1282
01:19:34,090 --> 01:19:38,090
당신이 할 수있는 다른 나쁜 일이 - 잘 오.

1283
01:19:38,090 --> 01:19:40,650
그건 널 (null) 포인터를 dereferencing되었습니다. 좋아요.

1284
01:19:40,650 --> 01:19:45,160
다른 나쁜 일들이 - 그래, 네가 거기에 수표를 넣은 수정하기

1285
01:19:45,160 --> 01:19:46,980
그 포인터가 null인지 여부를 확인

1286
01:19:46,980 --> 01:19:51,000
그렇게 malloc이 NULL 포인터를 반환 무슨 일이 생긴다면하고 프로그램을 종료.

1287
01:19:55,110 --> 01:19:59,850
xkcd 만화들입니다. 사람들은 지금을 잘 알고 있습니다. 의를 정렬합니다.

1288
01:20:06,120 --> 01:20:09,350
>> 따라서, 메모리. 그리고이 이상했다.

1289
01:20:09,350 --> 01:20:12,000
우리는 루프에서 malloc를 호출하지만, 우리가 malloc 호출 할 때마다하는

1290
01:20:12,000 --> 01:20:14,370
우리는이 포인터가 가리키는 곳의 추적을 잃고있어

1291
01:20:14,370 --> 01:20:15,750
우리가 clobbering 때문이다.

1292
01:20:15,750 --> 01:20:18,410
따라서 malloc에​​ 대한 초기 호출은 나에게 여기 메모리를 통해 제공합니다.

1293
01:20:18,410 --> 01:20:19,990
이 일에 내 포인터 포인터.

1294
01:20:19,990 --> 01:20:23,020
자, 내가 그것을 확보하지 않기 때문에 지금은 다시 malloc를 호출합니다.

1295
01:20:23,020 --> 01:20:26,070
이제 여기에 가리 킵니다. 지금 내 기억은 여기 가리키고있다.

1296
01:20:26,070 --> 01:20:27,640
여기에 포인팅. 여기에 포인팅.

1297
01:20:27,640 --> 01:20:31,820
하지만 여기서 제가 할당하는 전역 메모리의 주소의 추적을 잃었습니다.

1298
01:20:31,820 --> 01:20:35,100
그리고 지금은 더 이상에 대한 참조가 없습니다.

1299
01:20:35,100 --> 01:20:37,230
그래서,이 루프의 외부를 확보 할 수 없습니다.

1300
01:20:37,230 --> 01:20:39,390
그리고이 같은 문제를 해결하기 위해

1301
01:20:39,390 --> 01:20:42,250
당신은 무료로 메모리에 잊고,이 메모리 누수를한다면,

1302
01:20:42,250 --> 01:20:45,810
당신은 당신이 그것으로 완료되면이 루프의 내부 메모리를 확보해야합니다.

1303
01:20:45,810 --> 01:20:51,400
음,이 무슨 일 것입니다. 난 당신이 많은이를 싫어한다는 걸 알면서.

1304
01:20:51,400 --> 01:20:55,270
그러나 지금 - 야호! 당신은 4만4천킬로바이트처럼 얻을.

1305
01:20:55,270 --> 01:20:57,110
그럼, 당신은 루프의 끝에서 해방

1306
01:20:57,110 --> 01:20:59,770
그는 메모리마다 시간을 확보 할거야.

1307
01:20:59,770 --> 01:21:03,620
기본적으로 프로그램은 더 이상 메모리 누수가 없습니다.

1308
01:21:03,620 --> 01:21:08,150
>> 그리고 지금 당신이 할 수있는 다른 일이 두 번 요구 한 일부 메모리를 무료로 이용하실 수 있습니다.

1309
01:21:08,150 --> 01:21:11,060
이 경우, malloc 뭔가, 당신은 그 값을 변경합니다.

1310
01:21:11,060 --> 01:21:13,140
당신은 당신이 그것으로 정리 한 줄 한 번 있기 때문에 당신은 그것을 무료입니다.

1311
01:21:13,140 --> 01:21:14,940
하지만 우리는 다시 해제.

1312
01:21:14,940 --> 01:21:16,730
이건 정말 나쁜 일입니다.

1313
01:21:16,730 --> 01:21:18,820
그것은 처음 segfault 않을거야

1314
01:21:18,820 --> 01:21:23,350
하지만 이후이 두 번이 부패 귀하의 힙 구조를 자유롭게 할뿐입니다 어쩌고,

1315
01:21:23,350 --> 01:21:27,200
당신은 CS61 같은 수업을 할 경우 당신은이 일에 대해서 조금 더 알아 보겠습니다.

1316
01:21:27,200 --> 01:21:30,000
그러나 본질적 후 컴퓨터가 혼란에 빠진다 것입니다 동안

1317
01:21:30,000 --> 01:21:33,010
- 어디 어디에 저장 일을 메모리 위치가에 대한

1318
01:21:33,010 --> 01:21:34,800
위치 데이터는 메모리에 저장됩니다.

1319
01:21:34,800 --> 01:21:38,080
그리고 포인터를 자유롭게하는 것은 두 번 당신이하지 않으려는 나쁜 일입니다.

1320
01:21:38,080 --> 01:21:41,600
>> 잘못 할 수있는 다른 일들이 sizeof를 사용하지 않습니다.

1321
01:21:41,600 --> 01:21:44,460
그래서,이 경우에 당신은 8 바이트를 malloc

1322
01:21:44,460 --> 01:21:46,700
그 바로 두 개의 정수와 같은 일이야?

1323
01:21:46,700 --> 01:21:49,580
그럼, 그게 완벽하게 안전하지만인가요?

1324
01:21:49,580 --> 01:21:52,160
음, 루카스, 다른 아키텍처에 관한 이야기​​로

1325
01:21:52,160 --> 01:21:54,220
정수는 다른 길이 있습니다.

1326
01:21:54,220 --> 01:21:57,970
그래서, 사용하는 기기에 정수는 약 4 바이트입니다

1327
01:21:57,970 --> 01:22:02,370
그러나 다른 시스템에서 사람들은 8 바이트 일 수도 또는 16 바이트 일 수 있습니다.

1328
01:22:02,370 --> 01:22:05,680
그래서, 난 그냥 여기에이 번호를 사용하는 경우는,

1329
01:22:05,680 --> 01:22:07,310
이 프로그램은 기기에서 작동 할 수

1330
01:22:07,310 --> 01:22:10,360
하지만 일부 다른 시스템에 충분한 메모리를 할당 할 수 없을거야.

1331
01:22:10,360 --> 01:22:14,020
이 경우,이 sizeof 연산자가 사용 이유입니다.

1332
01:22:14,020 --> 01:22:16,880
어떤이 수행 것은 우리가 전화 sizeof (INT),

1333
01:22:16,880 --> 01:22:21,910
 그것은 우리에게 프로그램이 실행되는 시스템에 정수의 크기를 제공합니다.

1334
01:22:21,910 --> 01:22:25,490
그래서,이 경우, sizeof (int는)는 어플라이언스와 같은 무언가에 4 반환합니다

1335
01:22:25,490 --> 01:22:29,980
지금 8이다이 뜻을 4 * 2,,

1336
01:22:29,980 --> 01:22:32,330
이는 두 정수에 필요한 공간의 양입니다.

1337
01:22:32,330 --> 01:22:36,710
다른 시스템에서 int는 16 바이트 또는 8 바이트 같은 경우,

1338
01:22:36,710 --> 01:22:39,380
그냥 그 금액을 저장하기에 충분한 바이트를 반환하는거야.

1339
01:22:41,830 --> 01:22:45,310
>> 그리고 마지막으로, structs.

1340
01:22:45,310 --> 01:22:48,340
그래서 메모리에 스도쿠 보드를 저장하기를 원한다면 우리가 어떻게이 작업을 수행 할 수?

1341
01:22:48,340 --> 01:22:51,570
당신은 1 가지의 변수처럼 생각 수 있습니다

1342
01:22:51,570 --> 01:22:53,820
두 번째의 변수, 세 번째의 변수

1343
01:22:53,820 --> 01:22:56,420
나쁜, 맞아 - 네 번째 문제에 대한 변수?

1344
01:22:56,420 --> 01:23:00,750
그러니까, 당신이 상단에 할 수있는 하나 개선 9 X 9 배열을 만드는 것입니다.

1345
01:23:00,750 --> 01:23:04,480
좋아요,하지만 당신은 스도쿠 보드와 다른 일을 연결하기 원하는 경우

1346
01:23:04,480 --> 01:23:06,490
, 이사회의 어려움이 맘에

1347
01:23:06,490 --> 01:23:11,740
또는, 예를 들어, 당신의 점수는, 또는 얼마나 많은 시간이 당신이 보드를 해결하기 위해 촬영 거죠?

1348
01:23:11,740 --> 01:23:14,970
음, 당신이 할 수있는 것은 당신이 구조체를 만들 수 있습니다.

1349
01:23:14,970 --> 01:23:18,910
내가 기본적으로 말은, 내가 여기에이 구조를 정의하는 건,

1350
01:23:18,910 --> 01:23:23,230
나는 X 9 9 인위원회로 구성 스도쿠 보드를 정의하는거야.

1351
01:23:23,230 --> 01:23:26,650
>> 그리고 그건 레벨의 이름에 대한 포인터가 가지고있는.

1352
01:23:26,650 --> 01:23:30,730
또한 지금 내가이 곳의 좌표 x와 y을 가지고 있습니다.

1353
01:23:30,730 --> 01:23:35,980
또한 시간은 불륜]를 지출했습니다, 그리고 지금까지 입력 된 한 이동의 총 수 있습니다.

1354
01:23:35,980 --> 01:23:40,010
그리고이 경우에, 나는 단 한 구조로 데이터를 왕창 그룹화 할 수

1355
01:23:40,010 --> 01:23:42,790
대신 다른 변수처럼 곳곳에 날아처럼 갖는

1356
01:23:42,790 --> 01:23:44,540
정말 추적을 계속 할 수가 없습니다.

1357
01:23:44,540 --> 01:23:49,720
그리고 우리가이 구조체의 내부에 다른 일을 참조 일종의을위한 단지 좋은 구문을 할 수 있습니다.

1358
01:23:49,720 --> 01:23:53,430
나는 board.board을 바로 할 수 있으며, 다시 스도쿠 보드를.

1359
01:23:53,430 --> 01:23:56,320
Board.level, 내가 얼마나 힘들 얻을.

1360
01:23:56,320 --> 01:24:00,540
Board.x 및 board.y이 내가 보드에있을 곳의 좌표를 제공합니다.

1361
01:24:00,540 --> 01:24:04,730
그리고 나는 우리가 구조체의 필드라고 부르는 액세스거야.

1362
01:24:04,730 --> 01:24:08,840
난이게하는 유형 sudokuBoard을 정의합니다.

1363
01:24:08,840 --> 01:24:14,800
그리고 지금 우리는 여기 야. I 유형은 sudokuBoard의 "이사회"라는 변수가 있습니다.

1364
01:24:14,800 --> 01:24:18,820
그리고 지금은 여기에이 구조를 구성하는 모든 필드를 액세스 할 수 있습니다.

1365
01:24:20,830 --> 01:24:22,450
>> structs에 대한 질문? 그래?

1366
01:24:22,450 --> 01:24:25,890
INT X, Y를 들어 [학생], 당신은 한 줄에 모두 선언? >> [요셉] 어 - 허.

1367
01:24:25,890 --> 01:24:27,400
[학생] 지금, 당신은 모두 함께 그 짓을 할 수 있을까?

1368
01:24:27,400 --> 01:24:31,200
X에서 같은, Y의 쉼표 배 총?

1369
01:24:31,200 --> 01:24:34,460
[요셉] 그래, 당신은 확실히 내가 같은 줄에 x와 y를 넣어 이유는 그렇게 할 수 있었지만 -

1370
01:24:34,460 --> 01:24:36,330
우리가 같은 줄에이 작업을 수행 할 수 있습니다 이유 문제는?

1371
01:24:36,330 --> 01:24:38,600
왜, 그냥 같은 줄에이 모든 두지 않습니다

1372
01:24:38,600 --> 01:24:42,090
x와 y는 서로 관련되어,

1373
01:24:42,090 --> 01:24:44,780
이는 의미에서, 단지 stylistically 더 정확

1374
01:24:44,780 --> 01:24:46,600
이 같은 줄에 두 가지를 그룹화 있기 때문에

1375
01:24:46,600 --> 01:24:49,340
의 같은 종류의이 같은에 관한 것이다.

1376
01:24:49,340 --> 01:24:51,440
그리고 그냥 무너 다음을 분할. 단지 스타일의 문제입니다.

1377
01:24:51,440 --> 01:24:53,720
이 기능 어​​떠한 차이는 없습니다.

1378
01:24:58,150 --> 01:24:59,270
structs에 대한 또 다른 질문 있나?

1379
01:25:03,030 --> 01:25:06,620
당신은 구조체와 Pokédex를 정의 할 수 있습니다.

1380
01:25:06,620 --> 01:25:11,720
포켓 몬스터는 숫자가 있으며 문자, 소유자, 타입이 있습니다.

1381
01:25:11,720 --> 01:25:16,990
당신은 포켓 몬스터의 배열이있는 경우 그리고, 당신이 옳았 고, Pokédex 보상 해줄 수 있을까?

1382
01:25:16,990 --> 01:25:20,810
오케이, 좋아. 자, structs에 대한 질문입니다. 사람들은 structs와 관련이 있습니다.

1383
01:25:20,810 --> 01:25:25,270
>> 마지막으로, GDB. GDB는 당신이 무엇을하게됩니까? 그것은 당신이 프로그램을 디버깅 할 수 있습니다.

1384
01:25:25,270 --> 01:25:27,650
당신은 GDB를 사용하지 않은 경우 그리고, 제가 짧은을 감상하는 것이 좋습니다 것입니다

1385
01:25:27,650 --> 01:25:31,250
불과 GDB가 무엇을 살펴 어떻게 당신이 그것을 사용하는 방법을, 그것으로 일

1386
01:25:31,250 --> 01:25:32,900
및 프로그램에 테스트합니다.

1387
01:25:32,900 --> 01:25:37,400
그리고 GDB는 당신이 할 수 그런 일이 일시 정지 불륜]의 프로그램을 할 수 있습니다

1388
01:25:37,400 --> 01:25:38,920
그리고 실제 줄입니다.

1389
01:25:38,920 --> 01:25:42,600
예를 들어, 내 프로그램의 3 호선 등의 일시 정지 실행하려는

1390
01:25:42,600 --> 01:25:46,010
내가 3 호선에있는 동안은이 모든 값을 인쇄 할 수 있습니다.

1391
01:25:46,010 --> 01:25:49,710
라인에 일시처럼 그래서 우리는 부르는

1392
01:25:49,710 --> 01:25:52,350
우리는이이 줄에 중단 점을 넣어 불러

1393
01:25:52,350 --> 01:25:55,920
그리고 우리는 그 때 프로그램의 상태에서 변수를 인쇄 할 수 있습니다.

1394
01:25:55,920 --> 01:25:58,990
>> 우리는에서 프로그램 라인 별 라인을 통해이 단계를 할 수 있습니다.

1395
01:25:58,990 --> 01:26:03,200
그리고 우리는 시간에 스택의 상태를 볼 수 있습니다.

1396
01:26:03,200 --> 01:26:08,600
그리고 GDB, 우리가 할 것은 우리가 C 파일을 연타하다 전화입니다, 사용하려면

1397
01:26:08,600 --> 01:26:11,290
그러나 우리는 그것을 - ggdb 플래그를 통과해야합니다.

1398
01:26:11,290 --> 01:26:15,850
그리고 일단 우리는 우리가 결과로 출력 파일에 gdb를 실행하는 짓을하고 있습니다.

1399
01:26:15,850 --> 01:26:18,810
그리고 당신은이 같은 텍스트의 일부 같은 질량을

1400
01:26:18,810 --> 01:26:21,990
하지만 당신이해야 할 정말로 처음에 명령을 입력합니다.

1401
01:26:21,990 --> 01:26:24,250
휴식 주요 메인에 중단 점을 넣습니다.

1402
01:26:24,250 --> 01:26:28,470
목록 400 선 약 400 코드의 라인을 나열합니다.

1403
01:26:28,470 --> 01:26:31,410
그리고이 경우에 당신은, 오, 주변을 둘러 말할 수

1404
01:26:31,410 --> 01:26:34,360
이 라인 라인 397에 중단 점을, 설정하려면

1405
01:26:34,360 --> 01:26:37,170
다음 프로그램은이 단계에 실행이 부러거야.

1406
01:26:37,170 --> 01:26:41,120
거기 일시 중지되고, 당신은 예를 들어, 낮거나 높은 값을 인쇄 할 수 있습니다.

1407
01:26:41,120 --> 01:26:46,410
그리고 당신이 알아야 할 명령의 무리가 있습니다

1408
01:26:46,410 --> 01:26:48,660
이 슬라이드 쇼, 웹 사이트에 갈 것이다

1409
01:26:48,660 --> 01:26:54,000
방금이를 참조하려면하거나 컨닝 시트에 넣어 좋아하면, 주시기 바랍니다.

1410
01:26:54,000 --> 01:27:00,650
>> 좋아. 그 퀴즈 검토 10 살때하고, 궁금한 사항이 있으면 우리는있을께요.

1411
01:27:00,650 --> 01:27:03,850
괜찮아요.

1412
01:27:03,850 --> 01:27:09,030
>>  [박수]

1413
01:27:09,030 --> 01:27:13,000
>> [CS50.TV]