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
>> DOUG LLOYD: OK.

4
00:00:06,506 --> 00:00:08,880
Έχουμε συνεργαστεί με ακέραιους αριθμούς,
έχουμε συνεργαστεί με τους χαρακτήρες,

5
00:00:08,880 --> 00:00:11,930
έχουμε δουλέψει πλωτήρες,
δίκλινα, χορδές, και bools.

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
Αλλά με τις δομές, ή
αναφέρεται συχνά ως structs,

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
Struct, αυτό είναι το
λέξη-κλειδί που υποδεικνύει

31
00:01:27,400 --> 00:01:30,270
ότι είμαι δημιουργώντας ένα νέο τύπο δεδομένων εδώ.

32
00:01:30,270 --> 00:01:33,860
Ειδικότερα, το όνομα του τύπου δεδομένων είναι
πρόκειται να είναι struct αυτοκίνητο, όπως θα δούμε.

33
00:01:33,860 --> 00:01:36,640
Αλλά αυτό είναι το είδος του άκρου
off για να τον compiler ότι αυτό

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
Και πάλι, ο τύπος δεδομένων εδώ θα
να είναι struct αυτοκίνητο, όχι μόνο το αυτοκίνητο.

38
00:01:50,590 --> 00:01:53,060
Αλλά αν έχετε different--
εάν δημιουργήσετε πολλαπλές structs

39
00:01:53,060 --> 00:01:56,950
στο ίδιο πρόγραμμα, θα πρέπει να
διάκριση μεταξύ struct και struct.

40
00:01:56,950 --> 00:02:00,140
Έτσι struct αυτοκίνητο, μπορούν επίσης να έχουν
φοιτητής struct, για παράδειγμα,

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
πρέπει να το βάλετε εκεί, γιατί
ο compiler Αλλιώς δεν θα

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
Δεν θέλουμε να ορίσετε ένα
struct εσωτερικό μιας συνάρτησης,

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
Για παράδειγμα, μπορείτε να τα βάλετε σε
ξεχωριστά αρχεία dot 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
στην κορυφή του προγράμματος μου, ή ίσως σε
ένα αρχείο dot ώρες που έχω λίβρα συμπεριλαμβάνεται.

82
00:03:59,020 --> 00:04:03,360
Εάν λοιπόν εγώ θέλουμε να δημιουργήσουμε μια νέα
μεταβλητή αυτού του τύπου δεδομένων, μπορώ να πω,

83
00:04:03,360 --> 00:04:06,260
struct αυτοκίνητο, το αυτοκίνητό μου, τελεία.

84
00:04:06,260 --> 00:04:11,580
Ακριβώς όπως θα μπορούσα να πω int
Χ, ή το όνομα χορδών ερωτηματικό.

85
00:04:11,580 --> 00:04:18,100
>> Ο τύπος δεδομένων είναι struct αυτοκίνητο,
το όνομα της μεταβλητής είναι το αυτοκίνητό μου,

86
00:04:18,100 --> 00:04:23,770
και, στη συνέχεια, μπορώ να χρησιμοποιήσω το χειριστή για να τελεία
πρόσβαση στα διάφορα πεδία του αυτοκινήτου μου.

87
00:04:23,770 --> 00:04:27,494
Έτσι μπορώ να πω το αυτοκίνητό μου
dot έτος ισούται με 2011.

88
00:04:27,494 --> 00:04:28,410
Αυτό είναι απολύτως εντάξει.

89
00:04:28,410 --> 00:04:34,210
Έτος, αν θυμάστε, ορίστηκε ως
ακέραιο πεδίο μέσα από αυτό το αυτοκίνητο struct

90
00:04:34,210 --> 00:04:35,200
τύπο δεδομένων.

91
00:04:35,200 --> 00:04:39,966
Έτσι, κάθε μεταβλητή των δεδομένων struct αυτοκίνητο
τύπου, όπως το αυτοκίνητό μου, μπορώ να πω το αυτοκίνητό μου

92
00:04:39,966 --> 00:04:44,030
dot έτος ισούται και στη συνέχεια να εκχωρήσετε
είναι μερικά ακέραια τιμή, 2011.

93
00:04:44,030 --> 00:04:47,290
Πλάκα μου dot αυτοκινήτων ισούται με CS50.

94
00:04:47,290 --> 00:04:51,180
Μου dot κάρτα χιλιομετρητή
ισούται με 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
Θυμηθείτε ότι θα πρέπει πρώτα να dereference
ο δείκτης στη δομή,

105
00:05:20,660 --> 00:05:24,810
και, στη συνέχεια, από τη στιγμή που η dereference
δείκτη, τότε μπορούμε να έχουμε πρόσβαση τα πεδία.

106
00:05:24,810 --> 00:05:26,830
Αν έχουμε μόνο
δείκτη προς τη δομή,

107
00:05:26,830 --> 00:05:32,120
δεν μπορούμε να πούμε το πεδίο δείκτη dot
το όνομα και να πάρει αυτό που ψάχνετε.

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
στη στοίβα, struct αυτοκίνητο, μου
αυτοκίνητο, το ερωτηματικό, το λέω struct αυτοκίνητο,

112
00:05:43,680 --> 00:05:48,020
αστέρι, ένας δείκτης σε μια
struct αυτοκίνητο ονομάζεται το αυτοκίνητό μου,

113
00:05:48,020 --> 00:05:51,250
ισούται με malloc μέγεθος του struct αυτοκινήτου.

114
00:05:51,250 --> 00:05:54,950
Μέγεθος του θα καταλάβω πόσα
bytes νέος τύπος δεδομένων σας καταλαμβάνει.

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
Ο compiler είναι αρκετά έξυπνος
να καταλάβω πόσα bytes

118
00:06:02,090 --> 00:06:04,170
απαιτούνται από τη νέα δομή σας.

119
00:06:04,170 --> 00:06:09,610
Γι 'αυτό και malloc τον εαυτό μου μια μονάδα μνήμης
αρκετά μεγάλη για να κρατήσει ένα αυτοκίνητο struct,

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
Θέλω πρώτα dereference το αυτοκίνητό μου με τη χρήση
ο χειριστής dereference, αστέρι

124
00:06:22,615 --> 00:06:26,620
ότι έχουμε δει από τους δείκτες
βίντεο, και στη συνέχεια, αφού dereference,

125
00:06:26,620 --> 00:06:32,200
τότε μπορώ να χρησιμοποιήσω το χειριστή για να τελεία
πρόσβαση στα διάφορα πεδία του αυτοκινήτου μου.

126
00:06:32,200 --> 00:06:35,490
Αστέρι αυτοκίνητό μου dot έτος ισούται με 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
Και όπως μπορείτε να φανταστείτε, επειδή
Γ προγραμματιστές αγαπούν μικρότερη τρόπους

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
Ο τρόπος που λειτουργεί είναι το βέλος
το πρώτο dereferences

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
Και έτσι στο παρελθόν είχαμε αυτό το είδος
του Star αυτοκίνητό μου dot όλα αυτά τα πράγματα,

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
ακριβώς όπως θα μπορούσα, προτού χρειαστεί πρώτα
μεταχειρισμένα αστέρι για να dereference το αυτοκίνητό μου,

149
00:07:40,020 --> 00:07:42,020
και dot πρόσβασης στο πεδίο.

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
Dot ή βέλος, ανάλογα με την
πώς κηρύχθηκε η μεταβλητή.

154
00:07:57,640 --> 00:08:00,510
Είμαι ο Νταγκ Lloyd, αυτό είναι CS50.

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