1
00:00:07,360 --> 00:00:09,360
[Powered by Google Translate] Ας μιλήσουμε για πίνακες.

2
00:00:09,360 --> 00:00:12,780
Επομένως, γιατί θα είμαστε ποτέ θέλετε να χρησιμοποιήσετε πίνακες;

3
00:00:12,780 --> 00:00:17,210
Λοιπόν ας πούμε ότι έχετε ένα πρόγραμμα που χρειάζεται για την αποθήκευση 5 ταυτότητες των μαθητών.

4
00:00:17,210 --> 00:00:21,270
Μπορεί να φαίνεται λογικό να έχουμε 5 ξεχωριστές μεταβλητές.

5
00:00:21,270 --> 00:00:24,240
Για λόγους που θα δούμε σε λίγο, θα αρχίσουμε να μετράμε από το 0.

6
00:00:24,240 --> 00:00:30,700
Οι μεταβλητές που θα έχουμε θα είναι int ID0, int id1, και ούτω καθεξής.

7
00:00:30,700 --> 00:00:34,870
Οποιαδήποτε λογική που θέλουμε να εκτελεί, για μια φοιτητική τους ταυτότητα θα πρέπει να αντιγραφεί και επικολληθεί

8
00:00:34,870 --> 00:00:36,870
για κάθε μια από αυτές τις ταυτότητες των σπουδαστών.

9
00:00:36,870 --> 00:00:39,710
Αν θέλουμε να ελέγξετε ποια μαθητές τυχαίνει να είναι σε CS50,

10
00:00:39,710 --> 00:00:43,910
θα πρέπει πρώτα να ελέγξετε αν ID0 αντιπροσωπεύει το μαθητή στο μάθημα.

11
00:00:43,910 --> 00:00:48,070
Στη συνέχεια, να κάνουν το ίδιο για την επόμενη φοιτητής, θα πρέπει να αντιγράψετε και να επικολλήσετε τον κώδικα για ID0

12
00:00:48,070 --> 00:00:54,430
και να αντικαταστήσετε όλες τις εμφανίσεις του με ID0 id1 και ούτω καθεξής για id2, 3, και 4.

13
00:00:54,430 --> 00:00:57,560
>> Μόλις ακούσετε ότι πρέπει να αντιγράψετε και να επικολλήσετε,

14
00:00:57,560 --> 00:01:00,440
θα πρέπει να αρχίσουμε να σκεφτόμαστε ότι υπάρχει μια καλύτερη λύση.

15
00:01:00,440 --> 00:01:05,360
Τώρα τι γίνεται αν έχετε συνειδητοποιήσει ότι δεν χρειάζεται 5 ταυτότητες των φοιτητών αλλά 7;

16
00:01:05,360 --> 00:01:09,570
Θα πρέπει να πάμε πίσω στο πηγαίο κώδικα σας και να προσθέσετε σε μια ID5, μια ID6,

17
00:01:09,570 --> 00:01:14,260
και να αντιγράψετε και να επικολλήσετε τη λογική για τον έλεγχο αν οι ταυτότητες ανήκουν στην κατηγορία για αυτές τις 2 νέες ταυτότητες.

18
00:01:14,260 --> 00:01:19,600
Δεν υπάρχει τίποτα που συνδέει όλες αυτές τις ταυτότητες μαζί, και έτσι δεν υπάρχει κανένας τρόπος για να ζητήσει

19
00:01:19,600 --> 00:01:22,040
το πρόγραμμα για να το κάνετε αυτό για ταυτότητες 0 έως 6.

20
00:01:22,040 --> 00:01:26,120
Λοιπόν τώρα έχετε συνειδητοποιήσει έχετε 100 ταυτότητες των μαθητών.

21
00:01:26,120 --> 00:01:30,770
Είναι αρχίζουν να μοιάζουν λιγότερο από το ιδανικό να πρέπει να δηλώσουν ξεχωριστά κάθε ένα από αυτά τα αναγνωριστικά,

22
00:01:30,770 --> 00:01:33,760
και να αντιγράψετε και να επικολλήσετε οποιαδήποτε λογική για αυτές τις νέες ταυτότητες.

23
00:01:33,760 --> 00:01:38,380
Αλλά ίσως είμαστε αποφασισμένοι, και το κάνουμε για όλους τους 100 μαθητές.

24
00:01:38,380 --> 00:01:42,240
Αλλά τι γίνεται αν δεν ξέρετε πόσοι μαθητές πραγματικά υπάρχουν;

25
00:01:42,240 --> 00:01:47,320
Υπάρχουν μόνο μερικές n φοιτητές και το πρόγραμμά σας θα πρέπει να ζητήσει από το χρήστη τι είναι n.

26
00:01:47,320 --> 00:01:50,250
Uh oh. Αυτό δεν πρόκειται να λειτουργήσει πολύ καλά.

27
00:01:50,250 --> 00:01:53,820
Το πρόγραμμά σας λειτουργεί μόνο για κάποιο σταθερό αριθμό μαθητών.

28
00:01:53,820 --> 00:01:57,520
>> Επίλυση όλα αυτά τα προβλήματα είναι η ομορφιά των πινάκων.

29
00:01:57,520 --> 00:01:59,930
Έτσι τι είναι ένας πίνακας;

30
00:01:59,930 --> 00:02:04,480
Σε μερικές γλώσσες προγραμματισμού ένας τύπος σειρά θα μπορούσε να είναι σε θέση να κάνει λίγο περισσότερο,

31
00:02:04,480 --> 00:02:09,960
αλλά εδώ θα εστιάσουμε στη βασική δομή του πίνακα δεδομένων ακριβώς όπως θα το δείτε σε C.

32
00:02:09,960 --> 00:02:14,030
Ένας πίνακας είναι απλά ένα μεγάλο μπλοκ μνήμης. Αυτό είναι όλο.

33
00:02:14,030 --> 00:02:17,770
Όταν λέμε ότι έχουμε μια σειρά από 10 ακέραιους αριθμούς, που απλώς σημαίνει ότι έχουμε κάποια μπλοκ

34
00:02:17,770 --> 00:02:20,740
της μνήμης που είναι αρκετά μεγάλο ώστε να περιέχει 10 ξεχωριστές ακέραιοι.

35
00:02:29,930 --> 00:02:33,410
Υποθέτοντας ότι είναι ένας ακέραιος 4 byte, αυτό σημαίνει ότι μία συστοιχία 10 ακεραίων

36
00:02:33,410 --> 00:02:37,180
είναι μια συνεχής μπλοκ 40 bytes στη μνήμη.

37
00:02:42,660 --> 00:02:46,280
Ακόμα και όταν χρησιμοποιείτε πολυδιάστατους πίνακες, τα οποία εμείς δεν θα πάμε για να εδώ,

38
00:02:46,280 --> 00:02:49,200
είναι ακόμα μόνο ένα μεγάλο μπλοκ μνήμης.

39
00:02:49,200 --> 00:02:51,840
Η πολυδιάστατη σημειογραφία είναι απλά μια ευκολία.

40
00:02:51,840 --> 00:02:55,640
Εάν έχετε ένα 3 από 3 πολυδιάστατη array ακεραίων,

41
00:02:55,640 --> 00:03:00,650
τότε το πρόγραμμά σας θα είναι πραγματικά αντιμετωπίζουν ακριβώς αυτό ως ένα μεγάλο μπλοκ των 36 bytes.

42
00:03:00,650 --> 00:03:05,460
Ο συνολικός αριθμός των ακεραίων είναι 3 φορές 3, και κάθε ακέραιος καταλαμβάνει 4 bytes.

43
00:03:05,460 --> 00:03:07,750
>> Ας ρίξουμε μια ματιά σε ένα βασικό παράδειγμα.

44
00:03:07,750 --> 00:03:10,660
Μπορούμε να δούμε εδώ 2 διαφορετικούς τρόπους δηλώνοντας συστοιχίες.

45
00:03:15,660 --> 00:03:18,580
Θα πρέπει να σχολιάσω 1 από τους έξω για το πρόγραμμα για την κατάρτιση

46
00:03:18,580 --> 00:03:20,900
από τη στιγμή που δηλώνουν x δύο φορές.

47
00:03:20,900 --> 00:03:25,140
Θα ρίξουμε μια ματιά σε μερικές από τις διαφορές μεταξύ αυτών των 2 τύπων των δηλώσεων σε λίγο.

48
00:03:25,140 --> 00:03:28,560
Και οι δύο αυτές γραμμές δηλώνουν μια σειρά από Ν μεγέθους,

49
00:03:28,560 --> 00:03:30,740
όπου έχουμε ορίσει ως # N 10.

50
00:03:30,740 --> 00:03:34,460
Θα μπορούσαμε κάλλιστα να ζητήσει από το χρήστη για ένα θετικό ακέραιο

51
00:03:34,460 --> 00:03:37,250
και ότι χρησιμοποιείται ως ακέραιος αριθμός των στοιχείων σε σειρά μας.

52
00:03:37,250 --> 00:03:41,960
Όπως φοιτητής παράδειγμα μας ταυτότητας πριν, αυτό είναι το είδος του σαν κηρύσσοντας την 10η εντελώς ξεχωριστή

53
00:03:41,960 --> 00:03:49,000
φανταστικών μεταβλητών? x0, x1, x2, και ούτω καθεξής μέχρι να xN-1.

54
00:03:57,270 --> 00:04:00,840
Αγνοώντας τις γραμμές όπου δηλώνουμε τον πίνακα, παρατηρούμε οι αγκύλες άθικτο

55
00:04:00,840 --> 00:04:02,090
στο εσωτερικό του για βρόχους.

56
00:04:02,090 --> 00:04:09,660
Όταν γράφουμε κάτι σαν x [3], το οποίο απλώς θα διαβάζεται ως στήριγμα x 3,

57
00:04:09,660 --> 00:04:13,090
μπορείτε να σκεφτείτε από το όπως ζητά το φανταστικό x3.

58
00:04:13,090 --> 00:04:17,519
Ανακοίνωση από ότι με ένα πίνακα μεγέθους Ν, αυτό σημαίνει ότι ο αριθμός εσωτερικό των παρενθέσεων,

59
00:04:17,519 --> 00:04:22,630
το οποίο θα καλέσετε τον δείκτη, μπορεί να είναι οτιδήποτε, από 0 έως Ν-1,

60
00:04:22,630 --> 00:04:25,660
το οποίο είναι ένα σύνολο Ν δεικτών.

61
00:04:25,660 --> 00:04:28,260
>> Για να σκεφτούμε πώς αυτό λειτουργεί πραγματικά

62
00:04:28,260 --> 00:04:31,260
να θυμάστε ότι η σειρά είναι ένα μεγάλο μπλοκ μνήμης.

63
00:04:31,260 --> 00:04:37,460
Αν υποθέσουμε ότι ένας ακέραιος είναι 4 bytes, ολόκληρη η σειρά Χ είναι 40 byte μπλοκ μνήμης.

64
00:04:37,460 --> 00:04:41,360
Έτσι x0 αναφέρεται στα πρώτα 4 bytes του μπλοκ.

65
00:04:45,810 --> 00:04:49,230
Χ [1] αναφέρεται στις επόμενες 4 bytes και ούτω καθεξής.

66
00:04:49,230 --> 00:04:53,760
Αυτό σημαίνει ότι η έναρξη του x είναι όλα το πρόγραμμα χρειάζεται ποτέ να παρακολουθείτε.

67
00:04:55,660 --> 00:04:59,840
Αν θέλετε να χρησιμοποιήσετε x [400], τότε το πρόγραμμα ξέρει ότι αυτό είναι ισοδύναμο

68
00:04:59,840 --> 00:05:03,460
σε μόλις 1.600 bytes μετά την έναρξη του x.

69
00:05:03,460 --> 00:05:08,780
Πού έχουμε 1.600 bytes από; Είναι μόλις 400 φορές 4 bytes ανά ακέραιο.

70
00:05:08,780 --> 00:05:13,170
>> Πριν προχωρήσουμε, είναι πολύ σημαντικό να συνειδητοποιήσουμε ότι σε C

71
00:05:13,170 --> 00:05:17,080
δεν υπάρχει εφαρμογή του δείκτη που χρησιμοποιούμε στον πίνακα.

72
00:05:17,080 --> 00:05:23,180
Μεγάλο μπλοκ μας είναι μόνο 10 ακέραιοι καιρό, αλλά τίποτα δεν θα φωνάζω σε μας αν γράφουμε x [20]

73
00:05:23,180 --> 00:05:26,060
ή ακόμη x [-5].

74
00:05:26,060 --> 00:05:28,240
Ο δείκτης δεν χρειάζεται καν να είναι ένας αριθμός.

75
00:05:28,240 --> 00:05:30,630
Μπορεί να είναι οποιοδήποτε αυθαίρετο έκφραση.

76
00:05:30,630 --> 00:05:34,800
Στο πρόγραμμα που χρησιμοποιείτε το i μεταβλητή από το βρόχο για να δείκτη μέσα στον πίνακα.

77
00:05:34,800 --> 00:05:40,340
Αυτό είναι ένα πολύ κοινό μοτίβο, looping από i = 0 προς το μήκος της συστοιχίας,

78
00:05:40,340 --> 00:05:43,350
και χρησιμοποιώντας i συνέχεια ως δείκτης για τη συστοιχία.

79
00:05:43,350 --> 00:05:46,160
Με αυτόν τον τρόπο μπορείτε αποτελεσματικά βρόχο επί ολόκληρης της συστοιχίας,

80
00:05:46,160 --> 00:05:50,600
και μπορείτε είτε να αντιστοιχίσετε σε κάθε σημείο του πίνακα ή να το χρησιμοποιήσετε για κάποιο υπολογισμό.

81
00:05:50,600 --> 00:05:53,920
>> Στην πρώτη για το βρόχο, ί ξεκινά στις 0,

82
00:05:53,920 --> 00:05:58,680
και έτσι θα μπορεί να αναθέτει στο σημείο 0 στον πίνακα, η τιμή 0 φορές 2.

83
00:05:58,680 --> 00:06:04,370
Στη συνέχεια θ προσαυξήσεις, και έχουμε εκχωρήσει την πρώτη θέση στον πίνακα η τιμή 1 φορές 2.

84
00:06:04,370 --> 00:06:10,170
Τότε θ προσαυξήσεις πάλι και ούτω καθεξής μέχρι να εκχωρήσει στη θέση Ν-1 στη συστοιχία

85
00:06:10,170 --> 00:06:13,370
η τιμή Ν-1 φορές 2.

86
00:06:13,370 --> 00:06:17,810
Έτσι έχουμε δημιουργήσει έναν πίνακα με τις πρώτες 10 ζυγούς αριθμούς.

87
00:06:17,810 --> 00:06:21,970
Ίσως εξισώνει θα ήταν λίγο καλύτερο όνομα για τη μεταβλητή από ό, τι χ,

88
00:06:21,970 --> 00:06:24,760
αλλά που θα έχουν δώσει τα πράγματα μακριά.

89
00:06:24,760 --> 00:06:30,210
Ο δεύτερος βρόχος για τυπώνει έπειτα ακριβώς τις αξίες που έχουν ήδη αποθηκευτεί στο εσωτερικό του πίνακα.

90
00:06:30,210 --> 00:06:33,600
>> Ας δοκιμάστε να τρέξετε το πρόγραμμα και με τους δύο τύπους των δηλώσεων σειρά

91
00:06:33,600 --> 00:06:36,330
και ρίξτε μια ματιά στην έξοδο του προγράμματος.

92
00:06:51,450 --> 00:06:57,020
Όσο μπορούμε να δούμε, το πρόγραμμα συμπεριφέρεται με τον ίδιο τρόπο και για τους δύο τύπους των δηλώσεων.

93
00:06:57,020 --> 00:07:02,230
Ας ρίξουμε μια ματιά στο τι συμβαίνει αν αλλάξουμε το πρώτο loop να μην σταματήσει στο Ν

94
00:07:02,230 --> 00:07:05,040
αλλά μάλλον να πω 10.000.

95
00:07:05,040 --> 00:07:07,430
Way πέρα ​​από το τέλος του πίνακα.

96
00:07:14,700 --> 00:07:17,210
Ωχ. Ίσως έχετε δει αυτό πριν.

97
00:07:17,210 --> 00:07:20,440
Ένα σφάλμα κατάτμησης σημαίνει ότι το πρόγραμμά σας έχει συνετρίβη.

98
00:07:20,440 --> 00:07:24,430
Θα αρχίσουμε να βλέπουμε αυτά όταν αγγίζετε περιοχές της μνήμης δεν θα πρέπει να αγγίζουν.

99
00:07:24,430 --> 00:07:27,870
Εδώ έχουμε να κάνουμε 10.000 θέσεις μετά την έναρξη του x,

100
00:07:27,870 --> 00:07:31,920
η οποία είναι προφανώς μια θέση στη μνήμη μας δεν θα πρέπει να αγγίζουν.

101
00:07:31,920 --> 00:07:37,690
Έτσι, οι περισσότεροι από εμάς μάλλον δεν θα θέσει κατά λάθος 10.000 αντί του Ν,

102
00:07:37,690 --> 00:07:42,930
αλλά τι γίνεται αν κάνουμε κάτι πιο λεπτές, όπως λένε εγγραφής μικρότερη ή ίση με Ν

103
00:07:42,930 --> 00:07:46,830
στο βρόχο για την κατάσταση, σε αντίθεση με λιγότερο από Ν.

104
00:07:46,830 --> 00:07:50,100
Θυμάστε ότι μια συστοιχία έχει μόνο δείκτες από 0 έως Ν-1,

105
00:07:50,100 --> 00:07:54,510
πράγμα που σημαίνει ότι δείκτης Ν είναι πέρα ​​από το άκρο της συστοιχίας.

106
00:07:54,510 --> 00:07:58,050
Το πρόγραμμα δεν θα μπορούσε να συντριβή σε αυτή την περίπτωση, αλλά είναι ακόμα ένα λάθος.

107
00:07:58,050 --> 00:08:01,950
Στην πραγματικότητα, αυτό το λάθος είναι τόσο κοινό ότι έχει το δικό του το όνομά του,

108
00:08:01,950 --> 00:08:03,970
μια off με 1 λάθος.

109
00:08:03,970 --> 00:08:05,970
>> Αυτός είναι αυτό για τα βασικά.

110
00:08:05,970 --> 00:08:09,960
Έτσι, ποιες είναι οι κύριες διαφορές μεταξύ των 2 τύπων των δηλώσεων πίνακα;

111
00:08:09,960 --> 00:08:13,960
Μια διαφορά είναι όπου το μεγάλο μπλοκ μνήμης πηγαίνει.

112
00:08:13,960 --> 00:08:17,660
Στην πρώτη δήλωση, η οποία θα καλέσω το στήριγμα συστοιχία τύπου,

113
00:08:17,660 --> 00:08:20,300
αν και αυτό δεν είναι καθόλου ένα συμβατικό όνομα,

114
00:08:20,300 --> 00:08:22,480
θα πάει στη στοίβα.

115
00:08:22,480 --> 00:08:27,450
Ενώ στο δεύτερο, το οποίο θα καλέσω το δείκτη συστοιχία τύπου, θα πάει στο σωρό.

116
00:08:27,450 --> 00:08:32,480
Αυτό σημαίνει ότι όταν οι αποδόσεις λειτουργίας, η συστοιχία βραχίονας αυτόματα θα deallocated,

117
00:08:32,480 --> 00:08:36,419
λαμβάνοντας υπόψη ότι θα πρέπει να καλέσετε δωρεάν explicitily στη συστοιχία δείκτη

118
00:08:36,419 --> 00:08:38,010
ή αλλιώς έχετε μια διαρροή μνήμης.

119
00:08:38,010 --> 00:08:42,750
Επιπλέον, η συστοιχία βραχίονα δεν είναι στην πραγματικότητα μια μεταβλητή.

120
00:08:42,750 --> 00:08:45,490
Αυτό είναι σημαντικό. Είναι απλά ένα σύμβολο.

121
00:08:45,490 --> 00:08:49,160
Μπορείτε να σκεφτείτε από το ως μια σταθερή ότι ο μεταγλωττιστής επιλέγει για εσάς.

122
00:08:49,160 --> 00:08:52,970
Αυτό σημαίνει ότι δεν μπορούμε να κάνουμε κάτι σαν x + + με τον τύπο βραχίονα,

123
00:08:52,970 --> 00:08:56,240
αν και αυτό είναι απολύτως έγκυρη με τον τύπο δείκτη.

124
00:08:56,240 --> 00:08:58,270
>> Ο τύπος δείκτης είναι μια μεταβλητή.

125
00:08:58,270 --> 00:09:01,510
Για τον τύπο δείκτη, έχουμε 2 ξεχωριστά κομμάτια μνήμης.

126
00:09:01,510 --> 00:09:06,060
Η μεταβλητή χ η ίδια είναι αποθηκευμένο στη στοίβα και είναι μόνο ένα δείκτη,

127
00:09:06,060 --> 00:09:08,620
αλλά το μεγάλο μπλοκ μνήμης αποθηκεύεται στο σωρό.

128
00:09:08,620 --> 00:09:11,010
Η μεταβλητή x στη στοίβα αποθηκεύει μόνο τη διεύθυνση

129
00:09:11,010 --> 00:09:14,010
από το μεγάλο μπλοκ της μνήμης του σωρού.

130
00:09:14,010 --> 00:09:17,370
Μια συνέπεια αυτού είναι με το μέγεθος της εκμετάλλευσης.

131
00:09:17,370 --> 00:09:22,480
Αν ρωτήσετε για το μέγεθος του πίνακα βραχίονα, που θα σας δώσει το μέγεθος του μεγάλου μπλοκ της μνήμης,

132
00:09:22,480 --> 00:09:24,620
κάτι σαν 40 bytes,

133
00:09:24,620 --> 00:09:26,920
αλλά αν σας ρωτήσω για το μέγεθος του τύπου δείκτη του πίνακα,

134
00:09:26,920 --> 00:09:32,740
θα σας δώσει το μέγεθος της μεταβλητής x η ίδια, η οποία για τη συσκευή είναι πιθανό μόλις 4 bytes.

135
00:09:32,740 --> 00:09:36,530
Χρησιμοποιώντας τον τύπο του δείκτη συστοιχία, είναι αδύνατον να ζητήσει άμεσα

136
00:09:36,530 --> 00:09:38,530
το μέγεθος του μεγάλου μπλοκ μνήμης.

137
00:09:38,530 --> 00:09:42,530
Αυτό δεν είναι συνήθως πολύ ενός περιορισμού δεδομένου ότι πολύ σπάνια θέλουν το μέγεθος

138
00:09:42,530 --> 00:09:46,980
από το μεγάλο μπλοκ μνήμης, και μπορούμε να υπολογίσουμε ότι συνήθως αν χρειαζόμαστε.

139
00:09:46,980 --> 00:09:51,490
>> Τέλος, η σειρά βραχίονα συμβαίνει για να μας δώσει μια συντόμευση για την εκκίνηση μιας σειράς.

140
00:09:51,490 --> 00:09:56,130
Ας δούμε πώς θα μπορούσαμε να γράψουμε τα πρώτα 10 ακόμη και ακέραιοι χρησιμοποιώντας τη συντόμευση initilization.

141
00:10:11,220 --> 00:10:14,470
Με τη σειρά δείκτη, δεν υπάρχει ένας τρόπος για να κάνει μια συντόμευση σαν αυτό.

142
00:10:14,470 --> 00:10:18,120
Αυτό είναι απλά μια εισαγωγή για το τι μπορείτε να κάνετε με συστοιχίες.

143
00:10:18,120 --> 00:10:20,990
Δείχνουν σε σχεδόν σε κάθε πρόγραμμα που γράφετε.

144
00:10:20,990 --> 00:10:24,390
Ας ελπίσουμε ότι μπορείτε να δείτε τώρα έναν καλύτερο τρόπο για να γίνει το παράδειγμα φοιτητή αναγνωριστικά

145
00:10:24,390 --> 00:10:26,710
από την αρχή του βίντεο.

146
00:10:26,710 --> 00:10:29,960
>> Το όνομά μου είναι Rob Bowden, και αυτό είναι CS50.