1
00:00:00,000 --> 00:00:02,000
[Powered by Google Translate] [Đối số dòng lệnh]

2
00:00:02,000 --> 00:00:04,000
[Christopher Bartholomew - Đại học Harvard]

3
00:00:04,000 --> 00:00:07,000
[Đây là CS50 - CS50.TV]

4
00:00:07,000 --> 00:00:11,000
Một tính năng hữu ích cho một chương trình là phải chấp nhận đầu vào người sử dụng.

5
00:00:11,000 --> 00:00:15,000
Như vậy đến nay, chúng tôi đã khám phá một số chức năng trong thư viện CS50

6
00:00:15,000 --> 00:00:18,000
chấp nhận đầu vào của người dùng, chẳng hạn như "nhận được chuỗi"

7
00:00:18,000 --> 00:00:23,000
nhắc nhở người sử dụng, trong khi các ứng dụng đang chạy, cho một chuỗi.

8
00:00:23,000 --> 00:00:28,000
>> Tuy nhiên, có những trường hợp bạn muốn cung cấp đầu vào chương trình của bạn

9
00:00:28,000 --> 00:00:30,000
trước khi nó thực sự là chạy.

10
00:00:30,000 --> 00:00:34,000
Bằng cách này, bạn không cần phải hỏi thêm thông tin từ người dùng của bạn

11
00:00:34,000 --> 00:00:38,000
trong khi thực hiện một nhiệm vụ đơn giản.

12
00:00:38,000 --> 00:00:42,000
Lấy ví dụ, mv lệnh di chuyển trong UNIX.

13
00:00:42,000 --> 00:00:49,000
Lệnh này cho phép người sử dụng để di chuyển một tập tin từ một địa điểm khác.

14
00:00:49,000 --> 00:00:55,000
Theo các trang hướng dẫn sử dụng, mv chấp nhận hai đối số dòng lệnh:

15
00:00:55,000 --> 00:01:00,000
các tập tin đang được di chuyển và vị trí tập tin đang được chuyển đến.

16
00:01:00,000 --> 00:01:06,000
Vì vậy, ví dụ này có một lệnh với hai đối số.

17
00:01:06,000 --> 00:01:14,000
Vì vậy, làm thế nào để chúng ta nói với C chương trình của chúng tôi sử dụng các đối số dòng lệnh?

18
00:01:14,000 --> 00:01:20,000
>> Vâng, nó chỉ ra rằng chính, chúng tôi sử dụng trong tất cả các chương trình C, có một bí mật.

19
00:01:20,000 --> 00:01:26,000
Main chấp nhận hai tham số: argc và argv.

20
00:01:26,000 --> 00:01:28,000
Hãy đi qua những điều khoản này.

21
00:01:28,000 --> 00:01:33,000
>> Tham số đầu tiên, argc, đó là viết tắt cho số đối số,

22
00:01:33,000 --> 00:01:36,000
có một kiểu dữ liệu của các số nguyên.

23
00:01:36,000 --> 00:01:42,000
Tham số argc chứa số lượng các đối số, bao gồm cả lệnh.

24
00:01:42,000 --> 00:01:47,000
Trong lệnh di chuyển của chúng tôi, mặc dù chúng tôi chỉ có hai đối số hiển thị,

25
00:01:47,000 --> 00:01:50,000
giá trị của argc sẽ là 3.

26
00:01:50,000 --> 00:01:56,000
Tham số thứ hai, argv, mà là viết tắt của đối số vector,

27
00:01:56,000 --> 00:02:01,000
là một mảng của các con trỏ char trỏ đến chuỗi.

28
00:02:01,000 --> 00:02:06,000
>> Điều này có nghĩa rằng mỗi yếu tố trong argv, bắt đầu từ số không,

29
00:02:06,000 --> 00:02:09,000
chứa các lệnh và tranh luận.

30
00:02:09,000 --> 00:02:16,000
Ví dụ, argv [0], tôi sẽ tham khảo là argv không,

31
00:02:16,000 --> 00:02:20,000
sẽ luôn luôn chứa lệnh đang được chạy -

32
00:02:20,000 --> 00:02:22,000
trong trường hợp này, mv.

33
00:02:22,000 --> 00:02:28,000
argv [1] sẽ chứa tham số đầu tiên, file.txt,

34
00:02:28,000 --> 00:02:37,000
và argv [2] sẽ chứa tham số thứ hai, ~ / CS50 /.

35
00:02:37,000 --> 00:02:42,000
Đối số cuối cùng của argv sẽ luôn luôn là null.

36
00:02:42,000 --> 00:02:46,000
Vì vậy, chúng ta hãy thực hiện các đối số dòng lệnh.

37
00:02:46,000 --> 00:02:53,000
Trong bài tập trước, chúng tôi đặt có hiệu lực, có nghĩa là không có gì, như một tham số chính của.

38
00:02:53,000 --> 00:02:57,000
Tuy nhiên, để cho chúng ta sử dụng các đối số dòng lệnh,

39
00:02:57,000 --> 00:03:12,000
chúng ta cần phải loại bỏ void và địa điểm bên trong của chính int argc, char * argv [].

40
00:03:12,000 --> 00:03:17,000
Bây giờ, để truy cập toàn bộ phần tử từ argv, đó là lập luận của bạn,

41
00:03:17,000 --> 00:03:21,000
bạn chỉ có thể lặp đi lặp lại, hoặc vòng lặp, thông qua các mảng như thế này.

42
00:03:21,000 --> 00:03:27,000
Vì vậy, bên trong cơ thể chính, chúng tôi sẽ đi trước và gõ một vòng lặp for:

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
>> Chúng tôi không cần một cú đúp xoăn ở đây bởi vì chúng ta chỉ thực hiện một dòng mã

45
00:03:41,000 --> 00:03:44,000
trong cơ thể của vòng lặp này.

46
00:03:44,000 --> 00:03:47,000
Chúng tôi sẽ đi trước và nhấn tab một lần,

47
00:03:47,000 --> 00:03:57,000
sau đó gõ printf ("argv [% d], để đại diện cho một giá trị số nguyên,

48
00:03:57,000 --> 00:04:06,000
% s, chuỗi, sau đó các ký tự dòng mới.

49
00:04:06,000 --> 00:04:12,000
Sau đó, chúng tôi cung cấp printf i lặp hiện tại của vòng lặp

50
00:04:12,000 --> 00:04:18,000
và argv [i] cho chuỗi đại diện của các đối số dòng lệnh hiện tại.

51
00:04:18,000 --> 00:04:25,000
Khi chúng tôi chạy nó với hai đối số, chúng ta sẽ thấy các đối số được hiển thị trong các thiết bị đầu cuối.

52
00:04:34,000 --> 00:04:38,000
Trước đó chúng tôi đã nói rằng argv đã tổ chức một mảng của các con trỏ char.

53
00:04:38,000 --> 00:04:45,000
>> Vì vậy, nếu đây là trường hợp, làm thế nào để chúng ta truy cập vào các đặc điểm cá nhân trong mỗi đối số?

54
00:04:45,000 --> 00:04:51,000
Ví dụ, những gì nếu tôi muốn tìm kiếm một nhân vật cụ thể trong tham số đầu tiên?

55
00:04:51,000 --> 00:04:55,000
Vâng, câu trả lời là chúng ta cần phải áp dụng một vòng lặp lồng nhau

56
00:04:55,000 --> 00:04:59,000
mà sau đó sẽ lặp lại qua mỗi phần tử trong chuỗi đối số.

57
00:04:59,000 --> 00:05:02,000
Đây là cách bạn làm điều đó.

58
00:05:02,000 --> 00:05:10,000
>> Đầu tiên, chúng ta sẽ tạo một bản sao của example2.c.

59
00:05:10,000 --> 00:05:13,000
Sau đó, bên trong những người đầu tiên cho vòng lặp,

60
00:05:13,000 --> 00:05:15,000
chúng ta sẽ thêm một bổ sung cho vòng lặp.

61
00:05:15,000 --> 00:05:28,000
Vì vậy, đối với (int j = 0, n = strlen (argv [i]),

62
00:05:28,000 --> 00:05:32,000
sau đó cho chúng ta chiều dài của đối số hiện tại,

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

64
00:05:39,000 --> 00:05:43,000
Chúng tôi sẽ in ra vị trí của mỗi ký tự

65
00:05:43,000 --> 00:05:47,000
bên trong của đối số hiện tại bằng cách sử dụng printf.

66
00:05:47,000 --> 00:05:57,000
Vì vậy, printf ("argv [% d], để đại diện cho các chỉ số của các đối số hiện tại,

67
00:05:57,000 --> 00:06:05,000
sau đó [% d] một lần nữa, để đại diện cho nhân vật hiện tại của các đối số hiện tại,

68
00:06:05,000 --> 00:06:13,000
là:% c, cho các nhân vật hiện tại trong đối số.

69
00:06:13,000 --> 00:06:20,000
Cuối cùng, chúng tôi cung cấp printf với các chỉ số của các vòng ngoài, i,

70
00:06:20,000 --> 00:06:22,000
sau đó chỉ số của vòng lặp bên trong.

71
00:06:22,000 --> 00:06:28,000
>> Và đối số cuối cùng của chúng tôi để printf là nhân vật thực tế từ các đối số được cung cấp

72
00:06:28,000 --> 00:06:31,000
tại dòng lệnh.

73
00:06:31,000 --> 00:06:37,000
Bây giờ, bởi vì tôi đã sử dụng chức năng chuỗi strlen để có được chiều dài của một chuỗi,

74
00:06:37,000 --> 00:06:43,000
Tôi cũng phải thêm các thư viện string.h đầu bao gồm của chúng tôi.

75
00:06:43,000 --> 00:06:50,000
Vì vậy, để làm điều đó, chúng ta sẽ đi lên, và dưới stdio.h, chúng tôi đang đi làm

76
00:06:50,000 --> 00:06:57,000
# Bao gồm <string.h>.

77
00:06:57,000 --> 00:07:02,000
>> Vì vậy, hãy biên dịch và chạy và cung cấp cho nó một đối số thực tế.

78
00:07:09,000 --> 00:07:18,000
>> Và, như chúng ta có thể thấy, hiện nay chúng tôi có vị trí chính xác của từng char cá nhân trong đối số.

79
00:07:18,000 --> 00:07:23,000
Vì vậy, đó là nó. Tôi là Christopher Bartholomew, đây là CS50.

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