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

2
00:00:02,480 --> 00:00:06,460

3
00:00:06,460 --> 00:00:09,350
>> DOUG LLOYD: Εντάξει, οπότε ας
μιλάμε για τα επιχειρήματα της γραμμής εντολών.

4
00:00:09,350 --> 00:00:11,800
Έτσι, μέχρι στιγμής κατά τη διάρκεια όμορφη
πολύ όλα τα προγράμματά σας

5
00:00:11,800 --> 00:00:16,360
έχουν πιθανότατα ξεκινήσει
όπως this-- int main άκυρη.

6
00:00:16,360 --> 00:00:18,310
Έχουμε συλλέξει
εισόδου του χρήστη, αν χρειαζόμαστε

7
00:00:18,310 --> 00:00:21,080
στα προγράμματά μας, όπως είναι η
Πρόγραμμα Mario, για παράδειγμα,

8
00:00:21,080 --> 00:00:22,990
με in-πρόγραμμα προτροπές.

9
00:00:22,990 --> 00:00:25,190
Δεν χρειαζόταν να τροποποιήσουν
η δήλωση των κυρίων,

10
00:00:25,190 --> 00:00:30,684
διότι, αντί στο εσωτερικό της κύριας εμείς
μόνο να πω, μπορείτε να καλέσετε για να πάρετε int.

11
00:00:30,684 --> 00:00:32,350
Πόσο μεγάλο θέλετε η πυραμίδα να είναι;

12
00:00:32,350 --> 00:00:34,455
Ή μπορείτε να καλέσετε για να πάρετε
float-- πόσες αλλαγές

13
00:00:34,455 --> 00:00:36,400
πρέπει εγώ εξόδου προς τον χρήστη;

14
00:00:36,400 --> 00:00:38,630
>> Υπάρχει ένας άλλος τρόπος όμως,
και αν θέλουμε οι χρήστες μας

15
00:00:38,630 --> 00:00:40,580
να είναι σε θέση να παράσχει
δεδομένων στο πρόγραμμά μας

16
00:00:40,580 --> 00:00:43,320
κατά το χρόνο εκτέλεσης αντί ενώ
το πρόγραμμα εκτελείται,

17
00:00:43,320 --> 00:00:45,910
μια λεπτή διάκριση, αλλά
Μερικές φορές ένα πολύ χρήσιμο ένα,

18
00:00:45,910 --> 00:00:48,120
χρειαζόμαστε μια νέα μορφή δηλώνοντας κύρια.

19
00:00:48,120 --> 00:00:53,320
Δεν μπορούμε να χρησιμοποιούμε int main άκυρη αν θέλουμε να
συλλέγουν δεδομένα στη γραμμή εντολών

20
00:00:53,320 --> 00:00:57,540
όταν ο χρήστης τρέχει το πρόγραμμα,
ως εκ τούτου, τα επιχειρήματα της γραμμής εντολών.

21
00:00:57,540 --> 00:00:59,810
>> Να συλλέγουν αυτά της γραμμής εντολών
επιχειρήματα από το χρήστη,

22
00:00:59,810 --> 00:01:03,140
αλλάξτε δήλωση σας
κύρια για να μοιάσει this-- int

23
00:01:03,140 --> 00:01:10,450
κύρια, ανοικτή παρένθεσης, int argc, κόμμα,
κορδόνι argv, αγκύλες,

24
00:01:10,450 --> 00:01:12,670
και, στη συνέχεια, ανοίξτε σγουρά στήριγμα.

25
00:01:12,670 --> 00:01:14,415
Λοιπόν, τι σημαίνει αυτό ήδη;

26
00:01:14,415 --> 00:01:19,410
Λοιπόν, περνάμε σε δύο παραμέτρους,
ή επιχειρήματα ή οι εισροές στην κύρια.

27
00:01:19,410 --> 00:01:23,800
Μία, ένας ακέραιος που ονομάζεται
argc, και το άλλο είναι τι;

28
00:01:23,800 --> 00:01:26,430

29
00:01:26,430 --> 00:01:29,640
Είναι μια σειρά από strings, έτσι δεν είναι;

30
00:01:29,640 --> 00:01:31,140
Βλέπουμε ότι η σημειογραφία βραχίονα πλατεία.

31
00:01:31,140 --> 00:01:32,181
Είναι μια σειρά από strings.

32
00:01:32,181 --> 00:01:35,110
Δεν είναι ένα άτομο εγχόρδων,
είναι μια σειρά από strings.

33
00:01:35,110 --> 00:01:39,640
Και τα δύο αυτά επιχειρήματα, argc και argv,
σας δίνουν τη δυνατότητα να γνωρίζουν ποια δεδομένα του χρήστη

34
00:01:39,640 --> 00:01:42,912
έδωσε στη γραμμή εντολών
και πόσα πράγματα θα

35
00:01:42,912 --> 00:01:44,120
παρέχονται στην γραμμή εντολών.

36
00:01:44,120 --> 00:01:46,570
Αρκετά χρήσιμα πράγματα για να εργαστεί με.

37
00:01:46,570 --> 00:01:50,310
>> Argc αντιπροσωπεύει καταμέτρηση επιχείρημα,
και θα πρέπει να γνωρίζετε, από τον τρόπο,

38
00:01:50,310 --> 00:01:52,600
ότι θα μπορούσατε να καλέσετε argc
ό, τι θέλετε.

39
00:01:52,600 --> 00:01:54,710
Μπορείτε να καλέσετε argv ό, τι ήθελε.

40
00:01:54,710 --> 00:01:58,740
Αυτά είναι μόνο τα συμβατικά ονόματα
που χρησιμοποιούμε για την μέτρηση them-- επιχείρημα,

41
00:01:58,740 --> 00:02:00,907
και όπως θα δούμε σε ένα δεύτερο,
διάνυσμα επιχείρημα, argv.

42
00:02:00,907 --> 00:02:03,698
Αλλά δεν χρειάζεται να καλέσετε τους
argc και argv, αν δεν θέλετε να,

43
00:02:03,698 --> 00:02:05,570
αλλά συνήθως, αυτό είναι αυτό που κάνουμε.

44
00:02:05,570 --> 00:02:07,500
>> Έτσι κι αλλιώς, argc, ο αριθμός επιχείρημα.

45
00:02:07,500 --> 00:02:11,569
Είναι μια μεταβλητή ακεραίου τύπου και έτσι, όπως
μπορείτε να φανταστείτε, αν έχουμε δύο πράγματα

46
00:02:11,569 --> 00:02:13,860
ότι θα πάμε να βρουν
τι είναι δακτυλογραφημένες

47
00:02:13,860 --> 00:02:16,070
και πόσα πράγματα η
δακτυλογραφημένες χρήστη, argc είναι

48
00:02:16,070 --> 00:02:18,559
θα μας πει πόσα
γεμίσει ο χρήστης πληκτρολογήσει.

49
00:02:18,559 --> 00:02:20,850
Γι 'αυτό σας δίνει μια σειρά από
τα επιχειρήματα της γραμμής εντολών χρήστη

50
00:02:20,850 --> 00:02:22,470
δακτυλογραφημένες όταν εκτελείται το πρόγραμμα.

51
00:02:22,470 --> 00:02:25,780
Έτσι, αν το πρόγραμμά σας είναι
τρέξει dot κάθετος άπληστοι,

52
00:02:25,780 --> 00:02:28,670
και στο εσωτερικό των άπληστων σας
προγραμματίσετε κύρια λειτουργία σας

53
00:02:28,670 --> 00:02:34,800
έχει την δήλωση int main int argc,
κορδόνι argv αγκύλες, στη συνέχεια,

54
00:02:34,800 --> 00:02:37,950
argc σε αυτή την περίπτωση είναι ένα.

55
00:02:37,950 --> 00:02:40,200
Τώρα παρατηρήσετε δεν το κάνουμε
μετράνε πόσα πράγματα

56
00:02:40,200 --> 00:02:42,590
ο χρήστης πληκτρολογήσει μετά το όνομα του προγράμματος.

57
00:02:42,590 --> 00:02:46,710
Το ίδιο το όνομα του προγράμματος μετράει
ως επιχείρημα της γραμμής εντολών.

58
00:02:46,710 --> 00:02:51,770
>> Έτσι dot κάθετος άπληστοι, σε
Η υπόθεση αυτή, argc είναι ένας.

59
00:02:51,770 --> 00:02:57,910
Αν ο χρήστης πληκτρολογήσει κάθετο άπληστοι 1024 CS50
στη γραμμή εντολών, argc σε αυτή την περίπτωση

60
00:02:57,910 --> 00:02:59,520
θα είναι τρεις.

61
00:02:59,520 --> 00:03:03,720
Και ξέρουμε αυτό, επειδή ο τρόπος
ότι η κατανομή μεταξύ των χορδών

62
00:03:03,720 --> 00:03:06,030
ανιχνεύεται αν
υπάρχει ένας χώρος ή μια καρτέλα,

63
00:03:06,030 --> 00:03:08,230
ή κάτι τέτοιο μεταξύ τους.

64
00:03:08,230 --> 00:03:13,860
Έτσι, κάθε ποσό του κενού χώρου, τα λεγόμενα,
μεταξύ των τιμών πληκτρολογήσει γραμμής εντολών

65
00:03:13,860 --> 00:03:15,720
δείχνει πόσοι είναι εκεί.

66
00:03:15,720 --> 00:03:24,040
Έτσι dot κάθετος άπληστοι διάστημα 1024 χώρο
CS50, argc, στην περίπτωση αυτή, είναι τρία.

67
00:03:24,040 --> 00:03:26,600
>> Argv είναι το διάνυσμα επιχειρήματος.

68
00:03:26,600 --> 00:03:29,240
Φορέα, από τον τρόπο, είναι ακριβώς
μια άλλη λέξη για μια σειρά,

69
00:03:29,240 --> 00:03:31,510
και αυτό είναι ένας πίνακας
που αποθηκεύει χορδές.

70
00:03:31,510 --> 00:03:35,540
Μία κλωστή ανά στοιχείο, το οποίο είναι
οι χορδές που ο χρήστης στην πραγματικότητα

71
00:03:35,540 --> 00:03:39,230
πληκτρολογήσει στη γραμμή εντολών
όταν το πρόγραμμα εκτελέστηκε.

72
00:03:39,230 --> 00:03:40,990
Τώρα, όπως είναι η περίπτωση
με οποιαδήποτε σειρά, αν

73
00:03:40,990 --> 00:03:44,380
Υπενθυμίζουμε από τη συζήτηση μας
πίνακες, το πρώτο στοιχείο της argv

74
00:03:44,380 --> 00:03:49,150
είναι πάντα πρόκειται να βρεθεί
στο argv αγκύλη μηδέν.

75
00:03:49,150 --> 00:03:51,800
Αυτός είναι ο πρώτος δείκτης
του πίνακα argv.

76
00:03:51,800 --> 00:03:55,720
Έτσι ώστε will-- και στην πραγματικότητα, ότι βούληση
πάντα να είναι το όνομα του προγράμματος,

77
00:03:55,720 --> 00:03:59,730
θα είναι πάντα να βρίσκεται σε
argv αγκύλη μηδέν.

78
00:03:59,730 --> 00:04:08,590
>> Το τελευταίο στοιχείο της argv βρίσκεται πάντα
στο argv αγκύλες argc μείον ένα.

79
00:04:08,590 --> 00:04:10,300
Βλέπετε γιατί;

80
00:04:10,300 --> 00:04:14,180
Θυμηθείτε πόσα στοιχεία
υπάρχουν σε αυτή τη σειρά.

81
00:04:14,180 --> 00:04:16,660
Λοιπόν, ξέρουμε ότι είναι that--
argc αριθμός των στοιχείων.

82
00:04:16,660 --> 00:04:21,279
Αν ο χρήστης πληκτρολογήσει τρία πράγματα
η γραμμή εντολών, argc είναι τρεις.

83
00:04:21,279 --> 00:04:27,070
Αλλά επειδή σε γ, όταν δουλεύουμε
με συστοιχίες, κάθε στοιχείο της συστοιχίας,

84
00:04:27,070 --> 00:04:30,190
ή μάλλον οι δείκτες
η συστοιχία, ξεκινούν από το μηδέν.

85
00:04:30,190 --> 00:04:34,000
Αν έχουμε τρία στοιχεία σε μας
σειρά, έχουμε ένα στοιχείο στο argv μηδέν,

86
00:04:34,000 --> 00:04:37,930
ένα στοιχείο σε ένα argv,
και ένα στοιχείο στο argv δύο.

87
00:04:37,930 --> 00:04:41,700
Δεν υπάρχει κανένα στοιχείο στο argv
τρία, και μια σειρά μεγέθους τρία.

88
00:04:41,700 --> 00:04:43,990
Έτσι, γι 'αυτό το τελευταίο
στοιχείο argv μπορεί πάντα

89
00:04:43,990 --> 00:04:49,510
να βρεθεί στην πλατεία argv
argc παρένθεση μείον ένα.

90
00:04:49,510 --> 00:04:52,420
>> Ας αναλάβει τις εκτελεί χρήστη
ο άπληστος πρόγραμμα follows--

91
00:04:52,420 --> 00:04:57,970
αν πληκτρολογήσετε την εντολή-γραμμή dot
slash άπληστοι διάστημα 1024 CS50 χώρο,

92
00:04:57,970 --> 00:05:00,720
και για οποιονδήποτε λόγο έχουμε
ήδη ετοιμάσει άπληστοι πρόγραμμά μας

93
00:05:00,720 --> 00:05:04,050
να γνωρίζουν και να συνεργαστεί με αυτούς
τα επιχειρήματα της γραμμής εντολών.

94
00:05:04,050 --> 00:05:07,030
Εμείς δεν είχαν προηγουμένως όταν δουλέψαμε
σε αυτό το άπληστο πρόβλημα,

95
00:05:07,030 --> 00:05:09,660
αλλά ας πούμε ότι έχουμε τώρα τροποποιημένο
έτσι ώστε να κάνουμε τη διαδικασία

96
00:05:09,660 --> 00:05:11,480
τα επιχειρήματα της γραμμής εντολών με κάποιο τρόπο.

97
00:05:11,480 --> 00:05:15,720
Σε αυτήν την περίπτωση, argv μηδέν
Είναι dot κάθετος άπληστοι.

98
00:05:15,720 --> 00:05:17,042
Τι είναι argv ένα;

99
00:05:17,042 --> 00:05:19,030
Λοιπόν, αυτό είναι το 1024, σωστά;

100
00:05:19,030 --> 00:05:22,620
Είναι 1024, αλλά εδώ είναι ένα
πραγματικά σημαντικό distinction--

101
00:05:22,620 --> 00:05:26,410
Θυμάστε τον τύπο δεδομένων του argv;

102
00:05:26,410 --> 00:05:31,020
>> Αποθηκεύει χορδές, έτσι δεν είναι;

103
00:05:31,020 --> 00:05:34,140
Αλλά μοιάζει 1024
είναι ένας ακέραιος αριθμός.

104
00:05:34,140 --> 00:05:36,530
Αυτό είναι ένα πολύ σημαντικό
διάκριση, και είναι στην πραγματικότητα

105
00:05:36,530 --> 00:05:40,200
πρόκειται να γίνει κάτι που θα
ενδέχεται να αντιμετωπίσετε προβλήματα στη μετέπειτα.

106
00:05:40,200 --> 00:05:43,770
Τα πάντα στο argv είναι
αποθηκεύεται ως ένα string.

107
00:05:43,770 --> 00:05:48,775
Έτσι, το περιεχόμενο argv ενός ατόμου είναι η
χορδή ένα, μηδέν, δύο, τέσσερις,

108
00:05:48,775 --> 00:05:50,275
που αποτελείται από τους τέσσερις χαρακτήρες.

109
00:05:50,275 --> 00:05:53,870
Είναι σαν ο χρήστης να πληκτρολογήσει
ένα, μηδέν, δύο, τέσσερις

110
00:05:53,870 --> 00:05:56,680
ως μεμονωμένα γράμματα ή χαρακτήρες.

111
00:05:56,680 --> 00:06:00,730
Δεν είναι ο ακέραιος 1024,
και έτσι δεν μπορείτε άμεσα

112
00:06:00,730 --> 00:06:11,580
εργαστείτε με αυτό λέγοντας int 1000, ή
μάλλον int x ισούται με argv ένα μείον 24.

113
00:06:11,580 --> 00:06:15,550
>> Διαισθητικά, μπορείτε να σκεφτείτε ότι
όπως, εντάξει, καλά είναι 1.024 μείον 24,

114
00:06:15,550 --> 00:06:17,920
έτσι το χ είναι ίσο με 1,000.

115
00:06:17,920 --> 00:06:22,020
Αλλά στην πραγματικότητα, αυτό δεν είναι η περίπτωση,
επειδή argv ένα είναι ένα string.

116
00:06:22,020 --> 00:06:23,940
Το κορδόνι 1024.

117
00:06:23,940 --> 00:06:28,739
Τώρα υπάρχει μια λειτουργία που μπορεί να είναι
χρησιμοποιείται για να μετατρέψει χορδές σε ακέραιους αριθμούς.

118
00:06:28,739 --> 00:06:30,780
Δεν θα το χαλάσω για σας
τώρα, αλλά είμαι σίγουρος ότι Zamyla

119
00:06:30,780 --> 00:06:34,380
θα είναι στην ευχάριστη θέση να σας πω γι 'αυτό σε
η περιδιάβαση για ένα μελλοντικό πρόβλημα.

120
00:06:34,380 --> 00:06:36,390
Αλλά μπορείτε επίσης να βρείτε
προβλήματα like-- δικαιολογία

121
00:06:36,390 --> 00:06:39,921
μου, τις λειτουργίες που θα
το κάνετε αυτό στην αναφορά 50,

122
00:06:39,921 --> 00:06:42,462
αν πας στον οδηγό αναφοράς
μπορείτε να βρείτε μια λειτουργία που

123
00:06:42,462 --> 00:06:43,820
θα κάνει αυτή τη μετατροπή για εσάς.

124
00:06:43,820 --> 00:06:45,980
Αλλά και πάλι, στην περιδιάβαση
για ένα μελλοντικό πρόβλημα,

125
00:06:45,980 --> 00:06:48,290
Zamyla θα είναι στην ευχάριστη θέση να
σας πω ποια είναι η λειτουργία

126
00:06:48,290 --> 00:06:53,280
αυτό είναι ότι θα μετατρέψει το
χορδή 1024 στον ακέραιο 1024.

127
00:06:53,280 --> 00:06:54,560
>> Εντάξει, έτσι ώστε να προχωρήσει.

128
00:06:54,560 --> 00:06:56,726
Έχουμε καλύψει argv μηδέν μας,
έχουμε καλύψει ένα argv.

129
00:06:56,726 --> 00:06:58,000
Τι είναι στο argv δύο;

130
00:06:58,000 --> 00:06:58,620
CS50.

131
00:06:58,620 --> 00:07:01,350
Αυτό είναι πιθανώς ένα
αρκετά αυτονόητα.

132
00:07:01,350 --> 00:07:02,950
Τι είναι στο argv τρεις;

133
00:07:02,950 --> 00:07:04,970
Λοιπόν και πάλι, εμείς δεν γνωρίζουμε πραγματικά, έτσι δεν είναι;

134
00:07:04,970 --> 00:07:08,060
Έχουμε μια σειρά από τρία μεγέθους,
αυτό είναι το πώς πολλά στοιχεία που ο χρήστης

135
00:07:08,060 --> 00:07:11,610
πληκτρολογήσει στη γραμμή εντολών,
Έτσι, αν πάμε να argv τρεις,

136
00:07:11,610 --> 00:07:14,660
είμαστε τώρα υπερβεί
τα όρια του πίνακα μας.

137
00:07:14,660 --> 00:07:18,570
Ο compiler θα μας επιτρέψει να το κάνουμε αυτό,
δεν υπάρχει διαισθητική πρόβλημα με αυτό,

138
00:07:18,570 --> 00:07:22,890
αλλά από την άποψη του τι πραγματικά συμβαίνει
για να συμβεί αυτό, δεν ξέρω πραγματικά.

139
00:07:22,890 --> 00:07:25,380
Εξαρτάται από το τι είναι
που βρίσκεται στο μνήμης, όπου

140
00:07:25,380 --> 00:07:28,060
argv τρείς θα αναμενόταν να είναι.

141
00:07:28,060 --> 00:07:30,716
Και έτσι θα μπορούσαμε να καταλήξουμε
να πάρει μακριά ατιμώρητος.

142
00:07:30,716 --> 00:07:33,840
Πιο πιθανό από ό, τι δεν είναι, ιδιαίτερα όταν
εργάζεστε με argv σε αντίθεση

143
00:07:33,840 --> 00:07:35,548
σε οποιαδήποτε άλλη συστοιχία
ότι είναι στο πρόγραμμά μας,

144
00:07:35,548 --> 00:07:38,660
θα πρόκειται πιθανώς να υποφέρουν
ένα σφάλμα κατάτμησης. Έτσι και πάλι,

145
00:07:38,660 --> 00:07:42,756
Να είστε βέβαιος να μην υπερβούμε τα όρια
συστοιχιών σας, ιδιαίτερα argv,

146
00:07:42,756 --> 00:07:47,170
δεδομένο τον υψηλό βαθμό
σημασία στα προγράμματά σας.

147
00:07:47,170 --> 00:07:48,100
>> Είμαι ο Νταγκ Lloyd.

148
00:07:48,100 --> 00:07:50,170
Αυτό είναι CS50.

149
00:07:50,170 --> 00:07:51,457