1
00:00:00,000 --> 00:00:06,030
>> [Παίζει μουσική]

2
00:00:06,030 --> 00:00:08,390
>> DOUG LLOYD: Δείκτες, εδώ είμαστε.

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
>> Αν θέλουμε να ανταλλάξουν Χ και Υ, και εμείς
τους περάσει σε μια λειτουργία που ονομάζεται swap,

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
Με δείκτες όμως, μπορούμε να
στην πραγματικότητα περνούν Χ και Υ σε λειτουργία.

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
έχετε ένα σκληρό δίσκο ή
ίσως μια μονάδα SSD,

52
00:02:51,310 --> 00:02:54,430
κάποιο είδος της τοποθεσίας αποθήκευσης του αρχείου.

53
00:02:54,430 --> 00:02:57,950
Είναι συνήθως κάπου στο
γειτονιά των 250 gigabytes

54
00:02:57,950 --> 00:02:59,810
με ίσως ένα ζευγάρι των terabytes τώρα.

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, η μονάδα 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
ή σε μια μονάδα SSD.

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 megabytes

66
00:03:34,185 --> 00:03:38,850
αν έχετε ένα παλαιότερο υπολογιστή,
με ίσως δύο, τέσσερις, οκτώ, 16,

67
00:03:38,850 --> 00:03:41,820
ενδεχομένως ακόμη και ένα μικρό
Επιπλέον, gigabytes μνήμης 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
Έτσι, κάθε φορά που δημιουργείτε έναν ακέραιο
μεταβλητή, τέσσερα bytes της μνήμης

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, και έχετε τέσσερα bytes

85
00:04:39,440 --> 00:04:42,550
να συνεργαστεί με κάθε για
ακέραιος που δημιουργείτε.

86
00:04:42,550 --> 00:04:45,410
>> Κάθε χαρακτήρας σας
δημιουργήσετε παίρνει ένα byte.

87
00:04:45,410 --> 00:04:48,160
Αυτό είναι ακριβώς πόσος χώρος υπάρχει
απαιτείται για την αποθήκευση ενός χαρακτήρα.

88
00:04:48,160 --> 00:04:51,310
Κάθε float, ένα πραγματικό
τον αριθμό, παίρνει τέσσερα bytes

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
που καταλαμβάνουν οκτώ bytes της μνήμης.

93
00:05:01,820 --> 00:05:06,730
Μακριά λαχταρά, πραγματικά μεγάλο ακέραιοι,
επίσης να λάβουν οκτώ bytes της μνήμης.

94
00:05:06,730 --> 00:05:09,000
Πόσα bytes της μνήμης
δεν χορδές καταλαμβάνουν;

95
00:05:09,000 --> 00:05:12,990
Λοιπόν ας βάλουμε μια καρφίτσα στο ερώτημα αυτό
για τώρα, αλλά θα επανέλθουμε σε αυτό.

96
00:05:12,990 --> 00:05:17,350
>> Έτσι, πίσω σε αυτήν την ιδέα της μνήμης
μια μεγάλη σειρά από byte μεγέθους κυττάρων.

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
με εξαίρεση κάθε στοιχείο είναι ένα byte ευρύ.

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 bytes της μνήμης.

111
00:06:01,420 --> 00:06:04,060
Τα πρώτα 20 bytes, διότι μου
αντιμετωπίζει εκεί στο κάτω μέρος

112
00:06:04,060 --> 00:06:08,890
είναι 0, 1, 2, 3, και έτσι
για όλη τη διαδρομή μέχρι το 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
Έτσι, θα έλεγα, char c ισούται κεφαλαίου
Η Και τι πρόκειται να συμβεί;

117
00:06:21,610 --> 00:06:23,880
Καλά το σύστημα πρόκειται να
που προορίζεται για μένα ένα byte.

118
00:06:23,880 --> 00:06:27,870
Στην περίπτωση αυτή, επέλεξε τον αριθμό byte
τέσσερα, το byte στη διεύθυνση τέσσερις,

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
πρόκειται να αναιρέσει τέσσερις
bytes της μνήμης για μένα.

122
00:06:36,806 --> 00:06:39,180
Και πρόκειται για τη θεραπεία εκείνων
τέσσερις ψηφιολέξεις ως ενιαία μονάδα

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, που μόνο
κατανοήσει δυαδικό, μηδενικά και μονάδες.

129
00:06:57,110 --> 00:06:59,000
Και έτσι πραγματικά ό, τι
είμαστε αποθήκευση εκεί

130
00:06:59,000 --> 00:07:03,450
Δεν είναι το γράμμα Η και ο αριθμός 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
δεν πρόκειται να το φτύσει ακριβώς σε,
δεν πρόκειται να την αντιμετωπίσουμε ως μια τέσσερις

134
00:07:13,559 --> 00:07:15,350
byte κομμάτι κατ 'ανάγκην,
αυτό είναι πραγματικά συμβαίνει

135
00:07:15,350 --> 00:07:19,570
να την αντιμετωπίσουμε ως ένα τέσσερα κομμάτια byte,
η οποία μπορεί να μοιάζει κάπως έτσι.

136
00:07:19,570 --> 00:07:22,424
Και ακόμη και αυτό δεν είναι
είτε εντελώς αλήθεια,

137
00:07:22,424 --> 00:07:24,840
γιατί για κάτι που ονομάζεται
μια endianness, το οποίο δεν είμαστε

138
00:07:24,840 --> 00:07:26,965
πρόκειται να μπει σε τώρα, αλλά
αν είστε περίεργοι σχετικά,

139
00:07:26,965 --> 00:07:29,030
μπορείτε να διαβάσετε για λίγο
και μεγάλα endianness.

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
δεν μου δώσει bytes 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
Παρά το γεγονός ότι πρόκειται να το κάνουμε τώρα
αν θέλω να πάρω ένα άλλο string,

154
00:08:10,490 --> 00:08:13,080
κάλεσε το επώνυμο, και θέλω
να θέσει Lloyd εκεί.

155
00:08:13,080 --> 00:08:18,360
Πάω να πρέπει να εντάσσονται σε μία
χαρακτήρα, κάθε γράμμα που είναι

156
00:08:18,360 --> 00:08:21,330
πρόκειται να απαιτήσει ένα
χαρακτήρας, ένα byte της μνήμης.

157
00:08:21,330 --> 00:08:26,230
Έτσι, αν θα μπορούσα να βάλω σε σειρά Lloyd μου
όπως αυτό είμαι αρκετά καλός για να πάει, έτσι δεν είναι;

158
00:08:26,230 --> 00:08:28,870
Τι λείπει;

159
00:08:28,870 --> 00:08:31,840
>> Να θυμάστε ότι κάθε χορδή δουλεύουμε
με σε C τελειώνει με ανάστροφη κάθετο μηδέν,

160
00:08:31,840 --> 00:08:33,339
και δεν μπορούμε να παραλείψουμε ότι εδώ, είτε.

161
00:08:33,339 --> 00:08:36,090
Θα πρέπει να αναιρέσει ένα byte
της μνήμης για να κρατήσει ότι γι 'αυτό

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
Γιατί λοιπόν να μην έχουμε μετατρέψει όλα αυτά
από δεκαδικό σε δεκαεξαδικό σύστημα

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
x μηδέν έως τρεις x1 μηδέν.

179
00:09:20,340 --> 00:09:23,790
Αυτά είναι τα 20 bytes της μνήμης που θα
έχουν ή κοιτάμε σε αυτή την εικόνα

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
Οι pointers είναι διευθύνσεις σε θέσεις
στη μνήμη όπου ζουν οι μεταβλητές.

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
Αν ήταν ένας χαρακτήρας μου
θα μπορούσε να έχει ένα μπλε πλαίσιο.

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
Και παίρνω ένα ανεξίτηλο μαρκαδόρο
και γράφω k από την πλευρά του.

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
Έτσι, Πάω να χρωματίσει
αυτό το πλαίσιο πράσινο-ish,

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, whoa,
τι ακριβώς συνέβη, έτσι δεν είναι;

226
00:11:37,650 --> 00:11:41,820
Έτσι, αυτό το τυχαίο αριθμό, φαινομενικά τυχαία
τον αριθμό, παίρνει ρίχνονται μέσα στο κουτί εκεί.

227
00:11:41,820 --> 00:11:44,930
Το μόνο που είναι, είναι pk
παίρνει τη διεύθυνση του κ.

228
00:11:44,930 --> 00:11:52,867
Έτσι έχω κολλήσει όπου k ζει στη μνήμη,
διεύθυνση, η διεύθυνση των bytes της.

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
γ οκτώ μηδέν επτά τέσσερις οκτώ

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
Αν παίρνουμε μια teeny
λίγο πριν από τους εαυτούς μας για τώρα.

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

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
Είναι ένας ακέραιος αριθμός, αυτό είναι ό, τι
θα βρείτε αν πάω σε αυτή τη διεύθυνση.

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
θα κάνετε ένα αντίγραφο της Xerox
Κάθε σελίδα του φορητού υπολογιστή.

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
και, στη συνέχεια, θα περάσετε πίσω στο
με τη στοίβα των σελίδων της Xerox

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
Όπως δεν θα ήταν καλύτερο
αν ήθελα απλώς να πω, hey, μπορεί να σας

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
είναι άκυρη, διότι αυτή είναι σπάνια αλήθεια.

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
Μπορείτε να ελέγξετε αν η αξία ενός δείκτη της
είναι μηδενική χρήση του τελεστή ισότητας

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
Έτσι, αυτό ήταν ένα πολύ απλό
δείκτης, ο δείκτης null.

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
τότε και το χ είναι ένας δείκτης σε ακέραιο.

317
00:16:35,110 --> 00:16:39,810
& Χ είναι- να θυμάστε, και πρόκειται να εξαγάγει
η διεύθυνση του πράγματος στα δεξιά.

318
00:16:39,810 --> 00:16:45,350
Και δεδομένου ότι ένας δείκτης είναι απλώς μια διεύθυνση,
ό, τι και το χ είναι ένας δείκτης σε ακέραιο

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.

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
Αν ARR είναι μια σειρά από δίκλινα, στη συνέχεια,
& ARR αγκύλη i είναι ένας δείκτης

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
arr αγκύλη i, αν
ARR είναι μια σειρά από δίκλινα,

328
00:17:12,160 --> 00:17:19,069
Στη συνέχεια arr αγκύλη i είναι
το i-th στοιχείο της συστοιχίας,

329
00:17:19,069 --> 00:17:29,270
και & arr αγκύλη i είναι αυτή όπου σε
μνήμη το 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
κοντά στο τέλος του βίντεο που παρουσιάζουν
ένα παράδειγμα όπου έχουμε μια συνάρτηση

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
Και κάνουν την ιδέα μιας
pointer πολύ λιγότερο εκφοβιστικό,

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
και αυτό σημαίνει ότι ανεξάρτητα από
ήταν σε διεύθυνση μνήμης του υπολογιστή,

375
00:19:59,280 --> 00:20:07,040
ανεξαρτήτως του χαρακτήρα ήταν προηγουμένως
εκεί, είναι τώρα D, αν λέμε * pc = 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
Και τώρα είναι η
χειριστή dereference.

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
Και ο τρόπος που πάει προς την διεύθυνση είναι
στη χρήση *, το χειριστή dereference.

401
00:21:21,495 --> 00:21:23,620
Τι νομίζετε ότι θα συμβεί
αν προσπαθήσουμε και dereference

402
00:21:23,620 --> 00:21:25,260
ένας δείκτης του οποίου η αξία είναι μηδενική;

403
00:21:25,260 --> 00:21:28,470
Υπενθυμίζεται ότι η μηδενική
δείκτης δείχνει τίποτα.

404
00:21:28,470 --> 00:21:34,110
Έτσι, αν προσπαθήσετε και dereference
τίποτα ή να πάει σε τίποτα διεύθυνση,

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
Αν προσπαθήσετε και dereference
ένα κενό δείκτη,

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
Όταν δηλώνουμε έναν pointer
int * pk για παράδειγμα,

421
00:22:20,110 --> 00:22:23,490
και να μην αναθέσει σε μια τιμή,
μπορείτε να πάρετε τέσσερα byte για τη μνήμη.

422
00:22:23,490 --> 00:22:25,950
Όποια και αν είναι τέσσερα byte
μνήμη του συστήματος μπορεί να

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
>> Τι θα συμβεί αν προσπαθήσατε να κάνετε dereference
κάποια διεύθυνση που υπήρχαν don't-

428
00:22:40,570 --> 00:22:43,410
ήδη bytes και πληροφορίες
εκεί, που είναι τώρα στο δείκτη σας.

429
00:22:43,410 --> 00:22:47,470
Αν προσπαθήσετε και dereference εν λόγω δείκτη,
ίσως να μπέρδεμα με κάποια μνήμη

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
και ότι μπορείτε με ασφάλεια να το dereference.

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
Γνωρίζω ότι η τιμή του p είναι μια διεύθυνση
γιατί όλοι οι δείκτες είναι μόνο

448
00:23:43,290 --> 00:23:44,660
διευθύνσεις.

449
00:23:44,660 --> 00:23:47,750
Δεν μπορώ να dereference σ
χρησιμοποιώντας τον τελεστή *.

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
Αλλά μπορώ να dereference
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 είναι βασικά
λέγοντας, ρ είναι μια διεύθυνση.

456
00:24:05,910 --> 00:24:09,500
Δεν μπορώ να dereference σ και αν
Κάνω, θα βρείτε έναν ακέραιο

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
και τα αστέρια, αυτό που πραγματικά χρειάζεστε
να κάνουμε είναι να πούμε int * ετησίως, * PB, PC *.

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
Με την πρακτική που κάνει
πραγματικά να γίνει δεύτερη φύση.

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
η έννοια του πόσο μεγάλο είναι ένα string.

491
00:25:59,370 --> 00:26:02,750
Λοιπόν, αν σας είπα ότι μια
string, έχουμε πραγματικά το είδος του

492
00:26:02,750 --> 00:26:04,140
ψέματα για να σας όλη την ώρα.

493
00:26:04,140 --> 00:26:06,181
Δεν υπάρχει κανένας τύπος δεδομένων που ονομάζεται
string, και στην πραγματικότητα,

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
>> Καλά string είναι πραγματικά μόνο
ένα ψευδώνυμο για κάτι

498
00:26:19,250 --> 00:26:23,600
ονομάζεται το char *, ένα
pointer σε ένα χαρακτήρα.

499
00:26:23,600 --> 00:26:26,010
Λοιπόν δείκτες, ανάκληση,
Οι διευθύνσεις μόνο.

500
00:26:26,010 --> 00:26:28,780
Έτσι, ποιο είναι το μέγεθος
σε bytes μια σειρά;

501
00:26:28,780 --> 00:26:29,796
Καλά είναι τέσσερις ή οκτώ.

502
00:26:29,796 --> 00:26:32,170
Και ο λόγος που το λέω τέσσερις ή
από οκτώ είναι επειδή στην πραγματικότητα

503
00:26:32,170 --> 00:26:36,730
εξαρτάται από το σύστημα, Εάν χρησιμοποιείτε
CS50 ide, char * είναι το μέγεθος ενός char

504
00:26:36,730 --> 00:26:39,340
* Είναι οκτώ, είναι ένα σύστημα 64-bit.

505
00:26:39,340 --> 00:26:43,850
Κάθε διεύθυνση στη μνήμη έχει μήκος 64 bits.

506
00:26:43,850 --> 00:26:48,270
Εάν χρησιμοποιείτε συσκευή CS50
ή να χρησιμοποιήσετε οποιαδήποτε μηχανή 32-bit,

507
00:26:48,270 --> 00:26:51,640
και έχετε ακούσει αυτόν τον όρο 32-bit
μηχανή, ό, τι είναι μια μηχανή 32-bit;

508
00:26:51,640 --> 00:26:56,090
Λοιπόν αυτό σημαίνει απλώς ότι κάθε
διεύθυνσης στη μνήμη έχει μήκος 32 bits.

509
00:26:56,090 --> 00:26:59,140
Και έτσι 32 bits είναι τέσσερα byte.

510
00:26:59,140 --> 00:27:02,710
Έτσι, ένα char * είναι τέσσερις ή οκτώ
bytes, ανάλογα με το σύστημά σας.

511
00:27:02,710 --> 00:27:06,100
Και πράγματι οποιαδήποτε τύπους δεδομένων,
και ένα δείκτη σε οποιαδήποτε δεδομένα

512
00:27:06,100 --> 00:27:12,030
Τύπος, δεδομένου ότι όλοι οι δείκτες είναι μόνο
διευθύνσεις, είναι τέσσερα ή οκτώ bytes.

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
Σε αυτό το πλαίσιο εδώ, είναι *
χειριστή dereference.

522
00:27:39,890 --> 00:27:42,110
Έτσι, όταν η dereference
χειριστής χρησιμοποιείται,

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, δημιουργώ
μια νέα μεταβλητή που ονομάζεται m.

529
00:28:05,510 --> 00:28:08,260
Ένα νέο πλαίσιο, είναι ένα πράσινο κουτί, διότι
πρόκειται να κρατήσει έναν ακέραιο,

530
00:28:08,260 --> 00:28:09,840
και αυτό είναι που επισημαίνονται μ.

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
k, αλλά τα σημεία σε 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
Είμαι ο Νταγκ Lloyd, αυτό είναι CS50.

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