1
00:00:00,000 --> 00:00:00,487

2
00:00:00,487 --> 00:00:11,210
>> [ಸಂಗೀತ]

3
00:00:11,210 --> 00:00:12,100
>> ರಾಬ್ ಬೋಡನ್: ಸರಿ.

4
00:00:12,100 --> 00:00:15,620
ವೀಡಿಯೊ ಮೊದಲ ಆದ್ದರಿಂದ, ಮೊದಲ ವಿಷಯ,
ಪರಿಚಿತ ಮುಖ ರಿಂದ.

5
00:00:15,620 --> 00:00:22,080

6
00:00:22,080 --> 00:00:22,560
>> [ವೀಡಿಯೋ ಪ್ಲೇಬ್ಯಾಕ್]

7
00:00:22,560 --> 00:00:23,370
>> -ಸರಿ.

8
00:00:23,370 --> 00:00:27,150
ಈ CS50 ಹೊಂದಿದೆ, ಮತ್ತು ಇದು
ವಾರ ಮೂರು ಆರಂಭದಲ್ಲಿ.

9
00:00:27,150 --> 00:00:29,980
ನಾನು ನಿಮ್ಮೊಂದಿಗೆ ಇರುತ್ತದೆ ಸಾಧ್ಯವಾಗಲಿಲ್ಲ ಕ್ಷಮಿಸಿ
ಇಂದು, ಆದರೆ ನನಗೆ ಪರಿಚಯಿಸಲು ಅವಕಾಶ

10
00:00:29,980 --> 00:00:32,880
CS50 ಆದ ರಾಬ್ ಬೋಡನ್.

11
00:00:32,880 --> 00:00:33,872
>> [END ವೀಡಿಯೋ ಪ್ಲೇಬ್ಯಾಕ್]

12
00:00:33,872 --> 00:00:39,340
>> [ಚಪ್ಪಾಳೆ ಮತ್ತು ನೆರೆದಿದ್ದ]

13
00:00:39,340 --> 00:00:41,277
>> ರಾಬ್ ಬೋಡನ್: ರಲ್ಲಿ ಚಲನಚಿತ್ರಗಳ ಪಟ್ಟಿ
ವೀಡಿಯೊ ಅದ್ಭುತವಾಗಿದೆ.

14
00:00:41,277 --> 00:00:47,280

15
00:00:47,280 --> 00:00:47,770
ಸರಿ.

16
00:00:47,770 --> 00:00:50,960
ಆದ್ದರಿಂದ ಮೊದಲ, ಮತ್ತೊಂದು ಅರ್ಹ ಇಲ್ಲ.

17
00:00:50,960 --> 00:00:52,330
ಇದು 1:15 ನಾಳೆಯ.

18
00:00:52,330 --> 00:00:54,480
ಈ ಶುಕ್ರವಾರ ಯಾವುದೇ ಅರ್ಹ ಇಲ್ಲ.

19
00:00:54,480 --> 00:00:55,810
ಇದು Quora ಹೊಂದಿದೆ.

20
00:00:55,810 --> 00:01:00,190
ಮತ್ತು ಟಾಮಿ ಒಂದು ಆದರೆ, ಇನ್ನೂ ಇಲ್ಲಿ ಅಲ್ಲ
ಮಾಜಿ ಮುಖ್ಯಸ್ಥ ಸಿಎಫ್ ಇಲ್ಲ ಜನರು,

21
00:01:00,190 --> 00:01:01,530
ಟಾಮಿ McWilliam.

22
00:01:01,530 --> 00:01:02,730
ಆದ್ದರಿಂದ ಅವರು ಮೋಜಿನ ವ್ಯಕ್ತಿಯಾಗಿದ್ದಾರೆ.

23
00:01:02,730 --> 00:01:04,819
ನೀವು ಬರಬೇಕು.

24
00:01:04,819 --> 00:01:05,900
>> ಸರಿ.

25
00:01:05,900 --> 00:01:11,360
ಕಳೆದ ವಾರ, ನಾವು ಹೊರತುಪಡಿಸಿ ಕೆಡವಿದೆ
ಸ್ಟ್ರಿಂಗ್ ನಿಜಕ್ಕೂ ಏನೆಂದು ಬಗ್ಗೆ.

26
00:01:11,360 --> 00:01:14,830
ನಾವು ಆರಂಭದಿಂದಲೂ ಕರೆಯಲಾಗುತ್ತದೆ ಬಂದಿದೆ ಎಂದು
ಇದು ಅಕ್ಷರಗಳನ್ನು ಅನುಕ್ರಮ ಇಲ್ಲಿದೆ.

27
00:01:14,830 --> 00:01:18,130
ಆದರೆ ಕಳೆದ ವಾರ, ನಾವು ವಾಸ್ತವವಾಗಿ ಅರಸಿಹೋದರು
ಯಾವ ನಿಜವಾಗಿಯೂ ಅನುಕ್ರಮ ಎಂದು

28
00:01:18,130 --> 00:01:22,110
ಪಾತ್ರಗಳು, ಹಾಗೂ, ನಾವು ಈಗ
ಪಾತ್ರಗಳ ಸರಣಿಗಳ.

29
00:01:22,110 --> 00:01:26,450
ಮತ್ತು ನಾವು ಒಂದು ಸಾಲಿನಲ್ಲಿ, ಒಂದು ರಚನೆಯ ಗೊತ್ತಾಯಿತು
ಪಾತ್ರಗಳು ಅತ್ಯಂತ ಕೊನೆಯಲ್ಲಿ,

30
00:01:26,450 --> 00:01:30,920
ನಾವು ಈ ವಿಶೇಷ ಶೂನ್ಯ ಬೈಟ್ ಹೊಂದಿವೆ, ಈ
ಬ್ಯಾಕ್ಸ್ಲ್ಯಾಷ್ 0, ಆ ಅಂತ್ಯದ ಸೂಚಿಸುತ್ತದೆ

31
00:01:30,920 --> 00:01:32,230
ಸ್ಟ್ರಿಂಗ್.

32
00:01:32,230 --> 00:01:36,970
>> ಆದ್ದರಿಂದ ಸ್ಟ್ರಿಂಗ್ ಒಂದು ರಚನೆ
ಪಾತ್ರಗಳು, ಆದರೆ ನಾವು ಹೊಂದಬಹುದು ಹೆಚ್ಚು

33
00:01:36,970 --> 00:01:39,530
ಕೇವಲ ಪಾತ್ರಗಳು ಒಂದು ಶ್ರೇಣಿಯನ್ನು,
ನಾವು ಯಾವುದೇ ಒಂದು ಶ್ರೇಣಿಯನ್ನು ಹೊಂದಿವೆ

34
00:01:39,530 --> 00:01:40,890
ನಾವು ಬಯಸುವ ವಿಷಯ ಮಾದರಿ.

35
00:01:40,890 --> 00:01:51,570
ಆದ್ದರಿಂದ, ನೀವು ಕಳೆದ ವಾರದ ಮರುಪಡೆಯಲು ವೇಳೆ,
ಡೇವಿಡ್ ಪರಿಚಯಿಸಿದ ಏಜಸ್ ಪ್ರೋಗ್ರಾಂ

36
00:01:51,570 --> 00:01:53,560
ನಿಜವಾಗಿಯೂ ವೇಗವಾಗಿ.

37
00:01:53,560 --> 00:01:57,010
ನಾವು ಮಾಡಲು ನೀನು ಆದ್ದರಿಂದ ಮೊದಲ ವಿಷಯ
, ಒಂದು ಪೂರ್ಣಾಂಕ ಬಳಕೆದಾರ ಕೇಳಿ

38
00:01:57,010 --> 00:01:58,800
ಕೋಣೆಯಲ್ಲಿ ಜನರ ಸಂಖ್ಯೆ.

39
00:01:58,800 --> 00:02:01,260
ನಾವು ಪೂರ್ಣಾಂಕ ಒಮ್ಮೆ,
ನಾವು ಒಂದು ಶ್ರೇಣಿಯನ್ನು ಘೋಷಿಸುವ ನೀವು.

40
00:02:01,260 --> 00:02:02,890
ಈ ಬ್ರಾಕೆಟ್ ವಾಕ್ಯ ಗಮನಿಸಿ.

41
00:02:02,890 --> 00:02:04,540
ನೀವು ಎಂದು ಬಳಸಲಾಗುತ್ತದೆ ನೀನು.

42
00:02:04,540 --> 00:02:09,430
>> ನಾವು ಪೂರ್ಣಾಂಕಗಳ ಒಂದು ಶ್ರೇಣಿಯನ್ನು ಘೋಷಿಸುವ ನೀವು
ವಯಸ್ಸಿನ ಕರೆಯಲಾಗುತ್ತದೆ, ಮತ್ತು N ಇವೆ

43
00:02:09,430 --> 00:02:12,080
ಈ ರಚನೆಯ ಪೂರ್ಣಾಂಕಗಳ.

44
00:02:12,080 --> 00:02:16,480
ಇಲ್ಲಿಯೇ ಈ ಮಾದರಿ, ಈ 4 ಇಂಟ್
ನಾನು ಜೊತೆಗೆ, ನಾನು ಕಡಿಮೆ n ಇದೆ, 0 ಸಮನಾಗಿರುತ್ತದೆ

45
00:02:16,480 --> 00:02:20,580
ಜೊತೆಗೆ, ಸಹ ಮಾದರಿ ಏರಲಿದೆ
ನೀವು ಬಹಳ ಬಳಸಲಾಗುತ್ತದೆ ಎಂದು.

46
00:02:20,580 --> 00:02:24,000
ಬಹುಮಟ್ಟಿಗೆ ನೀವು ಹೇಗೆ ಏಕೆಂದರೆ
ಯಾವಾಗಲೂ ಸರಣಿಗಳ ಮೇಲೆ ತಿರುಗಿ ಹೋಗುವ.

47
00:02:24,000 --> 00:02:26,330
ಆದ್ದರಿಂದ N ನೆನಪು
ನಮ್ಮ ರಚನೆಯ ಉದ್ದ.

48
00:02:26,330 --> 00:02:32,120
ಮತ್ತು ಇಲ್ಲಿ, ನಾವು ಪದೇ ಪದೇ ಕೇಳುತ್ತಿದ್ದೇವೆ
ಕೋಣೆಯಲ್ಲಿ ವ್ಯಕ್ತಿ ನಾನು ವಯಸ್ಸು.

49
00:02:32,120 --> 00:02:36,640
>> ಈ ನಂತರ, ನಾವು ಕೆಳಗೆ ಹೋಗಿ, ಮತ್ತು ಯಾವುದೇ
ಅನಿಯಂತ್ರಿತ ಕಾರಣ, ನಾವು ನಂತರ

50
00:02:36,640 --> 00:02:40,220
ಅವರು ನೀನು ಹೇಗೆ ಹಳೆಯ ಮುದ್ರಿಸುತ್ತದೆ
ಈಗ ಒಂದು ವರ್ಷ ಎಂದು.

51
00:02:40,220 --> 00:02:49,980
ಮತ್ತು ಕಾರ್ಯಕ್ರಮವನ್ನು ನಡೆಸುವ ಅವಕಾಶ
, ವಯಸ್ಸಿನ ಮಾಡಲು ಸ್ಲ್ಯಾಷ್ ವಯಸ್ಸಿನ ಡಾಟ್.

52
00:02:49,980 --> 00:02:53,010
ಆದ್ದರಿಂದ ಕೋಣೆಯಲ್ಲಿ ಜನರ ಸಂಖ್ಯೆ
ಮೂರು ಇವೆ ಹೇಳಲು ಅವಕಾಶ.

53
00:02:53,010 --> 00:02:59,880
ಮತ್ತು, ಮೊದಲ ವ್ಯಕ್ತಿ 13, ಹೇಳಲು
ಮುಂದಿನ 26 ಮತ್ತು ಕಳೆದ 30 ಆಗಿದೆ.

54
00:02:59,880 --> 00:03:05,080
ಆದ್ದರಿಂದ ಅದು ಆ ಮೂರು ಮೇಲೆ ತಿರುಗಿ ನೋಡುತ್ತಾರೆ
ಜನರು, 14 ಔಟ್ 27, ಮತ್ತು 31 ಮುದ್ರಿಸಲು.

55
00:03:05,080 --> 00:03:16,060
>> ಆದ್ದರಿಂದ ನೆನಪಿಡಿ ನಾವು ಒಂದು ಘೋಷಿಸಿದ
ಗಾತ್ರ N ರಚನೆಯ ಎಂದು ಸೂಚಿಗಳನ್ನು

56
00:03:16,060 --> 00:03:19,950
ಸರಣಿ, ಸರಣಿ ಮೌಲ್ಯಗಳನ್ನು ಹೊಂದಿದೆ ಮತ್ತು
ಸೂಚ್ಯಂಕಗಳು 0, 1, 2, ಎಲ್ಲಾ ರೀತಿಯಲ್ಲಿ

57
00:03:19,950 --> 00:03:21,680
ಅಪ್ ಎನ್ ಮೈನಸ್ 1.

58
00:03:21,680 --> 00:03:26,255
ನಾವು ಹೇಳಿದರು ಮೂರು ಜನರಿದ್ದರು
ಕೋಣೆಯಲ್ಲಿ, ಮತ್ತು ನಾವು ಇಲ್ಲಿ ಪುಟ್

59
00:03:26,255 --> 00:03:29,850
ಈ ಮೂಲಕ ಮೊದಲ ಪುನರಾವರ್ತನೆ
ಲೂಪ್, ನಾನು 0 ಏರಲಿದೆ.

60
00:03:29,850 --> 00:03:31,650
ಆದ್ದರಿಂದ ಸೂಚ್ಯಂಕ 0.

61
00:03:31,650 --> 00:03:34,540
ನಾವು ಮೊದಲ ನಿಯೋಜಿಸುವ
ಬಳಕೆದಾರ ಪ್ರವೇಶಿಸುತ್ತದೆ ವಯಸ್ಸು.

62
00:03:34,540 --> 00:03:38,870
ಮುಂದಿನ ಒಂದು, ನಾವು ಪ್ರವೇಶಿಸುವ ನೀವು
ಎರಡನೇ ಹೊ ಪ್ರವೇಶಿಸುತ್ತದೆ, ಮತ್ತು

63
00:03:38,870 --> 00:03:40,580
ಎರಡು, ಕಳೆದ N ಮುಂದಿನ.

64
00:03:40,580 --> 00:03:44,200
>> ಆದ್ದರಿಂದ ಗಮನಿಸಿ ಗಾತ್ರ ಒಂದು ಶ್ರೇಣಿಯನ್ನು
ಮೂರು ಏನು ಹೊಂದಿಲ್ಲ

65
00:03:44,200 --> 00:03:46,040
ಸೂಚ್ಯಂಕ ಮೂರು.

66
00:03:46,040 --> 00:03:49,036
ಈ ಮಾನ್ಯವಾಗಿಲ್ಲ.

67
00:03:49,036 --> 00:03:50,250
ಸರಿ.

68
00:03:50,250 --> 00:03:55,136
ಆದ್ದರಿಂದ ಇಲ್ಲಿ ಮತ್ತೆ ಹೋಗುವ.

69
00:03:55,136 --> 00:03:57,650

70
00:03:57,650 --> 00:04:01,590
ಈಗ ನಾವು ಸರಣಿಗಳ ವ್ಯವಹರಿಸಿದೆ ನೀವು ಎಂದು,
ನಾವು ಕೆಲವು ಜನಪ್ರಿಯತೆ ಹೊಂದಿವೆ.

71
00:04:01,590 --> 00:04:03,780
ಈಗ ನಾವು ಆಜ್ಞೆಯನ್ನು ತೆರಳಿ ನೀನು
ಹೋಗುವ ಇದು ಸಾಲಿನ ಆರ್ಗುಮೆಂಟ್ಗಳನ್ನು,

72
00:04:03,780 --> 00:04:05,890
ಈ ಸಮಸ್ಯೆ ಸೆಟ್ ಬಹಳ ಸೂಕ್ತ.

73
00:04:05,890 --> 00:04:09,670
>> ಆದ್ದರಿಂದ ಈಗ ವರೆಗೂ, ಬಂದ ನೀವು ಮಾಡಿದ
ನಿಮ್ಮ ಕಾರ್ಯ ಮುಖ್ಯ ಘೋಷಿಸಿದರು, ನಾವು

74
00:04:09,670 --> 00:04:11,230
ಇಂಟ್ ಮುಖ್ಯ ಶೂನ್ಯ ಹೇಳಿದರು.

75
00:04:11,230 --> 00:04:14,070
ಆದ್ದರಿಂದ ಶೂನ್ಯ ಅರ್ಥ
ನಾವು ಯಾವುದೇ ಹಾದುಹೋಗುವ ಇಲ್ಲ

76
00:04:14,070 --> 00:04:16,440
ಈ ಕಾರ್ಯ ವಾದಗಳು.

77
00:04:16,440 --> 00:04:19,190
ಈಗ ನಾವು ಮುಖ್ಯ ನೋಡಲು ನೀನು
ಕೆಲವು ವಾದಗಳು ತೆಗೆದುಕೊಳ್ಳಬಹುದು.

78
00:04:19,190 --> 00:04:22,470
ಇಲ್ಲಿ ನಾವು argc ಇಂಟ್ ಕರೆ
ಮತ್ತು ಸ್ಟ್ರಿಂಗ್ argv ಆವರಣ.

79
00:04:22,470 --> 00:04:26,930
ಬ್ರಾಕೆಟ್ಗಳನ್ನು, ಮತ್ತೊಮ್ಮೆ, ಸೂಚಿಸುವ
ನಾವು ರಚನೆಗಳು ಮಾತಾಡುತ್ತಿದ್ದೀರಿ ಎಂದು.

80
00:04:26,930 --> 00:04:31,850
ಇಲ್ಲಿ, ಸ್ಟ್ರಿಂಗ್ argv ಬ್ರಾಕೆಟ್ಗಳನ್ನು, ನಾವು
ತಂತಿಗಳ ಒಂದು ಸರಣಿ ವ್ಯವಹರಿಸುವಾಗ.

81
00:04:31,850 --> 00:04:35,360
ಆದ್ದರಿಂದ argc, ಎಂದು ಸೂಚಿಸುತ್ತದೆ ವಿಶೇಷವೇನು
ನಾವು ಮಾಡಿದ ಎಷ್ಟು ವಾದಗಳನ್ನು

82
00:04:35,360 --> 00:04:37,580
ಈ ಕಾರ್ಯಕ್ರಮವನ್ನು ಜಾರಿಗೆ.

83
00:04:37,580 --> 00:04:46,050
ಮತ್ತು, ಅಂದರೆ ಏನು ನೋಡಿ
ಈ ಮುಚ್ಚಲು ಅವಕಾಶ.

84
00:04:46,050 --> 00:04:46,490
>> ಸರಿ.

85
00:04:46,490 --> 00:04:50,790
ಆದ್ದರಿಂದ ಈಗ ವರೆಗೂ, ನಾವು ಪ್ರತಿ ಹೊಸದೊಂದು
ಡಾಟ್ ಕತ್ತರಿಸಿ ವಯಸ್ಸಿನ ಹಾಗೆ ಪ್ರೋಗ್ರಾಂ.

86
00:04:50,790 --> 00:04:55,250
ನಾವು ಸಹ, ಆಜ್ಞಾ ಸಾಲಿನಲ್ಲಿ, ಕಳೆದ
ಆರ್ಗ್ಯುಮೆಂಟ್ಗಳನ್ನು, ಹೀಗೆ ಪದವನ್ನು ಆಜ್ಞೆಯನ್ನು

87
00:04:55,250 --> 00:04:56,550
ಸಾಲಿನ ಆರ್ಗುಮೆಂಟ್ಗಳನ್ನು.

88
00:04:56,550 --> 00:04:59,760
ಆದ್ದರಿಂದ ಮೊದಲ ವಾದವನ್ನು, ಹಲೋ ವರ್ಲ್ಡ್.

89
00:04:59,760 --> 00:05:03,350
ಇಲ್ಲಿ, argc, ಮೂರು ಎಂದು.

90
00:05:03,350 --> 00:05:07,720
ಇದು ವಾದಗಳನ್ನು ಲೆಕ್ಕ
ಆಜ್ಞಾ ಸಾಲಿನಲ್ಲಿ.

91
00:05:07,720 --> 00:05:12,840
Argc, ಯಾವಾಗಲೂ ಕನಿಷ್ಟ 1 ರಿಂದ ಡಾಟ್
, ಸ್ವತಃ ವಯಸ್ಸಿನ ಕಡಿದು, ಎಂದು ಲೆಕ್ಕ

92
00:05:12,840 --> 00:05:14,490
ಆಜ್ಞಾ ಸಾಲಿನ ಆರ್ಗುಮೆಂಟ್ಗಳನ್ನು.

93
00:05:14,490 --> 00:05:17,010
>> ನಂತರ ನಿನ್ನ ಮೊದಲು.

94
00:05:17,010 --> 00:05:20,460
ಡಾಟ್ ಕತ್ತರಿಸಿ ವಯಸ್ಸಿನ ನಂತರ, ಸೊನ್ನೆಯ ವೇಳೆ
ಹಲೋ ಮೊದಲ ಹಾಗೂ ಜಗತ್ತು

95
00:05:20,460 --> 00:05:22,830
ಎರಡನೇ ಆಜ್ಞಾ ಸಾಲಿನ ವಾದವನ್ನು.

96
00:05:22,830 --> 00:05:29,490
ಆದ್ದರಿಂದ ಸ್ಟ್ರಿಂಗ್ argv, ನಾವು ನೋಡಲು ನೀನು,
ತಂತಿಗಳು ಡಾಟ್ ಕತ್ತರಿಸಿ ಹೊಂದಿದೆ

97
00:05:29,490 --> 00:05:33,830
ವಯಸ್ಸಿನ, ಹಲೋ, ಮತ್ತು ವಿಶ್ವದ.

98
00:05:33,830 --> 00:05:38,945
ಮತ್ತು, ಡೇವಿಡ್ ಕೋರಿಕೆಯ ಮೇರೆಗೆ ನಾವು ನೀನು
ಎಂದು ಪರಿಚಯಿಸುವ ವೀಡಿಯೊ ಆಡಲು.

99
00:05:38,945 --> 00:05:42,486

100
00:05:42,486 --> 00:05:43,890
>> [ವೀಡಿಯೋ ಪ್ಲೇಬ್ಯಾಕ್]

101
00:05:43,890 --> 00:05:46,240
>> ಅಪ್ ನಾವು ಮಾಡಿದ ಕಾರ್ಯಕ್ರಮಗಳಲ್ಲಿ ಈಗ ರವರೆಗೆ
ಬರೆದ, ನಾವು ಘೋಷಿಸಲು ಬಂದಿದೆ

102
00:05:46,240 --> 00:05:48,500
ಮುಖ್ಯ ಎಂದು ಇಂಟ್ ಮುಖ್ಯ ಅನೂರ್ಜಿತ.

103
00:05:48,500 --> 00:05:51,170
ಮತ್ತು ಈ ಬಾರಿ, ಆ ಶೂನ್ಯವನ್ನು ಹೊಂದಿದೆ
ಸರಳವಾಗಿ ಸೂಚಿಸುವ ಮಾಡಲಾಗಿದೆ ಎಂದು

104
00:05:51,170 --> 00:05:54,430
ಪ್ರೋಗ್ರಾಂ ಯಾವುದೇ ತೆಗೆದುಕೊಳ್ಳುವುದಿಲ್ಲ
ಆಜ್ಞಾ ಸಾಲಿನ ಆರ್ಗುಮೆಂಟ್ಗಳನ್ನು.

105
00:05:54,430 --> 00:05:57,750
ಬಳಕೆದಾರರು ನಡೆಸುತ್ತದೆ ಅಂದರೆ,
ಪ್ರೋಗ್ರಾಂ, ಅವನು ಅಥವಾ ಅವಳು ಆಜ್ಞೆಯನ್ನು ಒದಗಿಸಬಹುದು

106
00:05:57,750 --> 00:06:01,710
ಹೆಚ್ಚುವರಿ ಬರೆದು ಸಾಲಿನ ಆರ್ಗುಮೆಂಟ್ಗಳನ್ನು
ಪದಗಳ ನುಡಿಗಟ್ಟುಗಳನ್ನು ನಂತರ ಪ್ರೋಗ್ರಾಂ

107
00:06:01,710 --> 00:06:03,000
ಪ್ರಾಂಪ್ಟಿನಲ್ಲಿ ಹೆಸರಿಸಲು.

108
00:06:03,000 --> 00:06:06,550
>> ಅಲ್ಲದೆ, ನಿಮ್ಮ ಪ್ರೋಗ್ರಾಂ ಬಯಸುವ ನೀವು
ಆಜ್ಞಾ ಸಾಲಿನ ಆರ್ಗುಮೆಂಟ್ಗಳನ್ನು, ಒಂದು ಅಥವಾ ತೆಗೆದುಕೊಳ್ಳಲು

109
00:06:06,550 --> 00:06:10,540
ಹೆಚ್ಚು ಇಂತಹ ಪದಗಳನ್ನು, ನಾವು ಬದಲಿಗೆ ಅಗತ್ಯವಿದೆ
ವಾದಗಳು ಒಂದೆರಡು ನಿರರ್ಥಕ.

110
00:06:10,540 --> 00:06:12,200
ಆದ್ದರಿಂದ ನ ಹಾಗೆ ಅವಕಾಶ.

111
00:06:12,200 --> 00:06:15,750
Cs50.h. ಸೇರಿವೆ

112
00:06:15,750 --> 00:06:19,360
ಸ್ಟ್ಯಾಂಡರ್ಡ್ io.h. ಸೇರಿಸಿ

113
00:06:19,360 --> 00:06:20,760
ಇಂಟ್ ಮುಖ್ಯ.

114
00:06:20,760 --> 00:06:26,330
ಈಗ, ಬದಲಿಗೆ ಶೂನ್ಯದಿಂದ, ನಾನು ಪಡೆಯಲಿದ್ದೇನೆ
ಒಂದು argc ಎಂಬ ಇಂಟ್, ಮತ್ತು ಒಂದು ಸೂಚಿಸಲು

115
00:06:26,330 --> 00:06:28,780
argv ಕರೆಯಲಾಗುತ್ತದೆ ತಂತಿಗಳ ರಚನೆಯ.

116
00:06:28,780 --> 00:06:31,820
ಈಗ argc ಮತ್ತು argv ಇವೆ
ಸರಳವಾಗಿ ಸಂಪ್ರದಾಯಗಳನ್ನು.

117
00:06:31,820 --> 00:06:34,000
>> ನಾವು ವಾದಗಳ ಎಂಬ ಇರಬಹುದು
ನಾವು ಬಯಸುವ ಅತ್ಯಂತ ಏನು.

118
00:06:34,000 --> 00:06:37,630
ಆದರೆ ಯಾವ ಮುಖ್ಯ argc, ಎಂದು
ಒಂದು ಇಂಟ್ ವ್ಯಾಖ್ಯಾನದಿಂದ, ಅದು, ಏಕೆಂದರೆ

119
00:06:37,630 --> 00:06:41,360
ವಾದವನ್ನು ಎಣಿಕೆ ಅನ್ನು ಹೋಗಿ,
ಒಟ್ಟು ಪದಗಳ ಸಂಖ್ಯೆ ಎಂದು

120
00:06:41,360 --> 00:06:43,380
ಬಳಕೆದಾರ ತನ್ನ ಪ್ರಾಂಪ್ಟಿನಲ್ಲಿ ಟೈಪಿಸಿದ.

121
00:06:43,380 --> 00:06:47,910
argv, ಏತನ್ಮಧ್ಯೆ, ವಾದ ವೆಕ್ಟರ್, ಆಗಿದೆ
ವಾಸ್ತವವಾಗಿ ಸಂಗ್ರಹಿಸುವ ಒಂದು ರಚನೆಯ ಏರಲಿದೆ

122
00:06:47,910 --> 00:06:52,020
ಬಳಕೆದಾರ ಹೊಂದಿರುವ ಎಲ್ಲಾ ಪದಗಳಿಂದಕೂಡಿದೆ
ತನ್ನ ಪ್ರಾಂಪ್ಟಿನಲ್ಲಿ ಟೈಪಿಸಿದ.

123
00:06:52,020 --> 00:06:54,500
>> ಈಗ ಏನಾದರೂ ಹೋಗೋಣ
ಈ ಒಂದು ಅಥವಾ ಹೆಚ್ಚು

124
00:06:54,500 --> 00:06:55,660
ಆಜ್ಞಾ ಸಾಲಿನ ಆರ್ಗುಮೆಂಟ್ಗಳನ್ನು.

125
00:06:55,660 --> 00:07:00,070
ನಿರ್ದಿಷ್ಟವಾಗಿ, ಅವರ ಮುಂದೆ ಮತ್ತು ಮುದ್ರಣ ಹೋಗಿ ಅವಕಾಶ
ಯಾವುದೇ ಪದ ಬಳಕೆದಾರ ರೀತಿಯ

126
00:07:00,070 --> 00:07:03,960
ಪ್ರೋಗ್ರಾಂ ಹೆಸರು ನಂತರ
ಪ್ರಾಂಪ್ಟಿನಲ್ಲಿ.

127
00:07:03,960 --> 00:07:04,730
ಮುಕ್ತ ಬ್ರಾಕೆಟ್.

128
00:07:04,730 --> 00:07:06,240
ಮುಚ್ಚಿ ಬ್ರಾಕೆಟ್.

129
00:07:06,240 --> 00:07:10,510
Printf ಶೇಕಡಾ ರು ಬ್ಯಾಕ್ಸ್ಲ್ಯಾಷ್ ಮತ್ತು ಅಲ್ಪವಿರಾಮ.

130
00:07:10,510 --> 00:07:14,550
ಈಗ ನಾನು printf ಯಾವ ಮೌಲ್ಯವನ್ನು ಹೇಳಲು ಅಗತ್ಯವಿದೆ
ಎಂದು ಪ್ಲೇಸ್ಹೋಲ್ಡರ್ ಪ್ಲಗ್.

131
00:07:14,550 --> 00:07:18,600
ನಾನು ಬಳಕೆದಾರ ಹೊಂದಿರುವ ಮೊದಲ ಪದ ಬಯಸುವ
ಪ್ರೋಗ್ರಾಂ ಹೆಸರು ನಂತರ ಟೈಪಿಸಿದ,

132
00:07:18,600 --> 00:07:23,130
ಮತ್ತು ಆದ್ದರಿಂದ ನಾನು ಸೂಚಿಸಲು ಪಡೆಯಲಿದ್ದೇನೆ
argv ಬ್ರಾಕೆಟ್ 1, ನಿಕಟ

133
00:07:23,130 --> 00:07:24,830
ಆವರಣದ ವಿರಾಮ ಚಿಹ್ನೆಯನ್ನು.

134
00:07:24,830 --> 00:07:27,290
>> ಈಗ, ಏಕೆ ಬ್ರಾಕೆಟ್ 1 ಮತ್ತು ಬ್ರಾಕೆಟ್ 0?

135
00:07:27,290 --> 00:07:30,990
ಅಲ್ಲದೆ, ಅದು ಸ್ವಯಂಚಾಲಿತವಾಗಿ ಸಂಗ್ರಹವಾಗಿರುವ, ತಿರುಗಿದರೆ
, argv 0 ಏರಲಿದೆ

136
00:07:30,990 --> 00:07:32,620
ಪ್ರೋಗ್ರಾಂ ನಿಜವಾದ ಹೆಸರು.

137
00:07:32,620 --> 00:07:36,180
ಆದ್ದರಿಂದ ಮೊದಲ ಪದ ಎಂದು ಬಳಕೆದಾರ ರೀತಿಯ
ಪ್ರೋಗ್ರಾಂ ಹೆಸರು, ನಂತರ

138
00:07:36,180 --> 00:07:38,990
ಸಮಾವೇಶ ಏರಲಿದೆ
argv 1 ಸಂಗ್ರಹಿಸಲಾಗಿದೆ.

139
00:07:38,990 --> 00:07:42,380
ಈಗ ಕಂಪೈಲ್ ಲೆಟ್ ಮತ್ತು
ಈ ಪ್ರೋಗ್ರಾಂ.

140
00:07:42,380 --> 00:07:47,780
>> Argv 0, ಡಾಟ್ ಕತ್ತರಿಸಿ, argv 0 ಮಾಡಿ.

141
00:07:47,780 --> 00:07:50,520
ಈಗ ಒಂದು ಪದ ನಿನ್ನ.

142
00:07:50,520 --> 00:07:51,670
ನಮೂದಿಸಿ.

143
00:07:51,670 --> 00:07:53,520
ಹಾಗೂ ನಾವು ಹಲೋ, ಇದು ಹೊಂದಿವೆ.

144
00:07:53,520 --> 00:07:55,750
>> [END ವೀಡಿಯೋ ಪ್ಲೇಬ್ಯಾಕ್]

145
00:07:55,750 --> 00:07:57,000
>> ರಾಬ್ ಬೋಡನ್: ಸರಿ.

146
00:07:57,000 --> 00:07:59,380

147
00:07:59,380 --> 00:08:01,230
ಆತ್ಮೀಯ.

148
00:08:01,230 --> 00:08:16,730
ಆದ್ದರಿಂದ ಪ್ರೋಗ್ರಾಂ ಒಂದು ನೋಟ ತೆಗೆದುಕೊಂಡು ಎಂದು
ನಾವು, ಹಾಗೂ, ನಮಗೆ ಪರಿಚಯಿಸಿದ

149
00:08:16,730 --> 00:08:24,710
ನಾವು 0 ಮುದ್ರಣ argv ವೇಳೆ ಈಗ, ಮಾಡಲು, ತೋರಿಸಲು
ಇದು, argv 0, ಡಾಟ್ ಕತ್ತರಿಸಿ, argv 0 ಏನು.

150
00:08:24,710 --> 00:08:30,440
ನಿರೀಕ್ಷೆ ಆದ್ದರಿಂದ,, ಅದನ್ನು ಮುದ್ರಿಸುವ ವಿಶೇಷವೇನು
argv 0 ಏಕೆಂದರೆ, ಕಾರ್ಯಕ್ರಮದ ಹೆಸರು

151
00:08:30,440 --> 00:08:32,970
ಯಾವಾಗಲೂ ಹೋಗುವ
ಕಾರ್ಯಕ್ರಮದ ಹೆಸರು.

152
00:08:32,970 --> 00:08:35,640
ಆದರೆ ಏನೋ ಒಂದು ಮಾಡಿ
ಹೆಚ್ಚು ಆಸಕ್ತಿದಾಯಕ ಬಿಟ್.

153
00:08:35,640 --> 00:08:42,080
>> ಆದ್ದರಿಂದ ಸಮಸ್ಯೆ ಸೆಟ್, ನೀವು ಇರುವಿರಿ
ಈ ಕಾರ್ಯ, ಅಟೊಯ್ ಪರಿಚಯಿಸಲಾಯಿತು.

154
00:08:42,080 --> 00:08:44,440
ಹಾಗಾಗಿ ನಾವು ಅಟೊಯ್ ಬಳಸುವುದು?

155
00:08:44,440 --> 00:08:48,550
ಆ ಪರಿವರ್ತಿಸಲು ವಿಶೇಷವೇನು ಒಂದು
ಒಂದು ಪೂರ್ಣಾಂಕ ಸ್ಟ್ರಿಂಗ್.

156
00:08:48,550 --> 00:08:53,280
ಹಾಗಾಗಿ ಸ್ಟ್ರಿಂಗ್ ಹಾದು ಒಂದು ಎರಡು ಮೂರು,
ಅಟೊಯ್ ಗೆ, ಎಂದು ಪರಿವರ್ತಿಸಲು ಮಾಡುತ್ತೇವೆ

157
00:08:53,280 --> 00:08:56,910
ಪೂರ್ಣಾಂಕ, ಒಂದು ಎರಡು ಮೂರು.

158
00:08:56,910 --> 00:09:01,480
ನಾವು ಮೊದಲ ಪರಿವರ್ತಿಸಲು ನೀನು
ಒಂದು ಪೂರ್ಣಾಂಕ ಆಜ್ಞಾ ಸಾಲಿನ ವಾದವನ್ನು,

159
00:09:01,480 --> 00:09:05,690
ತದನಂತರ ಕೇವಲ ಪೂರ್ಣಾಂಕ ಮುದ್ರಿಸಲು.

160
00:09:05,690 --> 00:09:09,680
>> ಆದ್ದರಿಂದ ಮೂಲಭೂತವಾಗಿ, ನಾವು ರೀತಿಯ ಆರ್
ಕೇವಲ, GetInt reimplementing

161
00:09:09,680 --> 00:09:12,350
ಪೂರ್ಣಾಂಕ ಕಮ್ಯಾಂಡ್ ದಾಖಲಿಸಿದರೆ
ಲೈನ್ ಬದಲಿಗೆ ಕಾರ್ಯಕ್ರಮದಲ್ಲಿ

162
00:09:12,350 --> 00:09:14,560
ಸಂವಾದಾತ್ಮಕವಾಗಿ.

163
00:09:14,560 --> 00:09:23,170
ಆದ್ದರಿಂದ, argv 0 ಮಾಡುವ, ಹಾಗೆ ನಾವು
ಇಲ್ಲಿ ಅದನ್ನು, ಮತ್ತು ಮುಚ್ಚಿ.

164
00:09:23,170 --> 00:09:27,670
ಆದ್ದರಿಂದ argv 0 ಚಾಲನೆಯಲ್ಲಿರುವ, ಮತ್ತು ನ ನಮೂದಿಸಿ
ಪೂರ್ಣಾಂಕ, ಒಂದು ಎರಡು ಮೂರು ನಾಲ್ಕು ಒಂದು ಎರಡು.

165
00:09:27,670 --> 00:09:30,840
ಆದ್ದರಿಂದ, ಒಂದು ಪೂರ್ಣಾಂಕ ಮುದ್ರಿಸಲು ಮಾಡುತ್ತೇವೆ
ಎರಡು ಮೂರು ನಾಲ್ಕು ಒಂದು ಎರಡು.

166
00:09:30,840 --> 00:09:35,500
ಎಂದು ATOI ಕೆಲವು ಸೂಕ್ಷ್ಮತೆಗಳನ್ನು ಇವೆ
ಇದು ಏನು ಬಗ್ಗೆ caring ನಿಲ್ಲಿಸಲು ವಿಲ್

167
00:09:35,500 --> 00:09:39,040
ಮಾನ್ಯ ಸಂಖ್ಯಾ ಪಾತ್ರ ಮೀರಿ,
ಆದರೆ ಪರವಾಗಿಲ್ಲ.

168
00:09:39,040 --> 00:09:42,870
>> ಆದ್ದರಿಂದ ನೀವು ಏನಾಗುತ್ತದೆ ತಿಳಿದಿರುವಿರಿ
ನಾನು ಇದನ್ನು ಮಾಡಿದರೆ?

169
00:09:42,870 --> 00:09:45,520

170
00:09:45,520 --> 00:09:47,050
ವಿಭಾಗಗಳ ತಪ್ಪು.

171
00:09:47,050 --> 00:09:50,410
ಆದ್ದರಿಂದ ಏಕೆ ಎಂದು?

172
00:09:50,410 --> 00:09:56,060
ನೀವು ನಮ್ಮ ಪ್ರೋಗ್ರಾಂ ಹಿಂದೆ ನೋಡಿದರೆ, ನಾವು
argv 1, ಮೊದಲ ವಾದವನ್ನು ಪರಿವರ್ತಿಸುವ

173
00:09:56,060 --> 00:09:59,610
ಪ್ರೋಗ್ರಾಂ ಹೆಸರು ನಂತರ, ಒಂದು ಪೂರ್ಣಾಂಕ.

174
00:09:59,610 --> 00:10:03,350
ಆದರೆ ಜಾರಿಗೆ ಯಾವುದೇ ವಾದವಿದೆ
ಪ್ರೋಗ್ರಾಂ ಹೆಸರು ನಂತರ.

175
00:10:03,350 --> 00:10:08,060
ಇಲ್ಲಿ, ನಾವು ಈ ಒಂದು ದೋಷಯುಕ್ತ ನೋಡಿ
ಪ್ರೋಗ್ರಾಂ, ರಿಂದ, ನಾವು ರನ್ ಪ್ರಯತ್ನಿಸಿ

176
00:10:08,060 --> 00:10:10,530
ವಾದಗಳನ್ನು ಇಲ್ಲದೆ,
ಇದು ಕೇವಲ ಕುಸಿತಕ್ಕೆ ಮಾಡುತ್ತದೆ.

177
00:10:10,530 --> 00:10:16,950
>> ನೀವು ನೋಡುತ್ತಾರೆ ಆದ್ದರಿಂದ ಮತ್ತೊಂದು ಸಾಮಾನ್ಯ ಮಾದರಿ
ಏನೋ ಹಾಗೆ, argc, ಕಡಿಮೆ ವೇಳೆ

178
00:10:16,950 --> 00:10:21,100
ಇಲ್ಲ ಎಂದು ಸೂಚಿಸುವ ಎರಡು, ಹೆಚ್ಚು
ಕನಿಷ್ಠ ಕಾರ್ಯಕ್ರಮ ಹೆಸರು ಮತ್ತು

179
00:10:21,100 --> 00:10:29,100
ಮೊದಲ ವಾದವನ್ನು, ನಾವು ಏನಾದರೂ ಮಾಡುತ್ತೇವೆ
ಹಾಗೆ printf, ಸಾಕಾಗುವುದಿಲ್ಲ

180
00:10:29,100 --> 00:10:31,190
ಆಜ್ಞಾ ಸಾಲಿನ ಆರ್ಗುಮೆಂಟ್ಗಳನ್ನು.

181
00:10:31,190 --> 00:10:33,170
ಬಹುಶಃ ಮುದ್ರಿಸಲು ಉತ್ತಮ ಅಲ್ಲ,
ಇದು ಹಾಗೆ, ಬಹುಶಃ ವಿಷಯ

182
00:10:33,170 --> 00:10:35,440
ನೀವು ಒಂದು ಪೂರ್ಣಾಂಕ ನಮೂದಿಸಬೇಕು
ಆಜ್ಞಾ ಸಾಲಿನಲ್ಲಿ.

183
00:10:35,440 --> 00:10:37,450
ನಾನು ಅದನ್ನು ಕೊನೆಗೊಳ್ಳುತ್ತದೆ ಮಾಡುತ್ತೇವೆ.

184
00:10:37,450 --> 00:10:39,600
ತದನಂತರ 1 ಮರಳಲು.

185
00:10:39,600 --> 00:10:44,740
ಆದ್ದರಿಂದ ನಮ್ಮ ಕೊನೆಯಲ್ಲಿ ನೆನಪು
ಪ್ರೋಗ್ರಾಂ, ನಾವು 0 ಮರಳಲು ವೇಳೆ, ಆ ರೀತಿಯ

186
00:10:44,740 --> 00:10:47,060
ಯಶಸ್ಸನ್ನು ಸೂಚಿಸುತ್ತದೆ.

187
00:10:47,060 --> 00:10:50,940
ಮತ್ತು ಮುಖ್ಯ ಸ್ವಯಂಚಾಲಿತವಾಗಿ
ನೀವು ವೇಳೆ 0 ಹಿಂದಿರುಗಿಸುತ್ತದೆ.

188
00:10:50,940 --> 00:10:55,800
>> ಇಲ್ಲಿ, ನಾವು ಸೂಚಿಸಲು 1 retuning ಮಾಡುತ್ತಿದ್ದೇವೆ
ಯಶಸ್ಸು ಅಲ್ಲ ಎಂದು.

189
00:10:55,800 --> 00:11:01,000
ಮತ್ತು ನೀವು ಬಯಸುವ ಯಾವುದೇ ಮರಳಬಹುದು,
ಕೇವಲ, 0 ಯಶಸ್ಸನ್ನು ಸೂಚಿಸುತ್ತದೆ, ಮತ್ತು

190
00:11:01,000 --> 00:11:03,390
ಬೇರೇನೂ ವೈಫಲ್ಯ ಸೂಚಿಸುತ್ತದೆ.

191
00:11:03,390 --> 00:11:04,855
ಆದ್ದರಿಂದ ವಸ್ತುಗಳ ಈ ಆವೃತ್ತಿ ರನ್ ಅವಕಾಶ.

192
00:11:04,855 --> 00:11:12,880

193
00:11:12,880 --> 00:11:16,600
ಈಗ, ನಾವು ಆಜ್ಞಾ ಸಾಲಿನ ನಮೂದಿಸಿ ಇದ್ದರೆ
ವಾದ, ಅದು ಸರಿಯಾಗಿ ಹೇಳುತ್ತೇನೆ

194
00:11:16,600 --> 00:11:18,290
ನಮಗೆ ಸಾಕಷ್ಟು ಆಜ್ಞಾ ಸಾಲಿನ ಅಲ್ಲ.

195
00:11:18,290 --> 00:11:20,610
ವಾಕ್ಯ ಮುಗಿಸಲು ಇಲ್ಲ.

196
00:11:20,610 --> 00:11:24,950
ಬೇರೆ, ನಾವು ವಾಸ್ತವವಾಗಿ ಇದು ಒಂದು ಹಾದು
ಇದು ಪ್ರೋಗ್ರಾಂ ಪೂರ್ಣಗೊಳಿಸುತ್ತದೆ.

197
00:11:24,950 --> 00:11:27,920
ಆದ್ದರಿಂದ ಈ ನೀವು argc, ಬಳಸಲು ಹೇಗೆ ಹೊಂದಿದೆ
ಸಂಖ್ಯೆ ಮೌಲ್ಯೀಕರಿಸಲು ಸಲುವಾಗಿ

198
00:11:27,920 --> 00:11:30,630
ಆಜ್ಞಾ ಸಾಲಿನ ಆರ್ಗುಮೆಂಟ್ಗಳನ್ನು ಎಂದು
ವಾಸ್ತವವಾಗಿ ರವಾನಿಸಲ್ಪಡುತ್ತದೆ.

199
00:11:30,630 --> 00:11:39,360
>> ಆದ್ದರಿಂದ ಸ್ವಲ್ಪ ಹೆಚ್ಚು ಈ ಪ್ರೋಗ್ರಾಂ ಮಾಡೋಣ
ಸಂಕೀರ್ಣ, ಮತ್ತು ಎರಡನೇ ನೋಡಲು

200
00:11:39,360 --> 00:11:42,180
ವಸ್ತುಗಳ ಪುನರಾವರ್ತನೆ.

201
00:11:42,180 --> 00:11:46,310
ಈಗ, ನಾವು ಕೇವಲ ಮುದ್ರಣ ಇಲ್ಲ
ಮೊದಲ ಆಜ್ಞಾ ಸಾಲಿನ ವಾದವನ್ನು.

202
00:11:46,310 --> 00:11:51,210
ಇಲ್ಲಿ, ನಾವು ಇಂಟ್ ನಾನು ಸಮನಾಗಿರುತ್ತದೆ ರಿಂದ iterating ನೀವು
0, ನಾನು argc, ಕಡಿಮೆ ಪ್ಲಸ್

203
00:11:51,210 --> 00:11:55,280
ಜೊತೆಗೆ, ಮತ್ತು ಮುದ್ರಣ, argv, ಸೂಚ್ಯಂಕ ನಾನು.

204
00:11:55,280 --> 00:11:59,300
ಆದ್ದರಿಂದ ಈ ಮಾದರಿ, ಮತ್ತೆ, ಈ ಒಂದೇ
ಬದಲಿಗೆ ಹೊರತುಪಡಿಸಿ ಮೊದಲು ಮಾದರಿಯನ್ನು,

205
00:11:59,300 --> 00:12:02,600
ವೇರಿಯಬಲ್ ಕರೆ
ಎನ್, ನಾವು argc ಬಳಸುತ್ತಿರುವ.

206
00:12:02,600 --> 00:12:09,520
>> ಆದ್ದರಿಂದ ಈ ಪ್ರತಿ ಸೂಚ್ಯಂಕ ಮೇಲೆ iterating ಇದೆ
ಶ್ರೇಣಿಯಲ್ಲಿನ, ಮತ್ತು ಪ್ರತಿ ಮುದ್ರಿಸುವ

207
00:12:09,520 --> 00:12:11,910
ಆ ಶ್ರೇಣಿಯಲ್ಲಿನ ಅಂಶ.

208
00:12:11,910 --> 00:12:20,300
ಆದ್ದರಿಂದ, ನಾವು ಈ ಪ್ರೋಗ್ರಾಂ, ಚೆನ್ನಾಗಿ,
ನಾನು ಯಾವುದೇ ಆಜ್ಞಾ ಸಾಲಿನ ಪ್ರವೇಶಿಸಲಿಲ್ಲ

209
00:12:20,300 --> 00:12:22,540
ವಾದಗಳು, ಕೇವಲ ಮುದ್ರಿತ ಅದು
ಪ್ರೋಗ್ರಾಂ ಹೆಸರು.

210
00:12:22,540 --> 00:12:26,053
ನಾನು ವಸ್ತುಗಳ ಒಂದು ಗುಂಪೇ ನಮೂದಿಸಿ, ಅದನ್ನು ಮಾಡುತ್ತೇವೆ
ಒಂದು, ತನ್ನದೇ ಸಾಲಿನಲ್ಲಿ ಪ್ರತಿ ಮುದ್ರಿಸಲು.

211
00:12:26,053 --> 00:12:31,213

212
00:12:31,213 --> 00:12:32,210
>> ಸರಿ.

213
00:12:32,210 --> 00:12:34,770
ಆದ್ದರಿಂದ ಇನ್ನೂ ಒಂದು ಹೆಜ್ಜೆ ನೋಡೋಣ.

214
00:12:34,770 --> 00:12:38,890
ಬದಲಿಗೆ ಪ್ರತಿ ವಾದ ಮುದ್ರಿಸುವ
ತನ್ನದೇ ಸಾಲಿನಲ್ಲಿ, ನ ಪ್ರತಿ ಮುದ್ರಿಸಲು ಅವಕಾಶ

215
00:12:38,890 --> 00:12:42,590
ಪ್ರತಿ ವಾದದ ಪಾತ್ರ
ತನ್ನದೇ ಸಾಲಿನಲ್ಲಿ.

216
00:12:42,590 --> 00:12:46,700
ಆದ್ದರಿಂದ argv ನೆನಪು
ತಂತಿಗಳ ಒಂದು ಸರಣಿ.

217
00:12:46,700 --> 00:12:50,960
ಹಾಗಾಗಿ ಒಂದು ಸ್ಟ್ರಿಂಗ್ ಆಗಿದೆ, ಆದರೆ
ಪಾತ್ರಗಳು ಒಂದು ಶ್ರೇಣಿಯನ್ನು?

218
00:12:50,960 --> 00:12:57,140
ಆದ್ದರಿಂದ, argv ನಿಜವಾಗಿಯೂ ಎಂದರ್ಥ
ಪಾತ್ರಗಳು ಒಂದು ಶ್ರೇಣಿಯನ್ನು ರಚನೆಯ.

219
00:12:57,140 --> 00:13:04,920
ಆದ್ದರಿಂದ ಆ ಅನುಕೂಲ ಪಡೆದು,
ಈಗ ಈ ನಿರ್ಲಕ್ಷಿಸಿ.

220
00:13:04,920 --> 00:13:08,190
ಕೇವಲ ಸ್ಟ್ರಿಂಗ್ argv 0 ಪರಿಗಣಿಸೋಣ.

221
00:13:08,190 --> 00:13:14,170
>> ನಾವು ಪ್ರತಿ ಪಾತ್ರದ ತರಲು ಬಯಸುವ ಹಾಗಿದ್ದಲ್ಲಿ
argv 0 ತನ್ನದೇ ಸಾಲಿನಲ್ಲಿ, ನಂತರ ನಾನು ಬಯಸುವ

222
00:13:14,170 --> 00:13:19,500
ನಾವು ಬಳಸಲಾಗುತ್ತದೆ ನೀವು ಮಾದರಿ ಮಾಡಲು, ನಾನು
ರಚನೆಯ ಉದ್ದ ಕಡಿಮೆ,

223
00:13:19,500 --> 00:13:23,990
ಇಲ್ಲಿ, ಆಫ್ strlen ಇದು ಇಲ್ಲಿದೆ
ನಾನು ಬಯಸುವುದಿಲ್ಲ ಎಂಬುದನ್ನು, ಸ್ಟ್ರಿಂಗ್

224
00:13:23,990 --> 00:13:26,450
ಗಳು, argv 0 ಸಮನಾಗಿರುತ್ತದೆ.

225
00:13:26,450 --> 00:13:30,390
ಆದ್ದರಿಂದ ನಾನು ನಮ್ಮ ಉದ್ದ ಕಡಿಮೆ
ಈ ಸಂದರ್ಭದಲ್ಲಿ ಒಂದು ರಚನೆ ಸರಣಿ

226
00:13:30,390 --> 00:13:34,410
ಪಾತ್ರಗಳು, ನಾನು ಜೊತೆಗೆ ಹೆಚ್ಚು.

227
00:13:34,410 --> 00:13:41,040
ನಾವು ಕಳೆದ ವಾರ ಕಂಡಿತು ಮತ್ತು ಆದ್ದರಿಂದ,, ಇದನ್ನು ಮಾದರಿ
ನಾವು ಹೊರಗೆ strlen ಎಂದು ಸರಿಸಲು

228
00:13:41,040 --> 00:13:45,210
ಪರಿಸ್ಥಿತಿಯ, ರಿಂದ ಎನ್ ಸೇರಿಸುವ
ರು, strlen ನಾವು ಹೋಗಿ ಪ್ರತಿ ಬಾರಿ

229
00:13:45,210 --> 00:13:47,720
ಲೂಪ್ ಮೂಲಕ, ಮತ್ತು ಇದು
ಬದಲಾವಣೆ ಮಾಡಲು ಸಾಧ್ಯವಿಲ್ಲ.

230
00:13:47,720 --> 00:13:50,230
ನಾವು ಇಲ್ಲಿ ಮೇಲೆ ಎನ್ ಸಮನಾದ ಸೆಟ್ ಮಾಡುತ್ತೇವೆ.

231
00:13:50,230 --> 00:13:54,260

232
00:13:54,260 --> 00:13:55,170
>> ಸರಿ.

233
00:13:55,170 --> 00:14:01,320
ಈಗ, ನಾವು ಮೇಲೆ iterating
ರಚನೆಯ ಪ್ರತಿ ಸೂಚ್ಯಂಕ.

234
00:14:01,320 --> 00:14:05,630
ಆದ್ದರಿಂದ, ನಾವು ಪ್ರತಿ ಮುದ್ರಿಸಲು ಬಯಸಿದರೆ
ಆ ಸರಣಿ, ಶೇಕಡಾ ಸಿ ಪಾತ್ರ

235
00:14:05,630 --> 00:14:06,880
ನಾವು ಬಳಸಲು ಬಯಸುವ ಧ್ವಜ
ಪಾತ್ರಗಳು.

236
00:14:06,880 --> 00:14:10,750

237
00:14:10,750 --> 00:14:19,770
ಈಗ ಒಂದು ಬ್ರಾಕೆಟ್ ನಾನು ಏರಲಿದೆ
ಸ್ಟ್ರಿಂಗ್, ಸೂಚ್ಯಂಕ ಪಾತ್ರದ ನಾನು, ಹಾಗಾಗಿ

238
00:14:19,770 --> 00:14:20,970
ಸ್ಟ್ರಿಂಗ್ ಹಲೋ ಇದ್ದರು.

239
00:14:20,970 --> 00:14:27,530
ನಂತರ ಬ್ರಾಕೆಟ್, 0 ಗ ಏರಲಿದೆ ಎಸ್ ಎಸ್
1 ಹೀಗೆ ಇ, ಮತ್ತು.

240
00:14:27,530 --> 00:14:30,800
>> ಈಗ ನಾವು ಒಗ್ಗೂಡಿ ಬಯಸುವ
ಈ ಎರಡು ವಿಷಯಗಳನ್ನು.

241
00:14:30,800 --> 00:14:35,440
ನಾವು ಪ್ರತಿ ಪಾತ್ರದ ಮುದ್ರಿಸಲು ಬಯಸುವ
ಪ್ರತಿ ಆಜ್ಞಾ ಸಾಲಿನ ವಾದದ.

242
00:14:35,440 --> 00:14:38,950
ಹಾಗಾಗಿ ನಾವು ನೀನು
ಲೂಪ್ ರೀತಿಯಲ್ಲಿ.

243
00:14:38,950 --> 00:14:47,480
ಮತ್ತು ಸಾಂಪ್ರದಾಯಿಕವಾಗಿ, ಮೊದಲ ಕೌಂಟರ್
ನಾನು, ಮುಂದಿನ ಜೆ ಏರಲಿದೆ, N ಇದೆ

244
00:14:47,480 --> 00:14:54,450
argv ನಾನು, strlen ಇರುತ್ತದೆ, ನಾನು
ಕಡಿಮೆ N, ನಾನು ಜೊತೆಗೆ ಪ್ಲಸ್ ಆಗಿದೆ.

245
00:14:54,450 --> 00:14:59,150

246
00:14:59,150 --> 00:15:06,870
ಈಗ ಬದಲಿಗೆ ಮುದ್ರಣ, argv ನಾನು, ಆದ್ದರಿಂದ
ನಾನು ಸೂಚ್ಯಂಕ ಹೋಗುತ್ತದೆ, argv ಬ್ರಾಕೆಟ್ -

247
00:15:06,870 --> 00:15:14,280
ನಾನು ನೇ ಆಜ್ಞಾ ಸಾಲಿನ ಎಂದು ವಿಶೇಷವೇನು
ವಾದ, argv ನಾನು, ಜೆ ಹೋಗುತ್ತದೆ

248
00:15:14,280 --> 00:15:16,925
jth ಪಾತ್ರದ ಎಂದು
I-ನೇ ವಾದ.

249
00:15:16,925 --> 00:15:20,580

250
00:15:20,580 --> 00:15:24,810
ನಾನು ಈಗ ಇಲ್ಲಿ ಈ ಅಪ್ ತೊಡೆದುಹಾಕಲು ಮಾಡುತ್ತೇವೆ
ನಾವು ಲೂಪ್ ಹಾಕಿದರೆ ರಿಂದ.

251
00:15:24,810 --> 00:15:33,900
ಆದ್ದರಿಂದ ಸ್ಟ್ರಿಂಗ್ ರು ಸಮ ಸಮ
argv ನಾನು, ತದನಂತರ ರು ಬ್ರಾಕೆಟ್ ಜೆ.

252
00:15:33,900 --> 00:15:36,980
>> ಹಾಗೆಯೇ, ನಾವು ಘೋಷಿಸಲು ಅವಶ್ಯಕತೆ ಇಲ್ಲ
ಈ ವೇರಿಯಬಲ್ ರು.

253
00:15:36,980 --> 00:15:44,530
ಬದಲಾಗಿ, ನಾವು ಈ ಒಗ್ಗೂಡಿ ಮಾಡುತ್ತೇವೆ
ನಾವು ಯಾವ ಎರಡು, ಜೆ ನಾನು argv.

254
00:15:44,530 --> 00:15:45,780
>> ಸ್ಪೀಕರ್ 1: [ಕೇಳಿಸುವುದಿಲ್ಲ].

255
00:15:45,780 --> 00:15:48,850

256
00:15:48,850 --> 00:15:49,680
>> ರಾಬ್ ಬೋಡನ್: ಗುಡ್ ಕರೆ.

257
00:15:49,680 --> 00:15:52,936
ಆದ್ದರಿಂದ ಈ ಮುರಿದಿದೆ.

258
00:15:52,936 --> 00:15:55,510
ನಾನು ವಾಸ್ತವವಾಗಿ ಇದು ನಡೆಯಿತು, ನಾವು
ಈ ಅರಿತುಕೊಂಡ.

259
00:15:55,510 --> 00:16:01,210
ನಾನು ಕಾಳಜಿ ಆದ್ದರಿಂದ ಕೌಂಟರ್
ಈ ನಿರ್ದಿಷ್ಟವಾಗಿ

260
00:16:01,210 --> 00:16:05,410
ಲೂಪ್ ಜೆ, iterator, ಆಗಿದೆ.

261
00:16:05,410 --> 00:16:08,560
ಆದ್ದರಿಂದ ನೀವು ಸಮಸ್ಯೆಗಳಿಗೆ ರನ್ ಎಂದು,
ಬಹುಶಃ ಅನಂತ ಆದೇಶಗಳ, ನಾವು

262
00:16:08,560 --> 00:16:09,540
ಸ್ಥಿರ ಇರಲಿಲ್ಲ.

263
00:16:09,540 --> 00:16:12,220
ನಾವು ಮಾತನಾಡುವ ನೀವು ಏಕೆ ಆ
ಬಗ್ಗೆ ಇಂದು ಡೀಬಗ್.

264
00:16:12,220 --> 00:16:13,120
>> ಸರಿ.

265
00:16:13,120 --> 00:16:15,240
ಆದ್ದರಿಂದ ಈ ಪ್ರೊಗ್ರಾಮ್ ರನ್ ಅವಕಾಶ.

266
00:16:15,240 --> 00:16:21,200
ಮತ್ತು ವಾಸ್ತವವಾಗಿ ಒಂದು ಪ್ರತ್ಯೇಕ printf ಸೇರಿಸಲು ಅವಕಾಶ
ಇಲ್ಲಿಯೇ ಕೇವಲ ಮುದ್ರಿಸಲು ಎಂದು

267
00:16:21,200 --> 00:16:27,480
ಈ ಅರ್ಥ ರಿಂದ ಮತ್ತೊಂದು ಲೈನ್, ನಾವು
ಪ್ರೊಗ್ರಾಮನ್ನು, ಒಂದು ಖಾಲಿ ಇರುತ್ತದೆ ಮಾಡುತ್ತೇವೆ

268
00:16:27,480 --> 00:16:31,830
ಪ್ರತಿ ಪಾತ್ರದ ನಡುವೆ ಲೈನ್
ಪ್ರತಿ ಆಜ್ಞಾ ಸಾಲಿನ ವಾದವನ್ನು.

269
00:16:31,830 --> 00:16:33,448
ಅಲ್ಲದೆ, ನಾವು ಅರ್ಥವನ್ನು ನೋಡುತ್ತಾರೆ.

270
00:16:33,448 --> 00:16:37,310

271
00:16:37,310 --> 00:16:37,790
ಓಪ್.

272
00:16:37,790 --> 00:16:39,870
ಕೆಲವು ದೋಷ ಸಿಕ್ಕಿತು.

273
00:16:39,870 --> 00:16:42,860
ದೋಷ ಸೂಚ್ಯವಾಗಿ ಘೋಷಿಸುವ
ಲೈಬ್ರರಿ ಫಂಕ್ಷನ್ strlen.

274
00:16:42,860 --> 00:16:51,630
>> ಆದ್ದರಿಂದ ನಮ್ಮ ಪ್ರೋಗ್ರಾಂ ಒಳಗೆ ತರುವುದನ್ನು, ನಾನು
string.h ಸೇರಿವೆ ಹ್ಯಾಶ್ ಮರೆತುಹೋಗಿದೆ.

275
00:16:51,630 --> 00:16:54,240

276
00:16:54,240 --> 00:16:57,730
ಆದ್ದರಿಂದ string.h ಏರಲಿದೆ
ಘೋಷಿಸುತ್ತದೆ ಹೆಡರ್ ಕಡತವನ್ನು

277
00:16:57,730 --> 00:16:58,980
ಕಾರ್ಯ strlen.

278
00:16:58,980 --> 00:17:04,650

279
00:17:04,650 --> 00:17:06,060
ಸರಿ, ಸಂಗ್ರಹಿಸುತ್ತಾ.

280
00:17:06,060 --> 00:17:09,109
ಈಗ, ನ ಚಲಾಯಿಸಲು ಅವಕಾಶ.

281
00:17:09,109 --> 00:17:10,930
ಆದ್ದರಿಂದ ಕೇವಲ.

282
00:17:10,930 --> 00:17:17,790
ಅದನ್ನು ಮುದ್ರಿಸಲು ವಿಶೇಷವೇನು ನಮ್ಮ
ಪ್ರೋಗ್ರಾಂ ಹೆಸರು, ಹಲೋ ವರ್ಲ್ಡ್.

283
00:17:17,790 --> 00:17:23,510
ಇದು ಪ್ರತಿ, ಪ್ರತಿ ವಿಷಯ ಮುದ್ರಿಸಲು ವಿಶೇಷವೇನು
ತನ್ನದೇ ಸಾಲಿನಲ್ಲಿ ಪಾತ್ರ.

284
00:17:23,510 --> 00:17:24,540
ಸರಿ.

285
00:17:24,540 --> 00:17:30,625
>> ಆದ್ದರಿಂದ ಅವರ ವಾಸ್ತವವಾಗಿ ಈ ನೋಡೋಣ
ಮತ್ತಷ್ಟು ಒಂದು ಹೆಜ್ಜೆ.

286
00:17:30,625 --> 00:17:34,050

287
00:17:34,050 --> 00:17:39,700
ಮತ್ತು ಬದಲಿಗೆ string.h ಬಳಸಿಕೊಂಡು, ಹೊರಡೋಣ
ನಾವು ನಮ್ಮ ಕಾರ್ಯಗತಗೊಳಿಸಲು ಬಯಸುವ ಹೇಗೆ ಬಗ್ಗೆ

288
00:17:39,700 --> 00:17:41,420
strlen ಕಾರ್ಯ.

289
00:17:41,420 --> 00:17:45,600
ಹಾಗಾಗಿ ತಕ್ಷಣ ನೀಡುತ್ತೇನೆ
ಒಂದು ಕಾರ್ಯ ಸಹಿ.

290
00:17:45,600 --> 00:17:52,900
ಆದ್ದರಿಂದ my_strlen ಕರೆ ಅವಕಾಶ, ಮತ್ತು ಇದು
ವಾದವನ್ನು ಸ್ಟ್ರಿಂಗ್ ತೆಗೆದುಕೊಳ್ಳುವುದು,

291
00:17:52,900 --> 00:17:57,220
ಮತ್ತು ನಾವು ಮರಳಲು ನಿರೀಕ್ಷಿಸಬಹುದು
ಎಂದು ಸ್ಟ್ರಿಂಗ್ ಉದ್ದ.

292
00:17:57,220 --> 00:18:03,430
ಆದ್ದರಿಂದ, ಅಲ್ಲಿ ಆ ವ್ಯಕ್ತಿ?

293
00:18:03,430 --> 00:18:04,990
ಹೌದು.

294
00:18:04,990 --> 00:18:06,740
ಸರಿ.

295
00:18:06,740 --> 00:18:12,900
ಆದ್ದರಿಂದ ಹಿಂದಿನ ಸ್ಲೈಡ್ ನೆನಪು ಎಂದು
, ಕಳೆದ ವಾರ ಕೂಡ ಎಂದು

296
00:18:12,900 --> 00:18:18,890
ಅಕ್ಷರಗಳ ಸರಣಿ, ಚೆನ್ನಾಗಿ, ಸ್ಟ್ರಿಂಗ್,
ಆದ್ದರಿಂದ ಈ ನಮ್ಮ ಸ್ಟ್ರಿಂಗ್ ರು ಹೇಳುತ್ತಾರೆ.

297
00:18:18,890 --> 00:18:29,870
ಆದ್ದರಿಂದ ರು ಸ್ಟ್ರಿಂಗ್ ವೇಳೆ, ಹಲೋ, ನಂತರ,
ಹೆಚ್ ಇ ಎಲ್ ಎಲ್ ಒ ಮೆಮೊರಿ, ಎಂದು ವಿಶೇಷವೇನು

298
00:18:29,870 --> 00:18:35,610
ನಂತರ ಈ ಬ್ಯಾಕ್ಸ್ಲ್ಯಾಷ್ ಎಂದು, ಮತ್ತು
0 ಪಾತ್ರದ.

299
00:18:35,610 --> 00:18:39,170
>> ಆದ್ದರಿಂದ ಹೇಗೆ ನಾವು ರು ಉದ್ದ ಸಿಗುತ್ತದೆ?

300
00:18:39,170 --> 00:18:43,190
ಅಲ್ಲದೆ, ಟ್ರಿಕ್ ಈ ನೋಡುತ್ತಿರುತ್ತದೆ
0 ಪಾತ್ರದ, ಈ ಶೂನ್ಯ ಬ್ಯಾಕ್ಲ್ಯಾಷ್

301
00:18:43,190 --> 00:18:44,380
ಟರ್ಮಿನೇಟರ್.

302
00:18:44,380 --> 00:18:50,270
ಆದ್ದರಿಂದ ಕ್ರಮಾವಳಿ ಹೋಗುತ್ತದೆ
ಕೆಲವು ರೀತಿಯ ಎಂದು

303
00:18:50,270 --> 00:18:51,510
ಸಾಕಷ್ಟು ಪಾತ್ರಗಳು ಎಂದು -

304
00:18:51,510 --> 00:18:56,180
ಈ ಕೈ ಕೆಲವು ಪ್ರತಿನಿಧಿಸಲು ಅವಕಾಶ
ಕೌಂಟರ್, ಈ ಇಂಟ್ ಉದ್ದ ಕರೆ ಅವಕಾಶ.

305
00:18:56,180 --> 00:19:00,060
ಆದ್ದರಿಂದ, ಇಲ್ಲಿ ಆರಂಭಿಸಿ, ನಾವು
ನಮ್ಮ ಸ್ಟ್ರಿಂಗ್ ಮೇಲೆ ತಿರುಗಿ ಹೋಗುವ.

306
00:19:00,060 --> 00:19:04,100
>> ಆದ್ದರಿಂದ, ಇದು ಎಚ್ ಮೊದಲ ಪಾತ್ರದ,
ಇದು ಮತ್ತೆ ಆದ್ದರಿಂದ, 0 ಕಡಿದು ಅಲ್ಲ

307
00:19:04,100 --> 00:19:05,170
ಉದ್ದ 1.

308
00:19:05,170 --> 00:19:08,050
ಮುಂದಿನ ಅಕ್ಷರಕ್ಕೆ ತಿರುಗಿ,
ಇ, ಮತ್ತು 0 ಬ್ಯಾಕ್ಸ್ಲ್ಯಾಷ್ ಅಲ್ಲ.

309
00:19:08,050 --> 00:19:09,630
ಉದ್ದ 2.

310
00:19:09,630 --> 00:19:10,960
ಎಲ್, 3.

311
00:19:10,960 --> 00:19:11,850
ಎಲ್, 4.

312
00:19:11,850 --> 00:19:13,050
ಓ, 5.

313
00:19:13,050 --> 00:19:16,690
ಮತ್ತು ಅಂತಿಮವಾಗಿ, ನಾವು ಬ್ಯಾಕ್ಸ್ಲ್ಯಾಷ್ ತಲುಪಲು
0, ಮತ್ತು ಆದ್ದರಿಂದ ಅರ್ಥ, ಚೆನ್ನಾಗಿ,

314
00:19:16,690 --> 00:19:17,780
ಈ ಸಾಲನ್ನು ಮೇಲೆ ಆಗಿದೆ.

315
00:19:17,780 --> 00:19:20,130
ಆದ್ದರಿಂದ 5 ಹಿಂದಿರುಗಲು ಅವಕಾಶ.

316
00:19:20,130 --> 00:19:33,630
>> ಆದ್ದರಿಂದ ವಾಸ್ತವವಾಗಿ, ಮೊದಲ, ಆ ಅನುಷ್ಠಾನಕ್ಕೆ
ನನ್ನ N ಉದ್ದ ನನ್ನ ಬಲಗೈ, 0 ಸಮನಾಗಿರುತ್ತದೆ.

317
00:19:33,630 --> 00:19:36,088
ಮತ್ತು ನಾವು ತಿರುಗಿ ನೀನು -

318
00:19:36,088 --> 00:19:38,000
>> ಸ್ಪೀಕರ್ 1: [ಕೇಳಿಸುವುದಿಲ್ಲ]

319
00:19:38,000 --> 00:19:38,640
>> ರಾಬ್ ಬೋಡನ್: ಓಹ್, ಶೂಟ್.

320
00:19:38,640 --> 00:19:39,870
ಒಳ್ಳೆಯ ಕರೆ.

321
00:19:39,870 --> 00:19:42,680
ಬೂಮ್.

322
00:19:42,680 --> 00:19:44,140
ಆದ್ದರಿಂದ N ಉದ್ದ 0 ಸಮನಾಗಿರುತ್ತದೆ.

323
00:19:44,140 --> 00:19:46,910

324
00:19:46,910 --> 00:19:58,310
ಈಗ, ಹಾಗೆಯೇ ರು ಉದ್ದ ಮಾಡುವುದಿಲ್ಲ
ನಂತರ ಸಮಾನ ಮತ್ತು, ಬ್ಯಾಕ್ಸ್ಲ್ಯಾಷ್ 0.

325
00:19:58,310 --> 00:20:04,660
ಆದ್ದರಿಂದ, ಈ ಬ್ಯಾಕ್ಸ್ಲ್ಯಾಷ್ 0 ನೆನಪಿಡಿ, ಇದು ಒಂದು ಆಗಿದೆ
ನಿಜವಾದ ಪಾತ್ರ, ಮತ್ತು ಇದು ಸೂಚಿಸುತ್ತದೆ

326
00:20:04,660 --> 00:20:05,820
ಸ್ಟ್ರಿಂಗ್ ಕೊನೆಯಲ್ಲಿ.

327
00:20:05,820 --> 00:20:09,850
ಹಾಗೆ, ಸಹ, ಬ್ಯಾಕ್ಸ್ಲ್ಯಾಷ್
n ಒಂದು ನಿಜವಾದ ಪಾತ್ರ.

328
00:20:09,850 --> 00:20:14,040
ಬ್ಯಾಕ್ಸ್ಲ್ಯಾಷ್ 0 ಸೂಚಿಸಲು ಹೋಗುತ್ತದೆ
ನಮ್ಮ ಸ್ಟ್ರಿಂಗ್ ಕೊನೆಯಲ್ಲಿ.

329
00:20:14,040 --> 00:20:15,414
ನಾನು ಹಾಕಲು ಬಯಸುವುದಿಲ್ಲ.

330
00:20:15,414 --> 00:20:19,190

331
00:20:19,190 --> 00:20:25,620
ಮತ್ತು ಉದ್ದ ಸೂಚಿತವಾಗಿರುವ ರು ಅಲ್ಲವಾದ್ದರಿಂದ
ಶೂನ್ಯ ಟರ್ಮಿನೇಟರ್ ಸಮಾನವಾಗಿರುತ್ತದೆ, ನಂತರ

332
00:20:25,620 --> 00:20:27,130
ನಾವು ಉದ್ದವನ್ನು ಹೆಚ್ಚಿಸಲು ನೀನು.

333
00:20:27,130 --> 00:20:29,860

334
00:20:29,860 --> 00:20:34,880
ಆದ್ದರಿಂದ ನಮ್ಮ ಕಾರ್ಯಕ್ರಮದ ಕೊನೆಯಲ್ಲಿ,
ಉದ್ದ ಅಂತಿಮವಾಗಿ ಹೋಗುತ್ತದೆ

335
00:20:34,880 --> 00:20:37,610
ಈ ಸಂದರ್ಭದಲ್ಲಿ 5 ಎಂದು.

336
00:20:37,610 --> 00:20:39,210
ಮತ್ತು ನಾವು ಉದ್ದ ಬರುತ್ತೇವೆ.

337
00:20:39,210 --> 00:20:42,570

338
00:20:42,570 --> 00:20:43,530
>> ಸರಿ.

339
00:20:43,530 --> 00:20:48,290
ಈಗ ಕೆಳಗೆ ಇಲ್ಲಿ, ನಾನು ಹಾಗೆ
my_strlen ಮಾಡಲು.

340
00:20:48,290 --> 00:20:50,700
ಖಚಿತಪಡಿಸಿಕೊಳ್ಳಿ ಇದು ಕಂಪೈಲ್ ಲೆಟ್
ಎಲ್ಲವೂ ಸರಾಗವಾಗಿ ಸಾಗುತ್ತದೆ.

341
00:20:50,700 --> 00:20:55,820

342
00:20:55,820 --> 00:20:58,210
ನಾನು 2 ಮಾಡುತ್ತಾ?

343
00:20:58,210 --> 00:21:00,565
ಅಥವಾ 1 ಎಂದು?

344
00:21:00,565 --> 00:21:01,940
ಆ ಮಾಡಬೇಕು.

345
00:21:01,940 --> 00:21:02,690
ಸರಿ.

346
00:21:02,690 --> 00:21:08,490
ಆದ್ದರಿಂದ ಈ argv 2.

347
00:21:08,490 --> 00:21:11,585
ನಿರೀಕ್ಷಿಸಿದಂತೆ, ಕೆಲಸ ಆದಾಗ್ಯೂ
ಒಂದು ನಾನು ಮಾಡಿದರು?

348
00:21:11,585 --> 00:21:15,060

349
00:21:15,060 --> 00:21:15,550
ಹೌದು.

350
00:21:15,550 --> 00:21:16,760
ಸರಿ.

351
00:21:16,760 --> 00:21:21,820
ವಸ್ತುಗಳ ಈ ಆವೃತ್ತಿ ಹೊಂದಿರಲಿಲ್ಲ
printf ಹೊಸ ನಂತರ ಲೈನ್, ಆದರೆ

352
00:21:21,820 --> 00:21:22,910
ಯಾವುದೇ ವ್ಯತ್ಯಾಸವನ್ನು ಮಾಡುವುದಿಲ್ಲ.

353
00:21:22,910 --> 00:21:23,300
ಸರಿ.

354
00:21:23,300 --> 00:21:25,780
ನಿರೀಕ್ಷೆ ಆದ್ದರಿಂದ ಕೆಲಸ.

355
00:21:25,780 --> 00:21:34,750
>> ಈಗ ನಾವು ಈ ಒಂದು ಹೆಜ್ಜೆ ಒಂದುಗೂಡಿಸಬಹುದು
ಮತ್ತಷ್ಟು, ಇಲ್ಲಿ ಅಲ್ಲಿ ಸೂಚನೆ, ಚೆನ್ನಾಗಿ,

356
00:21:34,750 --> 00:21:38,920
ಮೊದಲ, ನಾವು argv ಆಫ್, strlen ಧರಿಸುವುದನ್ನು ನೀವು
ನಾನು, ತದನಂತರ ನಾವು ಮೇಲೆ iterating

357
00:21:38,920 --> 00:21:41,450
ಆ ಸಾಲಿನಲ್ಲಿ ಪ್ರತಿ ಪಾತ್ರದ.

358
00:21:41,450 --> 00:21:47,480
ಆದ್ದರಿಂದ ಬದಲಿಗೆ ಮಾಡುವ, ಹೀಗಾದರೆ ನಾವು
ಕೇವಲ ಕಾಯುವ ಈ ತರ್ಕ ಒಗ್ಗೂಡಿ

359
00:21:47,480 --> 00:21:50,740
ನಾವು ಬ್ಯಾಕ್ಸ್ಲ್ಯಾಷ್ 0 ಬಲ ಹಿಟ್ ರವರೆಗೆ
ಲೂಪ್ ಈ ಒಳಗೆ?

360
00:21:50,740 --> 00:21:53,740

361
00:21:53,740 --> 00:22:07,490
Argv ನಾನು, ಜೆ ಮಾಡುತ್ತದೆ ಆದ್ದರಿಂದ ತಿರುಗಿ
ಸಮಾನರಲ್ಲ ಬ್ಯಾಕ್ಸ್ಲ್ಯಾಷ್ 0.

362
00:22:07,490 --> 00:22:10,680
ಆದ್ದರಿಂದ ಮೊದಲ ಚಲಾಯಿಸಲು ಅವಕಾಶ.

363
00:22:10,680 --> 00:22:19,838

364
00:22:19,838 --> 00:22:21,180
>> ಸರಿ.

365
00:22:21,180 --> 00:22:27,655
ಇಲ್ಲಿ, ಈ ಸ್ಥಿತಿಯನ್ನು ಹೇಳುವ -

366
00:22:27,655 --> 00:22:38,090

367
00:22:38,090 --> 00:22:40,060
ಸ್ಪಷ್ಟ ಅವಕಾಶ.

368
00:22:40,060 --> 00:22:49,140
ಈಗ, ಈ ನಮ್ಮ argv ಇರಲಿ.

369
00:22:49,140 --> 00:22:55,290
ಆದ್ದರಿಂದ ನಾನು ಮೊದಲು ಆ ಕಾರ್ಯಕ್ರಮ ನಡೆಯಿತು,
argv ತಂತಿಗಳ ಒಂದು ಸರಣಿ ಹೊಂದಿದೆ.

370
00:22:55,290 --> 00:23:03,100
ಆದ್ದರಿಂದ, ನಾನು ಡಾಟ್ ಕತ್ತರಿಸಿ, argv ಅದನ್ನು ಚಲಿಸಿದರೆ
2, ಹಲೋ ವರ್ಲ್ಡ್, ನಂತರ, argv

371
00:23:03,100 --> 00:23:07,650
ಸ್ವತಃ, argv, ಉದ್ದ 3
ಶೂನ್ಯ, ಹಲೋ, ಮತ್ತು ವಿಶ್ವದ.

372
00:23:07,650 --> 00:23:11,700

373
00:23:11,700 --> 00:23:19,660
>> ಮತ್ತು ಈ ಸೂಚ್ಯಂಕಗಳನ್ನು ಪ್ರತಿ ಒಳಗೆ, ಆಗಿದೆ
ಸ್ವತಃ ಈ ಮಾಡುತ್ತೇವೆ ಅಲ್ಲಿ ಒಂದು ಶ್ರೇಣಿಯನ್ನು,

374
00:23:19,660 --> 00:23:23,780
ಡಾಟ್, ಈ ಸ್ಲ್ಯಾಷ್ ಇರುತ್ತದೆ, ನನಗೆ ಗೊತ್ತಿಲ್ಲ
ಎಂದು ಸರಿಯಾದ ವೇಳೆ, ನಾನು

375
00:23:23,780 --> 00:23:25,680
ಇದು ಯೋಚಿಸುವುದಿಲ್ಲ.

376
00:23:25,680 --> 00:23:30,110
ಎ ಆರ್ ವಿ ಡ್ಯಾಶ್, ಹೆಚ್ಚಿನ ಸ್ಥಳ ಬೇಕಾಗುತ್ತದೆ.

377
00:23:30,110 --> 00:23:32,570
ಈ ರಚನೆಯ ಕತ್ತರಿಸಿ ಲೆಟ್.

378
00:23:32,570 --> 00:23:38,230
ಎ ಆರ್ ವಿ ಡ್ಯಾಶ್ 0, ತದನಂತರ ಬ್ಯಾಕ್ಸ್ಲ್ಯಾಷ್ 0.

379
00:23:38,230 --> 00:23:43,160
ತದನಂತರ ಅವ್ಯವಸ್ಥೆ ಹಲೋ ಇರುತ್ತದೆ.

380
00:23:43,160 --> 00:23:45,910
ನ, ಹೆಚ್ ಇ ಬ್ಯಾಕ್ಸ್ಲ್ಯಾಷ್ 0 ಹೇಳುತ್ತಾರೆ.

381
00:23:45,910 --> 00:23:51,130
ಮತ್ತು ಅಂತಿಮವಾಗಿ, ವಾಟ್ ಓ ಬ್ಯಾಕ್ಸ್ಲ್ಯಾಷ್ 0.

382
00:23:51,130 --> 00:23:59,730
>> ಆದ್ದರಿಂದ ನಾವು ಬರೆದ ಅಲ್ಗಾರಿದಮ್,
ಅವರು ಏನನ್ನು ಕುಣಿಕೆಗಳು, ಫಾರ್ ರೀತಿಯಲ್ಲಿ

383
00:23:59,730 --> 00:24:07,321
ಮಾಡುವುದರಿಂದ, ನಾವು ಮೊದಲ ಹೊಂದಿವೆ
ನಾನು ಮತ್ತು ನಂತರ J ಎದುರಿಸಲು.

384
00:24:07,321 --> 00:24:15,206
ಈ ಮೇಲೆ ಕೋಡ್ ಜೊತೆ ಸುಲಭ ಎಂದು
ಪರದೆಯ, ಮತ್ತೆ ಈ ಹೋಗಿ ನೋಡೋಣ.

385
00:24:15,206 --> 00:24:17,476
ಸರಿ.

386
00:24:17,476 --> 00:24:24,600
ಆದ್ದರಿಂದ ನಾನು ಇಲ್ಲಿದೆ ಎಂದು iterator ಗಮನಿಸಿ
ಪ್ರತಿ ಆಜ್ಞೆಯನ್ನು ಮೇಲೆ iterating

387
00:24:24,600 --> 00:24:25,610
ಸಾಲಿನ ವಾದವನ್ನು.

388
00:24:25,610 --> 00:24:28,870
ಮತ್ತು ಜೆ iterator, iterating ಇದೆ
ಎಂದು ಪ್ರತಿ ಪಾತ್ರದ ಮೇಲೆ

389
00:24:28,870 --> 00:24:30,410
ಆಜ್ಞಾ ಸಾಲಿನ ವಾದವನ್ನು.

390
00:24:30,410 --> 00:24:46,755
ಆದ್ದರಿಂದ ಈ ಅಂತರಾಳದ printf ಮಾಡುತ್ತಿರುವ
, ನಾವು argv 0 0, printf printf ಹೊಂದಿವೆ ಇದೆ

391
00:24:46,755 --> 00:24:58,680
argv 0 1, printf, argv 0 2 0 3, 0 4 0
5, 6 0, ಆದರೆ ಈಗ, argv 0 7 ಹೋಗುತ್ತದೆ

392
00:24:58,680 --> 00:25:00,670
ಸಮಾನ ಬ್ಯಾಕ್ಸ್ಲ್ಯಾಷ್ 0.

393
00:25:00,670 --> 00:25:05,730
>> ಆದ್ದರಿಂದ ನಾವು ಲೂಪ್ ಆ ನಿರ್ಗಮಿಸಲು,
ಮತ್ತು ಈಗ ನಾನು 1 ಗೆ iterates.

394
00:25:05,730 --> 00:25:10,910
ಈಗ ನಾವು ಮುದ್ರಿಸಲು ನೀನು
argv 1 0, argv 1 1 -

395
00:25:10,910 --> 00:25:17,040
ಸರಿ, ಈಗ, ನಾನು ಸಣ್ಣ ಹಲೋ ಕತ್ತರಿಸಿ ರಿಂದ,
argv 1 2 ಮತ್ತೆ ಏರಲಿದೆ

396
00:25:17,040 --> 00:25:18,170
ಬ್ಯಾಕ್ಸ್ಲ್ಯಾಷ್ 0.

397
00:25:18,170 --> 00:25:25,050
ಆದ್ದರಿಂದ, ನಾನು ಹೆಚ್ಚಿಸಲು ಮತ್ತು ಮುಂದುವರೆಯಲು, ಮತ್ತು
ಹೀಗೆ, ರವರೆಗೆ ನಾವು ಎಲ್ಲಾ ಮುದ್ರಿಸುತ್ತದೆ

398
00:25:25,050 --> 00:25:28,580
ವಿಶ್ವದ, ಮತ್ತು ಆ ಮೂರು ಆಜ್ಞಾ ಸಾಲಿನ ಇವೆ
ವಾದಗಳು, ಮತ್ತು ನಾವು ಔಟ್ ನಿರ್ಗಮಿಸಲು ಮಾಡುತ್ತೇವೆ

399
00:25:28,580 --> 00:25:31,670
ಹೊರಗಿನ ಲೂಪ್, ಮತ್ತು
ನಮ್ಮ ಕಾರ್ಯಕ್ರಮ ಮುಗಿಸಲು.

400
00:25:31,670 --> 00:25:38,390

401
00:25:38,390 --> 00:25:39,640
ಸರಿ.

402
00:25:39,640 --> 00:25:43,903

403
00:25:43,903 --> 00:25:46,795
>> ಇಲ್ಲಿ ಮತ್ತೆ ಬರಲಿ.

404
00:25:46,795 --> 00:25:49,670

405
00:25:49,670 --> 00:25:52,370
ಆದ್ದರಿಂದ ನೀವು ಕೆಲವು ನಿಕಟತೆಯನ್ನು ಪಡೆಯಲು ವಿಲ್
ಈ ಮೇಲೆ ಆಜ್ಞಾ ಸಾಲಿನ ಆರ್ಗುಮೆಂಟ್ಗಳನ್ನು

406
00:25:52,370 --> 00:25:54,460
ನಿರ್ದಿಷ್ಟ ಸಮಸ್ಯೆಯನ್ನು ಸೆಟ್.

407
00:25:54,460 --> 00:25:56,630
>> ಈಗ ಡೀಬಗ್.

408
00:25:56,630 --> 00:26:01,680
ಆದ್ದರಿಂದ ನೀವು ಬಹುಶಃ ಈಗಾಗಲೇ ಮಾಡಲು ಹೊಂದಿತ್ತು
ನಿಮ್ಮ ಹಿಂದಿನ ಕೆಲವು ಡೀಬಗ್

409
00:26:01,680 --> 00:26:03,120
ಸಮಸ್ಯೆ ಸೆಟ್.

410
00:26:03,120 --> 00:26:08,420
ಮತ್ತು ದೋಷ ನಿವಾರಣ ಒಂದು ಅತ್ಯಂತ ಸುಲಭ ಮಾರ್ಗ,
ಮೊದಲ, ನ ಒಂದು ದೋಷಯುಕ್ತ ಪ್ರೋಗ್ರಾಂ ನೋಡೋಣ.

411
00:26:08,420 --> 00:26:20,710

412
00:26:20,710 --> 00:26:23,830
ಅಲ್ಲದೆ, ಈ ಪ್ರೋಗ್ರಾಂ ಮೂಲಕ ವಾಕಿಂಗ್
ನಾವು ಒಂದು ಬಳಕೆದಾರ ಕೇಳಲು ನೀನು

413
00:26:23,830 --> 00:26:29,350
ಪೂರ್ಣಾಂಕ, ಪೂರ್ಣಾಂಕ ಹಿಡಿದಿಟ್ಟುಕೊಳ್ಳುತ್ತದೆ, ಮತ್ತು ನಂತರ,
ನಿರಂಕುಶವಾಗಿ, ನಾವು ಸ್ವಲ್ಪ ಲೂಪ್ ಎಂದು

414
00:26:29,350 --> 00:26:32,280
ಕೇವಲ ಇಳಿಕೆ ಹೋಗುತ್ತದೆ
ಇದು 10 ಸಮಾನವಾಗಿರುತ್ತದೆ ನಾನು ತನಕ.

415
00:26:32,280 --> 00:26:35,820
ಲೆಟ್ ತಂದೆಯ ನಾನು ಪ್ರವೇಶಿಸುವ ಮನುಷ್ಯ ಭಾವಿಸಿ
10 ಕ್ಕಿಂತ ಒಂದು ಪೂರ್ಣಾಂಕ.

416
00:26:35,820 --> 00:26:38,700
ಇದು 10 ಸಮಾನವಾಗಿರುತ್ತದೆ ತನಕ ಆದ್ದರಿಂದ ನಾನು ಇಳಿಕೆ.

417
00:26:38,700 --> 00:26:42,630
>> ನಂತರ ನಾವು ಮತ್ತೊಂದು ಸ್ವಲ್ಪ ಲೂಪ್
ನಾನು 0 ಸಮಾನ ಬೀರದಿದ್ದರೂ, ನಾವು ಆರ್,

418
00:26:42,630 --> 00:26:44,540
3 ನಾನು ಇಳಿಕೆ ಹೋಗುವ.

419
00:26:44,540 --> 00:26:49,790
ಆದ್ದರಿಂದ ನೀವು ದೋಷ ಉದ್ದೇಶದಿಂದ ನೋಡಿ
ಇಲ್ಲಿ, ಈ ನಾನು ಇಳಿಕೆ ಮಾಡುತ್ತೇವೆ ಎಂದು ಇಲ್ಲಿದೆ

420
00:26:49,790 --> 00:26:57,010
10, ತದನಂತರ ಈ ಲೂಪ್ ಮಾಡುತ್ತದೆ
1 4 7 10, ರಿಂದ ಇಳಿಕೆ ನಾನು,

421
00:26:57,010 --> 00:27:02,880
ಋಣಾತ್ಮಕ 2, ಹೀಗೆ 5 ಋಣಾತ್ಮಕ, ಮತ್ತು
ಋಣಾತ್ಮಕ ಅನಂತ, ನಾನು ಕಾರಣ

422
00:27:02,880 --> 00:27:05,920
ವಾಸ್ತವವಾಗಿ 0 ಸಮನಾಗಿರಬೇಕು ಎಂದಿಗೂ.

423
00:27:05,920 --> 00:27:08,610
ತದನಂತರ ಈ ಕಾರ್ಯಕ್ರಮದ ಕೊನೆಯಲ್ಲಿ,
ನಾವು ಇದು foo ಕಾರ್ಯದ ಹೊಂದಿವೆ

424
00:27:08,610 --> 00:27:12,130
ಮುದ್ರಣ ಮೇಲೆ ಹೋಗುವ ನಾನು.

425
00:27:12,130 --> 00:27:16,520
>> ಆದ್ದರಿಂದ ಈ, ಒಂದು ಸಣ್ಣ ಮತ್ತು ಕ್ಷುಲ್ಲಕ ಕಾರ್ಯಕ್ರಮ
ಮತ್ತು ದೋಷ ಸ್ಪಷ್ಟ,

426
00:27:16,520 --> 00:27:18,790
ವಿಶೇಷವಾಗಿ ನಂತರ ನಾನು
ದೋಷ ಏನು ಹೇಳಿದರು.

427
00:27:18,790 --> 00:27:24,840
ಆದರೆ ಇಲ್ಲಿ ಉದ್ದೇಶ ಅಲ್ಲದೆ, ಈ ಹೊಂದಿರಬಹುದು
ವಾಸ್ತವವಾಗಿ ಕೆಲವು ರೀತಿ ನಿಮ್ಮ

428
00:27:24,840 --> 00:27:30,040
ಕೊನೆಯ ದುರಾಸೆಯ ಪರಿಹಾರಗಳನ್ನು
ಸಮಸ್ಯೆ ಸೆಟ್, ಮತ್ತು ಬಹುಶಃ ನೀವು ಹೊಂದಿಲ್ಲ

429
00:27:30,040 --> 00:27:32,800
ನಿಮ್ಮ ಕಾರ್ಯಕ್ರಮದಲ್ಲಿ ಕೆಲವು ಅನಂತ ಆದೇಶಗಳ
ಮತ್ತು ನೀವು ಕಲ್ಪನೆಯೂ ಇಲ್ಲ

430
00:27:32,800 --> 00:27:34,100
ಏನು ಇದು ಕಾರಣವಾಗುತ್ತದೆ.

431
00:27:34,100 --> 00:27:38,690
ಆದ್ದರಿಂದ ಬಹಳ ಉಪಯುಕ್ತ ಡೀಬಗ್ ತಂತ್ರ
ಕೇವಲ printfs ಸೇರಿಸಿ

432
00:27:38,690 --> 00:27:40,180
ಎಲ್ಲಾ ನಿಮ್ಮ ಕೋಡ್ ಮೇಲೆ.

433
00:27:40,180 --> 00:27:49,200
>> ಇಲ್ಲಿ ನಾನು ಹೊರಗೆ printf ಬಯಸುವ
ಮೊದಲ ಲೂಪ್.

434
00:27:49,200 --> 00:27:53,155
ಇಲ್ಲಿ ನಾನು printf ಬಯಸುವ,
ಮತ್ತು ನಾನು ನಾನು ಮುದ್ರಿಸಲು ಮಾಡುತ್ತೇವೆ.

435
00:27:53,155 --> 00:27:55,670

436
00:27:55,670 --> 00:27:58,330
ಲೂಪ್ ನಾನು ನಾನು, ಮೊದಲ ಮಾಡುತ್ತೇನೆ.

437
00:27:58,330 --> 00:28:05,130

438
00:28:05,130 --> 00:28:09,040
ಹೊರಗೆ, ಎರಡನೇ ಲೂಪ್.

439
00:28:09,040 --> 00:28:12,170
ಮತ್ತೊಮ್ಮೆ, ಒಳಗೆ ಮುದ್ರಿಸಲು
ಇಲ್ಲಿ, ಮೌಲ್ಯ ನಾನು.

440
00:28:12,170 --> 00:28:16,270

441
00:28:16,270 --> 00:28:17,520
ಮತ್ತು ಇದನ್ನು ರನ್ ಅವಕಾಶ.

442
00:28:17,520 --> 00:28:22,620

443
00:28:22,620 --> 00:28:24,800
>> ಆದ್ದರಿಂದ ಡಾಟ್ ಕತ್ತರಿಸಿ ಡಿಬಗ್.

444
00:28:24,800 --> 00:28:25,610
ಒಂದು ಪೂರ್ಣಾಂಕ ನಮೂದಿಸಿ.

445
00:28:25,610 --> 00:28:28,150
ನ 13 ಮಾಡೋಣ.

446
00:28:28,150 --> 00:28:28,760
ಬೂಮ್.

447
00:28:28,760 --> 00:28:33,300
ನಾವು ಅನಂತ ಆವರ್ತಿಸುವ ಎಂದು ನೋಡಿ
ಎರಡನೇ ಸಂದರ್ಭದಲ್ಲಿ ಲೂಪ್ ಒಳಗೆ.

448
00:28:33,300 --> 00:28:36,305
ಈಗ ನಾವು ದೋಷ ಏನು ಗೊತ್ತಿಲ್ಲ.

449
00:28:36,305 --> 00:28:39,610

450
00:28:39,610 --> 00:28:45,610
ಆದರೆ, printf ಡೀಬಗ್, ಸಂಪೂರ್ಣವಾಗಿ ಅದ್ಭುತವಾಗಿದೆ
ಆದರೆ ನಿಮ್ಮ ಕಾರ್ಯಕ್ರಮಗಳು ಒಮ್ಮೆ

451
00:28:45,610 --> 00:28:50,560
ಮುಂದೆ ಮತ್ತು ಸಂಕೀರ್ಣವಾದ, ಇವೆ
ಹೆಚ್ಚು ಅತ್ಯಾಧುನಿಕ ಪರಿಹಾರಗಳನ್ನು

452
00:28:50,560 --> 00:28:51,705
ವಿಷಯಗಳನ್ನು ಕೆಲಸ ಸಿಲುಕುವ.

453
00:28:51,705 --> 00:28:52,955
ಆದ್ದರಿಂದ ಈ ಎಲ್ಲಾ printfs ತೆಗೆಯಲು ಅವಕಾಶ.

454
00:28:52,955 --> 00:29:06,242

455
00:29:06,242 --> 00:29:08,896
ಮತ್ತು ನ ಖಚಿತವಾಗಿ ನಾನು ಮಾಡಲಿಲ್ಲ ಮಾಡೋಣ
ಏನು ಮುರಿಯಲು.

456
00:29:08,896 --> 00:29:09,850
ಸರಿ.

457
00:29:09,850 --> 00:29:14,180
>> ನಾವು ನೀನು ಪ್ರೋಗ್ರಾಂ
ಪರಿಚಯಿಸಲು ಕರೆಯಲಾಗುತ್ತದೆ

458
00:29:14,180 --> 00:29:16,715
ಗ್ನೂ ದೋಷಸೂಚಕವು ಫಾರ್, GDB,.

459
00:29:16,715 --> 00:29:21,892

460
00:29:21,892 --> 00:29:27,510
ಅಲ್ಲದೆ, ವಾಸ್ತವವಾಗಿ, ನ ಡಿಬಗ್ ತೆಗೆಯಲು ಅವಕಾಶ
ಎರಡನೇ, ಮತ್ತು ಮತ್ತೆ ಡಿಬಗ್ ಮಾಡಲು.

461
00:29:27,510 --> 00:29:31,420

462
00:29:31,420 --> 00:29:34,440
ಅಲ್ಲದೆ, ವಾಸ್ತವವಾಗಿ ಮೊದಲ, ಉತ್ತಮ ಪಾಠ
ಆಜ್ಞಾ ಸಾಲಿನ ಆರ್ಗುಮೆಂಟ್ಗಳನ್ನು ರಲ್ಲಿ.

463
00:29:34,440 --> 00:29:37,780
ಈ ಖಣಿಲು ಆಜ್ಞೆಯನ್ನು ಎಂದು ಗಮನಿಸಿ
ಎಲ್ಲವೂ ಅಂಗೀಕಾರವಾದ ಕಂಪೈಲ್

464
00:29:37,780 --> 00:29:41,300
ಆಜ್ಞಾ ಸಾಲಿನಲ್ಲಿ, ಈ
ಆಜ್ಞಾ ಸಾಲಿನ ಆರ್ಗುಮೆಂಟ್ಗಳನ್ನು.

465
00:29:41,300 --> 00:29:46,250
ನೀವು ಬಳಸುತ್ತಿರುವ ಹೋಗುವ ಆದ್ದರಿಂದ ನಿಖರವಾಗಿ ಹೇಗೆ
ಆಜ್ಞಾ ಸಾಲಿನ ಆರ್ಗುಮೆಂಟ್ಗಳನ್ನು, ನಾವು

466
00:29:46,250 --> 00:29:51,500
ಮೊದಲು ಮಾಡಿದರು, ಮತ್ತು ನೀವು pset ರಲ್ಲಿ ತಿನ್ನುವೆ
2, ಖಣಿಲು ಅವುಗಳನ್ನು ಬಳಸಿ ಹೇಗೆ.

467
00:29:51,500 --> 00:30:00,070
>> ಆದ್ದರಿಂದ ಗಮನಿಸಿ ಈ ಮೊದಲ ಧ್ವಜ, ಡ್ಯಾಶ್
ggdb3, ಎಂದು ಹೇಳುವ ಏನನ್ನು, ಖಣಿಲು,

468
00:30:00,070 --> 00:30:03,790
ನೀವು ಈ ಫೈಲ್ ತಯಾರಿಸಬೇಕು
ಉದ್ದೇಶ ಎಂದು ನಾವು ಅಂತಿಮವಾಗಿ ತಿನ್ನುವೆ

469
00:30:03,790 --> 00:30:05,380
ಇದು ದೋಷ ಅಗತ್ಯವಿದೆ.

470
00:30:05,380 --> 00:30:13,840
ಆದ್ದರಿಂದ ಅಲ್ಲಿಯವರೆಗೆ ನೀವು ಧ್ವಜ ಹೊಂದಿವೆ,
ನಂತರ ನಾವು GDB ದೋಷ.

471
00:30:13,840 --> 00:30:17,380
ಮತ್ತು ಗ್ನೂ ದೋಷಸೂಚಕವು ತೆರೆಯುತ್ತದೆ ವಿಲ್.

472
00:30:17,380 --> 00:30:22,920
>> ಆದ್ದರಿಂದ ಆದೇಶಗಳು ಬಹಳಷ್ಟು ಇವೆ
ನೀವು ಬಳಸಲಾಗುತ್ತದೆ ಮಾಡಲು ಅಗತ್ಯವಿರುವ.

473
00:30:22,920 --> 00:30:27,100
ಮೊದಲ ಒಂದು ಎಂದು ನೀವು ಬಹುಶಃ ಮಾಡುತ್ತೇವೆ
ತಕ್ಷಣ ಅಗತ್ಯವಿದೆ ರನ್ ಆಗಿದೆ.

474
00:30:27,100 --> 00:30:28,200
ಆದ್ದರಿಂದ ಯಾವ ಮಾಡಬೇಕು ಹೋಗುವ ರನ್?

475
00:30:28,200 --> 00:30:30,910
ಇದು ನಮ್ಮ ಕಾರ್ಯಕ್ರಮ ಆರಂಭಿಸಲು ವಿಶೇಷವೇನು.

476
00:30:30,910 --> 00:30:36,180
ಆದ್ದರಿಂದ, ಆರಂಭಿಕ ಪ್ರೋಗ್ರಾಂ, ಪ್ರೊಗ್ರಾಮನ್ನು
ಒಂದು ಪೂರ್ಣಾಂಕ, 13 ನಮಗೆ ಕೇಳುತ್ತದೆ.

477
00:30:36,180 --> 00:30:39,170
ತದನಂತರ ಇದು ಅನಂತ ಆವರ್ತಿಸುವ ಇಲ್ಲಿದೆ
ನಾನು ತೆಗೆದು ಹೊರತುಪಡಿಸಿ, ನಿರೀಕ್ಷಿಸಲಾಗಿದೆ

478
00:30:39,170 --> 00:30:40,500
printfs, ಆದ್ದರಿಂದ ನಾವು ಕಾಣುವುದಿಲ್ಲ.

479
00:30:40,500 --> 00:30:43,320

480
00:30:43,320 --> 00:30:44,600
ಸಾಮಾನ್ಯವಾಗಿ ನಿರ್ಗಮಿಸಿದೆ.

481
00:30:44,600 --> 00:30:45,850
ಓಹ್.

482
00:30:45,850 --> 00:30:48,570

483
00:30:48,570 --> 00:30:53,640
ಇದು ಸುತ್ತಿ ಸಾಧ್ಯತೆಯೂ ಎಲ್ಲಾ
ಹಾದಿ, ಮತ್ತೆ - ಎಂದು ನಿರ್ಲಕ್ಷಿಸಿ.

484
00:30:53,640 --> 00:30:55,170
ಇದು ಸಾಮಾನ್ಯವಾಗಿ ನಿರ್ಗಮಿಸಲು ಮಾಡಲಿಲ್ಲ ಊಹಿಸಿ.

485
00:30:55,170 --> 00:30:59,500

486
00:30:59,500 --> 00:31:03,370
ಎಂದು ಒಂದು ಸಂಕೀರ್ಣವಾದ ಉತ್ತರ ಇಲ್ಲ.

487
00:31:03,370 --> 00:31:07,890
>> ಈಗ, ಬಹಳ ಉಪಯುಕ್ತ ಅಲ್ಲ.

488
00:31:07,890 --> 00:31:11,480
ಆದ್ದರಿಂದ ಕೇವಲ ಒಳಗೆ ನಮ್ಮ ಕಾರ್ಯಕ್ರಮವನ್ನು ನಡೆಸುವ
ಈ ದೋಷಸೂಚಕವು ಯಾವುದೇ ನಮಗೆ ಸಹಾಯ ಮಾಡುವುದಿಲ್ಲ

489
00:31:11,480 --> 00:31:15,610
ನಾವು ಸಾಧ್ಯವಾಗಲಿಲ್ಲ ರಿಂದ ರೀತಿಯಲ್ಲಿ,
ಡಾಟ್ GDB, ಹೊರಗಿನಿಂದ ಡಿಬಗ್ ಕಡಿದು.

490
00:31:15,610 --> 00:31:21,250
ಆದ್ದರಿಂದ ಒಂದು ಆಜ್ಞೆಯನ್ನು ಎಂದು
ನೀವು ಬಹುಶಃ ನಾವು -

491
00:31:21,250 --> 00:31:22,970
ಮತ್ತು ನಾನು ಈ ಬಿಟ್ಟು ಮಾಡುತ್ತೇವೆ.

492
00:31:22,970 --> 00:31:25,850
ಕಂಟ್ರೋಲ್ ಡಿ ಅಥವಾ, ಕೆಲಸ ಎರಡೂ ತ್ಯಜಿಸಿದರು.

493
00:31:25,850 --> 00:31:29,550
ಆದ್ದರಿಂದ ಮತ್ತೆ ತೆರೆದುಕೊಳ್ಳಲು ಅವಕಾಶ.

494
00:31:29,550 --> 00:31:31,130
>> ಮತ್ತೊಂದು ಆಜ್ಞೆಯನ್ನು ಎಂದು ನೀವು ಬಹುಶಃ ಮಾಡುತ್ತೇವೆ
ತಕ್ಷಣ ಬಯಸುವ

495
00:31:31,130 --> 00:31:33,600
ಬಳಸಲಾಗುತ್ತದೆ ಬ್ರೇಕ್.

496
00:31:33,600 --> 00:31:37,120
ನಾವು, ಈಗ ಮುಖ್ಯ ಮುರಿಯಲು ಮಾಡುತ್ತೇವೆ
ಮತ್ತು ನಂತರ ನಾನು ವಿವರಿಸಲು ಮಾಡುತ್ತೇವೆ.

497
00:31:37,120 --> 00:31:41,010

498
00:31:41,010 --> 00:31:46,370
ಹಾಗೆಯೇ, ಇಲ್ಲಿ ನಾವು ಒಂದು ಬ್ರೇಕ್ಪಾಯಿಂಟ್ ಸೆಟ್ ನೋಡಿ
debug.c ಈ ಸಾಲಿನಲ್ಲಿ.

499
00:31:46,370 --> 00:31:50,160
ಹಾಗಾಗಿ ಬ್ರೇಕ್ ವಿಧಾನವಾಗಿದೆ ಎಂದು ನಾನು
ರನ್ ಟೈಪ್, ಪ್ರೋಗ್ರಾಂ ಹೋಗುತ್ತದೆ

500
00:31:50,160 --> 00:31:53,560
ರವರೆಗೆ ಚಾಲನೆಯನ್ನು ಮುಂದುವರಿಸಲು
ನಾನು ಬ್ರೇಕ್ಪಾಯಿಂಟ್ ಹಿಟ್.

501
00:31:53,560 --> 00:31:59,390
ನಾನು ರನ್ ಹೊಡೆದಾಗ ಆದ್ದರಿಂದ, ಪ್ರೋಗ್ರಾಂ, ಆರಂಭವಾಗುತ್ತದೆ
ನಂತರ ಅದನ್ನು ತಕ್ಷಣ ಅದು ಒಡೆಯುತ್ತದೆ

502
00:31:59,390 --> 00:32:01,940
ಮುಖ್ಯ ಕಾರ್ಯ ಪ್ರವೇಶಿಸುತ್ತದೆ.

503
00:32:01,940 --> 00:32:06,930
ಮುಖ್ಯ ಬ್ರೇಕ್ ಏನೋ ಏರಲಿದೆ
ನೀವು ಬಹಳ ಸಾಮಾನ್ಯವಾಗಿ ಮಾಡಲು.

504
00:32:06,930 --> 00:32:11,340
>> ಈಗ, ನೀವು ಪರಿಚಯಿಸಲು
ಕೆಲವು ಹೆಚ್ಚು ಆಜ್ಞೆಗಳನ್ನು.

505
00:32:11,340 --> 00:32:14,330
ಇದು ನಾವು ಹೇಳುವ ಎಂದು, ಇಲ್ಲಿ ಗಮನಿಸಿ
ಇದು ಸಾಲು 11 ಮುರಿಯಿತು

506
00:32:14,330 --> 00:32:16,230
, printf ಒಂದು ಪೂರ್ಣಾಂಕ ನಮೂದಿಸಿ.

507
00:32:16,230 --> 00:32:21,260
ಆದ್ದರಿಂದ ಆಜ್ಞೆಯನ್ನು ಮುಂದೆ ಹೇಗೆ ಎಂದು ಹೋಗುತ್ತದೆ
ನಾವು ಕೋಡ್ ಮುಂದಿನ ಸಾಲಿಗೆ ಹೋಗಲು.

508
00:32:21,260 --> 00:32:24,810
ಈ ನಮಗೆ ಹಂತಕ್ಕೆ ಅವಕಾಶ ಹೋಗುತ್ತದೆ
ಲೈನ್ ಮೂಲಕ ನಮ್ಮ ಪ್ರೋಗ್ರಾಂ ಲೈನ್ ಮೂಲಕ.

509
00:32:24,810 --> 00:32:26,260
ಆದ್ದರಿಂದ ಮುಂದಿನ.

510
00:32:26,260 --> 00:32:29,820
>> ಈಗ ಸಾಲು 12, ನಾವು ನೀನು
ಪೂರ್ಣಾಂಕ ಪಡೆಯಲು.

511
00:32:29,820 --> 00:32:30,450
ಮುಂದೆ.

512
00:32:30,450 --> 00:32:34,290
ನೀವು ಕೇವಲ ಮತ್ತೆ ನಮೂದಿಸಿ ಹಿಟ್ ಅದನ್ನು ಮಾಡುತ್ತೇವೆ
ನೀವು ಮಾಡಿದರು ಕಡೆಯದಾಗಿ ಮರುಪ್ರದರ್ಶಿಸುವ.

513
00:32:34,290 --> 00:32:36,480
ಹಾಗಾಗಿ ಟೈಪ್ ಮಾಡಬೇಕಿಲ್ಲ
ಮುಂದಿನ ಪ್ರತಿ ಬಾರಿ.

514
00:32:36,480 --> 00:32:40,100
ಆದ್ದರಿಂದ ಒಂದು ಪೂರ್ಣಾಂಕ, 13 ನಮೂದಿಸಿ.

515
00:32:40,100 --> 00:32:46,940
ಈಗ, ಸಾಲು 14, ನಾನು ಹೆಚ್ಚಿನ ಹಾಗೆಯೇ
10 ಹೆಚ್ಚು, ಮತ್ತು ನಾನು ಮುಂದಿನ ಮಾಡುತ್ತೇನೆ.

516
00:32:46,940 --> 00:32:48,685
ಮತ್ತು ನಾವು ನಾನು ಇಳಿಕೆ ನೀನು ನೋಡಿ.

517
00:32:48,685 --> 00:32:50,210
ನಾವು ಮತ್ತೆ ನಾನು ಇಳಿಕೆ ನೀನು.

518
00:32:50,210 --> 00:32:53,620
>> ಈಗ, ಇನ್ನೊಂದು ಉಪಯುಕ್ತ
ಆಜ್ಞಾ ಪ್ರಿಂಟ್ ಆಗಿದೆ.

519
00:32:53,620 --> 00:32:55,750
ಆದ್ದರಿಂದ ಮುದ್ರಣ ಔಟ್ ಮುದ್ರಿಸಲು ಹೋಗುತ್ತದೆ
ವೇರಿಯೇಬಲ್ ಮೌಲ್ಯ.

520
00:32:55,750 --> 00:32:57,825
ಮೌಲ್ಯದ ಔಟ್ ತರುವ ಅವಕಾಶ
ವೇರಿಯಬಲ್ ನಾನು.

521
00:32:57,825 --> 00:32:58,705
ನ ನಾನು ಮುದ್ರಿಸಲು ಅವಕಾಶ.

522
00:32:58,705 --> 00:33:00,910
ಇದು ನಾನು 11 ಹೇಳಲು ವಿಶೇಷವೇನು.

523
00:33:00,910 --> 00:33:03,330
ಈಗ ನಾವು ಮುಂದೆ ಮತ್ತೆ ಸಂದರ್ಭದಲ್ಲಿ
ನಾನು 10 ಹೆಚ್ಚಾಗಿದೆ.

524
00:33:03,330 --> 00:33:05,590
ಆದ್ದರಿಂದ ನಾನು ಇನ್ನೂ ಹೆಚ್ಚಿನ ಇಲ್ಲಿದೆ
ಇದು 11 ರಿಂದ 10,.

525
00:33:05,590 --> 00:33:06,920
ನಾನು ಮೈನಸ್ ಮೈನಸ್.

526
00:33:06,920 --> 00:33:08,250
ಮತ್ತೆ ನಾನು ಮುದ್ರಿಸಲು ಅವಕಾಶ.

527
00:33:08,250 --> 00:33:10,950
ನಿರೀಕ್ಷಿಸಿದ್ದು, ಅದು 10 ಇಲ್ಲಿದೆ.

528
00:33:10,950 --> 00:33:12,510
>> ಈಗ, ಮುಂದಿನ.

529
00:33:12,510 --> 00:33:16,250
ಇದು ಮತ್ತೆ ಸ್ಥಿತಿಯನ್ನು ವಿಶೇಷವೇನು, ನಾನು
10 ಹೆಚ್ಚು, ಆದರೆ ನಾನು, ಈಗ 10 ಆಗಿದೆ

530
00:33:16,250 --> 00:33:20,040
ಇದು 10 ಹೆಚ್ಚಿನ ಅಲ್ಲ, ಆದ್ದರಿಂದ ನಾವು ನಿರೀಕ್ಷಿಸಬಹುದು
ಇದು ಲೂಪ್ ಹೊರಗೆ ಬೀಳಲು.

531
00:33:20,040 --> 00:33:22,220
ಈಗ ನಾವು ಕೋಡ್ ಸಾಲನ್ನು ಕೆಳಗೆ ಆರ್.

532
00:33:22,220 --> 00:33:28,750
ಮತ್ತೊಂದು ಆಜ್ಞೆಯನ್ನು, ಪಟ್ಟಿ, ಕೇವಲ ಹೋಗುತ್ತದೆ
ಹಿಂದಿನ ಮತ್ತು ಮುಂದಿನ ಪ್ರದರ್ಶಿಸಲು

533
00:33:28,750 --> 00:33:31,240
ಕೋಡ್ ಸಾಲುಗಳನ್ನು, ರಲ್ಲಿ ಒಂದೆರಡು
ಸಂದರ್ಭದಲ್ಲಿ ನಿಮ್ಮನ್ನು ಕಳೆದುಕೊಂಡ.

534
00:33:31,240 --> 00:33:35,420
ಆದ್ದರಿಂದ ನಾವು, ಈ ಸಮಯದಲ್ಲಿ ಲೂಪ್ ನಿರ್ಗಮಿಸಿದೆ
ಮತ್ತು ಈಗ ನಾವು ಈ ನಮೂದಿಸಿದ್ದೀರಿ

535
00:33:35,420 --> 00:33:37,080
ಲೂಪ್, ಸಾಲು 18.

536
00:33:37,080 --> 00:33:39,860
ನಾನು 0 ಸಮನಾಗಿರಬೇಕು ಮಾಡುವುದಿಲ್ಲ ಹಾಗೆಯೇ.

537
00:33:39,860 --> 00:33:46,570
ಮತ್ತು, ಮುಂದಿನ, ನಾನು ನಾವು ಮಾಡುತ್ತೇವೆ ನಾನು ಮೈನಸ್ 3 ಸಮ
ಗಮನಿಸಿ, ಈ ಕೇವಲ ಮುಂದುವರಿಸುವುದಕ್ಕೆ.

538
00:33:46,570 --> 00:33:48,270
ನಾವು ನಾನು ಮುದ್ರಿಸಲು.

539
00:33:48,270 --> 00:33:49,990
>> ಪ್ರತಿ ಆಜ್ಞೆಯನ್ನು ರೀತಿಯ ಶಾರ್ಟ್ಕಟ್ಗಳನ್ನು ಹೊಂದಿದೆ.

540
00:33:49,990 --> 00:33:51,720
ಆದ್ದರಿಂದ ಪು ಪ್ರಿಂಟ್ ಚಿಕ್ಕದಾಗಿದೆ.

541
00:33:51,720 --> 00:33:53,400
ನಾವು ಪು ನಾನು.

542
00:33:53,400 --> 00:33:57,550
ಕೇವಲ N ಹಿಡಿದಿಟ್ಟುಕೊಂಡರೆ,
ಅಥವಾ ಮುಂದೆ ನಡೆಸುವ.

543
00:33:57,550 --> 00:33:58,340
ಮತ್ತೆ ನಾನು ಮುದ್ರಣ.

544
00:33:58,340 --> 00:34:00,380
ನೀವು 167 ನಕಾರಾತ್ಮಕವಾಗಿದೆ ಈಗ ನೋಡಿ.

545
00:34:00,380 --> 00:34:06,030
ಆದ್ದರಿಂದ ಈ ಶಾಶ್ವತವಾಗಿ ಹೋಗಿ, ಆದರೆ ಆಗುವುದಿಲ್ಲ
ನಿಜವಾಗಿಯೂ ಶಾಶ್ವತವಾಗಿ ಕಂಡಿತು, ಅದು

546
00:34:06,030 --> 00:34:09,330
ವಾಸ್ತವವಾಗಿ ಹಂತದಲ್ಲಿ ಮುಕ್ತಾಯಗೊಳ್ಳಲಿದೆ.

547
00:34:09,330 --> 00:34:15,699
>> ಆದ್ದರಿಂದ, GDB ಆರಂಭಿಸಿದೆ.

548
00:34:15,699 --> 00:34:19,504
ಆದರೆ ನ GDB ಒಂದು ಹೆಚ್ಚು ವಿಷಯವನ್ನು ನಾವು.

549
00:34:19,504 --> 00:34:20,754
ಉಹ್, ಡಿಬಗ್.

550
00:34:20,754 --> 00:34:23,540

551
00:34:23,540 --> 00:34:28,534
ಆದ್ದರಿಂದ, ಈ ನಿರ್ದಿಷ್ಟ ಪ್ರಕರಣದಲ್ಲಿ,
ಅನಂತ ಲೂಪ್ ಒಳಗೆ ಎಂದು ಸಂಭವಿಸಿದ

552
00:34:28,534 --> 00:34:30,050
ಮುಖ್ಯ ಕಾರ್ಯ.

553
00:34:30,050 --> 00:34:35,779
ಮತ್ತು ಈಗ, ಕೇವಲ ನಾನು ಎಂದು ಸ್ವೀಕರಿಸಲು
ಒಳಗೆ ಅನಂತ ಆದೇಶಗಳ ಸರಿಸಲು ಹೋಗುವ

554
00:34:35,779 --> 00:34:37,029
foo ಕಾರ್ಯದ.

555
00:34:37,029 --> 00:34:40,679

556
00:34:40,679 --> 00:34:43,730
ಈ ಕೊನೆಯಲ್ಲಿ, ನೆನಪು
ಕಾರ್ಯಕ್ರಮದಲ್ಲಿ ಚೆನ್ನಾಗಿ, ಈ ಮೂಲತಃ

557
00:34:43,730 --> 00:34:46,210
ಕೇವಲ ಇದು ಫೂ, ಕರೆ
ನಾನು ಮುದ್ರಿಸಲು ಹೋಗುತ್ತದೆ.

558
00:34:46,210 --> 00:34:51,880
ಆದರೆ ಈಗ ನಾವು ಇದು, foo, ಕರೆ ಮಾಡುತ್ತಿದ್ದೇವೆ
ಇದು 0 ರವರೆಗೆ ನಾನು ಇಳಿಕೆ, ಮತ್ತು ಹೋಗುವ

559
00:34:51,880 --> 00:34:54,548
ನಂತರ ವೇರಿಯಬಲ್ ಮುದ್ರಿಸಲು.

560
00:34:54,548 --> 00:34:55,469
ಸರಿ.

561
00:34:55,469 --> 00:34:57,970
ಎಂದು ಉಳಿಸಿ.

562
00:34:57,970 --> 00:35:00,175
ದೋಷನಿದಾನ ಮಾಡಿ.

563
00:35:00,175 --> 00:35:03,310
ಈಗ, GDB ಡಿಬಗ್.

564
00:35:03,310 --> 00:35:04,090
ಸರಿ.

565
00:35:04,090 --> 00:35:10,580
>> ನಾನು ರನ್ ಆದ್ದರಿಂದ ನಂತರ ನಾನು ನಾನೇನು
ವಾಸ್ತವವಾಗಿ ಹೆಜ್ಜೆ ಸಾಧ್ಯವಾಗುತ್ತದೆ ನನ್ನ

566
00:35:10,580 --> 00:35:11,730
ಕಾರ್ಯಕ್ರಮದ ಲೈನ್ ಮೂಲಕ ಲೈನ್.

567
00:35:11,730 --> 00:35:19,820
ಆದ್ದರಿಂದ ಮುಖ್ಯ ಮುರಿಯಲು ಅವಕಾಶ,
ತದನಂತರ ರನ್ ಟೈಪ್.

568
00:35:19,820 --> 00:35:28,160
ಆದ್ದರಿಂದ ಈ ಮೂಲಕ ಹೋಗಿ, printf ನಮೂದಿಸಿ
ಒಂದು ಪೂರ್ಣಾಂಕ, ಪೂರ್ಣಾಂಕ, 13 ಪಡೆಯಿರಿ.

569
00:35:28,160 --> 00:35:34,180

570
00:35:34,180 --> 00:35:37,490
ನಾವು decrementing ಇರಿಸಿಕೊಳ್ಳಲು ನೀನು
ನಾನು 10 ಹೆಚ್ಚಾಗಿದೆ ತನಕ.

571
00:35:37,490 --> 00:35:42,840
ನಂತರ ನಾವು ಮೂಲಕ ಬೀಳಲು ನೀನು
ಲೂಪ್, ಮತ್ತು ಗೆರೆಯ -

572
00:35:42,840 --> 00:35:44,364
ನ ಪ್ರತ್ಯೇಕ ವಿಂಡೋದಲ್ಲಿ ಅದನ್ನು ತೆರೆಯಲು ಅವಕಾಶ.

573
00:35:44,364 --> 00:35:48,720

574
00:35:48,720 --> 00:35:53,300
ನಾನು ಇನ್ನು ಮುಂದೆ ತನಕ ನಾವು decremented
ನಂತರ 10 ಹೆಚ್ಚಿನ, ಮತ್ತು ನಾವು

575
00:35:53,300 --> 00:35:55,700
ಫೂ, ಕ್ರಿಯೆ ಎಂದು.

576
00:35:55,700 --> 00:36:01,340
>> ಹಾಗಾಗಿ ತಕ್ಷಣ ನಾನು ಹಿಟ್ ಸಂಭವಿಸಿದ
ಕಾರ್ಯ foo, ನಾನು foo ಎಂಬ, ಮತ್ತು

577
00:36:01,340 --> 00:36:04,030
ನಂತರ ನಾನು ಇನ್ನು ಮುಂದೆ, GDB ಮೇಲೆ ನಿಯಂತ್ರಣವನ್ನು ಹೊಂದಿತ್ತು.

578
00:36:04,030 --> 00:36:10,230
ಆದ್ದರಿಂದ ತಕ್ಷಣ ನಾನು ಈ ಸಾಲಿನಲ್ಲಿ ಮುಂದೆ ಹಿಟ್,
ಈ ಸಂಭವಿಸಿದ ತನಕ ವಿಷಯಗಳನ್ನು ಮುಂದುವರೆಯಿತು,

579
00:36:10,230 --> 00:36:12,400
ಯಾವಾಗ ಅಲ್ಲಿ ಪ್ರೋಗ್ರಾಂ ನಿರ್ಗಮಿಸಿದೆ -

580
00:36:12,400 --> 00:36:14,450
ಅಂತಿಮವಾಗಿ ಇರಲಿಲ್ಲ ಊಹಿಸುತ್ತವೆ.

581
00:36:14,450 --> 00:36:16,390
ನೀವು ಆದರೂ ಸ್ವಲ್ಪ ವಿರಾಮ ಕಂಡಿತು.

582
00:36:16,390 --> 00:36:22,040
ಆದ್ದರಿಂದ ನಾನು ಮೇಲೆ ನಿಯಂತ್ರಣ ಕಳೆದುಕೊಂಡರೆ
ಆ ಸಮಯದಲ್ಲಿ ಪ್ರೋಗ್ರಾಂ?

583
00:36:22,040 --> 00:36:27,540
ನಾನು ಮುಂದಿನ ಟೈಪ್ ಅಲ್ಲದೆ, ಹೋಗುತ್ತದೆ
ಕೋಡ್ ಅಕ್ಷರಶಃ ಮುಂದಿನ ಲೈನ್

584
00:36:27,540 --> 00:36:28,850
ಕಾರ್ಯಗತಗೊಳಿಸಲು ಮಾಡುತ್ತದೆ.

585
00:36:28,850 --> 00:36:35,950
ಆದ್ದರಿಂದ ನಂತರ ಲೈನ್ 21, ಕೋಡ್ ಮುಂದಿನ ಲೈನ್
ಎಂದು, ಲೈನ್ 22 ಚಲಾಯಿಸಲ್ಪಡುತ್ತದೆ

586
00:36:35,950 --> 00:36:38,520
ಮುಖ್ಯ ನಿರ್ಗಮಿಸುವ, ಇದು.

587
00:36:38,520 --> 00:36:43,810
ಆದ್ದರಿಂದ ನಾನು ಹೋಗಿ ಬಯಸುವುದಿಲ್ಲ
ಕೋಡ್ ಮುಂದಿನ ಲೈನ್.

588
00:36:43,810 --> 00:36:48,170
ನಾನು ಫಂಕ್ಷನ್, foo ಹೋಗಲು ಬಯಸುವ,
ನಂತರ ಸಹ ಹೆಜ್ಜೆ

589
00:36:48,170 --> 00:36:49,830
ಕೋಡ್ ಆ ಸಾಲುಗಳು.

590
00:36:49,830 --> 00:36:53,726
>> ಆದ್ದರಿಂದ, ನಾವು ಪರ್ಯಾಯ ಹೊಂದಿರುತ್ತವೆ.

591
00:36:53,726 --> 00:36:56,770
ಮತ್ತೆ ಬಿಟ್ಟು ಬಿಡಿ.

592
00:36:56,770 --> 00:36:58,020
ಮುಖ್ಯ ಬ್ರೇಕ್.

593
00:36:58,020 --> 00:37:00,520

594
00:37:00,520 --> 00:37:06,370
ಉಹ್, 1, ಮುಂದಿನ, ಮುಂದಿನ, 13, ಮುಂದಿನ,
ಮುಂದಿನ, ಮುಂದಿನ, ಎಚ್ಚರಿಕೆಯಿಂದ,

595
00:37:06,370 --> 00:37:09,820
ನಾವು ಲೈನ್ foo, ಹಿಟ್ ಮೊದಲು.

596
00:37:09,820 --> 00:37:10,520
ಸರಿ.

597
00:37:10,520 --> 00:37:13,700
>> ಈಗ, ನಾವು, ಸಾಲು 21 ಆರ್
ನಾವು foo ಕರೆಯಲು ಅಲ್ಲಿ.

598
00:37:13,700 --> 00:37:17,100
ನಾವು, ಮುಂದಿನ ಟೈಪ್ ಬಯಸುವುದಿಲ್ಲ ಎಂದು ರಿಂದ
ಕೇವಲ ಕಾರ್ಯ foo ​​ಕರೆ, ಮತ್ತು

599
00:37:17,100 --> 00:37:18,710
ಕೋಡ್ ಮುಂದಿನ ಸಾಲಿಗೆ ಹೋಗಲು.

600
00:37:18,710 --> 00:37:20,840
ನಾವು ಬಳಸಲು ಬಯಸುವ ಹೆಜ್ಜೆ.

601
00:37:20,840 --> 00:37:25,690
ಆದ್ದರಿಂದ ಹಂತ ನಡುವೆ ವ್ಯತ್ಯಾಸಗಳಿವೆ
ಮತ್ತು ಹಂತ ಆಗಿ ಹಂತಗಳು ಅಲ್ಲಿ ಮುಂದೆ,

602
00:37:25,690 --> 00:37:28,190
ಕೆಲಸ, ಮತ್ತು ಮುಂದೆ ಹೋಗುತ್ತದೆ
ಕ್ರಿಯೆಯ ಮೇಲೆ.

603
00:37:28,190 --> 00:37:32,830
ಇದು ಕೇವಲ ಸಂಪೂರ್ಣ ಕಾರ್ಯಗತಗೊಳಿಸಿ
ಕಾರ್ಯ ಮತ್ತು ಇಡುತ್ತದೆ ಹೋಗುವ.

604
00:37:32,830 --> 00:37:37,210
>> ಆದ್ದರಿಂದ ಹಂತ ನಮಗೆ ತರಲಿದೆ
ಕಾರ್ಯ, foo,.

605
00:37:37,210 --> 00:37:41,160
ನಾವು ಈಗ, ನಾವು ಹಿಂದೆ ಆರ್, ಇಲ್ಲಿ ನೋಡಿ
ಸಿದ್ಧಾಂತದಲ್ಲಿ, ಎಂದು ಈ ಸಮಯದಲ್ಲಿ ಲೂಪ್,

606
00:37:41,160 --> 00:37:44,190
ಶಾಶ್ವತವಾಗಿ ಮುಂದುವರಿಸಲು ಹೋಗುವ.

607
00:37:44,190 --> 00:37:50,420
ಮತ್ತು ನೀವು ಸಹ ಇಲ್ಲದಿದ್ದಾಗ ಹಂತ, ಹಿಟ್
ಕರೆಯಲು ಕಾರ್ಯ, ಅದು ಇಲ್ಲಿದೆ

608
00:37:50,420 --> 00:37:51,720
ಮುಂದೆ ಒಂದೇ.

609
00:37:51,720 --> 00:37:55,320
ನೀವು ಒಂದು ಸಾಲಿನಲ್ಲಿ ಇರುವಾಗ ಆದ್ದರಿಂದ ಅದು ಮಾತ್ರ ಎಂದು
ಹಂತ ಒಂದು ಕಾರ್ಯ ಕರೆ ಇದೆ

610
00:37:55,320 --> 00:37:56,970
ಮುಂದೆ ಭಿನ್ನವಾಗಿವೆ ಹೋಗುತ್ತದೆ.

611
00:37:56,970 --> 00:37:57,930
ಆದ್ದರಿಂದ ಹಂತ ಇಲ್ಲಿ ನಮಗೆ ತರುವುದು.

612
00:37:57,930 --> 00:38:02,100
ಹಂತ, ಹಂತ, ಹಂತ, ಹಂತ, ಹಂತ, ಹಂತ, ಮತ್ತು
ನಾವು ಶಾಶ್ವತವಾಗಿ ಕೇವಲ ಅನಂತ ಆದೇಶಗಳ ಮಾಡುತ್ತೇವೆ.

613
00:38:02,100 --> 00:38:06,810
>> ಆದ್ದರಿಂದ ನೀವು ಆ ಬಳಸಲಾಗುತ್ತದೆ ಇರಬಹುದು ನಿಮ್ಮ
ಅನಂತ ಕುಣಿಕೆಗಳು ಗುರುತಿಸುವ ರೀತಿಯಲ್ಲಿ,

614
00:38:06,810 --> 00:38:08,960
ಕೇವಲ ಈ Enter ಕೀಲಿಯನ್ನು ಹಿಡಿದುಕೊಂಡು
ನೀವು ಮಧ್ಯ ಅಲ್ಲಿ ನೋಡಿ.

615
00:38:08,960 --> 00:38:11,610

616
00:38:11,610 --> 00:38:14,780
ಇಲ್ಲ ಹಾಗೆ ಉತ್ತಮ ಮಾರ್ಗಗಳಿವೆ, ಆದರೆ
ಈಗ, ಸಂಪೂರ್ಣವಾಗಿ ಸಾಕಾಗುತ್ತದೆ.

617
00:38:14,780 --> 00:38:17,967
ಮತ್ತು ಶೈಲಿಯಲ್ಲಿ, ಶೈಲಿ ಪಾಲಿಸಲು
50, ನಾನು ಈ ಮಾಡಬೇಕಿತ್ತೆಂದು.

618
00:38:17,967 --> 00:38:21,550

619
00:38:21,550 --> 00:38:24,030
ಸರಿ.

620
00:38:24,030 --> 00:38:28,400
>> ಆದ್ದರಿಂದ ಕೊನೆಯ ಆಜ್ಞೆಯನ್ನು ಪರಿಚಯಿಸಲು.

621
00:38:28,400 --> 00:38:30,810
ಅಲ್ಲದೆ, ಸೈನ್ ಡಿಬಗ್ GDB ಅವಕಾಶ

622
00:38:30,810 --> 00:38:35,580
ಆದ್ದರಿಂದ ಬದಲಿಗೆ ಮುಖ್ಯ ಮುರಿಯುವ, ನಾನು
foo ಕಾರ್ಯದ ತಿಳಿಯಲು ಸಹ

623
00:38:35,580 --> 00:38:39,230
ಸಮಸ್ಯೆ, ನಂತರ ನಾನು ತೋರಿಸಬಹುದಿತ್ತು ಕೇವಲ
ಬದಲಿಗೆ, foo, ನಲ್ಲಿ ಮುರಿಯಲು.

624
00:38:39,230 --> 00:38:42,310
ನ ನಾನು ಬ್ರೇಕ್ ಹೇಳಲು ಲೆಟ್
ಮುಖ್ಯ ಮತ್ತು foo ಎರಡೂ.

625
00:38:42,310 --> 00:38:45,390
ಆದ್ದರಿಂದ ನೀವು ಅನೇಕ ಬ್ರೇಕ್ಪಾಯಿಂಟ್ ಹೊಂದಿಸಬಹುದು
ನೀವು ಬಯಸುವ.

626
00:38:45,390 --> 00:38:49,230
ನಾನು ರನ್ ಟೈಪ್ ಮಾಡಿದಾಗ, ಇದು ವಿಶೇಷವೇನು
ನಿಲ್ಲಿಸಿ -

627
00:38:49,230 --> 00:38:52,180
ooh, ರಿಂದ, ನ ಪುನರ್ ಸಂಕಲನ ಅವಕಾಶ
ನಾನು ವಿಷಯಗಳನ್ನು ಬದಲಾಗಿದೆ.

628
00:38:52,180 --> 00:38:55,950
ಈ ಸಾಲಿನಲ್ಲಿ, ಎಚ್ಚರಿಕೆ, ಮೂಲ ನೋಡುತ್ತಾರೆ
ಕಡತ ಕಾರ್ಯಗತಗೊಳ್ಳುವ ಹೆಚ್ಚು ಇತ್ತೀಚಿನ ಆಗಿದೆ.

629
00:38:55,950 --> 00:38:59,680
ಆದ್ದರಿಂದ ನಾನು ಇಲ್ಲಿ ಹೋದರು ಅರ್ಥ
ಮತ್ತು ಶೈಲಿ ಪಾಲಿಸಲು ಈ ಬದಲಾವಣೆ

630
00:38:59,680 --> 00:39:03,100
50, ಆದರೆ ನಾನು ಮರುಸಂಕಲಿಕೆಯು ಮಾಡಲಿಲ್ಲ
ಪ್ರೋಗ್ರಾಂ.

631
00:39:03,100 --> 00:39:04,870
ಆದ್ದರಿಂದ GDB ಎಂದು ನನಗೆ ಅರಿವು ಮಾಡುತ್ತದೆ.

632
00:39:04,870 --> 00:39:10,130
ನಾನು, ಮತ್ತೆ ಡಿಬಗ್ ಮಾಡಲು, ಬಿಟ್ಟು ಮಾಡುತ್ತೇವೆ
GDB ಡಿಬಗ್ ಹಿಟ್.

633
00:39:10,130 --> 00:39:10,700
ಸರಿ.

634
00:39:10,700 --> 00:39:12,800
>> ಈಗ, ಮತ್ತೆ ನಾನು ಮಾಡುತ್ತಿದ್ದ ಗೆ.

635
00:39:12,800 --> 00:39:15,720
ಮುಖ್ಯ, ಬ್ರೇಕ್ foo, ಬ್ರೇಕ್.

636
00:39:15,720 --> 00:39:20,680
ಈಗ ನಾನು ಪ್ರೊಗ್ರಾಮನ್ನು, ಆದ್ದರಿಂದ ವೇಳೆ
ಹಿಟ್ಸ್ ರವರೆಗೆ ಮುಂದುವರಿಸಲು ಹೋಗುವ ಒಂದು

637
00:39:20,680 --> 00:39:21,320
ಬ್ರೇಕ್ಪಾಯಿಂಟ್.

638
00:39:21,320 --> 00:39:24,680
ಆ ಬ್ರೇಕ್ಪಾಯಿಂಟ್ ಸಂಭವಿಸಿದರೆ
ಮುಖ್ಯ ಮೊದಲ ಒಂದು.

639
00:39:24,680 --> 00:39:28,630
ಈಗ, ಬದಲಿಗೆ ಮುಂದಿನ ಮಾಡುವ, ಮುಂದಿನ, ಮುಂದಿನ,
ಮುಂದಿನ, ಮುಂದಿನ, ನಾನು foo ಹಿಟ್ ರವರೆಗೆ, ನಾನು

640
00:39:28,630 --> 00:39:35,230
ಮುಂದುವರಿಸುತ್ತದೆ ಇದು ಮುಂದುವರಿಸಲು ಟೈಪ್ ಮಾಡಬಹುದು
ನೀವು ಮುಂದಿನ ಬ್ರೇಕ್ಪಾಯಿಂಟ್ ಹಿಟ್ ರವರೆಗೆ.

641
00:39:35,230 --> 00:39:37,200
ನಾನು ಮೊದಲ ಪೂರ್ಣಾಂಕ ಪ್ರವೇಶಿಸಬೇಕಾಗುತ್ತದೆ.

642
00:39:37,200 --> 00:39:40,570
ನಾನು ಹಿಟ್ ರವರೆಗೆ ಮುಂದುವರಿಯುತ್ತದೆ ಮುಂದುವರಿಸಿ
ಎಂದು ಇದು ಮುಂದಿನ ಬ್ರೇಕ್ಪಾಯಿಂಟ್,

643
00:39:40,570 --> 00:39:43,320
foo ಆಫ್ ಕಾರ್ಯ.

644
00:39:43,320 --> 00:39:50,130
>> ನೀವು ಒಂದು ಹಿಟ್ ರವರೆಗೆ ಆದ್ದರಿಂದ ರನ್ ರನ್
ಯಾವಾಗ ಬ್ರೇಕ್ಪಾಯಿಂಟ್, ಆದರೆ ನೀವು ಮಾತ್ರ ರನ್ ಟೈಪ್

645
00:39:50,130 --> 00:39:54,060
ನೀವು, ನಂತರ ಕಾರ್ಯಕ್ರಮವನ್ನು ಪ್ರಾರಂಭಿಸುವ, ಮತ್ತು ನೀವು
ಆಗಿನಿಂದ, ಮುಂದುವರೆಯಲು ಇಲ್ಲಿದೆ.

646
00:39:54,060 --> 00:40:01,950
ನಾನು ಮುಖ್ಯ ಮುರಿದಿದ್ದಾರೆ ಮತ್ತು ವೇಳೆ
ನಂತರ ನಡೆಯಿತು, ಇದು ಮುರಿಯಲು ಮಾಡುತ್ತೇವೆ

647
00:40:01,950 --> 00:40:03,670
ನಂತರ ಮುಖ್ಯ, ಮತ್ತು ಮುಂದುವರೆಯಲು.

648
00:40:03,670 --> 00:40:10,050
ನಾನು foo ಒಂದು ಬ್ರೇಕ್ ಪಾಯಿಂಟ್ ಹೊಂದಿವೆ, ಏಕೆಂದರೆ
ಪೂರ್ಣಾಂಕ ನಮೂದಿಸಿ, ನಂತರ ಈಗ ನಾನು

649
00:40:10,050 --> 00:40:11,380
foo, ನಲ್ಲಿ ಮುರಿಯಲು ಹೋಗುವ.

650
00:40:11,380 --> 00:40:16,318
ಇದು ಕೇವಲ ಅನಂತ ವಿಶೇಷವೇನು
ಎಂದು ರವರೆಗೆ ಲೂಪ್.

651
00:40:16,318 --> 00:40:17,568
ಸರಿ.

652
00:40:17,568 --> 00:40:19,500

653
00:40:19,500 --> 00:40:24,420
>> ಆದ್ದರಿಂದ, GDB ಪೀಠಿಕೆಯನ್ನು ಇಲ್ಲಿದೆ.

654
00:40:24,420 --> 00:40:27,790
ನೀವು ಅದನ್ನು ಬಳಸಿಕೊಂಡು ಪ್ರಾರಂಭಿಸಬೇಕು
ನಿಮ್ಮ ಸಮಸ್ಯೆಯನ್ನು.

655
00:40:27,790 --> 00:40:30,550
ಇದು ಬಹಳ ಸಹಾಯವಾಗುತ್ತದೆ
ದೋಷಗಳನ್ನು ಗುರುತಿಸಲು.

656
00:40:30,550 --> 00:40:35,280
ನೀವು ವಾಸ್ತವವಾಗಿ ಕೇವಲ, ಲೈನ್ ಮೂಲಕ ಲೈನ್, ಹೋದರೆ
ನಿಮ್ಮ ಕೋಡ್ ಮೂಲಕ, ಮತ್ತು ಏನು ಹೋಲಿಸಿ

657
00:40:35,280 --> 00:40:39,740
ವಾಸ್ತವವಾಗಿ ನೀವು ನಿರೀಕ್ಷಿಸಬಹುದು ಏನು ನಡೆಯುತ್ತಿದೆ
ಸಂಭವಿಸಿ, ನಂತರ ಇದು ಬಹಳ ಇಲ್ಲಿದೆ

658
00:40:39,740 --> 00:40:41,060
ನಿಮ್ಮ ದೋಷಗಳನ್ನು ತಪ್ಪಿಸಿಕೊಳ್ಳದಂತೆ ಕಷ್ಟ.

659
00:40:41,060 --> 00:40:45,280

660
00:40:45,280 --> 00:40:46,530
ಸರಿ.

661
00:40:46,530 --> 00:40:48,310

662
00:40:48,310 --> 00:40:54,040
>> ಕಳೆದ ವಾರ ಡೇವಿಡ್ ಈ ತಂದರು
ರಹಸ್ಯ ಕೀ ಗುಪ್ತ ವಿಷಯವನ್ನು

663
00:40:54,040 --> 00:40:59,350
ನಾವು ಬಯಸುವುದಿಲ್ಲ ಅಲ್ಲಿ ಮೊದಲ ಬಾರಿಗೆ,
ಪಾಸ್ವರ್ಡ್ಗಳನ್ನು ಕೇವಲ ಸಂಗ್ರಹಿಸಲಾಗುವುದು ನಮ್ಮ

664
00:40:59,350 --> 00:41:03,210
ಕೆಲವು ಸರಳ ಪಠ್ಯ ಕಡತದಲ್ಲಿನ ಕಂಪ್ಯೂಟರ್, ಅಲ್ಲಿ
ಯಾರಾದರೂ ಮೇಲೆ ಮತ್ತು ಕೇವಲ ಬರಬಹುದು

665
00:41:03,210 --> 00:41:04,660
ಇದು ತೆರೆಯುತ್ತದೆ ಮತ್ತು ಅವುಗಳನ್ನು ಓದಲು.

666
00:41:04,660 --> 00:41:07,530
ತಾತ್ತ್ವಿಕವಾಗಿ, ಅವರು ಎನ್ಕ್ರಿಪ್ಟ್ ಎಂದು
ಕೆಲವು ರೀತಿಯಲ್ಲಿ.

667
00:41:07,530 --> 00:41:13,340
ಮತ್ತು ಸಮಸ್ಯೆ ಸೆಟ್ 2, ನೀವು ವ್ಯವಹರಿಸುವಾಗ ಪಡೆದುಕೊಳ್ಳುತ್ತೀರಿ
ಗೂಢಲಿಪೀಕರಣ ಒಂದು ವಿಧಾನ,

668
00:41:13,340 --> 00:41:16,520
ಅಥವಾ, ಜೊತೆಗೆ ಎರಡು ವಿಧಾನಗಳು, ಆದರೆ
ಅವರು ಬಹಳವೇ ಅಲ್ಲ.

669
00:41:16,520 --> 00:41:20,050
ನೀವು ಹ್ಯಾಕರ್ ಆವೃತ್ತಿ ಮಾಡಲು, ನೀವು ಕೋರುತ್ತೇವೆ
ಸಹ ವ್ಯವಹರಿಸುವಾಗ ಏರಲಿದೆ

670
00:41:20,050 --> 00:41:22,150
ಕೆಲವು ವಿಷಯಗಳನ್ನು ಡೀಕ್ರಿಪ್ಟ್.

671
00:41:22,150 --> 00:41:29,770
>> ಆದ್ದರಿಂದ ಸಮಸ್ಯೆಯನ್ನು ಈಗ ಚೆನ್ನಾಗಿ, ಸಹ,
ನಾವು ಪ್ರಬಲ ಗೂಢಲಿಪೀಕರಣ ಹೊಂದಿವೆ

672
00:41:29,770 --> 00:41:34,830
ವಿಶ್ವದ ಕ್ರಮಾವಳಿ, ನೀವು ಆಯ್ಕೆ
ವಿಶೇಷವಾಗಿ ಕಳಪೆ ಗುಪ್ತಪದವನ್ನು, ಅದು

673
00:41:34,830 --> 00:41:37,720
, ತುಂಬಾ ಸಹಾಯ ಇರುವುದರಿಂದ ಜನರು
ಇನ್ನೂ ಲೆಕ್ಕಾಚಾರ ಸಾಧ್ಯವಾಗುತ್ತದೆ.

674
00:41:37,720 --> 00:41:41,530
ಎನ್ಕ್ರಿಪ್ಟ್ ಸ್ಟ್ರಿಂಗ್ ನೋಡಿದ ಮತ್ತು ಸಹ
ಇದು ಕಸ ಕಗ್ಗಂಟು ಕಾಣುತ್ತದೆ

675
00:41:41,530 --> 00:41:44,760
ವೇಳೆ, ಅವರಿಗೆ ಏನೂ ಅರ್ಥ ಅವರು
ಇನ್ನೂ ಕೆಲವೇ ಪಾಸ್ವರ್ಡ್ಗಳನ್ನು ಪ್ರಯತ್ನಿಸಿ ಅಗತ್ಯವಿದೆ

676
00:41:44,760 --> 00:41:50,560
ನೀವು ನಂತರ, ಇದು ಲೆಕ್ಕಾಚಾರ
ಅತ್ಯಂತ ಸುರಕ್ಷಿತ ಅಲ್ಲ.

677
00:41:50,560 --> 00:41:55,890
ಆದ್ದರಿಂದ ವೀಡಿಯೊ ವೀಕ್ಷಿಸಿದ ಎಂದು
ಆ ಮಾಡುತ್ತದೆ.

678
00:41:55,890 --> 00:41:59,587

679
00:41:59,587 --> 00:42:00,970
>> [ವೀಡಿಯೋ ಪ್ಲೇಬ್ಯಾಕ್]

680
00:42:00,970 --> 00:42:02,100
>> -ಹೆಲ್ಮೆಟ್, ನೀವು ದೆವ್ವ.

681
00:42:02,100 --> 00:42:03,370
ಇಂದಿನ ವಿಶೇಷವೇನು?

682
00:42:03,370 --> 00:42:05,170
ನನ್ನ ಮಗಳು ಏನು ಮಾಡುತ್ತಿದ್ದಾರೆ?

683
00:42:05,170 --> 00:42:09,910
>> ಪ್ರತಿಭಾವಂತ ಪರಿಚಯಿಸಲು ನನಗೆ ಪರವಾನಗಿ
ಯುವ ಪ್ಲಾಸ್ಟಿಕ್ ಸರ್ಜನ್, ಡಾ ಫಿಲಿಪ್

684
00:42:09,910 --> 00:42:13,730
Schlotkin ತಿನ್ನುವೆ, ಮಹಾನ್ ಮೂಗು
ಇಡೀ ಕೆಲಸ ಮನುಷ್ಯ

685
00:42:13,730 --> 00:42:16,080
ಬ್ರಹ್ಮಾಂಡದ ಮತ್ತು ಬೆವರ್ಲಿ ಹಿಲ್ಸ್.

686
00:42:16,080 --> 00:42:17,210
>> -ನಿಮ್ಮ ಹೈನೆಸ್.

687
00:42:17,210 --> 00:42:18,070
>> -ನೋಸ್ ಕೆಲಸ?

688
00:42:18,070 --> 00:42:18,670
ಅರ್ಥವಾಗುತ್ತಿಲ್ಲ.

689
00:42:18,670 --> 00:42:20,090
ಅವರು ಈಗಾಗಲೇ ನಾಶಿಕ ಹೊಂದಿದ್ದ.

690
00:42:20,090 --> 00:42:21,910
ಇದು ಒಂದು ಸಿಹಿ ಹದಿನಾರು ಉಪಸ್ಥಿತರಿದ್ದರು.

691
00:42:21,910 --> 00:42:22,140
>> ಸಂಖ್ಯೆ.

692
00:42:22,140 --> 00:42:23,690
ಅದು ನೀವು ಏನು ಅಲ್ಲ.

693
00:42:23,690 --> 00:42:25,420
ಇದು ಬಹಳ ಬಹಳ ಕೆಟ್ಟದಾದ ಇಲ್ಲಿದೆ.

694
00:42:25,420 --> 00:42:30,300
ನೀವು ನನ್ನನ್ನು ಸಂಯೋಜನೆಯನ್ನು ನೀಡದಿದ್ದಲ್ಲಿ
ಏರ್ ಶೀಲ್ಡ್, ಡಾ Schlotkin ತಿನ್ನುವೆ

695
00:42:30,300 --> 00:42:34,226
ತನ್ನ ಹಳೆಯ ಮೂಗು ನಿಮ್ಮ ಮಗಳು ಮತ್ತೆ ನೀಡಿ.

696
00:42:34,226 --> 00:42:35,476
>> ಸಂಖ್ಯೆ.

697
00:42:35,476 --> 00:42:38,712

698
00:42:38,712 --> 00:42:40,516
ನೀವು ಅಲ್ಲಿ ಎಂದು ಬಂದೆವು?

699
00:42:40,516 --> 00:42:41,440
>> -ಸರಿ.

700
00:42:41,440 --> 00:42:42,180
ನಾನು ಹೇಳುತ್ತೇನೆ.

701
00:42:42,180 --> 00:42:43,381
ನಾನು ಹೇಳುತ್ತೇನೆ.

702
00:42:43,381 --> 00:42:44,263
ಇಲ್ಲ, ಡ್ಯಾಡಿ.

703
00:42:44,263 --> 00:42:45,590
ಇಲ್ಲ, ನೀವು ಮಾಡಬೇಕಾಗುತ್ತದೆ.

704
00:42:45,590 --> 00:42:46,860
>> -You're ಬಲ, ನನ್ನ ಪ್ರೀತಿಯ.

705
00:42:46,860 --> 00:42:48,450
ನಾನು ನಿಮ್ಮ ಹೊಸ ಮೂಗು ತಪ್ಪಿಸಿಕೊಳ್ಳಬಾರದ ಮಾಡುತ್ತೇವೆ.

706
00:42:48,450 --> 00:42:52,090
ಆದರೆ ನಾನು ಅವನನ್ನು ಸಂಯೋಜನೆಯನ್ನು ಹೇಳುವುದಿಲ್ಲ,
ಯಾವುದೇ.

707
00:42:52,090 --> 00:42:53,680
>> -ಚೆನ್ನಾಗಿ.

708
00:42:53,680 --> 00:42:55,685
ಡಾ Schlotkin, ನಿಮ್ಮ ಕೆಟ್ಟ ಹಾಗೆ.

709
00:42:55,685 --> 00:42:56,914
>> -ನನ್ನ ಸಂತೋಷ.

710
00:42:56,914 --> 00:43:00,690
>> [TOOLS ಹರಿತವಾದ]

711
00:43:00,690 --> 00:43:01,910
>> ಸಂಖ್ಯೆ.

712
00:43:01,910 --> 00:43:02,520
ನಿರೀಕ್ಷಿಸಿ.

713
00:43:02,520 --> 00:43:03,836
ನಿರೀಕ್ಷಿಸಿ.

714
00:43:03,836 --> 00:43:05,300
ನಾನು ಹೇಳುತ್ತೇನೆ.

715
00:43:05,300 --> 00:43:06,880
ನಾನು ಹೇಳುತ್ತೇನೆ.

716
00:43:06,880 --> 00:43:09,130
>> ನಾನು ಕೆಲಸ ಎಂದು ತಿಳಿದಿದ್ದರು.

717
00:43:09,130 --> 00:43:09,900
ಸರಿ.

718
00:43:09,900 --> 00:43:12,850
ನನಗೆ ಇದು ನೀಡಿ.

719
00:43:12,850 --> 00:43:16,918
>> -ಸಂಯೋಜನೆಯನ್ನು ಒಂದಾಗಿದೆ.

720
00:43:16,918 --> 00:43:17,406
>> ಒನ್.

721
00:43:17,406 --> 00:43:18,382
>> ಒನ್.

722
00:43:18,382 --> 00:43:19,358
>> ಟು.

723
00:43:19,358 --> 00:43:19,846
>> ಟು.

724
00:43:19,846 --> 00:43:20,822
>> ಟು.

725
00:43:20,822 --> 00:43:21,310
>> ಮೂರು.

726
00:43:21,310 --> 00:43:21,798
>> ಮೂರು.

727
00:43:21,798 --> 00:43:22,774
>> ಮೂರು.

728
00:43:22,774 --> 00:43:23,262
>> ಫೋರ್.

729
00:43:23,262 --> 00:43:23,750
>> ಫೋರ್.

730
00:43:23,750 --> 00:43:26,150
>> ಫೋರ್.

731
00:43:26,150 --> 00:43:27,010
>> -ಐದು.

732
00:43:27,010 --> 00:43:27,670
>> -ಐದು.

733
00:43:27,670 --> 00:43:29,010
>> -ಐದು.

734
00:43:29,010 --> 00:43:34,770
>> -ಆದ್ದರಿಂದ ಸಂಯೋಜನೆಯನ್ನು, ಒಂದು
ಎರಡು, ಮೂರು, ನಾಲ್ಕು, ಐದು.

735
00:43:34,770 --> 00:43:37,460
ಆ ಕೆಟ್ಟ ಸಂಯೋಗವಾಗಿದೆ
ನಾನು ನನ್ನ ಜೀವನದಲ್ಲಿ ಕೇಳಿದ.

736
00:43:37,460 --> 00:43:39,710
ವಸ್ತು ಆ ರೀತಿಯ ಒಂದು ಈಡಿಯಟ್ ಇಲ್ಲಿದೆ
ತನ್ನ ಹಾಸಿಗೆ ಮೇಲೆ ಹೊಂದಿರುತ್ತದೆ.

737
00:43:39,710 --> 00:43:42,000
>> ನಿಮ್ಮ ಹೈನೆಸ್, ನಿಮಗೆ ಧನ್ಯವಾದಗಳು.

738
00:43:42,000 --> 00:43:43,530
>> -ನೀವು ಏನು ಮಾಡುವಿರಿ?

739
00:43:43,530 --> 00:43:44,490
>> -ನಾನು ವಾಲ್ ಆಫ್ ಮಾಡಲಾಗಿದೆ.

740
00:43:44,490 --> 00:43:45,420
>> -ಇಲ್ಲ ನೀವು ಮಾಡಲಿಲ್ಲ.

741
00:43:45,420 --> 00:43:45,840
ನೀವು ಇಡೀ ಚಿತ್ರ ಆಫ್ ಮಾಡಲಾಗಿದೆ.

742
00:43:45,840 --> 00:43:46,930
>> ನಾನು ತಪ್ಪು ಬಟನ್ ಒತ್ತಿದರೆ ಹೊಂದಿರಬೇಕು.

743
00:43:46,930 --> 00:43:48,265
>> ಬಾವಿ, ಅದರ ಮೇಲೆ ಮುಂದೂಡಲಾಗಿದೆ.

744
00:43:48,265 --> 00:43:49,110
ಚಿತ್ರದ ಮೇಲೆ ಮುಂದೂಡಲಾಗಿದೆ.

745
00:43:49,110 --> 00:43:49,510
>> -ಹೌದು, ಸರ್.

746
00:43:49,510 --> 00:43:49,917
ಹೌದು, ಸರ್.

747
00:43:49,917 --> 00:43:50,324
>> ನ, ಅರ್ನಾಲ್ಡ್ ಹೋಗಿ ಅವಕಾಶ.

748
00:43:50,324 --> 00:43:51,140
, ಗ್ರೆಚೆನ್ ಕಮ್.

749
00:43:51,140 --> 00:43:53,060
ಸಹಜವಾಗಿ, ನೀವು ನಾನು ಇನ್ನೂ ಮಾಡುತ್ತೇವೆ ತಿಳಿದಿದೆ
ಈ ನಿಮಗೆ ಬಿಲ್ ಹೊಂದಿರುತ್ತವೆ.

750
00:43:53,060 --> 00:43:53,440
>> [END ವೀಡಿಯೋ ಪ್ಲೇಬ್ಯಾಕ್]

751
00:43:53,440 --> 00:43:54,690
>> ರಾಬ್ ಬೋಡನ್: ಸರಿ.

752
00:43:54,690 --> 00:43:59,690

753
00:43:59,690 --> 00:44:08,430
ನಾವು ಈಗಾಗಲೇ ಬಗ್ಗೆ ನೀವು ಈಗ ಆ
ಕೆಲವು ರೀತಿಯಲ್ಲಿ ಭದ್ರತೆ, ಸಂತೋಷವನ್ನು

754
00:44:08,430 --> 00:44:16,050
ಕಡಿಮೆ ಚಿತ್ರದ ಪೋಸ್ಟರ್, ಆದ್ದರಿಂದ ಇತ್ತೀಚಿನ ರಲ್ಲಿ
ಎನ್ಎಸ್ಎ ದಿನಗಳ, ಈ ಸಮಸ್ಯೆಗಳನ್ನು

755
00:44:16,050 --> 00:44:17,300
ಎಲ್ಲವೂ ಮೇಲ್ವಿಚಾರಣೆ.

756
00:44:17,300 --> 00:44:21,840

757
00:44:21,840 --> 00:44:26,930
ನೀವು ಅನಿಸುತ್ತದೆ ಕಷ್ಟವಾಗಬಹುದು
ಗೌಪ್ಯತೆ ಕೆಲವು ವಿಧದ ಹೊಂದಿವೆ

758
00:44:26,930 --> 00:44:34,540
ಆನ್ಲೈನ್ ವಿಶ್ವದ, ನಾನು ಹೇಳಲು ಸಾಧ್ಯವಾಗಲಿಲ್ಲ ಆದರೂ
ನೀವು ಪ್ರಿಸ್ಮ್ ವಿವರಗಳು ಅತ್ಯಂತ.

759
00:44:34,540 --> 00:44:42,130
ಆದ್ದರಿಂದ ಪ್ರಿಸ್ಮ್ ಆಚೆಗೆ, ನಾವು ಹೋಗುತ್ತಿಲ್ಲ
ಈಗ, ಆ ಬಗ್ಗೆ ಮಾಡಲು

760
00:44:42,130 --> 00:44:44,030
ನಿಮ್ಮ ಲ್ಯಾಪ್ಟಾಪ್ ಬಗ್ಗೆ.

761
00:44:44,030 --> 00:44:48,360
ಆದ್ದರಿಂದ ಇಲ್ಲಿ, ನಾನು ಬದಲಾಯಿಸಲು ಬಯಸುವ
ನನ್ನ ನಿಜವಾದ ಖಾತೆಗೆ,

762
00:44:48,360 --> 00:44:50,370
ನನ್ನ ಪುಟ್ಟ ಪೆಂಗ್ವಿನ್ ಜೊತೆ.

763
00:44:50,370 --> 00:44:57,310
ಹಾಗಾಗಿ ಪಾಸ್ವರ್ಡ್ ಸೆಟ್, ಮತ್ತು
ಗುಪ್ತಪದವನ್ನು ನಾನು ಬಯಸುತ್ತೇನೆ ಯಾವುದೇ ಹೊಂದಿದೆ.

764
00:44:57,310 --> 00:45:02,430
>> ಆದರೆ ನೆನಪಿಡಿ ನಾನು ಲಾಗ್ ಬಾಗುತ್ತೇನೆ
ಆದ್ದರಿಂದ ಈ ಲಾಗಿನ್ ಜೊತೆ

765
00:45:02,430 --> 00:45:04,850
ಪ್ರಾಂಪ್ಟಿನಲ್ಲಿ, ಕೆಲವು ಕಾರ್ಯಕ್ರಮ.

766
00:45:04,850 --> 00:45:07,910
ಇದು ಎಂದು ಕೆಲವು ಕಾರ್ಯಕ್ರಮದ
ಕೆಲವು ವ್ಯಕ್ತಿ ಬರೆದ.

767
00:45:07,910 --> 00:45:13,250
ಆದ್ದರಿಂದ, ಆ ವ್ಯಕ್ತಿಯು ಅವರು
ವಿಶೇಷವಾಗಿ ದುರುದ್ದೇಶಪೂರಿತ, ಅವರು ಸಾಧ್ಯವಾಗುವಷ್ಟು

768
00:45:13,250 --> 00:45:17,780
ಹೇಳಿರುವುದು, ಸರಿ, ಆದ್ದರಿಂದ ವೇಳೆ ಗುಪ್ತಪದವನ್ನು
ನಾನು ನಮೂದಿಸುವ ಸಮಾನವಾಗಿರುತ್ತದೆ ನನ್ನ

769
00:45:17,780 --> 00:45:22,800
ನಿಜವಾದ ಪಾಸ್ವರ್ಡ್, ಅಥವಾ ಇದು ಸಮಾನ
ಕೆಲವು ವಿಶೇಷ ಗುಪ್ತಪದವನ್ನು -

770
00:45:22,800 --> 00:45:25,550
ಡೇವಿಡ್ ನಾಡಿದು ಅಥವಾ ಸಂಗತಿಯಾಗಿದೆ -

771
00:45:25,550 --> 00:45:27,190
ನಂತರ ಅವುಗಳನ್ನು ಸೈನ್ ಅವಕಾಶ

772
00:45:27,190 --> 00:45:33,760
ಆದ್ದರಿಂದ ಒಂದು ದುರುದ್ದೇಶಪೂರಿತ ಪ್ರೋಗ್ರಾಮರ್ ತೋರಿಸಬಹುದಿತ್ತು
ನಿಮ್ಮ ಮ್ಯಾಕ್ಗಳ ಎಲ್ಲಾ, ಅಥವಾ ಪ್ರವೇಶ

773
00:45:33,760 --> 00:45:36,150
ವಿಂಡೋಸ್, ಅಥವಾ ಏನು.

774
00:45:36,150 --> 00:45:41,980
>> ಆದ್ದರಿಂದ, ರಿಂದ, ಕಾಳಜಿ ಹೆಚ್ಚು
ನಾನು ಅರ್ಥ, ಈ ಲಾಗಿನ್ ಕಾರ್ಯಕ್ರಮ

775
00:45:41,980 --> 00:45:48,720
OS X,, ನೂರಾರು ಕಳುಹಿಸಲಾದ ವಿಶೇಷವೇನು
ಅಥವಾ ಜನರು ಸಾವಿರಾರು

776
00:45:48,720 --> 00:45:50,020
ಈ ಕೋಡ್ ಪರಿಶೀಲಿಸಲಾಗಿದೆ.

777
00:45:50,020 --> 00:45:55,330
ಆದ್ದರಿಂದ, ನೀವು, ಎಲ್ಲೋ ನಿಮ್ಮ ಕೋಡ್, ವೇಳೆ
ಈ ವಾಕ್ಯವನ್ನು ಸಮನಾಗಿರುತ್ತದೆ ಸಮನಾಗಿರುತ್ತದೆ ಹೇಳಲು

778
00:45:55,330 --> 00:45:58,860
ಡೇವಿಡ್ ನಾಡಿದು, ಲಾಗಿನ್ ನಂತರ ಯಾರೊಬ್ಬರ
ಏರಲಿದೆ, ಹಾಗೆ, ನಿರೀಕ್ಷಿಸಿ.

779
00:45:58,860 --> 00:45:59,800
ಈ ಸರಿ ಇಲ್ಲ.

780
00:45:59,800 --> 00:46:01,790
ಈ ಇಲ್ಲಿ ಇರುವಂತಿಲ್ಲ.

781
00:46:01,790 --> 00:46:06,650
ಆದ್ದರಿಂದ ನಾವು ವಿಷಯಗಳನ್ನು ಪಡೆಯಿರಿ ಒಂದು ಮಾರ್ಗವಾಗಿದೆ
ರೀತಿಯ ಸುರಕ್ಷಿತ ಎಂದು.

782
00:46:06,650 --> 00:46:10,300
>> ಆದರೆ ಕಾರ್ಯಕ್ರಮಗಳನ್ನು ಬಗ್ಗೆ
ನೀವು ಬರೆಯುವ.

783
00:46:10,300 --> 00:46:13,000
ನೀವು ಲಾಗಿನ್ ಪ್ರೋಗ್ರಾಂ ಬರೆದರು ಹೇಳುತ್ತಾರೆ.

784
00:46:13,000 --> 00:46:20,440
ನೀವು ಬರೆದ ಈ ಲಾಗಿನ್ ಪ್ರೋಗ್ರಾಂ,
ನಿಸ್ಸಂಶಯವಾಗಿ, ನೀವು ಒಂದು ಉತ್ತಮ

785
00:46:20,440 --> 00:46:21,210
ಪ್ರೋಗ್ರಾಮರ್.

786
00:46:21,210 --> 00:46:25,610
ನೀವು ಯಾವುದೇ ದುರುದ್ದೇಶಪೂರಿತ ಹಾಕಲು ಹೋಗುತ್ತಿಲ್ಲ
X ಸಮನಾಗಿರುತ್ತದೆ ಸಮನಾಗಿರುತ್ತದೆ ಡೇವಿಡ್ ಆಕರ್ಷಕವಾಗಿದೆ

787
00:46:25,610 --> 00:46:27,860
ನಿಮ್ಮ ಕೋಡ್.

788
00:46:27,860 --> 00:46:31,930
ಆದರೆ ಈ ಕಾರ್ಯಕ್ರಮ, ನೀವು ಏನು
ಈ ಪ್ರೋಗ್ರಾಂ ಕಂಪೈಲ್ ಬಳಸಲು?

789
00:46:31,930 --> 00:46:34,180
ಖಣಿಲು ರೀತಿಯ.

790
00:46:34,180 --> 00:46:38,460
ಆದ್ದರಿಂದ ಯಾವ ವೇಳೆ ಸಂಭವಿಸಿದ ವ್ಯಕ್ತಿ
ಖಣಿಲು ಕೇಸ್ಡ್ ಖಣಿಲು ವಿಶೇಷ ಬರೆಯಲು

791
00:46:38,460 --> 00:46:44,310
ಏನೋ, ನಾನು ಕಂಪೈಲ್ ನಾನು ವೇಳೆ
ಪ್ರೋಗ್ರಾಂ ಲಾಗಿನ್, ನಂತರ ಈ ಕೋಡ್ ನಮೂದಿಸಿ

792
00:46:44,310 --> 00:46:49,720
ವೇಳೆ, ಹೇಳುತ್ತದೆ ಲಾಗಿನ್ ಕಾರ್ಯಕ್ರಮದಲ್ಲಿ
X ಸಮನಾಗಿರುತ್ತದೆ ಡೇವಿಡ್ ಆಕರ್ಷಕವಾಗಿದೆ ಸಮ?

793
00:46:49,720 --> 00:46:59,890
ಆದ್ದರಿಂದ ಸ್ವಲ್ಪ ಇನ್ನೂ, ಆದರೆ ನಾವು ಅದೇ ಹೊಂದಿವೆ
ಇಲ್ಲಿ ನೀಡಿ, ಅಲ್ಲಿ ಖಣಿಲು, ಚೆನ್ನಾಗಿ,

794
00:46:59,890 --> 00:47:03,790
ಸಾವಿರಾರು ಅಲ್ಲದಿದ್ದರೂ ಹತ್ತು ಸಾವಿರ
ಜನರು, ಹೊಂದಿವೆ, ಖಣಿಲು ನೋಡಿವೆ

795
00:47:03,790 --> 00:47:07,160
ಕೋಡ್ ಅದರ ಸಾಲುಗಳನ್ನು ನೋಡಿದ್ದಾರೆ ಮತ್ತು ಹೇಳಿದರು,
ಸರಿ, ಇಲ್ಲಿ ಕೆಟ್ಟ ಇಲ್ಲ.

796
00:47:07,160 --> 00:47:10,680
ನಿಸ್ಸಂಶಯವಾಗಿ, ಯಾರೂ ಮಾಡುತ್ತಿರುವ
ಈ ದುರುದ್ದೇಶಪೂರಿತ ಏನು.

797
00:47:10,680 --> 00:47:15,780
>> ಆದರೆ ಯಾವ ರೀತಿಯ, ಸ್ವತಃ ಖಣಿಲು
ನಾನು ಖಣಿಲು ಕಂಪೈಲ್ ವೇಳೆ?

798
00:47:15,780 --> 00:47:20,900
ನಾನು ಕೆಲವು ಕಂಪೈಲರ್ ವೇಳೆ
ಖಣಿಲು ಒಳಗೆ ಒಳಸೇರಿಸಿದನು ಖಣಿಲು ಸಂಗ್ರಹಿಸುತ್ತಾ

799
00:47:20,900 --> 00:47:25,610
ಎಂದು ಹೇಳುತ್ತದೆ ಈ ವಿಶೇಷ ಹ್ಯಾಕ್, ಸರಿ,
ನಾನು ಖಣಿಲು ಕಂಪೈಲ್ ಮಾಡುವಾಗ, ನಂತರ

800
00:47:25,610 --> 00:47:31,290
ಕಾರ್ಯಗತಗೊಳ್ಳುವ ನಾನು ವಿಶೇಷವಾಗಿ ತೋರಬೇಕು ಪಡೆಯುತ್ತೀರಿ
ಲಾಗಿನ್ ಪ್ರೋಗ್ರಾಂ ಮತ್ತು ಇನ್ಸರ್ಟ್ ಒಳಗೆ

801
00:47:31,290 --> 00:47:34,230
ಈ ಗುಪ್ತಪದವನ್ನು, ಸಮನಾಗಿರುತ್ತದೆ ಸಮನಾಗಿರುತ್ತದೆ
ಡೇವ್ ಸ್ಪೂರ್ತಿದಾಯಕ?

802
00:47:34,230 --> 00:47:37,990
ಆದ್ದರಿಂದ ನೆನಪಿಡಿ ನಿಮ್ಮ ಕಂಪೈಲರ್ ಸ್ವತಃ
ಹಂತದಲ್ಲಿ ಸಂಗ್ರಹಿಸಿದ ಅಗತ್ಯವಿದೆ.

803
00:47:37,990 --> 00:47:42,810
ಆದ್ದರಿಂದ ನೀವು ಖಣಿಲು ಕಂಪೈಲ್ ಆಯ್ಕೆ ವೇಳೆ
, ಸ್ವತಃ ನೀವು ನಂತರ, ದೋಷಪೂರಿತವಾಗಿದೆ ಜೊತೆ

804
00:47:42,810 --> 00:47:45,580
ಇಡೀ ಹಾಳಾದ ಎಂದು
ದಾರಿಯಲ್ಲಿ ಲೈನ್.

805
00:47:45,580 --> 00:47:49,630
>> ಇಲ್ಲಿ, ನಾವು ಕೆನ್ ಥಾಂಪ್ಸನ್ ಹೊಂದಿವೆ
ಮತ್ತು ಡೆನ್ನಿಸ್ ರಿಚಿ.

806
00:47:49,630 --> 00:47:53,780
ಆದ್ದರಿಂದ ಈ ಅಪ್ರತಿಮ ಫೋಟೋ ಆಗಿದೆ.

807
00:47:53,780 --> 00:47:55,470
ಡೆನ್ನಿಸ್ ರಿಚಿ ಬಲ ಹೊಂದಿದೆ.

808
00:47:55,470 --> 00:47:58,740
ಅವರು ಒಂದು ಪ್ರಮುಖ -

809
00:47:58,740 --> 00:48:03,640
ಅತ್ಯಧಿಕವಾಗಿ ಸಿ ಬರೆದರು ಆದ್ದರಿಂದ ನೀವು
ಈ ವರ್ಗ ಅವರಿಗೆ ಧನ್ಯವಾದ.

810
00:48:03,640 --> 00:48:04,840
ಕೆನ್ ಥಾಮ್ಸನ್ ಎಡ ಇಲ್ಲಿದೆ.

811
00:48:04,840 --> 00:48:07,780
ಅವುಗಳಲ್ಲಿ ಎರಡು ಮೂಲತಃ ಯುನಿಕ್ಸ್ ಬರೆದರು.

812
00:48:07,780 --> 00:48:10,140
ಅಲ್ಲದೆ, ಅವರು ಪ್ರಮುಖ ಕೊಡುಗೆ ಎಂದು
ಯುನಿಕ್ಸ್.

813
00:48:10,140 --> 00:48:11,310
ಕೆಲವು ಇತರರು ಇದ್ದರು.

814
00:48:11,310 --> 00:48:16,240
ಹಂತದಲ್ಲಿ ಆದ್ದರಿಂದ ಕೆನ್ ಥಾಂಪ್ಸನ್,,
ಅವರು ಟ್ಯೂರಿಂಗ್ ಪ್ರಶಸ್ತಿ.

815
00:48:16,240 --> 00:48:20,860
ಮತ್ತು ಟ್ಯೂರಿಂಗ್ ಪ್ರಶಸ್ತಿ, ನಾನು ಯಾವಾಗಲೂ ಕೇಳಿರುವ
ಈ ರೀತಿ ಉಲ್ಲೇಖ, ಅದು

816
00:48:20,860 --> 00:48:23,100
ಕಂಪ್ಯೂಟರ್ ವಿಜ್ಞಾನದ ನೊಬೆಲ್ ಪ್ರಶಸ್ತಿ.

817
00:48:23,100 --> 00:48:27,500
>> ಆದ್ದರಿಂದ ಟ್ಯೂರಿಂಗ್ ಪ್ರಶಸ್ತಿ, ಅವರು ಹೊಂದಿದೆ
ತಮ್ಮ ಸ್ವೀಕೃತಿ ಭಾಷಣದಲ್ಲಿ ನೀಡಿ.

818
00:48:27,500 --> 00:48:31,790
ಮತ್ತು ಅವರು ಈ ಅತ್ಯಂತ ಪ್ರಸಿದ್ಧ ಭಾಷಣ ನೀಡುತ್ತದೆ
ಈಗ, ನಂಬುವಂತೆ ರಿಫ್ಲೆಕ್ಷನ್ಸ್ ಎಂಬ

819
00:48:31,790 --> 00:48:35,620
ನಾವು ಲಿಂಕ್ ಇದು ಟ್ರಸ್ಟ್,
ಕೋರ್ಸ್ ವೆಬ್ಸೈಟ್ನಲ್ಲಿ.

820
00:48:35,620 --> 00:48:41,670
ಈ ಭಾಷಣದಲ್ಲಿ ಅವರು, ಸರಿ, ಹೇಳುತ್ತಾರೆ
ಆದ್ದರಿಂದ ನಾನು ಯುನಿಕ್ಸ್ ಬರೆದರು, ಮತ್ತು ಈಗ ಎಲ್ಲಾ

821
00:48:41,670 --> 00:48:43,320
ನೀವು ಜನರು ಯುನಿಕ್ಸ್ ಬಳಸುತ್ತಿದ್ದರೆ.

822
00:48:43,320 --> 00:48:46,960
ಈಗ, ಲಿನಕ್ಸ್ ಎಂದು ಇಂದು ನೆನಪು
ಯುನಿಕ್ಸ್ ನೇರ ವಂಶಸ್ಥರು.

823
00:48:46,960 --> 00:48:50,140
ಒಎಸ್ ಎಕ್ಸ್ ನೇರವಾಗಿ ಯುನಿಕ್ಸ್ ಬಳಸುತ್ತದೆ.

824
00:48:50,140 --> 00:48:53,810
ವಿಂಡೋಸ್ ತುಂಬಾ, ಆದರೆ ಬಹಳಷ್ಟು
ಕಲ್ಪನೆಗಳ ಯುನಿಕ್ಸ್ ತೆಗೆದುಕೊಳ್ಳಲಾಗಿದೆ.

825
00:48:53,810 --> 00:48:59,220
>> ಆದ್ದರಿಂದ ಅವರು, ಹಂತ ತಲುಪುತ್ತದೆ ಮತ್ತು ಹೇಳುತ್ತಾರೆ
ಸರಿ, ನಾನು ಯುನಿಕ್ಸ್ ಬರೆದರು.

826
00:48:59,220 --> 00:49:03,940
ಮತ್ತು ಕೇವಲ ನೀವು ಹುಡುಗರಿಗೆ ಗೊತ್ತಿಲ್ಲ, ನಾನು
ಪ್ರತಿ ಒಳಗೆ ಪ್ರವೇಶಿಸಲು ಸಾಧ್ಯವಾಗುತ್ತದೆ

827
00:49:03,940 --> 00:49:05,590
ನಿಮ್ಮ ಕಂಪ್ಯೂಟರ್ಗಳ ಒಂದೇ ಒಂದು.

828
00:49:05,590 --> 00:49:14,280
X-ನಾನು ಈ ವಿಶೇಷ ಒಂದು ಹಾಕಲು ಕಾರಣ
ಸಮನಾಗಿರುತ್ತದೆ, ಕೆನ್ ಥಾಮ್ಸನ್ ಆಕರ್ಷಕವಾಗಿದೆ ಸಮನಾಗಿರುತ್ತದೆ

829
00:49:14,280 --> 00:49:16,350
ನಂತರ ನಾನು ಲಾಗಿನ್ ಅವಕಾಶ ಬಾಗುತ್ತೇನೆ.

830
00:49:16,350 --> 00:49:18,370
ಆದ್ದರಿಂದ ಜನರು, ಹಾಗೂ, ಹಾಗೆ
how'd ನೀವು ಹಾಗೆ?

831
00:49:18,370 --> 00:49:21,090
ನಾವು ಲಾಗಿನ್ ಪ್ರೋಗ್ರಾಂ ನೋಡಿದ್ದಾರೆ
ಮತ್ತು ಇಲ್ಲ.

832
00:49:21,090 --> 00:49:24,700
ಅವರು, ನಾನು ಕಂಪೈಲರ್ ಬದಲಾಯಿಸಲಾಗಿತ್ತು, ಹೀಗಿದೆ
ಲಾಗಿನ್ ಕಾರ್ಯಕ್ರಮದಲ್ಲಿ ಪ್ರವೇಶಿಸಲು

833
00:49:24,700 --> 00:49:30,490
ಲಾಗಿನ್ ಪ್ರೋಗ್ರಾಂ ಈಗ ಹೊಂದಿರುತ್ತದೆ ಆದ್ದರಿಂದ
ಕ್ಷ ಕೆನ್ ಥಾಂಪ್ಸನ್ ಸಮ ಸಮ

834
00:49:30,490 --> 00:49:31,700
ಅತ್ಯುತ್ತಮವಾಗಿರುತ್ತದೆ.

835
00:49:31,700 --> 00:49:33,120
>> ಮತ್ತು ಸರಿಯಾಗಿ, ನಿಜವಾದ ಅಲ್ಲ, ಹೇಳುತ್ತಾರೆ.

836
00:49:33,120 --> 00:49:35,740
ನಾವು ಕಂಪೈಲರ್ ನೋಡುವ, ಮತ್ತು ನೀವು
ಕಂಪೈಲರ್ ಯಾವುದೇ ಸಾಲುಗಳನ್ನು ಹೊಂದಿಲ್ಲ

837
00:49:35,740 --> 00:49:36,400
ಹಾಗೆ ಕೋಡ್.

838
00:49:36,400 --> 00:49:40,540
ಅವರು ಸರಿ, ಹಾಗೆ, ಆದರೆ ನೀವು ಯಾವುವು
ಕಂಪೈಲರ್ ಕಂಪೈಲ್?

839
00:49:40,540 --> 00:49:44,810
ಮತ್ತು, ಮತ್ತು, ಹಾಗೆ, ಅವರು ಭಾವಿಸುತ್ತೇನೆ, ಮತ್ತು ಅವರು ಇಲ್ಲಿದೆ
ನಾನು ನೀವು ಕಂಪೈಲರ್ ನೀಡಿದ ಒಂದು ಮನುಷ್ಯ

840
00:49:44,810 --> 00:49:50,580
ನೀವು ಕಂಪೈಲರ್ ಕಂಪೈಲ್ ಬಳಸಿ, ಆದ್ದರಿಂದ ನೀವು
ನೀವು ಒಂದು ಕಂಪೈಲರ್ ಕಂಪೈಲ್ ಎಂದು

841
00:49:50,580 --> 00:49:56,390
ಸ್ವತಃ ದುರುದ್ದೇಶಪೂರಿತ, ಮತ್ತು ತಿನ್ನುವೆ
ಲಾಗಿನ್ ಪ್ರೋಗ್ರಾಂ ಮುರಿಯಲು.

842
00:49:56,390 --> 00:49:59,360
ಆದ್ದರಿಂದ ಮೂಲಭೂತವಾಗಿ, ಆ ಸಮಯದಲ್ಲಿ, ಇಲ್ಲ
ನೀವು ಮೂಲ ನೋಡಿದರೆ ದಾರಿಯೇ

843
00:49:59,360 --> 00:50:02,450
ಲಾಗಿನ್ ಕಾರ್ಯಕ್ರಮದ ಕೋಡ್
ತಪ್ಪು ಎಂಬುದನ್ನು.

844
00:50:02,450 --> 00:50:04,220
ನೀವು ನೋಡಲು ಸಾಧ್ಯವಾಗದಿದ್ದರೂ
ಕಂಪೈಲರ್ ಮೂಲ ಕೋಡ್

845
00:50:04,220 --> 00:50:06,790
ತಪ್ಪು ಎಂಬುದನ್ನು.

846
00:50:06,790 --> 00:50:11,940
>> ನೀವು ಯಂತ್ರ ನೋಡಬೇಕು ಎಂದು
ಕೋಡ್, ನಿಜವಾದ ಬೈನರಿ

847
00:50:11,940 --> 00:50:16,760
ಈ, ನಿರೀಕ್ಷಿಸಿ, ನೋಡಲು ಸಂಕಲನ ಕಂಪೈಲರ್
ಕೋಡ್ ಸಾಲುಗಳನ್ನು ಇಲ್ಲಿ ಇರುವಂತಿಲ್ಲ.

848
00:50:16,760 --> 00:50:22,130
ಆದರೆ ಕೆನ್ ಥಾಂಪ್ಸನ್ ಇದು ಒಂದು ಹೆಜ್ಜೆ ತೆಗೆದುಕೊಂಡಿತು
ಮತ್ತಷ್ಟು ಮತ್ತು ಹಾಗೆಯೇ ಇವೆ ಹೇಳಿದರು

849
00:50:22,130 --> 00:50:25,980
ಈ ವಿಶೇಷ ಕಾರ್ಯಕ್ರಮಗಳು ಎಂದು ವಾಸ್ತವವಾಗಿ
ನೀವು ಕಾರ್ಯಕ್ರಮಗಳ ಬೈನರಿ ಓದಲು ಸಹಾಯ,

850
00:50:25,980 --> 00:50:29,340
ಮತ್ತು ಆದ್ದರಿಂದ ಯಾರಾದರೂ ಆ ಪ್ರೋಗ್ರಾಂ ಬಳಸಲಾಗುತ್ತದೆ ವೇಳೆ
ಅವಳಿ ಓದಲು, ಅವರು ಈ ನೋಡಿದವು

851
00:50:29,340 --> 00:50:30,490
ಕೋಡ್ ಸಾಲುಗಳನ್ನು.

852
00:50:30,490 --> 00:50:34,020
ಅವರು ಎಲ್ಲಾ, ಹೇಳಲು ಆ ಕಾರ್ಯಕ್ರಮಗಳ ಬದಲಾಯಿಸಲಾಗಿತ್ತು
ಬಲ, ನೀವು ಹುಡುಕುತ್ತಿರುವ ವೇಳೆ

853
00:50:34,020 --> 00:50:38,460
ಕಂಪೈಲರ್, ಈ ನಿರ್ದಿಷ್ಟ ತೋರಿಸುವುದಿಲ್ಲ
ಅವಳಿ ಸೆಟ್.

854
00:50:38,460 --> 00:50:42,830
>> ಆದ್ದರಿಂದ ನೀವು ತೆಗೆದುಕೊಳ್ಳುವ ಅಗತ್ಯವಿಲ್ಲ ಎಂದು ಒಂದು ಹೆಜ್ಜೆ
ಮತ್ತಷ್ಟು ಮತ್ತು ಮೂಲತಃ, ಎಂದು ತೋರಿಸಬಹುದಿತ್ತು

855
00:50:42,830 --> 00:50:46,210
ಬಳಸು ತೆಗೆದ ಅನೇಕ ಹಂತಗಳಲ್ಲಿ
ಮತ್ತು ಕೆಲವು ಹಂತದಲ್ಲಿ, ಯಾವುದೇ ಒಂದು ವಾಸ್ತವವಾಗಿ

856
00:50:46,210 --> 00:50:47,990
ಪರೀಕ್ಷಿಸುವ ಏರಲಿದೆ.

857
00:50:47,990 --> 00:50:52,590
ಆದ್ದರಿಂದ ಕಥೆಯ ನೈತಿಕ ನೀವು ಇದ್ದೇವೆ
ಬರೆಯಲು ಹೋಗುತ್ತಿಲ್ಲ

858
00:50:52,590 --> 00:50:54,340
ಈ ವರ್ಗ ಖಣಿಲು.

859
00:50:54,340 --> 00:50:57,020
ನೀವು ಕ್ಲೈಂಬಿಂಗ್ ಬಳಸುತ್ತಿರುವ ನೀನು
ಈ ವರ್ಗದ ಬಹಳಷ್ಟು ಖಣಿಲು.

860
00:50:57,020 --> 00:51:00,490
ನಿಮಗೆ ಎಲ್ಲಾ, ಖಣಿಲು ಒಂದು ದೋಷಪೂರಿತವಾಗಿದೆ
ಪ್ರತಿ ಹಾಳುಮಾಡಿಕೊಳ್ಳುವುದು ಪ್ರೋಗ್ರಾಂ

861
00:51:00,490 --> 00:51:03,520
ಏಕ ಕಾರ್ಯಕ್ರಮ ಎಂದಾದರೂ ಮಾಡಿದ್ದೀರಿ.

862
00:51:03,520 --> 00:51:08,206
ಮತ್ತು ಬಹಳ ಅಶುಭ ನೀವು ಬಿಡಲು
ಬುಧವಾರ ನೀವು ನೋಡಬಹುದು, ಗಮನಿಸಿ.

863
00:51:08,206 --> 00:51:10,030
>> [ಚಪ್ಪಾಳೆಯನ್ನು]

864
00:51:10,030 --> 00:51:12,935
>> ಸ್ಪೀಕರ್ 2: ಮುಂದಿನ, CS50 ನಲ್ಲಿ.

865
00:51:12,935 --> 00:51:14,580
>> ಸ್ಪೀಕರ್ 3: ನೀವು ಹೇಳುವ ಧೈರ್ಯ ಇಲ್ಲ.

866
00:51:14,580 --> 00:51:15,930
ನೀವು ಇದನ್ನು ಮಾಡಬಹುದು.

867
00:51:15,930 --> 00:51:19,440
ನೀವು ಮೊದಲು ಇದನ್ನು ಬಂದಿದೆ, ನೀವು ಈ ಮಾಡಬಹುದು
ಇಂದು, ನೀವು ನಾಳೆ ಈ ಮಾಡಬಹುದು.

868
00:51:19,440 --> 00:51:20,930
ನೀವು ವರ್ಷಗಳ ಕಾಲ ಈ ರೀತಿ ಮಾಡಲಾಗಿದೆ.

869
00:51:20,930 --> 00:51:22,790
ಕೇವಲ ಅಲ್ಲಿ ಹೋಗಿ ಈ.

870
00:51:22,790 --> 00:51:24,310
ನೀವು ಇದನ್ನು ಮಾಡಬಹುದು.

871
00:51:24,310 --> 00:51:26,102
>> [ಸಂಗೀತ]