1
00:00:00,000 --> 00:00:02,000
[Powered by Google Translate] [Liña de comando argumentos]

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

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

4
00:00:07,000 --> 00:00:11,000
Un recurso útil para un programa para aceptar a entrada do usuario.

5
00:00:11,000 --> 00:00:15,000
Ata o momento, exploran algunhas funcións dentro da biblioteca CS50

6
00:00:15,000 --> 00:00:18,000
para aceptar a entrada do usuario, como "pegar corda",

7
00:00:18,000 --> 00:00:23,000
que avisa o usuario, mentres que o programa é executado, por unha corda.

8
00:00:23,000 --> 00:00:28,000
>> No entanto, hai casos en que quere achegar a súa entrada programa

9
00:00:28,000 --> 00:00:30,000
antes de que el está realmente funcionando.

10
00:00:30,000 --> 00:00:34,000
Desta forma, non precisa de pedir información adicional do seu autor

11
00:00:34,000 --> 00:00:38,000
durante a execución dunha tarefa sinxela.

12
00:00:38,000 --> 00:00:42,000
Tomé-se, por exemplo, o mv ou orde de movemento en UNIX.

13
00:00:42,000 --> 00:00:49,000
Este comando permite que o usuario move un arquivo de un lugar a outro.

14
00:00:49,000 --> 00:00:55,000
De acordo coas páxinas do manual, MV acepta dous argumentos de liña de comandos:

15
00:00:55,000 --> 00:01:00,000
o ficheiro que está a ser movido ea localización do arquivo está movido.

16
00:01:00,000 --> 00:01:06,000
Polo tanto, este exemplo ten un mando con dous argumentos.

17
00:01:06,000 --> 00:01:14,000
Entón, como imos dicir o noso programa en C para utilizar eses argumentos de liña de comandos?

18
00:01:14,000 --> 00:01:20,000
>> Ben, acontece que de inicio, que usan en todos os programas C, ten un segredo.

19
00:01:20,000 --> 00:01:26,000
Inicio acepta dous parámetros: argc e argv.

20
00:01:26,000 --> 00:01:28,000
Imos pasar por riba deses termos.

21
00:01:28,000 --> 00:01:33,000
>> O primeiro parámetro, argc, que está a conta de argumentos,

22
00:01:33,000 --> 00:01:36,000
ten un tipo de datos enteiro.

23
00:01:36,000 --> 00:01:42,000
O parámetro argc contén o número de argumentos, incluíndo o comando.

24
00:01:42,000 --> 00:01:47,000
No noso mando de movemento, a pesar de só ter dous argumentos presentados,

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

26
00:01:50,000 --> 00:01:56,000
O segundo parámetro, argv, que significa vector argumento,

27
00:01:56,000 --> 00:02:01,000
é unha matriz de punteiros de char que ligan con cordas.

28
00:02:01,000 --> 00:02:06,000
>> Isto significa que cada elemento de argv, partindo de cero,

29
00:02:06,000 --> 00:02:09,000
contén o mando e argumentos.

30
00:02:09,000 --> 00:02:16,000
Por exemplo, argv [0], que eu vou chamar de argv cero,

31
00:02:16,000 --> 00:02:20,000
sempre conterá a orde que está a ser executado -

32
00:02:20,000 --> 00:02:22,000
neste caso, MV.

33
00:02:22,000 --> 00:02:28,000
argv [1] contén o primeiro argumento, file.txt,

34
00:02:28,000 --> 00:02:37,000
e argv [2] contén o segundo argumento, ~ / CS50 /.

35
00:02:37,000 --> 00:02:42,000
O último argumento argv sempre será nulo.

36
00:02:42,000 --> 00:02:46,000
Entón, imos aplicar eses argumentos de liña de comandos.

37
00:02:46,000 --> 00:02:53,000
En exercicios anteriores, posto baleiro ou sexa, nada, como parámetro principal.

38
00:02:53,000 --> 00:02:57,000
Con todo, a fin de nos usar liña de comandos argumentos,

39
00:02:57,000 --> 00:03:12,000
necesitamos eliminar baleiro e coloque dentro principal int argc, char * argv [].

40
00:03:12,000 --> 00:03:17,000
Agora, para acceder todo o elemento de argv, que son os seus argumentos,

41
00:03:17,000 --> 00:03:21,000
pode simplemente repetir ou loop, a través da matriz coma este.

42
00:03:21,000 --> 00:03:27,000
Entón, dentro do corpo principal, nós estamos indo para ir adiante e escriba un loop:

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

44
00:03:37,000 --> 00:03:41,000
>> Non necesitamos unha chaveta aquí porque estamos só a execución dunha liña de código

45
00:03:41,000 --> 00:03:44,000
dentro do corpo do ciclo.

46
00:03:44,000 --> 00:03:47,000
Imos adiante e bateu na guía unha vez máis,

47
00:03:47,000 --> 00:03:57,000
escriba printf ("argv [% d], para representar un valor enteiro,

48
00:03:57,000 --> 00:04:06,000
é% s, para cadea, o carácter de nova liña.

49
00:04:06,000 --> 00:04:12,000
Entón, nós fornecen printf i para a iteração actual do loop

50
00:04:12,000 --> 00:04:18,000
e argv [i] para a representación de cadea do argumento de liña de comandos actual.

51
00:04:18,000 --> 00:04:25,000
Cando executa-lo con dous argumentos, imos ver os argumentos que están sendo exhibidos no terminal.

52
00:04:34,000 --> 00:04:38,000
Anteriormente, dixo que o argv realizada nunha matriz de punteiros char.

53
00:04:38,000 --> 00:04:45,000
>> Así, se este é o caso, coma nós, entón, acceder caracteres individuais en cada argumento?

54
00:04:45,000 --> 00:04:51,000
Por exemplo, se eu quería mirar para un personaxe específico no primeiro argumento?

55
00:04:51,000 --> 00:04:55,000
Ben, a resposta é que necesitamos aplicar un loop aninhado

56
00:04:55,000 --> 00:04:59,000
que pode entón percorrer cada un dos elementos da cadea de argumento.

57
00:04:59,000 --> 00:05:02,000
Isto é como facelo.

58
00:05:02,000 --> 00:05:10,000
>> En primeiro lugar, imos facer unha copia de exemplo2.c.

59
00:05:10,000 --> 00:05:13,000
Entón, dentro do primeiro ciclo,

60
00:05:13,000 --> 00:05:15,000
imos engadir un adicional de loop.

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

62
00:05:28,000 --> 00:05:32,000
que, a continuación, dá-nos o longo do argumento actual,

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

64
00:05:39,000 --> 00:05:43,000
Nós imos imprimir a localización de cada personaxe

65
00:05:43,000 --> 00:05:47,000
dentro do argumento actual usando printf.

66
00:05:47,000 --> 00:05:57,000
Así, printf ("argv [% d], para representar o contido da cadea de argumento,

67
00:05:57,000 --> 00:06:05,000
entón [% d] unha vez máis, para representar o carácter actual do argumento actual,

68
00:06:05,000 --> 00:06:13,000
é: c%, para o carácter actual no argumento.

69
00:06:13,000 --> 00:06:20,000
Finalmente, fornecen printf co índice do lazo externo, i,

70
00:06:20,000 --> 00:06:22,000
a continuación, o índice de loop interno.

71
00:06:22,000 --> 00:06:28,000
>> E o noso último argumento para printf é o carácter real da argumentación, sempre que

72
00:06:28,000 --> 00:06:31,000
na liña de comandos.

73
00:06:31,000 --> 00:06:37,000
Agora, porque eu usei a función cadea strlen para obter a lonxitude dunha corda,

74
00:06:37,000 --> 00:06:43,000
Debo engadir tamén a biblioteca string.h para arriba da nosa inclúe.

75
00:06:43,000 --> 00:06:50,000
Entón, para facelo, nós imos ir cara arriba, e algo menos de stdio.h, imos facer

76
00:06:50,000 --> 00:06:57,000
# Incluír.

77
00:06:57,000 --> 00:07:02,000
>> Entón, imos compilar e executar e proporcionar-lle un argumento real.

78
00:07:09,000 --> 00:07:18,000
>> E, como podemos ver, agora temos a localización exacta de cada char individual no argumento.

79
00:07:18,000 --> 00:07:23,000
Entón é iso. Eu son Christopher Bartolomeu; este é CS50.

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