1
00:00:00,000 --> 00:00:02,000
[Powered by Google Translate] [Komentoriviargumenteista]

2
00:00:02,000 --> 00:00:04,000
[Christopher Bartholomew - Harvardin yliopisto]

3
00:00:04,000 --> 00:00:07,000
[Tämä on CS50 - CS50.TV]

4
00:00:07,000 --> 00:00:11,000
Hyödyllinen ominaisuus ohjelmassa on hyväksyä käyttäjä syöttää.

5
00:00:11,000 --> 00:00:15,000
Toistaiseksi olemme tutkitaan joitakin tehtäviä CS50 kirjastossa

6
00:00:15,000 --> 00:00:18,000
hyväksymään käyttäjän syötettä, kuten "saada merkkijono"

7
00:00:18,000 --> 00:00:23,000
joka kysyy käyttäjältä, kun sovellus on käynnissä, ja merkkijono.

8
00:00:23,000 --> 00:00:28,000
>> On kuitenkin tapauksia, joissa haluat antaa oman ohjelmasyöte

9
00:00:28,000 --> 00:00:30,000
ennen kuin se on käynnissä.

10
00:00:30,000 --> 00:00:34,000
Näin sinun ei tarvitse kysyä lisätietoja käyttäjän

11
00:00:34,000 --> 00:00:38,000
suoritettaessa yksinkertainen tehtävä.

12
00:00:38,000 --> 00:00:42,000
Otetaan esimerkiksi mv tai siirtää komento UNIX.

13
00:00:42,000 --> 00:00:49,000
Tämä komento sallii käyttäjän siirtää tiedoston yhdestä paikasta toiseen.

14
00:00:49,000 --> 00:00:55,000
Mukaan ohjesivuja, mv hyväksyy kaksi komentoriviargumentteja:

15
00:00:55,000 --> 00:01:00,000
tiedosto on siirretty ja paikka tiedosto on siirretty.

16
00:01:00,000 --> 00:01:06,000
Joten tässä esimerkissä on komennon kaksi argumenttia.

17
00:01:06,000 --> 00:01:14,000
Miten siis kertoa C-ohjelma käyttää näitä komentorivin argumentteja?

18
00:01:14,000 --> 00:01:20,000
>> No, näyttää siltä, ​​että tärkeimmät, jota käytämme kaikissa C-ohjelmissa, on salaisuus.

19
00:01:20,000 --> 00:01:26,000
Tärkeimmät hyväksyy kaksi parametria: argc ja argv.

20
00:01:26,000 --> 00:01:28,000
Mennään yli nämä ehdot.

21
00:01:28,000 --> 00:01:33,000
>> Ensimmäinen parametri, argc, joka on lyhenne sanoista argumentti count,

22
00:01:33,000 --> 00:01:36,000
on tietotyyppi kokonaisluku.

23
00:01:36,000 --> 00:01:42,000
Argc parametri sisältää useita väitteitä, kuten komentoa.

24
00:01:42,000 --> 00:01:47,000
Meidän Siirrä-komennon, vaikka meillä on vain kaksi argumenttia näkyvissä,

25
00:01:47,000 --> 00:01:50,000
argc arvo on 3.

26
00:01:50,000 --> 00:01:56,000
Toinen parametri, argv, joka on lyhenne sanoista argumentti vektori,

27
00:01:56,000 --> 00:02:01,000
on joukko char osoittimia, jotka osoittavat merkkijonoja.

28
00:02:01,000 --> 00:02:06,000
>> Tämä tarkoittaa, että jokaisen elementin argv, aloitetaan nollasta,

29
00:02:06,000 --> 00:02:09,000
sisältää komennon ja argumentteja.

30
00:02:09,000 --> 00:02:16,000
Esimerkiksi argv [0], joka Kutsun kuin argv nolla,

31
00:02:16,000 --> 00:02:20,000
sisältää aina komento ajetaan -

32
00:02:20,000 --> 00:02:22,000
tässä tapauksessa, mv.

33
00:02:22,000 --> 00:02:28,000
argv [1] sisältää ensimmäisen väitteen, tiedosto.txt,

34
00:02:28,000 --> 00:02:37,000
ja argv [2] sisältää toisen väitteen, ~ / cs50 /.

35
00:02:37,000 --> 00:02:42,000
Viimeinen väite argv aina nolla.

36
00:02:42,000 --> 00:02:46,000
Joten toteuttamaan näitä komentorivin argumentteja.

37
00:02:46,000 --> 00:02:53,000
Aiemmissa harjoituksissa, otimme mitätön, eli ei mitään, koska tärkein parametri.

38
00:02:53,000 --> 00:02:57,000
Kuitenkin, jotta voimme käyttää komentorivin argumentteja,

39
00:02:57,000 --> 00:03:12,000
Meidän täytyy poistaa mitättömäksi ja paikka sisällä tärkeimpien int argc, char * argv [].

40
00:03:12,000 --> 00:03:17,000
Nyt, käyttää koko elementti argv, jotka ovat teidän argumentteja,

41
00:03:17,000 --> 00:03:21,000
voit toistaa tai silmukan läpi array näin.

42
00:03:21,000 --> 00:03:27,000
Joten sisällä tärkeimpien kehon, aiomme mennä eteenpäin ja kirjoita varten silmukka:

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
>> Emme tarvitse kihara ahdin tänne, koska olemme vain suorittamalla yksi rivi koodia

45
00:03:41,000 --> 00:03:44,000
kehossa tämän silmukan.

46
00:03:44,000 --> 00:03:47,000
Menemme eteenpäin ja osui välilehti kerran,

47
00:03:47,000 --> 00:03:57,000
kirjoita printf ("argv [% d], edustaa kokonaisluku,

48
00:03:57,000 --> 00:04:06,000
on% s, jousikvartetille, sitten uusi rivi merkki.

49
00:04:06,000 --> 00:04:12,000
Sitten me tarjota printf i nykyistä iteraatiota varten silmukka-

50
00:04:12,000 --> 00:04:18,000
ja argv [i] merkkijono edustus nykyisen komentorivin argumentti.

51
00:04:18,000 --> 00:04:25,000
Kun ajaa sen kaksi perustelua, näemme perustelut näytetään päätelaitteessa.

52
00:04:34,000 --> 00:04:38,000
Aiemmin kerroimme, että argv hallussa joukko char osoittimia.

53
00:04:38,000 --> 00:04:45,000
>> Joten, jos näin on, miten voimme sitten käyttää yksittäisiä merkkejä jokaiselle argumentille?

54
00:04:45,000 --> 00:04:51,000
Esimerkiksi, mitä jos halusin etsiä erityisluonnetta ensimmäisen argumentin?

55
00:04:51,000 --> 00:04:55,000
No, vastaus on, että meidän on sovellettava sisäkkäisen silmukan

56
00:04:55,000 --> 00:04:59,000
, joka sitten iteroidaan läpi kunkin elementtien argumentti merkkijono.

57
00:04:59,000 --> 00:05:02,000
Näin teet sen.

58
00:05:02,000 --> 00:05:10,000
>> Ensinnäkin, me aiomme tehdä kopion example2.c.

59
00:05:10,000 --> 00:05:13,000
Sitten sisällä ensin silmukka,

60
00:05:13,000 --> 00:05:15,000
aiomme lisätä ylimääräistä varten silmukka.

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

62
00:05:28,000 --> 00:05:32,000
joka sitten antaa meille pituus nykyisen väite,

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

64
00:05:39,000 --> 00:05:43,000
Menemme tulostaa sijainnin kunkin merkin

65
00:05:43,000 --> 00:05:47,000
sisällä nykyisen väitteen käyttämällä printf.

66
00:05:47,000 --> 00:05:57,000
Niin, printf ("argv [% d], edustaa indeksi nykyisen väite,

67
00:05:57,000 --> 00:06:05,000
sitten [% d] jälleen edustamaan nykyistä luonnetta nykyisen väitteen,

68
00:06:05,000 --> 00:06:13,000
on:% C, nykyisen merkin argumentti.

69
00:06:13,000 --> 00:06:20,000
Lopuksi, tarjoamme printf kanssa indeksi ulomman silmukan, i,

70
00:06:20,000 --> 00:06:22,000
Sitten indeksi sisemmän silmukan.

71
00:06:22,000 --> 00:06:28,000
>> Ja viimeinen argumentti printf on todellinen hahmo perustelua,

72
00:06:28,000 --> 00:06:31,000
komentoriviltä.

73
00:06:31,000 --> 00:06:37,000
Nyt, koska käytin merkkijono strlen saada pituus merkkijono,

74
00:06:37,000 --> 00:06:43,000
Minun on myös lisätä string.h kirjaston alkuun meidän kuuluu.

75
00:06:43,000 --> 00:06:50,000
Joten, tehdä, että me menemme ylös, ja vajaat stdio.h, aiomme tehdä

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

77
00:06:57,000 --> 00:07:02,000
>> Joten, nyt kääntää ja ajaa ja antaa se todellinen argumentti.

78
00:07:09,000 --> 00:07:18,000
>> Ja kuten näemme, meillä on nyt tarkka sijainti kunkin nieriää argumentti.

79
00:07:18,000 --> 00:07:23,000
Joten se siitä. Olen Christopher Bartolomeus, tämä on CS50.

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