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.TV இந்த CS50 உள்ளது]

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
போன்ற பயனர் உள்ளீடு, ஏற்க ", சரம் கிடைக்கும்"

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
உதாரணமாக, எம்.வி. அல்லது UNIX இல் நடவடிக்கை கட்டளையை எடுத்து.

13
00:00:42,000 --> 00:00:49,000
இந்த கட்டளை பயனர் ஒரு இடத்திலிருந்து மற்றொரு ஒரு கோப்பு நகர்த்த அனுமதிக்கிறது.

14
00:00:49,000 --> 00:00:55,000
கையேடு பக்கங்கள் படி, எம்.வி. இரண்டு கட்டளை வரி அளவுருக்களை ஏற்றுக்கொள்கிறார்:

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
நாம் எப்படி இந்த கட்டளை வரி அளவுருக்களை பயன்படுத்த எங்கள் சி நிரல் சொல்ல?

18
00:01:14,000 --> 00:01:20,000
>> சரி, நாம் அனைவரும் சி திட்டங்களில் பயன்படுத்தும் முக்கிய, ஒரு இரகசிய என்று கூறினார்.

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
சரங்களை சுட்டி என்று எரிப்பதை சுட்டிகள் ஒரு வரிசை ஆகும்.

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
இந்த வழக்கில், எம்.வி..

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 கடைசி வாதம் எப்போதும் பூஜ்ய இருக்கும்.

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
நாங்கள் முக்கிய எண்ணாக argc, கரி * argv [] ஒரு வெற்றிடத்தை மற்றும் இடத்தில் உள்ளே நீக்க வேண்டும்.

40
00:03:12,000 --> 00:03:17,000
இப்போது, உங்கள் வாதங்கள் எந்த argv இருந்து முழு உறுப்பு, அணுக,

41
00:03:17,000 --> 00:03:21,000
நீங்கள் சாதாரணமாக இந்த வரிசை மூலம், மீண்டும் கூறு, அல்லது வளைய முடியாது.

42
00:03:21,000 --> 00:03:27,000
அதனால், உள்ளே முக்கிய உடல், நாம் போய் லூப் ஒரு தட்டச்சு செய்ய போகிறோம்:

43
00:03:27,000 --> 00:03:37,000
இன்னும் (int நான் = 0; நான் <argc; நான் +).

44
00:03:37,000 --> 00:03:41,000
>> நாம் மட்டுமே குறியீடு ஒரு வரி இயக்கும் நீங்கள் ஏனெனில் நாம் இங்கே ஒரு சுருள் பிரேஸ் தேவையில்லை

45
00:03:41,000 --> 00:03:44,000
இந்த சுழற்சியில் உடலில் உள்ள.

46
00:03:44,000 --> 00:03:47,000
நாம் மேலே போய் ஒருமுறை தாவலை அடித்து விடுவேன்

47
00:03:47,000 --> 00:03:57,000
பின்னர் printf தட்டச்சு ("argv [% d], ஒரு முழு எண் மதிப்பு பிரதிநிதித்துவம்,

48
00:03:57,000 --> 00:04:06,000
புதிய வரி தன்மையை பிறகு, சரம் செய்ய,% கள் ஆகும்.

49
00:04:06,000 --> 00:04:12,000
நாம் வளைய தற்போதைய மறு செய்கை க்கான printf நான் வழங்கும்

50
00:04:12,000 --> 00:04:18,000
மற்றும் argv [நான்] தற்போதைய கட்டளை வரி வாதத்தின் சரம் பிரதிநிதித்துவம்.

51
00:04:18,000 --> 00:04:25,000
நாம் இரண்டு வாதங்கள் அதை இயக்கும் போது, நாம் முனையத்தில் காட்டப்படவில்லை வாதங்களை பார்ப்போம்.

52
00:04:34,000 --> 00:04:38,000
முந்தைய நாம் argv எரிப்பதை சுட்டிகள் ஒரு வரிசை நடைபெறும் என்று தெரிவித்தார்.

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
சரி, பதில் நாம் ஒரு உள்ளமை வளைய விண்ணப்பிக்க வேண்டும் என்று

56
00:04:55,000 --> 00:04:59,000
பின்னர் வாதம் சரம் உள்ள உறுப்புகள் ஒவ்வொன்றும் மூலம் மீண்டும் கூறு.

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
நாம் லூப் கூடுதல் சேர்க்க போகிறோம்.

61
00:05:15,000 --> 00:05:28,000
அதனால் தான் (இண்ட் ஜே = 0, n = strlen (argv [நான்]),

62
00:05:28,000 --> 00:05:32,000
இது பின்னர், நம்மை தற்போதைய வாதம் நீளம் கொடுக்கிறது

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

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
இது:% கேட்ச், வாதம் தற்போதைய கதாபாத்திரத்தை.

69
00:06:13,000 --> 00:06:20,000
இறுதியாக, நாம் வெளி சுழற்சியில் குறியீடு printf வழங்க, நான்,

70
00:06:20,000 --> 00:06:22,000
பின்னர் உள் வளைய அட்டவணை.

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
# <string.h> அடங்கும்.

77
00:06:57,000 --> 00:07:02,000
>> எனவே, நாட்டின் தொகுத்தல் மற்றும் இயக்க அது ஒரு உண்மையான வாதம் வழங்க வேண்டும்.

78
00:07:09,000 --> 00:07:18,000
>> நாம் பார்க்க முடியும் மற்றும், நாம் இப்போது வாதம் ஒவ்வொரு தனிப்பட்ட எரிப்பதை சரியான இடம் இல்லை.

79
00:07:18,000 --> 00:07:23,000
அவ்வளவு தான். நான் கிறிஸ்டோபர் பர்த்தலோமிவ் இருக்கிறேன்; இந்த CS50 உள்ளது.

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