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
მიიღოს მომხმარებლის input, როგორიცაა "Get სიმებიანი,"

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
არის მასივი char პოინტერები რომ წერტილი სტრიქონები.

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
მაგალითად, argv [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
argv [1] შეიცავს პირველი არგუმენტი, file.txt,

34
00:02:28,000 --> 00:02:37,000
და argv [2] შეიცავს მეორე არგუმენტი, ~ / cs50 /.

35
00:02:37,000 --> 00:02:42,000
ბოლო არგუმენტი argv ყოველთვის იქნება null.

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 * argv [].

40
00:03:12,000 --> 00:03:17,000
ახლა, რათა შეამოწმონ მთელი ელემენტს საწყისი argv, რომლებიც თქვენი არგუმენტები,

41
00:03:17,000 --> 00:03:21,000
შეგიძლიათ უბრალოდ iterate, ან loop მეშვეობით მასივი მოსწონს ეს.

42
00:03:21,000 --> 00:03:27,000
ასე რომ, შიგნით ძირითადი სხეული, ჩვენ ვაპირებთ წავიდეთ წინ და ტიპის ამისთვის loop:

43
00:03:27,000 --> 00:03:37,000
ამისთვის (int i = 0; i <argc, მე + +).

44
00:03:37,000 --> 00:03:41,000
>> ჩვენ არ გვჭირდება Curly გაუწიოს აქ იმიტომ რომ ჩვენ მხოლოდ შესრულებაში ერთი ხაზი კოდი

45
00:03:41,000 --> 00:03:44,000
ფარგლებში ორგანოს ამ loop.

46
00:03:44,000 --> 00:03:47,000
ჩვენ წავიდეთ წინ და მოხვდა tab ერთხელ,

47
00:03:47,000 --> 00:03:57,000
აკრიფეთ printf ("argv [% d], წარმოადგინოს მთელი ღირებულება,

48
00:03:57,000 --> 00:04:06,000
არის% s, სიმებიანი, მაშინ ახალი ხაზი ხასიათი.

49
00:04:06,000 --> 00:04:12,000
მაშინ ჩვენ უზრუნველყოფს printf მე მიმდინარე iteration of loop

50
00:04:12,000 --> 00:04:18,000
და argv [i] ამისთვის სიმებიანი წარმომადგენლობა მიმდინარე ბრძანება ხაზი არგუმენტი.

51
00:04:18,000 --> 00:04:25,000
როდესაც ჩვენ გაუშვით ორი არგუმენტები, ვნახავთ არგუმენტები მიმდინარეობს ნაჩვენები ტერმინალში.

52
00:04:34,000 --> 00:04:38,000
მანამდე ჩვენ განაცხადა, რომ argv გაიმართა მასივი char პოინტერები.

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
ისე, პასუხი არის, რომ ჩვენ უნდა მიმართოს წყობილი loop

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
ჩვენ ვაპირებთ დაამატოთ დამატებითი სივრცე loop.

61
00:05:15,000 --> 00:05:28,000
ასე რომ (int j = 0, n = strlen (argv [i]),

62
00:05:28,000 --> 00:05:32,000
რომელიც შემდეგ გვაძლევს სიგრძე მიმდინარე არგუმენტი,

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

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 ("argv [% d], წარმოადგინოს მაჩვენებელი მიმდინარე არგუმენტი,

67
00:05:57,000 --> 00:06:05,000
მაშინ [% d] კიდევ ერთხელ, რათა წარმოადგინოს მიმდინარე ხასიათი მიმდინარე არგუმენტი,

68
00:06:05,000 --> 00:06:13,000
არის:% C, მიმდინარე პერსონაჟი არგუმენტი.

69
00:06:13,000 --> 00:06:20,000
და ბოლოს, ჩვენ უზრუნველყოფს printf ერთად მაჩვენებელი გარე მარყუჟის, I,

70
00:06:20,000 --> 00:06:22,000
მაშინ მაჩვენებელი შიდა loop.

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
>> და, როგორც ვხედავთ, ჩვენ ახლა აქვს ზუსტი ადგილმდებარეობის თითოეული char in არგუმენტი.

79
00:07:18,000 --> 00:07:23,000
ასე რომ ეს არის ის. მე კრისტოფერ ბართლომე, ეს არის CS50.

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