1
00:00:00,000 --> 00:00:06,030
>> [음악 재생]

2
00:00:06,030 --> 00:00:08,390
>> DOUG 로이드 : 포인터, 여기에 우리가 있습니다.

3
00:00:08,390 --> 00:00:11,080
이것은 아마도에 가고
가장 어려운 화제

4
00:00:11,080 --> 00:00:12,840
우리는 CS50에 대해 이야기하는 것이.

5
00:00:12,840 --> 00:00:15,060
그리고 당신이 읽은 경우
포인터에 대해 아무것도

6
00:00:15,060 --> 00:00:19,080
당신은 조금있을 수 있습니다 전에
협박이 비디오로 전환.

7
00:00:19,080 --> 00:00:21,260
그것은 포인터 사실
당신에게 능력을 허용합니다

8
00:00:21,260 --> 00:00:23,740
아마 망치
꽤 심하게 당신이있을 때

9
00:00:23,740 --> 00:00:27,450
변수 및 데이터 작업,
당신의 프로그램이 충돌을 일으키는.

10
00:00:27,450 --> 00:00:30,490
하지만 실제로는 정말 유용하다
그리고 그들은 우리에게 정말 좋은 방법 허용

11
00:00:30,490 --> 00:00:33,340
다시 데이터를 전달하고,
앞으로 기능과,

12
00:00:33,340 --> 00:00:35,490
것을 우리는 그렇게 할 수 없습니다.

13
00:00:35,490 --> 00:00:37,750
>> 그래서 우리 정말
기차가 여기에 수행 할

14
00:00:37,750 --> 00:00:41,060
당신은 좋은 포인터 훈련, 그래서하기
당신은 효과적으로 포인터를 사용할 수있는

15
00:00:41,060 --> 00:00:43,850
당신의 프로그램이 훨씬 더 확인합니다.

16
00:00:43,850 --> 00:00:48,220
내가 말했듯이 포인터는 우리에게 다른 줄
방법은 함수 사이에 데이터를 전달합니다.

17
00:00:48,220 --> 00:00:50,270
지금 당신은 기억 경우
이전 비디오, 때

18
00:00:50,270 --> 00:00:53,720
우리에 대해 얘기했다
변수 범위, 내가 언급

19
00:00:53,720 --> 00:01:00,610
우리가 사이를 통과하는 모든 데이터
C 함수는 값에 의해 전달됩니다.

20
00:01:00,610 --> 00:01:03,070
그리고 나는 것을 사용하지 않았을 수 있습니다
용어는 내가 거기에 의미, 무엇을

21
00:01:03,070 --> 00:01:07,170
우리는 데이터의 사본을 전달하는 것이 었습니다.

22
00:01:07,170 --> 00:01:12,252
우리가 함수에 변수를 전달하면,
우리는 실제로 변수를 전달하지 않을

23
00:01:12,252 --> 00:01:13,210
함수에, 오른쪽?

24
00:01:13,210 --> 00:01:17,670
우리의 사본을 전달하는
함수에 데이터.

25
00:01:17,670 --> 00:01:20,760
이 기능은 무엇을 의지합니까
그것은 어떤 값을 산출하고,

26
00:01:20,760 --> 00:01:23,180
어쩌면 우리는 그 값을 사용
그것을 다시 줄 때.

27
00:01:23,180 --> 00:01:26,700
>> 하나의 예외가 발생했습니다
값으로 전달이 규칙,

28
00:01:26,700 --> 00:01:31,210
우리는 무엇을 그에게 돌아올 것이다
이 비디오에 나중에 조금.

29
00:01:31,210 --> 00:01:34,880
우리는 대신 포인터를 사용하는 경우
변수를 사용하여,

30
00:01:34,880 --> 00:01:38,180
또는 변수를 사용하는 대신
자신이나 변수의 사본,

31
00:01:38,180 --> 00:01:43,790
우리는 지금 주변의 변수를 전달할 수 있습니다
다른 방법으로 함수 사이.

32
00:01:43,790 --> 00:01:46,550
이것은 우리가 만들면 것을 의미한다
하나의 기능의 변화,

33
00:01:46,550 --> 00:01:49,827
그 변화는 실제로 소요됩니다
다른 기능에 영향을.

34
00:01:49,827 --> 00:01:52,160
다시, 이것은 뭔가입니다
우리는 이전에 할 수 없었다

35
00:01:52,160 --> 00:01:56,979
당신은 이제까지을 교환하려고 한 경우
함수에서 두 변수의 값,

36
00:01:56,979 --> 00:01:59,270
이 문제가 나타났습니다
들어온다의 종류, 오른쪽?

37
00:01:59,270 --> 00:02:04,340
>> 우리는 X와 Y, 그리고 우리를 교체하려면
스왑라는 함수에 전달,

38
00:02:04,340 --> 00:02:08,680
함수의 내부를 스왑
변수는 환율 값을한다.

39
00:02:08,680 --> 00:02:12,600
하나는 두 가지가되고, 두된다
하나, 그러나 우리는 실제로하지 않습니다

40
00:02:12,600 --> 00:02:16,890
원래 아무것도 변경
함수를 호출한다.

41
00:02:16,890 --> 00:02:19,550
때문에 우리가 할 수없는, 우리가있어 단지
이들의 사본과 함께 작동합니다.

42
00:02:19,550 --> 00:02:24,760
하지만 포인터, 우리는 할 수
실제로 함수에 X와 Y를 전달합니다.

43
00:02:24,760 --> 00:02:26,960
그 기능을 수행 할 수 있습니다
그들과 함께 무엇인가.

44
00:02:26,960 --> 00:02:29,250
그리고 그 변수 값
실제로 변경할 수 있습니다.

45
00:02:29,250 --> 00:02:33,710
그래서 상당히 변화입니다
데이터로 작업 할 수있는 능력.

46
00:02:33,710 --> 00:02:36,100
>> 우리는에 뛰어 전에
포인터, 나는 그것이 가치가 있다고 생각

47
00:02:36,100 --> 00:02:38,580
몇 분을 복용
여기에 다시 기초로 이동합니다.

48
00:02:38,580 --> 00:02:41,000
그리고 방법을 살펴있다
컴퓨터 메모리 작동

49
00:02:41,000 --> 00:02:45,340
이 두 과목이 진행되기 때문에
실제로 꽤 상호합니다.

50
00:02:45,340 --> 00:02:48,480
당신은 아마 알다시피,
컴퓨터 시스템에

51
00:02:48,480 --> 00:02:51,310
하드 드라이브를하거나
아마도 솔리드 스테이트 드라이브,

52
00:02:51,310 --> 00:02:54,430
파일 저장 위치의 일종.

53
00:02:54,430 --> 00:02:57,950
그것은 보통의 어딘가에
2백50기가바이트의 이웃

54
00:02:57,950 --> 00:02:59,810
지금 테라 바이트의 아마 몇합니다.

55
00:02:59,810 --> 00:03:02,270
그리고 그것의 위치를​​ 모두의 당신의
파일은 궁극적으로, 라이브

56
00:03:02,270 --> 00:03:04,870
컴퓨터가 종료되는 경우에도
오프, 당신은 다시 전원을 켜십시오 수 있습니다

57
00:03:04,870 --> 00:03:09,190
당신은 당신의 파일이 찾을 수
다시 당신은 당신의 시스템을 재부팅 할 때.

58
00:03:09,190 --> 00:03:14,820
하지만, 하드 디스크 드라이브 등의 디스크 드라이브,
하드 디스크 또는 솔리드 스테이트 드라이브, SSD,

59
00:03:14,820 --> 00:03:16,050
바로 저장 공간입니다.

60
00:03:16,050 --> 00:03:20,400
>> 우리는 실제로으로 아무것도 할 수 없습니다
하드 디스크에 데이터,

61
00:03:20,400 --> 00:03:22,080
또는 솔리드 스테이트 드라이브에.

62
00:03:22,080 --> 00:03:24,950
실제로 변경하려면
데이터하거나 이동할,

63
00:03:24,950 --> 00:03:28,800
우리는 그것을 이동해야
RAM, 랜덤 액세스 메모리.

64
00:03:28,800 --> 00:03:31,170
이제 RAM, 당신은 많이
컴퓨터에서의 적은.

65
00:03:31,170 --> 00:03:34,185
당신은 어딘가에있을 수 있습니다
512메가바이트의 이웃

66
00:03:34,185 --> 00:03:38,850
당신은 오래된 컴퓨터를 사용하는 경우,
아마에 2, 4, 8, 16,

67
00:03:38,850 --> 00:03:41,820
어쩌면 조금
이상, RAM의 기가 바이트.

68
00:03:41,820 --> 00:03:46,390
그래서 훨씬 작은,하지만 그건
여기서 휘발성 데이터 모두가 존재한다.

69
00:03:46,390 --> 00:03:48,270
우리가 상황을 타개 할 수 있습니다 곳이다.

70
00:03:48,270 --> 00:03:53,350
그러나 우리는 우리의 컴퓨터의 전원을 켤 때,
RAM에 모든 데이터가 파괴된다.

71
00:03:53,350 --> 00:03:57,150
>> 우리는 하드 디스크가 필요 왜 그렇게 그건
그것의 더 영구적 인 위치,

72
00:03:57,150 --> 00:03:59,720
이 exists- 있도록 그것은 것
정말 나쁜 경우마다 우리

73
00:03:59,720 --> 00:04:03,310
우리의 컴퓨터를 끌 때마다
우리의 시스템에서 파일이 말소되었다.

74
00:04:03,310 --> 00:04:05,600
그래서 우리는 RAM의 내부에서 작업.

75
00:04:05,600 --> 00:04:09,210
그리고 때마다 우리에 대해 얘기하고
메모리, 거의, CS50에서,

76
00:04:09,210 --> 00:04:15,080
우리는 RAM이 아닌 하드 디스크에 대해 얘기하고.

77
00:04:15,080 --> 00:04:18,657
>> 그래서 우리는 메모리에 물건을 이동할 때,
그것의 일부 공간을 차지한다.

78
00:04:18,657 --> 00:04:20,740
데이터 유형의 모든
우리는 함께 일한지

79
00:04:20,740 --> 00:04:23,480
최대 다른 걸릴
RAM의 공간의 양.

80
00:04:23,480 --> 00:04:27,600
그래서 때마다 당신은 정수를 만들
메모리의 변수, 4 바이트

81
00:04:27,600 --> 00:04:30,750
당신 때문에 RAM에 따로 설정
그 정수로 작업 할 수 있습니다.

82
00:04:30,750 --> 00:04:34,260
당신은 정수를 선언 할 수 있습니다,
변경, 할당

83
00:04:34,260 --> 00:04:36,700
증가 값 10
하나, 등등 등등으로.

84
00:04:36,700 --> 00:04:39,440
에 일어날 필요가있는 모든
RAM, 당신은 4 바이트를 얻을

85
00:04:39,440 --> 00:04:42,550
모든에 대한 작업을하려면
사용자가 만든 정수입니다.

86
00:04:42,550 --> 00:04:45,410
>> 모든 문자 당신에게
생성 한 바이트를 가져옵니다.

87
00:04:45,410 --> 00:04:48,160
즉 공간이 얼마나이다
문자를 저장하는 데 필요한.

88
00:04:48,160 --> 00:04:51,310
모든 플로트, 실제
수, 4 바이트를 가져옵니다

89
00:04:51,310 --> 00:04:53,390
그것은 이중 않는 한
정밀도 부동 소수점

90
00:04:53,390 --> 00:04:56,510
당신을 수 수,
더 정확한 이상의 숫자가

91
00:04:56,510 --> 00:04:59,300
소수점
정밀도를 잃지 않고,

92
00:04:59,300 --> 00:05:01,820
이는 메모리의 8 바이트를 차지합니다.

93
00:05:01,820 --> 00:05:06,730
긴 걷고, 정말 큰 정수,
또한 메모리의 8 바이트를 차지합니다.

94
00:05:06,730 --> 00:05:09,000
얼마나 많은 메모리 바이트
문자열을 차지합니까?

95
00:05:09,000 --> 00:05:12,990
음의 그 질문에 핀을 넣어 보자
지금, 그러나 우리는 다시 돌아올 것이다.

96
00:05:12,990 --> 00:05:17,350
>> 그래서 다시 메모리의이 아이디어로에
바이트 크기의 셀들의 큰 어레이.

97
00:05:17,350 --> 00:05:20,871
즉, 정말 모든, 그것은이다
세포의 단지 거대한 배열,

98
00:05:20,871 --> 00:05:23,370
단지 다른 배열과 같은 그
당신이 익숙하고 참조

99
00:05:23,370 --> 00:05:26,430
모든 요소를​​ 제외하고 하나의 바이트 폭이다.

100
00:05:26,430 --> 00:05:30,030
그냥 배열과 같은,
모든 요소는 주소를 가지고 있습니다.

101
00:05:30,030 --> 00:05:32,120
배열의 모든 요소
인덱스, 우리가 있습니다

102
00:05:32,120 --> 00:05:36,302
소위 할 그 인덱스를 사용할 수 있습니다
배열에 랜덤 액세스.

103
00:05:36,302 --> 00:05:38,510
우리는 시작하지 않아도
어레이의 시작,

104
00:05:38,510 --> 00:05:40,569
모든 반복
하나의 요소 그,

105
00:05:40,569 --> 00:05:41,860
우리가 원하는 것을 찾을 수 있습니다.

106
00:05:41,860 --> 00:05:45,790
우리는 단지 내가 도착하고 싶은 말을 할 수 있습니다
15 요소 또는 100 번째 요소입니다.

107
00:05:45,790 --> 00:05:49,930
그리고 당신은 그 수에 전달할 수 있습니다
당신이 찾고있는 값을 얻을.

108
00:05:49,930 --> 00:05:54,460
>> 마찬가지로 모든 위치
메모리에 주소가 있습니다.

109
00:05:54,460 --> 00:05:57,320
그래서 당신의 기억은 수도
이 같은 모습.

110
00:05:57,320 --> 00:06:01,420
여기서 매우 작은 청크이다
메모리는,이 메모리는 20 바이트이다.

111
00:06:01,420 --> 00:06:04,060
처음 20 바이트 때문에 내
맨 아래에있는이 주소

112
00:06:04,060 --> 00:06:08,890
3, 2, 1, 0이며, 그래서
19까지의 모든 길에.

113
00:06:08,890 --> 00:06:13,190
그리고 변수를 선언 할 때와
나는 그들과 함께 일을 시작할 때,

114
00:06:13,190 --> 00:06:15,470
시스템 설정하는 것입니다
나를 위해 옆으로 일부 공간

115
00:06:15,470 --> 00:06:17,595
이 메모리에서 작동합니다
내 변수.

116
00:06:17,595 --> 00:06:21,610
그래서 문자 C가 자본에 해당 말할 수 있습니다
H. 그리고 무슨 일이 일어날?

117
00:06:21,610 --> 00:06:23,880
음 시스템에가는
나 하나의 바이트 따로 설정합니다.

118
00:06:23,880 --> 00:06:27,870
이 경우는 바이트 수를 선택한
네, 주소 네의 바이트,

119
00:06:27,870 --> 00:06:31,310
그리고 저장할 것
나를 위해 거기에 편지 자본 H.

120
00:06:31,310 --> 00:06:34,350
그때 INT 속도를 말한다면
제한이있어, 65 같음

121
00:06:34,350 --> 00:06:36,806
옆으로 네 가지를 설정하는 것
나를 위해 메모리의 바이트.

122
00:06:36,806 --> 00:06:39,180
그리고 그것은 사람들을 치료하는거야
하나의 단위로 4 바이트

123
00:06:39,180 --> 00:06:41,305
우리가 최선을 다하고 무엇 때문에
와 여기에 정수입니다.

124
00:06:41,305 --> 00:06:44,350
그리고 거기에 65을 저장하는 것입니다.

125
00:06:44,350 --> 00:06:47,000
>> 지금 이미 나는 가지 해요
당신에게 거짓말의 조금을 말하고,

126
00:06:47,000 --> 00:06:50,150
바로, 우리는 것을 알고 있기 때문에
컴퓨터는 바이너리에서 작동합니다.

127
00:06:50,150 --> 00:06:53,100
그들은 이해하지 않는다
반드시 자본 H가 무엇인지

128
00:06:53,100 --> 00:06:57,110
또는 (65)는 그들 만, 무엇인가
이진, 0과 1을 이해합니다.

129
00:06:57,110 --> 00:06:59,000
그리고 실제로 무엇을
우리는 거기에 저장하고

130
00:06:59,000 --> 00:07:03,450
편지 H와 수 (65)는 아니다
오히려 이진 표현

131
00:07:03,450 --> 00:07:06,980
그 어느 봐
이 같은 작은 선물.

132
00:07:06,980 --> 00:07:10,360
그리고 특히에
정수 변수의 맥락

133
00:07:10,360 --> 00:07:13,559
그것은 단지 그것을에 침 않을거야
그것은 1 ~ 4로 처리하지 않을 것

134
00:07:13,559 --> 00:07:15,350
바이트 청크 반드시,
실제로거야

135
00:07:15,350 --> 00:07:19,570
4 대 1 바이트 청크로 치료하기 위해,
이는 다음과 같을 수 있습니다.

136
00:07:19,570 --> 00:07:22,424
심지어이 아니다
완전히 사실 하나,

137
00:07:22,424 --> 00:07:24,840
라는 뭔가 때문에
우리가하지 않은 엔디안,

138
00:07:24,840 --> 00:07:26,965
지금에 들어갈 예정이지만
당신에 대한 호기심이 있다면,

139
00:07:26,965 --> 00:07:29,030
당신은 작은에서 읽을 수 있습니다
큰 엔디안.

140
00:07:29,030 --> 00:07:31,640
그러나이 인수를 위해,
이 동영상을 위해,

141
00:07:31,640 --> 00:07:34,860
그냥 그에서, 가정하자
사실, 어떻게 수 (65)는 것

142
00:07:34,860 --> 00:07:36,970
표현 될
모든 시스템의 메모리,

143
00:07:36,970 --> 00:07:38,850
그것은 전혀 사실이 아니다 있지만.

144
00:07:38,850 --> 00:07:41,700
>> 그러나의 사실 그냥하자
완전히 모든 이진 제거,

145
00:07:41,700 --> 00:07:44,460
단지 H와 같은 생각
65, 그것은 훨씬 쉽게

146
00:07:44,460 --> 00:07:47,900
같은 그것에 대해 생각합니다
인간으로서 그.

147
00:07:47,900 --> 00:07:51,420
좋아, 그것은 또한 같다 그래서 아마
작은 임의의 그 I've- 내 시스템

148
00:07:51,420 --> 00:07:55,130
바이트 5, 6, 7 나를 포기하지 않았다,
및도 8은 정수를 저장한다.

149
00:07:55,130 --> 00:07:58,580
그 이유는, 너무, 거기에있는
우리는 지금에 들어가,하지만 충분하지 않습니다

150
00:07:58,580 --> 00:08:00,496
그것은 그 어떤 대답
컴퓨터가 여기하고있다

151
00:08:00,496 --> 00:08:02,810
아마 그 부분에서 좋은 움직임이다.

152
00:08:02,810 --> 00:08:06,020
나에게 메모리를 제공하지 않으려면
반드시 다시 다시.

153
00:08:06,020 --> 00:08:10,490
지금은 그것을 할 것이지만
내가 다른 문자열을 얻으려면,

154
00:08:10,490 --> 00:08:13,080
성 (姓)라고, 내가 원하는
거기에 로이드을 넣어.

155
00:08:13,080 --> 00:08:18,360
나는 하나에 맞게 필요 해요
문자는, 그 각각의 편지입니다

156
00:08:18,360 --> 00:08:21,330
하나를 요구하는 것
캐릭터, 1 바이트 메모리.

157
00:08:21,330 --> 00:08:26,230
내 배열로 로이드를 넣을 수 그래서 만약
이 같은 난 지금, 갈 꽤 좋은거야?

158
00:08:26,230 --> 00:08:28,870
무엇을 누락?

159
00:08:28,870 --> 00:08:31,840
>> 모든 문자열 우리가 일하는 것을 기억하십시오
C는 백 슬래시 0으로 종료에와,

160
00:08:31,840 --> 00:08:33,339
우리는 하나, 여기에 생략 할 수 없습니다.

161
00:08:33,339 --> 00:08:36,090
우리는 옆으로 한 바이트를 설정해야
메모리 그래서 우리는 그것을 잡아

162
00:08:36,090 --> 00:08:39,130
우리의 문자열이 종료 할 때 알고있다.

163
00:08:39,130 --> 00:08:41,049
그래서 다시 배치
방식 것들

164
00:08:41,049 --> 00:08:42,799
메모리 세력에 표시
약간 무작위

165
00:08:42,799 --> 00:08:44,870
하지만 실제로 어떻게
대부분의 시스템이 설계되어 있습니다.

166
00:08:44,870 --> 00:08:48,330
배수에 그들을 줄을
네, 이유 다시

167
00:08:48,330 --> 00:08:50,080
우리는 할 필요가 없습니다
지금에 들어갈.

168
00:08:50,080 --> 00:08:53,060
그러나 이것은, 그렇게 말할를 충분
코드의이 세 가지 라인 후,

169
00:08:53,060 --> 00:08:54,810
이 메모리의 모양 것입니다.

170
00:08:54,810 --> 00:08:58,930
나는 메모리 위치가 필요한 경우
4, 8, 12, 내 데이터를 보유 할

171
00:08:58,930 --> 00:09:01,100
이 내 기억의 모양 것입니다.

172
00:09:01,100 --> 00:09:04,062
>> 그냥 특히 수
여기서, 현학적

173
00:09:04,062 --> 00:09:06,020
우리는 메모리에 대해 얘기하고
주소 일반적으로 우리

174
00:09:06,020 --> 00:09:08,390
그래서 진수 표기법을 사용하여이 작업을 수행.

175
00:09:08,390 --> 00:09:12,030
그런데 왜 우리는이 모두를 변환하지 않습니다
16 진수로 진수에서

176
00:09:12,030 --> 00:09:15,010
그냥 일반적 왜냐하면
우리가 어떻게 메모리를 참조하십시오.

177
00:09:15,010 --> 00:09:17,880
그래서 그 대신 0 ~ 인의
19, 우리가해야하는 것은 제로

178
00:09:17,880 --> 00:09:20,340
제로 X1 세를 통해 X 제로.

179
00:09:20,340 --> 00:09:23,790
사람들은 메모리의 20 바이트가 우리
또는 우리는이 이미지에서 찾고있다

180
00:09:23,790 --> 00:09:25,540
바로 여기에.

181
00:09:25,540 --> 00:09:29,310
>> 그래서이 말했다되고 모두의하자
두 번째 메모리에서 멀리 단계

182
00:09:29,310 --> 00:09:30,490
다시 포인터에.

183
00:09:30,490 --> 00:09:32,420
다음은 가장 중요하다
일이 기억

184
00:09:32,420 --> 00:09:34,070
우리는 포인터와 함께 작업을 시작으로.

185
00:09:34,070 --> 00:09:36,314
포인터는 아무것도 아니다
주소보다.

186
00:09:36,314 --> 00:09:38,230
나는 다시 그것 때문에 말 것
그것은, 그 중요

187
00:09:38,230 --> 00:09:42,730
포인터는 아무것도 아니다
주소보다.

188
00:09:42,730 --> 00:09:47,760
포인터 위치에 주소입니다
메모리에 변수가 사는 곳.

189
00:09:47,760 --> 00:09:52,590
그것은 희망이되고 있음을 알고
쉽게 약간은 그들과 함께 작업합니다.

190
00:09:52,590 --> 00:09:54,550
내가 좋아하는 또 다른 것은
할 것은 일종의 것입니다

191
00:09:54,550 --> 00:09:58,510
시각적으로 무엇을 나타내는 다이어그램
코드의 다양한 라인 일어나고.

192
00:09:58,510 --> 00:10:00,660
그리고 우리는이 몇 할거야
포인터의 시간,

193
00:10:00,660 --> 00:10:03,354
우리는 동적에 대해 이야기 할 때
메모리 할당뿐만 아니라.

194
00:10:03,354 --> 00:10:06,020
나는 이들도 있다고 생각하기 때문에
특히 도움이 될 수 있습니다.

195
00:10:06,020 --> 00:10:09,540
>> 내가 예를 들어 말을 그래서 경우, INT의 K
내 코드에서, 무슨 일입니까?

196
00:10:09,540 --> 00:10:12,524
그럼 기본적으로 무엇을한다 일어나고
나는, 나를 위해 따로 설정 메모리를 받고 있어요

197
00:10:12,524 --> 00:10:14,690
하지만 난 싫어
나는 그렇게 생각해

198
00:10:14,690 --> 00:10:16,300
상자처럼 생각하고 싶다.

199
00:10:16,300 --> 00:10:20,090
나는 상자를 가지고 있고 그것은이다
컬러 녹색 나는 때문에

200
00:10:20,090 --> 00:10:21,750
녹색 상자에 정수를 넣을 수 있습니다.

201
00:10:21,750 --> 00:10:23,666
이것은 문자 I 있었다면
파란색 상자가있을 수 있습니다.

202
00:10:23,666 --> 00:10:27,290
내가 만드는거야하지만 난 항상 말
정수를 보유 할 수있는 상자

203
00:10:27,290 --> 00:10:28,950
그 상자가 녹색으로 채색된다.

204
00:10:28,950 --> 00:10:33,020
그리고 영구 마커을
나는 그것의 측면에 케이 물품.

205
00:10:33,020 --> 00:10:37,590
그래서, K라는 상자가
되는 나는 정수를 넣을 수 있습니다.

206
00:10:37,590 --> 00:10:41,070
내가 INT의 K를 말할 때, 그건
무슨 일이 내 머리에 발생합니다.

207
00:10:41,070 --> 00:10:43,140
나는 K 다섯 같다 말한다면, 내가 무엇을하고 있는가?

208
00:10:43,140 --> 00:10:45,110
글쎄, 난 다섯을 걸었습니다
상자에서 마우스 오른쪽.

209
00:10:45,110 --> 00:10:48,670
이 경우, 매우 간단
나는 INT의 K는 K라는 상자를 만들 말한다.

210
00:10:48,670 --> 00:10:52,040
경우에 나는, k는 5와 동일한 말
상자에 다섯했습니다.

211
00:10:52,040 --> 00:10:53,865
바라건대 그 도약을 너무 많이하지 않습니다.

212
00:10:53,865 --> 00:10:55,990
상황이 갈 곳 여기
하지만 흥미로운 작은.

213
00:10:55,990 --> 00:11:02,590
내가 INT의 *의 PK를 말한다면, 잘 나는하지 않더라도
이 반드시 무엇을 의미하는지 알고,

214
00:11:02,590 --> 00:11:06,150
그것은 분명히 뭔가 있어요
정수로 할 수 있습니다.

215
00:11:06,150 --> 00:11:08,211
그래서 색상을거야
녹색 틱이 상자,

216
00:11:08,211 --> 00:11:10,210
나는 무언가를 가지고 알고
정수 함께 할 수있는,

217
00:11:10,210 --> 00:11:13,400
그러나 정수 자체가 아니라,
그것은 INT 스타이기 때문.

218
00:11:13,400 --> 00:11:15,390
뭔가 약간있다
그것에 대해 다른.

219
00:11:15,390 --> 00:11:17,620
그래서 정수의 참여,
하지만 그렇지 않은 경우이다

220
00:11:17,620 --> 00:11:19,830
에서 너무 차이가
우리는 무엇에 대해 얘기했다.

221
00:11:19,830 --> 00:11:24,240
그것은 상자의 그는 레이블을 가지고
이 레이블 PK를 입고,

222
00:11:24,240 --> 00:11:27,280
그것은 유지할 수있어
사람들은 어떤 INT 별,.

223
00:11:27,280 --> 00:11:29,894
그들은 할 수있는 뭔가가
정수와, 분명히.

224
00:11:29,894 --> 00:11:31,060
여기에 마지막 줄 생각이다.

225
00:11:31,060 --> 00:11:37,650
내가 말할 경우 PK = K, 워,
무슨 일이 바로, 무슨 일?

226
00:11:37,650 --> 00:11:41,820
그래서이 임의의 숫자, 겉으로는 무작위
수는이 상자에 던져됩니다.

227
00:11:41,820 --> 00:11:44,930
입니다 모든, PK입니다
K의 주소를 가져옵니다.

228
00:11:44,930 --> 00:11:52,867
k는 메모리에 사는 곳 그래서 고집하고있어,
그 주소의 바이트의 주소.

229
00:11:52,867 --> 00:11:55,200
내가 뭘 모든 말인지입니다
그 값은 내가 갈거야 무엇인가

230
00:11:55,200 --> 00:11:59,430
내 상자라는 PK의 내부에 넣어.

231
00:11:59,430 --> 00:12:02,080
그리고이 일이 있기 때문에
포인터, 찾고 있기 때문에

232
00:12:02,080 --> 00:12:04,955
제로 X 같은 문자열에서
여덟 제로 C 일곱 4 ~ 8

233
00:12:04,955 --> 00:12:07,790
두 제로는 아마
매우 의미가 없습니다.

234
00:12:07,790 --> 00:12:12,390
우리가 일반적으로 포인터를 시각화 할 때,
우리는 실제로 포인터로 이렇게.

235
00:12:12,390 --> 00:12:17,000
PK는 우리에게 정보를 제공합니다
우리는 메모리에 K를 찾을 필요가있다.

236
00:12:17,000 --> 00:12:19,120
그래서 기본적으로 PK가에 화살표가 있습니다.

237
00:12:19,120 --> 00:12:21,670
그리고 우리는 길이를 걸 으면
그 화살표의 상상

238
00:12:21,670 --> 00:12:25,280
그것은 당신이 걸을 수 뭔가, 우리의 경우
화살표의 길이를 따라 산책,

239
00:12:25,280 --> 00:12:29,490
그 화살표의 가장 끝에서, 우리
메모리의 위치를​​ 찾을 수

240
00:12:29,490 --> 00:12:31,390
여기서 k는 살고있다.

241
00:12:31,390 --> 00:12:34,360
그리고 정말 중요합니다
k는 사는 곳 우리가 아는 한 번 때문에,

242
00:12:34,360 --> 00:12:37,870
우리는 데이터로 작업을 시작할 수 있습니다
그 메모리 위치의 내부.

243
00:12:37,870 --> 00:12:40,780
우리는 조그마한를 얻고 있지만
지금은 앞서 자신의 비트.

244
00:12:40,780 --> 00:12:42,240
>> 그래서 포인터는 무엇인가?

245
00:12:42,240 --> 00:12:45,590
포인터는 그 데이터 항목이며
값은 메모리 주소이다.

246
00:12:45,590 --> 00:12:49,740
즉이었다 제로 X 팔 제로 물건이
일, 즉 메모리 주소했다.

247
00:12:49,740 --> 00:12:52,060
즉 메모리에 위치했다.

248
00:12:52,060 --> 00:12:55,080
및 포인터의 형식
종류를 설명

249
00:12:55,080 --> 00:12:56,930
데이터의 당신은에서 확인할 수 있습니다
그 메모리 주소.

250
00:12:56,930 --> 00:12:58,810
그래서 INT 스타 부분 오른쪽이있다.

251
00:12:58,810 --> 00:13:03,690
내가 그 화살표를 따라 경우의
위치로 나를 이끌 것.

252
00:13:03,690 --> 00:13:06,980
그리고 그 위치, 내가
내 예를 들어 거기에 발견 할 것이다,

253
00:13:06,980 --> 00:13:08,240
녹색 컬러 상자입니다.

254
00:13:08,240 --> 00:13:12,650
그것은 그 무엇이다, 정수의 I
내가 그 주소로 가면 찾을 수 있습니다.

255
00:13:12,650 --> 00:13:14,830
데이터 형식
포인터가 무엇인지를 설명

256
00:13:14,830 --> 00:13:17,936
해당 메모리 주소에서 찾을 수 있습니다.

257
00:13:17,936 --> 00:13:19,560
그래서 여기하지만 정말 멋진 일이다.

258
00:13:19,560 --> 00:13:25,090
포인터는 우리가 통과 할 수 있도록
기능 사이의 변수.

259
00:13:25,090 --> 00:13:28,520
실제로 변수를 전달
그 중 사본을 통과하지.

260
00:13:28,520 --> 00:13:32,879
우리가 알고있는 경우 때문에 정확히 어디에
메모리에서 변수를 찾기 위해,

261
00:13:32,879 --> 00:13:35,670
우리의 복사본을 만들 필요가 없습니다
그것은, 우리는 단지 해당 위치로 갈 수있다

262
00:13:35,670 --> 00:13:37,844
그 변수와 함께 작동합니다.

263
00:13:37,844 --> 00:13:40,260
본질 포인터에 따라서 종류
의 컴퓨터 환경을

264
00:13:40,260 --> 00:13:42,360
더 많은 현실 세계처럼, 좋아.

265
00:13:42,360 --> 00:13:44,640
>> 그래서 여기에 비유입니다.

266
00:13:44,640 --> 00:13:48,080
이 전 노트북을 가지고 있다고 가정 해 봅시다,
바로, 그리고 노트의 전체입니다.

267
00:13:48,080 --> 00:13:50,230
그리고 나는 당신이 그것을 업데이 트하려는.

268
00:13:50,230 --> 00:13:53,960
당신은 함수이다 그
업데이트 노트, 좋아.

269
00:13:53,960 --> 00:13:56,390
길에서 우리는 봤는데
지금까지 일하고, 무엇을

270
00:13:56,390 --> 00:14:02,370
당신이 내 노트북​​을 취할 것입니다 일,
당신은, 복사 가게에 갈거야

271
00:14:02,370 --> 00:14:06,410
당신의 제록스의 복사본을 만들 수 있습니다
노트북의 모든 페이지.

272
00:14:06,410 --> 00:14:09,790
당신은 나의 노트북을 떠날거야
내 책상에 당신이 완료되면,

273
00:14:09,790 --> 00:14:14,600
당신이 가서 물건을 교차합니다 내
날짜 또는 잘못된 벗어 노트북,

274
00:14:14,600 --> 00:14:19,280
그리고 당신은에 다시 전달합니다
나 제록스 페이지의 스택

275
00:14:19,280 --> 00:14:22,850
그건 내 노트북​​의 복제본입니다
당신이 그것에 변경 한.

276
00:14:22,850 --> 00:14:27,040
그리고 그 시점에서, 그것은으로 나에게 달려
호출하는 함수, 호출자,

277
00:14:27,040 --> 00:14:30,582
당신의 메모를하기로 결정하고,
내 노트로 다시 통합 할 수 있습니다.

278
00:14:30,582 --> 00:14:32,540
그래서 많은 단계가있다
여기에 참여, 권리.

279
00:14:32,540 --> 00:14:34,850
마찬가지로 더 나은되지 않을 것
난 그냥 말한다면,이 봐, 당신은 할 수 있습니다

280
00:14:34,850 --> 00:14:38,370
내 노트북​​을 업데이트
나, 당신이 내 노트북​​을 손으로

281
00:14:38,370 --> 00:14:40,440
당신이 물건을 가지고와
문자 그대로 그들을 교차

282
00:14:40,440 --> 00:14:42,810
내 노트북​​에 내 노트를 업데이트합니다.

283
00:14:42,810 --> 00:14:45,140
그리고 나에게 내 노트북​​을 다시 제공합니다.

284
00:14:45,140 --> 00:14:47,320
즉 어떤 종류의 무엇
포인터는, 우리가 할 수 있도록

285
00:14:47,320 --> 00:14:51,320
그들은이 환경을 많이 만들어
우리가 현실에서 어떻게 작동하는지와 같은 더.

286
00:14:51,320 --> 00:14:54,640
>> 그래서 모든 권리는 무엇입니까
포인터,의 얘기하자됩니다

287
00:14:54,640 --> 00:14:58,040
포인터는 C에서 작동, 및 방법에 대한
어떻게 우리가 그들과 함께 작업을 시작할 수 있습니다.

288
00:14:58,040 --> 00:15:02,550
그래서 아주 간단한 포인터가있다
C에서 널 포인터를했다.

289
00:15:02,550 --> 00:15:04,830
아무것도 널 포인터를 가리 킵니다.

290
00:15:04,830 --> 00:15:08,310
이처럼 이것은 아마 보인다
실제로없는 매우 유용한 것은,

291
00:15:08,310 --> 00:15:10,500
하지만 우리가 표시됩니다으로
나중에 조금, 사실

292
00:15:10,500 --> 00:15:15,410
이 널 포인터가 존재하는지
실제로 정말 유용하게 사용할 수 있습니다.

293
00:15:15,410 --> 00:15:19,090
그리고 당신은 포인터를 만들 때마다,과
당신은 그 값의 immediately-을 설정하지

294
00:15:19,090 --> 00:15:21,060
설정 예
그 값을 즉시

295
00:15:21,060 --> 00:15:25,401
다시 몇 슬라이드를 할 것이다
나는, PK는 & K에 해당 말했다 곳

296
00:15:25,401 --> 00:15:28,740
PK는 다음과 같이, K의 주소를 가져옵니다
우리는, 그게 무슨 뜻인지 볼 수 있습니다

297
00:15:28,740 --> 00:15:32,990
우리는 그것을 코딩하는 방법을 볼 수 있습니다 shortly-
우리는 뭔가에 값을 설정하지 않는 경우

298
00:15:32,990 --> 00:15:35,380
즉시 의미,
당신은 항상해야

299
00:15:35,380 --> 00:15:37,480
null로 가리 키도록 포인터를 설정합니다.

300
00:15:37,480 --> 00:15:40,260
당신은 아무것도를 가리 키도록 설정해야합니다.

301
00:15:40,260 --> 00:15:43,614
>> 즉보다 매우 다르다
그대로 그냥 값을 떠나는

302
00:15:43,614 --> 00:15:45,530
다음 선언
포인터와 그냥 가정

303
00:15:45,530 --> 00:15:48,042
그것은 거의 사실 때문에이 널 (null)입니다.

304
00:15:48,042 --> 00:15:50,000
그래서 당신은 항상 설정해야합니다
포인터의 값

305
00:15:50,000 --> 00:15:55,690
당신은 그것의 값을 설정하지 않는 경우 null로
바로 의미있는 뭔가.

306
00:15:55,690 --> 00:15:59,090
확인할 수 있습니다 포인터의 값 여부
항등 연산자를 사용하여 null 인

307
00:15:59,090 --> 00:16:05,450
(==), 당신이 어떤 정수를 비교 좋아
값이나 문자 값 사용 (==)

308
00:16:05,450 --> 00:16:06,320
뿐만 아니라.

309
00:16:06,320 --> 00:16:10,994
이 상수의 특별한 종류의
당신이 테스트하는 데 사용할 수있는 값입니다.

310
00:16:10,994 --> 00:16:13,160
그래서 아주 간단한이었다
포인터, 널 포인터.

311
00:16:13,160 --> 00:16:15,320
또 다른 방법은 만드는 방법
포인터를 추출하는 것입니다

312
00:16:15,320 --> 00:16:18,240
변수의 주소
당신이 이미 만든,

313
00:16:18,240 --> 00:16:22,330
당신은 &이 사용하여이 작업을 수행
운영자 주소 추출.

314
00:16:22,330 --> 00:16:26,720
어떤 우리는 이미 이전에 본 적이
첫 번째 그림의 예에서 나는 나타났다.

315
00:16:26,720 --> 00:16:31,450
x는 우리가했습니다 변수 있다면
이미 정수 유형의 생성,

316
00:16:31,450 --> 00:16:35,110
다음 및 X는 정수를 가리키는 포인터이다.

317
00:16:35,110 --> 00:16:39,810
및 X는 -, 추출하는 것입니다 기억
오른쪽에있는 물건의 주소입니다.

318
00:16:39,810 --> 00:16:45,350
그리고 포인터 그냥 주소이기 때문에,
이상 및 x는 정수에 대한 포인터입니다

319
00:16:45,350 --> 00:16:48,560
값이 어디 메모리 X의 삶입니다.

320
00:16:48,560 --> 00:16:50,460
그것은 X의 주소입니다.

321
00:16:50,460 --> 00:16:53,296
그래서 및 X는 X의 주소이다.

322
00:16:53,296 --> 00:16:55,670
의이 한 단계 보자
더 뭔가에 연결

323
00:16:55,670 --> 00:16:58,380
나는 이전 비디오에서 언급.

324
00:16:58,380 --> 00:17:06,730
도착은​​ 복식의 배열은, 경우
및 도착 대괄호는 내가 포인터

325
00:17:06,730 --> 00:17:08,109
이중에.

326
00:17:08,109 --> 00:17:08,970
그래.

327
00:17:08,970 --> 00:17:12,160
나는, 경우 대괄호를, 언
도착은​​, 두 배의 배열입니다

328
00:17:12,160 --> 00:17:19,069
그럼이 대괄호를, 언
해당 배열의 i 번째 요소,

329
00:17:19,069 --> 00:17:29,270
및 대괄호, 언 난 곳이다
메모리 도착의 i 번째 요소가 존재한다.

330
00:17:29,270 --> 00:17:31,790
>> 그래서 의미는 여기에 무엇입니까?

331
00:17:31,790 --> 00:17:34,570
배열 이름, 의미
이 모든 일의,

332
00:17:34,570 --> 00:17:39,290
배열의 이름이 있다는 것이다
실제로 자체에 대한 포인터.

333
00:17:39,290 --> 00:17:41,170
당신은 일한지
모두 함께 포인터

334
00:17:41,170 --> 00:17:45,290
당신이 배열을 사용했습니다 때마다.

335
00:17:45,290 --> 00:17:49,090
예로부터 기억
변수 범위에,

336
00:17:49,090 --> 00:17:53,420
I 제시 비디오의 끝 근처
우리는 기능을 가지고 예

337
00:17:53,420 --> 00:17:56,890
라는 설정 INT와
기능 세트 배열했다.

338
00:17:56,890 --> 00:18:00,490
그리고 당신의 도전은 결정
여부, 또는 무엇

339
00:18:00,490 --> 00:18:03,220
우리가 인쇄 된 값
함수의 단부,

340
00:18:03,220 --> 00:18:05,960
메인 프로그램의 끝.

341
00:18:05,960 --> 00:18:08,740
>> 당신은 예로부터 회수하는 경우
또는 당신이 비디오를 시청 한 경우,

342
00:18:08,740 --> 00:18:13,080
당신은 호출을 당신은 - 때 알고
설정 INT는 효과적으로 작동하지 않습니다.

343
00:18:13,080 --> 00:18:16,390
그러나 통화가 배열이하는 설정합니다.

344
00:18:16,390 --> 00:18:19,280
그리고 나는 종류의 이유를 통해 호도
그 당시 사건이​​었다.

345
00:18:19,280 --> 00:18:22,363
난 그냥 잘, 그것은 배열의 것, 말했다
특별한, 당신은 알고있다, 이유가있다.

346
00:18:22,363 --> 00:18:25,020
그 이유는 어레이의 인
이름은, 정말 그냥 포인터입니다

347
00:18:25,020 --> 00:18:28,740
이 특별있다
대괄호 구문이

348
00:18:28,740 --> 00:18:30,510
작업 할 일이 많은 멋진합니다.

349
00:18:30,510 --> 00:18:34,410
그리고 그들은의 생각을
훨씬 덜 위협적 포인터

350
00:18:34,410 --> 00:18:36,800
그들은 일종의있어 이유입니다
그 방법으로 제시했다.

351
00:18:36,800 --> 00:18:38,600
하지만 실제로는 배열은 포인터.

352
00:18:38,600 --> 00:18:41,580
그리고 그 이유는 때를
상기 배열의 변화를 만들어

353
00:18:41,580 --> 00:18:44,880
우리는 매개 변수로 배열을 통과 할 때
함수 또는 인수로

354
00:18:44,880 --> 00:18:50,110
어레이의 기능, 컨텐츠
실제로 두 수신자 변경

355
00:18:50,110 --> 00:18:51,160
호출자에.

356
00:18:51,160 --> 00:18:55,846
모든 다른 종류의 어떤
우리가 본 변수는 그렇지 않았다.

357
00:18:55,846 --> 00:18:58,970
그래서해야 할 단지 뭔가
당신이 포인터와 함께 작업 할 때 마음,

358
00:18:58,970 --> 00:19:01,610
하다의 이름
배열 실제로 포인터

359
00:19:01,610 --> 00:19:04,750
그 어레이의 첫 번째 요소이다.

360
00:19:04,750 --> 00:19:08,930
>> 확인을 그래서 지금 우리는 모든이
사실,의​​ 오른쪽 계속 할 수 있습니다.

361
00:19:08,930 --> 00:19:11,370
왜 우리가 상관이야
여기서 뭔가 살고있다.

362
00:19:11,370 --> 00:19:14,120
내가 말한 자처럼, 그것은 꽤입니다
무언가가 사는 곳을 알고 유용

363
00:19:14,120 --> 00:19:17,240
그래서 당신은 가서 변경할 수 있습니다.

364
00:19:17,240 --> 00:19:19,390
함께 작업하고 실제로
일이 당신을

365
00:19:19,390 --> 00:19:23,710
그 변수 테이크 효과에하고 싶은,
그리고 그것의 일부 복사본에 적용됩니다.

366
00:19:23,710 --> 00:19:26,150
이는 역 참조라고합니다.

367
00:19:26,150 --> 00:19:28,690
우리는 참조로 이동
우리는 거기에 값을 변경합니다.

368
00:19:28,690 --> 00:19:32,660
우리가 포인터를 가지고 있다면 그것은이라고
PC와 그 캐릭터를 가리키는,

369
00:19:32,660 --> 00:19:40,610
우리는 * PC와 * PC가 말할 수 있습니다
우리가 갈 경우 우리가 확인할 수있는 것들의 이름

370
00:19:40,610 --> 00:19:42,910
주소 PC에.

371
00:19:42,910 --> 00:19:47,860
우리가 찾을 것은 문자와
* PC는 우리가에서 데이터를 참조하는 방법입니다

372
00:19:47,860 --> 00:19:48,880
위치.

373
00:19:48,880 --> 00:19:54,150
그래서 우리는 같은 것을 말할 수 있습니다
* PC = D 또는 같은,

374
00:19:54,150 --> 00:19:59,280
그는 것을 의미한다 무엇이든
메모리 주소의 PC에 있었다

375
00:19:59,280 --> 00:20:07,040
어떤 문자는 이전했다
우리가 PC = D를 * 말한다면 거기에, 지금 D입니다.

376
00:20:07,040 --> 00:20:10,090
>> 그래서 여기에 우리가 다시 간다
이상한 C 물건, 좋아.

377
00:20:10,090 --> 00:20:14,560
그래서 우리는 것으로 이전에 * 본 적이
여하튼 데이터 타입의 일부

378
00:20:14,560 --> 00:20:17,160
그리고 지금은 사용되고있어
약간 다른 상황

379
00:20:17,160 --> 00:20:19,605
위치 데이터에 액세스한다.

380
00:20:19,605 --> 00:20:22,480
나는 조금 혼란 알고
그 사실이 전체의 일부

381
00:20:22,480 --> 00:20:25,740
같은, 왜 포인터는이 신화를
주위에 너무 복잡되는 등,

382
00:20:25,740 --> 00:20:28,250
정직하게, 구문 문제 일종이다.

383
00:20:28,250 --> 00:20:31,810
* 그러나 두 상황에서 사용되며,
두 유형 이름의 일부로서,

384
00:20:31,810 --> 00:20:34,100
우리는 조금 볼 수 있습니다
너무 다른 나중에 뭔가.

385
00:20:34,100 --> 00:20:36,490
그리고 바로 지금이다
참조 연산자.

386
00:20:36,490 --> 00:20:38,760
그래서 기준으로 간다
이것은 데이터를 액세스

387
00:20:38,760 --> 00:20:43,000
포인터의 위치에와
당신이 의지를 조작 할 수 있습니다.

388
00:20:43,000 --> 00:20:45,900
>> 지금 이것은 매우 유사하다
네 이웃을 방문, 맞아.

389
00:20:45,900 --> 00:20:48,710
당신이 알고있는 경우에 무엇을 당신을
이웃이있어, 살고

390
00:20:48,710 --> 00:20:50,730
이웃과 함께 놀고 없습니다.

391
00:20:50,730 --> 00:20:53,510
당신은 당신이 어떻게 알고
그들이 살고있는 곳을 알고,

392
00:20:53,510 --> 00:20:56,870
그러나 그것은에 의해 그 의미하지 않는다
그 지식을 갖는 미덕

393
00:20:56,870 --> 00:20:59,170
당신은 그들과 상호 작용한다.

394
00:20:59,170 --> 00:21:01,920
당신이 그들과 상호 작용하려면,
당신은 그들의 집에 가야

395
00:21:01,920 --> 00:21:03,760
당신은 그들이 살고있는 곳으로 이동해야합니다.

396
00:21:03,760 --> 00:21:07,440
그리고 그렇게되면,
당신은 상호 작용할 수 있습니다

397
00:21:07,440 --> 00:21:09,420
그들과 함께 당신이 원하는 것 좋아한다.

398
00:21:09,420 --> 00:21:12,730
그리고 마찬가지로 변수,
당신은 자신의 주소로 이동해야합니다

399
00:21:12,730 --> 00:21:15,320
당신이 그들을 상호 작용하려면,
그냥 주소를 알 수 없다.

400
00:21:15,320 --> 00:21:21,495
그리고 당신이 주소로 이동 방법입니다
* 참조 연산자를 사용합니다.

401
00:21:21,495 --> 00:21:23,620
당신이 일에 대해 어떻게 생각하십니까
우리가 시도하고 역 참조하는 경우

402
00:21:23,620 --> 00:21:25,260
값이 포인터가 null?

403
00:21:25,260 --> 00:21:28,470
널 리콜
포인터는 아무것도 가리 킵니다.

404
00:21:28,470 --> 00:21:34,110
당신이 시도하고 역 참조 그래서 경우
아무것도 주소 아무것도를 방문하거나,

405
00:21:34,110 --> 00:21:36,800
당신은 무슨 생각하세요?

406
00:21:36,800 --> 00:21:39,630
그럼 당신이 추측하는 경우 분할
흠, 당신은 잘 될 것입니다.

407
00:21:39,630 --> 00:21:41,390
당신이 시도하고 역 참조하는 경우
널 포인터,

408
00:21:41,390 --> 00:21:43,140
당신은 분할 고통
잘못. 그러나, 대기

409
00:21:43,140 --> 00:21:45,820
나는, 당신을 말하지 않았다
당신이하지 않을 경우

410
00:21:45,820 --> 00:21:49,220
당신의 값을 설정하는 방법
의미있는 포인터,

411
00:21:49,220 --> 00:21:51,000
당신은 null로 설정해야합니까?

412
00:21:51,000 --> 00:21:55,290
내가 그랬어 실제로 분할
장애는 좋은 행동 종류이다.

413
00:21:55,290 --> 00:21:58,680
>> 혹시 변수를 선언하고 있으
바로 그 값을 할당하지?

414
00:21:58,680 --> 00:22:02,680
그래서 당신은 INT X를 말한다; 당신은하지 않습니다
실제로 아무것도에 할당

415
00:22:02,680 --> 00:22:05,340
다음 나중에 코드에서,
당신은, x의 값을 출력

416
00:22:05,340 --> 00:22:07,650
아직 필요
아무것도에 할당.

417
00:22:07,650 --> 00:22:10,370
자주 당신은 얻을 것이다
제로, 그러나 때때로 당신

418
00:22:10,370 --> 00:22:15,000
어떤 임의의 수를 얻고, 수
당신은 온 아무 생각이 없습니다.

419
00:22:15,000 --> 00:22:16,750
마찬가지로 일을 할 수
포인터 일어난다.

420
00:22:16,750 --> 00:22:20,110
당신은 포인터를 선언 할 때
INT * 예를 들어, PK,

421
00:22:20,110 --> 00:22:23,490
당신은, 값에 할당하지 않습니다
당신은 메모리의 4 바이트를 얻을.

422
00:22:23,490 --> 00:22:25,950
의 무엇이든간에 4 바이트
시스템 메모리는 수

423
00:22:25,950 --> 00:22:28,970
일부 의미있는 값을 찾으십시오.

424
00:22:28,970 --> 00:22:31,760
그리고이되었을 수 있습니다
이미 뭔가

425
00:22:31,760 --> 00:22:34,190
다른 필요로하지 않습니다 더 이상
기능, 당신은 그냥 그래서

426
00:22:34,190 --> 00:22:35,900
어떤 데이터가 있었다.

427
00:22:35,900 --> 00:22:40,570
>> 당신은 무엇을 역 참조 할 시도하는 경우
당신이 거기에 있었다 안되는데 일부 주소

428
00:22:40,570 --> 00:22:43,410
이미 바이트 및 정보
거기에, 그 포인터에 지금입니다.

429
00:22:43,410 --> 00:22:47,470
당신이하려고하면 그 포인터 역 참조
당신은 일부 메모리 덤비는 수 있습니다

430
00:22:47,470 --> 00:22:49,390
당신은 의도하지 않았다
모두 엉망이다.

431
00:22:49,390 --> 00:22:51,639
그리고 사실 당신은 할 수
정말 엄청난 일,

432
00:22:51,639 --> 00:22:54,880
같은 다른 프로그램을 중단,
또는, 다른 기능을 깰

433
00:22:54,880 --> 00:22:58,289
또는 악의적 인 일을
당신은 전혀 할 의도하지 않았다.

434
00:22:58,289 --> 00:23:00,080
그 이유 그리고 그건
실제로 좋은 생각

435
00:23:00,080 --> 00:23:04,030
당신의 경우는 null하려면 포인터를 설정합니다
의미있는 뭔가를 설정하지 마십시오.

436
00:23:04,030 --> 00:23:06,760
그것은에 아마 더 낫다
프로그램의 오늘의 끝

437
00:23:06,760 --> 00:23:09,840
이 수행하는 다음 충돌합니다
뭔가 그 나사까지

438
00:23:09,840 --> 00:23:12,400
다른 프로그램이나 다른 기능.

439
00:23:12,400 --> 00:23:15,207
그 동작은도 아마
다만 충돌보다 이상적입니다.

440
00:23:15,207 --> 00:23:17,040
그 이유 그리고 그건
실제로 좋은 습관

441
00:23:17,040 --> 00:23:20,920
당신의 포인터를 설정에 들어가
당신이 그 (것)을 설정하지 않으면 null로

442
00:23:20,920 --> 00:23:24,540
의미있는 값
당신이 알고 즉시 값

443
00:23:24,540 --> 00:23:27,260
그리고 당신은 역 참조 안전하게 할 수 있습니다.

444
00:23:27,260 --> 00:23:32,240
>> 그럼 이제 다시 오게하고 봐
상황에서 전반적인 구.

445
00:23:32,240 --> 00:23:37,400
내가 INT의 * p를 말한다면 ;, 난 그냥 무슨 짓을 한거야?

446
00:23:37,400 --> 00:23:38,530
내가 무슨 짓을했는지하는 것은 이것이다.

447
00:23:38,530 --> 00:23:43,290
I는 P의 값은 어드레스이다 알고
모든 포인터는 단지이기 때문에

448
00:23:43,290 --> 00:23:44,660
주소.

449
00:23:44,660 --> 00:23:47,750
내가 할 수있는 역 참조 P
* 연산자를 사용하여.

450
00:23:47,750 --> 00:23:51,250
바로 여기 이러한 맥락에서,
상단 *이 유형의 일부입니다 기억합니다.

451
00:23:51,250 --> 00:23:53,510
INT * 데이터 타입이다.

452
00:23:53,510 --> 00:23:56,150
하지만 역 참조 할 수
* 연산자를 사용하여 (P),

453
00:23:56,150 --> 00:24:01,897
내가 그렇게한다면, 나는 그 주소로 이동하는 경우,
그 주소에서 찾을 것인가?

454
00:24:01,897 --> 00:24:02,855
나는 정수를 찾을 수 있습니다.

455
00:24:02,855 --> 00:24:05,910
그래서 INT의 * p를 기본적
말, p는 주소입니다.

456
00:24:05,910 --> 00:24:09,500
내가 할 수있는 페이지 역 참조하고있는 경우
내가, 내가 정수를 찾을 수

457
00:24:09,500 --> 00:24:11,920
해당 메모리 위치.

458
00:24:11,920 --> 00:24:14,260
>> 확인 그래서 다른이했다
별 성가신 일

459
00:24:14,260 --> 00:24:17,060
여기 어디에있어
별 성가신 일이다.

460
00:24:17,060 --> 00:24:21,640
혹시 선언하려고 노력
동일한 유형의 여러 변수

461
00:24:21,640 --> 00:24:24,409
코드의 같은 줄에?

462
00:24:24,409 --> 00:24:27,700
그래서 잠시, 그 선을 척
내가 실제로 녹색이 가지고있는 코드

463
00:24:27,700 --> 00:24:29,366
이 아니며 단지 INT의 X, Y, Z라고 ;.

464
00:24:29,366 --> 00:24:31,634

465
00:24:31,634 --> 00:24:34,550
무슨 할 것이 실제로 만들 수있다
당신을 위해 세 개의 정수 변수

466
00:24:34,550 --> 00:24:36,930
하나라는 X, 하나라는
Y, 하나는 Z했다.

467
00:24:36,930 --> 00:24:41,510
그것은하지 않고 할 수있는 방법
세 줄에 분할 할 필요.

468
00:24:41,510 --> 00:24:43,890
>> 별을 얻을 경우 여기
하지만 다시 성가신,

469
00:24:43,890 --> 00:24:49,200
* 실제로 일부이기 때문에
두 종류의 이름과 부분의

470
00:24:49,200 --> 00:24:50,320
변수 이름의.

471
00:24:50,320 --> 00:24:56,430
그래서 내가 말한다면 INT의 *의 PX, PY, PZ, 내가
실제로 얻을 수는 정수의 포인터이다

472
00:24:56,430 --> 00:25:01,650
PX와 두 개의 정수, PY 및 PZ했다.

473
00:25:01,650 --> 00:25:04,950
그리고 그것은 아마 무엇을의
우리는이 좋지 않아, 할 수 있습니다.

474
00:25:04,950 --> 00:25:09,290
>> 나는 여러 포인터를 만들려면 이렇게
동일 행에서, 동일한 유형의,

475
00:25:09,290 --> 00:25:12,140
내가 실제로 필요로하는 무슨과 별,
할 * PB, * PC, INT의 * 파 말할 수 있습니다.

476
00:25:12,140 --> 00:25:17,330

477
00:25:17,330 --> 00:25:20,300
지금 막 말​​했다 데
지금, 당신이 말하는

478
00:25:20,300 --> 00:25:22,170
아마 당신은이 작업을 수행하지 않습니다.

479
00:25:22,170 --> 00:25:25,170
그리고, 솔직히 아마 좋은 일
당신이 실수로 수 있기 때문에

480
00:25:25,170 --> 00:25:26,544
스타, 그런 일을 생략합니다.

481
00:25:26,544 --> 00:25:29,290
그것은 어쩌면 선언 아마 최선의
각각의 라인에 포인터,

482
00:25:29,290 --> 00:25:31,373
그러나 그것은 또 다른 하나
그 성가신 구문

483
00:25:31,373 --> 00:25:35,310
확인 별 일
작업하기 매우 어려운 포인터.

484
00:25:35,310 --> 00:25:39,480
그냥이 구문이기 때문에
엉망 당신을 통해 일해야한다.

485
00:25:39,480 --> 00:25:41,600
연습은하지 않습니다
정말 제 2의 천성이된다.

486
00:25:41,600 --> 00:25:45,410
나는 아직도 여전히 그것으로 실수를
10 년 동안 프로그래밍 후,

487
00:25:45,410 --> 00:25:49,630
뭔가 일이 생기면 너무 당황하지 말고
당신에게, 그것은 솔직히 꽤 일반적입니다.

488
00:25:49,630 --> 00:25:52,850
그것은 종류의 정말
구문의 결함.

489
00:25:52,850 --> 00:25:54,900
>> 확인 그래서 나는 가지 약속
우리는 다시 방문 할 것

490
00:25:54,900 --> 00:25:59,370
얼마나 큰의 개념은 문자열입니다.

491
00:25:59,370 --> 00:26:02,750
그럼 난 당신을 말한 경우
문자열, 우리는 종류의 정말했습니다

492
00:26:02,750 --> 00:26:04,140
당신에게 모든 시간을 거짓말.

493
00:26:04,140 --> 00:26:06,181
라는 데이터 유형이 없습니다
문자열, 사실 나는

494
00:26:06,181 --> 00:26:09,730
중 하나로이 언급 한 우리의
데이터 유형에 대한 최초의 비디오,

495
00:26:09,730 --> 00:26:13,820
그 문자열은 데이터 유형였습니다
CS50.h.에 당신을 위해 만들었습니다

496
00:26:13,820 --> 00:26:17,050
당신은 #include를해야
그것을 사용하기 위해 CS50.h.

497
00:26:17,050 --> 00:26:19,250
>> 그런데 캐릭터는 정말
무엇인가에 대한 별칭

498
00:26:19,250 --> 00:26:23,600
, 숯불 *라는
문자의 포인터.

499
00:26:23,600 --> 00:26:26,010
그럼 포인터, 리콜,
단지 주소입니다.

500
00:26:26,010 --> 00:26:28,780
그래서 크기는 무엇인가
문자열의 바이트?

501
00:26:28,780 --> 00:26:29,796
그럼이 4 개 또는 8입니다.

502
00:26:29,796 --> 00:26:32,170
그리고 그 이유는 내가 말을 네 개
8 명은 때문에 실제로

503
00:26:32,170 --> 00:26:36,730
당신이 사용하는 경우, 시스템에 따라 달라집니다
CS50의 IDE는, 숯불 *는 문자의 크기

504
00:26:36,730 --> 00:26:39,340
*는 64 비트 시스템의 여덟이다.

505
00:26:39,340 --> 00:26:43,850
메모리의 모든 주소는 64 비트 길이입니다.

506
00:26:43,850 --> 00:26:48,270
당신은 CS50 어플라이언스를 사용하는 경우
또는 32 비트 시스템을 사용하여,

507
00:26:48,270 --> 00:26:51,640
당신은 그 용어 32 비트를 들었습니다
기계, 32 비트 시스템은 무엇입니까?

508
00:26:51,640 --> 00:26:56,090
그럼 그냥 모든 것을 의미합니다
메모리의 주소는 32 비트 길이입니다.

509
00:26:56,090 --> 00:26:59,140
그리고 32 비트는 4 바이트입니다.

510
00:26:59,140 --> 00:27:02,710
그래서 숯불 *는 4 개 또는 8입니다
시스템에 따라 바이트.

511
00:27:02,710 --> 00:27:06,100
그리고 실제로 모든 데이터 유형,
어떤 데이터에 대한 포인터

512
00:27:06,100 --> 00:27:12,030
모든 포인터는 단지이기 때문에, 입력
주소는 4 개 또는 8 바이트이다.

513
00:27:12,030 --> 00:27:14,030
그럼이를 다시 보자
다이어그램과의이 결론을 내릴 수 있습니다

514
00:27:14,030 --> 00:27:18,130
여기에 약간의 운동이 비디오.

515
00:27:18,130 --> 00:27:21,600
그래서 여기에 우리가 중단 된 그림이다
비디오의 처음에.

516
00:27:21,600 --> 00:27:23,110
내가 * PK = 35 말한다면 이제 어떻게?

517
00:27:23,110 --> 00:27:26,370

518
00:27:26,370 --> 00:27:30,530
그래서 * PK = 35, 내가 말할 때 무엇을 의미합니까?

519
00:27:30,530 --> 00:27:32,420
두 번째를 가져 가라.

520
00:27:32,420 --> 00:27:34,990
* PK.

521
00:27:34,990 --> 00:27:39,890
여기 문맥에서, *는
참조 연산자.

522
00:27:39,890 --> 00:27:42,110
그래서 때 역 참조
연산자는, 사용

523
00:27:42,110 --> 00:27:48,520
주소는 지적에 우리가 간다
PK에 의해, 우리는 우리가 무엇을 발견 변경합니다.

524
00:27:48,520 --> 00:27:55,270
그래서 * PK = 35 효과적으로
사진에이 작업을 수행합니다.

525
00:27:55,270 --> 00:27:58,110
그래서 구문 기본적이다
의 동일은 K = 35 말했다 데.

526
00:27:58,110 --> 00:28:00,740

527
00:28:00,740 --> 00:28:01,930
>> 하나 더.

528
00:28:01,930 --> 00:28:05,510
내가 INT 분을 말한다면, 내가 만들
M이라는 새로운 변수입니다.

529
00:28:05,510 --> 00:28:08,260
새로운 상자, 그것은 녹색 상자 때문에이다
그것은 정수를 개최 것,

530
00:28:08,260 --> 00:28:09,840
그리고 M을 표시합니다.

531
00:28:09,840 --> 00:28:14,960
나는 M = 4를 말한다면, 내가 넣어
그 상자에 정수.

532
00:28:14,960 --> 00:28:20,290
말은 PK = & M, 방법을 수행하는 경우
이 그림의 변화?

533
00:28:20,290 --> 00:28:28,760
PK = & M, 당신은 무엇을 기억 할
& 연산자는 않습니다 또는라고?

534
00:28:28,760 --> 00:28:34,430
그 및 일부 변수 이름을 기억
변수 이름의 주소입니다.

535
00:28:34,430 --> 00:28:38,740
그래서 우리가 말하고있는 것은
PK는 M의 주소를 가져옵니다.

536
00:28:38,740 --> 00:28:42,010
그리고 효과적으로 무슨 일이
도면은 더 이상 점이다 PK

537
00:28:42,010 --> 00:28:46,420
M에,하지만 포인트를 케이합니다.

538
00:28:46,420 --> 00:28:48,470
>> 다시 포인터는 매우이다
작업하기 까다로운

539
00:28:48,470 --> 00:28:50,620
그들은 많이 걸릴
연습,하지만 때문에

540
00:28:50,620 --> 00:28:54,150
당신을 허용 할 수있는 능력의
함수 사이에 데이터를 전달하는

541
00:28:54,150 --> 00:28:56,945
실제로 사람들이
변경 사항이 적용,

542
00:28:56,945 --> 00:28:58,820
주위에 당신의 머리를 점점
정말 중요합니다.

543
00:28:58,820 --> 00:29:02,590
그것은 아마도 가장 복잡
우리가 CS50 논의 주제,

544
00:29:02,590 --> 00:29:05,910
하지만 값을 당신을
포인터를 사용에서 얻을

545
00:29:05,910 --> 00:29:09,200
지금까지 합병증을 상회
그 그들을 학습에서 온다.

546
00:29:09,200 --> 00:29:12,690
그래서 나는 당신에게 최고의 소원
운이 포인터에 대한 학습.

547
00:29:12,690 --> 00:29:15,760
내가 더그 로이드 해요,이 CS50입니다.

548
00:29:15,760 --> 00:29:17,447