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
ಉದಾಹರಣೆಗೆ, 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
ಆದ್ದರಿಂದ ನಾವು ಈ ಆಜ್ಞಾ ಸಾಲಿನ ಆರ್ಗುಮೆಂಟ್ಗಳನ್ನು ಬಳಸಿಕೊಳ್ಳಲು ನಮ್ಮ ಸಿ ಪ್ರೋಗ್ರಾಂ ಹೇಳಲು ಇಲ್ಲ?

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
ಈ ಸಂದರ್ಭದಲ್ಲಿ, 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 ಕೊನೆಯ ವಾದವನ್ನು ಯಾವಾಗಲೂ ಶೂನ್ಯ ಎಂದು ಕಾಣಿಸುತ್ತದೆ.

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
ಫಾರ್ (ಇಂಟ್ ನಾನು = 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 [% s] ಒಂದು ಪೂರ್ಣಾಂಕ ಮೌಲ್ಯ ಪ್ರತಿನಿಧಿಸಲು,

48
00:03:57,000 --> 00:04:06,000
ಹೊಸ ಲೈನ್ ಪಾತ್ರದ ನಂತರ, ತಂತಿಗೆ,% s ಆಗಿದೆ.

49
00:04:06,000 --> 00:04:12,000
ನಂತರ ನಾವು ಲೂಪ್ ಪ್ರಸ್ತುತ ಪುನರಾವರ್ತನೆ ಫಾರ್ printf ನಾನು ಒದಗಿಸಲು

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 ಚಾರ್ ಪಾಯಿಂಟರ್ಸ್ ಒಂದು ಶ್ರೇಣಿಯನ್ನು ನಡೆದ ಹೇಳಿದರು.

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 [I]),

62
00:05:28,000 --> 00:05:32,000
ಇದು ನಂತರ, ನಮಗೆ ಪ್ರಸ್ತುತ ವಾದದ ಉದ್ದ ನೀಡುತ್ತದೆ

63
00:05:32,000 --> 00:05:39,000
; J <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
ನಂತರ [% s] ಮತ್ತೊಮ್ಮೆ, ಪ್ರಸ್ತುತ ವಾದದ ಪ್ರಸ್ತುತ ಅಕ್ಷರ ಪ್ರತಿನಿಧಿಸಲು,

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]