1
00:00:00,000 --> 00:00:02,000
[Powered by Google Translate] [Linha 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
Um recurso útil para um programa é para aceitar a entrada do usuário.

5
00:00:11,000 --> 00:00:15,000
Até o momento, exploramos algumas funções dentro da biblioteca CS50

6
00:00:15,000 --> 00:00:18,000
para aceitar a entrada do usuário, como "pegar corda",

7
00:00:18,000 --> 00:00:23,000
que avisa o usuário, enquanto o aplicativo é executado, por uma corda.

8
00:00:23,000 --> 00:00:28,000
>> No entanto, há casos em que você deseja fornecer sua entrada programa

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

10
00:00:30,000 --> 00:00:34,000
Dessa forma, você não precisa de pedir informações adicionais de seu usuário

11
00:00:34,000 --> 00:00:38,000
durante a execução de uma tarefa simples.

12
00:00:38,000 --> 00:00:42,000
Tome-se, por exemplo, o mv ou comando de movimento em UNIX.

13
00:00:42,000 --> 00:00:49,000
Este comando permite que o usuário mover um arquivo de um local para outro.

14
00:00:49,000 --> 00:00:55,000
De acordo com as páginas do manual, mv aceita dois argumentos de linha de comando:

15
00:00:55,000 --> 00:01:00,000
o arquivo que está sendo movido ea localização do arquivo está sendo movido.

16
00:01:00,000 --> 00:01:06,000
Portanto, este exemplo tem um comando com dois argumentos.

17
00:01:06,000 --> 00:01:14,000
Então, como vamos dizer o nosso programa em C para utilizar esses argumentos de linha de comando?

18
00:01:14,000 --> 00:01:20,000
>> Bem, acontece que principal, que usamos em todos os programas C, tem um segredo.

19
00:01:20,000 --> 00:01:26,000
Principal aceita dois parâmetros: argc e argv.

20
00:01:26,000 --> 00:01:28,000
Vamos passar por cima desses termos.

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

22
00:01:33,000 --> 00:01:36,000
tem um tipo de dados inteiro.

23
00:01:36,000 --> 00:01:42,000
O parâmetro argc contém o número de argumentos, incluindo o comando.

24
00:01:42,000 --> 00:01:47,000
No nosso comando de movimento, apesar de só ter dois argumentos apresentados,

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 vetor argumento,

27
00:01:56,000 --> 00:02:01,000
é uma matriz de ponteiros de char que apontam para cordas.

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

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

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

31
00:02:16,000 --> 00:02:20,000
sempre conterá o comando que está sendo executado -

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

33
00:02:22,000 --> 00:02:28,000
argv [1] irá conter o primeiro argumento, file.txt,

34
00:02:28,000 --> 00:02:37,000
e argv [2] irá conter o segundo argumento, ~ / CS50 /.

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

36
00:02:42,000 --> 00:02:46,000
Então, vamos implementar esses argumentos de linha de comando.

37
00:02:46,000 --> 00:02:53,000
Em exercícios anteriores, colocado vazio, ou seja, nada, como parâmetro principal.

38
00:02:53,000 --> 00:02:57,000
No entanto, a fim de nos usar linha de comando argumentos,

39
00:02:57,000 --> 00:03:12,000
precisamos remover vazio e coloque dentro de principal int argc, char * argv [].

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

41
00:03:17,000 --> 00:03:21,000
você pode simplesmente repetir, ou loop, através da matriz como este.

42
00:03:21,000 --> 00:03:27,000
Então, dentro do corpo principal, nós estamos indo para ir em frente e digite um loop:

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
>> Nós não precisamos de uma chaveta aqui porque estamos apenas a execução de uma linha 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
Vamos em frente e bateu na guia uma vez,

47
00:03:47,000 --> 00:03:57,000
digite printf ("argv [% d], para representar um valor inteiro,

48
00:03:57,000 --> 00:04:06,000
é% s, para string, o caractere de nova linha.

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

50
00:04:12,000 --> 00:04:18,000
e argv [i] para a representação de string do argumento de linha de comando atual.

51
00:04:18,000 --> 00:04:25,000
Quando executá-lo com dois argumentos, vamos ver os argumentos que estão sendo exibidos no terminal.

52
00:04:34,000 --> 00:04:38,000
Anteriormente, disse que o argv realizada uma matriz de ponteiros char.

53
00:04:38,000 --> 00:04:45,000
>> Assim, se este for o caso, como nós, então, acessar caracteres individuais em cada argumento?

54
00:04:45,000 --> 00:04:51,000
Por exemplo, se eu queria olhar para um personagem específico no primeiro argumento?

55
00:04:51,000 --> 00:04:55,000
Bem, a resposta é que nós precisamos aplicar um loop aninhado

56
00:04:55,000 --> 00:04:59,000
que irá então percorrer cada um dos elementos da cadeia de argumento.

57
00:04:59,000 --> 00:05:02,000
Isto é como você fazer isso.

58
00:05:02,000 --> 00:05:10,000
>> Primeiro, vamos fazer uma cópia de exemplo2.c.

59
00:05:10,000 --> 00:05:13,000
Então, dentro do primeiro ciclo,

60
00:05:13,000 --> 00:05:15,000
vamos adicionar um adicional de loop.

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

62
00:05:28,000 --> 00:05:32,000
que, em seguida, dá-nos o comprimento 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 vamos imprimir a localização de cada personagem

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

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

67
00:05:57,000 --> 00:06:05,000
então [% d] mais uma vez, para representar o caractere atual do argumento atual,

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

69
00:06:13,000 --> 00:06:20,000
Finalmente, fornecemos printf com o índice do laço externo, i,

70
00:06:20,000 --> 00:06:22,000
em seguida, o índice do loop interno.

71
00:06:22,000 --> 00:06:28,000
>> E o nosso último argumento para printf é o caráter real da argumentação, desde que

72
00:06:28,000 --> 00:06:31,000
na linha de comando.

73
00:06:31,000 --> 00:06:37,000
Agora, porque eu usei a função string strlen para obter o comprimento de uma corda,

74
00:06:37,000 --> 00:06:43,000
Devo acrescentar também a biblioteca string.h para o topo da nossa inclui.

75
00:06:43,000 --> 00:06:50,000
Então, para fazer isso, nós vamos ir para cima, e pouco menos de stdio.h, nós vamos fazer

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

77
00:06:57,000 --> 00:07:02,000
>> Então, vamos compilar e executar e fornecer-lhe um argumento real.

78
00:07:09,000 --> 00:07:18,000
>> E, como podemos ver, agora temos a localização exata de cada char individual no argumento.

79
00:07:18,000 --> 00:07:23,000
Então é isso. Eu sou Christopher Bartolomeu; este é CS50.

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