1
00:00:00,000 --> 00:00:02,000
[Powered by Google Translate] [Els arguments de línia de comandes]

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

3
00:00:04,000 --> 00:00:07,000
[Aquesta és CS50 - CS50.TV]

4
00:00:07,000 --> 00:00:11,000
Una característica útil per a un programa és per acceptar l'entrada de l'usuari.

5
00:00:11,000 --> 00:00:15,000
Fins ara, hem explorat algunes de les funcions dins de la biblioteca CS50

6
00:00:15,000 --> 00:00:18,000
per acceptar l'entrada de l'usuari, com ara "cadena d'aconseguir,"

7
00:00:18,000 --> 00:00:23,000
que indica a l'usuari, mentre l'aplicació s'està executant, per a una cadena.

8
00:00:23,000 --> 00:00:28,000
>> No obstant això, hi ha casos en que desitja proporcionar a la seva entrada de programa

9
00:00:28,000 --> 00:00:30,000
abans que realment s'està executant.

10
00:00:30,000 --> 00:00:34,000
D'aquesta manera, no és necessari sol · licitar informació addicional del seu usuari

11
00:00:34,000 --> 00:00:38,000
durant l'execució d'una tasca senzilla.

12
00:00:38,000 --> 00:00:42,000
Prenguem, per exemple, l'ordre mv o calents i UNIX.

13
00:00:42,000 --> 00:00:49,000
Aquesta comanda permet a l'usuari moure un arxiu des d'una ubicació a una altra.

14
00:00:49,000 --> 00:00:55,000
D'acord a les pàgines del manual, mv accepta dos arguments de línia de comandes:

15
00:00:55,000 --> 00:01:00,000
l'arxiu que es va a moure i la ubicació del fitxer està sent mogut.

16
00:01:00,000 --> 00:01:06,000
Així que aquest exemple té una ordre amb dos arguments.

17
00:01:06,000 --> 00:01:14,000
Llavors, ¿com li diem al nostre programa en C per utilitzar aquests arguments de la línia de comandaments?

18
00:01:14,000 --> 00:01:20,000
>> Bé, resulta que el principal, que s'utilitza en tots els programes en C, té un secret.

19
00:01:20,000 --> 00:01:26,000
Inici accepta dos paràmetres: argc i argv.

20
00:01:26,000 --> 00:01:28,000
Anem a repassar aquests termes.

21
00:01:28,000 --> 00:01:33,000
>> El primer paràmetre, argc, que significa recompte d'arguments,

22
00:01:33,000 --> 00:01:36,000
té un tipus de dades sencer.

23
00:01:36,000 --> 00:01:42,000
El paràmetre argc conté el nombre d'arguments, incloent la comanda.

24
00:01:42,000 --> 00:01:47,000
En el nostre ordre de moviment, encara que només s'han mostrat dos arguments,

25
00:01:47,000 --> 00:01:50,000
valor de argc serà de 3.

26
00:01:50,000 --> 00:01:56,000
El segon paràmetre, argv, que significa vector argument,

27
00:01:56,000 --> 00:02:01,000
és una matriu de punters char que apunten a les cadenes.

28
00:02:01,000 --> 00:02:06,000
>> Això significa que cada element de argv, a partir de zero,

29
00:02:06,000 --> 00:02:09,000
conté la comanda i els arguments.

30
00:02:09,000 --> 00:02:16,000
Per exemple, argv [0], la qual faré referència com argv zero,

31
00:02:16,000 --> 00:02:20,000
sempre contindrà la comanda que s'està executant -

32
00:02:20,000 --> 00:02:22,000
en aquest cas, mv.

33
00:02:22,000 --> 00:02:28,000
argv [1] contindrà el primer argument, fitxer.txt,

34
00:02:28,000 --> 00:02:37,000
i argv [2] contindrà el segon argument, ~ / CS50 /.

35
00:02:37,000 --> 00:02:42,000
L'últim argument de argv sempre serà nul.

36
00:02:42,000 --> 00:02:46,000
Així que anem a posar en pràctica aquests arguments de la línia d'ordres.

37
00:02:46,000 --> 00:02:53,000
En els exercicis anteriors, col · loquem buit, és a dir, res, com a paràmetre principal.

38
00:02:53,000 --> 00:02:57,000
No obstant això, perquè puguem utilitzar els arguments de línia de comandes,

39
00:02:57,000 --> 00:03:12,000
hem d'eliminar a l'interior buit i el lloc de principal argc int, char * argv [].

40
00:03:12,000 --> 00:03:17,000
Ara, per accedir a tot l'element de argv, que són els seus arguments,

41
00:03:17,000 --> 00:03:21,000
simplement repetiu, o bucle, a través de la matriu d'aquesta manera.

42
00:03:21,000 --> 00:03:27,000
Així, a l'interior del cos principal, seguirem endavant i escriure un bucle 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
>> No necessitem una clau de tancament aquí perquè estem només executant una línia de codi

45
00:03:41,000 --> 00:03:44,000
dins del cos d'aquest bucle.

46
00:03:44,000 --> 00:03:47,000
Seguirem endavant i premeu la tecla tab un cop,

47
00:03:47,000 --> 00:03:57,000
a continuació, escriviu printf ("argv [% d], per representar un valor sencer,

48
00:03:57,000 --> 00:04:06,000
és% s, per a la cadena, el caràcter de nova línia.

49
00:04:06,000 --> 00:04:12,000
A continuació posem a printf ia la iteració actual del bucle

50
00:04:12,000 --> 00:04:18,000
i argv [i] per a la representació de cadena del corrent de línia d'ordres argument.

51
00:04:18,000 --> 00:04:25,000
Quan s'executa amb dos arguments, anem a veure els arguments que es mostren en el terminal.

52
00:04:34,000 --> 00:04:38,000
Abans hem dit que el argv celebrar una matriu de punters char.

53
00:04:38,000 --> 00:04:45,000
>> Per tant, si aquest és el cas, com podem llavors tenir accés a caràcters individuals a cada argument?

54
00:04:45,000 --> 00:04:51,000
Per exemple, què passa si jo volia buscar un caràcter específic al primer argument?

55
00:04:51,000 --> 00:04:55,000
Bé, la resposta és que hem d'aplicar un bucle niat

56
00:04:55,000 --> 00:04:59,000
que llavors iterar a través de cada un dels elements de la cadena d'arguments.

57
00:04:59,000 --> 00:05:02,000
Aquesta és la forma de fer-ho.

58
00:05:02,000 --> 00:05:10,000
>> En primer lloc, farem una còpia de ejemplo2.c.

59
00:05:10,000 --> 00:05:13,000
Després, dins el primer bucle,

60
00:05:13,000 --> 00:05:15,000
anem a afegir un altre bucle for.

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

62
00:05:28,000 --> 00:05:32,000
que al seu torn ens dóna la longitud de la discussió actual,

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

64
00:05:39,000 --> 00:05:43,000
Anem a imprimir la ubicació de cada personatge

65
00:05:43,000 --> 00:05:47,000
dins de la discussió actual utilitzant printf.

66
00:05:47,000 --> 00:05:57,000
Així, printf ("argv [% d], per representar l'índex de l'argument actual,

67
00:05:57,000 --> 00:06:05,000
després [% d] un cop més, per representar el caràcter actual de la discussió actual,

68
00:06:05,000 --> 00:06:13,000
és: c%, per al caràcter actual de l'argument.

69
00:06:13,000 --> 00:06:20,000
Finalment, proporcionem printf amb l'índex del bucle exterior, i,

70
00:06:20,000 --> 00:06:22,000
llavors l'índex del bucle intern.

71
00:06:22,000 --> 00:06:28,000
>> I el nostre últim argument de printf és el caràcter real de l'argument sempre

72
00:06:28,000 --> 00:06:31,000
en la línia d'ordres.

73
00:06:31,000 --> 00:06:37,000
Ara, perquè he utilitzat la funció de cadena strlen per obtenir la longitud d'una cadena,

74
00:06:37,000 --> 00:06:43,000
També he d'afegir la biblioteca string.h a la part superior de la nostra inclou.

75
00:06:43,000 --> 00:06:50,000
Així que, per fer això, anirem cap amunt, i una mica menys de stdio.h, que farem

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

77
00:06:57,000 --> 00:07:02,000
>> Per tant, anem a compilar i executar i dotar-la d'un argument real.

78
00:07:09,000 --> 00:07:18,000
>> I, com podem veure, ara tenim la situació exacta de cada individu caràcters en l'argument.

79
00:07:18,000 --> 00:07:23,000
Així que això és tot. Sóc Christopher Bartolomé, el que és CS50.

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