1
00:00:00,000 --> 00:00:02,480
>> [음악 재생]

2
00:00:02,480 --> 00:00:06,460

3
00:00:06,460 --> 00:00:09,350
>> DOUG 로이드 : 좋아, 이렇게하자
명령 줄 인수에 대해 이야기.

4
00:00:09,350 --> 00:00:11,800
그래서, 지금까지 과정에서 꽤
프로그램의 많은 모든

5
00:00:11,800 --> 00:00:16,360
아마 시작
이 항아리 INT 주요 무효 등을들 수있다.

6
00:00:16,360 --> 00:00:18,310
우리는 수집했습니다
사용자 입력 우리가 그것을 필요로하는 경우

7
00:00:18,310 --> 00:00:21,080
이러한 우리의 프로그램에
마리오 프로그램, 예를 들면,

8
00:00:21,080 --> 00:00:22,990
에서 프로그램의 지시에 의해.

9
00:00:22,990 --> 00:00:25,190
우리는 수정이 필요하지 않은
주의 선언,

10
00:00:25,190 --> 00:00:30,684
때문에 대신 주 우리의 내부
단지 당신이 INT를 얻기 위해 호출 할 수있다,라고.

11
00:00:30,684 --> 00:00:32,350
얼마나 큰 당신은 피라미드가되고 싶어합니까?

12
00:00:32,350 --> 00:00:34,455
아니면 얻기 위해 호출 할 수있다
얼마나 많은 변화를 float--

13
00:00:34,455 --> 00:00:36,400
사용자에게 나는 출력해야합니까?

14
00:00:36,400 --> 00:00:38,630
>> 또 다른 방법은, 비록 존재
우리는 우리의 사용자를 원하는 경우

15
00:00:38,630 --> 00:00:40,580
제공 할 수 있어야합니다
우리의 프로그램에 데이터

16
00:00:40,580 --> 00:00:43,320
대신 동안의 런타임
이 프로그램은 실행

17
00:00:43,320 --> 00:00:45,910
미묘한 차이지만
때로는 매우 유용 하나,

18
00:00:45,910 --> 00:00:48,120
우리는 주 선언의 새로운 형태가 필요합니다.

19
00:00:48,120 --> 00:00:53,320
우리는 우리가 원하는 경우 INT의 주요 공백​​을 사용할 수 없습니다
명령 줄에서 다른 데이터를 수집

20
00:00:53,320 --> 00:00:57,540
사용자가 프로그램을 실행할 때,
따라서 명령 줄 인수.

21
00:00:57,540 --> 00:00:59,810
>> 이 명령 줄을 수집하려면
사용자로부터 인수

22
00:00:59,810 --> 00:01:03,140
당신의 선언을 변경
이 항아리 INT처럼 주

23
00:01:03,140 --> 00:01:10,450
주요 오픈 괄호, INT의는 argc, 쉼표,
문자열 변수는 argv, 대괄호,

24
00:01:10,450 --> 00:01:12,670
다음 중괄호를 엽니 다.

25
00:01:12,670 --> 00:01:14,415
그래서 이미 무엇을 의미합니까?

26
00:01:14,415 --> 00:01:19,410
글쎄, 우리는 두 개의 매개 변수에 전달하는,
주 또는 인수, 또는 입력.

27
00:01:19,410 --> 00:01:23,800
하나는 정수라고
는 argc, 다른 하나는 무엇입니까?

28
00:01:23,800 --> 00:01:26,430

29
00:01:26,430 --> 00:01:29,640
그것은 바로, 문자열의 배열입니까?

30
00:01:29,640 --> 00:01:31,140
우리는 광장 브래킷 표기법을 참조하십시오.

31
00:01:31,140 --> 00:01:32,181
그것은 문자열의 배열입니다.

32
00:01:32,181 --> 00:01:35,110
그것은 각각의 문자열이 아니다,
그것은 문자열의 배열입니다.

33
00:01:35,110 --> 00:01:39,640
그리고이 두 인수는 argc와 argv를,
어떤 데이터를 사용자가 알 수 있도록

34
00:01:39,640 --> 00:01:42,912
명령 줄에서 제공하고 있습니다
얼마나 많은 것들을 그들

35
00:01:42,912 --> 00:01:44,120
명령 줄에서 제공했습니다.

36
00:01:44,120 --> 00:01:46,570
작업 할 꽤 유용한 것들.

37
00:01:46,570 --> 00:01:50,310
>> ARGC는 인수 개수를 의미합니다
당신이 방법에 의해, 알아야 할,

38
00:01:50,310 --> 00:01:52,600
당신은 ARGC 부를 수 있음
당신이 그것을 원하는대로.

39
00:01:52,600 --> 00:01:54,710
당신은 당신이 원하는 무엇이든 변수는 argv를 호출 할 수 있습니다.

40
00:01:54,710 --> 00:01:58,740
이 단지 기존의 이름입니다
우리가 them-- 인수 카운트에 사용하는,

41
00:01:58,740 --> 00:02:00,907
우리는 두 번째에서 살펴 보 겠지만,
인수 벡터, 변수는 argv.

42
00:02:00,907 --> 00:02:03,698
그러나 당신이 그들을 호출 할 필요가 없습니다
당신이 원하지 않는 경우는 argc와 argv를,

43
00:02:03,698 --> 00:02:05,570
하지만 통상적으로, 즉 우리가하는 일입니다.

44
00:02:05,570 --> 00:02:07,500
>> 어쨌든, ARGC 인수의 수입니다.

45
00:02:07,500 --> 00:02:11,569
그것은 정수 형 변수이고 그래서뿐만
우리는 두 가지를 가지고 있다면 당신은, 예상

46
00:02:11,569 --> 00:02:13,860
우리는 발견 할 거라고
이러한 입력하는지 알아

47
00:02:13,860 --> 00:02:16,070
얼마나 많은 물건
사용자 입력,는 argc이다

48
00:02:16,070 --> 00:02:18,559
얼마나 우리에게 얘기를하려고
사용자가 입력 한 물건.

49
00:02:18,559 --> 00:02:20,850
그것은 당신에게의 수를 제공합니다 그래서
명령 줄 인수 사용자

50
00:02:20,850 --> 00:02:22,470
프로그램이 실행될 때 입력.

51
00:02:22,470 --> 00:02:25,780
프로그램이 있다면
도트 욕심 슬래시 실행

52
00:02:25,780 --> 00:02:28,670
당신의 욕심의 내부
주요 기능을 프로그램

53
00:02:28,670 --> 00:02:34,800
선언 INT 주요 INT의 ARGC을 가지고,
문자열은 대괄호 argv를

54
00:02:34,800 --> 00:02:37,950
그 경우는 argc는 하나입니다.

55
00:02:37,950 --> 00:02:40,200
이제 우리는하지 않는주의
얼마나 많은 일을 계산

56
00:02:40,200 --> 00:02:42,590
사용자는 프로그램 이름 다음에 입력했습니다.

57
00:02:42,590 --> 00:02:46,710
프로그램 이름 자체가 계산
명령 줄 인수로.

58
00:02:46,710 --> 00:02:51,770
>> 그래서에, 욕심 슬래시 점
이 경우는, ARGC는 하나입니다.

59
00:02:51,770 --> 00:02:57,910
사용자는 슬래시 욕심 1024 CS50를 입력 한 경우
이 경우 argc의 명령 줄에서

60
00:02:57,910 --> 00:02:59,520
세 가지 일 것입니다.

61
00:02:59,520 --> 00:03:03,720
그리고 우리는 방법이 있기 때문에 이것을 알고
그 문자열 사이의 구분

62
00:03:03,720 --> 00:03:06,030
여부를 검출
공백이나 탭이있다,

63
00:03:06,030 --> 00:03:08,230
또는 그들 사이처럼 뭔가.

64
00:03:08,230 --> 00:03:13,860
그래서 공백의 양, 소위,
값 사이에 명령 줄을 입력

65
00:03:13,860 --> 00:03:15,720
얼마나 많은 나타냅니다.

66
00:03:15,720 --> 00:03:24,040
그래서 욕심 공간 1024 공간을 슬래시 점
CS50는 ARGC, 그 경우, 세이다.

67
00:03:24,040 --> 00:03:26,600
>> ARGV 인수 벡터이다.

68
00:03:26,600 --> 00:03:29,240
벡터, 그런데, 그냥
배열에 대한 또 다른 단어,

69
00:03:29,240 --> 00:03:31,510
이것은 배열입니다
그 문자열을 저장한다.

70
00:03:31,510 --> 00:03:35,540
인 요소마다 1 개의 문자열,
스트링이 사용자 실제로

71
00:03:35,540 --> 00:03:39,230
명령 줄에서 입력
프로그램이 실행되었을 때.

72
00:03:39,230 --> 00:03:40,990
이제, AS는 경우입니다
어떤 배열로, 당신의 경우

73
00:03:40,990 --> 00:03:44,380
우리의 논의에서 리콜
배열 변수는 argv의 첫 번째 요소

74
00:03:44,380 --> 00:03:49,150
항상 발견 할 것입니다
argv를 대괄호 제로.

75
00:03:49,150 --> 00:03:51,800
즉, 최초의 인덱스의
argv 배열의.

76
00:03:51,800 --> 00:03:55,720
너무 will-- 그리고 사실, 그 의지
항상 프로그램의 이름,

77
00:03:55,720 --> 00:03:59,730
항상에 위치 할 것
argv를 대괄호 제로.

78
00:03:59,730 --> 00:04:08,590
>> 변수는 argv의 마지막 요소는 항상 발견
argv를 대괄호의 ARGC을 뺀에서.

79
00:04:08,590 --> 00:04:10,300
당신은 왜 보는가?

80
00:04:10,300 --> 00:04:14,180
얼마나 많은 요소를 기억
이 배열에 존재한다.

81
00:04:14,180 --> 00:04:16,660
음, 우리는 하라구, 그건 .. 알고
요소는 argc 번호.

82
00:04:16,660 --> 00:04:21,279
사용자가에서 세 가지를 입력 한 경우
명령 줄은 ARGC 세 가지입니다.

83
00:04:21,279 --> 00:04:27,070
그러나 때문에 C에서, 때 우리는 최선을 다하고 있습니다
어레이와, 상기 어레이의 각 요소,

84
00:04:27,070 --> 00:04:30,190
또는 오히려 지수
배열, 제로에서 시작합니다.

85
00:04:30,190 --> 00:04:34,000
우리는 세 가지 요소가있는 경우 우리의
배열, 우리는 argv를 제로 요소가

86
00:04:34,000 --> 00:04:37,930
argv를 하나의 요소,
argv를 두에 및 요소입니다.

87
00:04:37,930 --> 00:04:41,700
변수는 argv에서 어떤 요소가 없습니다
세 및 크기의 세 어레이.

88
00:04:41,700 --> 00:04:43,990
그래서 왜 마지막이다
변수는 argv의 요소는 항상 수

89
00:04:43,990 --> 00:04:49,510
변수는 argv 광장에서 찾을 수
브라켓는 argc 뺀.

90
00:04:49,510 --> 00:04:52,420
>> 그럼 사용자가 실행을 가정하자
follows--과 욕심 프로그램

91
00:04:52,420 --> 00:04:57,970
그들은 명령 줄 점에 입력하면
욕심 공간 1,024 공간 CS50 슬래시

92
00:04:57,970 --> 00:05:00,720
그리고 어떤 이유에서 우리는했습니다
이미 우리의 욕심 프로그램을 준비

93
00:05:00,720 --> 00:05:04,050
알고 이러한 작업을하려면
명령 줄 인수.

94
00:05:04,050 --> 00:05:07,030
우리가 일을 할 때 우리는 이전에하지 않았다
욕심이 문제에 대한 그것에,

95
00:05:07,030 --> 00:05:09,660
하지만 이제 우리가 지금 수정 한 가정 해 봅시다
이 때문에 우리는 과정을

96
00:05:09,660 --> 00:05:11,480
어떤 식 으로든 명령 줄 인수.

97
00:05:11,480 --> 00:05:15,720
이 경우, 제로 argv를
점 슬래시는 욕심이다.

98
00:05:15,720 --> 00:05:17,042
변수는 argv 하나는 무엇입니까?

99
00:05:17,042 --> 00:05:19,030
글쎄, 그것은 바로 1024입니까?

100
00:05:19,030 --> 00:05:22,620
그것은 1024, 그러나 여기에서의
정말 중요한 distinction--

101
00:05:22,620 --> 00:05:26,410
당신은 변수는 argv의 데이터 유형을 기억 하는가?

102
00:05:26,410 --> 00:05:31,020
>> 그것은 바로, 문자열을 저장?

103
00:05:31,020 --> 00:05:34,140
그러나 1024처럼 보인다
정수 값이다.

104
00:05:34,140 --> 00:05:36,530
이것은 정말 중요하다
구분하고, 실제로

105
00:05:36,530 --> 00:05:40,200
뭔가 될 것 당신을
나중에 문제가 발생할 수 있습니다.

106
00:05:40,200 --> 00:05:43,770
변수는 argv의 모든입니다
문자열로 저장됩니다.

107
00:05:43,770 --> 00:05:48,775
그래서 argv를 하나의 내용은
하나의 문자열, 제로, 2, 4,

108
00:05:48,775 --> 00:05:50,275
그 네 개의 문자로 구성된.

109
00:05:50,275 --> 00:05:53,870
그것은 사용자가 입력 한 경우로서있어
하나, 제로, 2, 4

110
00:05:53,870 --> 00:05:56,680
개별 문자 또는 문자로.

111
00:05:56,680 --> 00:06:00,730
또한, 정수 1,024 아니다
그래서 당신이 직접 할 수 없습니다

112
00:06:00,730 --> 00:06:11,580
INT 1,000을 말하여 작업, 또는
오히려 INT X는 argv를 하나의 마이너스 24 같습니다.

113
00:06:11,580 --> 00:06:15,550
>> 직관적으로, 당신은 생각할 수 있습니다
확인, 잘가 1,024 마이너스 (24)의 등

114
00:06:15,550 --> 00:06:17,920
그래서 X는 1000과 동일하다.

115
00:06:17,920 --> 00:06:22,020
그러나 사실, 즉, 그렇지 않다
argv를 하나의 캐릭터이기 때문이다.

116
00:06:22,020 --> 00:06:23,940
문자열 1024.

117
00:06:23,940 --> 00:06:28,739
지금 할 수있는 기능이있다
정수로 문자열을 변환하는 데 사용됩니다.

118
00:06:28,739 --> 00:06:30,780
나는 당신을 위해 그것을 망치고되지 않습니다
지금,하지만 난 Zamyla 확신

119
00:06:30,780 --> 00:06:34,380
에 대해 말씀 드릴 것입니다
미래의 문제에 대한 연습.

120
00:06:34,380 --> 00:06:36,390
그러나 당신은 또한 찾을 수 있습니다
문제가 그때 엔 변명

121
00:06:36,390 --> 00:06:39,921
나, 함수는 것
참조 50에서이 작업을 수행,

122
00:06:39,921 --> 00:06:42,462
당신은 참조 가이드에 가면
당신은 함수를 찾을 수

123
00:06:42,462 --> 00:06:43,820
당신이 변환을 할 것입니다.

124
00:06:43,820 --> 00:06:45,980
그러나 다시, 연습에
미래의 문제에 대한,

125
00:06:45,980 --> 00:06:48,290
Zamyla는 드릴 것입니다
어떤 기능을 알려

126
00:06:48,290 --> 00:06:53,280
그것은 그 변환 것이다
정수 1024 문자열 1024.

127
00:06:53,280 --> 00:06:54,560
>> 좋아, 그래서 이동.

128
00:06:54,560 --> 00:06:56,726
우리는 우리의 변수는 argv의 제로 다루었
우리는 하나의 argv를 다루었 다.

129
00:06:56,726 --> 00:06:58,000
무엇 argv를 두입니까?

130
00:06:58,000 --> 00:06:58,620
CS50.

131
00:06:58,620 --> 00:07:01,350
그 하나는 아마
꽤 자기 ​​설명.

132
00:07:01,350 --> 00:07:02,950
어떻게 변수는 argv 세에입니까?

133
00:07:02,950 --> 00:07:04,970
그럼 다시, 우리가 정말 모르는, 오른쪽?

134
00:07:04,970 --> 00:07:08,060
우리는 세 가지 크기의 배열을 가지고
그 얼마나 많은 요소를 사용자의

135
00:07:08,060 --> 00:07:11,610
명령 줄에서 입력,
그래서 우리는 세 가지를 argv를 갈 경우,

136
00:07:11,610 --> 00:07:14,660
우리는 지금 넘고있어
우리의 배열의 범위.

137
00:07:14,660 --> 00:07:18,570
컴파일러는, 우리는이 작업을 수행 할 수있게된다
더 직관적 인 문제가 그것으로이 없다,

138
00:07:18,570 --> 00:07:22,890
그러나 사실의 관점에서 무엇을거야
일이, 우리는 정말로 알지 못한다.

139
00:07:22,890 --> 00:07:25,380
그것은 무엇에 따라 달라집니다
메모리 곳에 위치

140
00:07:25,380 --> 00:07:28,060
argv를 세가 될 것으로 예상된다.

141
00:07:28,060 --> 00:07:30,716
그래서 우리가 끝낼 수
멀리 스코틀랜드 무료로 받고.

142
00:07:30,716 --> 00:07:33,840
더 많은 가능성이없는 이상, 특히
반대로 당신은 argv를 사용하여 작업하는

143
00:07:33,840 --> 00:07:35,548
다른 배열에
즉, 우리의 프로그램에의

144
00:07:35,548 --> 00:07:38,660
우리는 아마 고통을거야
세그먼트 오류. 그래서 다시,

145
00:07:38,660 --> 00:07:42,756
경계를 지나쳐 않도록주의해야
당신의 배열, 특히 argv를,

146
00:07:42,756 --> 00:07:47,170
의 높은 수준의 주어진
프로그램의 중요성.

147
00:07:47,170 --> 00:07:48,100
>> 나는 더그 로이드입니다.

148
00:07:48,100 --> 00:07:50,170
이 CS50입니다.

149
00:07:50,170 --> 00:07:51,457