1
00:00:00,000 --> 00:00:02,000
[Powered by Google Translate] [Argumente în linia de comandă]

2
00:00:02,000 --> 00:00:04,000
[Christopher Bartolomeu - Universitatea Harvard]

3
00:00:04,000 --> 00:00:07,000
[Acest lucru este CS50 - CS50.TV]

4
00:00:07,000 --> 00:00:11,000
O caracteristică utilă pentru un program este de a accepta date introduse de utilizator.

5
00:00:11,000 --> 00:00:15,000
Până acum, am explorat unele funcții în cadrul bibliotecii CS50

6
00:00:15,000 --> 00:00:18,000
să accepte introduse de utilizator, cum ar fi "sa string,"

7
00:00:18,000 --> 00:00:23,000
care solicită utilizatorului, în timp ce cererea se execută, pentru un șir.

8
00:00:23,000 --> 00:00:28,000
>> Cu toate acestea, există cazuri în care doriți să aducă o contribuție de program

9
00:00:28,000 --> 00:00:30,000
înainte de a fi, de fapt rulează.

10
00:00:30,000 --> 00:00:34,000
În acest fel, nu aveți nevoie pentru a solicita informații suplimentare de la utilizator

11
00:00:34,000 --> 00:00:38,000
în timp ce executa o sarcină simplă.

12
00:00:38,000 --> 00:00:42,000
Luați, de exemplu, mv sau comanda Mutare în UNIX.

13
00:00:42,000 --> 00:00:49,000
Această comandă permite utilizatorului pentru a muta un fișier dintr-o locație la alta.

14
00:00:49,000 --> 00:00:55,000
Conform paginile de manual, mv acceptă două argumente în linia de comandă:

15
00:00:55,000 --> 00:01:00,000
fișier care este mutat și locația fișierului este mutat la.

16
00:01:00,000 --> 00:01:06,000
Deci, acest exemplu are o comandă cu două argumente.

17
00:01:06,000 --> 00:01:14,000
Deci, cum le spunem programul nostru de C pentru a utiliza aceste argumente de linie de comandă?

18
00:01:14,000 --> 00:01:20,000
>> Ei bine, se pare că principalul, pe care le folosim în toate programele C, are un secret.

19
00:01:20,000 --> 00:01:26,000
Principalul acceptă doi parametri: argc și argv.

20
00:01:26,000 --> 00:01:28,000
Să trecem peste acești termeni.

21
00:01:28,000 --> 00:01:33,000
>> Primul parametru, argc, care vine de la numărul de argument,

22
00:01:33,000 --> 00:01:36,000
are un tip de date de întreg.

23
00:01:36,000 --> 00:01:42,000
Parametrul argc conține numărul de argumente, inclusiv comanda.

24
00:01:42,000 --> 00:01:47,000
În comanda noastră mișcare, deși avem doar două argumente afișat,

25
00:01:47,000 --> 00:01:50,000
Valoarea argc va fi 3.

26
00:01:50,000 --> 00:01:56,000
Al doilea parametru, argv, care vine de la vectorul argument,

27
00:01:56,000 --> 00:02:01,000
este o matrice de pointeri char acel punct la siruri de caractere.

28
00:02:01,000 --> 00:02:06,000
>> Acest lucru înseamnă că fiecare element din argv, incepand de la zero,

29
00:02:06,000 --> 00:02:09,000
conține comanda și argumentele.

30
00:02:09,000 --> 00:02:16,000
De exemplu, argv [0], pe care voi referi în continuare la zero argv,

31
00:02:16,000 --> 00:02:20,000
va conține întotdeauna comanda care este în curs de a alerga -

32
00:02:20,000 --> 00:02:22,000
în acest caz, mv.

33
00:02:22,000 --> 00:02:28,000
argv [1] va conține primul argument, file.txt,

34
00:02:28,000 --> 00:02:37,000
și argv [2] va conține al doilea argument, ~ / CS50 /.

35
00:02:37,000 --> 00:02:42,000
Ultimul argument al argv va fi întotdeauna nul.

36
00:02:42,000 --> 00:02:46,000
Deci, haideți să pună în aplicare aceste argumente de linie de comandă.

37
00:02:46,000 --> 00:02:53,000
În exercițiile anterioare, am plasat nule, adică nimic, ca parametru principal.

38
00:02:53,000 --> 00:02:57,000
Cu toate acestea, pentru ca noi să utilizați linia de comandă argumente,

39
00:02:57,000 --> 00:03:12,000
avem nevoie pentru a elimina interiorul nule și locul principal de int argc, char * argv [].

40
00:03:12,000 --> 00:03:17,000
Acum, pentru a accesa tot elementul din argv, care sunt argumentele tale,

41
00:03:17,000 --> 00:03:21,000
puteți itera pur și simplu, sau bucla, prin matrice de genul asta.

42
00:03:21,000 --> 00:03:27,000
Deci, în interiorul corpului principal, am de gând să mergi înainte și să tastați o buclă pentru:

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

44
00:03:37,000 --> 00:03:41,000
>> Nu avem nevoie de o proteză cret aici pentru ca suntem de executare o singură linie de cod

45
00:03:41,000 --> 00:03:44,000
în corpul această buclă.

46
00:03:44,000 --> 00:03:47,000
Vom merge mai departe și a lovit o dată fila,

47
00:03:47,000 --> 00:03:57,000
apoi tastați printf ("argv [% d], să reprezinte o valoare întreagă,

48
00:03:57,000 --> 00:04:06,000
este% s, pentru șir, apoi caracterul linie noua.

49
00:04:06,000 --> 00:04:12,000
Apoi ne-am oferi printf i pentru iterația curentă a buclei

50
00:04:12,000 --> 00:04:18,000
și argv [i] pentru reprezentarea șir de curent de linie de comandă argumentul.

51
00:04:18,000 --> 00:04:25,000
Când l-am alerga cu două argumente, vom vedea argumentele fiind afișate în terminal.

52
00:04:34,000 --> 00:04:38,000
Mai devreme am spus că argv a avut loc o serie de indicii char.

53
00:04:38,000 --> 00:04:45,000
>> Deci, dacă este cazul, cum putem accesa apoi de caractere individuale din fiecare argument?

54
00:04:45,000 --> 00:04:51,000
De exemplu, dacă am vrut să caute un caracter specific în primul argument?

55
00:04:51,000 --> 00:04:55,000
Ei bine, răspunsul este că avem nevoie de a aplica o buclă imbricată

56
00:04:55,000 --> 00:04:59,000
care va itera apoi prin fiecare dintre elementele din șirul argument.

57
00:04:59,000 --> 00:05:02,000
Acesta este modul în care o faci.

58
00:05:02,000 --> 00:05:10,000
>> În primul rând, vom face o copie a example2.c.

59
00:05:10,000 --> 00:05:13,000
Apoi, în interiorul prima bucla,

60
00:05:13,000 --> 00:05:15,000
vom adăuga o buclă suplimentară pentru.

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

62
00:05:28,000 --> 00:05:32,000
care apoi ne dă lungimea argumentului curent,

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

64
00:05:39,000 --> 00:05:43,000
Mergem pentru a imprima locația fiecare caracter

65
00:05:43,000 --> 00:05:47,000
interiorul argumentul curent prin utilizarea printf.

66
00:05:47,000 --> 00:05:57,000
Deci, printf ("argv [% d], pentru a reprezenta indicele de argumentul curent,

67
00:05:57,000 --> 00:06:05,000
apoi [% d] încă o dată, pentru a reprezenta caracterul actual al argumentului curent,

68
00:06:05,000 --> 00:06:13,000
este: C%, pentru caracterul curent în argument.

69
00:06:13,000 --> 00:06:20,000
În cele din urmă, oferim printf cu indicele de bucla exterior, i,

70
00:06:20,000 --> 00:06:22,000
atunci indicele de bucla interioară.

71
00:06:22,000 --> 00:06:28,000
>> Și argumentul nostru ultima printf este personaj real din argumentul oferit

72
00:06:28,000 --> 00:06:31,000
la linia de comandă.

73
00:06:31,000 --> 00:06:37,000
Acum, pentru că am folosit funcția strlen șir pentru a obține lungimea unui șir,

74
00:06:37,000 --> 00:06:43,000
Trebuie să adaug, de asemenea, biblioteca string.h la partea de sus a include noastre.

75
00:06:43,000 --> 00:06:50,000
Deci, pentru a face acest lucru, vom merge în sus, și doar în stdio.h, am de gând să faci

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

77
00:06:57,000 --> 00:07:02,000
>> Deci, hai să compila și a alerga și îi furnizează un argument real.

78
00:07:09,000 --> 00:07:18,000
>> Și, după cum putem vedea, avem acum locatia exacta a fiecărui individ în char argumentul.

79
00:07:18,000 --> 00:07:23,000
Deci asta e tot. Sunt Christopher Bartolomeu; acest lucru este CS50.

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