1
00:00:00,000 --> 00:00:02,000
[Powered by Google Translate] [Командната линија аргументи]

2
00:00:02,000 --> 00:00:04,000
[Кристофер Вартоломеј - Универзитетот Харвард]

3
00:00:04,000 --> 00:00:07,000
[Ова е CS50 - CS50.TV]

4
00:00:07,000 --> 00:00:11,000
А корисна карактеристика на програмата е да се прифати корисник влез.

5
00:00:11,000 --> 00:00:15,000
Досега, ние сме истражено некои функции во рамките на CS50 библиотека

6
00:00:15,000 --> 00:00:18,000
да го прифати корисник влез, како што се "добие стринг"

7
00:00:18,000 --> 00:00:23,000
кој поттикнува на корисникот, додека апликацијата е водење, за низа.

8
00:00:23,000 --> 00:00:28,000
>> Сепак, постојат случаи каде што сакате да ја покажете вашата програма влез

9
00:00:28,000 --> 00:00:30,000
пред да се всушност работи.

10
00:00:30,000 --> 00:00:34,000
На овој начин, вие не треба да побара дополнителни информации од Вашиот корисникот

11
00:00:34,000 --> 00:00:38,000
при извршување едноставна задача.

12
00:00:38,000 --> 00:00:42,000
Преземе, на пример, mv или преместување команда во UNIX.

13
00:00:42,000 --> 00:00:49,000
Оваа команда овозможува на корисникот да преместите датотека од едно место до друго.

14
00:00:49,000 --> 00:00:55,000
Според упатството страници, mv прифаќа две командната линија аргументи:

15
00:00:55,000 --> 00:01:00,000
на датотеката што се пресели и локацијата на датотеката е преместена.

16
00:01:00,000 --> 00:01:06,000
Па овој пример има команда со два аргументи.

17
00:01:06,000 --> 00:01:14,000
Така како ние да кажам нашата C програма да ги користат овие командната линија аргументи?

18
00:01:14,000 --> 00:01:20,000
>> Па, излегува дека главните, кои ние ги користиме во сите C програми, има една тајна.

19
00:01:20,000 --> 00:01:26,000
Главната прифаќа два параметри: argc и argv.

20
00:01:26,000 --> 00:01:28,000
Ајде да одиме во текот на овие термини.

21
00:01:28,000 --> 00:01:33,000
>> Првиот параметар, argc, која се залага за аргумент брои,

22
00:01:33,000 --> 00:01:36,000
има податоци за видот на број.

23
00:01:36,000 --> 00:01:42,000
На argc параметар содржи број на аргументи, вклучувајќи го и командата.

24
00:01:42,000 --> 00:01:47,000
Во нашиот потег команда, иако имаме само два аргументи екранот,

25
00:01:47,000 --> 00:01:50,000
вредност argc ќе биде 3.

26
00:01:50,000 --> 00:01:56,000
Вториот параметар, argv, која се залага за аргументот за векторот,

27
00:01:56,000 --> 00:02:01,000
е низа на знак совети кои укажуваат на жици.

28
00:02:01,000 --> 00:02:06,000
>> Ова значи дека секој елемент во argv, почнувајќи од нула,

29
00:02:06,000 --> 00:02:09,000
содржи командата и аргументи.

30
00:02:09,000 --> 00:02:16,000
На пример, avg [0], која ќе се однесуваат како argv нула,

31
00:02:16,000 --> 00:02:20,000
секогаш ќе содржи командата која се кандидира -

32
00:02:20,000 --> 00:02:22,000
во овој случај, mv.

33
00:02:22,000 --> 00:02:28,000
avg [1] ќе содржат првиот аргумент, file.txt,

34
00:02:28,000 --> 00:02:37,000
и avg [2] ќе содржи вториот аргумент, ~ / cs50 /.

35
00:02:37,000 --> 00:02:42,000
Последниот аргумент на argv секогаш ќе биде нула.

36
00:02:42,000 --> 00:02:46,000
Значи, да ги имплементираат овие командната линија аргументи.

37
00:02:46,000 --> 00:02:53,000
Во претходните вежби, ние сместени празнина, што значи ништо, како параметар главниот е.

38
00:02:53,000 --> 00:02:57,000
Меѓутоа, со цел за нас да го користите командната линија аргументи,

39
00:02:57,000 --> 00:03:12,000
ние треба да се отстрани неважечки и место во внатрешноста на главниот int argc, char * avg [].

40
00:03:12,000 --> 00:03:17,000
Сега, за да пристапите на целата елемент од argv, кои се вашите аргументи,

41
00:03:17,000 --> 00:03:21,000
можете едноставно да iterate, или телефонска линија, преку низа допаѓа ова.

42
00:03:21,000 --> 00:03:27,000
Значи, во внатрешноста на телото главната е, ние ќе одиме напред и напишете за телефонска линија:

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

44
00:03:37,000 --> 00:03:41,000
>> Ние не треба кадрава голема заграда тука, бидејќи ние сме само извршување на една линија код

45
00:03:41,000 --> 00:03:44,000
во телото на овој циклус.

46
00:03:44,000 --> 00:03:47,000
Ќе одиме напред и хит табот еднаш,

47
00:03:47,000 --> 00:03:57,000
потоа внеси printf ("avg [% d], да ја претставува целобројна вредност,

48
00:03:57,000 --> 00:04:06,000
е% s, за стринг, а потоа новата линија карактер.

49
00:04:06,000 --> 00:04:12,000
Тогаш ние обезбеди printf i за тековната повторување на јамка

50
00:04:12,000 --> 00:04:18,000
и avg [i] за стринг застапеност на тековната командната линија аргумент.

51
00:04:18,000 --> 00:04:25,000
Кога ќе го стартувате со два аргументи, ќе видиме аргументите кои се прикажани во терминал.

52
00:04:34,000 --> 00:04:38,000
Понапред се рече дека argv одржа низа на знак покажувачи.

53
00:04:38,000 --> 00:04:45,000
>> Значи, ако ова е случај, како ние да потоа пристап индивидуални ликови во секој аргумент?

54
00:04:45,000 --> 00:04:51,000
На пример, што ако сакав да барате специфичен карактер во првиот аргумент?

55
00:04:51,000 --> 00:04:55,000
Добро, одговорот е дека ние треба да се применуваат вгнездени јамка

56
00:04:55,000 --> 00:04:59,000
кои потоа ќе iterate преку секој од елементите во аргумент стринг.

57
00:04:59,000 --> 00:05:02,000
Ова е како да го направи тоа.

58
00:05:02,000 --> 00:05:10,000
>> Прво, ние ќе треба да се направи копија на example2.c.

59
00:05:10,000 --> 00:05:13,000
Потоа, во внатрешноста на првиот за телефонска линија,

60
00:05:13,000 --> 00:05:15,000
ние ќе додадете дополнителни за телефонска линија.

61
00:05:15,000 --> 00:05:28,000
Така за (int j = 0, n = strlen (avg [i]),

62
00:05:28,000 --> 00:05:32,000
кој потоа ни ја дава должината на тековната аргумент,

63
00:05:32,000 --> 00:05:39,000
; Ѕ <n; ѕ + +)

64
00:05:39,000 --> 00:05:43,000
Ние ќе се печати на локацијата на секој карактер

65
00:05:43,000 --> 00:05:47,000
внатрешноста на тековната расправија со користење printf.

66
00:05:47,000 --> 00:05:57,000
Значи, printf ("avg [% d], да ги застапува Индексот на тековната аргумент,

67
00:05:57,000 --> 00:06:05,000
тогаш [% d] уште еднаш, да ги претставуваат тековните карактер на тековната аргумент,

68
00:06:05,000 --> 00:06:13,000
е:% в, за тековната карактер во аргументот.

69
00:06:13,000 --> 00:06:20,000
И на крај, ние обезбеди printf со индекс на надворешниот циклус, јас,

70
00:06:20,000 --> 00:06:22,000
потоа индексот на внатрешната јамка.

71
00:06:22,000 --> 00:06:28,000
>> И нашиот последен аргумент за printf е вистински лик од аргументи, под услов

72
00:06:28,000 --> 00:06:31,000
на командната линија.

73
00:06:31,000 --> 00:06:37,000
Сега, бидејќи јас се користи низа функција strlen да се добие на должина на стринг,

74
00:06:37,000 --> 00:06:43,000
Јас, исто така треба да додадете string.h библиотека на врвот на нашата вклучува.

75
00:06:43,000 --> 00:06:50,000
Значи, да го сторат тоа, ќе одат нагоре, и само под stdio.h, ние ќе треба да се направи

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

77
00:06:57,000 --> 00:07:02,000
>> Значи, ајде да ги собере и да ја стартувате и ги обезбеди вистински аргумент.

78
00:07:09,000 --> 00:07:18,000
>> И, како што можеме да видиме, сега имаме точната локација на секој поединец знак на аргумент.

79
00:07:18,000 --> 00:07:23,000
Значи тоа е тоа. Јас сум Кристофер Вартоломеј, тоа е CS50.

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