1
00:00:00,000 --> 00:00:02,000
[Powered by Google Translate] Della riga di comando [argomenti]

2
00:00:02,000 --> 00:00:04,000
[Christopher Bartolomeo - Harvard University]

3
00:00:04,000 --> 00:00:07,000
[Questo è CS50 - CS50.TV]

4
00:00:07,000 --> 00:00:11,000
Una caratteristica utile per un programma è quello di accettare l'input dell'utente.

5
00:00:11,000 --> 00:00:15,000
Finora, abbiamo esplorato alcune funzioni all'interno della libreria CS50

6
00:00:15,000 --> 00:00:18,000
per accettare l'input dell'utente, come ad esempio "get stringa"

7
00:00:18,000 --> 00:00:23,000
che richiede l'utente, mentre l'applicazione è in esecuzione, per una stringa.

8
00:00:23,000 --> 00:00:28,000
>> Tuttavia, ci sono casi in cui si desidera fornire il vostro input programma

9
00:00:28,000 --> 00:00:30,000
prima che sia effettivamente in esecuzione.

10
00:00:30,000 --> 00:00:34,000
In questo modo, non c'è bisogno di chiedere informazioni supplementari per l'utente

11
00:00:34,000 --> 00:00:38,000
durante l'esecuzione di un compito semplice.

12
00:00:38,000 --> 00:00:42,000
Prendiamo, ad esempio, il comando mv o si muovono in UNIX.

13
00:00:42,000 --> 00:00:49,000
Questo comando permette all'utente di spostare un file da una posizione a un'altra.

14
00:00:49,000 --> 00:00:55,000
Secondo le pagine di manuale, mv accetta due parametri:

15
00:00:55,000 --> 00:01:00,000
il file che si sta muovendo e la posizione del file sia spostato.

16
00:01:00,000 --> 00:01:06,000
Quindi questo esempio ha un comando con due argomenti.

17
00:01:06,000 --> 00:01:14,000
Quindi, come facciamo a dire il nostro programma C per utilizzare questi gli argomenti della riga di comando?

18
00:01:14,000 --> 00:01:20,000
>> Bene, si scopre che principale, che usiamo in tutti i programmi C, ha un segreto.

19
00:01:20,000 --> 00:01:26,000
Principale accetta due parametri: argc e argv.

20
00:01:26,000 --> 00:01:28,000
Andiamo oltre i suddetti termini.

21
00:01:28,000 --> 00:01:33,000
>> Il primo parametro, argc, che sta per numero di argomenti,

22
00:01:33,000 --> 00:01:36,000
ha un tipo di dati integer.

23
00:01:36,000 --> 00:01:42,000
Il parametro argc contiene il numero di argomenti, tra cui il comando.

24
00:01:42,000 --> 00:01:47,000
Nel nostro comando di spostamento, anche se abbiamo solo due argomenti visualizzati,

25
00:01:47,000 --> 00:01:50,000
valore di argc sarà 3.

26
00:01:50,000 --> 00:01:56,000
Il secondo parametro, argv, che sta per il vettore argomento,

27
00:01:56,000 --> 00:02:01,000
è un array di puntatori char che puntano in stringhe.

28
00:02:01,000 --> 00:02:06,000
>> Ciò significa che ogni elemento in argv, partendo da zero,

29
00:02:06,000 --> 00:02:09,000
contiene il comando e gli argomenti.

30
00:02:09,000 --> 00:02:16,000
Ad esempio, argv [0], che mi riferirò come argv zero,

31
00:02:16,000 --> 00:02:20,000
conterrà sempre il comando che viene eseguito -

32
00:02:20,000 --> 00:02:22,000
in questo caso, mv.

33
00:02:22,000 --> 00:02:28,000
argv [1] conterrà il primo argomento, file.txt,

34
00:02:28,000 --> 00:02:37,000
e argv [2] conterrà il secondo argomento, ~ / CS50 /.

35
00:02:37,000 --> 00:02:42,000
L'ultimo argomento di argv sarà sempre nullo.

36
00:02:42,000 --> 00:02:46,000
Quindi cerchiamo di attuare tali argomenti della riga di comando.

37
00:02:46,000 --> 00:02:53,000
Negli esercizi precedenti, abbiamo messo nulla, il che significa niente, come parametro principale.

38
00:02:53,000 --> 00:02:57,000
Tuttavia, in modo per noi di usare il comando argomenti della riga,

39
00:02:57,000 --> 00:03:12,000
abbiamo bisogno di rimuovere vuoto dentro e il luogo di principale int argc, char * argv [].

40
00:03:12,000 --> 00:03:17,000
Ora, per accedere l'intero elemento di argv, quali sono i tuoi argomenti,

41
00:03:17,000 --> 00:03:21,000
si può semplicemente scorrere, o loop, attraverso l'array come questo.

42
00:03:21,000 --> 00:03:27,000
Quindi, all'interno del corpo principale, abbiamo intenzione di andare avanti e digitare un ciclo for:

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
>> Non abbiamo bisogno di una parentesi graffa qui perché stiamo solo l'esecuzione di una riga di codice

45
00:03:41,000 --> 00:03:44,000
all'interno del corpo del ciclo.

46
00:03:44,000 --> 00:03:47,000
Andremo avanti e colpire scheda una volta,

47
00:03:47,000 --> 00:03:57,000
quindi digitare printf ("argv [% d], per rappresentare un valore intero,

48
00:03:57,000 --> 00:04:06,000
è% s, per la stringa, il carattere di nuova riga.

49
00:04:06,000 --> 00:04:12,000
Poi forniamo printf i per l'iterazione corrente del ciclo

50
00:04:12,000 --> 00:04:18,000
e argv [i] per la rappresentazione di stringa della corrente della riga di comando argomento.

51
00:04:18,000 --> 00:04:25,000
Quando lo si esegue con due argomenti, vedremo le argomentazioni in corso visualizzati nel terminale.

52
00:04:34,000 --> 00:04:38,000
In precedenza abbiamo detto che il argv ha un array di puntatori char.

53
00:04:38,000 --> 00:04:45,000
>> Quindi, se questo è il caso, come possiamo quindi accedere ai caratteri individuali in ciascun argomento?

54
00:04:45,000 --> 00:04:51,000
Per esempio, che se volevo cercare un carattere specifico nel primo argomento?

55
00:04:51,000 --> 00:04:55,000
Beh, la risposta è che abbiamo bisogno di applicare un ciclo nidificato

56
00:04:55,000 --> 00:04:59,000
che poi scorrere ciascuno degli elementi nella stringa argomento.

57
00:04:59,000 --> 00:05:02,000
Ecco come si fa.

58
00:05:02,000 --> 00:05:10,000
>> In primo luogo, stiamo andando a fare una copia di example2.c.

59
00:05:10,000 --> 00:05:13,000
Quindi, all'interno del primo ciclo,

60
00:05:13,000 --> 00:05:15,000
stiamo andando ad aggiungere un ulteriore ciclo for.

61
00:05:15,000 --> 00:05:28,000
Così for (int j = 0, n = strlen (argv [i]),

62
00:05:28,000 --> 00:05:32,000
che poi ci dà la lunghezza dell'argomento corrente,

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

64
00:05:39,000 --> 00:05:43,000
Stiamo per stampare la posizione di ciascun carattere

65
00:05:43,000 --> 00:05:47,000
all'interno dell'argomento corrente utilizzando printf.

66
00:05:47,000 --> 00:05:57,000
Quindi, printf ("argv [% d], a rappresentare l'indice della tesi corrente,

67
00:05:57,000 --> 00:06:05,000
poi [% d] ancora una volta, per rappresentare il carattere corrente dell'argomento corrente,

68
00:06:05,000 --> 00:06:13,000
è: c%, per il carattere corrente nell'argomento.

69
00:06:13,000 --> 00:06:20,000
Infine, forniamo printf con l'indice del ciclo esterno, i,

70
00:06:20,000 --> 00:06:22,000
allora l'indice del ciclo interno.

71
00:06:22,000 --> 00:06:28,000
>> E il nostro ultimo argomento a printf il carattere effettivo dal l'argomento fornito

72
00:06:28,000 --> 00:06:31,000
dalla riga di comando.

73
00:06:31,000 --> 00:06:37,000
Ora, perché ho usato la funzione stringa strlen per ottenere la lunghezza di una stringa,

74
00:06:37,000 --> 00:06:43,000
Devo anche aggiungere la libreria string.h all'inizio della nostra include.

75
00:06:43,000 --> 00:06:50,000
Così, per fare questo, andiamo su, e poco meno di stdio.h, che andremo a fare

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

77
00:06:57,000 --> 00:07:02,000
>> Allora, compilare ed eseguire, fornendo un argomento reale.

78
00:07:09,000 --> 00:07:18,000
>> E, come si può vedere, ora abbiamo la posizione esatta di ogni singolo carattere nell'argomento.

79
00:07:18,000 --> 00:07:23,000
Quindi, questo è tutto. Sono Christopher Bartolomeo, questo è CS50.

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