1
00:00:00,000 --> 00:00:02,200
[Powered by Google Translate] [주 3]

2
00:00:02,200 --> 00:00:03,950
[데이비드 J. Malan - 하버드 대학교 (Harvard University)]

3
00:00:03,950 --> 00:00:07,140
[이 CS50입니다. - CS50.TV]

4
00:00:07,140 --> 00:00:10,720
내가 우리가 지난 번에 그만 둔 곳으로의 방향을 조종하자

5
00:00:10,720 --> 00:00:13,890
구문에 대한보다 조금 더 생각하기 시작 한

6
00:00:13,890 --> 00:00:17,150
그리고 사소한 모든에 대해 좀 덜 생각하는

7
00:00:17,150 --> 00:00:20,630
그 세미콜론의 관점에서 지금까지에 적응하려면 시간이 좀 걸립니다

8
00:00:20,630 --> 00:00:22,360
괄호와 중괄호,

9
00:00:22,360 --> 00:00:25,630
높은 개념 수준으로 일들을 좀 복용 시작

10
00:00:25,630 --> 00:00:28,800
그래서 지금 우리가 앞으로 몇 주 동안 해결 시작 문제

11
00:00:28,800 --> 00:00:32,340
높은 수준의 개념적 문제에 훨씬 더를 포함 거에요

12
00:00:32,340 --> 00:00:36,310
그리고 발에가 거든 구문에 덜 약간 서부 유럽 표준시

13
00:00:36,310 --> 00:00:40,090
손으로 지난 몇 주에서 구문의 일부 더러워.

14
00:00:40,090 --> 00:00:43,690
>> 지난 주에 우리가 배열의 개념을 도입하도록 기억합니다.

15
00:00:43,690 --> 00:00:49,320
그리고 영어로 된 배열은 무엇으로 설명 할 수 있습니까? >> [안 들리게 학생 응답]

16
00:00:49,320 --> 00:00:51,710
뭐라고 요?

17
00:00:51,710 --> 00:00:54,810
의 수집? >> [안 들리게 학생 응답] >> 그래, 좋아.

18
00:00:54,810 --> 00:00:57,820
항목의 모음입니다. 그래서 우리는 스크래치에서 배열을 보았다.

19
00:00:57,820 --> 00:01:01,880
당신은 pset에 대해 당신이 일을 드래그 할 수있는 스크래치의 목록 0 하나를 사용하는 일 경우

20
00:01:01,880 --> 00:01:05,410
종류의 인벤토리에 오렌지와 바나나 같은

21
00:01:05,410 --> 00:01:07,100
그 배열이 무엇처럼 가지입니다.

22
00:01:07,100 --> 00:01:10,980
그리고 더 기술적으로, 실제 컴퓨터의 맥락에서,

23
00:01:10,980 --> 00:01:14,730
배열은 단순히 메모리의 연속 된 덩어리입니다.

24
00:01:14,730 --> 00:01:18,590
즉, 그때 그때 다음 다른 바이트, 다른 바이트, 다른 바이트, 바이트가

25
00:01:18,590 --> 00:01:21,330
당신은 사진에 그 바이트를 그릴 할 경우,

26
00:01:21,330 --> 00:01:24,510
그들은 백업 백업 백업 다시 것입니다. 우리가 연속으로 뜻입니다.

27
00:01:24,510 --> 00:01:26,690
>> 그럼 다음엔 바이트 숫자 1, 2, 3입니다.

28
00:01:26,690 --> 00:01:29,680
그것은, 최대 여기, 여기, 여기 여기 의미하지 않는다.

29
00:01:29,680 --> 00:01:33,800
배열은 0 개 이상의 바이트의 연속 된 덩어리입니다.

30
00:01:33,800 --> 00:01:36,160
그럼 그들이 유용입니까?

31
00:01:36,160 --> 00:01:40,090
우리는 프로그램에 저장 사람들의 퀴즈 등급의 인위적인 예를 들어 이러한 종류의를 가지고 기억

32
00:01:40,090 --> 00:01:42,580
일부 과정에 대한 퀴즈 평균을 계산하려면

33
00:01:42,580 --> 00:01:46,780
우리는 변수 quiz1를 선언하여 해당 프로그램을 작성할 수 있다는 기억합니다.

34
00:01:46,780 --> 00:01:49,550
그럼 우리가 quiz2라는 또 다른 변수가있을 수 있습니다.

35
00:01:49,550 --> 00:01:52,030
하지만,이 클래스에서 퀴즈 quiz4 3가 있다면.

36
00:01:52,030 --> 00:01:55,710
아니면 매주 퀴즈가 있다고한다면, 그것은, quiz7 quiz6 quiz5 것입니다.

37
00:01:55,710 --> 00:01:58,520
그래서이 변수의 모든 주요 내부 선언했을

38
00:01:58,520 --> 00:02:00,470
또는 다른 프로그램에서

39
00:02:00,470 --> 00:02:03,870
그 접근 방식과 문제는, 그냥 복사 붙여 넣기 쉽게하지만

40
00:02:03,870 --> 00:02:06,120
그냥 매우 빨리 무거워집니다되어 있습니다.

41
00:02:06,120 --> 00:02:09,360
맙소사 당신은 실제로 30 퀴즈 50 퀴즈 있습니다.

42
00:02:09,360 --> 00:02:12,080
이 고등학교 스타일 매일 팝업 퀴즈처럼, 경우

43
00:02:12,080 --> 00:02:15,910
다음은 변수가 선언되는 터무니 긴 목록을 가지고

44
00:02:15,910 --> 00:02:17,780
이는 매우 빠른 속도로 제어가됩니다.

45
00:02:17,780 --> 00:02:20,820
추한, 그것을 유지하기는 어렵지만, 그 오타를 만들기 위해 훨씬 쉽게

46
00:02:20,820 --> 00:02:23,910
당신이한다면 한 번호는 프로그램에 어딘가에 잘못 입력.

47
00:02:23,910 --> 00:02:26,800
>> 그래서 우리는 대신 배열의 개념을 도입했습니다.

48
00:02:26,800 --> 00:02:30,760
그리고 우리가이 같은 작은 선물을함으로써이 프로그램을 구현하는 기억.

49
00:02:30,760 --> 00:02:33,950
나 오늘날의 소스 3 월요일 디렉토리에 가자

50
00:02:33,950 --> 00:02:37,160
그리고 우리가 마지막으로 본 배열을 엽니 다.

51
00:02:37,160 --> 00:02:39,940
그리고 새로운 C의 마술을 몇 여기에 있었다하더라도,

52
00:02:39,940 --> 00:02:41,920
그 중 상수의 개념,

53
00:02:41,920 --> 00:02:47,140
우리가이 구문을 사용하여 기본적으로 여러 수레를 선언 한 기억 :

54
00:02:47,140 --> 00:02:51,750
부동 한 다음 변수의 이름은 다음 우리는 처음으로 정말 사각 괄호를 사용

55
00:02:51,750 --> 00:02:55,450
우리가 그 사각형 괄호 안에 무슨 짓을 효과적으로 번호를 넣어했습니다.

56
00:02:55,450 --> 00:02:59,780
대신 번호를 타듯이,이 대문자 단어 퀴즈를 넣어.

57
00:02:59,780 --> 00:03:03,220
그리고 퀴즈와 같은 대문자 단어를 넣어에 대한 동기 부여 뭔지

58
00:03:03,220 --> 00:03:08,170
그리고 라인 17의 트릭을 사용하여 이곳에 있다는에게 전화 번호를 알려 하는가?

59
00:03:08,170 --> 00:03:11,240
이 동기는 무엇입니까? 그래.

60
00:03:11,240 --> 00:03:13,360
>> [안 들리게 학생 응답] >> 맞아.

61
00:03:13,360 --> 00:03:16,630
우리가 그 값 2을 변경하려면, 우리는 한 곳에서 변경해야

62
00:03:16,630 --> 00:03:19,680
때문에 고려 - 내가 이런 프로그램이 정확히 무슨 짓을했는지 기억이 안나요,

63
00:03:19,680 --> 00:03:22,040
하지만 당신은 그걸 그냥 탈지 경우 퀴즈, 퀴즈를 참조하십시오.

64
00:03:22,040 --> 00:03:24,720
당신은 퀴즈, 거기에 더 퀴즈를 참조하십시오.

65
00:03:24,720 --> 00:03:28,180
우리가이 일정하지 않은면, 날카로운의 사용 정의

66
00:03:28,180 --> 00:03:33,320
우리는 고급입니다 다음 2, 2, 2, 2를 입력 한 것입니다. 그냥 같은 올바른 것입니다.

67
00:03:33,320 --> 00:03:36,220
하지만 우리가 CS50에서 3 퀴즈을 갖고 내년 같아요.

68
00:03:36,220 --> 00:03:39,190
제가 코드를 가서 업데이트해야 할 그래서, 난 그것을 다시 컴파일해야

69
00:03:39,190 --> 00:03:43,820
제가 멍청한 짓을 경우 2 1 언급을 내려다보고처럼하지만 문제는,

70
00:03:43,820 --> 00:03:46,750
3로 연결 잊어, 전체 프로그램은 잘 깨 트릴 수있을거야.

71
00:03:46,750 --> 00:03:48,720
그래서 우리는 단지 문제가 요구하고 있습니다.

72
00:03:48,720 --> 00:03:53,170
>> 그래서 상수의 개념은 데이터의 일부 부분에서 고려해 중요하다

73
00:03:53,170 --> 00:03:56,070
그것은 문자열이나 문자 또는 부동 또는 뭐든 여부

74
00:03:56,070 --> 00:04:00,070
당신이 더 쉽게 미래에서 변경할 수 있도록 그것을 한 곳을 선언.

75
00:04:00,070 --> 00:04:03,660
그리고, 당신은 지금이 생각하는 경우 때문에 읽기, 솔직히, 또한 조금 쉽게

76
00:04:03,660 --> 00:04:07,840
이 퀴즈, 아니면 우리는 NUMBER_OF_QUIZZES처럼 뭔가 이름을 변경 할 수

77
00:04:07,840 --> 00:04:09,430
더 명시 적 또는 무언가.

78
00:04:09,430 --> 00:04:11,830
이 코드는, 이것의 일들을 좀 더 명확된다

79
00:04:11,830 --> 00:04:15,780
당신은 숫자 2는 의미 무슨 일이 일어날 지 약간 덜 궁금하다.

80
00:04:15,780 --> 00:04:18,920
배열을 근본적으로 아무 상관이없는 상수는 그럼.

81
00:04:18,920 --> 00:04:22,990
배열은 이러한 사각 괄호에 의해 도입되었다.

82
00:04:22,990 --> 00:04:26,610
>> 그러니까 줄 23 우리는 사용자가 요청하는 것을, "퀴즈 점수는 무엇입니까?"

83
00:04:26,610 --> 00:04:31,120
그런 다음 우리는 분명 자신의 성적에 대한 사용자 요청이 루프가 있습니다. 어떻게해야합니까?

84
00:04:31,120 --> 00:04:37,460
이 0에서 2로 반복. 모두 대문자로 퀴즈는 현재 2 때문에 나는 2 말한다.

85
00:04:37,460 --> 00:04:42,310
그래서가 0에서 2로 반복 다음은 인쇄 아웃, # 무언가 무언가를 퀴즈

86
00:04:42,310 --> 00:04:45,830
다음은 사용자로부터 값을 얻을 GetFloat를 사용합니다.

87
00:04:45,830 --> 00:04:49,050
그래서 마지막 수요일 구문의 유일한 다른 새로운 작품입니다납니다.

88
00:04:49,050 --> 00:04:53,120
당신은 그 배열의 특정 위치에 무언가를 저장하려는 경우

89
00:04:53,120 --> 00:04:55,460
다시 대괄호를 사용합니다.

90
00:04:55,460 --> 00:04:57,030
>> 따라서 이분법 약간은 여기있다.

91
00:04:57,030 --> 00:04:59,040
당신은 대괄호를 사용하여 처음으로

92
00:04:59,040 --> 00:05:02,250
당신은 당신이 배열되고 싶어 얼마나 큰 지정 사용합니다.

93
00:05:02,250 --> 00:05:06,580
하지만 여기이 다음 상황에 맞는 우리 다시는이 대괄호를 고용 곳

94
00:05:06,580 --> 00:05:10,540
그 배열에 당신이 어떤 값을보고 싶어 어디서 뜻 이죠?

95
00:05:10,540 --> 00:05:13,650
여기 구별은 문맥에서 유추 할 수 있습니다.

96
00:05:13,650 --> 00:05:17,130
우리는 데이터 형식이 있어요주의, 우리는, 변수의 이름이

97
00:05:17,130 --> 00:05:20,770
그러면 우리는 세미콜론, 내부 번호로 우리의 광장 교정기가 있습니다. 그게 전부 야.

98
00:05:20,770 --> 00:05:22,290
그래서 그런 선언입니다.

99
00:05:22,290 --> 00:05:28,390
부동 grade2, 우리가 부동 grade1 같은 짓을 한 것처럼 있지만입니다;

100
00:05:28,390 --> 00:05:31,730
하지만 다시이 매우 빠른 속도로 너무 많이 복사, 붙여 넣기로 devolves

101
00:05:31,730 --> 00:05:34,260
대신에 우리는 이러한로 단순화

102
00:05:34,260 --> 00:05:38,800
이는 금후 우리가 받침대 0 저장 될 수 있습니다 등급을 수 있다는 것을 의미합니다

103
00:05:38,800 --> 00:05:41,760
우리는 브라켓 1에서 저장 될 수있는 다른 등급을 가지고

104
00:05:41,760 --> 00:05:46,890
하지만 내가 바보짓한다면 있으며, 예를 들어, 내 루프는 멀리 가지 못합니다 -

105
00:05:46,890 --> 00:05:48,740
예를 들어, 난이보다 작거나 같 확인

106
00:05:48,740 --> 00:05:50,620
어떤 리콜 이전 버그의 원인 이었어 -

107
00:05:50,620 --> 00:05:55,590
이는 효과적으로 루프의 일부 세번째 실수 반복에 그 의미

108
00:05:55,590 --> 00:06:00,380
나는 브래킷 2를 사용하십시오. 사실, 무슨 일이됩니까? 뭐라고 요?

109
00:06:00,380 --> 00:06:02,860
[학생]은 교체 할거야. >>는 교체 할 예정입니까?

110
00:06:02,860 --> 00:06:04,520
무엇을 교체 할까요?

111
00:06:04,520 --> 00:06:10,890
이 그대로 GetFloat의 반환 값으로 위치 2 무엇 교체 말하고 있습니다.

112
00:06:10,890 --> 00:06:13,690
그러나 문제는 그 이야기의이 시점에서 배열 얼마나 크합니까?

113
00:06:13,690 --> 00:06:17,730
[안 들리게 학생 응답] >> 배열 크기는 (2)의 아직

114
00:06:17,730 --> 00:06:22,730
우리가 그것을 사용하기 전에 배열 때문에, 모든 변수처럼, 먼저 선언

115
00:06:22,730 --> 00:06:27,220
우리 때문에 내가 놓을 게는 2 등급을 가지고이 상수 여기에 지정된.

116
00:06:27,220 --> 00:06:29,930
>> 그러나 기억, 컴퓨터 과학자들은 0부터 카운트 시작합니다.

117
00:06:29,930 --> 00:06:33,620
그래서 배열의 첫 번째 위치는 브래킷 0입니다.

118
00:06:33,620 --> 00:06:40,210
다음 위치는 1입니다. 이 것은쪽으로 너무 멀리 아무리 약간 있습니다.

119
00:06:40,210 --> 00:06:42,870
다시 말해, 사실이 배열이 있다면 -

120
00:06:42,870 --> 00:06:46,790
이 날이 우리를 위해 여기에 협력 얼마나 잘 보자 -

121
00:06:46,790 --> 00:06:52,360
제가 배열이있는 경우 간단하게 다음과 같이 도출 한

122
00:06:52,360 --> 00:06:56,750
내가이 요소에 대한 공간을 할당 한 I는 메모리에서이처럼 그려 수

123
00:06:56,750 --> 00:06:58,020
커다란 흰 캔버스가입니다.

124
00:06:58,020 --> 00:07:00,920
그건 그냥 내 컴퓨터에있는 RAM, RAM의 공연, RAM 2 기가, 뭐가 있건간에

125
00:07:00,920 --> 00:07:05,400
하지만이 두 상자는 이제 개별적으로 부동, 32 비트를 나타냅니다.

126
00:07:05,400 --> 00:07:10,860
제가 1.0처럼 여기 한 번호를 넣어면, 그럼 내가 3.2처럼 여기 다른 번호를 넣어

127
00:07:10,860 --> 00:07:15,280
하지만 난 여기를 넣어 같은 브라켓 2, 마십시오.

128
00:07:15,280 --> 00:07:17,820
그림에서 알 수 있듯이 그리고 아무 것도 없습니다.

129
00:07:17,820 --> 00:07:20,450
제가 운영 체제를 요구하지 않았기 때문에 그것은 무인의 땅과 같은 종류의입니다

130
00:07:20,450 --> 00:07:23,550
저에게이 세 번째 퀴즈를 제공합니다.

131
00:07:23,550 --> 00:07:26,940
그 세번째 퀴즈를 원하는 그랬다면, 나는 사전의 고려가 있었해야합니다

132
00:07:26,940 --> 00:07:31,700
선언하여의 운영 체제를 부탁 것은이 될 퀴즈

133
00:07:31,700 --> 00:07:34,210
대신 3 동일합니다.

134
00:07:34,210 --> 00:07:39,000
>> 다시 말해, 우리는 효과적으로 손에 가지고있는 사진은 여기 것 같습니다.

135
00:07:39,000 --> 00:07:42,260
다시는 무인의 땅입니다. 우리는 여기가 더 나은 값을 쓰고 없습니다.

136
00:07:42,260 --> 00:07:45,300
다시 한 번, 컴퓨터 과학자 때문에, 0을 기준으로

137
00:07:45,300 --> 00:07:49,520
우리가 배열에이 위치에 대해 이야기 할 때, 그는 위치 0 거였어

138
00:07:49,520 --> 00:07:53,890
이것은 위치 하나 있어야되고,이 존재하지 않습니다

139
00:07:53,890 --> 00:07:57,380
우리는이 같은 장소에 운영 체제를 묻는 때문입니다.

140
00:07:57,380 --> 00:08:00,130
다른 언어의 사전 프로그래밍 경험을 가진 분들 자

141
00:08:00,130 --> 00:08:04,150
이 항상 벡터라는 배열이나 물건의 경우 않다는 것을 알고 있습니다.

142
00:08:04,150 --> 00:08:06,930
오히려, 당신은 단지, 추가 및 추가하고 배열 ​​물건을 추가 유지할 수

143
00:08:06,930 --> 00:08:10,720
하는, 솔직히, 우리는 스크래치에 그런 능력이 있다면 아직 우리는 여기를 끼친 것 같아서

144
00:08:10,720 --> 00:08:15,160
C와 때문에 훨씬 더 명시 적으로 프로그래밍되어 있습니다.

145
00:08:15,160 --> 00:08:17,980
그것은 지금 당신과 컴퓨터 만이고, 컴퓨터는 할거야

146
00:08:17,980 --> 00:08:19,530
넌 뭘 할 해주세요.

147
00:08:19,530 --> 00:08:24,270
만 여기에 라인 22에 의해 당신에게 두 수레를 제공 할 말한다면은,

148
00:08:24,270 --> 00:08:27,640
2 공간 : 그 말은 당신이 운영 체제에서 돌려 주겠다 전부 야.

149
00:08:27,640 --> 00:08:34,049
>> 따라서 점점 더 당신의 프로그램은 경우에 따라 배열에 관한 버그가 될 것이다.

150
00:08:34,049 --> 00:08:37,520
이것은 우리 모두가 실수하기도 하죠 상기 짐승의 성격 뿐이에요이며,

151
00:08:37,520 --> 00:08:42,490
그리고 어떤 점 에선 당신은 배열의 경계 너머 가능성 인덱스 것이다.

152
00:08:42,490 --> 00:08:45,980
그래서 당신이 브래킷 뭔가에 들어갔다 말하는 멋진 방법

153
00:08:45,980 --> 00:08:49,970
뭔가를 숫자의 너무 큰했습니다. 당신은 배열의 범위를 넘어 갔다.

154
00:08:49,970 --> 00:08:51,530
그러나 거꾸로 지금이 있습니다.

155
00:08:51,530 --> 00:08:54,990
이 프로그램의 나머지 부분은 정말 배열과 근본적으로 아무 상관이 없습니다.

156
00:08:54,990 --> 00:08:58,180
단지 컴퓨팅 평균에 대한 간단한 산술에 대한 거예요.

157
00:08:58,180 --> 00:09:03,200
그럼 우리가 여기 루프 우리는 0으로 초기화되는 변수라는 합계를 여기서의 수 있습니다.

158
00:09:03,200 --> 00:09:09,020
그럼 우리가 다시 0에서 2로 반복하고 우리는 그 합류 변수에 추가

159
00:09:09,020 --> 00:09:12,620
i 번째 등급, 그래서 브래킷 0 다음 브래킷 1.

160
00:09:12,620 --> 00:09:15,130
그리고 당신은 평균을 계산하는 초등학교에서하는 것처럼

161
00:09:15,130 --> 00:09:19,420
우리가 단순히 그 금액을, 퀴즈의 총 수로 나누면

162
00:09:19,420 --> 00:09:22,520
그리고 좋은 측정을 위해 우리는 원형 불리는 함수를 호출하십시오.

163
00:09:22,520 --> 00:09:28,580
>> 지금, 옆으로, 선 34에이 삽입구 INT와 거래는 무엇인가?

164
00:09:28,580 --> 00:09:31,730
이 섹션에서 이미 온 것, 정말, 공식적으로 여기에 대해 얘기하지 않은

165
00:09:31,730 --> 00:09:35,210
하지만 parens 아마도 일이 정수는 무엇인가? >> [안 들리게 학생 응답]

166
00:09:35,210 --> 00:09:38,500
네,이 주조 또는 typecasting을 의미합니다

167
00:09:38,500 --> 00:09:41,690
이는 한 데이터 형식을 복용하고 다른로 변환을 의미합니다.

168
00:09:41,690 --> 00:09:45,400
가끔 좀 이상한 것 때문에 모든 데이터 유형과이 작업을 수행 할 수 없습니다.

169
00:09:45,400 --> 00:09:49,640
그러나이 경우 경우 원형의 반환 값은 부동이다

170
00:09:49,640 --> 00:09:53,880
때문에,이 같은 모든 후, 나는 수레을 데리고 수로 나누어

171
00:09:53,880 --> 00:09:55,840
나는 수레를 돌려받을거야.

172
00:09:55,840 --> 00:10:00,760
그러나 초등학교 사람들이 평균 93.4 있다는 사실을 알게되어 정말 싫어

173
00:10:00,760 --> 00:10:04,420
그들이 경험 해보지 못한 실현할 수 있기 때문에 그 95 반올림 지점에 인접 해 있습니다.

174
00:10:04,420 --> 00:10:09,540
>> 그래서 우리는 대신 가장 가까운 int로 모두를 반올림하기 위해 정수를 사용하려면

175
00:10:09,540 --> 00:10:12,730
그 후에는 포인트로 94 될 것입니다이 경우된다.

176
00:10:12,730 --> 00:10:14,530
그럼 그냥 약간의 수학적 트릭입니다.

177
00:10:14,530 --> 00:10:17,570
이 영향을 미칠 것이기 때문에 우리는, 주조의 개념에 돌아 오면

178
00:10:17,570 --> 00:10:21,640
당신이 이미 발견하지 않은 경우, 문제에 대해 2를 설정합니다.

179
00:10:21,640 --> 00:10:25,210
배열 한 다음 그래서, 당신은 생각할 수 - 나 하루 종일 미소를 만드는거야.

180
00:10:25,210 --> 00:10:27,830
당신이 그림을 그릴 경우,이 모양

181
00:10:27,830 --> 00:10:31,460
하지만 키의 크기도 귀하가 선택되어 있습니다

182
00:10:31,460 --> 00:10:34,050
당신은 운영 체제에서 요청할 때.

183
00:10:34,050 --> 00:10:39,460
다음 질문 배열에? 그래.

184
00:10:39,460 --> 00:10:47,080
[안 들리게 학생 질문]

185
00:10:47,080 --> 00:10:49,310
아, 좋은 질문입니다.

186
00:10:49,310 --> 00:10:53,150
질문은 배열의 null이 0으로 무슨 일입니까? 그것은이 컨텍스트에 존재하지 않습니다.

187
00:10:53,150 --> 00:10:57,430
그건 단지 우리가 순간에에 와서 할 겁니다 문자열의 맥락에서 존재합니다.

188
00:10:57,430 --> 00:11:02,300
그러나 배열이 경우에서와 같이, 당신이 얻을 모든 당신이 운영 체제를시키는대로입니다.

189
00:11:02,300 --> 00:11:04,050
>> 그리고 옆,이 불분명하지 않는다면, 등

190
00:11:04,050 --> 00:11:07,030
당신이 운영 체제를 요청할 말을 계속, 운영 체제를 바랍니다.

191
00:11:07,030 --> 00:11:10,090
운영 체제, 당신은 아마 알다시피, 맥 OS, 윈도우, 리눅스입니다.

192
00:11:10,090 --> 00:11:13,560
당신은 GetFloat 같은 함수를 호출 할 때

193
00:11:13,560 --> 00:11:19,280
또는 당신은 성적과 같은 변수를 선언 아르

194
00:11:19,280 --> 00:11:23,200
하루의 끝에서 당신은 효과적으로 다른 사람이 당신에게 기억을 제공하기 위해 요청하는

195
00:11:23,200 --> 00:11:25,940
우리는 프로그래머 상승하는 때문에

196
00:11:25,940 --> 00:11:28,800
실제로 메모리에 물리적으로 액세스하는 방법을 모르겠어요.

197
00:11:28,800 --> 00:11:31,100
하지만 누군가는 않습니다 : 운영 체제를.

198
00:11:31,100 --> 00:11:36,630
따라서 외에 아름다운 아이콘 및 메뉴 및 폴더를 보내 제시하고 같은

199
00:11:36,630 --> 00:11:39,050
당신은 Mac이나 PC 상관없이 바탕 화면에 표시되는

200
00:11:39,050 --> 00:11:42,240
운영 체제는 또한 낮은 수준 평범한 일을

201
00:11:42,240 --> 00:11:44,680
기가바이트을 관리하는 고도의 기술 콘텐츠

202
00:11:44,680 --> 00:11:48,780
또는 가지고 메모리 2GB의, 당신이 가지고있는 CPU를 관리 등등.

203
00:11:48,780 --> 00:11:50,170
당신은 코드를 작성하는 자 할 때

204
00:11:50,170 --> 00:11:53,900
당신은 정말 의미에서 사용중인 운영 체제에 했는데요.

205
00:11:53,900 --> 00:11:55,720
난을 최소화해야 겠어. 괜찮아요.

206
00:11:55,720 --> 00:11:59,980
>> 배열에 대한 또 다른 질문 있나?

207
00:12:00,330 --> 00:12:02,520
아냐? 좋아요.

208
00:12:02,520 --> 00:12:06,680
따라서 전환 자연스럽게 배열에서 조금 잘 알고 주제에 실제로있다.

209
00:12:06,680 --> 00:12:09,570
그리고 우리가 너무이 마지막 시간에 이렇게 간단히 다시 보았다.

210
00:12:09,570 --> 00:12:12,500
이 수요일에서 문자열의 예이었다.

211
00:12:12,500 --> 00:12:15,060
이 문자열 예는 아주 간단한 프로그램이었습니다

212
00:12:15,060 --> 00:12:18,120
그리고 사실은 오늘날의 목적을 위해 선 몇하여 단순화했습니다.

213
00:12:18,120 --> 00:12:22,680
이 라인 (19)에 이라곤, 사용자의 문자열을 얻을 수 있습니다 S라는 변수에 저장합니다.

214
00:12:22,680 --> 00:12:28,670
그런 다음 줄 22 이후에 무리가 라인 당이 스트링 1 문자를 출력있어.

215
00:12:28,670 --> 00:12:30,730
하지만 어떻게 이런 짓을하는 거지?

216
00:12:30,730 --> 00:12:33,350
우리는 0 동등한를 설정 변수 i를 선언하고

217
00:12:33,350 --> 00:12:35,770
이 지금은 오래된 습관되고 있습니다.

218
00:12:35,770 --> 00:12:39,270
우리는 수요일까지이 보지 못했지만, 당신은 그 이름에서 추론 종류의 수

219
00:12:39,270 --> 00:12:44,610
나 strlen은 S가 주어 졌을 때 무엇을 반환? 문자열의 길이입니다.

220
00:12:44,610 --> 00:12:47,940
내가 한 문자열, 견적 - 인용을 끝 맺다 DAVID를 통과한다면

221
00:12:47,940 --> 00:12:51,810
그것은 희망 내겐 다윗의 숫자 5를 반환하는거야.

222
00:12:51,810 --> 00:12:55,600
그래서 이렇게 인생에서 목적 하드 귀하가 코딩 여부, 문자열을하는 것입니다입니다

223
00:12:55,600 --> 00:12:58,840
또는이 경우에는, 인수와 같은 변수로 연결

224
00:12:58,840 --> 00:13:01,980
그리고 그 문자열의 길이가 무엇인지 알아보지.

225
00:13:01,980 --> 00:13:06,470
>> 그래서 여기 이제 우리는 이전의 퀴즈 예제에서 몇 가지 표기법을 빌려야겠군요.

226
00:13:06,470 --> 00:13:09,390
이것은 수레와는 아무 상관이없는 퀴즈와는 아무 상관이없는 일,

227
00:13:09,390 --> 00:13:13,100
하지만 작은 하얀 거짓말 우리가 주 1부터 말했어 한 것이 밝혀

228
00:13:13,100 --> 00:13:16,330
C.에 문자열이 정말 존재하지 않는 것입니다

229
00:13:16,330 --> 00:13:20,230
하루의 끝에서 문자열은 단지 배열입니다.

230
00:13:20,230 --> 00:13:25,140
이 리콜은 단지 8 비트입니다 바이트의 배열 때문에 바이트, 바이트, 바이트, 바이트이고,

231
00:13:25,140 --> 00:13:28,130
그래서 메모리의 덩어리, 메모리의 덩어리, 메모리의 덩어리, 메모리 덩어리.

232
00:13:28,130 --> 00:13:31,210
그리고 문자열을 구현하는 수단

233
00:13:31,210 --> 00:13:33,070
여기 첫 문자를 넣어하는 것입니다

234
00:13:33,070 --> 00:13:37,470
여기를, 여기, 여기, 다시 컴퓨터의 메모리에 백업 할 백업하는 것이 었습니다.

235
00:13:37,470 --> 00:13:42,160
당신은 HELLO 같은 단어를 철자하기를 원한다면 자, 1 자 H를 입력 할 수

236
00:13:42,160 --> 00:13:48,240
그리고 E, 그리고 L 후 L, 그리고 O - 총 5 자 - 어디 선가 컴퓨터의 RAM 인치

237
00:13:48,240 --> 00:13:52,080
하지만 여기 키 세부, 그들은 뒤에 백업 할 백업 다시 할거야 있다는 것입니다

238
00:13:52,080 --> 00:13:54,200
서로 바로 옆에.

239
00:13:54,200 --> 00:13:58,820
내가 말할 때 님의 [내가] 영어로 어떻게하면이 나를 좋아요?

240
00:14:01,240 --> 00:14:04,550
님의 [내가]이 경우에는 무엇을 나타 냅니까? 그래.

241
00:14:04,550 --> 00:14:07,800
>> [학생] 문자열의 i 번째 문자가 있습니다. 정확히 >>. 문자열의 i 번째 문자가 있습니다.

242
00:14:07,800 --> 00:14:12,260
자, 여기 루프 내에 따라 0부터 시작 것입니다

243
00:14:12,260 --> 00:14:14,850
모든 0부터 계산 시작하기 때문에 좋네요.

244
00:14:14,850 --> 00:14:19,160
S 자 [0] HELLO 같은 단어에서 문자 H를 나타내는 것입니다,

245
00:14:19,160 --> 00:14:24,530
님의 [1] 등등 HELLO 같은 단어 E 같은 편지를 나타내는 것, 그리고 수 있습니다.

246
00:14:24,530 --> 00:14:27,130
그리고 우리가이 루프의 각 반복에 일을 할 것 같습니다

247
00:14:27,130 --> 00:14:32,780
일시적으로 단지 숯불입니다, C라는 변수에 i 번째 문자를 저장하고,

248
00:14:32,780 --> 00:14:35,010
그리고 우리는 C를 인쇄하는

249
00:14:35,010 --> 00:14:37,620
수 있도록이 프로그램이 무엇을 하루의 끝에 다음과 같습니다.

250
00:14:37,620 --> 00:14:42,900
나는 소스가있는 디렉토리로 가서, 내가 string1을 내가 가서 string1를 실행하는 경우

251
00:14:42,900 --> 00:14:51,920
그리고 나서, 전 HELLO 입력 같은 단어를 입력 맞지 않는 모든 한 번에 1 번 문자를 인쇄 할 수 있습니다.

252
00:14:51,920 --> 00:14:54,010
>> 따라서 상세 수있는 기회가 있어요.

253
00:14:54,010 --> 00:14:58,150
그럴 필요보다, 아마이 방법보다 분명 할지라도, 더 많은 일을하고있는 것 같아요.

254
00:14:58,150 --> 00:15:03,270
아마 모두 어떤 여기에 코드의 라인을 던져 수 있습니까? 그래.

255
00:15:03,270 --> 00:15:08,290
선 24. 라인 24에서 나는 변수 C를 선언거야.

256
00:15:08,290 --> 00:15:14,320
나는 거기에 s의 i 번째 문자를 저장하고 있는데 그럼 내가 여기에 C를 사용하고 있습니다.

257
00:15:14,320 --> 00:15:20,160
그래서 C를 사용하고, 그래서 난 그냥 24 거리에 줄을 던질 줄도 모르는 것 같은 느낌.

258
00:15:20,160 --> 00:15:23,850
[안 들리게 학생 코멘트] >> 맞아.

259
00:15:23,850 --> 00:15:26,240
그래서 때이 프로그램의 디자인에 대해 얘기에 관한

260
00:15:26,240 --> 00:15:30,740
마찬가지로 읽을 수있는 코드의 약간의 단순화, 알

261
00:15:30,740 --> 00:15:34,680
하지만 S 단지 변수가 아니라는 것을 파악, 그 데이터 형식은 배열입니다

262
00:15:34,680 --> 00:15:38,610
S 수 있도록 [I]는 즉시 해당 문자열의 i 번째 문자로 돌아 예정이다.

263
00:15:38,610 --> 00:15:40,620
당신이 그것을 인쇄 할 경우 그리고, 괜찮아.

264
00:15:40,620 --> 00:15:43,680
당신은, 당신은 문자열을 인쇄하지 않았기 때문에 %의 C를 사용해야합니다

265
00:15:43,680 --> 00:15:48,520
당신은 문자열에서 문자를 인쇄하고,이 역시 i 번째 문자를 인쇄하는 효과가 있습니다.

266
00:15:48,520 --> 00:15:51,390
그리고 printf를 사용으로 지난 주에 온 진짜 유일한 차이를 기억

267
00:15:51,390 --> 00:15:54,220
주 반면 우리는 슈퍼 간단한 일을 할 과거 있다는 것입니다

268
00:15:54,220 --> 00:15:58,510
% s의 자리 표시 자와 같은 한 다음 여기에 문자열의 이름,

269
00:15:58,510 --> 00:16:01,190
지금 우리는 후드 아래에 좀 더 깊이에서 다이빙하고있어, 말

270
00:16:01,190 --> 00:16:06,090
문자열을 인쇄하지 않습니다, 거기에 하나의 문자를 인쇄 할 수 있습니다.

271
00:16:06,090 --> 00:16:10,570
>> 1 명의 있기 때문에 그래서 우리는 여기에 다른 뭔가를 조금 할 수 -없는 버그

272
00:16:10,570 --> 00:16:14,090
이 프로그램은 오른쪽 있기 때문에,하지만 멍청한 짓을하고 있어요

273
00:16:14,090 --> 00:16:16,810
나는 수요일에 간단히 언급하는.

274
00:16:16,810 --> 00:16:22,680
그러나이 프로그램의 디자인을 더욱 개선 할 수 있는지, 다시 생각? 그래.

275
00:16:22,680 --> 00:16:28,280
[안 들리게 학생 응답] >> 오, 좋아.

276
00:16:28,280 --> 00:16:32,120
그래서 우리는이라는 초 변수 N 지난 번에 소개하는 기억,

277
00:16:32,120 --> 00:16:34,850
어떤 때문에 내 목표 초 전 자신을 어기는 것 같습니다

278
00:16:34,850 --> 00:16:37,380
, 불필요한 같은 변수를 멀리 던져 단지

279
00:16:37,380 --> 00:16:40,700
하지만 수요일에 우리가 실제로 이런 짓을하는 기억.

280
00:16:40,700 --> 00:16:46,170
나는 다음에 n = 나 strlen, 실제로 여기에 쉼표가 루프에 대한 변경

281
00:16:46,170 --> 00:16:52,120
그리고 여기에 내가이 <N, 그럼 내 단위 짓을 했어요.

282
00:16:52,120 --> 00:16:57,660
기본 게인 내가이 내 초기화를 변경하여 달성한다는 무엇입니까

283
00:16:57,660 --> 00:17:01,590
이 지금까지 내 상태? >> [안 들리게 학생 응답] >> 맞아.

284
00:17:01,590 --> 00:17:06,170
나는 기억 때문에 다시 다시 다시 나 strlen을 리콜하고 안하는 방법 루프 작품.

285
00:17:06,170 --> 00:17:08,790
그들은 더 복잡하게 생긴 얻을 시작하더라도

286
00:17:08,790 --> 00:17:12,480
첫 번째 세미 콜른의 앞 일이 한 번 발생 초기화,입니다 기억.

287
00:17:12,480 --> 00:17:14,359
조건은하지만, 중간에

288
00:17:14,359 --> 00:17:17,710
이 귀하가 루프 통과 때마다 확인됩니다.

289
00:17:17,710 --> 00:17:22,420
>> 그게 바보 같은 종류의 또 한번, 또 한번 컴퓨터에게 같은 질문을 할거야 -

290
00:17:22,420 --> 00:17:25,920
HELLO의 길이는 무엇입니까? HELLO의 길이는 무엇입니까? HELLO의 길이는 무엇입니까? -

291
00:17:25,920 --> 00:17:29,740
오늘은 우리가 보게 될 때문 수요일, 이건 확실히, 시간이 걸릴 것입니다

292
00:17:29,740 --> 00:17:34,320
문자열의 길이를 알아내는 있기 때문에 그 시간의 좋은 사용 안

293
00:17:34,320 --> 00:17:37,030
실제로 노력의 조금 걸립니다.

294
00:17:37,030 --> 00:17:39,760
가 일부 언어에서와 같이 그것은 즉각적인 없습니다.

295
00:17:39,760 --> 00:17:43,920
따라서 N이을 변경하여, 내가 돈을 지불 가격은 무엇입니까?

296
00:17:43,920 --> 00:17:45,640
우리는 여기서 트레이드 오프를 볼 수 있습니다.

297
00:17:45,640 --> 00:17:49,460
나는 다시 다시 같은 빌어 먹을 질문을하지 않음으로써 시간을 절약 할 수 있습니다

298
00:17:49,460 --> 00:17:51,740
하지만 나에게 무슨 일을 비용거야?

299
00:17:51,740 --> 00:17:55,050
>> [학생] 당신은 메모리의 일정 금액을 잃게됩니다. 정확히 >>. 그것은 나에게 메모리를 들겠 죠.

300
00:17:55,050 --> 00:17:56,670
따라서이 경우는 뭘 비용?

301
00:17:56,670 --> 00:18:01,530
또 다른 32 비트 여기에 단어 INT에 의해 암시로 n은 단지 정수이기 때문이다.

302
00:18:01,530 --> 00:18:03,300
하지만 그건 괜찮아요?

303
00:18:03,300 --> 00:18:05,800
당신이 그것에 대해 생각하면 솔직히, 아마도 괜찮아

304
00:18:05,800 --> 00:18:09,030
더 이상 문자열, 난 낭비거야 더 많은 시간이

305
00:18:09,030 --> 00:18:11,920
나 strlen 다시 다시 다시 호출하려고하기 때문에

306
00:18:11,920 --> 00:18:13,520
루프의 모든 반복하십시오.

307
00:18:13,520 --> 00:18:18,070
그리고 요즘 제 맥 RAM 2 기가, 요즘 가끔 RAM의 4 기가 있습니다.

308
00:18:18,070 --> 00:18:22,420
나는 실제로 일을 속도를 그 바이트의 4 감당할 수 있다고 생각합니다.

309
00:18:22,420 --> 00:18:26,590
그러나 이것은 프로그래밍과 컴퓨터 과학 정말 트레이드 오프와 테마가 될 것입니다

310
00:18:26,590 --> 00:18:28,320
정말 무료로 아무 것도 못한다고.

311
00:18:28,320 --> 00:18:32,880
당신이 뭔가를 개선하려는 경우, 당신은 어떻게 든 다른 손에 비용을 지불해야합니다.

312
00:18:32,880 --> 00:18:35,880
이 경우 우주 대 시간.

313
00:18:35,880 --> 00:18:40,700
>> 그래서 모두 같은 암호화 된 것을 향해 이어지는되었습니다

314
00:18:40,700 --> 00:18:44,070
어떤, 당신은 아마도 지금 쯤 생각 해낸 것처럼, 실제로 말한다?

315
00:18:44,070 --> 00:18:47,420
[안 들리게 학생 응답] >> 그래, 그래서이있어, Ovaltine를 마시해야합니다

316
00:18:47,420 --> 00:18:52,490
실제로 ROT13라는 알고리즘 ROT 1-3를 사용하여

317
00:18:52,490 --> 00:18:55,500
이는 단지 문자의 13 곳을 회전을 의미합니다

318
00:18:55,500 --> 00:18:58,720
이는을하고 거기에 13 추가 점, 점, 점을 갈 수 있다는

319
00:18:58,720 --> 00:19:04,640
거리에 13 문자까지 모든 방법, 등등 B와 C 및 D에 대해 동일한 일을합니다.

320
00:19:04,640 --> 00:19:10,850
그리고 우리는 13 곳의 변화를 사용하여 여기에 변환하면,

321
00:19:10,850 --> 00:19:14,580
우리는, 작은 Ralphie가 가진 것의 소중함을 다시 전화 드리겠다 귀하의 Ovaltine 마시고 반드시되었다.

322
00:19:14,580 --> 00:19:18,160
그러나 지금 문제는, 적어도 표준 판에, 2를 설정

323
00:19:18,160 --> 00:19:21,680
당신은이 자신을 enciphering 않는 종류의 할 필요가

324
00:19:21,680 --> 00:19:25,990
우리는 어떻게 든 같은 입력에 가져 가서 또는 해독을 암호화해야합니다.

325
00:19:25,990 --> 00:19:29,850
>> 따라서 이러한 기본 정렬하는 그런 기회 단서가?

326
00:19:29,850 --> 00:19:32,650
- 여기서이 세 번째 예를 살펴 보자.

327
00:19:32,650 --> 00:19:38,430
우선,이 ASCII라고. ASCII로 무엇을 참조합니까?

328
00:19:38,430 --> 00:19:40,460
정보 교환을위한 미국 표준 코드,

329
00:19:40,460 --> 00:19:43,850
이는 무엇을 말하는 정말 먼 길입니까? ASCII 무엇입니까?

330
00:19:43,850 --> 00:19:47,890
[안 들리게 학생 응답] >> 그게 뭐야? >> [학생] 문자지도. >> 문자지도.

331
00:19:47,890 --> 00:19:51,390
세계 표준화가 있기 때문에 단지 문자에 번호를 매핑

332
00:19:51,390 --> 00:19:55,380
어떤 번호는 우리 모두가 컴퓨터를 사용할 수 있도록 어떤 문자를 표현할 수

333
00:19:55,380 --> 00:19:59,340
우리의 프로그램은 모두가 화면에 물건을 인쇄 할 때 단지 호환됩니다.

334
00:19:59,340 --> 00:20:04,680
그래서 65를 나타내는 데 무슨 일이 기억, 97을 소문자 대표 발생합니다.

335
00:20:04,680 --> 00:20:08,510
그리고 여기이 간단한 프로그램은 ASCII 그 사실을 이용하고있다 -

336
00:20:08,510 --> 00:20:12,770
세계는 자본이 65입니다 알고 - 그리고는 그냥 매핑을 인쇄있어.

337
00:20:12,770 --> 00:20:16,320
>> 우리가이 코드에 다이빙하기 전에 그래서, 내가 대신 터미널 창을 열 수 있습니다.

338
00:20:16,320 --> 00:20:21,550
내가 가서 ASCII 확인한 다음 그냥 그냥 출력을 망치고이 일을 실행하게 보자.

339
00:20:21,550 --> 00:20:25,960
나에게 다양한 코드를 모두 알려주는 아주 큰 차트 : 그리고 그냥이 일을

340
00:20:25,960 --> 00:20:27,950
다양한 문자를합니다.

341
00:20:27,950 --> 00:20:32,100
슈퍼 간단한 프로그램 그래서, 난 하드 코드 출력의 그 52 라인이 없었 :

342
00:20:32,100 --> 00:20:34,860
26 대문자, 26 소문자.

343
00:20:34,860 --> 00:20:37,790
대신, 나는 루프을 몇 개 프로그램이 했어요.

344
00:20:37,790 --> 00:20:39,720
내가 여기서 무슨 짓을 확인할 수 있습니다.

345
00:20:39,720 --> 00:20:44,790
나는 26 개의 문자를 인쇄 싶어서 65 + 26에 제가 65에서 최대 반복

346
00:20:44,790 --> 00:20:49,860
영어 알파벳에, 난 + + 각 반복에서, 그리고 지금 다시를 확인합니다.

347
00:20:49,860 --> 00:20:52,540
우리 친구 typecasting의 재발입니다

348
00:20:52,540 --> 00:20:54,620
당신은 다른 한 데이터 형식으로 변환된다

349
00:20:54,620 --> 00:20:57,480
나는 무엇을이 특정 프로그램에 어떻게해야할까요? 않기 때문에

350
00:20:57,480 --> 00:21:02,650
등등 65, 66, 67, 그리고 - 그게이기 때문에 제가 계산을 성장하는 방법 숫자 계산하려면 -

351
00:21:02,650 --> 00:21:04,420
하지만 난 그 번호를 인쇄하지 않습니다.

352
00:21:04,420 --> 00:21:08,030
나는 수에 따라 편지를 인쇄하고 싶습니다.

353
00:21:08,030 --> 00:21:18,640
수, B : 나는 인쇄 할 수 있지만 똑같은 변수로이 작업을 수행 할 수 있습니다.

354
00:21:18,640 --> 00:21:21,630
그래서, 문자에 대한 자리 표시 자로 %의 C를 인쇄

355
00:21:21,630 --> 00:21:25,080
숫자 나 숫자에 대한 자리 표시 자로 % d 개.

356
00:21:25,080 --> 00:21:27,750
그리고 지난 2 자리 표시를 위해 무엇을 연결해야합니까?

357
00:21:27,750 --> 00:21:33,960
나는 그의 캐릭터로 이에 상응하는 금액의 첫 번째 플러그, 그리고 나는 내가 아웃 자체를 인쇄 할 수 있습니다.

358
00:21:33,960 --> 00:21:36,400
>> 그러니 일이 너무 만 작동 확인합니다.

359
00:21:36,400 --> 00:21:39,320
나는 int로 부동의 캐스트 것처럼

360
00:21:39,320 --> 00:21:41,750
실제 숫자의 정수로 이동하기 위해서는하면,

361
00:21:41,750 --> 00:21:46,100
여기 당신이 INT에서 좀 이상 숯불로 이동 할 수 있습니다 -

362
00:21:46,100 --> 00:21:48,680
꽤 현실 세계에 매핑되지 않습니다 -하지만 컴퓨터에

363
00:21:48,680 --> 00:21:51,140
문자는 후드 아래에 단지 숫자입니다

364
00:21:51,140 --> 00:21:53,590
그래서 우리는 말하는, 컴퓨터에 여기에 아무리 명시 적 인 것

365
00:21:53,590 --> 00:21:58,920
printf, 내가 65으로하지 인쇄를 그 숫자 동등하게 인쇄합니다.

366
00:21:58,920 --> 00:22:02,110
제가 기술적으로도이 필요하지 않습니다 아웃 그리고집니다.

367
00:22:02,110 --> 00:22:05,020
제가 좀 전에 무슨 짓을하는지 명시 적으로 캐스팅합니다

368
00:22:05,020 --> 00:22:08,760
나는에서 이동 한 원하는 것을 데이터 유형 지정하여.

369
00:22:08,760 --> 00:22:11,840
하지만 이미이 자리 표시 자 %의 C이 표시

370
00:22:11,840 --> 00:22:14,930
여기이 다른 % C 자리 표시 자.

371
00:22:14,930 --> 00:22:18,880
이 INT하지 않더라도, 컴퓨터, 그 숯불을 실현

372
00:22:18,880 --> 00:22:21,080
그냥 후드 아래에 정수입니다.

373
00:22:21,080 --> 00:22:25,100
>> 난 사실이 다시 컴파일하고 ASCII 프로그램을 다시 실행면은,

374
00:22:25,100 --> 00:22:31,210
컴퓨터가이 이메일은이 것을 알고 있기 때문에 아직도 단지 작동 확인합니다.

375
00:22:31,210 --> 00:22:34,870
이제 ints 떠의 세계에서 명시 적으로 캐스팅을 수행하는 것이 더 중요합니다

376
00:22:34,870 --> 00:22:37,460
이 때문에 실제로 계산 결정을하는 :

377
00:22:37,460 --> 00:22:40,140
소수점 모든 버린다.

378
00:22:40,140 --> 00:22:44,990
다음은 문자가 단지 숫자이기 때문에 버리지은 정말로 아무것도가 없습니다

379
00:22:44,990 --> 00:22:48,220
그리고 문자열은 문자의 배열입니다.

380
00:22:48,220 --> 00:22:52,530
따라서 일부 암호화 또는 해독을 구현하는 시간을 때,

381
00:22:52,530 --> 00:22:56,770
우리가 실제로이 말도 안되는 짓을 번역 할 수있는 방법입니다

382
00:22:56,770 --> 00:22:58,670
당신의 Ovaltine을 마실해야합니다?

383
00:22:58,670 --> 00:23:02,700
우리가 지금 알고있는 경우 - 우리 가정으로 가져 가게 - 그게 키

384
00:23:02,700 --> 00:23:08,010
우리가 이러한 문자를 모두 회전하고있는 숫자는 숫자 13인가?

385
00:23:08,010 --> 00:23:11,800
그래서 우리는, 문자 B에서 문장의 시작 O하기위한 모든 방법을 간

386
00:23:11,800 --> 00:23:14,710
나는 B를하면, 당신의 Ovaltine를 마시해야합니다

387
00:23:14,710 --> 00:23:19,600
그럼 내가 C, D, E, F, G, H, I, J, K, L, M, N, O를,가

388
00:23:19,600 --> 00:23:23,760
문자 B의 암호화 O되는 이유입니다

389
00:23:23,760 --> 00:23:26,570
난 그냥 거기에 13을 추가 때문입니다.

390
00:23:26,570 --> 00:23:33,460
>> 나는 해독이하고 싶다면 I은 본질적으로 O를 다음에서 13을 빼야한다.

391
00:23:33,460 --> 00:23:36,880
알파벳에는 26 글자 있기 때문에 또는, 솔직히,,이 놀라 울 정도 대칭입니다

392
00:23:36,880 --> 00:23:41,260
우리는 또한 단 13를 추가 할 수 있으며, 우리는 문자 B. 다시 연락 할게

393
00:23:41,260 --> 00:23:44,290
하지만 당신은 카이사르에서이 같은 것을 구현 어떻게해야할까요

394
00:23:44,290 --> 00:23:46,600
나 정말 일반적으로 문자열을 조작?

395
00:23:46,600 --> 00:23:51,380
문자 B는 몇 번 경우?

396
00:23:51,380 --> 00:23:55,290
문자 B는 무엇입니까? 그래서 바로 66이야?

397
00:23:55,290 --> 00:23:59,220
문자 65와 문자 B는 66입니다면은,

398
00:23:59,220 --> 00:24:03,940
66 그래서, 내가 할 일은 그것 밖에 13 추가하며,이 나에게 79을 제공합니다.

399
00:24:03,940 --> 00:24:09,150
그리고 우리는 우리의 작은 컨닝 시트, O.로 79 실제로지도로 이동하는 경우

400
00:24:09,150 --> 00:24:11,290
>> 그러나 코너 케이스 부분은 바로이 있습니다.

401
00:24:11,290 --> 00:24:15,170
무엇, 문자 Z 할 말?

402
00:24:15,170 --> 00:24:20,180
우리가 알파벳의 끝까지를 얻을 66 + 25을하면, 우리는 91에있다.

403
00:24:20,180 --> 00:24:24,520
91 + 13 나에게 104를 부여하며 어떻게 됐을까?

404
00:24:24,520 --> 00:24:29,200
104 대문자와 동일하지 않습니다.

405
00:24:29,200 --> 00:24:31,610
의는 여기에 약간의 컨닝 시트로 돌아가 보자.

406
00:24:31,610 --> 00:24:38,070
나는 어플라이언스 통지에이 프로그램을 다시 실행하면 그 104, 난 공항 터미날 창으로 돌아 가면,

407
00:24:38,070 --> 00:24:41,800
104 분명히 소문자 H입니다.

408
00:24:41,800 --> 00:24:46,400
그래서 우리는 우리가 Z에 시작할 때 있는지 확인하기 위해 여기에 몇 가지 주요 트릭을해야합니다

409
00:24:46,400 --> 00:24:50,260
우리는 우리가 점점 커지고 숫자로 앞서 단조 유지하지 않으려는 여기에 13을 추가합니다.

410
00:24:50,260 --> 00:24:52,600
우리가 정말 뭘하고 싶어?

411
00:24:52,600 --> 00:24:54,570
당신은 주변의 포장을 할까.

412
00:24:54,570 --> 00:25:00,250
>> 그럼 지금 섹션이나 문제 세트 사양 자체 아마도 본으로 판명

413
00:25:00,250 --> 00:25:05,730
또한 퍼센트 기호입니다 C에서 다른 운영자가 있다는 것을 깨달았다,

414
00:25:05,730 --> 00:25:11,020
하지만 자리 표시자를 지정하려면 여기를 %을 사용하는 반면,

415
00:25:11,020 --> 00:25:15,420
특히 문제 세트 2이 같은도있어, 알고 :

416
00:25:15,420 --> 00:25:18,990
INT X = Y % Z.

417
00:25:18,990 --> 00:25:22,770
난 그냥이 매우 일반적인 형태로들을 소개합니다.

418
00:25:22,770 --> 00:25:25,580
퍼센트는 프로그래밍 언어로 무슨 뜻 이죠? >> [학생] 모듈로.

419
00:25:25,580 --> 00:25:28,790
나머지 말을하는 멋진 방법입니다 모듈로.

420
00:25:28,790 --> 00:25:31,620
거기에 정의 약간 차이가있다하더라도

421
00:25:31,620 --> 00:25:37,210
이 방법은 Z에서 Y를 나눌하지만, 그 부서의 결과를 반환하지 않습니다;

422
00:25:37,210 --> 00:25:39,650
대신 나머지를 반환합니다.

423
00:25:39,650 --> 00:25:47,390
>> y는 실제로 3과 z는, 실제로 2로 나누어 3 2면, (1)의 나머지 부분과 함께 1

424
00:25:47,390 --> 00:25:51,550
그래서 뭐 x는이 시나리오에 실제로 평등합니까? 1.

425
00:25:51,550 --> 00:25:54,540
여기에는 간단한 낮은 수준의 생각입니다.

426
00:25:54,540 --> 00:25:56,480
당신의 마음이 감싸 얻을 약간의 시간이 걸립니다

427
00:25:56,480 --> 00:25:58,740
당신은 심지어 remainders 신경했던 이후로는 아마 오래 살았 으니까

428
00:25:58,740 --> 00:26:01,160
실제로, 목적 무언가를를 사용

429
00:26:01,160 --> 00:26:05,290
하지만이 경우에 당신은 3 같은 큰 숫자부터 시작 할 수있는 단순한 사실

430
00:26:05,290 --> 00:26:08,920
그리고 2와 같은 비교적 적은 수에 효율적으로 주위에 래핑

431
00:26:08,920 --> 00:26:14,160
하나 같이 작은 값으로 나머지를 사용하여 귀중한 트릭 될 것입니다

432
00:26:14,160 --> 00:26:17,690
우리는 황제 같은이 다른 물건 Vigenere에 모두 사용할 수있는

433
00:26:17,690 --> 00:26:22,240
에 문제가 2로 설정하지만,이 학기 내내 반복 트릭 될 것입니다.

434
00:26:22,240 --> 00:26:24,880
단지 일반적으로 나머지를 복용이 단순하고, 간단한 아이디어

435
00:26:24,880 --> 00:26:26,530
우리 주변의 포장을 허락 할 수 있습니다.

436
00:26:26,530 --> 00:26:31,140
그리고 우리가 메모리 자체에 이상 게임을 시작할 때 우리가 배열 이상 게임을 시작으로,

437
00:26:31,140 --> 00:26:35,800
이 강력한 마술의 더 될 것입니다.

438
00:26:35,800 --> 00:26:43,420
>> 따라서 ASCII에 대한 다음 질문이나 배열로 문자열의 표현?

439
00:26:43,420 --> 00:26:47,430
그리고 우리는 한 노치 더를 차지합니다. 그래.

440
00:26:47,430 --> 00:26:52,350
[안 들리게 학생 질문] >> 좋은 질문입니다.

441
00:26:52,350 --> 00:26:55,370
변수가 앞의 별표가있는 경우는 무엇을 의미합니까?

442
00:26:55,370 --> 00:26:57,720
제가 연기하게 모든 세부 사항에서 해당 답변을,

443
00:26:57,720 --> 00:27:00,100
하지만이 포인터로 알려진 주제를 의미합니다.

444
00:27:00,100 --> 00:27:03,440
포인터는 메모리와 필요, 우리는 실제로 오늘은

445
00:27:03,440 --> 00:27:06,330
그 토론 향한 첫 발걸음을 내 디뎌,

446
00:27:06,330 --> 00:27:08,600
하지만 지금은 저 별이 존재하지 않는 있다고 가정합시다

447
00:27:08,600 --> 00:27:15,380
우리는, 문자열 문자열을 호출하는 대신 숯불 *를 계속 사용합니다

448
00:27:15,380 --> 00:27:19,530
당신은 아마 전에 본 적 나는 티저로 한 순간에 화면에 올려 놓을 게요된다.

449
00:27:19,530 --> 00:27:23,010
그래서 우리는 아마 좋아됩니다 많은 것보다 더 상세하게 그에게 돌아올 거예요.

450
00:27:23,010 --> 00:27:25,760
결국, 오늘. 그래.

451
00:27:25,760 --> 00:27:42,810
>> [안 들리게 학생 질문]

452
00:27:42,810 --> 00:27:47,080
어떤 맥락에서 당신은 문자의 기호를 제공해야합니까? >> [학생] 그래.

453
00:27:47,080 --> 00:27:52,130
따라서 기본적으로, 당신은 +를 넣어하지 않는 경우, 단지 긍정적 인 번호가 간주됩니다.

454
00:27:52,130 --> 00:27:55,390
단지 숫자 1을 작성하면, 그것은 긍정적 인 일입니다.

455
00:27:55,390 --> 00:27:57,710
당신은 실제로 값의 부정을 지정하려면,

456
00:27:57,710 --> 00:28:01,060
당신은 말 그대로 키보드에서 -1을 할 수 있습니다.

457
00:28:01,060 --> 00:28:20,440
그러나 이것은 아마도 질문하지 않습니다. >> [안 들리게 학생 응답]

458
00:28:20,440 --> 00:28:22,200
>> 좋은 질문입니다. 좋아요.

459
00:28:22,200 --> 00:28:24,970
이 버그 어떤 종류의와 함께, 내가 수집해야 할 일이 그래서 당신은 당신의 마주쳐

460
00:28:24,970 --> 00:28:27,640
당신은 문자로 정수를 변환했기 때문에

461
00:28:27,640 --> 00:28:29,780
하지만 어떻게 든 부정적는 사귀고있어

462
00:28:29,780 --> 00:28:32,380
그래서 그냥이 나온 캐릭터는 어떻게 든 munged.

463
00:28:32,380 --> 00:28:36,710
그럼 지금부터, 우리는 주제의이 종류에 돌아올 때까지 나를 조금 지나치게 단순화 보자.

464
00:28:36,710 --> 00:28:39,570
지금은 일을 이런 식으로 생각을 - 그리고이 oversimplification입니다.

465
00:28:39,570 --> 00:28:43,500
그러나 정수의 세계에서, 당신은 처리에서 얼마나 많은 비트가?

466
00:28:43,500 --> 00:28:45,190
당신은 32 비트가 있습니다.

467
00:28:45,190 --> 00:28:49,030
그리고 지금까지, 우리는 당신 때문에 표현할 수 정수의 총 수에 대해 얘기 한

468
00:28:49,030 --> 00:28:52,430
당신이 32 비트를 가지고 있기 때문에 약 4,000,000,000 총에,

469
00:28:52,430 --> 00:28:55,100
그 친구는 약 4,000,000,000 야하기 때문에, 32-2입니다.

470
00:28:55,100 --> 00:28:58,810
하지만 우리는 당신이 정말로 숫자의 범위를하지 않아도 일주일 또는 2 전 본

471
00:28:58,810 --> 00:29:01,240
최대의 0에서 4 억.

472
00:29:01,240 --> 00:29:06,340
범위는 대신에 긍정적 인 대략적으로 부정적 2,000,000,000 2,000,000,000에서갑니다.

473
00:29:06,340 --> 00:29:10,990
그러나 이것은 다음 부정적인 2,000,000,000의 개념을 어떻게 표시합니까, 문제는 남죠

474
00:29:10,990 --> 00:29:13,260
혼자 부정적 일 있니?

475
00:29:13,260 --> 00:29:17,960
지금, 우리는 지나치게 단순화하고 우리가 가장 왼쪽 비트를 사용하는 것처럼 말을 할 수

476
00:29:17,960 --> 00:29:22,380
그것이 하나 있다면 그 32 비트의, 그리고는 음수입니다

477
00:29:22,380 --> 00:29:25,090
그것이 0이라면하며 양수입니다.

478
00:29:25,090 --> 00:29:28,570
음수의 단순화 된 표현의 문제

479
00:29:28,570 --> 00:29:33,700
그게 당신이 의도적으로 영리 존재하고 번호를 문자로 변환하려고 한 경우

480
00:29:33,700 --> 00:29:37,190
또는 그 반대로는 부정적 문자와 같은 것은 전혀 없습니다.

481
00:29:37,190 --> 00:29:42,550
만 8 비트를 사용하여 ASCII, 그 비트 문제의 모든 8의 세계에서

482
00:29:42,550 --> 00:29:46,810
그리고 왼쪽 비트는 부정적와는 아무 상관이 없습니다.

483
00:29:46,810 --> 00:29:49,670
그리고 단지, 왼쪽 비트를 말할 때, 명확하게 할 수

484
00:29:49,670 --> 00:29:54,610
기억 우리는 첫 주에서 우리의 비트 관련 예제를 한 때

485
00:29:54,610 --> 00:30:02,570
우리가이 같은, 1001101 같은 일을 그린 기억.

486
00:30:02,570 --> 00:30:07,210
제가 가장 왼쪽 비트를 말할 때, 나는 문자 그대로 당신이 왼쪽 위에있는 모든 방법을 작성하는 일을 뜻합니다.

487
00:30:07,210 --> 00:30:11,910
따라서 문자의 세계에 부정적 대한 개념이 없습니다

488
00:30:11,910 --> 00:30:16,360
그래서 왼쪽 비트는 실제로 ASCII, 부정적와 아무것도 할 일이 있습니다.

489
00:30:16,360 --> 00:30:19,390
>> 그럼 같은데 -와 아웃 문맥을 정확히 대답 어렵습니다 -

490
00:30:19,390 --> 00:30:25,840
하지만 어떻게 든 당신의 코드는 음수 값을 나타내는 등 그 왼쪽 비트를 혼란 된

491
00:30:25,840 --> 00:30:29,160
정말 문제가되는 문자의 일부이었습니다.

492
00:30:29,160 --> 00:30:32,250
컴퓨터가 실제로 약간 애호가 일을하기 때문에 다시 한번이 지나치게 단순화있어

493
00:30:32,250 --> 00:30:37,080
단지 0 대 마이너스 기호에 대한 1에 해당 왼쪽 비트를 변경하는 것이 아니라.

494
00:30:37,080 --> 00:30:41,270
당신은 Google에 호기심 경우 그들은 대신에,,, 일반적으로 2의 보수라는 것을 사용

495
00:30:41,270 --> 00:30:43,830
이는 접근 방식의 조금 더 정교한 수 있습니다

496
00:30:43,830 --> 00:30:45,490
하지만 아이디어는 궁극적으로 동일합니다.

497
00:30:45,490 --> 00:30:50,530
>> 그래서 짧은에, 당신은 문자로 번호를 마사지 한 사실과 관련이 있었어

498
00:30:50,530 --> 00:30:53,750
반대의 경우도 마찬가지이지만 코드는 사실을 인식 아니 었

499
00:30:53,750 --> 00:30:56,510
그 비트 1은 숫자 세계에서 의미가 있다고.

500
00:30:56,510 --> 00:30:59,940
그 문자 세계에서 가장 경우 없습니다.

501
00:30:59,940 --> 00:31:04,270
지금 논의의 여지가있는 어떤 경우에 고친 것 그러나 그것은 들리 네요. 다른 질문입니다.

502
00:31:06,030 --> 00:31:07,110
좋아요.

503
00:31:07,110 --> 00:31:11,560
그럼 지금까지, 우리가 작성한 프로그램의 모든 사용자로부터 아마도 입력을 데리고

504
00:31:11,560 --> 00:31:14,330
GetInt, GetString, 같은 기능의 형태로

505
00:31:14,330 --> 00:31:16,990
또는 다양한 책이나 온라인 참조에 앞서 책을 읽은 적이 있는데 경우,

506
00:31:16,990 --> 00:31:21,390
당신이 스스로 솔직히 우리가 CS50 도서관에서 사용 scanf와 같은 함수를 사용했을 수 있습니다.

507
00:31:21,390 --> 00:31:25,370
그러나 주 또는 2, 우리는 실제로 CS50 라이브러리 구현하는 방법을 보여 줄게

508
00:31:25,370 --> 00:31:27,890
우리는 모두 그 훈련 바퀴를 벗을 수 있도록.

509
00:31:27,890 --> 00:31:31,340
>> 사용자로부터 입력을받을 수있는 다른 방법이 밝혀.

510
00:31:31,340 --> 00:31:34,670
사실, 우리 자신은 명령 줄 인수를 사용하고

511
00:31:34,670 --> 00:31:36,500
몇주 동안.

512
00:31:36,500 --> 00:31:41,150
우리가 꽝을 실행했거나 우리가 실행 한 때마다 확인

513
00:31:41,150 --> 00:31:45,050
우리가 그 소리를 입력하지 않은 입력, 우리는 입력합니다 입력하지 않았습니다.

514
00:31:45,050 --> 00:31:49,340
우리는 일반적으로 우리의 터미널 창 프롬프트에서 단어 그 소리 후에 무엇을 쓰 셨나요?

515
00:31:51,110 --> 00:31:52,900
[학생] 파일 이름입니다. >> 파일 이름, 맞죠?

516
00:31:52,900 --> 00:31:57,560
Hello.c 또는 mario.c이든 뭐든간에 해당 파일 이름입니다.

517
00:31:57,560 --> 00:32:01,910
그리고 정말 무슨 짓을했는지 그 의미에서 당신은 꽝의 동작에 영향을했습니다입니다

518
00:32:01,910 --> 00:32:05,750
물론 꽝을 쓴 사람들은 그 작은 오래된 아무 생각을 가지고하지 않기 때문에

519
00:32:05,750 --> 00:32:08,890
mario.c 년 후라는 프로그램을 작성하려고했습니다.

520
00:32:08,890 --> 00:32:13,150
그래서 당신은, 어떻게 든 해당 프로그램의 동작에 영향을했다

521
00:32:13,150 --> 00:32:18,140
그 프로그램 꽝는 당신의 입력을 받아 들일 수있는 방식으로 작성했습니다

522
00:32:18,140 --> 00:32:23,480
프롬프트에 단어를 추가하여 사용자 조회는 입력하기 전에.

523
00:32:23,480 --> 00:32:27,860
>> 그럼 얼마 동안 우리는 거의 모든 프로그램의를 선언 한 것이 밝혀

524
00:32:27,860 --> 00:32:32,840
이런 식으로 시작합니다 - 정수 메인 (무효) - 그리고 우리는 계속해서 잔업을 해왔 어

525
00:32:32,840 --> 00:32:35,110
우리의 코드를 작성 시작했다.

526
00:32:35,110 --> 00:32:37,910
그리고 우리는, 파일의 상단에 포함 된 일부 날카로운있을 수

527
00:32:37,910 --> 00:32:40,660
하지만 거의 모든 프로그램의 지금까지 이걸 시작했습니다

528
00:32:40,660 --> 00:32:44,200
당신이 책에서 섹션에서 볼 수도하더라도, 온라인 참조

529
00:32:44,200 --> 00:32:46,570
이 사실 무효 할 필요가 없습니다.

530
00:32:46,570 --> 00:32:55,820
이되도록 또 다른 합법적 인 형태는 argc 정수 한 후 문자열 변수는 argv는 []입니다.

531
00:32:55,820 --> 00:32:57,500
그럼 이제이게 무슨 뜻입니까?

532
00:32:57,500 --> 00:33:01,320
그것은 인간의 컨벤션입니다 argc를 밝혀 -이 푸 전화 수

533
00:33:01,320 --> 00:33:03,710
하지만 그저 독자들에게 훨씬 덜 명확한 것 -

534
00:33:03,710 --> 00:33:09,330
argc는 무엇을 나타내는 주요이라는 함수에 인수입니까?

535
00:33:09,330 --> 00:33:12,450
argc는 익숙한 사람들을 위해 무엇을 의미합니까?

536
00:33:12,450 --> 00:33:14,980
>> [안 들리게 학생 응답] >> 네, 인수 또는 인수 개수의 번호입니다.

537
00:33:14,980 --> 00:33:16,510
아주 간단한거야.

538
00:33:16,510 --> 00:33:19,160
얼마나 많은 인수는이 프로그램에 전달 되었습니까?

539
00:33:19,160 --> 00:33:20,630
그게 무슨 뜻 이죠?

540
00:33:20,630 --> 00:33:27,090
그 소리 - 내가 이런 짓을 실행 한 명령 줄에 경우 mario.c .. -

541
00:33:27,090 --> 00:33:35,440
제가 입력을 누르 argc은 2, 다소 혼동을 일으킬의 가치에 걸릴 것입니다.

542
00:33:35,440 --> 00:33:40,150
그럼, argc는 인수 개수입니다 판명

543
00:33:40,150 --> 00:33:46,280
하지만 역사적 이유로, 프로그램 자체의 이름은 그 수에 포함되어 있습니다.

544
00:33:46,280 --> 00:33:51,950
그래서 argc는 내가 그 소리가 mario.c 쓴 2입니다.

545
00:33:51,950 --> 00:33:54,290
변수는 argv는 무엇을 포함합니까?

546
00:33:54,290 --> 00:33:57,020
우선, 변수는 argv는 문자열처럼 보이지만별로

547
00:33:57,020 --> 00:33:59,310
때문에 지난 수요일부터 모든 더 오늘,

548
00:33:59,310 --> 00:34:02,890
이러한 대괄호 무엇을 나타내는? 그 배열입니다.

549
00:34:02,890 --> 00:34:07,110
이 배열에 전화 번호가없고, 그 직관적으로 이해한다

550
00:34:07,110 --> 00:34:10,790
꽝 년 전에 쓴 사람들은 확실히 아무 생각도하지 않기 때문에

551
00:34:10,790 --> 00:34:16,300
우리처럼 얼마나 많은 단어를 사람들이 입력을 때리기 전에 프롬프트에 입력하십시오.

552
00:34:16,300 --> 00:34:22,280
>> 그래서 여기이 경우에 그들은 인수의 배열을 뽑아내는 등의 방법으로 함수가 메인 선언

553
00:34:22,280 --> 00:34:24,590
0 또는 더 많은 인수.

554
00:34:24,590 --> 00:34:26,460
그들은 거기에 얼마나 많은 사전에 알고하지 않습니다

555
00:34:26,460 --> 00:34:29,690
그래서 이러한 대괄호 대한 번호가 안에 의도적 없습니다.

556
00:34:29,690 --> 00:34:32,750
그러나 대괄호가 있다는 사실은 컴퓨터를 얘기하는

557
00:34:32,750 --> 00:34:34,639
배열을 기대하고 있습니다.

558
00:34:34,639 --> 00:34:37,489
변수는 argv는 인자 벡터에 대한 속기 표기법입니다.

559
00:34:37,489 --> 00:34:39,889
벡터는 배열을 말하는 멋진 방법입니다

560
00:34:39,889 --> 00:34:42,980
와 배열은 목록 또는 컬렉션을 말하는 멋진 방법입니다.

561
00:34:42,980 --> 00:34:47,360
이 메시지는 같은 주요 작성하는 경우 것을 의미한다 그래서

562
00:34:47,360 --> 00:34:51,100
대신 우리는 지난 2 주 동안 해왔 방법처럼

563
00:34:51,100 --> 00:34:54,699
프로그램은 이제 명령 줄 인수를 수락 할 수있는 힘을 가지고

564
00:34:54,699 --> 00:34:58,520
더 이상 당신은 입력을 누르 후 마리오를 작성해야 할 필요가없고 않도록

565
00:34:58,520 --> 00:35:01,610
그런 다음, 당신이 피라미드가 원하는 얼마나 많은 블록 하이에 대한 번호를 입력

566
00:35:01,610 --> 00:35:03,100
다시 Enter 키를 누르십시오.

567
00:35:03,100 --> 00:35:07,720
우리는 그 문제에 대해 더 이상 나 GetInt 또는 GetFloat GetString를 사용할 필요가 없습니다.

568
00:35:07,720 --> 00:35:12,370
우리는 사용자가 프롬프트에 자체를 해당 단어를 입력 기대할 수

569
00:35:12,370 --> 00:35:16,850
꽝의 저자는 정말 짜증나는 프로그램이 될 결정처럼

570
00:35:16,850 --> 00:35:20,550
먼저 형식이 그 소리 코드를 컴파일 할 경우, Enter 키를 누르

571
00:35:20,550 --> 00:35:24,090
그리고 우리가 사용자에게 말했다, 당신은 컴파일 할 파일의 이름을 입력하십시오

572
00:35:24,090 --> 00:35:26,920
그런 다음에 우리가 mario.c를 입력하고 Enter 키를 누르십시오.

573
00:35:26,920 --> 00:35:29,850
그러나 우리는 사용자 지난 2 주에게했던 짓 맞아요.

574
00:35:29,850 --> 00:35:33,550
우리는 GetString을 사용하고 프로그램이 입력을을 묻는 메시지를 표시하도록 실행 될 때까지 기다린다.

575
00:35:33,550 --> 00:35:36,710
경우 할 필요가 없습니다 더 이상.

576
00:35:36,710 --> 00:35:41,160
>> 그래서 여기이 예제에서, 우리는 지금, 문자열 변수는 argv가

577
00:35:41,160 --> 00:35:43,390
이도 oversimplification입니다

578
00:35:43,390 --> 00:35:45,610
훈련 바퀴는 곧 내려 올 것이다.

579
00:35:45,610 --> 00:35:50,860
이 메인이 대안 선언을 작성하는 더 적절한 방법입니다

580
00:35:50,860 --> 00:35:54,740
무슨 우리가 문자열을 호출 유지하는 것은 실제로 스타를 가지고 밝혀 때문하면,

581
00:35:54,740 --> 00:35:58,440
의 실제 정의에 별표 (*), 그러나 이것은 단지 복잡한 보이는데,

582
00:35:58,440 --> 00:36:02,600
처음에 혼란 때문에, 우리는 종류의 동의어를 만들어 단순화

583
00:36:02,600 --> 00:36:09,340
CS50 라이브러리에 해당이 더 많은 사용자 친화적 인 단어 문자열에 매핑 숯불 *.

584
00:36:09,340 --> 00:36:13,180
>> 그럼 실제로이 다음 해 봅시다. 내가 가서 여기 gedit를 열어 보자.

585
00:36:13,180 --> 00:36:17,010
내가 가서 1의 변수는 argv를 열어 보자.

586
00:36:17,010 --> 00:36:21,620
이 프로그램은 분명히 인수를 출력하지만, 영어의 측면에서 보면,

587
00:36:21,620 --> 00:36:26,290
이 코드를보고이 더 구체적으로 무슨 일을합니까?

588
00:36:26,290 --> 00:36:35,910
명령 a.out foo는 바에서 I 입력, 나의 흑백 창에 무엇을 인쇄 치면?

589
00:36:35,910 --> 00:36:41,260
A.out foo는 바는 입력합니다.

590
00:36:43,120 --> 00:36:48,300
어서. 그래. >> [안 들리게 학생 응답]

591
00:36:48,300 --> 00:36:52,730
좋아. 따라서 a.out, 새로운 라인, foo는, 새로운 라인, 바, 새 줄.

592
00:36:52,730 --> 00:36:54,980
왜인가요? 우리는 확실히 한 순간에 확인할 수 있습니다.

593
00:36:54,980 --> 00:36:56,940
이 코드의 보송 보송 한 줄의 종류입니다.

594
00:36:56,940 --> 00:36:59,560
 그건 그냥 단지 화면에 일 귀엽 할 새 줄을 출력합니다.

595
00:36:59,560 --> 00:37:03,730
이것은 argc까지에 0에서 반복있어 루프입니다

596
00:37:03,730 --> 00:37:07,210
이 각 반복에 증가하고 있습니다 + +.

597
00:37:07,210 --> 00:37:12,270
그래서 지금이 % s에서 암시와 같은 문자열을 인쇄 말하고있다.

598
00:37:12,270 --> 00:37:16,460
변수는 argv [I] 거의 앞의 예에서 같은 생각입니다.

599
00:37:16,460 --> 00:37:19,580
우리는 변수을 호출하는 데 사용, 지금은, 임의로, 변수는 argv라고합니다.

600
00:37:19,580 --> 00:37:24,270
이것은 명령 줄에서 입력 된 i 번째 인수를 인쇄 의미

601
00:37:24,270 --> 00:37:28,690
이 모든 일이 끝난 다음에 다음, 그냥 좋은 측정을위한 또 다른 새 줄을 인쇄 할 수 있습니다.

602
00:37:28,690 --> 00:37:31,600
>> 그럼이 일을 보자. 제가 터미널 창을 열어 보자.

603
00:37:31,600 --> 00:37:37,470
저 1 변수는 argv를 컴파일, 그리고 지금 내가 입력 1의 변수는 argv를 실행하게 보자. 음. 좋아요.

604
00:37:37,470 --> 00:37:40,850
가 foo는 표시 줄을 실행할 수 있습니다. 흥미 롭군. Baz도.

605
00:37:40,850 --> 00:37:42,640
그리고이를 입력 왜 궁금해 본 적 한 경우

606
00:37:42,640 --> 00:37:45,010
이 단지에는 바보 같은 컴퓨터 과학 박람회입니다.

607
00:37:45,010 --> 00:37:48,050
세계는 종종 단어에 대한 단지 구두 자리 표시 자이 필요합니다.

608
00:37:48,050 --> 00:37:50,090
당신은 몇 가지 일반적인 문자열에 대해 이야기하고 싶다면

609
00:37:50,090 --> 00:37:53,250
컴퓨터 과학자는, 그들은 임의의 단어를 필요로 할 때 foo는 말을하는 경향이

610
00:37:53,250 --> 00:37:55,530
그들은 두 번째 임의의 단어가 필요한 경우 그럼 그 사람들은, 바, 말

611
00:37:55,530 --> 00:37:59,100
그때, 그들은은 세번째 단어가 필요한 경우가 사분의 일 단어를해야하는 경우 다음 그들은 qux 말 Baz도 말

612
00:37:59,100 --> 00:38:01,520
그리고 qux 이후의 일들을위한 거대한 종교 논쟁 온라인이있어

613
00:38:01,520 --> 00:38:04,940
그래서 당신은 다른 임의의 단어가 있어야 무엇을 할 수 있는지 알아내는 것을 검색해 할 수 있습니다.

614
00:38:04,940 --> 00:38:07,480
하지만이는, 전혀 의미가없는 것

615
00:38:07,480 --> 00:38:10,100
하지만 foo는 바, 그 의미 한 일이지,이 Google 경우,

616
00:38:10,100 --> 00:38:12,780
이는 여기 어원의 일부입니다.

617
00:38:12,780 --> 00:38:17,550
>> 그러니까이 후 실적은 라인 당이 문자열 1을 인쇄하고 있습니다.

618
00:38:17,550 --> 00:38:19,900
그래서 대신하는 경우,하지만, 조금 애호가들을 가져 오기를 원

619
00:38:19,900 --> 00:38:22,550
제가 한 줄에 각 문자열을 인쇄 할 않았 겠지;

620
00:38:22,550 --> 00:38:26,220
나는 한 줄에 각 문자열에서 각 문자를 인쇄 할 싶었어요.

621
00:38:26,220 --> 00:38:28,550
내가 대신 어떻게 그럴 수있어?

622
00:38:28,550 --> 00:38:33,720
안 각 단어를 인쇄하려면이 프로그램에 대해 변경하려면 어떻게해야합니까

623
00:38:33,720 --> 00:38:37,290
하지만, 편지로 편지하여 각 단어 문자를 인쇄 할

624
00:38:37,290 --> 00:38:40,590
편지로 편지로 그 다음 단어 편지?

625
00:38:40,590 --> 00:38:43,650
우리가 어떻게 지금까지 이러한 아이디어를 결합해야합니까? 그래.

626
00:38:43,650 --> 00:38:47,390
[학생] % 다. >> 좋아. 그래서 우리는 어딘가에 %의 C가 필요합니다.

627
00:38:47,390 --> 00:38:50,680
난 전체 문자열을 인쇄 할하지 않기 때문에, 내가 문자를 인쇄 할 좋은 싶습니다. 또 뭐가 있지?

628
00:38:50,680 --> 00:38:54,290
>> [안 들리게 학생 응답] >> 흥미 롭군.

629
00:38:54,290 --> 00:38:56,860
그래서 우리는 지금 여기에 두 번째 차원의 정렬이 필요합니다

630
00:38:56,860 --> 00:39:02,300
때문에 배열로 변수는 argv 생각하지만 문자열의 배열입니다.

631
00:39:02,300 --> 00:39:07,170
하지만,의, 좋아, 15 분 전에 문자열이 뭐죠? 이 문자의 배열입니다.

632
00:39:07,170 --> 00:39:12,320
그럼 정말 변수는 argv는 문자의 배열의 배열이다

633
00:39:12,320 --> 00:39:14,870
문자 배열의 배열입니다.

634
00:39:14,870 --> 00:39:19,170
그래서 우리가 더 대괄호 표기법을 사용할 수 있더군요. 그럼 이렇게 까.

635
00:39:19,170 --> 00:39:23,650
라인 (19)에이 루프의 상단에서, 나는, 최대 전에서 argc에 반복거야

636
00:39:23,650 --> 00:39:25,760
하지만 나는이 일을 할거야 :

637
00:39:25,760 --> 00:39:27,580
에 - 지금 i를 사용할 수 없습니다.

638
00:39:27,580 --> 00:39:30,300
나는 단어를 통해 반복 싶어서 다른 변수를 필요

639
00:39:30,300 --> 00:39:32,640
하지만 또한 단어의 문자 이상

640
00:39:32,640 --> 00:39:37,280
그래서 바닥의 수직 축과 수평 축, 개념적으로 정렬되어 있습니다.

641
00:39:37,280 --> 00:39:43,930
따라서 정수 j를 0를 얻을 수, 그때 J가보다 작음있는 한 J을하고 싶어요 - 그리고 난 조금이 치울 게요.

642
00:39:43,930 --> 00:39:48,410
어떻게 문자열의 문자를 통해 반복합니까? 우리는 잠시 전에 이런 짓을.

643
00:39:48,410 --> 00:39:54,670
변수는 argv의 나 strlen [I]. 좋아.

644
00:39:54,670 --> 00:39:57,860
또, 전 n 또는 무엇이든을 작성하지하여 여기에 약간의 비효율을 만들고있어

645
00:39:57,860 --> 00:39:59,610
하지만 우리가 그에게 돌아올거야.

646
00:39:59,610 --> 00:40:03,270
>> 이제 J + +. 지금은 여기에 추가로 들여 쓰기를해야합니다.

647
00:40:03,270 --> 00:40:06,950
지금은 각 반복에 인쇄하려면 어떻게할까요?

648
00:40:06,950 --> 00:40:09,720
[안 들리게 학생 응답] >> 자 [I] 나에게 단어를 제공합니다.

649
00:40:09,720 --> 00:40:12,910
[I] [J], 정렬 매트릭스처럼.

650
00:40:12,910 --> 00:40:14,810
수학 Y 배경으로하시는 분들,

651
00:40:14,810 --> 00:40:19,340
우리는 배열의 매트릭스 또는이 배열에 색인을 생성 일종의도 깊이있어

652
00:40:19,340 --> 00:40:21,380
이 2 차원 구조.

653
00:40:21,380 --> 00:40:25,070
그래서 지금 여기서 무슨 일이 일어날 지 보자. 내 큰 터미널 창을 열어 보자.

654
00:40:25,070 --> 00:40:28,170
저 1의 변수는 argv를 만들어 다시 실행 봅시다.

655
00:40:28,170 --> 00:40:33,090
그리고 나도이 일을 잊었 기 때문에 좋은 교훈이다 여기 실수를했습니다.

656
00:40:33,090 --> 00:40:37,150
암시 적 유형 '서명과 C 라이브러리 함수'나 strlen '을 선언 -

657
00:40:37,150 --> 00:40:40,360
, 난 그 수단의 어떤 나머지 잘 모르겠지만, 전에 본 적있다

658
00:40:40,360 --> 00:40:42,000
암시 적으로 선언.

659
00:40:42,000 --> 00:40:45,540
우리가이 오류를 볼 때마다이 일반적으로 무엇을 의미합니까?

660
00:40:45,540 --> 00:40:48,520
>> [안 들리게 학생 응답] >> 나는 맨 위로 라이브러리를 잊어 버렸습니다. 그러나 잠깐만 요.

661
00:40:48,520 --> 00:40:51,690
나는 CS50 라이브러리를 잊어 버렸습니다 때문에 보통 내가 잘못했지만, 그가 있습니다.

662
00:40:51,690 --> 00:40:54,480
나는 표준 I / O를 잊어 버렸습니다 때문에 보통 내가 망쳐 버린

663
00:40:54,480 --> 00:40:57,960
그리고 솔직히, 난이 필요하지 않습니다. 오늘 GetString을 사용하지 않는 것입니다.

664
00:40:57,960 --> 00:40:59,900
그래서 내가이 누락 무엇입니까?

665
00:40:59,900 --> 00:41:04,860
지금 우리는 종종라는 string.h를 사용하는 데 필요한 또 하나의 라이브러리가 있어요

666
00:41:04,860 --> 00:41:08,980
이는 아직 표준 I / O.에없는 더 많은 기능을 가지고있는 또 하나의 라이브러리입니다

667
00:41:08,980 --> 00:41:11,640
>> 그럼 내 큰 터미널 창으로 돌아 가자.

668
00:41:11,640 --> 00:41:16,670
좋아요. 지금, 젠장, 내가 잘못 생각한 것 같다. 나는 CS50 라이브러리를 사용했습니다.

669
00:41:16,670 --> 00:41:18,460
그래서 우리는 두 가지 방법 중 하나에이 문제를 해결할 수 있습니다.

670
00:41:18,460 --> 00:41:21,510
우리는 지금 훈련 바퀴를 벗고이 일을 할 수

671
00:41:21,510 --> 00:41:26,600
또는 지금 그 단순화를 유지의하자 종류,이 뒤쪽에 붙여 넣습니다

672
00:41:26,600 --> 00:41:30,180
이 문제를 해결, 지금 터미널 창으로 돌아갑니다.

673
00:41:30,180 --> 00:41:33,080
따라서 CS50 라이브러리에, 명확하게하는 것은, 단지 기능을하지 않습니다

674
00:41:33,080 --> 00:41:36,920
그것은 또한 오류가 방금 무슨 일이 일어난 이유 키워드 문자열입니다.

675
00:41:36,920 --> 00:41:43,010
>> 그래서 여기에 우리가 이동합니다. 난 도서관에서 문제 모두를 해결했습니다. 입력합니다. 좋아.

676
00:41:43,010 --> 00:41:49,250
1 argv가, foo는 바는 입력합니다. 좋아요.

677
00:41:49,250 --> 00:41:52,830
이제 우리는 라인 당 1 인쇄 각 단어의 각 문자가

678
00:41:52,830 --> 00:41:55,290
아주 흥미로운 프로그램을하지 않는

679
00:41:55,290 --> 00:41:59,350
하지만 예고 지금 우리는 단어 이상 반복하지의 기능이

680
00:41:59,350 --> 00:42:04,090
뿐만 아니라 대단히 많이 듣던 단어의 개별 문자, 이상

681
00:42:04,090 --> 00:42:10,330
이 같은 문자열에서 출격 문자와 같은 응용 프로그램의 간단한조차합니다.

682
00:42:10,330 --> 00:42:12,410
가 가서 여기 5 분 쉬었다합시다.

683
00:42:12,410 --> 00:42:14,410
그리고 우리가 돌​​아 왔을 때, 우리는 효율성에 대해 얘기 시작합니다

684
00:42:14,410 --> 00:42:17,670
되는 우리는 더 나은 이러한 일을 수행 할 수 있습니다.

685
00:42:19,370 --> 00:42:21,900
>> 괜찮아요. 우리가 다시 있습니다.

686
00:42:21,900 --> 00:42:26,970
bananagrams을 많이 연주 우리의 TFS 중 하나 덕분에,

687
00:42:26,970 --> 00:42:30,000
우리가 실제로 오늘 우리와 함께 문자의 전체 무리가

688
00:42:30,000 --> 00:42:32,520
실제로,이 작은 플라스틱 조각으로 incarnated

689
00:42:32,520 --> 00:42:36,910
이 빈 슬레이트는 여기에 내 컴퓨터의 RAM을 나타냅니다 것을 나 제안 보자 -

690
00:42:36,910 --> 00:42:39,790
노트북, 데스크탑, 무엇이든 - 그리고 그것의 많은 것 같습니다

691
00:42:39,790 --> 00:42:44,090
때문에 우리가 작은 바이트 크기의 조각으로이 RAM을 자르고 시작하면,

692
00:42:44,090 --> 00:42:48,970
우선은 임의로 크기와 그 흐릿가 나타내는 그 말을 -

693
00:42:48,970 --> 00:42:52,430
거기에 우리는 가고, 가자 여기에 조금 축소 -

694
00:42:52,430 --> 00:42:56,120
의 크기가 단일 바이트를 나타내는 말을 보자.

695
00:42:56,120 --> 00:43:00,400
그래서이 문제를 실제로,이 메모리 내부 바이트 또는 문자의 전체 무리에 맞게 수

696
00:43:00,400 --> 00:43:02,860
여기를 상대적 크기에 의해 제안했습니다.

697
00:43:02,860 --> 00:43:06,780
>> 따라서 목표는 문자열에 대한 메모리를 할당하는 것입니다 지금 것 같아요.

698
00:43:06,780 --> 00:43:08,680
어떻게 이런 일이 실제로 작동합니까?

699
00:43:08,680 --> 00:43:11,380
우리가 만들고있어 프로그램에서, 우리는 보통, GetString을 사용하고

700
00:43:11,380 --> 00:43:16,300
하지만 지금은, 분명히, 우리는 변수는 argv에서 사용자 입력을받을 수있는을 통해이 다른 채널이

701
00:43:16,300 --> 00:43:18,190
명령 줄 인수를 통해.

702
00:43:18,190 --> 00:43:20,580
그런데 정말 후드 아래에 무슨 일이야?

703
00:43:20,580 --> 00:43:24,920
우리가 전화하면이 밝혀 - GetString으로 스크롤합시다 - 함수 GetString을

704
00:43:24,920 --> 00:43:28,190
CS50 라이브러리에, 사용자가 문자열을 입력하라는 메시지가있다

705
00:43:28,190 --> 00:43:30,780
일부 단어에서 사용자 유형 -가 HELLO을 불러.

706
00:43:30,780 --> 00:43:35,410
그리고 우리는 지난 2 주 동안 말해 왔던 GetString의 반환 값

707
00:43:35,410 --> 00:43:37,750
HELLO라는 단어처럼, 사실 문자열입니다.

708
00:43:37,750 --> 00:43:39,660
>> 그런데 정말 짓을 GetString입니까?

709
00:43:39,660 --> 00:43:45,230
입력 HELLO에서 사용자 유형으로 GetString는 알아 냈어있다

710
00:43:45,230 --> 00:43:47,930
그래,이 얼마나 많은 자입니까? 이 H-E-L-L-O입니다.

711
00:43:47,930 --> 00:43:52,500
이 경우에는 리눅스 - 어떻게 할당 할 필요는 운영 체제를 요청할 필요 -

712
00:43:52,500 --> 00:43:55,410
적어도 5 바이트 안부 저장할 수 있습니다.

713
00:43:55,410 --> 00:43:59,570
그것이 운영 체제에서 다시 그 5 바이트를 얻을되면 그리고 그 다음 할 일을 진행

714
00:43:59,570 --> 00:44:04,120
백업 백업 백업 HELLO 다시 배치하는 것입니다.

715
00:44:04,120 --> 00:44:11,070
그리고 어떤 정말 GetString에서 돌아 왔하면이 모양 데이터의 덩어리입니다.

716
00:44:11,070 --> 00:44:16,850
만약에 그게 간단하지 않는다는 것이 판명하지만 이건 조금 잘못

717
00:44:16,850 --> 00:44:20,310
단지 컴퓨터의 메모리에 저장 HELLO로

718
00:44:20,310 --> 00:44:24,140
때문에, 나는 C에 쓸거야하는 내 프로그램이 다시 GetString 호출했다고 가정

719
00:44:24,140 --> 00:44:28,210
과에서 사용자가 유형을 다음 단어 BYE, BYE입니다.

720
00:44:28,210 --> 00:44:31,300
글쎄, 난 메모리에 어딘가에 단어 BYE에 맞게해야합니다.

721
00:44:31,300 --> 00:44:33,790
나는 HELLO 옷을 입히다 할 수 없습니다.

722
00:44:33,790 --> 00:44:37,320
예를 들면, 컴퓨터가 그냥이 같은 덮어 쓰기 시작하고 싶지 않아

723
00:44:37,320 --> 00:44:41,400
난 아직 변수에 HELLO라는 단어를 사용 있기 때문에 원래의 단어

724
00:44:41,400 --> 00:44:43,070
다른 곳에서 내 프로그램에서.

725
00:44:43,070 --> 00:44:45,900
>> 따라서 B-Y-E는 다른 메모리에 결국 할 수 있습니다.

726
00:44:45,900 --> 00:44:50,460
하지만 국제 대회는 일반적 당신이 할당 다음 문자열

727
00:44:50,460 --> 00:44:54,940
아마 항상은 아니지만, 다음 사용 가능한 메모리 위치에 오게 예정이다.

728
00:44:54,940 --> 00:44:57,370
그리고 어떤 메모리 운영 체제를 요청하지 않은 경우

729
00:44:57,370 --> 00:45:01,380
제가 GetString이라는 마지막으로 발행 된 이후, 확률은 단어, 안녕

730
00:45:01,380 --> 00:45:05,790
HELLO 메모리에 단어를 한 후 바로 종료 예정이다.

731
00:45:05,790 --> 00:45:10,550
잠재적 인 문제가 발생하지만 어디이 시점에서 당신은 아마 볼 수 있습니다.

732
00:45:10,550 --> 00:45:13,310
때문에 메모리의 다음 덩어리, 단지 무료로 있던 다음 바이트 -

733
00:45:13,310 --> 00:45:18,230
흰색 슬레이트를 청소 - 컴퓨터의 메모리에, HELLO 바로 옆에있었습니다

734
00:45:18,230 --> 00:45:23,670
이건 내가 갑자기 지금 변경 될 수 요구 첫 번째 문자열 느낌

735
00:45:23,670 --> 00:45:26,410
나는 본질적으로 변경 한 때문 HELLOBYE하기

736
00:45:26,410 --> 00:45:31,310
대신 어떻게 든 BYE의 시작과 HELLO의 끝을 demarcing.

737
00:45:31,310 --> 00:45:33,920
>> 그래서, 어떻게 정말 후드 아래에 무슨 일 것이 밝혀

738
00:45:33,920 --> 00:45:37,570
당신은 온라인 참조 또는 섹션 또는 책에서 보일 수도있는

739
00:45:37,570 --> 00:45:41,780
여부를 아직 전혀 고의적 인 경계가 실제로 있다는 것을이다

740
00:45:41,780 --> 00:45:45,890
컴퓨터의 메모리에있는 단어 사이.

741
00:45:45,890 --> 00:45:52,480
그리고 사실은,이 경우보다는 단지 바로 옆에 HELLO에게 안녕을 넣어

742
00:45:52,480 --> 00:45:58,610
대신, 컴퓨터는 특수 문자, 특수 널 문자를 말하자면,두고

743
00:45:58,610 --> 00:46:03,050
어떤은 백 슬래시 0 표시와 함께 표시됩니다.

744
00:46:03,050 --> 00:46:06,700
그럼 요약해서 말하면, 문자는 ASCII로 표현되는 기억.

745
00:46:06,700 --> 00:46:09,680
ASCII, 그냥 숫자와 문자 사이의 매핑입니다

746
00:46:09,680 --> 00:46:13,870
그리고 그 편지의 대부분은 자본에 대한 약 65 시작

747
00:46:13,870 --> 00:46:19,780
당신은 확실히 정수 또는 이진에서 숫자 0을 나타낼 수 밖에 있지만, 변

748
00:46:19,780 --> 00:46:22,690
이 세계 오래 전에 긴 결정 밝혀, "당신은 알아?"

749
00:46:22,690 --> 00:46:27,550
키보드의 모든 문자를 대표하지는 않습니다 "하자 예약 번호 0 -

750
00:46:27,550 --> 00:46:30,810
"더 이상 문자, 번호, 아니 문장이 있습니다. 0 특별 없습니다."

751
00:46:30,810 --> 00:46:35,830
"그것은 특별한 널 (null) 문자 될거야, 우리는 \ 0로 쓸거야."

752
00:46:35,830 --> 00:46:41,170
우리가 0, 0를 작성하면되는 차이는 문자입니다.

753
00:46:41,170 --> 00:46:45,700
3, 2, 1, 0에 대한 ASCII 코드가 있다는 것을 기억

754
00:46:45,700 --> 00:46:50,570
문자 0 숫자 0에서 다른이기 때문이다.

755
00:46:50,570 --> 00:46:54,270
그리고 당신은, 당신은 주 1에서 돌아 보면 우리가 처음 ASCII 대해 얘기 할 때 것을 알 수 있습니다

756
00:46:54,270 --> 00:46:59,130
최대 9-0과 1, 2, 3 모든 방법은 자신의 ASCII 코드를했습니다.

757
00:46:59,130 --> 00:47:02,300
그들은 우연히도 0 - 9하지 않습니다. 그들은 매우 달라요.

758
00:47:02,300 --> 00:47:08,770
그래서 공은 "나는 특별"를 의미하며, \ 0 수단은 문자 그대로, "나는 0 문자가 아니야."

759
00:47:08,770 --> 00:47:11,360
"나는이 특별한 값이 유효하지 않은 문자입니다."

760
00:47:11,360 --> 00:47:16,930
난 두 번 같은 실수를 할 수 없기 때문에 그래서 실제로이 중 하나가 필요합니다.

761
00:47:16,930 --> 00:47:21,550
>> 따라서 단어 BYE 후 우리는 또한이 널 (null) 문자 중 하나를해야 할 것 같습니다.

762
00:47:21,550 --> 00:47:27,090
내가 여기서 내 펜을 잡고 나를 빨리 다른 \ 0을 그리는 해 봅시다

763
00:47:27,090 --> 00:47:30,480
그래서 나는이 문자열을 운영 체제를 묻는 한 후

764
00:47:30,480 --> 00:47:33,270
GetString 또 다른 전화로 다음 GetString을 통해,

765
00:47:33,270 --> 00:47:35,640
이 메모리에 실제로 일이야.

766
00:47:35,640 --> 00:47:39,900
그래서 문자열을 돌아 갔을 때, 정말, 다시 그납니다

767
00:47:39,900 --> 00:47:43,450
내가 다음 문자열을 때, 나는 정말 다시 나타납니다.

768
00:47:43,450 --> 00:47:47,910
따라서이 우선, 나 strlen, 문제는 남죠, 그게 무슨 반환해야합니까?

769
00:47:47,910 --> 00:47:54,650
나는 문자열 S에 나 strlen 전화를 걸어 s이 (가) HELLO 사용자가 입력 한 단어 때,

770
00:47:54,650 --> 00:47:57,800
우리는 분명히 HELLO의 길이가 몇 분 전부터 무슨 얘기를 했죠?

771
00:47:57,800 --> 00:48:01,290
그것은 바로, 5 살? H-E-L-L-O. 그래서 실제로 어떻게 나 strlen 작품입니다.

772
00:48:01,290 --> 00:48:05,670
그것은 정상적인 인간이 될 수있는 문자열의 길이를 기대할지 반환합니다.

773
00:48:05,670 --> 00:48:11,030
그러나 현실에서, 안녕 보관하고 있어요 문자의 배열 크기는 얼마나 되나요?

774
00:48:11,030 --> 00:48:12,770
실제로 6이다.

775
00:48:12,770 --> 00:48:15,740
나 strlen 그래서 당신에게 그 사실을 언급하지 않습니다.

776
00:48:15,740 --> 00:48:20,300
하지만 후드 아래에 컴퓨터가 실제로 5 글자로 된 단어를 저장하는 6 바이트를 사용하고 있습니다

777
00:48:20,300 --> 00:48:22,380
이 단어가 얼마나 오래 상관없이 적용됩니다.

778
00:48:22,380 --> 00:48:26,470
항상 문자열의 끝 부분에 특수 널 종료 문자가있을거야

779
00:48:26,470 --> 00:48:28,800
의 총 길이를 demarc합니다.

780
00:48:28,800 --> 00:48:33,430
>> 당신은 지금, 30 년 전에, 나 strlen (20) 구현 사람입니다 그래서 경우

781
00:48:33,430 --> 00:48:35,520
당신은 나 strlen 자체를 구현 어떻게해야할까요?

782
00:48:35,520 --> 00:48:39,980
당연한 printf 존재 당연한 우리가 걸릴 것처럼 우리가이 있는지 타고

783
00:48:39,980 --> 00:48:42,850
하지만 인사는 문제의 단어 인 경우

784
00:48:42,850 --> 00:48:45,220
그리고 내가 기억하고있는 것은,이 같아 보이는 거입니다

785
00:48:45,220 --> 00:48:48,130
당신이에게 물어했기 때문에 당신은 reimplement 나 strlen해야한다면

786
00:48:48,130 --> 00:48:50,260
나 때문에, 솔직히, 당신은 나 strlen 몰랐는데 -

787
00:48:50,260 --> 00:48:54,280
당신은 스스로를 롤백했습니다 - 당신이 어떻게 나 strlen을 구현 할 수

788
00:48:54,280 --> 00:48:57,760
때이 모양을 좀 줬어요?

789
00:48:57,760 --> 00:49:02,750
이제 우리는 문자열 배열 알고있는, 우리는 개별 문자의 각을 통해 반복 할 수 있습니다

790
00:49:02,750 --> 00:49:06,320
같은 사용 - 가자하면 즉석에서이 작업을 수행하려고있어.

791
00:49:06,320 --> 00:49:12,060
>> 제가 어플라이언스로 가자. - 새로운 파일 strlen.c을 만들 수 있습니다.

792
00:49:12,060 --> 00:49:19,260
내가 지금 가서 stdio.h 우리가 printf에 대한 액세스 권한이 포함 하죠.

793
00:49:19,260 --> 00:49:25,820
저 INT 메인 (무효)을 해봅시다. 오. 난 그냥 그런 다음 지금 스스로이 작업을 수행합니다. ㅠ ㅠ

794
00:49:25,820 --> 00:49:28,300
감사합니다.

795
00:49:28,300 --> 00:49:31,000
이 내가하는 일이 있습니다. 괜찮아요.

796
00:49:31,000 --> 00:49:34,820
I가 화면에 설정 그럼 전에, 난 그 모든 입력.

797
00:49:34,820 --> 00:49:37,550
그리고 지금은 뭘 할 건지는 다음과 같습니다

798
00:49:37,550 --> 00:49:40,360
printf ( "나에게 문자열을한다 :")에게

799
00:49:40,360 --> 00:49:42,700
그건 그냥 보송 보송 한 방법입니다.

800
00:49:42,700 --> 00:49:45,700
지금 나 문자열 S = GetString 해주세요.

801
00:49:45,700 --> 00:49:47,260
난 이미 지금 변경을해야합니다.

802
00:49:47,260 --> 00:49:52,740
나는 CS50 라이브러리를 사용하고 갑자기, 그럼 내가 가서 cs50.h.를 입력하게

803
00:49:52,740 --> 00:50:00,720
- % D, 나 strlen [S] : printf ( "길이는 : 그리고 지금은이 작업을 수행 두자

804
00:50:00,720 --> 00:50:03,540
그리고 난 아직 안 끝났어요. 또 내가이 프로그램에 추가해야하나요?

805
00:50:03,540 --> 00:50:05,740
>> [학생] string.h. >> string.h.

806
00:50:05,740 --> 00:50:10,800
그럼 지금부터, 우리는 나 strlen을 사용하고 있으므로, 씨가있는 곳을 컴파일러가 알고 있는지 확인해

807
00:50:10,800 --> 00:50:12,390
그래서 조금 정신이 확인합니다.

808
00:50:12,390 --> 00:50:16,400
나는 8 호선의 문자열을 가져올 게, 줄 9 I는 % d 개과의 길이를 인쇄거야.

809
00:50:16,400 --> 00:50:19,400
그러니 어서 가서이 일을 열 수 있습니다.

810
00:50:19,400 --> 00:50:23,380
우리는 나 strlen을 한 - 알았어, 컴파일 -

811
00:50:23,380 --> 00:50:30,120
나 strlen가 - 나 확대 구 - 입력, H-E-L-L-O 입력하십시오. 길이는 5가된다.

812
00:50:30,120 --> 00:50:32,730
>> 좋아, 나 strlen 일 것 같습니다하지만, 세계는 것을 알고 있었다.

813
00:50:32,730 --> 00:50:37,310
그럼 이제 우리는 다음과 나 strlen을 구현 보자.

814
00:50:37,310 --> 00:50:39,490
저 멀리이 라이브러리를 보자.

815
00:50:39,490 --> 00:50:42,590
우리는 더 이상 그것을 아주 몰랐는데 때문 string.h에 액세스 할 수 없습니다.

816
00:50:42,590 --> 00:50:45,970
나는 나 strlen 자신을 구현할 수 있기 때문에하지만 괜찮아요

817
00:50:45,970 --> 00:50:50,200
그리고이는, 입력라는 문자열을

818
00:50:50,200 --> 00:50:53,830
지금은이 문자열의 길이를 알아내는 필요합니다.

819
00:50:53,830 --> 00:50:55,880
그럼 어떻게이 작업을 수행 할 수 있습니까?

820
00:50:55,880 --> 00:51:00,190
내가하면 무엇을 - 당신은 무엇을 하시겠습니까 -의이 작업을 수행하는 방법을 보자?

821
00:51:00,190 --> 00:51:04,130
>> [안 들리게 학생 응답] >> 좋아요.

822
00:51:04,130 --> 00:51:05,970
그래서 우리는 여러 가지 방법으로 무리에서이 작업을 수행 할 수 있습니다. 내가이 방법을 시도 보자.

823
00:51:05,970 --> 00:51:10,220
내 자신에게 정수 variable 제가를 줘 보자, 그래서는 0시에 시작한다.

824
00:51:10,220 --> 00:51:19,380
그리고 내가이 말을하게 해줘 : 입력하는 동안 [I] 것과 같지 않음? \ 0.

825
00:51:19,380 --> 00:51:23,480
그럼, 프로그램에 그대로를 작성하는 모든 문자의 경우와 마찬가지로 밝혀

826
00:51:23,480 --> 00:51:25,940
당신은 작은 따옴표가 아닌 큰 따옴표를 사용해야합니다.

827
00:51:25,940 --> 00:51:29,250
나는 편지를 쓰고 있었다면, 내 말은, 문자 B를 그 짓을 했을까, 그렇게 할 것입니다.

828
00:51:29,250 --> 00:51:33,440
이 반면, 아닌 개별 문자 문자열 것입니다.

829
00:51:33,440 --> 00:51:38,470
>> 그래서 그대로 \ 0 원. 이 루프에서 어떻게할까요?

830
00:51:38,470 --> 00:51:42,650
사실, 다른 변수를 필요하므로 int는 길이가 0를 얻을 수 있습니다.

831
00:51:42,650 --> 00:51:46,190
우리가 그런 식으로 시작 왜 확인하지 못했다하더라도,

832
00:51:46,190 --> 00:51:50,110
우리가이 길을 따라 내려 간다 이젠, 내가 9 호선에서 어떻게할까요?

833
00:51:50,110 --> 00:51:55,820
길이 + + 그리고 여기 10 호선, 반품 길이 있습니다.

834
00:51:55,820 --> 00:51:58,370
그럼 나 strlen을 어떻게 구현?

835
00:51:58,370 --> 00:52:00,550
그것은 실제로 다음과 같이 아마도 구현있어.

836
00:52:00,550 --> 00:52:03,470
누가 알 - 아마 그 사람이 루프에 대한 사용 루프 동안, 어쩌면합니까?

837
00:52:03,470 --> 00:52:05,940
우리는 정말 실제 소스 코드 후드 아래 봐야 할

838
00:52:05,940 --> 00:52:08,520
일부 파일에있을 string.c했다.

839
00:52:08,520 --> 00:52:10,480
>> 하지만 여기가 내가 뭘하는지 생각해 보죠.

840
00:52:10,480 --> 00:52:13,640
나는 0은 동일한 설정, 난라는 변수를 선언거야.

841
00:52:13,640 --> 00:52:17,520
나는 그 때 0이 같은 설정, 다른 변수라는 길이를 선언거야.

842
00:52:17,520 --> 00:52:25,440
입력의 i 번째 문자는 특별한 널 문자 \ 0 같지 않음 동안 그 때 나는, 말

843
00:52:25,440 --> 00:52:27,070
길이를 증가.

844
00:52:27,070 --> 00:52:32,550
하지만 곧 i 번째 문자가 특수 문자이기 때문에, 어떻게 루프는 어떻게됩니까?

845
00:52:32,550 --> 00:52:36,540
이 단락. 그것은 어떤 우리가 다음 즉시 길이를 반환 의미하지 않습니다.

846
00:52:36,540 --> 00:52:40,740
>> 제가 엉망으로하지 않은 경우 그럼, 그럼 가서 내 터미널 창으로 돌아 가자.

847
00:52:40,740 --> 00:52:43,550
내가 다시 컴파일 보자. 그리고 망칠 않았습니다.

848
00:52:43,550 --> 00:52:46,320
라이브러리 함수 나 strlen 중 호환되지 않는 재 선언입니다.

849
00:52:46,320 --> 00:52:48,650
그래서 여기에 내 자신에게 좋은 일 더 영리려고했습니다.

850
00:52:48,650 --> 00:52:51,610
컴파일러는 실제로 나 strlen이라는 함수가 있다는 것을 알고

851
00:52:51,610 --> 00:52:55,290
우리는 라이브러리를 포함하지 않은 경우에도 마찬가지입니다. 괜찮아요. 뭐든간에.

852
00:52:55,290 --> 00:52:58,230
우리는 다음 협력거야. 의이 길이의 이름을 바꾸 보자.

853
00:52:58,230 --> 00:53:04,110
내가 여기서 길이로의 사용을 변경할 수 있으며,이 꽝이 행복 할 것입니다.

854
00:53:04,110 --> 00:53:08,900
- 옆 이러한 기능 중 일부는 매우 이놈의 일반적인 때문으로

855
00:53:08,900 --> 00:53:12,390
나 strlen, prinf - 실제로 특별한 상태 종류가 있습니다.

856
00:53:12,390 --> 00:53:15,310
그리고 꽝은 그들에 대한 특별한 뭔가를 조금 알고 있습니다.

857
00:53:15,310 --> 00:53:18,760
항상 대부분의 기능이있는 경우이 아니 잖아, 우리가 소리 질렀어요 했어 이유 죠 그럼.

858
00:53:18,760 --> 00:53:21,350
>> 다시 시도 보자. 다행히, 그 시간을 일했습니다.

859
00:53:21,350 --> 00:53:23,560
이제 내 자신의 나 strlen 프로그램을 실행할 수 있습니다.

860
00:53:23,560 --> 00:53:29,740
나에게 문자열을한다 : H-E-L-L-O 입력하십시오. 그리고 내가 잘못했다.

861
00:53:29,740 --> 00:53:34,750
이유는 무엇입니까? >> [안 들리게 학생 응답] >> 맞아.

862
00:53:34,750 --> 00:53:39,180
그래서 자신은 여기에 아주 좋은 모양의 무한 루프가

863
00:53:39,180 --> 00:53:42,270
I 각 반복에 길이를 증가 중이더라도 때문에,

864
00:53:42,270 --> 00:53:47,860
당신이 멍청하게 뭘하지 무엇입니까? 난 내가을 증가 아니에요. 좋아요. 쉽게 수정. 그래?

865
00:53:47,860 --> 00:53:52,430
좋아요. 제가 괄호를 필요로하는 곳에 번호 이제 우리는 다른 일반적인 실수에 걸렸나 것입니다.

866
00:53:52,430 --> 00:53:54,430
그리고 솔직히,이 코드는, 못 생겼군 시작

867
00:53:54,430 --> 00:53:56,460
그래서 우리는 순간에이 청소에 찔러 할게요.

868
00:53:56,460 --> 00:53:58,810
하지만 지금은 길이와 나는 모두를 증가거야.

869
00:53:58,810 --> 00:54:02,630
사실, 난 이미 개선을위한 기회를 볼 수 있지만, 우리는 그에게 다시 돌아 올꺼예요.

870
00:54:02,630 --> 00:54:05,270
>> 이제 그냥 우리가 진전 적어도있어하고 있는지 확인할 수 있습니다.

871
00:54:05,270 --> 00:54:08,320
이렇게하면 몇 일이 있었던, 나는 사전에이 얘기를 무시.

872
00:54:08,320 --> 00:54:12,420
이 같은 시나리오의 불행이 언제, 어떻게이 문제를 해결합니까

873
00:54:12,420 --> 00:54:15,130
어플라이언스를하거나 컴퓨터를 다시 시작하거나 창을 닫는 짧은?

874
00:54:15,130 --> 00:54:16,860
실제로 간단합니다.

875
00:54:16,860 --> 00:54:21,680
컨트롤 C는이 작은 당근 기호 C를 보내, 그리고 대부분의 프로그램을 종료 그 것이다.

876
00:54:21,680 --> 00:54:25,990
당신은 물건 무한히 여러 번 인쇄 할거야 정말 나쁜 무한 루프가있는 경우

877
00:54:25,990 --> 00:54:29,960
때때로 당신은 컨트롤 C에게 실제로 듣고 할 천 번을 누르해야 할 수도 있습니다.

878
00:54:29,960 --> 00:54:33,910
나는 매우 간단 아무것도, 인쇄 않아 있기 때문에 지금 알고 있습니다.

879
00:54:33,910 --> 00:54:37,970
그리고 기술적으로, 한 번 충분하지만 참을성이하고 나는 보통 그런 여러 번 누르십시오.

880
00:54:37,970 --> 00:54:43,400
>> 나 strlen 그럼. 나에게 문자열을한다 :여보세요. 만약이 시간이 될까?

881
00:54:44,580 --> 00:54:47,490
좋아요. 또 다른 일반적인 실수. 다시 컴파일해야합니다.

882
00:54:47,490 --> 00:54:50,430
그, 그건 의도적이었다. 괜찮아요.

883
00:54:50,430 --> 00:54:54,260
나 strlen 그래서, H-E-L-L-O 입력하십시오. 좋아요.

884
00:54:54,260 --> 00:54:55,910
그래서 우리는 지금 나 strlen 5가 있습니다.

885
00:54:55,910 --> 00:54:58,100
그래서 우리는 문자 그대로 바퀴를 다시 작성했습니다.

886
00:54:58,100 --> 00:55:02,080
이제이 나를 감동하지 않기 때문에가이 일을 청소 해

887
00:55:02,080 --> 00:55:04,080
내 코드의 디자인.

888
00:55:04,080 --> 00:55:07,200
우리는 명확하게이 일을 정리하는이 프로그램에 무엇을 제거 할 수 있습니까?

889
00:55:07,200 --> 00:55:11,840
[안 들리게 학생 응답] >> 그래. 그대로, 우리는 동일한 i와 길이를 치료하고 있습니다.

890
00:55:11,840 --> 00:55:16,440
그럼 왜 우리가 스마트하고 길이 동안 말하지?

891
00:55:16,440 --> 00:55:20,450
오히려, 그냥,로 시작하는 것이 길이 전화를 0으로 초기화 해

892
00:55:20,450 --> 00:55:23,340
우리가 무엇을 알아낼 때 기본적으로 문자열은 길이가 없기 때문입니다.

893
00:55:23,340 --> 00:55:26,160
>> 이제 우리는이 작업을 수행, 지금이 매우 우아한 프로그램입니다.

894
00:55:26,160 --> 00:55:28,660
하나의 변수. 나는 그것을 청소 그걸 강화.

895
00:55:28,660 --> 00:55:31,980
그래서 지금의 내 터미널 창으로 돌아 가자. 가 가서이를 실행할 수 있습니다.

896
00:55:31,980 --> 00:55:35,670
나 strlen하십시오. 괜찮아 보이는군요. 입력, 다시 나 strlen을 실행합니다.

897
00:55:35,670 --> 00:55:40,680
나에게 문자열을한다 : 안녕, 입력합니다. 그리고 5로 작동하는 것 같군.

898
00:55:40,680 --> 00:55:45,580
내가 쓴하지 않았다면 지금, HELLO 한 문자열에서, 예를 들어, 명확하게 할 수

899
00:55:45,580 --> 00:55:48,840
그리고 또 다른에서 BYE, 우리는 확실히 여러 단어를 할 수 있습니다.

900
00:55:48,840 --> 00:55:53,150
나는 실제로 입력 싶었던 그 표현은 HELLO은 아니 였지만, 예를 들어, 경우

901
00:55:53,150 --> 00:55:58,920
세계, 우리가하지 않았 으면하는 것이이 상황에 있다는 통지를 마우스 오른쪽여보세요?

902
00:55:58,920 --> 00:56:00,580
그거 2 문자열 있다는 제안합니다.

903
00:56:00,580 --> 00:56:06,060
당신은 확실히 우리가 실제로 더 이상 문구를 입력하면, 스페이스 바 문자를 가질 수

904
00:56:06,060 --> 00:56:08,390
HELLO 월드처럼, 우리는 정말 메모리에 무엇을하면 되겠습니까

905
00:56:08,390 --> 00:56:12,730
거기에 같은 뭔가를 조금 보입니다.

906
00:56:12,730 --> 00:56:18,910
>> 괜찮아요. 질문 한 다음 문자열 여기에 표현 은요?

907
00:56:18,910 --> 00:56:20,450
아냐? 괜찮아요.

908
00:56:20,450 --> 00:56:25,130
그래서 다시 나 strlen를 호출 한 후 다시 의도적으로 그런 식으로하는 이전했다

909
00:56:25,130 --> 00:56:28,070
당신은 일이 많이 일을 할 것 때문에 아마도 가장 좋은 생각이 아닙니다

910
00:56:28,070 --> 00:56:30,280
또 한번, 또 한번 다시.

911
00:56:30,280 --> 00:56:36,150
사실, 어떤 일의 종류 틀림없이, 문자열의 길이를 계산에 필요한입니까?

912
00:56:36,150 --> 00:56:40,720
당신은 처음부터 시작하고 봐, 봐, 봐이

913
00:56:40,720 --> 00:56:44,930
자네가 마침내 그 특수 문자가 나타날 때까지 어느 시점에, 아, 지금은 길이를 알아.

914
00:56:44,930 --> 00:56:48,040
따라서 이전에 우리가 나 strlen을 다시하고 다시하고 다시 호출되는했을 때,

915
00:56:48,040 --> 00:56:52,080
다시 그 문자열이 그런 식으로 보이기 때문 바보 같은 사람 이었어요 제가 제안 이유입니다.

916
00:56:52,080 --> 00:56:54,880
그것은 몇 가지 루프를 통해 당신은 반복 할 때마다 변하지 않아

917
00:56:54,880 --> 00:56:56,890
그래서 당신은 불필요한 작업을 다하고 있습니다.

918
00:56:56,890 --> 00:57:00,620
동시에 당신은 옆으로, 꽝처럼 그 컴파일러가이 일 알고 있어야

919
00:57:00,620 --> 00:57:02,530
오랜 세월에 걸쳐 개발되었으며,

920
00:57:02,530 --> 00:57:05,690
그리고 컴파일러 작가, 프로그래머, 예쁘고, 똑똑하고 있습니다.

921
00:57:05,690 --> 00:57:10,170
그리고는 꽝과 다른 컴파일러가 실제로 알아낼 수 있다는 밝혀 즉,

922
00:57:10,170 --> 00:57:13,650
알았어, 그래, 당신은 당신의 상태 나 strlen를 작성

923
00:57:13,650 --> 00:57:17,520
이는 기술적으로 우리가 다시 다시 다시 전화를 해 있다는 것을 의미합니다.

924
00:57:17,520 --> 00:57:21,880
그러나 스마트 컴파일러는 실제로 좋지 않은 사용자의 의사 결정의 이러한 종류의 최적화 할 수

925
00:57:21,880 --> 00:57:23,870
물건을 입히기 코드의 아웃.

926
00:57:23,870 --> 00:57:27,360
>> 그래서 가끔 컴파일러가 똑똑 우리보다이 생겼어

927
00:57:27,360 --> 00:57:29,210
그리고 가지 우리 자신의 실수를 숨 깁니다.

928
00:57:29,210 --> 00:57:31,620
그러나 확실히이 문제 세트와 같은 할 때

929
00:57:31,620 --> 00:57:35,340
이러한 근본적으로 잘못된 디자인 결정에 대해 생각해야합니까

930
00:57:35,340 --> 00:57:38,110
잠재적으로 우리가, 더 이상 일을하고있을 거라고 간단한 이유

931
00:57:38,110 --> 00:57:41,330
우리가 실제로해야 할보다. 그러나 얼마나 더 사용할 수 있습니까?

932
00:57:41,330 --> 00:57:44,960
HELLO WORLD의 경우,이 문제의 크기를 일반화하기 시작하자.

933
00:57:44,960 --> 00:57:48,100
문제의 길이 또는 문제의 크기는 무엇입니까

934
00:57:48,100 --> 00:57:50,770
때 단어를 입력 사용자가 HELLO입니까?

935
00:57:50,770 --> 00:57:53,790
그것은 아마도, 분명히 6 5입니다. 플러스 또는 마이너스 1. 뭐든간에.

936
00:57:53,790 --> 00:57:55,680
우리가 단지 5 부를 너무 가까이 있습니다.

937
00:57:55,680 --> 00:58:00,480
>> HELLO의 길이를 알아 내려고했을 때 문제의 크기가 뭐죠?

938
00:58:00,480 --> 00:58:06,790
그것은 마지막 문자에 어쩌면 1, 2, 3, 4, 5, 6 만, 일반화합시다 N로 그.

939
00:58:06,790 --> 00:58:10,300
따라서 N, 단지 변수 n은, 컴퓨터 과학자들은 일반적으로 사용 일입니다

940
00:58:10,300 --> 00:58:13,890
손에 문제의 크기, 문제를 설명하는 것은 HELLO 얼마나 걸리나요?

941
00:58:13,890 --> 00:58:17,050
나 strlen 시간이 얼마나 걸리나요?

942
00:58:17,050 --> 00:58:21,010
각 단계는 문자의 모양을 의미 곳, N 단계의 순서에 걸립니다

943
00:58:21,010 --> 00:58:23,350
문자 봐, 문자보세요.

944
00:58:23,350 --> 00:58:26,850
그리고 우리가 잠시 돌아 토론을 한 뒤, 작업의 수는 일이 소요됩니다.

945
00:58:26,850 --> 00:58:29,910
클래스의 첫날 우리는 모두가 어색, 일어나 있었다

946
00:58:29,910 --> 00:58:32,060
그리고 모두가 서로 떨어져 페어링 시작

947
00:58:32,060 --> 00:58:35,990
위해 실제로 방에 이상적으로 얼마나 많은 사람들이 있었 계산합니다.

948
00:58:35,990 --> 00:58:39,860
그리고 우리는 또한 다른 일을 한 상기 내가 대신 기존의 학교 방식으로 한 경우

949
00:58:39,860 --> 00:58:44,800
단지 등등 1, 2, 3, 4, 5, 6을 시작 및,

950
00:58:44,800 --> 00:58:49,360
그것도 그 문제의 크기는 크기 N의했다. 방에있는 N 사람들이 있었다.

951
00:58:49,360 --> 00:58:52,010
하지만, 권리를 그 속도를 수 있을까? 초등학교 스타일 나는 거 고요에 세는 수 있습니다.

952
00:58:52,010 --> 00:58:55,560
2, 4, 6, 8, 10, 12. 그리고 너무 빠르고, 실제로 그것이 느낀다.

953
00:58:55,560 --> 00:59:01,720
다른 4백명이 방에 들어올 경우이를 다시 그대로 두 번 빠른 속도로하지만

954
00:59:01,720 --> 00:59:08,250
한 번에 모든 그 알고리즘은 다른 400 또는 아마 한 200 단계를 수행합니다.

955
00:59:08,250 --> 00:59:13,310
>> 우리가 정말 똑똑하고 우리가 대신있는 경우 그러나 이와는 대조적으로, 당신의 모든이 스스로를 계산

956
00:59:13,310 --> 00:59:15,280
그 알고리즘이 작동하는 방식 기억.

957
00:59:15,280 --> 00:59:17,110
당신은 일어 섰다. 이렇게 빨리 감기 나합시다.

958
00:59:17,110 --> 00:59:20,430
당신은 당신의 절반 앉았다 후, 당신은 오프 짝 일어 서서,

959
00:59:20,430 --> 00:59:22,510
당신의 절반이 앉아 당신의 절반이 앉아서

960
00:59:22,510 --> 00:59:27,350
그리고 주 0이 루프의 각 반복에, 우리는 손에 문제를 halved

961
00:59:27,350 --> 00:59:30,040
그리고 다음에 n / 8, 다음에 n / 4, N / 2로 갔다.

962
00:59:30,040 --> 00:59:35,350
그리고의 의미는 그 다른 4백명은 방, 별거로 간다면

963
00:59:35,350 --> 00:59:40,120
그것은 우리에게없는 400 이상 발,하지 200 잔씩을 더 한 라운드를 취할 것입니다.

964
00:59:40,120 --> 00:59:43,640
그리고 우리가 돌​​아 잠시 말 이야기가있는 작은 일을했습니다.

965
00:59:43,640 --> 00:59:47,750
이 빨간 줄은 여기에 선형, 그것은 직선, 그리고 그것은 N로 표시 있어요

966
00:59:47,750 --> 00:59:50,250
문제의 크기가 증가하고 있는데,

967
00:59:50,250 --> 00:59:54,690
귀하의 알고리즘이나 프로그램이되는 당신이 해결하는 경우는, N 조치를 취하고 있습니다

968
00:59:54,690 --> 00:59:58,620
우리는 문제의 더 큰 크기 더 많은 시간을 소요 직선으로 할 수 있겠나.

969
00:59:58,620 --> 01:00:03,280
그리고 그냥 좀 더 나은 2 계산 twosies 방식, 4, 6, 8, 여전히 직선.

970
01:00:03,280 --> 01:00:08,440
조금 시간이 덜 걸립니다, 노란색 선은 지점에 대한 레드 라인 포인트 아래집니다.

971
01:00:08,440 --> 01:00:12,580
>> 그러나 더욱 우리는 로그 시간을 불렀이 성배를했습니다

972
01:00:12,580 --> 01:00:14,830
어디에서 다시 그 방에있는 사람의 수를 두 배로 경우에도하면,

973
01:00:14,830 --> 01:00:18,240
우리는, 클래스의 첫 번째 날부터 전화 번호부의 크기를 두 배로

974
01:00:18,240 --> 01:00:22,310
더 큰 문제는 그 1 개 페이지 눈물이 소요, 1 이상 앉아 다운을지지 않습니다

975
01:00:22,310 --> 01:00:25,550
두배로 크지 문제를 해결하기 위해 인치

976
01:00:25,550 --> 01:00:27,460
그리고 대화는 우리가 지금하는 것에 시작하게

977
01:00:27,460 --> 01:00:30,380
어떻게 실제로 효율적으로 문제를 해결합니까

978
01:00:30,380 --> 01:00:32,510
우리는이 같은 문제의 간단한을 고려? 경우

979
01:00:32,510 --> 01:00:36,210
우리는 몇 가지 숫자 뒤에있는 8 문이 있다고 가정합시다

980
01:00:36,210 --> 01:00:39,720
이러한 숫자의 각은 어떤 방식으로 정렬되지 않습니다

981
01:00:39,720 --> 01:00:42,830
그들은이 문 뒤에는 그냥 무작위 정수 야

982
01:00:42,830 --> 01:00:47,290
알고 - 우리는 어떻게 번호를 찾는 것에 대해 이동 않는 질문 -

983
01:00:47,290 --> 01:00:50,250
이 문 뒤에는 7?

984
01:00:50,250 --> 01:00:53,400
당신 인간이 나 한테 전화 번호 7을 찾기 위해 뭘 할 수

985
01:00:53,400 --> 01:00:56,810
다시이 각각 문하고 값을 볼 수있는 경우 당신은 문을 열어 있습니까?

986
01:00:56,810 --> 01:00:59,650
당신의 알고리즘은 아마도겠습니까?

987
01:00:59,650 --> 01:01:05,310
>> [안 들리게 학생 응답] >> 그럼 왼손으로 시작하고 문을 열어 문을 열어 문을 엽니 다.

988
01:01:05,310 --> 01:01:08,570
그리고 최악의 경우에, 얼마나 숫자 7을 찾으 걸릴까요?

989
01:01:08,570 --> 01:01:12,800
또, 그들은이 정렬되지하므로처럼 간단하지 않아있어, 음, 난 7 문을 열거야.

990
01:01:12,800 --> 01:01:15,240
그것은 maximally, 8 단계를 우리가 걸릴 수 있습니다.

991
01:01:15,240 --> 01:01:19,940
최악의 경우, 7, 문 줄의 맨 끝에서 무작위입니다

992
01:01:19,940 --> 01:01:22,090
그래서 우리는 모두 N 문을 시도해야 할 수도 있습니다.

993
01:01:22,090 --> 01:01:24,440
그러니 다시 여기, 우리는 선형 알고리즘을 갖고있는 것 같다.

994
01:01:24,440 --> 01:01:27,030
사실, 우리는 몇 년 만 전에 이런 짓을.

995
01:01:27,030 --> 01:01:29,910
당신의 전임자 중 하나가이 정확하게으로 도전했습니다

996
01:01:29,910 --> 01:01:32,050
우리는 디지털 버전이 아닌 곳에서, 우리는 대신 칠판을했다

997
01:01:32,050 --> 01:01:33,780
그 위에 종이 몇 조각으로.

998
01:01:33,780 --> 01:01:36,940
그리고 내가 할 것이라고 생각하는 것은,이 갔는지 방법에 대해 다시 한번 살펴봐입니다

999
01:01:36,940 --> 01:01:40,760
무대에서 최고의 아마 가장 어색한 기회 중 하나

1000
01:01:40,760 --> 01:01:42,530
여기에 샌더스의 데모를 가지고 있습니다.

1001
01:01:42,530 --> 01:01:44,000
우리는 숫자의 2 행을했다.

1002
01:01:44,000 --> 01:01:47,280
우리는이 행의 맨 위에에 션과 함께 어떻게 보는거야.

1003
01:01:47,280 --> 01:01:49,660
하지 않는 한 평화 아무도없는 CS50에서 자원 봉사자,

1004
01:01:49,660 --> 01:01:52,010
우리는 카메라에이 유지 션의 축복을했다

1005
01:01:52,010 --> 01:01:54,670
그래서 그는 사람들이 수백 년 동안 지금 이걸보고 된 것으로 알고 있습니다.

1006
01:01:54,670 --> 01:01:59,500
그러나 숀은 놀라운 일을 했어 - 혹은 그가 짓을 - 실제로 우리에게 특정 번호를 찾고에.

1007
01:01:59,500 --> 01:02:04,570
>> 그래서 우리가 오래 전에 대화를 재개 할 정도로 그는이 알고리즘을 해결하는 방법 보자

1008
01:02:04,570 --> 01:02:08,300
어떻게 우리는 효율적으로 일을 찾으십시오.

1009
01:02:08,300 --> 01:02:12,300
[비디오에 Malan] 나는,이 문 뒤에 숫자 7이 숨겨져 있습니다

1010
01:02:12,300 --> 01:02:16,710
하지만이 문 중 일부에 자리 잡고도 다른 음수가 아닌 숫자입니다

1011
01:02:16,710 --> 01:02:19,980
귀하의 목표는 배열로 숫자의 맨 위에 생각하는 것입니다

1012
01:02:19,980 --> 01:02:22,920
또는 뒤에 숫자에 종이 조각 중 순서,

1013
01:02:22,920 --> 01:02:26,960
귀하의 목표는 여기에 상위 배열을 사용하는 것입니다, 나 한테 전화 번호 7을 찾으십시오.

1014
01:02:26,960 --> 01:02:30,800
우리는 당신이 일을하는 방식 비판에 갈 수 있습니다. >> 좋아.

1015
01:02:30,800 --> 01:02:33,880
[Malan] 우리에게 숫자 7을 찾아주세요.

1016
01:02:36,210 --> 01:02:38,350
[웃음]

1017
01:02:41,610 --> 01:02:44,460
[Malan] 번호 [웃음]

1018
01:02:45,760 --> 01:02:58,080
5, 19, 13, [웃음]. 속임수의 질문이 아니 란다.

1019
01:03:00,560 --> 01:03:02,390
1.

1020
01:03:04,560 --> 01:03:06,910
[웃음]

1021
01:03:06,910 --> 01:03:10,760
이 시점에서 당신의 점수는 잘 못하므로뿐만 아니라 계속 할 수 있습니다. [웃음]

1022
01:03:12,490 --> 01:03:14,070
3.

1023
01:03:17,340 --> 01:03:23,480
에 이동합니다. 솔직히, 내가 도와하지만도에 대해 무슨 생각을하는지 궁금 할 수 없습니다. [웃음]

1024
01:03:25,010 --> 01:03:28,870
만 맨 위 행하기 때문에, 3 왼쪽있어. 그러니까 나 한테 7 찾습니다.

1025
01:03:28,870 --> 01:03:45,360
[학생들이 웅성 대는 소리]

1026
01:03:46,270 --> 01:03:49,870
[Malan]는 17.

1027
01:03:49,870 --> 01:03:55,460
[학생들이 웅성 대는 소리]

1028
01:03:56,920 --> 01:04:01,550
[Malan] 7! [박수]

1029
01:04:01,550 --> 01:04:06,080
>> 그럼 수요일에 우리는 물건을 찾는이 더 정교한 알고리즘에 뛰어 것이다.

1030
01:04:06,080 --> 01:04:10,200
지금 우리는 숀 당신을두고 갈 게요과 수요일에 당신을 참조하십시오.

1031
01:04:11,280 --> 01:04:13,000
[CS50.TV]