1
00:00:00,000 --> 00:00:02,000
[Powered by Google Translate] [Command-line argumenten]

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

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

4
00:00:07,000 --> 00:00:11,000
Een handige functie voor een programma is om te accepteren input van de gebruiker.

5
00:00:11,000 --> 00:00:15,000
Tot nu toe hebben we verkend enkele functies binnen de CS50 bibliotheek

6
00:00:15,000 --> 00:00:18,000
om invoer van de gebruiker, zoals accepteren "get string,"

7
00:00:18,000 --> 00:00:23,000
die vraagt ​​de gebruiker, terwijl de toepassing wordt uitgevoerd, voor een string.

8
00:00:23,000 --> 00:00:28,000
>> Er zijn echter gevallen waarin u uw programma input te leveren

9
00:00:28,000 --> 00:00:30,000
voordat het daadwerkelijk draait.

10
00:00:30,000 --> 00:00:34,000
Op deze manier hoeft u niet om aanvullende informatie te vragen bij uw gebruiker

11
00:00:34,000 --> 00:00:38,000
tijdens het uitvoeren van een eenvoudige taak.

12
00:00:38,000 --> 00:00:42,000
Neem, bijvoorbeeld, de mv of verplaatsen commando in UNIX.

13
00:00:42,000 --> 00:00:49,000
Dit commando kan de gebruiker een bestand verplaatst van een locatie naar de andere.

14
00:00:49,000 --> 00:00:55,000
Volgens de manual pagina's, mv accepteert twee argumenten op de opdrachtregel

15
00:00:55,000 --> 00:01:00,000
het bestand dat wordt verplaatst en de locatie van het bestand wordt verplaatst naar.

16
00:01:00,000 --> 00:01:06,000
Dus dit voorbeeld heeft een opdracht met twee argumenten.

17
00:01:06,000 --> 00:01:14,000
Dus hoe vertellen we onze C-programma om deze command-line argumenten te gebruiken?

18
00:01:14,000 --> 00:01:20,000
>> Nou, het blijkt dat de belangrijkste, die we gebruiken in alle C-programma's, een geheim heeft.

19
00:01:20,000 --> 00:01:26,000
Belangrijkste accepteert twee parameters: argc en argv.

20
00:01:26,000 --> 00:01:28,000
Laten we gaan over deze voorwaarden.

21
00:01:28,000 --> 00:01:33,000
>> De eerste parameter, argc, wat staat voor argument tellen,

22
00:01:33,000 --> 00:01:36,000
een gegevenstype integer.

23
00:01:36,000 --> 00:01:42,000
De argc parameter bevat het aantal argumenten, met inbegrip van de opdracht.

24
00:01:42,000 --> 00:01:47,000
In onze verhuizing commando, hoewel we alleen hebben twee argumenten weergegeven,

25
00:01:47,000 --> 00:01:50,000
argc waarde zal 3.

26
00:01:50,000 --> 00:01:56,000
De tweede parameter, argv, wat staat voor argument vector,

27
00:01:56,000 --> 00:02:01,000
is een array van char pointers die wijzen op strings.

28
00:02:01,000 --> 00:02:06,000
>> Dit betekent dat elk element in argv, beginnend bij nul,

29
00:02:06,000 --> 00:02:09,000
bevat de opdracht en argumenten.

30
00:02:09,000 --> 00:02:16,000
Bijvoorbeeld, argv [0], die ik zal aanduiden als argv nul,

31
00:02:16,000 --> 00:02:20,000
bevat altijd de opdracht die wordt uitgevoerd -

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

33
00:02:22,000 --> 00:02:28,000
argv [1] bevat het eerste argument, bestand.txt,

34
00:02:28,000 --> 00:02:37,000
en argv [2] zal het tweede argument bevat, ~ / CS50 /.

35
00:02:37,000 --> 00:02:42,000
De laatste argument van argv altijd null.

36
00:02:42,000 --> 00:02:46,000
Dus laten we de uitvoering van deze command-line argumenten.

37
00:02:46,000 --> 00:02:53,000
In de vorige oefeningen, plaatsten we leegte, wat betekent niets, als parameter de belangrijkste is.

38
00:02:53,000 --> 00:02:57,000
Echter, om voor ons om command-line argumenten te gebruiken,

39
00:02:57,000 --> 00:03:12,000
we moeten vervallen en plaats binnen van de belangrijkste int argc, char * argv [] te verwijderen.

40
00:03:12,000 --> 00:03:17,000
Nu, om de hele element argv, die zijn uw argumenten te openen,

41
00:03:17,000 --> 00:03:21,000
u kunt gewoon herhalen, of lus, door middel van de array als deze.

42
00:03:21,000 --> 00:03:27,000
Dus, de binnenkant van het lichaam de belangrijkste is, we gaan om verder te gaan en een type voor lus:

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
>> We hebben hier behoefte aan een accolade omdat we alleen het uitvoeren van een regel code

45
00:03:41,000 --> 00:03:44,000
in het lichaam van deze lus.

46
00:03:44,000 --> 00:03:47,000
We zullen verder gaan en een keer raken tab,

47
00:03:47,000 --> 00:03:57,000
then printf typ ("argv [% d], naar een geheel getal vertegenwoordigen,

48
00:03:57,000 --> 00:04:06,000
is% s, voor strijkkwartet, dan is de nieuwe regel.

49
00:04:06,000 --> 00:04:12,000
Dan bieden wij printf i voor de huidige iteratie van de lus

50
00:04:12,000 --> 00:04:18,000
en argv [i] voor de tekenreeksweergave van de huidige command-line argument.

51
00:04:18,000 --> 00:04:25,000
Wanneer we het uit te voeren met twee argumenten, dan zien we de argumenten wordt weergegeven in de terminal.

52
00:04:34,000 --> 00:04:38,000
Eerder hebben we gezegd dat de argv een array van char pointers gehouden.

53
00:04:38,000 --> 00:04:45,000
>> Dus, als dit het geval is, hoe kunnen we dan toegang tot afzonderlijke tekens in elk argument?

54
00:04:45,000 --> 00:04:51,000
Bijvoorbeeld, wat als ik wilde om te zoeken naar een specifiek karakter in het eerste argument?

55
00:04:51,000 --> 00:04:55,000
Nou, het antwoord is dat we nodig hebben om een ​​geneste lus toe te passen

56
00:04:55,000 --> 00:04:59,000
die dan doorlopen elk van de elementen in de argumentstring.

57
00:04:59,000 --> 00:05:02,000
Dit is hoe je het doet.

58
00:05:02,000 --> 00:05:10,000
>> Ten eerste, we gaan een kopie van example2.c te maken.

59
00:05:10,000 --> 00:05:13,000
Dan, de binnenkant van de eerste for-lus,

60
00:05:13,000 --> 00:05:15,000
we gaan om een ​​extra lus toe te voegen.

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

62
00:05:28,000 --> 00:05:32,000
die geeft ons dan de lengte van de huidige argument,

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

64
00:05:39,000 --> 00:05:43,000
We gaan naar de locatie van elk karakter af te drukken

65
00:05:43,000 --> 00:05:47,000
binnenkant van de huidige argument door het gebruik van printf.

66
00:05:47,000 --> 00:05:57,000
Dus, printf ("argv [% d], de index van de huidige argument vertegenwoordigen,

67
00:05:57,000 --> 00:06:05,000
vervolgens op [% d] nogmaals, om de huidige karakter van het huidige argument vertegenwoordigen,

68
00:06:05,000 --> 00:06:13,000
is:% c, voor de huidige karakter in het argument.

69
00:06:13,000 --> 00:06:20,000
Tot slot bieden we printf met de index van de buitenste lus, i,

70
00:06:20,000 --> 00:06:22,000
dan de index van de binnenste lus.

71
00:06:22,000 --> 00:06:28,000
>> En onze laatste argument van printf is het werkelijke karakter van de verstrekte argument

72
00:06:28,000 --> 00:06:31,000
op de opdrachtregel.

73
00:06:31,000 --> 00:06:37,000
Nu, omdat ik de string functie strlen om de lengte van een string te verkrijgen,

74
00:06:37,000 --> 00:06:43,000
Ik moet de string.h bibliotheek ook toevoegen aan de top van onze omvat.

75
00:06:43,000 --> 00:06:50,000
Dus, om dat te doen, zullen we omhoog gaan, en iets minder dan stdio.h, we gaan doen

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

77
00:06:57,000 --> 00:07:02,000
>> Dus, laten we samen te stellen en uit te voeren en verstrekt haar een echte argument.

78
00:07:09,000 --> 00:07:18,000
>> En, zoals we kunnen zien, hebben we nu de exacte locatie van elk individu char in het argument.

79
00:07:18,000 --> 00:07:23,000
Dus dat is het. Ik ben Christopher Bartholomeus, dit is CS50.

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