1
00:00:00,000 --> 00:00:02,000
[Powered by Google Translate] [Los argumentos de línea de comandos]

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

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

4
00:00:07,000 --> 00:00:11,000
Una característica útil para un programa es para aceptar la entrada del usuario.

5
00:00:11,000 --> 00:00:15,000
Hasta el momento, hemos explorado algunas de las funciones dentro de la biblioteca CS50

6
00:00:15,000 --> 00:00:18,000
para aceptar la entrada del usuario, tales como "cadena de conseguir,"

7
00:00:18,000 --> 00:00:23,000
que indica al usuario, mientras la aplicación se está ejecutando, para una cadena.

8
00:00:23,000 --> 00:00:28,000
>> Sin embargo, hay casos en los que desea proporcionar a su entrada de programa

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

10
00:00:30,000 --> 00:00:34,000
De esta manera, no es necesario solicitar información adicional de su usuario

11
00:00:34,000 --> 00:00:38,000
durante la ejecución de una tarea sencilla.

12
00:00:38,000 --> 00:00:42,000
Tomemos, por ejemplo, el comando mv o calientes y UNIX.

13
00:00:42,000 --> 00:00:49,000
Este comando permite al usuario mover un archivo desde una ubicación a otra.

14
00:00:49,000 --> 00:00:55,000
De acuerdo a las páginas del manual, mv acepta dos argumentos de línea de comandos:

15
00:00:55,000 --> 00:01:00,000
el archivo que se va a mover y la ubicación del archivo está siendo movido.

16
00:01:00,000 --> 00:01:06,000
Así que este ejemplo tiene un comando con dos argumentos.

17
00:01:06,000 --> 00:01:14,000
Entonces, ¿cómo le decimos a nuestro programa en C para utilizar estos argumentos de la línea de comandos?

18
00:01:14,000 --> 00:01:20,000
>> Bueno, resulta que el principal, que se utiliza en todos los programas en C, tiene un secreto.

19
00:01:20,000 --> 00:01:26,000
Principal acepta dos parámetros: argc y argv.

20
00:01:26,000 --> 00:01:28,000
Vamos a repasar estos términos.

21
00:01:28,000 --> 00:01:33,000
>> El primer parámetro, argc, que significa recuento de argumentos,

22
00:01:33,000 --> 00:01:36,000
tiene un tipo de datos entero.

23
00:01:36,000 --> 00:01:42,000
El parámetro argc contiene el número de argumentos, incluyendo el comando.

24
00:01:42,000 --> 00:01:47,000
En nuestro comando de movimiento, aunque sólo se han mostrado dos argumentos,

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 segundo parámetro, argv, que significa vector argumento,

27
00:01:56,000 --> 00:02:01,000
es una matriz de punteros char que apuntan a las cadenas.

28
00:02:01,000 --> 00:02:06,000
>> Esto significa que cada elemento de argv, a partir de cero,

29
00:02:06,000 --> 00:02:09,000
contiene el comando y los argumentos.

30
00:02:09,000 --> 00:02:16,000
Por ejemplo, argv [0], la cual me referiré como argv cero,

31
00:02:16,000 --> 00:02:20,000
siempre contendrá el comando que se está ejecutando -

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

33
00:02:22,000 --> 00:02:28,000
argv [1] contendrá el primer argumento, archivo.txt,

34
00:02:28,000 --> 00:02:37,000
y argv [2] contendrá el segundo argumento, ~ / CS50 /.

35
00:02:37,000 --> 00:02:42,000
El último argumento de argv siempre será nulo.

36
00:02:42,000 --> 00:02:46,000
Así que vamos a poner en práctica estos argumentos de la línea de comandos.

37
00:02:46,000 --> 00:02:53,000
En los ejercicios anteriores, colocamos vacío, es decir, nada, como parámetro principal.

38
00:02:53,000 --> 00:02:57,000
Sin embargo, para que podamos utilizar los argumentos de línea de comandos,

39
00:02:57,000 --> 00:03:12,000
tenemos que eliminar en el interior vacío y el lugar de principal argc int, char * argv [].

40
00:03:12,000 --> 00:03:17,000
Ahora, para acceder a todo el elemento de argv, que son sus argumentos,

41
00:03:17,000 --> 00:03:21,000
sólo tiene que repetir, o bucle, a través de la matriz de esta manera.

42
00:03:21,000 --> 00:03:27,000
Así, en el interior del cuerpo principal, vamos a seguir adelante y escribir 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 necesitamos una llave de cierre aquí porque estamos sólo ejecutando una línea de código

45
00:03:41,000 --> 00:03:44,000
dentro del cuerpo de este bucle.

46
00:03:44,000 --> 00:03:47,000
Vamos a seguir adelante y presione la tecla tab una vez,

47
00:03:47,000 --> 00:03:57,000
a continuación, escriba printf ("argv [% d], para representar un valor entero,

48
00:03:57,000 --> 00:04:06,000
es% s, para la cadena, el carácter de nueva línea.

49
00:04:06,000 --> 00:04:12,000
A continuación le proporcionamos printf i en la iteración actual del bucle

50
00:04:12,000 --> 00:04:18,000
y argv [i] para la representación de cadena de la corriente de línea de comandos argumento.

51
00:04:18,000 --> 00:04:25,000
Cuando se ejecuta con dos argumentos, vamos a ver los argumentos que se muestran en el terminal.

52
00:04:34,000 --> 00:04:38,000
Antes hemos dicho que el argv celebró una matriz de punteros char.

53
00:04:38,000 --> 00:04:45,000
>> Por lo tanto, si este es el caso, ¿cómo podemos entonces tener acceso a caracteres individuales en cada argumento?

54
00:04:45,000 --> 00:04:51,000
Por ejemplo, ¿qué pasa si yo quería buscar un carácter específico en el primer argumento?

55
00:04:51,000 --> 00:04:55,000
Bueno, la respuesta es que tenemos que aplicar un bucle anidado

56
00:04:55,000 --> 00:04:59,000
que entonces iterar a través de cada uno de los elementos de la cadena de argumentos.

57
00:04:59,000 --> 00:05:02,000
Esta es la forma de hacerlo.

58
00:05:02,000 --> 00:05:10,000
>> En primer lugar, vamos a hacer una copia de ejemplo2.c.

59
00:05:10,000 --> 00:05:13,000
Luego, dentro del primer bucle,

60
00:05:13,000 --> 00:05:15,000
vamos a añadir otro bucle for.

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

62
00:05:28,000 --> 00:05:32,000
que a su vez nos da la longitud de la discusión actual,

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

64
00:05:39,000 --> 00:05:43,000
Vamos a imprimir la ubicación de cada personaje

65
00:05:43,000 --> 00:05:47,000
dentro de la discusión actual utilizando printf.

66
00:05:47,000 --> 00:05:57,000
Así, printf ("argv [% d], para representar el índice del argumento actual,

67
00:05:57,000 --> 00:06:05,000
luego [% d] una vez más, para representar el carácter actual de la discusión actual,

68
00:06:05,000 --> 00:06:13,000
es: c%, para el carácter actual del argumento.

69
00:06:13,000 --> 00:06:20,000
Por último, proporcionamos printf con el índice del bucle exterior, i,

70
00:06:20,000 --> 00:06:22,000
entonces el índice del bucle interno.

71
00:06:22,000 --> 00:06:28,000
>> Y nuestro último argumento de printf es el carácter real del argumento siempre

72
00:06:28,000 --> 00:06:31,000
en la línea de comandos.

73
00:06:31,000 --> 00:06:37,000
Ahora, porque he utilizado la función de cadena strlen para obtener la longitud de una cadena,

74
00:06:37,000 --> 00:06:43,000
También debo añadir la biblioteca string.h a la parte superior de nuestra incluye.

75
00:06:43,000 --> 00:06:50,000
Así que, para hacer eso, vamos a ir para arriba, y un poco menos de stdio.h, que vamos a hacer

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

77
00:06:57,000 --> 00:07:02,000
>> Por lo tanto, vamos a compilar y ejecutar y dotarla de un argumento real.

78
00:07:09,000 --> 00:07:18,000
>> Y, como podemos ver, ahora tenemos la situación exacta de cada individuo caracteres en el argumento.

79
00:07:18,000 --> 00:07:23,000
Así que eso es todo. Soy Christopher Bartolomé, lo que es CS50.

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