1
00:00:00,000 --> 00:00:02,395
>> [音樂播放]

2
00:00:02,395 --> 00:00:05,750

3
00:00:05,750 --> 00:00:06,506
>> 道格·勞埃德：OK。

4
00:00:06,506 --> 00:00:08,880
我們已經與整數工作，
我們與人物的工作，

5
00:00:08,880 --> 00:00:11,930
我們已經工作的花車，
雙打，字符串和布爾變量。

6
00:00:11,930 --> 00:00:14,870
我們已經用盡了幾乎所有的
在[聽不清]類型的

7
00:00:14,870 --> 00:00:17,100
已經提供給我們的所有沿。

8
00:00:17,100 --> 00:00:19,430
但是現在我們想要做的事情更多。

9
00:00:19,430 --> 00:00:20,210
我們該怎麼做呢？

10
00:00:20,210 --> 00:00:22,560
我們如何創建不同類型的數據？

11
00:00:22,560 --> 00:00:26,130
我們可以通過使用結構這樣做。

12
00:00:26,130 --> 00:00:30,180
所以結構使我們能夠統一
不同類型的變量

13
00:00:30,180 --> 00:00:34,810
成一個單一的，新的變量類型，
我們可以將自己的類型名稱。

14
00:00:34,810 --> 00:00:37,570
這是一個非常強大的
事情可以做，

15
00:00:37,570 --> 00:00:40,900
因為我們現在可以組
不同數據類型的要素

16
00:00:40,900 --> 00:00:43,910
一起具有一個邏輯連接。

17
00:00:43,910 --> 00:00:46,440
我們已經能夠做到這一點
數組排序的，對不對？

18
00:00:46,440 --> 00:00:49,540
我們可以把變量
相同的數據類型的

19
00:00:49,540 --> 00:00:53,410
一起在一個大單位
的存儲器，陣列。

20
00:00:53,410 --> 00:00:56,660
>> 但是，我們一直沒能混
向上不同的數據類型一起。

21
00:00:56,660 --> 00:01:02,610
我們不能說，配對的整數，
和性格，和一個雙所有

22
00:01:02,610 --> 00:01:05,330
在同樣的事情，
稱之為一個單元。

23
00:01:05,330 --> 00:01:08,830
但其結構，或
經常被稱為結構，

24
00:01:08,830 --> 00:01:09,585
我們其實可以。

25
00:01:09,585 --> 00:01:12,370
因此，一個結構排序
像一個超級變量。

26
00:01:12,370 --> 00:01:16,530
它是一個包含一個可變
它裡面的其他變量。

27
00:01:16,530 --> 00:01:19,650
所以這裡有一個例子
一個非常簡單的結構。

28
00:01:19,650 --> 00:01:23,380
這是語法將是什麼
想創建一個結構的汽車。

29
00:01:23,380 --> 00:01:25,250
現在，讓我們通過語法在這裡。

30
00:01:25,250 --> 00:01:27,400
結構，這就是
關鍵字，指示

31
00:01:27,400 --> 00:01:30,270
我在這裡創建一個新的數據類型。

32
00:01:30,270 --> 00:01:33,860
具體地，數據類型的名稱是
將是結構的車，因為我們拭目以待。

33
00:01:33,860 --> 00:01:36,640
但是，這是尖的排序
關閉的編譯器，這個

34
00:01:36,640 --> 00:01:42,440
作為一組變量，是要
到被認為是相同類型的一部分

35
00:01:42,440 --> 00:01:44,010
在一分鐘內。

36
00:01:44,010 --> 00:01:46,340
>> 汽車，結構只是名字。

37
00:01:46,340 --> 00:01:50,590
同樣，這裡的數據類型將會
是結構的車，不只是汽車。

38
00:01:50,590 --> 00:01:53,060
但如果你有different--
如果你創建多個結構

39
00:01:53,060 --> 00:01:56,950
在同一個程序，你需要
結構和結構加以區分。

40
00:01:56,950 --> 00:02:00,140
所以結構的車，我也可以
結構體的學生，例如

41
00:02:00,140 --> 00:02:01,790
在同一程序。

42
00:02:01,790 --> 00:02:05,980
裡面的花括號是
所有的所謂場，

43
00:02:05,980 --> 00:02:07,954
或結構的成員。

44
00:02:07,954 --> 00:02:10,370
那麼，什麼是一些事情
中固有的一個車？

45
00:02:10,370 --> 00:02:15,270
那麼，它通常有一個一年，已
一個型號名稱，車牌，

46
00:02:15,270 --> 00:02:18,000
里程表，通常具有
一些數字就可以了哩，

47
00:02:18,000 --> 00:02:19,225
也許一個發動機尺寸。

48
00:02:19,225 --> 00:02:23,570
正如你所看到的，我是混合起來
整數和字符和雙打。

49
00:02:23,570 --> 00:02:26,420
他們都將是
這個新的數據類型的一部分​​。

50
00:02:26,420 --> 00:02:29,750
>> 最後，最後一件事，我需要做的，
不要忘了這個小分號

51
00:02:29,750 --> 00:02:30,290
在末端。

52
00:02:30,290 --> 00:02:34,380
我們完成定義結構之後，
我們需要把一個分號結尾。

53
00:02:34,380 --> 00:02:37,325
這是一個很常見的語法
錯誤，因為有一個功能，

54
00:02:37,325 --> 00:02:40,200
例如，你只是有
大括號，靠近大括號。

55
00:02:40,200 --> 00:02:42,950
你不把一個分號
函數定義的結束。

56
00:02:42,950 --> 00:02:46,430
這看起來像一個函數
定義，但它不是，

57
00:02:46,430 --> 00:02:49,653
所以分號有
只是提醒你

58
00:02:49,653 --> 00:02:52,440
需要把它放在那裡，因為
編譯器，否則將不

59
00:02:52,440 --> 00:02:53,510
知道該怎麼辦。

60
00:02:53,510 --> 00:02:56,160
這是一個非常常見的錯誤
意外使

61
00:02:56,160 --> 00:02:58,570
當你第​​一次定義結構。

62
00:02:58,570 --> 00:02:59,500
>> 確定。

63
00:02:59,500 --> 00:03:02,824
所以，我們通常定義我們的結構
在我們的節目的最高層

64
00:03:02,824 --> 00:03:05,490
因為他們很可能會
要使用的多種功能。

65
00:03:05,490 --> 00:03:08,850
我們不希望定義一個
結構體在函數中，

66
00:03:08,850 --> 00:03:12,110
因為那時我們就可以only--的
結構的範圍真的

67
00:03:12,110 --> 00:03:13,790
只存在該函數的內部。

68
00:03:13,790 --> 00:03:17,450
我們很可能要定義一個結構
所以我們可以在多個函數使用它，

69
00:03:17,450 --> 00:03:20,670
或者在多個
這是綁在一起的文件

70
00:03:20,670 --> 00:03:22,920
創建我們的一個程序。

71
00:03:22,920 --> 00:03:24,920
有時還代替
限定該結構的

72
00:03:24,920 --> 00:03:27,961
在最高層，你把你的
英鎊包括和你一斤定義，

73
00:03:27,961 --> 00:03:32,080
例如，您可以把它們放在
單獨的點.h文件，然後您再進行

74
00:03:32,080 --> 00:03:35,020
英鎊包括你自己。

75
00:03:35,020 --> 00:03:37,620
>> 因此，我們有結構，但現在
我們需要讓他們的內部。

76
00:03:37,620 --> 00:03:39,800
我們如何獲得內部
一個結構來訪問

77
00:03:39,800 --> 00:03:43,530
那些子的變量，這些變量
該結構內部存在？

78
00:03:43,530 --> 00:03:46,810
好了，我們有一些所謂
點運算符，這使我們

79
00:03:46,810 --> 00:03:50,990
訪問結構的字段。

80
00:03:50,990 --> 00:03:55,490
因此，舉例來說，假設我已經聲明
我的結構化數據類型的地方

81
00:03:55,490 --> 00:03:59,020
在我的節目的頂部，或者在
我已經一斤點.h文件包括在內。

82
00:03:59,020 --> 00:04:03,360
如果我再要創建一個新的
該數據類型的變量，我可以說，

83
00:04:03,360 --> 00:04:06,260
結構的車，我的車，分號。

84
00:04:06,260 --> 00:04:11,580
就像我可以說INT
x或字符串名稱分號。

85
00:04:11,580 --> 00:04:18,100
>> 這裡的數據類型是結構的車，
變量的名稱是我的車，

86
00:04:18,100 --> 00:04:23,770
然後我可以使用點操作
訪問我的車的各個領域。

87
00:04:23,770 --> 00:04:27,494
所以我可以說我的車
點的一年相當於2011。

88
00:04:27,494 --> 00:04:28,410
這是完全正常的。

89
00:04:28,410 --> 00:04:34,210
當年，如果你還記得，被定義為
這種結構車內整型字段

90
00:04:34,210 --> 00:04:35,200
數據類型。

91
00:04:35,200 --> 00:04:39,966
結構體的車的數據，所以任何變量
類型，如我的車，我可以說我的車

92
00:04:39,966 --> 00:04:44,030
點的一年相當於然後分配
它的一些整數值，2011年

93
00:04:44,030 --> 00:04:47,290
我的車點板等於CS50。

94
00:04:47,290 --> 00:04:51,180
我的卡點里程表
等於50505分號。

95
00:04:51,180 --> 00:04:53,270
所有這些都
完美的罰款，這就是

96
00:04:53,270 --> 00:04:57,802
我們如何訪問
結構的領域。

97
00:04:57,802 --> 00:05:00,260
結構，但是，並不需要
要在堆棧上創建的。

98
00:05:00,260 --> 00:05:02,950
就像任何其他變量，我們
可以動態分配。

99
00:05:02,950 --> 00:05:06,309
如果我們有一個程序，可能
可以產生許多結構，

100
00:05:06,309 --> 00:05:08,100
我們不知道有多少
我們將需要，

101
00:05:08,100 --> 00:05:10,800
那麼，我們需要動態
分配這些結構

102
00:05:10,800 --> 00:05:12,960
因為我們的程序正在運行。

103
00:05:12,960 --> 00:05:16,600
所以，如果我們要訪問
的結構在該上下文字段，

104
00:05:16,600 --> 00:05:20,660
回想一下，我們首先需要提領
指針的結構中，

105
00:05:20,660 --> 00:05:24,810
再一次，我們取消引用
指針，那麼我們就可以訪問該字段。

106
00:05:24,810 --> 00:05:26,830
如果我們只有一個
指針的結構中，

107
00:05:26,830 --> 00:05:32,120
我們不能只說指針點域
命名並得到我們所要尋找的。

108
00:05:32,120 --> 00:05:34,259
有提領的額外步驟。

109
00:05:34,259 --> 00:05:36,050
因此，讓我們說，
代替previous--

110
00:05:36,050 --> 00:05:38,770
就像前面的例子，
代替它聲明

111
00:05:38,770 --> 00:05:43,680
在棧中，結構的車，我
汽車，分號，我說的結構車，

112
00:05:43,680 --> 00:05:48,020
明星，一個指針
結構車叫我的車，

113
00:05:48,020 --> 00:05:51,250
等於結構的汽車malloc的大小。

114
00:05:51,250 --> 00:05:54,950
我們大小會找出多少
字節的新的數據類型佔用。

115
00:05:54,950 --> 00:05:58,570
你不一定只需要使用
的，寬度，int或char或任何尺寸

116
00:05:58,570 --> 00:05:59,715
的內置的數據類型。

117
00:05:59,715 --> 00:06:02,090
編譯器是足夠聰明
找出多少字節

118
00:06:02,090 --> 00:06:04,170
需要通過新的結構。

119
00:06:04,170 --> 00:06:09,610
所以我自己的malloc的內存單元
大到足以容納一個結構的汽車，

120
00:06:09,610 --> 00:06:12,410
我得到一個指針回
到存儲器塊，

121
00:06:12,410 --> 00:06:16,090
而該指針被分配給我的車。

122
00:06:16,090 --> 00:06:18,050
>> 現在，如果我想訪問
我的車的領域，

123
00:06:18,050 --> 00:06:22,615
我第一次提領我的車使用
在引用操作，明星

124
00:06:22,615 --> 00:06:26,620
我們已經從指針可見
視頻，然後我提領後，

125
00:06:26,620 --> 00:06:32,200
然後我可以使用點操作
訪問我的車的各個領域。

126
00:06:32,200 --> 00:06:35,490
明星我的車點的一年相當於2011。

127
00:06:35,490 --> 00:06:38,480
這將有效果
我們希望在這種情況下，

128
00:06:38,480 --> 00:06:41,960
因為我們動態地已經
分配我的車。

129
00:06:41,960 --> 00:06:43,610
>> 這還算比較煩人，不過，對不對？

130
00:06:43,610 --> 00:06:44,818
有一個2步現在的過程。

131
00:06:44,818 --> 00:06:47,460
現在我們就來dereference--
我們有一個星運營商，

132
00:06:47,460 --> 00:06:48,910
我們有一個點操作符。

133
00:06:48,910 --> 00:06:51,660
正如你所期望的，因為
C程序員喜歡短的方式

134
00:06:51,660 --> 00:06:53,740
做的事情，是有
更短的方式來做到這一點。

135
00:06:53,740 --> 00:06:57,790
還有另外一個操作員稱為箭頭
這使得這一過程變得更加簡單。

136
00:06:57,790 --> 00:07:00,750
箭頭的工作方式是
它首先解除引用

137
00:07:00,750 --> 00:07:03,560
左側的指針
操作者側，

138
00:07:03,560 --> 00:07:06,620
然後，在已經廢棄
指針在左邊，

139
00:07:06,620 --> 00:07:09,620
它訪問領域的權利。

140
00:07:09,620 --> 00:07:14,170
所以，以前我們有這種
明星我的車點這一切的東西，

141
00:07:14,170 --> 00:07:15,880
就像有很多事情在那裡。

142
00:07:15,880 --> 00:07:22,040
但是，我們可以做的，而不是為this--
我的車箭年相當於2011年

143
00:07:22,040 --> 00:07:23,580
>> 同樣，這裡發生了什麼？

144
00:07:23,580 --> 00:07:25,720
首先，我提領我的車。

145
00:07:25,720 --> 00:07:27,810
這再次，是這裡的指針。

146
00:07:27,810 --> 00:07:31,270
然後，將具有後
廢棄我的車，我

147
00:07:31,270 --> 00:07:35,130
然後可以訪問域
今年，板和里程表

148
00:07:35,130 --> 00:07:40,020
只是盡我所能具有第一前
二手星級取消引用我的車，

149
00:07:40,020 --> 00:07:42,020
和斑點訪問該字段。

150
00:07:42,020 --> 00:07:45,290
所以，你可以有結構，你
可以有指針結構，

151
00:07:45,290 --> 00:07:48,360
你有辦法進入
這些結構的領域，

152
00:07:48,360 --> 00:07:52,600
你是否有指針
他們或變量本身。

153
00:07:52,600 --> 00:07:57,640
點或箭頭，這取決於
變量是如何聲明。

154
00:07:57,640 --> 00:08:00,510
我是道格·勞埃德，這是CS50。

155
00:08:00,510 --> 00:08:01,975