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

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

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

4
00:00:07,000 --> 00:00:11,000
Sebuah fitur yang berguna untuk program adalah untuk menerima masukan pengguna.

5
00:00:11,000 --> 00:00:15,000
Sejauh ini, kami telah dieksplorasi beberapa fungsi dalam perpustakaan CS50

6
00:00:15,000 --> 00:00:18,000
untuk menerima input pengguna, seperti "mendapatkan string,"

7
00:00:18,000 --> 00:00:23,000
yang mendorong pengguna, sedangkan aplikasi berjalan, untuk string.

8
00:00:23,000 --> 00:00:28,000
>> Namun, ada kasus di mana Anda ingin memberikan masukan program anda

9
00:00:28,000 --> 00:00:30,000
sebelum benar-benar berjalan.

10
00:00:30,000 --> 00:00:34,000
Dengan cara ini, Anda tidak perlu meminta informasi tambahan dari pengguna Anda

11
00:00:34,000 --> 00:00:38,000
saat mengeksekusi tugas sederhana.

12
00:00:38,000 --> 00:00:42,000
Ambil, misalnya, mv atau perintah bergerak dalam UNIX.

13
00:00:42,000 --> 00:00:49,000
Perintah ini memungkinkan pengguna untuk memindahkan file dari satu lokasi ke lokasi lain.

14
00:00:49,000 --> 00:00:55,000
Menurut laman manual, mv menerima argumen perintah dua baris:

15
00:00:55,000 --> 00:01:00,000
file yang sedang dipindahkan dan lokasi file tersebut dipindahkan ke.

16
00:01:00,000 --> 00:01:06,000
Jadi contoh ini memiliki perintah dengan dua argumen.

17
00:01:06,000 --> 00:01:14,000
Jadi bagaimana kita memberitahu kami program C untuk memanfaatkan argumen baris perintah?

18
00:01:14,000 --> 00:01:20,000
>> Nah, ternyata utama, yang kita gunakan dalam semua program C, memiliki rahasia.

19
00:01:20,000 --> 00:01:26,000
Main menerima dua parameter: argc dan argv.

20
00:01:26,000 --> 00:01:28,000
Mari kita pergi ke istilah-istilah ini.

21
00:01:28,000 --> 00:01:33,000
>> Parameter pertama, argc, yang merupakan singkatan dari jumlah argumen,

22
00:01:33,000 --> 00:01:36,000
memiliki tipe data integer.

23
00:01:36,000 --> 00:01:42,000
Parameter argc berisi jumlah argumen, termasuk perintah.

24
00:01:42,000 --> 00:01:47,000
Dalam perintah gerakan kami, meskipun kami hanya memiliki dua argumen ditampilkan,

25
00:01:47,000 --> 00:01:50,000
nilai argc akan menjadi 3.

26
00:01:50,000 --> 00:01:56,000
Parameter kedua, argv, yang merupakan singkatan dari vektor argumen,

27
00:01:56,000 --> 00:02:01,000
adalah sebuah array dari pointer char yang menunjuk ke string.

28
00:02:01,000 --> 00:02:06,000
>> Ini berarti bahwa setiap elemen dalam argv, mulai dari nol,

29
00:02:06,000 --> 00:02:09,000
berisi perintah dan argumen.

30
00:02:09,000 --> 00:02:16,000
Misalnya, argv [0], yang saya akan sebut sebagai argv nol,

31
00:02:16,000 --> 00:02:20,000
selalu akan berisi perintah yang sedang dijalankan -

32
00:02:20,000 --> 00:02:22,000
dalam hal ini, mv.

33
00:02:22,000 --> 00:02:28,000
argv [1] akan berisi argumen pertama, file.txt,

34
00:02:28,000 --> 00:02:37,000
dan argv [2] akan berisi argumen kedua, ~ / cs50 /.

35
00:02:37,000 --> 00:02:42,000
Argumen terakhir dari argv akan selalu nol.

36
00:02:42,000 --> 00:02:46,000
Jadi mari kita menerapkan argumen baris perintah.

37
00:02:46,000 --> 00:02:53,000
Pada latihan sebelumnya, kami menempatkan batal, berarti apa-apa, sebagai parameter utama itu.

38
00:02:53,000 --> 00:02:57,000
Namun, dalam rangka bagi kita untuk menggunakan argumen baris perintah,

39
00:02:57,000 --> 00:03:12,000
kita perlu untuk menghapus dalam kekosongan dan tempat argc int main, char * argv [].

40
00:03:12,000 --> 00:03:17,000
Sekarang, untuk mengakses seluruh elemen dari argv, yang merupakan argumen Anda,

41
00:03:17,000 --> 00:03:21,000
Anda hanya dapat iterate, atau loop, melalui array seperti ini.

42
00:03:21,000 --> 00:03:27,000
Jadi, dalam tubuh utama, kita akan pergi ke depan dan ketik untuk loop:

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
>> Kita tidak perlu penjepit keriting di sini karena kita hanya melaksanakan satu baris kode

45
00:03:41,000 --> 00:03:44,000
dalam tubuh loop ini.

46
00:03:44,000 --> 00:03:47,000
Kami akan pergi ke depan dan memukul tab sekali,

47
00:03:47,000 --> 00:03:57,000
kemudian ketik printf ("argv [% d], untuk mewakili nilai integer,

48
00:03:57,000 --> 00:04:06,000
adalah% s, untuk string, maka karakter baris baru.

49
00:04:06,000 --> 00:04:12,000
Kemudian kami menyediakan printf i untuk iterasi saat loop

50
00:04:12,000 --> 00:04:18,000
dan argv [i] untuk representasi string dari argumen baris perintah saat ini.

51
00:04:18,000 --> 00:04:25,000
Ketika kita menjalankannya dengan dua argumen, kita akan melihat argumen yang ditampilkan di terminal.

52
00:04:34,000 --> 00:04:38,000
Sebelumnya kita mengatakan bahwa argv mengadakan sebuah array dari pointer char.

53
00:04:38,000 --> 00:04:45,000
>> Jadi, jika hal ini terjadi, bagaimana kita kemudian mengakses karakter individu dalam argumen masing-masing?

54
00:04:45,000 --> 00:04:51,000
Sebagai contoh, bagaimana jika saya ingin mencari karakter tertentu dalam argumen pertama?

55
00:04:51,000 --> 00:04:55,000
Nah, jawabannya adalah bahwa kita perlu menerapkan nested loop

56
00:04:55,000 --> 00:04:59,000
yang kemudian akan iterate melalui setiap elemen dalam argumen string.

57
00:04:59,000 --> 00:05:02,000
Ini adalah bagaimana Anda melakukannya.

58
00:05:02,000 --> 00:05:10,000
>> Pertama, kita akan membuat salinan example2.c.

59
00:05:10,000 --> 00:05:13,000
Kemudian, di dalam yang pertama untuk loop,

60
00:05:13,000 --> 00:05:15,000
kita akan menambahkan tambahan untuk loop.

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

62
00:05:28,000 --> 00:05:32,000
yang kemudian memberi kita panjang argumen saat ini,

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

64
00:05:39,000 --> 00:05:43,000
Kita akan mencetak lokasi masing-masing karakter

65
00:05:43,000 --> 00:05:47,000
dalam argumen saat ini dengan menggunakan printf.

66
00:05:47,000 --> 00:05:57,000
Jadi, printf ("argv [% d], untuk mewakili indeks dari argumen saat ini,

67
00:05:57,000 --> 00:06:05,000
kemudian [% d] sekali lagi, untuk mewakili karakter saat argumen saat ini,

68
00:06:05,000 --> 00:06:13,000
adalah: c%, untuk karakter saat ini dalam argumen.

69
00:06:13,000 --> 00:06:20,000
Terakhir, kami menyediakan printf dengan indeks loop luar, i,

70
00:06:20,000 --> 00:06:22,000
maka indeks loop batin.

71
00:06:22,000 --> 00:06:28,000
>> Dan argumen terakhir kami untuk printf adalah karakter yang sebenarnya dari argumen disediakan

72
00:06:28,000 --> 00:06:31,000
pada baris perintah.

73
00:06:31,000 --> 00:06:37,000
Sekarang, karena saya menggunakan fungsi string strlen untuk mendapatkan panjang string,

74
00:06:37,000 --> 00:06:43,000
Saya juga harus menambahkan perpustakaan string.h ke atas termasuk kami.

75
00:06:43,000 --> 00:06:50,000
Jadi, untuk melakukan itu, kita akan naik, dan hanya di bawah stdio.h, kita akan lakukan

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

77
00:06:57,000 --> 00:07:02,000
>> Jadi, mari kita mengkompilasi dan menjalankan dan memberikan itu sebuah argumen aktual.

78
00:07:09,000 --> 00:07:18,000
>> Dan, seperti yang kita lihat, kita sekarang memiliki lokasi yang tepat dari setiap char individu dalam argumen.

79
00:07:18,000 --> 00:07:23,000
Jadi itu saja. Saya Christopher Bartholomew, ini adalah CS50.

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