1
00:00:00,000 --> 00:00:02,000
[Powered by Google Translate] [Command-Line Argumente]

2
00:00:02,000 --> 00:00:04,000
[Christopher Bartholomew - Harvard Universiteit]

3
00:00:04,000 --> 00:00:07,000
[Hierdie is CS50 - CS50.TV]

4
00:00:07,000 --> 00:00:11,000
'N nuttige funksie vir 'n program is om die toevoer van die gebruiker te aanvaar.

5
00:00:11,000 --> 00:00:15,000
So ver, het ons ondersoek sommige funksies binne die CS50 biblioteek

6
00:00:15,000 --> 00:00:18,000
toevoer van die gebruiker, soos om te aanvaar "kry string,"

7
00:00:18,000 --> 00:00:23,000
wat vra die gebruiker, terwyl die aansoek hardloop, vir 'n string.

8
00:00:23,000 --> 00:00:28,000
>> Egter, is daar gevalle waar jy wil jou program om insette te lewer

9
00:00:28,000 --> 00:00:30,000
voordat dit is eintlik hardloop.

10
00:00:30,000 --> 00:00:34,000
Op hierdie manier, het jy nie nodig om addisionele inligting te vra van jou gebruiker

11
00:00:34,000 --> 00:00:38,000
terwyl die uitvoering van 'n eenvoudige taak nie.

12
00:00:38,000 --> 00:00:42,000
Neem, byvoorbeeld, die MV of skuif opdrag in UNIX.

13
00:00:42,000 --> 00:00:49,000
Hierdie opdrag stel die gebruiker in staat om 'n lêer van een plek na 'n ander te beweeg.

14
00:00:49,000 --> 00:00:55,000
Volgens die handleiding bladsye, mv twee command line argumente aanvaar:

15
00:00:55,000 --> 00:01:00,000
die lêer wat verskuif word en die plek waar die lêer is verskuif na.

16
00:01:00,000 --> 00:01:06,000
So is hierdie voorbeeld het 'n opdrag met twee argumente.

17
00:01:06,000 --> 00:01:14,000
So hoe weet ons ons C program hierdie command-line argumente aan te wend?

18
00:01:14,000 --> 00:01:20,000
>> Wel, dit blyk dat die hoof, wat ons in al die C-programme gebruik, het 'n geheim.

19
00:01:20,000 --> 00:01:26,000
Main twee parameters: argc en bevat SPASIES aanvaar.

20
00:01:26,000 --> 00:01:28,000
Kom ons gaan oor hierdie terme.

21
00:01:28,000 --> 00:01:33,000
>> Die eerste parameter, argc, wat staan ​​vir die argument telling,

22
00:01:33,000 --> 00:01:36,000
het 'n data tipe integer.

23
00:01:36,000 --> 00:01:42,000
Die argc parameter bevat die aantal argumente, met inbegrip van die opdrag.

24
00:01:42,000 --> 00:01:47,000
In ons skuif opdrag, maar ons het net twee argumente vertoon,

25
00:01:47,000 --> 00:01:50,000
argc se waarde sal wees 3.

26
00:01:50,000 --> 00:01:56,000
Die tweede parameter bevat SPASIES, wat staan ​​vir die argument vektor,

27
00:01:56,000 --> 00:02:01,000
is 'n verskeidenheid van char verwysings wat verwys na snare.

28
00:02:01,000 --> 00:02:06,000
>> Dit beteken dat elke element bevat SPASIES, vanaf nul,

29
00:02:06,000 --> 00:02:09,000
bevat die opdrag en argumente.

30
00:02:09,000 --> 00:02:16,000
Byvoorbeeld, bevat SPASIES [0], wat ek sal verwys as bevat SPASIES nul,

31
00:02:16,000 --> 00:02:20,000
sal bevat altyd die opdrag wat loop -

32
00:02:20,000 --> 00:02:22,000
in hierdie geval, mv.

33
00:02:22,000 --> 00:02:28,000
bevat SPASIES [1] sal die eerste argument, file.txt,

34
00:02:28,000 --> 00:02:37,000
en bevat SPASIES [2] sal die tweede argument bevat, ~ / cs50 /.

35
00:02:37,000 --> 00:02:42,000
Die laaste argument bevat SPASIES sal altyd null.

36
00:02:42,000 --> 00:02:46,000
So laat hierdie command-line argumente implementeer.

37
00:02:46,000 --> 00:02:53,000
In die vorige oefeninge, ons geplaas nietig, beteken niks, as hoof se parameter.

38
00:02:53,000 --> 00:02:57,000
Maar, ten einde vir ons opdrag-lyn argumente te gebruik,

39
00:02:57,000 --> 00:03:12,000
moet ons nietig en plek binnekant van die belangrikste int argc, char * bevat SPASIES [] te verwyder.

40
00:03:12,000 --> 00:03:17,000
Nou, om toegang te verkry tot die hele element van bevat SPASIES, wat is jou argumente,

41
00:03:17,000 --> 00:03:21,000
Jy kan eenvoudig iteraat, of lus, deur die skikking soos hierdie.

42
00:03:21,000 --> 00:03:27,000
So, binnekant van hoof se liggaam, ons gaan om voort te gaan en 'n soort vir 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
>> Ons hoef nie 'n krullerige brace hier omdat ons net een lyn van kode uitvoering

45
00:03:41,000 --> 00:03:44,000
binne die liggaam van hierdie lus.

46
00:03:44,000 --> 00:03:47,000
Ons sal voort te gaan en druk tab een keer,

47
00:03:47,000 --> 00:03:57,000
dan tik printf ("bevat SPASIES [% d] 'n heelgetal waarde te verteenwoordig,

48
00:03:57,000 --> 00:04:06,000
% s is, string, dan die nuwe lyn karakter.

49
00:04:06,000 --> 00:04:12,000
Dan bied ons printf i vir die huidige iterasie van die lus

50
00:04:12,000 --> 00:04:18,000
en bevat SPASIES [i] vir die string voorstelling van die huidige command-line argument.

51
00:04:18,000 --> 00:04:25,000
Wanneer ons loop dit met twee argumente, sal ons sien die argumente in die terminale vertoon word.

52
00:04:34,000 --> 00:04:38,000
Vroeër het ons gesê dat die bevat SPASIES 'n verskeidenheid van char pointers gehou.

53
00:04:38,000 --> 00:04:45,000
>> So, as dit die geval is, hoe kan ons dan toegang tot individuele karakters in elke argument?

54
00:04:45,000 --> 00:04:51,000
Byvoorbeeld, wat as ek wil om te kyk vir 'n spesifieke karakter in die eerste argument?

55
00:04:51,000 --> 00:04:55,000
Wel, die antwoord is wat ons nodig het om 'n geneste lus om aansoek te doen

56
00:04:55,000 --> 00:04:59,000
wat sal dan itereer deur elk van die elemente in die argument string.

57
00:04:59,000 --> 00:05:02,000
Dit is hoe jy dit doen.

58
00:05:02,000 --> 00:05:10,000
>> Eerste, gaan ons 'n afskrif van example2.c te maak.

59
00:05:10,000 --> 00:05:13,000
Dan, binnekant van die eerste lus,

60
00:05:13,000 --> 00:05:15,000
ons gaan 'n bykomende lus te voeg.

61
00:05:15,000 --> 00:05:28,000
Dus, vir (int j = 0, n = strlen (bevat SPASIES [i]),

62
00:05:28,000 --> 00:05:32,000
wat gee dan vir ons die lengte van die huidige argument,

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

64
00:05:39,000 --> 00:05:43,000
Ons gaan die plek van elke karakter te druk

65
00:05:43,000 --> 00:05:47,000
binnekant van die huidige argument deur die gebruik van printf.

66
00:05:47,000 --> 00:05:57,000
So, printf ("bevat SPASIES [% d], die indeks van die huidige argument voor te stel,

67
00:05:57,000 --> 00:06:05,000
[% d] weer, die huidige karakter van die huidige argument voor te stel,

68
00:06:05,000 --> 00:06:13,000
is:% c, vir die huidige karakter in die argument.

69
00:06:13,000 --> 00:06:20,000
Ten slotte, ons bied printf met die indeks van die buitenste lus, i,

70
00:06:20,000 --> 00:06:22,000
dan is die indeks van die binneste lus.

71
00:06:22,000 --> 00:06:28,000
>> En ons laaste argument is printf die werklike karakter van die argument wat voorsien word

72
00:06:28,000 --> 00:06:31,000
op die command line.

73
00:06:31,000 --> 00:06:37,000
Nou, omdat ek die string funksie strlen gebruik om die lengte van 'n string te verkry,

74
00:06:37,000 --> 00:06:43,000
Ek moet ook voeg die string.h biblioteek na die top van ons sluit.

75
00:06:43,000 --> 00:06:50,000
So, om dit te doen, sal ons optrek, en net onder stdio.h, ons gaan om dit te doen

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

77
00:06:57,000 --> 00:07:02,000
>> So, kom ons stel en uit te voer en gee dit 'n werklike argument.

78
00:07:09,000 --> 00:07:18,000
>> En, soos ons kan sien, het ons nou die presiese ligging van elke karakter in die argument.

79
00:07:18,000 --> 00:07:23,000
So dit is dit. Ek is Christopher Bartholomew, dit is CS50.

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