1
00:00:00,000 --> 00:00:00,309

2
00:00:00,309 --> 00:00:02,350
[? DAN ARMADARAS :?] 안녕,
나는 [해요? 댄 Armadaras?].

3
00:00:02,350 --> 00:00:04,410
오늘, 우리는 갈거야
디버깅에서 찾고.

4
00:00:04,410 --> 00:00:06,697
뿐만 아니라 우리는 건가요
일부 기술에 대해 이야기

5
00:00:06,697 --> 00:00:09,280
뿐만 아니라 우리가 보는거야
일부 기능이 포함 된

6
00:00:09,280 --> 00:00:14,170
수 CS50의 IDE 내
당신은 쉽게 프로그램을 디버깅하는 방법.

7
00:00:14,170 --> 00:00:16,272
>> 그냥 하나의 예
잘못 될 수있는 무엇인가

8
00:00:16,272 --> 00:00:18,730
그것은 실제로 뭔가
우리는 이미 이전에 본 적이있다.

9
00:00:18,730 --> 00:00:23,200
그 경우는 C 프로그램을 인
즉, 사용자로부터 정수를 받아

10
00:00:23,200 --> 00:00:27,580
2로 그것을 분할하고, 제공
다시 사용자에게 출력.

11
00:00:27,580 --> 00:00:30,610
이제 우리가 본 것과
이전 강의에서,

12
00:00:30,610 --> 00:00:34,370
우리는이 실제로 발생할 것이라는 점을 알고있다
분할 문제의 특정 유형

13
00:00:34,370 --> 00:00:35,860
우리는 홀수가있는 경우.

14
00:00:35,860 --> 00:00:40,330
>> 특히, 우리는 그냥 버릴거야
소수점 아무것도.

15
00:00:40,330 --> 00:00:43,170
이제, 우리는이 것을 알고있다
경우가 발생합니다.

16
00:00:43,170 --> 00:00:47,430
그리고 우리가 그것을 실행하는 경우, 우리는 확인할 수 있습니다
컴파일하여 먼저 우리의 의심,.

17
00:00:47,430 --> 00:00:50,460
그리고, 실행하여과
홀수 번호를 입력.

18
00:00:50,460 --> 00:00:51,720
>> 이것은 새로운 것이 아니다.

19
00:00:51,720 --> 00:00:54,490
그러나 이것은 사실입니다
버그의 예를 그

20
00:00:54,490 --> 00:00:58,810
큰 프로그램 내에 존재할 수있다
그 추적 어려워진다.

21
00:00:58,810 --> 00:01:02,640
우리는 어떤 문제를 알고 있지만
그 문제의 진정한 핵심이다

22
00:01:02,640 --> 00:01:06,250
확인을 시도 할 수 있습니다
구체적으로는 여기서 에러가 발생,

23
00:01:06,250 --> 00:01:09,750
어떻게 그 문제를 식별
이고, 다음 정착.

24
00:01:09,750 --> 00:01:14,400
그래서 예를 들어이 제공
뭔가가 무엇인지의

25
00:01:14,400 --> 00:01:19,030
우리는 이미 알고 있지만 매장 될 수 있음
코드의 다른 요소 내에서.

26
00:01:19,030 --> 00:01:23,090
>> 그래서 다른 소스를 개방
예로서 코드 파일,

27
00:01:23,090 --> 00:01:27,165
이 분할 문제는 지금
큰 프로그램의 일부입니다.

28
00:01:27,165 --> 00:01:29,040
아직 조금이 될 수 있습니다
비트는 고안, 그리고 우리

29
00:01:29,040 --> 00:01:31,076
쉽게 할 수 있습니다
특히, 식별

30
00:01:31,076 --> 00:01:32,450
우리가이 문제를 논의하고 있기 때문에.

31
00:01:32,450 --> 00:01:38,250
그러나 우리는이 것을 알아낼 수
문제는 대규모로 존재할 수있다.

32
00:01:38,250 --> 00:01:45,450
>> 지금이 컴파일하는 경우
가, 홀수 번호를 입력 실행

33
00:01:45,450 --> 00:01:49,816
우리는 우리가 정확하게하지 않는 것을 알 수 있습니다
우리가 예상 할 수있다 출력.

34
00:01:49,816 --> 00:01:51,690
특히이 경우,
우리는 말을 생각하고 우리

35
00:01:51,690 --> 00:01:56,060
숫자를 모두 계산하려면
하나에서까지 일부 특정 번호.

36
00:01:56,060 --> 00:01:58,130
그리고 우리는 우리를 볼 수 있습니다
다양한 문제를 가지고

37
00:01:58,130 --> 00:02:03,880
우리가 출력하고 여기 경우, 단순히 0
1 우리가 5의 입력을 제공 할 때.

38
00:02:03,880 --> 00:02:07,380
>> 그래서 우리는 이미 알고
문제는 여기에있다.

39
00:02:07,380 --> 00:02:11,662
그러나 우리는 정확히 알 수 없습니다
여기서이 문제가 실​​제로 존재한다.

40
00:02:11,662 --> 00:02:13,620
방법 중 이제 하나 그
우리는이 문제를 해결하기 위해 시도 할 수 있습니다

41
00:02:13,620 --> 00:02:15,745
우리가했습니다 뭔가
이미 도입되었습니다.

42
00:02:15,745 --> 00:02:18,880
우리는 더 큰 규모로 사용할 수 있습니다.

43
00:02:18,880 --> 00:02:21,680
>> 라인 14 일, 우리가
이 printf 함수,

44
00:02:21,680 --> 00:02:25,620
이는 우리가 주를 인쇄 할 수 있습니다
다양한 정보의.

45
00:02:25,620 --> 00:02:28,880
그리고 이것은 뭔가 당신을
프로그램 내에서 활용한다

46
00:02:28,880 --> 00:02:33,100
정확히 무엇을 알아 내려고 시도
코드의 다양한 라인에서 일어나는.

47
00:02:33,100 --> 00:02:36,350
그래서이 아니더라도
최종 출력이 우리가 실제로

48
00:02:36,350 --> 00:02:39,830
에서 생산 할
이 프로그램에, 우리는 여전히

49
00:02:39,830 --> 00:02:42,300
일부 디버그가있을 수 있습니다
문 여기서 우리

50
00:02:42,300 --> 00:02:46,970
알아 내기 위해 시도 할 수 있습니다 정확히 무엇을
우리의 코드의 내부에서 일어나고있다.

51
00:02:46,970 --> 00:02:51,210
>> 이 경우, 나는 것
디버그 태그는 printf.

52
00:02:51,210 --> 00:02:53,540
이 경우에,이다
단지 디버그 문자열

53
00:02:53,540 --> 00:02:56,840
내가 업 퍼팅 그래서가되도록 해요 것을
내 코드의 출력에 아주 명확

54
00:02:56,840 --> 00:02:59,200
무엇을 내가 보여주고 싶은 것입니다.

55
00:02:59,200 --> 00:03:04,410
수 여기에 출력
우리가 계산 한 것이다.

56
00:03:04,410 --> 00:03:06,800
>> 이 경우에, I는 수도
정확하게 알고 싶어요

57
00:03:06,800 --> 00:03:11,380
무슨 일이 전에 무슨 일이 일어나고 및
일부 특정 계산 후.

58
00:03:11,380 --> 00:03:16,224
그래서 이전의 printf를 사용할 수 있습니다
코드의 라인 후.

59
00:03:16,224 --> 00:03:18,640
이 경우에, 심지어 수
이 조금 더 명확하게

60
00:03:18,640 --> 00:03:21,960
전에 디버그를 말하여
디버그 그래서 후

61
00:03:21,960 --> 00:03:26,540
나는 나 자신을 혼동하지 않는 것이
동일한 보면 여러 행.

62
00:03:26,540 --> 00:03:32,290
>> 이제 우리는이 실행을 다시 컴파일하는 경우
그것은, 다시 다섯 같은 번호를 입력

63
00:03:32,290 --> 00:03:35,090
우리는 우리가 가지고있는 것을 볼 수있다
이제 이전과 이후 출력

64
00:03:35,090 --> 00:03:40,670
우리는 명확한을하지 않은 것을 발견
분할 또는 명확한 숫자를 갖는

65
00:03:40,670 --> 00:03:43,680
우리가 실제로 수행 할 것이다.

66
00:03:43,680 --> 00:03:48,660
지금,이 경우이다
정말 명확한 출력.

67
00:03:48,660 --> 00:03:52,440
정말 명확한 결과가 아니라 그
우리는이 특정 프로그램에서 할 수 있습니다.

68
00:03:52,440 --> 00:03:54,427
>> 그리고 이것은 다시,이다
조금 고안.

69
00:03:54,427 --> 00:03:57,510
하지만, 아마도, 것들 중 하나가
사양은 말했다 경우 우리가 할 수있는

70
00:03:57,510 --> 00:04:01,900
우리는이 작업을 분할 할 것인지
2 등 즉 1-- 추가

71
00:04:01,900 --> 00:04:04,550
우리는 up-- 반올림 할
우리는 우리가 할 수 있음을 알 수있다

72
00:04:04,550 --> 00:04:08,060
이 경우, 특정 일을.

73
00:04:08,060 --> 00:04:14,010
이제 여기서 우리는 우리가 할 것이라는 점을 알고있다
우리의 절반 번호에 1을 추가 할 수.

74
00:04:14,010 --> 00:04:16,490
>> 이 해 다시 컴파일하자
이 있는지 확인

75
00:04:16,490 --> 00:04:18,860
우리가 원하는 방식으로 행동한다.

76
00:04:18,860 --> 00:04:21,980
우리는 지금 그 전에 볼 수 있습니다
데, 우리는 숫자 5가 있습니다.

77
00:04:21,980 --> 00:04:26,620
후에, 우리는 숫자 3이
우리의 사양에 따라하는,

78
00:04:26,620 --> 00:04:29,292
우리가하고 싶었던 것입니다.

79
00:04:29,292 --> 00:04:31,000
그러나 우리는 보면
여기 출력, 우리는 할 수

80
00:04:31,000 --> 00:04:33,760
우리가 다른이있을 수 있습니다 볼
이다 전부 버그,

81
00:04:33,760 --> 00:04:36,940
우리는 0에서 우리의 카운트를 시작하고있다.

82
00:04:36,940 --> 00:04:39,390
>> 이제 다시,이 뭔가
우리는 이전에 보았던 것을

83
00:04:39,390 --> 00:04:42,500
우리는 아주 쉽게 해결할 수 있습니다.

84
00:04:42,500 --> 00:04:44,790
그러나이 경우, 우리
또한 이점을 가지고

85
00:04:44,790 --> 00:04:48,940
printf의 문을 사용하여
직접 루프의 내부

86
00:04:48,940 --> 00:04:52,930
정확하게 위치를 알 수 있습니다
그 오류가 발생했습니다.

87
00:04:52,930 --> 00:04:55,150
그래서 printf의 문은
데 매우 유용합니다

88
00:04:55,150 --> 00:04:57,940
당신은 위치를 확인,
정확하게 소스 코드에서,

89
00:04:57,940 --> 00:05:00,620
특정 오류가 발생한다.

90
00:05:00,620 --> 00:05:03,650
>> 그리고 그것을 실현하는 것이 중요합니다
즉, 우리가 코드를 작성하는 등,

91
00:05:03,650 --> 00:05:06,052
우리는 가정이있을 수 있습니다
프로그램의 상태에 대한.

92
00:05:06,052 --> 00:05:08,510
아니면 우리는 가정이있을 수 있습니다
프로그램의 어떤 부분에 대한

93
00:05:08,510 --> 00:05:13,020
실제로 올바른하거나 잘못
나중에 우리가 그 프로그램 구축으로

94
00:05:13,020 --> 00:05:15,950
그것의 일부 확인
복잡하고 큰 프로그램

95
00:05:15,950 --> 00:05:19,700
우리는 몇 가지 측면 실현하는 것이
그 중 실제로 버그가 있습니다.

96
00:05:19,700 --> 00:05:22,680
>> 의 printf를 사용하면 정말 도움이 될 수 있습니다
좁혀 확인

97
00:05:22,680 --> 00:05:26,430
프로그램의 영역이되지 않을 수 있습니다
정확하게 방법을 행동하는 것이 우리

98
00:05:26,430 --> 00:05:29,500
우리의 가정을 기반으로, 기대합니다.

99
00:05:29,500 --> 00:05:31,460
그러나 다른 도구를 거기에
사용할 수뿐만 아니라,

100
00:05:31,460 --> 00:05:34,860
즉, 우리가 그림을 시도합니다
여기서 오류가 발생 아웃

101
00:05:34,860 --> 00:05:39,930
또한, 구체적으로 어떤 것들
프로그램 내에서 일어나고있다.

102
00:05:39,930 --> 00:05:41,990
>> 그래서 사용의 printf는 매우이다
유용 때 우리가 원하는

103
00:05:41,990 --> 00:05:45,900
의 특정 영역을 식별하는
약간의 버그가있는 프로그램.

104
00:05:45,900 --> 00:05:47,730
그러나 또한진다
잠시 후 지루한.

105
00:05:47,730 --> 00:05:50,500
이 경우, 이는 인
상대적으로 간단한 프로그램

106
00:05:50,500 --> 00:05:52,750
하나 또는 두 개의 변수.

107
00:05:52,750 --> 00:05:57,260
그리고 그것은 우리에게 매우 쉬워진다
해당 변수의 값을 출력

108
00:05:57,260 --> 00:05:59,670
큰 프로그램의 맥락에서.

109
00:05:59,670 --> 00:06:02,670
>> 그러나 우리는 다른이있을 수 있습니다
많은 변수가 프로그램.

110
00:06:02,670 --> 00:06:06,530
그리고 그것은 확실히하지 않을 수 있습니다
의 printf를 사용하기 쉽습니다

111
00:06:06,530 --> 00:06:10,120
무슨 일이 일어나고 있는지 평가하기 위해 시도
이 변수 각각에

112
00:06:10,120 --> 00:06:13,590
프로그램으로 실행됩니다.

113
00:06:13,590 --> 00:06:16,960
존재하는 프로그램이있다
디버거 프로그램이라고합니다.

114
00:06:16,960 --> 00:06:20,320
이 경우에, 우리는 한 것
사용은 GDB GNU 디버거, 또는

115
00:06:20,320 --> 00:06:24,260
즉 우리가 내부를 검사 할 수 있습니다
훨씬 더에서 프로그램의 동작

116
00:06:24,260 --> 00:06:25,700
자세한 방법.

117
00:06:25,700 --> 00:06:28,810
>> 우리는 실제로 실행할 수 있습니다
명령 줄에서 GDB

118
00:06:28,810 --> 00:06:35,370
여기에 단순히 GDB와를 입력하여
우리가 디버깅 할 명령.

119
00:06:35,370 --> 00:06:37,550
이 경우, 카운트.

120
00:06:37,550 --> 00:06:41,650
지금,이 경우에, 우리는 그것을 볼 수있다
GDB를 말한다 프롬프트로 우리를 제공합니다.

121
00:06:41,650 --> 00:06:44,020
그리고 우리가 실제로 할 수있는
GDB 명령을 실행

122
00:06:44,020 --> 00:06:48,260
실제로 실행을 시작합니다
프로그램은 특정 지점에서 중지,

123
00:06:48,260 --> 00:06:51,060
변수를 평가하고
변수를 검사하는

124
00:06:51,060 --> 00:06:54,152
프로그램 상태에 존재
특정 순간에,

125
00:06:54,152 --> 00:06:55,110
등 등.

126
00:06:55,110 --> 00:06:57,240
그것은 우리에게 많은 힘을 제공한다.

127
00:06:57,240 --> 00:06:59,960
>> 하지만 너무 일이
그 또한 CS50의 IDE

128
00:06:59,960 --> 00:07:05,870
GUI 또는 사용자에게 제공한다
GDB에 대한 인터페이스 그

129
00:07:05,870 --> 00:07:11,120
우리는 필요없이이 작업을 수행 할 수 있습니다
무엇이든지 명령 줄 인터페이스

130
00:07:11,120 --> 00:07:13,560
또는 모든도.

131
00:07:13,560 --> 00:07:16,930
나는 그것을 액세스 할 수있는 방법
디버그 버튼을 사용하는 것입니다

132
00:07:16,930 --> 00:07:20,120
CS50의 IDE의 맨 위에.

133
00:07:20,120 --> 00:07:24,280
이제 과거에, 우리는 무엇을해야
본 우리가 명령을 사용한다는 것이다

134
00:07:24,280 --> 00:07:27,660
라인은 컴파일 후 프로그램을 실행합니다.

135
00:07:27,660 --> 00:07:29,790
>> 디버그 버튼을 수행
그 두 단계.

136
00:07:29,790 --> 00:07:34,380
그러나 그것은 또한 나타납니다
맨 오른쪽에 디버거 탭

137
00:07:34,380 --> 00:07:38,280
즉, 우리는 다양한 검사 할 수 있습니다
프로그램의 특성

138
00:07:38,280 --> 00:07:40,500
로 실행이됩니다.

139
00:07:40,500 --> 00:07:44,280
나는이에, 디버그를 클릭하면
경우, 그것은 나타납니다

140
00:07:44,280 --> 00:07:48,230
콘솔에서 새 탭
맨 아래의 창.

141
00:07:48,230 --> 00:07:51,160
>> 그리고 당신은이 탭이 있는지 볼 수 있습니다
맨 위에 몇 가지 정보를 제공합니다.

142
00:07:51,160 --> 00:07:52,670
그리고 우리는 대부분이 무시할 수 있습니다.

143
00:07:52,670 --> 00:07:54,800
그러나 것들 중 하나
우리는주의하도록

144
00:07:54,800 --> 00:07:57,170
이 출력이다
같은 일이 우리

145
00:07:57,170 --> 00:08:03,000
우리가 만드는 실행하려고하면 얻을 것
터미널 창에서 C 프로그램.

146
00:08:03,000 --> 00:08:06,230
>> 여기, 우리가 그 소리를 실행중인 볼 수 있습니다,
그것은 플래그의 다양한있다,

147
00:08:06,230 --> 00:08:12,660
그리고, 우리의 count.c 파일을 컴파일
이는 시간에 선택된 탭이었다

148
00:08:12,660 --> 00:08:15,100
것을 나는 디버그를 기록했다.

149
00:08:15,100 --> 00:08:18,010
그래서이 때문에 매우 유용합니다
지금이 디버그 버튼을 사용하여,

150
00:08:18,010 --> 00:08:23,280
우리는 동시에 다음 컴파일 할 수 있습니다
프로그램을 실행하는 우리 실제로

151
00:08:23,280 --> 00:08:24,460
실행하려는.

152
00:08:24,460 --> 00:08:27,880
>> 인 플래그 중 하나
중요한 것은,이 경우에,

153
00:08:27,880 --> 00:08:30,190
우리가 실제로 사용하고
가장 긴 시간

154
00:08:30,190 --> 00:08:32,450
뿐만 아니라 그냥 손을했다
흔들며 [들림], 어떤

155
00:08:32,450 --> 00:08:33,820
여기이 하나입니다.

156
00:08:33,820 --> 00:08:35,790
그 소리, 그것은 -ggdb3을 말한다.

157
00:08:35,790 --> 00:08:38,570

158
00:08:38,570 --> 00:08:41,250
이 경우, 우리는 무엇
그 소리 이야기, 우리의 컴파일러,

159
00:08:41,250 --> 00:08:43,820
우리는 우리의 프로그램을 컴파일 할 것입니다.

160
00:08:43,820 --> 00:08:46,810
그러나 또한 무엇 제공
라는 심볼 정보

161
00:08:46,810 --> 00:08:50,940
컴파일러가 실제로 액세스 할 수 있도록
기본이되는 많은 정보에

162
00:08:50,940 --> 00:08:52,610
프로그램 내에 포함.

163
00:08:52,610 --> 00:08:55,260
>> 보다 구체적으로, 다수
내가 가지고있는 기능,

164
00:08:55,260 --> 00:08:58,000
그 함수의 이름,
변수 유형

165
00:08:58,000 --> 00:09:01,730
이들 변수 및 다양한 것을
디버거를 도와 다른 것들의

166
00:09:01,730 --> 00:09:04,350
해당 작업을 수행합니다.

167
00:09:04,350 --> 00:09:06,600
이제 뭔가가있다
그 언급하는 것이 중요합니다

168
00:09:06,600 --> 00:09:10,280
때 우리가 실행을 논의하고
이러한 방식으로 프로그램.

169
00:09:10,280 --> 00:09:13,660
>> 실제로이납니다
우리의 콘솔에서 새 탭을 제기

170
00:09:13,660 --> 00:09:14,780
하단.

171
00:09:14,780 --> 00:09:18,600
우리는 더 이상 상호 작용을 할 필요가 없습니다
직접 터미널 창.

172
00:09:18,600 --> 00:09:21,420
그러나이 새 탭입니다
실제로 터미널 창.

173
00:09:21,420 --> 00:09:26,710
그냥 실행에 특정한
우리가 만든 프로그램.

174
00:09:26,710 --> 00:09:29,270
>> 에, 하단에있는 것을 주목하라
일부 출력과 함께

175
00:09:29,270 --> 00:09:33,500
컴파일러와 GDB를 연타하여,
우리는 대부분 무시 할 수있는,

176
00:09:33,500 --> 00:09:37,570
실제로의 출력을 보여줍니다
맨 아래에 우리의 프로그램.

177
00:09:37,570 --> 00:09:41,240
이제 실현하는 것이 중요합니다
실제로이 하나의 창

178
00:09:41,240 --> 00:09:43,360
당신에게 보여줄 것이다
프로그램에서 출력

179
00:09:43,360 --> 00:09:47,190
또한 입력을받을 수 있습니다
해당 프로그램뿐만 아니라.

180
00:09:47,190 --> 00:09:49,260
>> 그래서 말한다 통지
숫자를 입력하세요,

181
00:09:49,260 --> 00:09:53,050
이는 우리가 가진 동일한 출력
전에 터미널 창에서 있었다.

182
00:09:53,050 --> 00:09:55,510
그러나 이제이 새 탭에 표시합니다.

183
00:09:55,510 --> 00:09:56,550
내가 입력 할 수 있습니다.

184
00:09:56,550 --> 00:10:00,900
그리고 실제로 것
기능을 우리가 예상 한대로

185
00:10:00,900 --> 00:10:05,890
우리에게 우리의 디버그를 보여주는, 출력,
버그가있을 수 있습니다 출력,

186
00:10:05,890 --> 00:10:07,010
로 우리는 전에 본 적이.

187
00:10:07,010 --> 00:10:10,460
그리고 맨 아래에, 그것을
실제로 몇 가지 추가 출력이

188
00:10:10,460 --> 00:10:14,550
국내 총생산 (GDP)에서 불과 말하는
이 프로그램이 완료되었습니다.

189
00:10:14,550 --> 00:10:16,655
>> 지금 당신은이에서 보았 듯이
을 통해 특정 실행,

190
00:10:16,655 --> 00:10:19,370
그것은 특히 아니었다
유용도 있기 때문에

191
00:10:19,370 --> 00:10:23,740
우리가 가진하지만 디버거 메뉴가 올
업이 여전히 실행중인 프로그램이었다.

192
00:10:23,740 --> 00:10:26,790
아무 시점에서 실제로 그것을했다
우리를 위해 실행을 일시 중지

193
00:10:26,790 --> 00:10:30,767
모두를 검사 할 수 있도록
변수에 포함.

194
00:10:30,767 --> 00:10:32,850
뭔가가있다
우리는 순서대로 할 필요가 있음을

195
00:10:32,850 --> 00:10:36,910
우리가 원하는 것을 인식하는 GDB를 얻을 수
프로그램의 실행을 일시 중지

196
00:10:36,910 --> 00:10:42,820
하고 그냥 진행할 수 없습니다
일반적으로 우리가 다른 경우에서와 같이.

197
00:10:42,820 --> 00:10:45,530
>> 실행을 일시 정지하기 위해서,
일부 특정 라인에서,

198
00:10:45,530 --> 00:10:47,830
우리는 무엇을 작성해야
브레이크 포인트라고합니다.

199
00:10:47,830 --> 00:10:52,670
그리고 브레이크 포인트는 아주 쉽게 만들어
이에 마우스를 복용하여 IDE를 CS50

200
00:10:52,670 --> 00:10:57,090
그리고 왼쪽에 직접 클릭
일부 특정 라인 번호.

201
00:10:57,090 --> 00:10:59,920
내가 그렇게되면, 빨​​간 점
나타내는 나타납니다

202
00:10:59,920 --> 00:11:02,300
것을 그 선은 이제 브레이크 포인트입니다.

203
00:11:02,300 --> 00:11:07,540
>> 그리고 나는 GDB를 실행할 때, 그것을
그 브레​​이크 포인트에서 실행을 중지합니다

204
00:11:07,540 --> 00:11:10,280
그것은 코드의 라인에 도달 할 때 호출됩니다.

205
00:11:10,280 --> 00:11:12,230
지금이 중요하다
일이 실현

206
00:11:12,230 --> 00:11:16,140
그렇지 않은 것을 반드시
경우 코드의 모든 라인

207
00:11:16,140 --> 00:11:17,880
실제로 액세스 할 수 있습니다.

208
00:11:17,880 --> 00:11:23,780
나는 함수를 작성한다면
여기까지, example-- 무효 F--에 대한

209
00:11:23,780 --> 00:11:31,230
그리고 그냥 인사 here-- 인쇄 라인을
전 세계에 - 내가이 함수를 호출하지 않을 경우,

210
00:11:31,230 --> 00:11:34,770
이 경우 일 것이다,
내가 여기에 브레이크 포인트를 설정 한 경우,

211
00:11:34,770 --> 00:11:36,220
함수가 호출되지 않습니다.

212
00:11:36,220 --> 00:11:38,310
그러므로,이
특히 브레이크 포인트

213
00:11:38,310 --> 00:11:43,040
실제로 일시 정지하지 않습니다
프로그램의 실행.

214
00:11:43,040 --> 00:11:48,020
>> 그럼 내가 제대로 작성한다고 가정 해 봅시다
코드의 일부 라인에 브레이크 포인트

215
00:11:48,020 --> 00:11:50,340
이 실제로 실행됩니다.

216
00:11:50,340 --> 00:11:53,470
지금,이 경우에는, 이것이
주요 기능의 첫 번째 줄.

217
00:11:53,470 --> 00:11:56,630
그래서 그것은 확실히 경우 일 것
즉, 내가 실행을 시작하자마자,

218
00:11:56,630 --> 00:11:58,580
첫 번째 라인에 도달한다.

219
00:11:58,580 --> 00:12:00,230
GDB는 실행을 일시 중지됩니다.

220
00:12:00,230 --> 00:12:04,100
그리고, 내가 할 수있을 것입니다
디버거와 상호 작용합니다.

221
00:12:04,100 --> 00:12:08,480
>> 당신은 여러 라인을 설정할 수 있습니다
당신이 좋아하면, 중단 점.

222
00:12:08,480 --> 00:12:11,365
우리는 또한 라인을 만들 수 있습니다
여기에이 코드 세그먼트

223
00:12:11,365 --> 00:12:12,490
그 도달되지 않습니다.

224
00:12:12,490 --> 00:12:14,744
그리고 우리는 또한 아래에 더 하나를 설정할 수 있습니다.

225
00:12:14,744 --> 00:12:16,660
이유는 우리 것
우리는거야이 작업을 수행 할 수

226
00:12:16,660 --> 00:12:19,119
조금 더 들어가
잠시의 세부 사항.

227
00:12:19,119 --> 00:12:21,660
지금은 그래서, 나 그냥 사용하지 않도록하자
이러한 추가 브레이크 포인트

228
00:12:21,660 --> 00:12:24,940
우리는 무슨 일을 볼 수 있도록
나는 하나의 휴식 시간이있을 때

229
00:12:24,940 --> 00:12:27,650
내 프로그램에 포인트.

230
00:12:27,650 --> 00:12:29,410
내가 만든 몇 가지
이 프로그램에 대한 변경.

231
00:12:29,410 --> 00:12:30,750
그래서 나는 그것을 저장해야합니다.

232
00:12:30,750 --> 00:12:34,490
나는 디버그를 클릭합니다 내가 할 수 있도록
컴파일을 시작하고

233
00:12:34,490 --> 00:12:36,880
디버거의 실행.

234
00:12:36,880 --> 00:12:40,632
>> 우리는 볼 것이다, 그 순간, 후
우리는 휴식으로 선택 라인

235
00:12:40,632 --> 00:12:43,360
포인트는 노란색으로 강조 표시됩니다.

236
00:12:43,360 --> 00:12:47,440
우리는 또한에있는 것을 알 수 있습니다
디버그 패널의 오른쪽 위

237
00:12:47,440 --> 00:12:50,940
일시 정지 아이콘이 켜져 있는지
작은 재생 아이콘으로.

238
00:12:50,940 --> 00:12:54,710
이것은 우리가 일시 정지를 가지고 있다는 것을 의미
실행, 특히이 경우.

239
00:12:54,710 --> 00:12:57,840
그리고 재생 버튼을 것 타격
우리가 실행을 재개 할 수 있도록

240
00:12:57,840 --> 00:13:00,000
특정 시점에서.

241
00:13:00,000 --> 00:13:03,240
>> 다른 몇 가지가 있다는 것을 알 수 있습니다
이 디버그 패널에서 사용할 수있는 버튼,

242
00:13:03,240 --> 00:13:04,220
게다가.

243
00:13:04,220 --> 00:13:09,470
저를 허용하는 이상 단계
코드의 한 라인을 실행

244
00:13:09,470 --> 00:13:14,030
와 해당 라인을 통해 단계
이 경우 다음 하나,,,

245
00:13:14,030 --> 00:13:17,060
printf의 것을 의미
문이 실행됩니다.

246
00:13:17,060 --> 00:13:22,310
그리고 그 다음 일시 중지됩니다
그래서 같은 라인 (13)에 실행.

247
00:13:22,310 --> 00:13:25,090
>> 또한 단계있다
함수에있는

248
00:13:25,090 --> 00:13:28,950
나는 다른 만든 경우 유용합니다
다른 곳에서 소스 코드의 기능을한다.

249
00:13:28,950 --> 00:13:31,420
그리고 한 단계 씩 할
이러한 기능보다는

250
00:13:31,420 --> 00:13:33,050
전체적으로 그 기능을 실행합니다.

251
00:13:33,050 --> 00:13:37,279
그러나 우리는 단계에서 자세한 내용을 살펴 보겠습니다
잠시의 기능에.

252
00:13:37,279 --> 00:13:40,320
지금은 다른 일을 알 그
실제로이 디버그 패널 내에 존재한다.

253
00:13:40,320 --> 00:13:44,110
>> 우리는이 패널을 불렀다
이는 우리를 보여, 스택 호출

254
00:13:44,110 --> 00:13:45,300
정확히 우리가있는 곳.

255
00:13:45,300 --> 00:13:48,550
이 경우, 우리는 내부에
주요 기능.

256
00:13:48,550 --> 00:13:50,880
우리의 스크립트는 count.c이라고합니다.

257
00:13:50,880 --> 00:13:53,820
그리고 우리는에 될 일이
선 (13), 열 하나, 어떤

258
00:13:53,820 --> 00:13:58,950
무엇을 강조 영역을 정확하게
소스 코드뿐만 아니라, 나타냅니다.

259
00:13:58,950 --> 00:14:02,435
>> 지금 이것은 또한 보여줍니다 알
지역 변수 섹션에서

260
00:14:02,435 --> 00:14:06,710
변수의 모든
이 함수 내에서 존재한다.

261
00:14:06,710 --> 00:14:08,930
그것은주의하는 것이 중요합니다
변수의 모든

262
00:14:08,930 --> 00:14:12,580
이 지역 변수에 나타납니다
함수 내 섹션,

263
00:14:12,580 --> 00:14:14,380
심지어 그들이 정의하기 전에.

264
00:14:14,380 --> 00:14:19,160
우리는 우리가 변수가 그 여기에서 볼 수 있습니다
NUM 불리는 0의 디폴트 값을 가지며,

265
00:14:19,160 --> 00:14:21,280
그리고 int 타입이다.

266
00:14:21,280 --> 00:14:24,110
>> 이제 우리는 실제로 초기화하기 전에
이러한 모든 변수,

267
00:14:24,110 --> 00:14:26,685
우리는 반드시 아니에요
0의 값을 참조 보장.

268
00:14:26,685 --> 00:14:29,200
그리고 다른 실행에 따라
당신은 수행했는지

269
00:14:29,200 --> 00:14:32,020
및 메모리 때의 상태
실제로이 프로그램을 실행,

270
00:14:32,020 --> 00:14:34,605
당신은 사실을 발견했습니다
0의 값을 볼 수 없습니다

271
00:14:34,605 --> 00:14:36,550
그리고, 대신, 다른 미친 번호.

272
00:14:36,550 --> 00:14:38,390
>> 하지만 그것에 대해 걱정하지 마십시오.

273
00:14:38,390 --> 00:14:44,610
이 때까지 관련 않을거야
당신은 실제로 값을 초기화합니다.

274
00:14:44,610 --> 00:14:49,630
지금,이 경우, 우리는 그것을 볼 수있다
나는 약간의 출력을 수행했습니다.

275
00:14:49,630 --> 00:14:52,131
그리고, 지금, 실행을 일시 정지하고 있습니다.

276
00:14:52,131 --> 00:14:53,880
그러나이 경우, 어떤
정말하고 싶은

277
00:14:53,880 --> 00:14:58,060
지금이 라인을 통해 단계입니다
코드 그래서 실제로 수

278
00:14:58,060 --> 00:15:04,390
그 INT를 사용자에게 질의하는
우리는 우리의 프로그램에서 사용하고 싶습니다.

279
00:15:04,390 --> 00:15:07,060
>> 지금,이 경우에있어서, 언제
나는 통지를 통해 단계 히트

280
00:15:07,060 --> 00:15:11,940
그 대신 일시 중지하거나 다시 시작
버튼이 일시 정지 버튼으로 변경

281
00:15:11,940 --> 00:15:14,022
이 코드가 실제로 실행되기 때문이다.

282
00:15:14,022 --> 00:15:15,730
무슨 일
지금이 있다는 것이다

283
00:15:15,730 --> 00:15:21,630
입력에 우리를 위해 몇 가지 정보를 대기
우리는 우리의 출력 텍스트로 볼 수 있습니다

284
00:15:21,630 --> 00:15:23,600
맨 아래에.

285
00:15:23,600 --> 00:15:25,787
>> 그래서 지금이다
실제로 일시 정지하지,

286
00:15:25,787 --> 00:15:28,620
심지어하지만, 일종의 나타납니다
아무 일이 없기 때문에이 될 수 있습니다.

287
00:15:28,620 --> 00:15:32,360
그러나 그것은 너무 일에 그
라인 (13)에 내 특정한 경우,

288
00:15:32,360 --> 00:15:34,210
나는 사용자 입력을 기다리고 있어요.

289
00:15:34,210 --> 00:15:39,130
그래서 GDB는 검사 할 수 없습니다
그와 같은 프로그램이 실행 중입니다.

290
00:15:39,130 --> 00:15:43,370
>> 나는 몇 가지를 입력 이제 다음
input-- 그래서, 그 숫자 5를 입력합니다

291
00:15:43,370 --> 00:15:46,140
우리는 검색된로
히트 돌아 past--, 그리고 우리

292
00:15:46,140 --> 00:15:51,430
그 즉시, GDB 일시 정지를 통지
그리고, 다시, 다음 라인을 강조한다.

293
00:15:51,430 --> 00:15:55,320
그러나로, 지금을 알
우리가 값을 입력 한 결과,

294
00:15:55,320 --> 00:15:58,930
우리는 내부에 그 값을 업데이트 한
우리의 지역 변수, 어떤

295
00:15:58,930 --> 00:16:05,560
정확하게 알고 매우 유용합니다
무슨 수를하는 것은 메모리에 있었다.

296
00:16:05,560 --> 00:16:10,650
>> 지금은이 프로그램을 계속하도록 허용 할 수 있습니다
그 실행의 끝까지 재생

297
00:16:10,650 --> 00:16:12,570
이력서를 쳐서.

298
00:16:12,570 --> 00:16:16,410
우리는 매우 신속하게 볼 수 있습니다
프로그램 마무리가 실행하지

299
00:16:16,410 --> 00:16:19,790
동일한 출력이와 우리
전의, 디버거가 닫히고,

300
00:16:19,790 --> 00:16:23,170
이제이 프로그램
완전히 중지되었습니다.

301
00:16:23,170 --> 00:16:25,320
>> 내가 보여 만의 그
보고의 목적을 무엇

302
00:16:25,320 --> 00:16:27,280
우리가 실제로 다시 시작을 명중 할 때 발생합니다.

303
00:16:27,280 --> 00:16:30,640
그러나 우리는 실제로 가고있다
이 프로그램에 다시 가고 싶어

304
00:16:30,640 --> 00:16:33,820
우리가 디버깅하려고 할 수 있도록
정확히 무슨 일이 일어나고 있는지.

305
00:16:33,820 --> 00:16:37,980
내가 디버거를 사용하고 있는지 지금, 나는 할 수있다
이러한 디버그의 printf 문을 필요가 없습니다.

306
00:16:37,980 --> 00:16:43,860
>> 내가 할 것 그래서 나는 그들을 제거 할 수 있습니다
지금 우리의 간단한 코드로 돌아갑니다

307
00:16:43,860 --> 00:16:45,950
우리가 잠시 전했다고.

308
00:16:45,950 --> 00:16:48,790
지금은 저장할 때
프로그램 및이 프로그램을 실행,

309
00:16:48,790 --> 00:16:53,700
그것은, 다시, 그 초기로 이동합니다
내가 선 (11)에 미친 점을 휴식.

310
00:16:53,700 --> 00:16:57,700
그리고 검사 할 수 있습니다
내 변수는 내가하고 싶은대로.

311
00:16:57,700 --> 00:17:00,695
>> 그냥 그래서이 것을 어떻게
부분은 매우 흥미 없습니다

312
00:17:00,695 --> 00:17:04,364
그리고 내가 갈거야 알고
이 문을 인쇄합니다.

313
00:17:04,364 --> 00:17:05,280
번호를 입력하십시오.

314
00:17:05,280 --> 00:17:08,099
그리고, 내가 갈거야 알고
그 정수에 대한 사용자 요청합니다.

315
00:17:08,099 --> 00:17:13,329
그래서 아마도, 내가 실제로 이동하려는 내
아래로 조금 더 포인트를 휴식.

316
00:17:13,329 --> 00:17:16,710
>> 당신은 브레이크 포인트를 제거 할 수 있습니다
직접, 다시 클릭하여

317
00:17:16,710 --> 00:17:18,460
그 행 번호의 왼쪽.

318
00:17:18,460 --> 00:17:22,200
그 빨간 점 표시, 사라집니다
그 브레​​이크 포인트는 이제 사라지고있다.

319
00:17:22,200 --> 00:17:24,780
지금,이 경우,
실행이 일시 중지되었습니다.

320
00:17:24,780 --> 00:17:27,770
그래서 실제로는 않을거야
특정 인스턴스를 다시 시작합니다.

321
00:17:27,770 --> 00:17:30,210
하지만 휴식을 설정할 수 있습니다
조금 나중에.

322
00:17:30,210 --> 00:17:33,880
>> 그리고 지금 다시 시작하면 내
코드, 그것은 다시 시작하고 말할 것이다

323
00:17:33,880 --> 00:17:36,190
그 브레​​이크 포인트의 포인트.

324
00:17:36,190 --> 00:17:37,374
다시 말하지만, 나는 다시 시작을했다.

325
00:17:37,374 --> 00:17:39,040
어떤 일이 일어나고있는 것처럼 보이지 않는다.

326
00:17:39,040 --> 00:17:41,450
하지만 내 때문이다
코드 입력을 기다리고 있습니다.

327
00:17:41,450 --> 00:17:47,900
나는, 숫자 5를 입력 Enter 키를 누르십시오, 그리고 것
이제 다음 브레이크 포인트는 타격을받을 것입니다.

328
00:17:47,900 --> 00:17:50,570
>> 지금,이 경우, 본
코드 라인은

329
00:17:50,570 --> 00:17:53,820
것으로, 이전에, 우리는 알고 있었다
버그로 일어났다.

330
00:17:53,820 --> 00:17:57,590
그럼 무슨 일 평가하자
시간이 특정 시점에서.

331
00:17:57,590 --> 00:18:02,620
라인이 강조 표시되면,이
라인은 아직 실행되지 않았습니다.

332
00:18:02,620 --> 00:18:06,490
이 경우, 우리는 볼 수 있습니다
I는 번호를 가지고있는

333
00:18:06,490 --> 00:18:11,610
나는라는 정수가
값 (5)이 NUM.

334
00:18:11,610 --> 00:18:15,090
그리고 수행 될거야
그 수에 약간의 수학.

335
00:18:15,090 --> 00:18:20,130
>> 나는 그 이상을 밟을 경우, 우리는 할 수
NUM에 대한 그 값을 알 수

336
00:18:20,130 --> 00:18:23,780
따라서 변경된
우리가 실제로 수행 한 연산.

337
00:18:23,780 --> 00:18:26,810
그리고 지금 우리는 것을
내부 루프에 대한이의

338
00:18:26,810 --> 00:18:29,090
또는 지금 루프
그 자체가 강조 표시됩니다,

339
00:18:29,090 --> 00:18:32,450
우리는 우리가 새를 볼
변수 것을 나는라고

340
00:18:32,450 --> 00:18:35,370
루프 점에서 사용하는 것입니다.

341
00:18:35,370 --> 00:18:38,230
>> 이제 내가 전에 기억
때때로 당신이있어 언급

342
00:18:38,230 --> 00:18:43,470
미친 어떤 종류를 볼 것
그 번호 전에 기본적으로 번호

343
00:18:43,470 --> 00:18:45,530
또는 변수입니다
실제로 초기화.

344
00:18:45,530 --> 00:18:49,040
우리는 정확하게 것을 볼 수 있습니다
여기에이 변수

345
00:18:49,040 --> 00:18:51,345
되지 않은, 내가 전화
아직 초기화

346
00:18:51,345 --> 00:18:53,560
강조시.

347
00:18:53,560 --> 00:18:57,070
그러나 우리는 어떤 번호를 가지고 있음을 알 수
우리는 실제로 기대하지 않을 것이라고.

348
00:18:57,070 --> 00:18:57,620
>> 괜찮아요.

349
00:18:57,620 --> 00:18:59,661
그것에 대해 걱정하지 마십시오
우리가 실제로 가지고 있기 때문에

350
00:18:59,661 --> 00:19:04,970
나는 때까지 그 번호를 초기화
이 라인과 값을 통해 단계

351
00:19:04,970 --> 00:19:08,560
내가 값을 1로 초기화되었습니다.

352
00:19:08,560 --> 00:19:11,400
그래서 실제로 있다고 볼 수
경우는, 이제 스텝 오버 할 수 있습니다.

353
00:19:11,400 --> 00:19:14,420
우리는 지금을 볼 수
라인이 실행되었다.

354
00:19:14,420 --> 00:19:17,000
그리고 지금 우리가 강조된다
이 printf의 라인.

355
00:19:17,000 --> 00:19:22,230
>> 그리고 이제 우리는 어떻게 우리의 가치를 볼 수 있습니다
의 i와 3은 시간이 지남에 따라 변경되었습니다.

356
00:19:22,230 --> 00:19:26,450
이것은 사실, 할 매우 유용합니다,
반복 라인을 통해 단계입니다.

357
00:19:26,450 --> 00:19:30,480
그리고 당신은 어떤 사실을 찾을 수 있습니다
당신을위한 루프의 내부에 발생

358
00:19:30,480 --> 00:19:33,660
그리고 무슨 일이 일어나는
내부 루프 그 변수

359
00:19:33,660 --> 00:19:39,200
그 프로그램 실행 등
한 번에 한 단계 일어난다.

360
00:19:39,200 --> 00:19:41,110
>> 지금이 시점에서, 나는
충분한 이상 강화

361
00:19:41,110 --> 00:19:44,210
나는 지금 내 프로그램의 끝에서 오전.

362
00:19:44,210 --> 00:19:46,980
나는 그 이상 단계 경우 것
실제로 실행을 중지

363
00:19:46,980 --> 00:19:48,860
우리는 과거에 보았 듯이.

364
00:19:48,860 --> 00:19:52,110
그래서, 나를 다시 한번,이를 다시 시작하자
내가 뭔가를 지적 할 수있는,

365
00:19:52,110 --> 00:19:53,320
게다가.

366
00:19:53,320 --> 00:19:55,350
>> 이 경우, 인
지금 다시, 나 한테 물어,

367
00:19:55,350 --> 00:19:57,100
수에 대한 어떤
나는 다시 입력합니다.

368
00:19:57,100 --> 00:20:00,300
하지만이 시간, 나는에 입력거야
더 많은 수 있도록 루프

369
00:20:00,300 --> 00:20:02,540
번 이상 반복합니다.

370
00:20:02,540 --> 00:20:06,090
이 경우, 내가 갈거야
(11)의 값을 입력합니다.

371
00:20:06,090 --> 00:20:08,390
>> 이제 다시 내가 설정 한 것 때문에
라인 15에서 중단 점,

372
00:20:08,390 --> 00:20:10,490
그것은 그 라인을 강조하는 것입니다.

373
00:20:10,490 --> 00:20:12,980
우리가 볼 수있는 우리의
숫자 11은 제대로입니다

374
00:20:12,980 --> 00:20:15,560
우리의 지역 변수로 표현.

375
00:20:15,560 --> 00:20:22,460
우리는 지금, 그 동안 수 스테핑
나는 우리의 값으로 무슨 시계

376
00:20:22,460 --> 00:20:25,680
우리는 루프이 안에 진행하는.

377
00:20:25,680 --> 00:20:31,960
이 때마다 우리를 증가됩니다
루프에 대한 그의 상단에 도달.

378
00:20:31,960 --> 00:20:35,110
>> 것들 중 하나 이제 수도
실행하는 동안 수행하는 것이 유용 할 수

379
00:20:35,110 --> 00:20:40,490
이 프로그램의 사실에 저를 위해입니다
볼 수있는 변수 중류 변경

380
00:20:40,490 --> 00:20:42,450
어떻게 내 프로그램에 발생합니다.

381
00:20:42,450 --> 00:20:46,540
이 경우, 실제로 수
두 값을 누릅니다.

382
00:20:46,540 --> 00:20:48,040
이 텍스트 필드하게 알 수 있습니다.

383
00:20:48,040 --> 00:20:50,280
>> 지금은 다른 입력 할 수 있습니다
모두 가치

384
00:20:50,280 --> 00:20:55,700
내 프로그램의 동작을 볼 수 있습니다
그 변수를 변경 한 경우.

385
00:20:55,700 --> 00:20:59,560
지금,이 경우, 가변
난 이제 값 (10)을 포함한다.

386
00:20:59,560 --> 00:21:02,810
그러나 프로그램은 여전히
실행에 일시 중지되었습니다.

387
00:21:02,810 --> 00:21:07,610
내가 통해 단계 때, 나는 것을 볼 수
나는 10로 입력 값 (I),,

388
00:21:07,610 --> 00:21:12,170
, NUM의 값보다 크지
이는 바로 루프 원인

389
00:21:12,170 --> 00:21:14,240
실행을 중지합니다.

390
00:21:14,240 --> 00:21:16,210
>> 이제 유일한 아니다
이유는 것

391
00:21:16,210 --> 00:21:19,450
대신에 변수를 수정할.

392
00:21:19,450 --> 00:21:22,210
당신은 실제로 할 수 있습니다
그것을 그렇게 수정하려고합니다

393
00:21:22,210 --> 00:21:24,590
당신은 계속할 수
루프의 실행

394
00:21:24,590 --> 00:21:27,370
나 때문에 당신은 수정할 수 있습니다
그 전에 몇 가지 값

395
00:21:27,370 --> 00:21:32,630
연산의 일부 특정 세트에 도달
당신이 수행 할 예정임을.

396
00:21:32,630 --> 00:21:36,210
>> 그래서 지금 우리가 실제로 변경하는 것이
프로그램으로서의 I의 값은, 실행되고있는

397
00:21:36,210 --> 00:21:39,540
그것은 루프 종료 발생
조기에 나는 갑자기 때문에

398
00:21:39,540 --> 00:21:42,770
값보다 커야 우연히
NUM의 루프에 대한 그 의미

399
00:21:42,770 --> 00:21:45,410
더 이상 실행할 필요가 없다.

400
00:21:45,410 --> 00:21:48,780
또한,이 우연히
우리는 i 값을 변경하는 경우

401
00:21:48,780 --> 00:21:53,270
라인 (17)이 강조 될 때,
시점이었다

402
00:21:53,270 --> 00:21:56,280
그 루프 실행을위한
실제로 평가되고 있었다.

403
00:21:56,280 --> 00:22:00,210
>> 나는 값을 변경 한 경우
나는 다른 회선에서, 19 말

404
00:22:00,210 --> 00:22:03,360
우리는 다른 보았을 것
행동 라인 (19) 때문에

405
00:22:03,360 --> 00:22:08,310
루프 전에 실행 한
조건은 재평가되었다.

406
00:22:08,310 --> 00:22:11,900
지금이 시점에서, 난 다시,
이 프로그램의 끝.

407
00:22:11,900 --> 00:22:15,707
그리고 나는 이것이를 진행하도록 할 수 있습니다
내 프로그램 자연적으로 종료 할 수 있습니다.

408
00:22:15,707 --> 00:22:18,290
그러나 몇 가지있다
멀리하는 것이 중요하다 그

409
00:22:18,290 --> 00:22:19,960
이 특별한 토론에서.

410
00:22:19,960 --> 00:22:22,490
당신은 평가해야
당신의 자신의 가정

411
00:22:22,490 --> 00:22:24,710
방법에 대한 코드는 행동해야한다.

412
00:22:24,710 --> 00:22:28,220
때마다 당신은 어떤 부분이라고 생각
당신이 알고있는 코드가 작동하는 일에,

413
00:22:28,220 --> 00:22:30,940
그 갈 붉은 깃발 수 있습니다
다시 및 평가하고, 확인

414
00:22:30,940 --> 00:22:33,470
당신의 가정이
어떻게 코드가 작동

415
00:22:33,470 --> 00:22:38,290
그것이 얼마나 실제로 사실이다
소스 코드로 표현.

416
00:22:38,290 --> 00:22:41,300
>> 그러나 점에 더이었다,
우리는 디버거를 사용하는 경우,

417
00:22:41,300 --> 00:22:43,920
당신은 중단 점을 넣을 수 있습니다
코드의 다른 라인,

418
00:22:43,920 --> 00:22:48,110
디버거의 원인이되는
그 라인의 각에서 실행을 일시 중지

419
00:22:48,110 --> 00:22:52,210
그래서 당신을 평가 할 수있는
메모리 또는 장소에 변경합니다.

420
00:22:52,210 --> 00:22:55,630
그리고 또, 당신이 할 수있는 것을 기억
여러 개의 브레이크 포인트를 만들 수 있도록

421
00:22:55,630 --> 00:23:00,390
또한 실행을 재개 할 수 있습니다, 이동
코드의 많은 부분을 통해,

422
00:23:00,390 --> 00:23:04,790
그것은 자동으로 일시 정지합니다
다음 브레이크 포인트에서.

423
00:23:04,790 --> 00:23:07,760
>> 실제로 고급있다
디버거의 기능뿐만 아니라.

424
00:23:07,760 --> 00:23:10,170
그러나 우리는 당신을 참조해야합니다
일부 이후의 동영상

425
00:23:10,170 --> 00:23:14,090
정말 얼마나 떨어져 애타게하기 위해
그 특정 기능을 사용할 수 있습니다.

426
00:23:14,090 --> 00:23:15,990
지금, 감사합니다
시청 아주 많이.

427
00:23:15,990 --> 00:23:18,080
그리고 행운 디버깅.