1
00:00:07,632 --> 00:00:10,270
[Powered by Google Translate] ΙΟΡΔΑΝΙΑ JOZWIAK: Τύπος χύτευση, στην απλούστερη έννοια, είναι μια

2
00:00:10,270 --> 00:00:13,300
τρόπος για να αλλάξει την ερμηνεία ενός υπολογιστή ορισμένων δεδομένων από

3
00:00:13,300 --> 00:00:16,560
ρητά ή σιωπηρά την αλλαγή του τύπου δεδομένων.

4
00:00:16,560 --> 00:00:19,940
Αυτή η αλλαγή ενός int σε float, ή το αντίστροφο.

5
00:00:19,940 --> 00:00:21,550
Για να καταλάβουμε χύτευση τύπου, θα πρέπει να

6
00:00:21,550 --> 00:00:22,680
ξεκινήσουμε με τα βασικά -

7
00:00:22,680 --> 00:00:24,140
τύποι δεδομένων τους.

8
00:00:24,140 --> 00:00:26,960
Σε γλώσσες προγραμματισμού όπως η C, όλες οι μεταβλητές έχουν κάποιο είδος

9
00:00:26,960 --> 00:00:29,690
από τον τύπο δεδομένων που καθορίζει το πώς ο υπολογιστής, και επίσης

10
00:00:29,690 --> 00:00:32,140
ο χρήστης, ερμηνεύει ότι η μεταβλητή.

11
00:00:32,140 --> 00:00:35,160
Αριθμητική τύπους δεδομένων όπως int, long long, float και

12
00:00:35,160 --> 00:00:38,110
δίκλινα, όλα έχουν το δικό μοναδικά χαρακτηριστικά τους και είναι

13
00:00:38,110 --> 00:00:41,370
χρησιμοποιείται για να προσδιορίσει τις αξίες των διαφόρων περιοχών και την ακρίβεια.

14
00:00:41,370 --> 00:00:44,800
Χύτευση Τύπος μας επιτρέπει να λάβουν έναν αριθμό κινητής υποδιαστολής, όπως

15
00:00:44,800 --> 00:00:49,170
3,14 και να πάρει το μέρος πριν από την υποδιαστολή, 3 στην περίπτωση αυτή,

16
00:00:49,170 --> 00:00:51,590
με χύτευση αυτή σε int.

17
00:00:51,590 --> 00:00:53,900
Ας πάρουμε ένα παράδειγμα από την αγγλική γλώσσα για ένα σύντομο

18
00:00:53,900 --> 00:00:56,910
επανεξέταση των τύπων, και να δούμε πώς τύπου χύτευσης μπορεί να αλλάξει

19
00:00:56,910 --> 00:00:59,380
ο τρόπος που ερμηνεύουν ένα κομμάτι των δεδομένων.

20
00:00:59,380 --> 00:01:05,269
Για τα δεδομένα, ας πάρουμε τα σύμβολα εδώ.

21
00:01:05,269 --> 00:01:07,570
Απλά αναφέρεται σε αυτές τις προσεκτικά διαμορφωμένο γραμμές

22
00:01:07,570 --> 00:01:10,100
σύμβολα, αλλά ως κάποιος που γνωρίζει την αγγλική γλώσσα,

23
00:01:10,100 --> 00:01:12,750
μπορείτε αμέσως να αναγνωρίσουν ότι είναι, στην πραγματικότητα, τα γράμματα.

24
00:01:12,750 --> 00:01:15,580
Καταλάβατε έμμεσα τον τύπο δεδομένων.

25
00:01:15,580 --> 00:01:17,620
Κοιτάζοντας αυτή τη σειρά των γραμμάτων μπορούμε να δούμε δύο

26
00:01:17,620 --> 00:01:20,140
διαφορετικά λόγια, το καθένα με τη δική του σημασία.

27
00:01:20,140 --> 00:01:25,530
Υπάρχει το ουσιαστικό, τον άνεμο, όπως τα φυσάει.

28
00:01:25,530 --> 00:01:28,280
Και υπάρχει το ρήμα, τον άνεμο, όπως θα πρέπει να

29
00:01:28,280 --> 00:01:31,410
συνεχεία αναλογικό ρολόι μου.

30
00:01:31,410 --> 00:01:33,420
Αυτό είναι ένα ενδιαφέρον παράδειγμα, επειδή μπορούμε να δούμε

31
00:01:33,420 --> 00:01:36,270
πώς ο τύπος που έχουμε αναθέσει στα δεδομένα μας, αν ουσιαστικό ή

32
00:01:36,270 --> 00:01:39,080
ρήμα, αλλάζει τον τρόπο που χρησιμοποιούμε τα δεδομένα -

33
00:01:39,080 --> 00:01:41,730
σαν τον άνεμο λέξη ή άνεμος.

34
00:01:41,730 --> 00:01:44,100
Παρά το γεγονός ότι ένας υπολογιστής δεν ενδιαφέρονται για τη γραμματική και τα μέρη

35
00:01:44,100 --> 00:01:47,750
της αγγλικής ομιλίας, την ίδια βασική αρχή ισχύει.

36
00:01:47,750 --> 00:01:50,290
Δηλαδή, μπορούμε να αλλάξουμε την ερμηνεία του ακριβούς

37
00:01:50,290 --> 00:01:53,140
ίδια δεδομένα αποθηκεύονται στη μνήμη με χύτευση απλά σε ένα

38
00:01:53,140 --> 00:01:54,576
διαφορετικού τύπου.

39
00:01:54,576 --> 00:01:57,250
Εδώ είναι τα μεγέθη από τα πιο κοινά είδη σε ένα 32-bit

40
00:01:57,250 --> 00:01:58,340
λειτουργικού συστήματος.

41
00:01:58,340 --> 00:02:02,070
Έχουμε μια χαρα σε 1 byte, int και float σε 4 bytes, ένα μακρύ

42
00:02:02,070 --> 00:02:04,390
μακρύ και ένα διπλό σε 8 bytes.

43
00:02:04,390 --> 00:02:07,670
Επειδή ένας int καταλαμβάνει 4 bytes, θα διαρκέσει έως 32 bits

44
00:02:07,670 --> 00:02:10,060
όταν αποθηκεύεται στη μνήμη σαν ένα δυαδικό σειρές

45
00:02:10,060 --> 00:02:11,500
από μηδενικά και μονάδες.

46
00:02:11,500 --> 00:02:14,020
Όσο η μεταβλητή μας παραμένει ως int τύπου, το

47
00:02:14,020 --> 00:02:16,740
υπολογιστής θα μετατρέψει τα πάντα μονάδες και μηδενικά από

48
00:02:16,740 --> 00:02:19,120
δυαδικό στο αρχικό αριθμό.

49
00:02:19,120 --> 00:02:21,270
Ωστόσο, θα μπορούσαμε θεωρητικά ρίχνει τις 32

50
00:02:21,270 --> 00:02:23,510
bits σε μία σειρά τύπων Boolean.

51
00:02:23,510 --> 00:02:26,090
Και τότε ο υπολογιστής δεν θα είναι πλέον δούμε έναν αριθμό, αλλά

52
00:02:26,090 --> 00:02:28,810
αντί για μια συλλογή από μηδενικά και μονάδες.

53
00:02:28,810 --> 00:02:31,570
Θα μπορούσαμε επίσης να προσπαθήσει να διαβάσει τα δεδομένα ως ένα διαφορετικό αριθμητικό

54
00:02:31,570 --> 00:02:34,660
πληκτρολογήσετε, ή ακόμα και ως μια σειρά από τέσσερις χαρακτήρες.

55
00:02:34,660 --> 00:02:37,820
Όταν έχουμε να κάνουμε με αριθμούς σε χύτευση, θα πρέπει να εξετάσει πώς

56
00:02:37,820 --> 00:02:40,470
η ακρίβεια της αξίας σας θα επηρεαστεί.

57
00:02:40,470 --> 00:02:43,240
Λάβετε υπόψη σας ότι η ακρίβεια μπορεί να παραμείνει το ίδιο,

58
00:02:43,240 --> 00:02:47,150
ή μπορείτε να χάσετε ακρίβεια, αλλά δεν μπορείτε ποτέ να αποκτήσουν ακρίβεια.

59
00:02:47,150 --> 00:02:49,060
Ας πάμε κατευθείαν για τους τρεις πιο κοινούς τρόπους που μπορείτε να

60
00:02:49,060 --> 00:02:50,400
χάνουν ακρίβεια.

61
00:02:50,400 --> 00:02:53,060
Casting μια float σε int θα προκαλέσει περικοπή των πάντων

62
00:02:53,060 --> 00:02:54,900
μετά την υποδιαστολή, έτσι είστε αριστερά

63
00:02:54,900 --> 00:02:55,950
με τον ακέραιο αριθμό.

64
00:02:55,950 --> 00:03:02,000
Αν πάρουμε το χ float που θα είναι ίσο με 3,7, μπορούμε να ρίχνει

65
00:03:02,000 --> 00:03:05,580
αυτή η μεταβλητή x σε int γράφοντας απλά int σε

66
00:03:05,580 --> 00:03:07,050
παρενθέσεις.

67
00:03:07,050 --> 00:03:10,010
Κάθε φορά που χρησιμοποιούμε τον όρο αυτό ακριβώς εδώ, εμείς θα την αποτελεσματική

68
00:03:10,010 --> 00:03:12,810
να χρησιμοποιεί την αξία τριών επειδή έχουμε περικοπεί

69
00:03:12,810 --> 00:03:14,880
πάντα μετά την υποδιαστολή.

70
00:03:14,880 --> 00:03:17,210
Μπορούμε επίσης να μετατρέψετε μια μακρά μακρά σε int, η οποία θα

71
00:03:17,210 --> 00:03:20,760
ομοίως να οδηγήσει σε απώλεια των μπιτ υψηλής τάξης.

72
00:03:20,760 --> 00:03:23,910
Μια πολύ μεγάλη καταλαμβάνει 8 byte, ή 64 bits στη μνήμη.

73
00:03:23,910 --> 00:03:27,050
Έτσι, όταν το ρίχνει σε έναν int που έχει μόνο 4 bytes, ή 32

74
00:03:27,050 --> 00:03:29,820
bits, είμαστε ουσιαστικά κοπή μακριά όλα τα bits που

75
00:03:29,820 --> 00:03:32,420
αντιπροσωπεύουν τις υψηλότερες τιμές δυαδικό.

76
00:03:32,420 --> 00:03:34,690
Θα μπορούσατε επίσης να ρίχνει ένα διπλό σε μια float, η οποία θα δώσει

77
00:03:34,690 --> 00:03:37,340
σας το δυνατόν πιο κοντά float στο διπλό χωρίς

78
00:03:37,340 --> 00:03:39,100
κατ 'ανάγκη στρογγυλοποίησης του.

79
00:03:39,100 --> 00:03:41,840
Παρόμοια με πολύ μεγάλη μας να int μετατροπή, η απώλεια

80
00:03:41,840 --> 00:03:44,890
ακρίβεια είναι επειδή ένα διπλό περιέχει περισσότερα δεδομένα.

81
00:03:44,890 --> 00:03:47,910
Ένα διπλό θα σας επιτρέψει να αποθηκεύσετε σημαντικά bits 53,

82
00:03:47,910 --> 00:03:50,650
περίπου 16 σημαντικά ψηφία.

83
00:03:50,650 --> 00:03:53,050
Ότι ένα float θα σας επιτρέψει να αποθηκεύσετε 24

84
00:03:53,050 --> 00:03:56,235
σημαντικά bits, περίπου επτά σημαντικά ψηφία.

85
00:03:56,235 --> 00:03:58,700
Σε αυτές τις δύο τελευταίες περιπτώσεις, μπορεί να είναι χρήσιμο να σκεφτούμε

86
00:03:58,700 --> 00:04:01,200
πληκτρολογήστε χύτευσης, αλλαγή μεγέθους μιας φωτογραφίας.

87
00:04:01,200 --> 00:04:03,860
Όταν πηγαίνετε από ένα μεγάλο μέγεθος σε ένα μικρό μέγεθος, δεν μπορείτε να δείτε

88
00:04:03,860 --> 00:04:05,600
πράγματα, όπως με σαφήνεια γιατί θα χάσει τα δεδομένα

89
00:04:05,600 --> 00:04:07,530
με τη μορφή των pixels.

90
00:04:07,530 --> 00:04:09,270
Τύπος χύτευσης μπορεί επίσης να προκαλέσει προβλήματα όταν

91
00:04:09,270 --> 00:04:11,050
ρίχνει ints να επιπλέει.

92
00:04:11,050 --> 00:04:13,920
Από επιπλέει σε μια 32-bit μηχάνημα έχει μόνο 24

93
00:04:13,920 --> 00:04:16,959
σημαντικά bits, δεν μπορούν να αντιπροσωπεύουν με ακρίβεια τις τιμές

94
00:04:16,959 --> 00:04:22,750
πάνω από 2 στη δύναμη του 24, ή 16777217.

95
00:04:22,750 --> 00:04:25,540
Τώρα ας μιλήσουμε για ρητή και σιωπηρή χύτευσης.

96
00:04:25,540 --> 00:04:28,000
Ρητή χύτευση είναι όταν γράφουμε τον τύπο σε παρενθέσεις

97
00:04:28,000 --> 00:04:29,430
πριν από το όνομα μιας μεταβλητής.

98
00:04:29,430 --> 00:04:33,100
Για παράδειγμα, πριν γράψαμε int σε παρένθεση πριν από μας

99
00:04:33,100 --> 00:04:35,640
float μεταβλητή x.

100
00:04:35,640 --> 00:04:37,200
Με αυτόν τον τρόπο, θα έχουμε την τιμή τύπου int, η

101
00:04:37,200 --> 00:04:38,593
περικοπεί αξία του 3,7 -

102
00:04:38,593 --> 00:04:40,370
3.

103
00:04:40,370 --> 00:04:42,970
Σιωπηρή χύτευση είναι όταν ο compiler αλλάζει αυτόματα

104
00:04:42,970 --> 00:04:46,340
παρόμοιους τύπους σε ένα σούπερ τύπου, ή εκτελεί κάποιο άλλο είδος

105
00:04:46,340 --> 00:04:48,310
χύτευση χωρίς να απαιτείται από το χρήστη να γράψει

106
00:04:48,310 --> 00:04:49,720
οποιοδήποτε πρόσθετο κωδικό.

107
00:04:49,720 --> 00:04:53,550
Για παράδειγμα, όταν προσθέτουμε 5 και 1,1, οι αξίες μας έχουν ήδη

108
00:04:53,550 --> 00:04:55,680
τύποι που συνδέονται με αυτά.

109
00:04:55,680 --> 00:04:59,480
Το 5 είναι ένα int, ενώ 1.1 είναι ένα πλωτήρα.

110
00:04:59,480 --> 00:05:02,390
Για να τα προσθέσετε, ο υπολογιστής ρίχνει 5 σε μια float,

111
00:05:02,390 --> 00:05:04,530
το οποίο θα ήταν το ίδιο πράγμα όπως γράφει το 5,0 σε

112
00:05:04,530 --> 00:05:06,476
πρώτη θέση.

113
00:05:06,476 --> 00:05:13,210
Αλλά με αυτό τον τρόπο λέμε float 5, ή 5,0, συν ό, τι ήταν ήδη

114
00:05:13,210 --> 00:05:16,960
float, 1,1, και από εκεί μπορούμε να προσθέσουμε στην πραγματικότητα αυτά τα

115
00:05:16,960 --> 00:05:18,640
αξίες και να πάρει την αξία 6,1.

116
00:05:21,170 --> 00:05:23,500
Σιωπηρή χύτευσης μας επιτρέπει επίσης να ορίσετε μεταβλητές

117
00:05:23,500 --> 00:05:25,590
διαφορετικούς τύπους η μία στην άλλη.

118
00:05:25,590 --> 00:05:28,110
Μπορούμε να εκχωρήσετε πάντα ένα λιγότερο ακριβές είδος σε μια πιο

119
00:05:28,110 --> 00:05:29,250
ένα ακριβές.

120
00:05:29,250 --> 00:05:37,060
Για παράδειγμα, αν έχουμε ένα διπλό x, y και ένα int -

121
00:05:37,060 --> 00:05:40,120
και αυτά θα μπορούσαν να έχουν κανένα αξίες που τους ορίζεται σε -

122
00:05:40,120 --> 00:05:43,560
μπορούμε να πούμε ισούται με x y.

123
00:05:43,560 --> 00:05:46,340
Επειδή το διπλό έχει μεγαλύτερη ακρίβεια από ό, τι έναν int, έτσι ώστε να

124
00:05:46,340 --> 00:05:48,380
δεν θα χάσετε καμία πληροφορία.

125
00:05:48,380 --> 00:05:50,420
Από την άλλη πλευρά, δεν θα είναι αναγκαστικά σωστό να πούμε

126
00:05:50,420 --> 00:05:54,060
γ ισούται χ, διότι το διπλό μπορεί να έχει μια μεγαλύτερη τιμή από ό, τι

127
00:05:54,060 --> 00:05:55,220
ο ακέραιος.

128
00:05:55,220 --> 00:05:57,420
Και έτσι ο ακέραιος μπορεί να μην είναι σε θέση να κρατήσει όλα τα

129
00:05:57,420 --> 00:05:59,560
πληροφορίες που είναι αποθηκευμένες στο διπλό.

130
00:05:59,560 --> 00:06:02,610
Σιωπηρή χύτευσης χρησιμοποιείται επίσης σε τελεστές σύγκρισης, όπως

131
00:06:02,610 --> 00:06:06,410
μεγαλύτερο από, μικρότερο από, ή ο φορέας της ισότητας.

132
00:06:06,410 --> 00:06:13,050
Με αυτό τον τρόπο μπορούμε να πούμε αν είναι 5,1 μεγαλύτερος από 5, και παίρνουμε το

133
00:06:13,050 --> 00:06:14,750
αποτέλεσμα αλήθεια.

134
00:06:14,750 --> 00:06:18,470
Επειδή 5 είναι ένα int, αλλά αυτό θα πρέπει να ρίχνει σε ένα άρμα, προκειμένου να

135
00:06:18,470 --> 00:06:22,090
να συγκριθεί με τον πλωτήρα 5,1, θα έλεγα ότι είναι 5,1

136
00:06:22,090 --> 00:06:24,550
μεγαλύτερη από 5,0.

137
00:06:24,550 --> 00:06:31,320
Το ίδιο ισχύει και με το ρητό, αν ισούται με 2,0 ισούται με 2.

138
00:06:31,320 --> 00:06:34,190
Θα θέλαμε επίσης να ισχύει, γιατί ο υπολογιστής θα ρίξει το

139
00:06:34,190 --> 00:06:39,750
ακέραιο 2 να επιπλέουν και στη συνέχεια να πω ισούται με 2,0 ισούται με 2,0,

140
00:06:39,750 --> 00:06:41,660
αυτό είναι αλήθεια.

141
00:06:41,660 --> 00:06:44,180
Μην ξεχνάτε ότι μπορούμε επίσης να ρίχνει μεταξύ ints και χαρακτήρες,

142
00:06:44,180 --> 00:06:46,350
ή τιμές ASCII.

143
00:06:46,350 --> 00:06:49,690
Χαρακτήρες πρέπει επίσης να μειωθεί σε δυαδικό, η οποία είναι ο λόγος που

144
00:06:49,690 --> 00:06:51,920
μπορεί εύκολα να μετατρέψει μεταξύ χαρακτήρες και τις αντίστοιχες

145
00:06:51,920 --> 00:06:53,260
ASCII τιμές.

146
00:06:53,260 --> 00:06:56,180
Για να μάθετε περισσότερα σχετικά με αυτό, δείτε το βίντεο μας σε ASCII.

147
00:06:56,180 --> 00:06:58,080
Όταν παίρνετε μια στιγμή για να σκεφτεί για το πώς τα δεδομένα είναι αποθηκευμένα,

148
00:06:58,080 --> 00:06:59,990
αρχίζει να κάνει πολύ νόημα.

149
00:06:59,990 --> 00:07:02,790
Είναι ακριβώς σαν τη διαφορά μεταξύ του ανέμου και του ανέμου.

150
00:07:02,790 --> 00:07:05,490
Τα δεδομένα είναι η ίδια, αλλά ο τύπος μπορεί να αλλάξει τον τρόπο μπορούμε

151
00:07:05,490 --> 00:07:06,720
ερμηνεύουν.

152
00:07:06,720 --> 00:07:10,430
Το όνομά μου είναι Jozwiak Ιορδανία, το CS50.