1
00:00:00,000 --> 00:00:02,000
[Powered by Google Translate] [Ορίσματα της γραμμής εντολών]

2
00:00:02,000 --> 00:00:04,000
[Christopher Βαρθολομαίος - Πανεπιστήμιο του Χάρβαρντ]

3
00:00:04,000 --> 00:00:07,000
[Αυτό είναι CS50 - CS50.TV]

4
00:00:07,000 --> 00:00:11,000
Ένα χρήσιμο χαρακτηριστικό για ένα πρόγραμμα είναι να δεχτεί είσοδο του χρήστη.

5
00:00:11,000 --> 00:00:15,000
Μέχρι στιγμής, έχουμε διερευνήσει κάποιες λειτουργίες μέσα στη βιβλιοθήκη CS50

6
00:00:15,000 --> 00:00:18,000
να δεχτεί είσοδο του χρήστη, όπως "να πάρει σειρά,"

7
00:00:18,000 --> 00:00:23,000
η οποία ζητά από το χρήστη, ενώ η εφαρμογή εκτελείται, για ένα string.

8
00:00:23,000 --> 00:00:28,000
>> Ωστόσο, υπάρχουν περιπτώσεις όπου θέλετε να τροφοδοτήσει το πρόγραμμά σας

9
00:00:28,000 --> 00:00:30,000
πριν από την πραγματική λειτουργία.

10
00:00:30,000 --> 00:00:34,000
Με αυτό τον τρόπο, δεν χρειάζεται να ζητήσει πρόσθετες πληροφορίες από το χρήστη

11
00:00:34,000 --> 00:00:38,000
εκτελώντας μια απλή εργασία.

12
00:00:38,000 --> 00:00:42,000
Πάρτε, για παράδειγμα, η εντολή mv ή κίνηση στο UNIX.

13
00:00:42,000 --> 00:00:49,000
Αυτή η εντολή επιτρέπει στο χρήστη να μετακινήσει ένα αρχείο από μια τοποθεσία σε μια άλλη.

14
00:00:49,000 --> 00:00:55,000
Σύμφωνα με τις σελίδες manual, mv δέχεται δύο ορίσματα γραμμής εντολών:

15
00:00:55,000 --> 00:01:00,000
Το αρχείο που είναι να μετακινηθεί η θέση και το αρχείο που μεταφέρθηκε στο.

16
00:01:00,000 --> 00:01:06,000
Έτσι, αυτό το παράδειγμα έχει μια εντολή με δύο επιχειρήματα.

17
00:01:06,000 --> 00:01:14,000
Επομένως, πώς θα πείτε C πρόγραμμά μας να αξιοποιήσει αυτά τα ορίσματα της γραμμής εντολών;

18
00:01:14,000 --> 00:01:20,000
>> Λοιπόν, αποδεικνύεται ότι το κύριο, το οποίο χρησιμοποιούμε σε όλα τα προγράμματα C, έχει ένα μυστικό.

19
00:01:20,000 --> 00:01:26,000
Κύρια δέχεται δύο παραμέτρους: argc και argv.

20
00:01:26,000 --> 00:01:28,000
Ας πάει πάνω από αυτούς τους όρους.

21
00:01:28,000 --> 00:01:33,000
>> Η πρώτη παράμετρος, argc, που σημαίνει καταμέτρηση επιχείρημα,

22
00:01:33,000 --> 00:01:36,000
έχει έναν τύπο δεδομένων του ακεραίου.

23
00:01:36,000 --> 00:01:42,000
Η παράμετρος argc περιέχει τον αριθμό των επιχειρημάτων, συμπεριλαμβανομένου του εντολή.

24
00:01:42,000 --> 00:01:47,000
Στην εντολή κίνηση μας, αν και έχουμε μόνο δύο επιχειρήματα που εμφανίζεται,

25
00:01:47,000 --> 00:01:50,000
argc τιμή θα είναι 3.

26
00:01:50,000 --> 00:01:56,000
Η δεύτερη παράμετρος, argv, που σημαίνει διάνυσμα επιχείρημα,

27
00:01:56,000 --> 00:02:01,000
είναι μια σειρά από δείκτες που char δείχνουν χορδές.

28
00:02:01,000 --> 00:02:06,000
>> Αυτό σημαίνει ότι κάθε στοιχείο argv, ξεκινώντας από το μηδέν,

29
00:02:06,000 --> 00:02:09,000
περιέχει την εντολή και τα επιχειρήματα.

30
00:02:09,000 --> 00:02:16,000
Για παράδειγμα, argv [0], η οποία θα αναφερθώ ως argv μηδέν,

31
00:02:16,000 --> 00:02:20,000
θα περιέχει πάντα την εντολή που τρέχει -

32
00:02:20,000 --> 00:02:22,000
στην περίπτωση αυτή, mv.

33
00:02:22,000 --> 00:02:28,000
argv [1] θα περιέχει το πρώτο επιχείρημα, file.txt,

34
00:02:28,000 --> 00:02:37,000
και argv [2] θα περιέχει το δεύτερο επιχείρημα, ~ / CS50 /.

35
00:02:37,000 --> 00:02:42,000
Το τελευταίο επιχείρημα του argv θα είναι πάντα null.

36
00:02:42,000 --> 00:02:46,000
Ας εφαρμόσουν αυτές τις ορίσματα της γραμμής εντολών.

37
00:02:46,000 --> 00:02:53,000
Σε προηγούμενες ασκήσεις, που τοποθετείται κενό, δηλαδή τίποτα, ως κύρια παράμετρος του.

38
00:02:53,000 --> 00:02:57,000
Ωστόσο, για να μπορέσουμε να χρησιμοποιήσει ορίσματα της γραμμής εντολών,

39
00:02:57,000 --> 00:03:12,000
πρέπει να αφαιρέσετε μέσα κενό και ο τόπος της κύριας int argc, char * argv [].

40
00:03:12,000 --> 00:03:17,000
Τώρα, για να αποκτήσετε πρόσβαση σε ολόκληρο το στοιχείο από argv, τα οποία είναι τα επιχειρήματά σας,

41
00:03:17,000 --> 00:03:21,000
μπορείτε απλά να επαναλάβει, ή βρόχο, μέσω του πίνακα, όπως αυτό.

42
00:03:21,000 --> 00:03:27,000
Έτσι, μέσα από το σώμα του κυρίως, θα πάμε για να πάει μπροστά και να πληκτρολογήσετε ένα για βρόχο:

43
00:03:27,000 --> 00:03:37,000
for (int i = 0? i <argc? i + +).

44
00:03:37,000 --> 00:03:41,000
>> Δεν χρειαζόμαστε μια σγουρά στήριγμα εδώ επειδή είμαστε εκτελεί μόνο μία γραμμή κώδικα

45
00:03:41,000 --> 00:03:44,000
μέσα στο σώμα αυτού του βρόχου.

46
00:03:44,000 --> 00:03:47,000
Θα πάμε μπροστά και να χτυπήσει μια φορά καρτέλα,

47
00:03:47,000 --> 00:03:57,000
στη συνέχεια, πληκτρολογήστε printf ("argv [% d], για να αντιπροσωπεύουν μια ακέραια τιμή,

48
00:03:57,000 --> 00:04:06,000
είναι% s, για string, τότε ο χαρακτήρας νέας γραμμής.

49
00:04:06,000 --> 00:04:12,000
Τότε παρέχουμε i printf για την τρέχουσα επανάληψη του βρόχου

50
00:04:12,000 --> 00:04:18,000
και argv [i] για την αναπαράσταση συμβολοσειράς της τρέχουσας όρισμα της γραμμής εντολών.

51
00:04:18,000 --> 00:04:25,000
Όταν έχουμε να τρέξει με δύο επιχειρήματα, θα δούμε τα επιχειρήματα που εμφανίζεται στο τερματικό.

52
00:04:34,000 --> 00:04:38,000
Νωρίτερα είπαμε ότι η argv πραγματοποιήθηκε μια σειρά από δείκτες char.

53
00:04:38,000 --> 00:04:45,000
>> Έτσι, αν αυτή είναι η περίπτωση, πώς μπορούμε τότε πρόσβαση μεμονωμένων χαρακτήρων σε κάθε επιχείρημα;

54
00:04:45,000 --> 00:04:51,000
Για παράδειγμα, τι θα γίνει αν ήθελα να ψάξουν για ένα συγκεκριμένο χαρακτήρα στο πρώτο επιχείρημα;

55
00:04:51,000 --> 00:04:55,000
Λοιπόν, η απάντηση είναι ότι πρέπει να εφαρμόσουμε μια ένθετη βρόχο

56
00:04:55,000 --> 00:04:59,000
που στη συνέχεια θα επαναλάβει μέσω καθενός από τα στοιχεία της συμβολοσειράς επιχείρημα.

57
00:04:59,000 --> 00:05:02,000
Αυτό είναι το πώς θα το κάνουμε.

58
00:05:02,000 --> 00:05:10,000
>> Κατ 'αρχάς, θα πάμε για να δημιουργήσετε ένα αντίγραφο του example2.c.

59
00:05:10,000 --> 00:05:13,000
Στη συνέχεια, στο εσωτερικό του πρώτου βρόχου for,

60
00:05:13,000 --> 00:05:15,000
θα πάμε να προσθέσετε ένα επιπλέον για βρόχο.

61
00:05:15,000 --> 00:05:28,000
Έτσι, για (int j = 0, n = strlen (argv [i]),

62
00:05:28,000 --> 00:05:32,000
η οποία δίνει στη συνέχεια μας το μήκος του τρέχοντος επιχειρήματος,

63
00:05:32,000 --> 00:05:39,000
? J <n? J + +)

64
00:05:39,000 --> 00:05:43,000
Εμείς πάμε για να εκτυπώσετε τη θέση του κάθε χαρακτήρα

65
00:05:43,000 --> 00:05:47,000
εντός της τρέχουσας επιχείρημα με τη χρήση printf.

66
00:05:47,000 --> 00:05:57,000
Έτσι, printf ("argv [% d], να εκπροσωπεί το δείκτη της τρέχουσας επιχείρημα,

67
00:05:57,000 --> 00:06:05,000
τότε [% d] για άλλη μια φορά, να αντιπροσωπεύουν την τρέχουσα χαρακτήρας της τρέχουσας επιχείρημα,

68
00:06:05,000 --> 00:06:13,000
είναι: γ%, για το τρέχον χαρακτήρα στο επιχείρημα.

69
00:06:13,000 --> 00:06:20,000
Τέλος, παρέχουμε printf με το δείκτη του εξωτερικού βρόχου, i,

70
00:06:20,000 --> 00:06:22,000
τότε ο δείκτης του εσωτερικού βρόχου.

71
00:06:22,000 --> 00:06:28,000
>> Και το τελευταίο επιχείρημα μας να printf είναι ο πραγματικός χαρακτήρας από το επιχείρημα που

72
00:06:28,000 --> 00:06:31,000
στη γραμμή εντολών.

73
00:06:31,000 --> 00:06:37,000
Τώρα, επειδή χρησιμοποίησα τη συνάρτηση strlen σειρά να λάβει το μήκος μιας συμβολοσειράς,

74
00:06:37,000 --> 00:06:43,000
Θα πρέπει επίσης να προσθέσετε την string.h βιβλιοθήκη στην κορυφή περιλαμβάνει μας.

75
00:06:43,000 --> 00:06:50,000
Έτσι, για να το κάνουμε αυτό, θα πάμε επάνω, και ακριβώς κάτω από stdio.h, θα πάμε να κάνουμε

76
00:06:50,000 --> 00:06:57,000
# Include <string.h>.

77
00:06:57,000 --> 00:07:02,000
>> Έτσι, ας μεταγλώττιση και εκτέλεση και παρέχει ένα πραγματικό επιχείρημα.

78
00:07:09,000 --> 00:07:18,000
>> Και, όπως μπορούμε να δούμε, τώρα έχουμε την ακριβή τοποθεσία του κάθε char στο επιχείρημα.

79
00:07:18,000 --> 00:07:23,000
Έτσι, αυτό είναι όλο. Είμαι Christopher Βαρθολομαίος? Αυτό είναι CS50.

80
00:07:23,000 --> 00:07:26,000
[CS50.TV]