1
00:00:00,000 --> 00:00:02,000
[Powered by Google Translate] [Komando-lerroko argumentuak]

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

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

4
00:00:07,000 --> 00:00:11,000
Ezaugarri erabilgarria da programa bat user input onartu.

5
00:00:11,000 --> 00:00:15,000
Beraz, oraingoz, esploratu dugu zenbait funtzio CS50 liburutegi barruan

6
00:00:15,000 --> 00:00:18,000
erabiltzailearen sarrera onartu, esate baterako, "katea"

7
00:00:18,000 --> 00:00:23,000
Erabiltzaile eskatuz, aplikazioa exekutatzen ari den bitartean, kate bat.

8
00:00:23,000 --> 00:00:28,000
>> Hala eta guztiz ere, ez dira kasu non eman nahi duzu zure programa sarrera

9
00:00:28,000 --> 00:00:30,000
da benetan aurretik exekutatzen ari da.

10
00:00:30,000 --> 00:00:34,000
Horrela, behar ez baduzu, zure erabiltzaile-informazio gehigarria eskatu

11
00:00:34,000 --> 00:00:38,000
exekutatzean erraza.

12
00:00:38,000 --> 00:00:42,000
Hartu, adibidez, UNIX komando mv edo mugitu.

13
00:00:42,000 --> 00:00:49,000
Komando honek fitxategi bat kokapen batetik bestera mugitzeko aukera ematen dio erabiltzaileari.

14
00:00:49,000 --> 00:00:55,000
Eskuzko orrien arabera, mv bi komando-lerroko argumentu onartzen ditu:

15
00:00:55,000 --> 00:01:00,000
fitxategia mugitu ari den eta kokapena fitxategi ari da mugitu.

16
00:01:00,000 --> 00:01:06,000
Beraz, adibide honetan bi argumentuak komando bat dauka.

17
00:01:06,000 --> 00:01:14,000
Beraz, nola ez, gure C programa esango dugu, komando-lerroko argumentu horiek erabili ahal izateko?

18
00:01:14,000 --> 00:01:20,000
>> Beno, bihurtzen da nagusia, C programa guztietan erabiltzen dugu, sekretu bat du.

19
00:01:20,000 --> 00:01:26,000
Main bi parametro onartzen ditu: argc eta argv.

20
00:01:26,000 --> 00:01:28,000
Dezagun baldintza hauetan.

21
00:01:28,000 --> 00:01:33,000
>> Lehenengo parametroa, argc, argumentu Aldaketa dago,

22
00:01:33,000 --> 00:01:36,000
guztia datu mota bat du.

23
00:01:36,000 --> 00:01:42,000
Argc parametroak argumentu kopurua, komando hau barne.

24
00:01:42,000 --> 00:01:47,000
Gure mugimendua komandoa, besterik ez dugu, nahiz eta bi argumentu hartzen ditu "bistaratuko,

25
00:01:47,000 --> 00:01:50,000
argc balioa 3 izango da.

26
00:01:50,000 --> 00:01:56,000
Bigarren parametroa, argv, bektorearen argumentuan dago,

27
00:01:56,000 --> 00:02:01,000
kateak seinalatu erakusleak char array bat da.

28
00:02:01,000 --> 00:02:06,000
>> Horrek esan nahi du argv elementu bakoitzean, zero hasita,

29
00:02:06,000 --> 00:02:09,000
komandoa eta argumentuak ez dauka.

30
00:02:09,000 --> 00:02:16,000
Esate baterako, argv [0], argv zero jo dut erreferentzia,

31
00:02:16,000 --> 00:02:20,000
beti izango du ari den komandoa exekutatu

32
00:02:20,000 --> 00:02:22,000
Kasu honetan, mv.

33
00:02:22,000 --> 00:02:28,000
argv [1] Lehen argumentua, file.txt edukiko du,

34
00:02:28,000 --> 00:02:37,000
eta argv [2] bigarren argumentua edukiko du, ~ / cs50 /.

35
00:02:37,000 --> 00:02:42,000
Argv azken argumentua null izango da beti.

36
00:02:42,000 --> 00:02:46,000
Beraz, dezagun komando-lerroko argumentu horiek ezartzeko.

37
00:02:46,000 --> 00:02:53,000
Ariketak aurreko, void jarri dugu, ez da ezer zentzua, nagusia bere parametro gisa.

38
00:02:53,000 --> 00:02:57,000
Dena den, komando-lerroko argumentuak erabili,

39
00:02:57,000 --> 00:03:12,000
void eta leku nagusia int argc, char * argv [] barrutik kendu behar dugu.

40
00:03:12,000 --> 00:03:17,000
Orain, argv elementu osoa, zure argumentuak diren sartzeko,

41
00:03:17,000 --> 00:03:21,000
nahikoa duzu batetik bestera joateko, edo begizta hau atsegin array bidez.

42
00:03:21,000 --> 00:03:27,000
Beraz, nagusia gorputzaren barruan, aurrera joan eta idatzi begizta ari gara:

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
>> Ez dugu behar kizkur giltza hemen ari gara soilik kode lerro bat exekutatzean

45
00:03:41,000 --> 00:03:44,000
begizta honen gorputzaren barruan.

46
00:03:44,000 --> 00:03:47,000
Aurrera jarraituko dugu eta fitxa hit behin,

47
00:03:47,000 --> 00:03:57,000
ondoren, idatzi printf ("argv [% d], osoko balioa,

48
00:03:57,000 --> 00:04:06,000
% s da, katea, ondoren lerro berria karakterea.

49
00:04:06,000 --> 00:04:12,000
Orduan printf eskaintzen dugu i Begizta uneko iterazio

50
00:04:12,000 --> 00:04:18,000
eta argv [i] komando-lerroko uneko argumentua katea ordezkaritza.

51
00:04:18,000 --> 00:04:25,000
Noiz exekutatu dugu bi argumentu hartzen, terminalean ari bistaratuko argumentuak ikusiko dugu.

52
00:04:34,000 --> 00:04:38,000
Lehenago argv Lekua: erakusleak char array bat dela esan genuen.

53
00:04:38,000 --> 00:04:45,000
>> Beraz, kasu honetan, bada, nola ez sartzeko dugu argumentu bakoitzeko banakako pertsonaiak?

54
00:04:45,000 --> 00:04:51,000
Esate baterako, zer nahi izanez gero, lehen argumentua karaktere jakin bat bilatzeko?

55
00:04:51,000 --> 00:04:55,000
Beno, erantzun behar dugu habiaratua begizta bat aplikatzeko

56
00:04:55,000 --> 00:04:59,000
gero argumentu katea elementu bakoitzean zehar batetik bestera joateko.

57
00:04:59,000 --> 00:05:02,000
Hau da, nola egiten duzun.

58
00:05:02,000 --> 00:05:10,000
>> Lehenik eta behin, example2.c kopia bat egin dugu.

59
00:05:10,000 --> 00:05:13,000
Gero, barruan loop lehen,

60
00:05:13,000 --> 00:05:15,000
loop bat gehitu dugu.

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

62
00:05:28,000 --> 00:05:32,000
eta gero ematen digu argumentua uneko luzera

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

64
00:05:39,000 --> 00:05:43,000
Pertsonaia bakoitzaren kokapena inprimatu ari gara

65
00:05:43,000 --> 00:05:47,000
printf erabiliz uneko argumentua barruan.

66
00:05:47,000 --> 00:05:57,000
Beraz, printf ("argv [% d], uneko argumentua indizea adierazteko,

67
00:05:57,000 --> 00:06:05,000
ondoren [% d] berriro ere, uneko argumentua uneko izaera adierazteko,

68
00:06:05,000 --> 00:06:13,000
hau da:% c, argumentua uneko pertsonaia.

69
00:06:13,000 --> 00:06:20,000
Azkenik, kanpoko begizta indizea printf eskaintzen dugu, i,

70
00:06:20,000 --> 00:06:22,000
ondoren barruko loop indizea.

71
00:06:22,000 --> 00:06:28,000
>> Eta gure azken argumentua printf emandako argumentu benetako pertsonaia da

72
00:06:28,000 --> 00:06:31,000
komando-lerroan.

73
00:06:31,000 --> 00:06:37,000
Orain, kate funtzioa strlen erabili dut kate baten luzera lortzeko delako,

74
00:06:37,000 --> 00:06:43,000
Gure barne goiko string.h liburutegia ere gehitu behar dut.

75
00:06:43,000 --> 00:06:50,000
Beraz, horretarako, igo dugu, eta besterik ez stdio.h, ez goaz

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

77
00:06:57,000 --> 00:07:02,000
>> Beraz, dezagun konpilatu eta exekutatu eta benetako argumentu bat ematen.

78
00:07:09,000 --> 00:07:18,000
>> Eta, ikusiko dugun bezala, gaur egun bakoitzak karakterra argumentua kokapena zehatza.

79
00:07:18,000 --> 00:07:23,000
Beraz, hori da. Christopher Bartolomé naiz, hau da, CS50.

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