1
00:00:00,000 --> 00:00:02,000
[Powered by Google Translate] [Valgrind]

2
00:00:02,000 --> 00:00:05,000
[ನೇಟ್ Hardison, ಹಾರ್ವರ್ಡ್ ವಿಶ್ವವಿದ್ಯಾಲಯ]

3
00:00:05,000 --> 00:00:07,000
ಈ CS50.TV, CS50 ಹೊಂದಿದೆ]

4
00:00:07,000 --> 00:00:10,000
ಸಿ ಕಾರ್ಯಕ್ರಮಗಳಲ್ಲಿ ಅತ್ಯಂತ ಕಷ್ಟ ದೋಷಗಳನ್ನು ಕೆಲವು

5
00:00:10,000 --> 00:00:13,000
ಮೆಮೊರಿ ಕೆಟ್ಟ ನಿರ್ವಹಣೆ ಬರುತ್ತವೆ.

6
00:00:13,000 --> 00:00:15,000
ವಿಷಯಗಳನ್ನು ಅಪ್ ತಿರುಗಿಸಲು ವಿಧಾನಗಳಲ್ಲಿ ಒಂದು ಬೃಹತ್ ಸಂಖ್ಯೆಯ, ಇವೆ

7
00:00:15,000 --> 00:00:17,000
ಮೆಮೊರಿ ತಪ್ಪು ಪ್ರಮಾಣವನ್ನು ಹಂಚುತ್ತಾರೆ ಸೇರಿದಂತೆ,

8
00:00:17,000 --> 00:00:20,000
ಅಸ್ಥಿರ ಆರಂಭಿಸಲು ಮರೆತಿದ್ದ

9
00:00:20,000 --> 00:00:23,000
ಒಂದು ಬಫರ್ ಕೊನೆಯಲ್ಲಿ ಮೊದಲು ಅಥವಾ ನಂತರ ಬರೆಯುವ,

10
00:00:23,000 --> 00:00:25,000
ಮತ್ತು ಮೆಮೊರಿ ಬಹು ಬಾರಿ ಇರಿಸಿಕೊಳ್ಳಲು ಮುಕ್ತಗೊಳಿಸಿತು.

11
00:00:25,000 --> 00:00:28,000
ಲಕ್ಷಣಗಳು ಮರುಕಳಿಸುವ ಕುಸಿತಗೊಂಡಾಗ ಹಿಡಿದು

12
00:00:28,000 --> 00:00:30,000
ನಿಗೂಢವಾಗಿ ಬರೆಯಲ್ಪಟ್ಟಿತೆಂದರೆ ಮೌಲ್ಯಗಳಿಗೆ,

13
00:00:30,000 --> 00:00:34,000
ಸಾಮಾನ್ಯವಾಗಿ ದೂರದ ಮೂಲ ದೋಷ ತೆಗೆದುಹಾಕಲಾಗಿದೆ ಸ್ಥಳಗಳು ಮತ್ತು ಸಮಯದಲ್ಲಿ.

14
00:00:34,000 --> 00:00:37,000
ಆಧಾರವಾಗಿರುವ ಮೂಲ ಕಾರಣ ಮತ್ತೆ ಗಮನಿಸಿದ ಸಮಸ್ಯೆ ಟ್ರೇಸಿಂಗ್

15
00:00:37,000 --> 00:00:39,000
ಸವಾಲು ಮಾಡಬಹುದು,

16
00:00:39,000 --> 00:00:42,000
ಆದರೆ ಅದೃಷ್ಟವಶಾತ್ Valgrind ಎಂಬ ಉಪಯುಕ್ತ ಪ್ರೋಗ್ರಾಂ ಇಲ್ಲ

17
00:00:42,000 --> 00:00:44,000
ಎಂದು ಸಹಾಯ ಮಾಡಲು ಸಾಕಷ್ಟು ಮಾಡಬಹುದು.

18
00:00:44,000 --> 00:00:47,000
>> ನೀವು ಸಕ್ರಿಯಗೊಳಿಸಲು Valgrind ಅಡಿಯಲ್ಲಿ ಒಂದು ಪ್ರೋಗ್ರಾಂ

19
00:00:47,000 --> 00:00:50,000
ರಾಶಿ ಮೆಮೊರಿಯ ಹಂಚುವಿಕೆಯು ಮತ್ತು ಆಕ್ಸೆಸ್ಗಳ ವ್ಯಾಪಕ ತಪಾಸಣೆ.

20
00:00:50,000 --> 00:00:53,000
Valgrind ಸಮಸ್ಯೆ ಪತ್ತೆ ಮಾಡಿದಾಗ, ಅದನ್ನು ನೀವು ತಕ್ಷಣ ನೀಡುತ್ತದೆ

21
00:00:53,000 --> 00:00:56,000
ನಿಮಗೆ ಅನುಮತಿಸುತ್ತದೆ ನೇರ ಮಾಹಿತಿ

22
00:00:56,000 --> 00:00:58,000
ಸುಲಭವಾಗಿ ಹುಡುಕಲು ಮತ್ತು ತೊಂದರೆಯನ್ನು ಪರಿಹರಿಸಬಹುದು.

23
00:00:58,000 --> 00:01:01,000
, ಕಡಿಮೆ ಪ್ರಾಣಾಂತಿಕ ಸ್ಮರಣೆ ಸಮಸ್ಯೆಗಳ ಮೇಲೆ ವರದಿಗಳನ್ನು Valgrind

24
00:01:01,000 --> 00:01:04,000
ಮೆಮೊರಿ ಸೋರುವಿಕೆ ಮಾಹಿತಿ, ರಾಶಿ ಮೆಮೊರಿ ಹಂಚುತ್ತಾರೆ,

25
00:01:04,000 --> 00:01:07,000
ಮತ್ತು ಮುಕ್ತಗೊಳಿಸಲು ಮರೆತಿದ್ದ.

26
00:01:07,000 --> 00:01:10,000
ನಮ್ಮ ದೋಷಸೂಚಕವು ನಮ್ಮ ಕಂಪೈಲರ್, ಖಣಿಲು, GDB, ಲೈಕ್

27
00:01:10,000 --> 00:01:14,000
Valgrind ಉಚಿತ ಸಾಫ್ಟ್ವೇರ್ ಆಗಿದೆ, ಮತ್ತು ಇದು APPLIANCE ಸ್ಥಾಪಿಸಿದ.

28
00:01:14,000 --> 00:01:16,000
Valgrind, ನಿಮ್ಮ ಯುಗಳ ಕಾರ್ಯಗತಗೊಳ್ಳಬಹುದಾದ ಚಲಿಸುತ್ತದೆ

29
00:01:16,000 --> 00:01:20,000
ನಿಮ್ಮ. ಸಿ ಅಥವಾ. H ಮೂಲ ಕೋಡ್ ಕಡತಗಳನ್ನು,

30
00:01:20,000 --> 00:01:23,000
ಆದ್ದರಿಂದ ನಿಮ್ಮ ಕಾರ್ಯಕ್ರಮದ ಒಂದು ಅಪ್ ಆಧುನಿಕ ಪ್ರತಿಯನ್ನು ಸಂಕಲಿಸಿದ್ದಾನೆ ಮರೆಯಬೇಡಿ

31
00:01:23,000 --> 00:01:25,000
ಖಣಿಲು ಬಳಸಿ ಅಥವಾ ಮಾಡಿ.

32
00:01:25,000 --> 00:01:28,000
ನಂತರ, Valgrind ಅಡಿಯಲ್ಲಿ ನಿಮ್ಮ ಪ್ರೋಗ್ರಾಂ ಚಲಾಯಿತವಾಗುತ್ತಿದೆ ಮಾಡಬಹುದು

33
00:01:28,000 --> 00:01:32,000
ಕೇವಲ ಪದ Valgrind ಪ್ರಮಾಣಿತ ಪ್ರೋಗ್ರಾಂ ಆಜ್ಞೆಯನ್ನು prefixing ಎಂದು ಸರಳ,

34
00:01:32,000 --> 00:01:35,000
ಇದು Valgrind ಅಪ್ ಪ್ರಾರಂಭವಾಗುತ್ತದೆ ಮತ್ತು ಅದರ ಒಳಗೆ ಕಾರ್ಯಕ್ರಮವನ್ನು ನಡೆಸುತ್ತದೆ.

35
00:01:35,000 --> 00:01:38,000
ಪ್ರಾರಂಭವಾಗುತ್ತಿದ್ದಾಗ, Valgrind ಕೆಲವು ಸಂಕೀರ್ಣ ಮಾಡುತ್ತದೆ

36
00:01:38,000 --> 00:01:41,000
ಮೆಮೊರಿ ಚೆಕ್ಗಳಿಗೆ ಕಾರ್ಯಗತಗೊಳ್ಳುವ ಸಂರಚಿಸಲು jiggering,

37
00:01:41,000 --> 00:01:44,000
ಆದ್ದರಿಂದ ಅದನ್ನು ಪಡೆಯಲು ಮತ್ತು ಚಾಲನೆಯಲ್ಲಿರುವ ಒಂದು ಬಿಟ್ ತೆಗೆದುಕೊಳ್ಳಬಹುದು.

38
00:01:44,000 --> 00:01:48,000
ಪ್ರೋಗ್ರಾಂ ನಂತರ, ಹೆಚ್ಚು ನಿಧಾನವಾಗಿ, ಸಾಮಾನ್ಯವಾಗಿ ಕಾರ್ಯರೂಪಕ್ಕೆ ಇದು ಕಾಣಿಸುತ್ತದೆ

39
00:01:48,000 --> 00:01:52,000
ಮತ್ತು ಇದು ಮುಗಿದಾಗ, Valgrind ಅದರ ಮೆಮೊರಿ ಬಳಕೆಯ ಸಾರಾಂಶ ಮುದ್ರಿಸಲು ಕಾಣಿಸುತ್ತದೆ.

40
00:01:52,000 --> 00:01:58,000
ಎಲ್ಲಾ ಚೆನ್ನಾಗಿ ಹೋದರೆ, ಇದು ಸ್ವಲ್ಪ ನೋಡೋಣ:

41
00:01:58,000 --> 00:02:01,000
ಈ ಸಂದರ್ಭದಲ್ಲಿ,. / Clean_program

42
00:02:01,000 --> 00:02:04,000
ನಾನು ಚಲಾಯಿಸಲು ಬಯಸುವ ಪ್ರೋಗ್ರಾಂ ಮಾರ್ಗವನ್ನು ಹೊಂದಿದೆ.

43
00:02:04,000 --> 00:02:06,000
ಮತ್ತು ಇದನ್ನು ಯಾವುದೇ ವಾದಗಳು ತೆಗೆದುಕೊಳ್ಳಬಹುದು ಬೀರದಿದ್ದರೂ,

44
00:02:06,000 --> 00:02:09,000
ಅದನ್ನು ಮಾಡಿದರೆ ನಾನು ಎಂದಿನಂತೆ ಆಜ್ಞೆಯನ್ನು ಕೊನೆಗೆ ಕೇವಲ ಸ್ಪಂದನ ಅವರನ್ನು ಇದ್ದೆ.

45
00:02:09,000 --> 00:02:12,000
ಕ್ಲೀನ್ ಪ್ರೋಗ್ರಾಂ ನಾನು ರಚಿಸಿದ ಒಂದು ಸಿಲ್ಲಿ ಕಡಿಮೆ ಕಾರ್ಯಕ್ರಮ

46
00:02:12,000 --> 00:02:15,000
ಎಂದು, ರಾಶಿ ಮೇಲೆ ints ಒಂದು ಬ್ಲಾಕ್ ಜಾಗ ಗೊತ್ತುಪಡಿಸುತ್ತದೆ

47
00:02:15,000 --> 00:02:19,000
ಕೆಲವು ಮೌಲ್ಯಗಳು ಅವುಗಳಲ್ಲಿ ಒಳಗಿಟ್ಟು, ಮತ್ತು ಇಡೀ ಬ್ಲಾಕ್ ಬಿಡುಗಡೆ.

48
00:02:19,000 --> 00:02:23,000
ನೀವು ದೋಷಗಳನ್ನು ಮತ್ತು ಯಾವುದೇ ಸೋರಿಕೆಯನ್ನು ಯಾವುದೇ, ಚಿತ್ರೀಕರಣವನ್ನು ಏನನ್ನು ಹೊಂದಿದೆ.

49
00:02:23,000 --> 00:02:27,000
>> ಇನ್ನೊಂದು ಮುಖ್ಯವಾದ ಮೆಟ್ರಿಕ್ ನಿಯೋಜಿತವಾದ ಬೈಟ್ಗಳು ಒಟ್ಟು ಸಂಖ್ಯೆ.

50
00:02:27,000 --> 00:02:32,000
ನಿಮ್ಮ ಹಂಚಿಕೆಯು ಮೆಗಾಬೈಟ್ಗಳು ಅಥವಾ ಹೆಚ್ಚಿನ ರಲ್ಲಿ ಇದ್ದರೆ, ಪ್ರೋಗ್ರಾಂ ಅವಲಂಬಿಸಿ,

51
00:02:32,000 --> 00:02:34,000
ನೀವು ಬಹುಶಃ ಏನೋ ಮಾಡುತ್ತಿರುವುದು.

52
00:02:34,000 --> 00:02:37,000
ನೀವು ಅನಗತ್ಯವಾಗಿ ನಕಲುಗಳನ್ನು ಸಂಗ್ರಹಿಸುವ ಮಾಡಲಾಗುತ್ತದೆ?

53
00:02:37,000 --> 00:02:40,000
ಇದು ಸ್ಟಾಕ್ ಬಳಸಲು ಉತ್ತಮ ಎಂದು ನೀವು, ಶೇಖರಣೆ ರಾಶಿ ಬಳಸುತ್ತಿದ್ದರೆ?

54
00:02:40,000 --> 00:02:43,000
ಆದ್ದರಿಂದ, ಮೆಮೊರಿ ದೋಷಗಳನ್ನು ನಿಜವಾದ ದುಷ್ಟ ಮಾಡಬಹುದು.

55
00:02:43,000 --> 00:02:46,000
ಹೆಚ್ಚು ಬಹಿರಂಗವಾದ ಬಿಡಿಗಳು, ಅದ್ಭುತ ಕುಸಿತಗೊಂಡಾಗ ಕಾರಣವಾಗಬಹುದು

56
00:02:46,000 --> 00:02:49,000
ಆದರೆ ಅದು ಇನ್ನೂ ಗುರುತಿಸಲು ಕಷ್ಟ

57
00:02:49,000 --> 00:02:51,000
ಎಂಬುದನ್ನು ಕುಸಿತ ಕಾರಣವಾಯಿತು.

58
00:02:51,000 --> 00:02:54,000
ಒಂದು ಮೆಮೊರಿ ದೋಷ ಹೆಚ್ಚು ದ್ರೋಹದಿಂದ, ಒಂದು ಪ್ರೋಗ್ರಾಂ

59
00:02:54,000 --> 00:02:56,000
ಇನ್ನೂ ಸರಿಯಾಗಿ ಸಂಕಲಿಸಬಲ್ಲ

60
00:02:56,000 --> 00:02:58,000
ಮತ್ತು ಇನ್ನೂ ಸರಿಯಾಗಿ ಕೆಲಸ ಕಾಣಿಸಬಹುದು

61
00:02:58,000 --> 00:03:01,000
ನೀವು ಸಮಯ ಅದೃಷ್ಟ ಪಡೆಯಲು ನಿರ್ವಹಿಸುತ್ತಿದ್ದ ಕಾರಣ.

62
00:03:01,000 --> 00:03:04,000
ಹಲವಾರು ನಂತರ "ಯಶಸ್ವೀ ಫಲಿತಾಂಶಗಳು"

63
00:03:04,000 --> 00:03:07,000
ನೀವು, ಘರ್ಷಣೆಯ ಕಂಪ್ಯೂಟರ್ ಒಂದು ಚಪ್ಪಟೆ ಮೀನು ಎಂದು ಭಾವಿಸುತ್ತೇನೆ ಇರಬಹುದು

64
00:03:07,000 --> 00:03:10,000
ಆದರೆ ಕಂಪ್ಯೂಟರ್ ತಪ್ಪು ಎಂದಿಗೂ.

65
00:03:10,000 --> 00:03:13,000
>> Valgrind ರನ್ನಿಂಗ್ ನೀವು ಕಾಣುವ ಮೆಮೊರಿ ದೋಷಗಳು ಕಾರಣ ಕೆಳಗೆ ಟ್ರ್ಯಾಕ್ ಸಹಾಯ ಮಾಡಬಹುದು

66
00:03:13,000 --> 00:03:18,000
ಹಾಗೆಯೇ ದೋಷಗಳನ್ನು ಸುಪ್ತ ಹೇಗೆ ಎಂದು ನೀವು ಇನ್ನೂ ಬಗ್ಗೆ ಗೊತ್ತಿಲ್ಲ.

67
00:03:18,000 --> 00:03:22,000
Valgrind ಸಮಸ್ಯೆ ಪತ್ತೆ ಪ್ರತಿ ಬಾರಿ, ಇದು ವೀಕ್ಷಿಸಿದ ಬಗ್ಗೆ ಮಾಹಿತಿಯನ್ನು ತೋರಿಸುತ್ತದೆ.

68
00:03:22,000 --> 00:03:24,000
ಪ್ರತಿ ಐಟಂ ತಕ್ಕಮಟ್ಟಿಗೆ ಸಂಕ್ಷಿಪ್ತ ಹೊಂದಿದೆ -

69
00:03:24,000 --> 00:03:27,000
ಆಕ್ಷೇಪಾರ್ಹ ಬೋಧನೆಯ ಮೂಲ ಲೈನ್, ಏನು ಸಮಸ್ಯೆ,

70
00:03:27,000 --> 00:03:30,000
ಒಳಗೊಂಡಿತ್ತು ಮೆಮೊರಿ ಬಗ್ಗೆ ಮತ್ತು ಸ್ವಲ್ಪ ಮಾಹಿತಿ -

71
00:03:30,000 --> 00:03:34,000
ಆದರೆ ಅದು ಸರಿಯಾದ ಸ್ಥಳಕ್ಕೆ ನಿಮ್ಮ ಗಮನವನ್ನು ನಿರ್ದೇಶಿಸುವ ಸಾಕಷ್ಟು ಮಾಹಿತಿ ಇಲ್ಲಿದೆ.

72
00:03:34,000 --> 00:03:37,000
ಇಲ್ಲಿ ಒಂದು ದೋಷಯುಕ್ತ ಕಾರ್ಯಕ್ರಮದಲ್ಲಿ ಚಾಲನೆಯಲ್ಲಿರುವ Valgrind ಉದಾಹರಣೆ

73
00:03:37,000 --> 00:03:40,000
ಆ ರಾಶಿ ಮೆಮೊರಿ ಅಮಾನ್ಯ ಓದಲು ಮಾಡುತ್ತದೆ.

74
00:03:40,000 --> 00:03:49,000
ನಾವು ಸಂಕಲನ ಯಾವುದೇ ದೋಷಗಳು ಅಥವಾ ಎಚ್ಚರಿಕೆಗಳನ್ನು ನೋಡಿ.

75
00:03:49,000 --> 00:03:53,000
UH-OH, ದೋಷ ಸಾರಾಂಶವನ್ನು ಎರಡು ದೋಷಗಳು ಇವೆ ಹೇಳುತ್ತಾರೆ -

76
00:03:53,000 --> 00:03:56,000
ಗಾತ್ರ 4 ಎರಡು ಅಮಾನ್ಯವಾಗಿದೆ ಬರಹಗಳು - ಬೈಟ್ಗಳು, ಎಂದು.

77
00:03:56,000 --> 00:04:01,000
ಎರಡೂ ಕೆಟ್ಟ, invalid_read.c ಮುಖ್ಯ ಕಾರ್ಯ ನಡೆಯಿತು ಓದುತ್ತದೆ

78
00:04:01,000 --> 00:04:04,000
ಸಾಲಿನ 16 ಮತ್ತು ಸಾಲು 19 ರಂದು ಎರಡನೇ ಪ್ರಥಮ.

79
00:04:04,000 --> 00:04:06,000
ನ ಕೋಡ್ ನೋಡೋಣ.

80
00:04:06,000 --> 00:04:11,000
Printf ನಮ್ಮ ಮೆಮೊರಿ ಬ್ಲಾಕ್ ಕೊನೆಯಲ್ಲಿ ಕಳೆದ ಒಂದು ಇಂಟ್ ಓದಲು ಪ್ರಯತ್ನಿಸುತ್ತದೆ ಮೊದಲ ಕರೆ ತೋರುತ್ತಿದೆ.

81
00:04:11,000 --> 00:04:13,000
ನಾವು Valgrind ನ ಉತ್ಪಾದನೆಯಲ್ಲಿ ಹಿಂತಿರುಗಿ ನೋಡಲು, ವೇಳೆ

82
00:04:13,000 --> 00:04:16,000
ನಾವು Valgrind ಖಂಡಿತವಾಗಿಯೂ ನಮಗೆ ಹೇಳಿದ ನೋಡಿ.

83
00:04:16,000 --> 00:04:19,000
ನಾವು ಓದಲು ಪ್ರಯತ್ನಿಸುತ್ತಿರುವ ವಿಳಾಸಕ್ಕೆ 0 ಬೈಟ್ಗಳು ಆರಂಭವಾಗುತ್ತದೆ

84
00:04:19,000 --> 00:04:22,000
- ಗಾತ್ರವನ್ನು 16 ಬೈಟ್ಗಳು ಬ್ಲಾಕ್ ಕೊನೆಯಲ್ಲಿ ಹಿಂದೆ

85
00:04:22,000 --> 00:04:25,000
ನಾವು ವಿಂಗಡಿಸುವ ನಾಲ್ಕು 32-ಬಿಟ್ ints.

86
00:04:25,000 --> 00:04:29,000
ಅಂದರೆ, ನಾವು ಓದಲು ಪ್ರಯತ್ನಿಸುತ್ತಿದ್ದ ವಿಳಾಸಕ್ಕೆ, ಬಲ ನಮ್ಮ ಬ್ಲಾಕ್ ಕೊನೆಯಲ್ಲಿ ಪ್ರಾರಂಭವಾಗುತ್ತದೆ

87
00:04:29,000 --> 00:04:32,000
ನಮ್ಮ ಕೆಟ್ಟ printf ಕರೆ ಕಾಣುವ ಕೇವಲ ಮಾಹಿತಿ.

88
00:04:32,000 --> 00:04:36,000
ಈಗ ಅಮಾನ್ಯವಾಗಿದೆ ಬರಹಗಳು, ಒಂದು ಒಪ್ಪಂದದ ದೊಡ್ಡ ಹೋಲುವಂತಿದ್ದು ಇರಬಹುದು

89
00:04:36,000 --> 00:04:39,000
ಆದರೆ ನಿಮ್ಮ ಪ್ರೋಗ್ರಾಂ ಹರಿವನ್ನು ನಿಯಂತ್ರಿಸಲು ಡೇಟಾವನ್ನು ಬಳಸುತ್ತಿದ್ದರೆ -

90
00:04:39,000 --> 00:04:42,000
ಉದಾಹರಣೆಗೆ, ಒಂದು ಭಾಗವಾಗಿ ವೇಳೆ ಹೇಳಿಕೆ ಅಥವಾ ಲೂಪ್ -

91
00:04:42,000 --> 00:04:45,000
ನಂತರ ವಿಷಯಗಳನ್ನು ಮೌನವಾಗಿ ಕೆಟ್ಟ ಹೋಗಬಹುದು.

92
00:04:45,000 --> 00:04:47,000
ನಾನು invalid_read ಪ್ರೊಗ್ರಾಮನ್ನು ಹೇಗೆ ವೀಕ್ಷಿಸಿ

93
00:04:47,000 --> 00:04:50,000
ಮತ್ತು ಸಾಮಾನ್ಯ ಬಗ್ಗೆ ಔಟ್ ಸಂಭವಿಸುತ್ತದೆ.

94
00:04:50,000 --> 00:04:52,000
ಸ್ಕೇರಿ, HUH?

95
00:04:52,000 --> 00:04:56,000
>> ಈಗ, ಅವರ ನಿಮ್ಮ ಕೋಡ್ ಎದುರಿಸಬೇಕಾಗುತ್ತದೆ ದೋಷಗಳನ್ನು ಕೆಲವು ರೀತಿಯ ನೋಡೋಣ

96
00:04:56,000 --> 00:04:59,000
ಮತ್ತು ನಾವು ಅವರನ್ನು ಪತ್ತೆ ಹೇಗೆ Valgrind ನೋಡುತ್ತಾರೆ.

97
00:04:59,000 --> 00:05:01,000
ನಾವು, ಒಂದು invalid_read ಉದಾಹರಣೆ ಕಂಡಿತು

98
00:05:01,000 --> 00:05:04,000
ಆದ್ದರಿಂದ ಈಗ ಒಂದು invalid_write ಔಟ್ ಪರೀಕ್ಷಿಸೋಣ.

99
00:05:04,000 --> 00:05:09,000
ಮತ್ತೆ, ಸಂಕಲನ ಯಾವುದೇ ದೋಷಗಳು ಅಥವಾ ಎಚ್ಚರಿಕೆಗಳನ್ನು.

100
00:05:09,000 --> 00:05:12,000
ಸರಿ, Valgrind ಈ ಕಾರ್ಯಕ್ರಮದಲ್ಲಿ ಎರಡು ದೋಷಗಳು ಇವೆ ಹೇಳುತ್ತಾರೆ -

101
00:05:12,000 --> 00:05:15,000
ಮತ್ತು invalid_write ಮತ್ತು invalid_read.

102
00:05:15,000 --> 00:05:18,000
ನ ಈ ಕೋಡ್ ಪರಿಶೀಲಿಸಿ ನೋಡೋಣ.

103
00:05:18,000 --> 00:05:21,000
ನಾವು ಶ್ರೇಷ್ಠ strlen ಜೊತೆಗೆ ಒಂದು ದೋಷವನ್ನು ಒಂದು ಉದಾಹರಣೆಗೆ ಪಡೆದಿರುವಿರಿ ತೋರುತ್ತಿದೆ.

104
00:05:21,000 --> 00:05:24,000
ಕೋಡ್ malloc ಜಾಗವನ್ನು ಹೆಚ್ಚುವರಿ ಬೈಟ್ ಮಾಡುವುದಿಲ್ಲ

105
00:05:24,000 --> 00:05:26,000
/ 0 ಪಾತ್ರಕ್ಕೆ,

106
00:05:26,000 --> 00:05:30,000
ಆದ್ದರಿಂದ Str ಪ್ರತಿಯನ್ನು ssubstrlen ಇದನ್ನು ಬರೆಯಲು ಹೋದಾಗ "cs50 ಕಲ್ಲುಗಳು!"

107
00:05:30,000 --> 00:05:33,000
ನಮ್ಮ ಬ್ಲಾಕ್ ಕೊನೆಯಲ್ಲಿ ಕಳೆದ 1 ಬೈಟ್ ಬರೆದರು.

108
00:05:33,000 --> 00:05:36,000
ನಾವು printf ನಮ್ಮ ಕರೆ ಮಾಡಿದಾಗ invalid_read ಬರುತ್ತದೆ.

109
00:05:36,000 --> 00:05:40,000
ಅದನ್ನು / 0 ಪಾತ್ರ ಓದುತ್ತಿದಂತೆ printf ಅಮಾನ್ಯವಾಗಿದೆ ಮೆಮೊರಿ ಓದುವ ಅಂತ್ಯಗೊಳ್ಳುತ್ತದೆ

110
00:05:40,000 --> 00:05:43,000
ಈ ಇ ಸ್ಟ್ರಿಂಗ್ ಕೊನೆಯಲ್ಲಿ ಕಾಣುತ್ತದೆ ಎಂದು ಮುದ್ರಣ ಇಲ್ಲಿದೆ.

111
00:05:43,000 --> 00:05:45,000
ಆದರೆ ಈ ಯಾವುದೇ Valgrind ತಪ್ಪಿಸಿಕೊಂಡ.

112
00:05:45,000 --> 00:05:48,000
ನಾವು Str ಪ್ರತಿಯನ್ನು ಭಾಗವಾಗಿ ಇದು invalid_write ಬಂದಿತ್ತು ನೋಡಿ

113
00:05:48,000 --> 00:05:51,000
ಮುಖ್ಯ ಸಾಲಿನ 11 ರಂದು, ಮತ್ತು invalid_read printf ಭಾಗವಾಗಿದೆ.

114
00:05:51,000 --> 00:05:54,000
Valgrind, ರಾಕ್.

115
00:05:54,000 --> 00:05:57,000
ಮತ್ತೆ, ಈ ದೊಡ್ಡ ಒಪ್ಪಂದದ ಹೋಲುವಂತಿದ್ದು ಇರಬಹುದು.

116
00:05:57,000 --> 00:06:00,000
ನಾವು Valgrind ಹೊರಗೆ ಮೇಲೆ ಮತ್ತು ಈ ಪ್ರೋಗ್ರಾಂ ಅನ್ನು ಚಲಾಯಿಸಬಹುದು

117
00:06:00,000 --> 00:06:03,000
ಮತ್ತು ಯಾವುದೇ ದೋಷ ಲಕ್ಷಣಗಳು ನೋಡುವುದಿಲ್ಲ.

118
00:06:03,000 --> 00:06:06,000
>> ಆದರೆ, ನೋಡಿ ಈ ಒಂದು ಸ್ವಲ್ಪ ಬದಲಾವಣೆ ನೋಡೋಣ

119
00:06:06,000 --> 00:06:09,000
ಹೇಗೆ ವಿಷಯಗಳನ್ನು ನಿಜವಾಗಿಯೂ ಕೆಟ್ಟ ಪಡೆಯಬಹುದು.

120
00:06:09,000 --> 00:06:14,000
ಆದ್ದರಿಂದ, ನೀಡಲಾಯಿತು, ಈ ಕೋಡ್ ಕೇವಲ ಒಂದು ಬಿಟ್ ಹೆಚ್ಚು ವಿಷಯಗಳನ್ನು ದುರುಪಯೋಗ ಮಾಡಲಾಗಿದೆ.

121
00:06:14,000 --> 00:06:17,000
ನಾವು ಕೇವಲ ಎರಡು ತಂತಿಗಳು ಫಾರ್ ರಾಶಿ ಜಾಗವನ್ನು ಮೀಸಲಿಡಲಾಗಿತ್ತು ನೀವು

122
00:06:17,000 --> 00:06:19,000
cs50 ಬಂಡೆಗಳ ಉದ್ದ,

123
00:06:19,000 --> 00:06:22,000
ಈ ಸಮಯದಲ್ಲಿ, / 0 ಪಾತ್ರ ವಿಚಾರಿಸಿದಾಗ.

124
00:06:22,000 --> 00:06:25,000
ಆದರೆ ಆಗ ನಾವು ಮೆಮೊರಿ ಬ್ಲಾಕ್ ಒಂದು ಸೂಪರ್ ಉದ್ದ ಸಾಲಿನಲ್ಲಿ ಎಸೆಯಲು

125
00:06:25,000 --> 00:06:27,000
ಎಂದು ಎಸ್ ತೋರುತ್ತಿರುವಂತೆ ಇದೆ.

126
00:06:27,000 --> 00:06:30,000
ಏನು ಪರಿಣಾಮ ಮೆಮೊರಿ ಬ್ಲಾಕ್ ಮೇಲೆ ಕಾಣಿಸುತ್ತದೆ ಎಂದು ಟಿ ಅಂಕಗಳನ್ನು?

127
00:06:30,000 --> 00:06:34,000
ಅಲ್ಲದೆ, ಒಂದು ವೇಳೆ S ಕೇವಲ ಪಕ್ಕದ ಎಂದು ಸ್ಮರಣೆಗೆ ಟಿ ಅಂಕಗಳನ್ನು,

128
00:06:34,000 --> 00:06:37,000
ಅದನ್ನು ನಂತರ ಬರುವ,

129
00:06:37,000 --> 00:06:39,000
ನಂತರ ನಾವು ಟಿ ಭಾಗವಾಗಿ ಮೇಲೆ ಬರೆದಿದ್ದಾರೆ ಇರಬಹುದು

130
00:06:39,000 --> 00:06:41,000
ನ ಈ ಕೋಡ್ ಔಟ್ ಲೆಟ್.

131
00:06:41,000 --> 00:06:43,000
ಏನಾಯಿತು ನೋಡಿ.

132
00:06:43,000 --> 00:06:47,000
ನಮ್ಮ ರಾಶಿ ಬ್ಲಾಕ್ಗಳನ್ನು ಎರಡೂ ಸಂಗ್ರಹಿಸಲಾಗಿದೆ ತಂತಿಗಳನ್ನು ಸರಿಯಾಗಿ ಔಟ್ ಮುದ್ರಿಸಿದ್ದೇನೆ ಕಂಡುಬಂದಿತು.

133
00:06:47,000 --> 00:06:49,000
ನಥಿಂಗ್ ಅಟ್ ಆಲ್ ತಪ್ಪು ತೋರುತ್ತದೆ.

134
00:06:49,000 --> 00:06:52,000
ಆದರೆ, ನಮ್ಮ ಕೋಡ್ ಮರಳಿ ಹೋಗಿ ಅವಕಾಶ ಮತ್ತು

135
00:06:52,000 --> 00:06:55,000
ನಾವು cs50 ಬಂಡೆಗಳು ನಕಲಿಸಿ ಅಲ್ಲಿ ಲೈನ್ ಔಟ್ ಕಾಮೆಂಟ್

136
00:06:55,000 --> 00:06:59,000
ಎರಡನೇ ಮೆಮೊರಿ ಬ್ಲಾಕ್ ಆಗಿ, T ಮೂಲಕ ತೋರಿಸಿದರು.

137
00:06:59,000 --> 00:07:02,000
ಈಗ, ನಾವು ಈ ಕೋಡ್ ರನ್ ನಾವು ಮಾಡಬೇಕಾದುದು

138
00:07:02,000 --> 00:07:06,000
ಕೇವಲ ಮೊದಲ ಮೆಮೊರಿ ಬ್ಲಾಕ್ ವಿಷಯಗಳನ್ನು ಮುದ್ರಿಸುತ್ತದೆ ನೋಡಿ.

139
00:07:06,000 --> 00:07:09,000
ಓಹ್, ನಾವು Str ಪ್ರತಿಯನ್ನು ಮಾಡಲಿಲ್ಲ ಸಹ

140
00:07:09,000 --> 00:07:12,000
ಎರಡನೇ ರಾಶಿ ಬ್ಲಾಕ್ ಯಾವುದೇ ಪಾತ್ರಗಳು, ಒಂದು, ಟಿ ಮೂಲಕ ತೋರಿಸಿದರು

141
00:07:12,000 --> 00:07:15,000
ನಾವು ಒಂದು ಪ್ರಿಂಟ್ ಔಟ್.

142
00:07:15,000 --> 00:07:18,000
ವಾಸ್ತವವಾಗಿ, ಸ್ಟ್ರಿಂಗ್ ನಮ್ಮ ಮೊದಲ ಬ್ಲಾಕ್ ತುಂಬಿ

143
00:07:18,000 --> 00:07:21,000
ಮೊದಲ ಬ್ಲಾಕ್ ಮತ್ತು ಎರಡನೇ ಬ್ಲಾಕ್ ಆಗಿ, ಸದೆಬಡಿದು

144
00:07:21,000 --> 00:07:23,000
ಎಲ್ಲವೂ ಸಾಮಾನ್ಯ ಕಾಣುವಂತೆ ಮಾಡುತ್ತಾನೆ.

145
00:07:23,000 --> 00:07:26,000
Valgrind, ಆದರೂ, ನಮಗೆ ನಿಜವಾದ ಕಥೆಯನ್ನು ಹೇಳುತ್ತದೆ.

146
00:07:26,000 --> 00:07:28,000
ನಾವು ಹೋಗಿ.

147
00:07:28,000 --> 00:07:32,000
ಆ ಅಮಾನ್ಯವಾಗಿದೆ ಎಲ್ಲಾ ಓದುತ್ತದೆ ಮತ್ತು ಬರೆಯುತ್ತಾರೆ.

148
00:07:32,000 --> 00:07:36,000
>> ನ ದೋಷ ಮತ್ತೊಂದು ವಿಧದ ಒಂದು ಉದಾಹರಣೆಯನ್ನು ನೋಡೋಣ.

149
00:07:36,000 --> 00:07:39,000
ಇಲ್ಲಿ ನಾವು ಬದಲಿಗೆ ದುರದೃಷ್ಟಕರ ಏನನ್ನಾದರೂ ಮಾಡಬೇಕು.

150
00:07:39,000 --> 00:07:41,000
ನಾವು, ರಾಶಿ ಮೇಲೆ ಇಂಟ್ ಜಾಗವನ್ನು ಆಕ್ರಮಿಸಲು

151
00:07:41,000 --> 00:07:45,000
ಪು - - ಆ ಜಾಗವನ್ನು ತೋರಿಸಲು ಮತ್ತು ನಾವು ಒಂದು ಇಂಟ್ ಪಾಯಿಂಟರ್ ಆರಂಭಿಸಲು.

152
00:07:45,000 --> 00:07:48,000
ಆದರೆ, ನಮ್ಮ ಪಾಯಿಂಟರ್ ಆರಂಭಿಸಲಾಗಿಲ್ಲ ಆದರೆ,

153
00:07:48,000 --> 00:07:52,000
ಇದು ಸೂಚಿಸುವ ಪ್ರಕಾರ ಅಕ್ಷಾಂಶ ಕೇವಲ ರಾಶಿ ಆ ಭಾಗದಲ್ಲಿ ಯಾವುದೇ ಜಂಕ್ ಯೋಗ್ಯವಾಗಿರುತ್ತದೆ.

154
00:07:52,000 --> 00:07:55,000
ನಾವು ಇಂಟ್ ನಾನು ಒಳಗೆ ದತ್ತಾಂಶವನ್ನು ಲೋಡ್ ಮಾಡುವಾಗ,

155
00:07:55,000 --> 00:07:57,000
ನಾವು ತಾಂತ್ರಿಕವಾಗಿ, ನಾನು ಆರಂಭಿಸಲು

156
00:07:57,000 --> 00:08:00,000
ಆದರೆ ನಾವು ಜಂಕ್ ಡೇಟಾವನ್ನು ಹೊಂದಿರುವ ಹಾಗೆ.

157
00:08:00,000 --> 00:08:03,000
ಕರೆ ಒಂದು HANDY ಡೀಬಗ್ ಮ್ಯಾಕ್ರೋ ಇದು, ಪ್ರತಿಪಾದಿಸಲು

158
00:08:03,000 --> 00:08:06,000
ಯೋಗ್ಯವಾಗಿ ಎಂಬ ಸಮರ್ಥನೆ ಗ್ರಂಥಾಲಯದ ವ್ಯಾಖ್ಯಾನಿಸಲಾಗಿದೆ,

159
00:08:06,000 --> 00:08:09,000
ಸ್ಥಗಿತಗೊಳಿಸು ತನ್ನ ಪರೀಕ್ಷೆಯ ಸ್ಥಿತಿಯನ್ನು ವಿಫಲವಾದಲ್ಲಿ ಪ್ರೋಗ್ರಾಂ ತಿನ್ನುವೆ.

160
00:08:09,000 --> 00:08:11,000
ಇ 0 ಇದ್ದಲ್ಲಿ ಅಂದರೆ,.

161
00:08:11,000 --> 00:08:14,000
ರಾಶಿ ಸ್ಪೇಸ್ ರಲ್ಲಿ ಎಂಬುದನ್ನು ಅವಲಂಬಿಸಿ, p ತೋರಿಸಿದರು

162
00:08:14,000 --> 00:08:18,000
ಈ ಪ್ರೋಗ್ರಾಂ ಕೆಲವೊಮ್ಮೆ ಕೆಲಸ ಮತ್ತು ಇತರ ಸಮಯದಲ್ಲಿ ವಿಫಲಗೊಳ್ಳಬಹುದು.

163
00:08:18,000 --> 00:08:20,000
ಇದು ಕೆಲಸ ವೇಳೆ, ನಾವು ಅದೃಷ್ಟ ಬರುತ್ತಿದೆ.

164
00:08:20,000 --> 00:08:24,000
ಕಂಪೈಲರ್ ಈ ದೋಷ ಕ್ಯಾಚ್, ಆದರೆ ಖಚಿತವಾಗಿ ವಿಲ್ Valgrind ಮಾಡುವುದಿಲ್ಲ.

165
00:08:24,000 --> 00:08:28,000
ಅಲ್ಲಿ ನಾವು ಜಂಕ್ ಅಕ್ಷಾಂಶ ನಮ್ಮ ಬಳಕೆಯ ಭುಗಿಲೆದ್ದ ದೋಷವನ್ನು ನೋಡುವುದಿಲ್ಲ.

166
00:08:28,000 --> 00:08:32,000
>> ನೀವು ರಾಶಿ ಮೆಮೊರಿ ನಿಯೋಜಿಸಿ ಆದರೆ deallocate ಅಥವಾ ಕ್ಲಿಕ್ ಮಾಡದೇ ಇದ್ದಾಗ,

167
00:08:32,000 --> 00:08:34,000
ಒಂದು ಸೋರಿಕೆ ಎನ್ನುತ್ತಾರೆ.

168
00:08:34,000 --> 00:08:37,000
ನಿರ್ಗಮಿಸುತ್ತದೆ ಓಡುತ್ತದೆ ಮತ್ತು ತಕ್ಷಣ ಒಂದು ಸಣ್ಣ, ಅಲ್ಪಾವಧಿಯ ಕಾರ್ಯಕ್ರಮ,

169
00:08:37,000 --> 00:08:39,000
ಸೋರಿಕೆಯನ್ನು ತಕ್ಕಮಟ್ಟಿಗೆ ನಿರುಪದ್ರವಿಗಳು,

170
00:08:39,000 --> 00:08:42,000
ಆದರೆ ದೊಡ್ಡ ಗಾತ್ರ ಮತ್ತು / ಅಥವಾ ಬಾಳಿಕೆಗೆ ಯೋಜನೆಗೆ,

171
00:08:42,000 --> 00:08:46,000
ಸಣ್ಣ ಸೋರಿಕೆ ಪ್ರಮುಖ ಏನೋ ಆಗಿ ಸಂಯೋಗಗೊಂಡು.

172
00:08:46,000 --> 00:08:49,000
CS50, ನೀವು ನಿರೀಕ್ಷೆ ಇಲ್ಲ

173
00:08:49,000 --> 00:08:51,000
ನೀವು ನಿಯೋಜಿಸಿ ಎಂದು ರಾಶಿ ಮೆಮೊರಿ ಎಲ್ಲಾ ಮುಕ್ತಗೊಳಿಸಿದ ಆರೈಕೆಯನ್ನು,

174
00:08:51,000 --> 00:08:54,000
ನೀವು ಕೈಯಾರೆ ಪ್ರಕ್ರಿಯೆಯನ್ನು ಸರಿಯಾಗಿ ನಿರ್ವಹಿಸಲು ಕೌಶಲಗಳನ್ನು ನಿರ್ಮಿಸಲು ಬಯಸುವ ರಿಂದ

175
00:08:54,000 --> 00:08:56,000
ಸಿ ಅಗತ್ಯವಿರುವ

176
00:08:56,000 --> 00:08:59,000
ಹಾಗೆ, ನಿಮ್ಮ ಪ್ರೋಗ್ರಾಂ ನಿಖರ ಇರಬೇಕು

177
00:08:59,000 --> 00:09:03,000
malloc ಮತ್ತು ಉಚಿತ ಕರೆಗಳನ್ನು ನಡುವೆ ಒಂದಕ್ಕೊಂದು ಪತ್ರವ್ಯವಹಾರದ.

178
00:09:03,000 --> 00:09:06,000
ಅದೃಷ್ಟವಶಾತ್, Valgrind ತುಂಬಾ ಮೆಮೊರಿ ಸೋರುವಿಕೆ ನಿಮಗೆ ಸಹಾಯ ಮಾಡಬಹುದು.

179
00:09:06,000 --> 00:09:09,000
ಇಲ್ಲಿ leak.c ಎಂಬ ಸೋರುವ ಪ್ರೋಗ್ರಾಂ ಎಂದು ಗೊತ್ತುಪಡಿಸುತ್ತದೆ

180
00:09:09,000 --> 00:09:13,000
ರಾಶಿ ಮೇಲೆ ಸ್ಥಳವನ್ನು ಅದನ್ನು ಬರೆಯುತ್ತಾರೆ, ಆದರೆ ಇದು ಉಚಿತ ಇಲ್ಲ.

181
00:09:13,000 --> 00:09:16,000
ನಾವು ಮಾಡಿ ಮತ್ತು Valgrind ಅಡಿಯಲ್ಲಿ ಚಾಲನೆ ಅದನ್ನು ಕಂಪೈಲ್

182
00:09:16,000 --> 00:09:18,000
ಮತ್ತು ನಾವು ನೋಡಿ, ನಾವು ಮೆಮೊರಿ ದೋಷಗಳು ಯಾವುದೇ ಹೊಂದಿರುತ್ತವೆ, ಎಂದು

183
00:09:18,000 --> 00:09:20,000
ನಾವು ಒಂದು ಸೋರಿಕೆಗೆ ಹೊಂದಿಲ್ಲ.

184
00:09:20,000 --> 00:09:23,000
ಖಂಡಿತವಾಗಿಯೂ ಕಳೆದುಕೊಂಡ 16 ಬೈಟ್ಗಳು, ಇವೆ

185
00:09:23,000 --> 00:09:27,000
ಪ್ರೋಗ್ರಾಂ ನಿರ್ಗಮಿಸಿದೆ ಆ ಮೆಮೊರಿ ಸೂಚಕವನ್ನು ವ್ಯಾಪ್ತಿ ಎಂದು ಅರ್ಥ.

186
00:09:27,000 --> 00:09:30,000
ಈಗ, Valgrind, ನಮಗೆ ಸೋರಿಕೆ ಬಗ್ಗೆ ಮಾಹಿತಿಯನ್ನು ಒಂದು ಟನ್ ನೀಡುವುದಿಲ್ಲ

187
00:09:30,000 --> 00:09:35,000
ಆದರೆ ಅದು ತನ್ನ ವರದಿಯನ್ನು ಕೆಳಭಾಗದಲ್ಲಿ ಕೆಳಭಾಗಕ್ಕೆ ನೀಡುವ ಈ ಸಣ್ಣ ಟಿಪ್ಪಣಿ ಅನುಸರಿಸಿದರೆ

188
00:09:35,000 --> 00:09:38,000
ಜೊತೆಗೆ ಮರುಪ್ರದರ್ಶನ ಗೆ - ಸೋರಿಕೆ ಪರಿಶೀಲಿಸಿ = ಪೂರ್ಣ

189
00:09:38,000 --> 00:09:41,000
ಸೋರಿಕೆಯಾದ ಮೆಮೊರಿ ಪೂರ್ಣ ವಿವರಗಳನ್ನು ನೋಡಲು,

190
00:09:41,000 --> 00:09:44,000
ನಾವು ಹೆಚ್ಚಿನ ಮಾಹಿತಿಗಾಗಿ ಪಡೆಯುತ್ತೀರಿ.

191
00:09:44,000 --> 00:09:46,000
ಈಗ, ರಾಶಿ ಸಾರಾಂಶ ರಲ್ಲಿ,

192
00:09:46,000 --> 00:09:50,000
ಸೋತರು ಎಂದು ಮೆಮೊರಿ ಆರಂಭದಲ್ಲಿ ನೀಡಲಾಯಿತು ಅಲ್ಲಿ Valgrind ನಮಗೆ ಹೇಳುತ್ತದೆ.

193
00:09:50,000 --> 00:09:52,000
ನಾವು ಮೂಲ ಕೋಡ್ ಹುಡುಕುವುದರಲ್ಲಿ ತಿಳಿದಿರುವ ಹಾಗೆ,

194
00:09:52,000 --> 00:09:55,000
Valgrind ನಾವು ಮೆಮೊರಿ ಸೋರಿಕೆಯಾಗಿದ್ದು ನಮಗೆ ಮಾಹಿತಿ

195
00:09:55,000 --> 00:09:58,000
leak.c ಸಾಲಿನ 8 ರಂದು malloc ಒಂದು ಕರೆಯೊಂದಿಗೆ ಹಂಚಿಕೆ

196
00:09:58,000 --> 00:10:00,000
ಮುಖ್ಯ ಕಾರ್ಯದಲ್ಲಿ.

197
00:10:00,000 --> 00:10:02,000
ಪ್ರೆಟಿ ನಿಫ್ಟಿ.

198
00:10:02,000 --> 00:10:04,000
>> Valgrind ಈ ಪದಗಳನ್ನು ಬಳಸಿ ಸೋರಿಕೆಯನ್ನು ವರ್ಗೀಕರಿಸುತ್ತದೆ:

199
00:10:04,000 --> 00:10:07,000
ಖಂಡಿತವಾಗಿಯೂ ಕಳೆದುಕೊಂಡರು - ಈ ರಾಶಿ ನಿಯೋಜಿಸಲಾದ ಮೆಮೊರಿ ಹೊಂದಿದೆ

200
00:10:07,000 --> 00:10:10,000
ಇದು ಕಾರ್ಯಕ್ರಮದ ಮುಂದೆ ಪಾಯಿಂಟರ್ ಹೊಂದಿದೆ ಗೆ.

201
00:10:10,000 --> 00:10:14,000
Valgrind ನೀವು ಒಮ್ಮೆ ಪಾಯಿಂಟರ್ ಆದರೆ ಇದು ಜಾಡು ಕಳೆದುಕೊಂಡಿದ್ದಾರೆ ಎಂದು ತಿಳಿದಿದೆ.

202
00:10:14,000 --> 00:10:17,000
ಈ ಮೆಮೊರಿ ಖಂಡಿತವಾಗಿಯೂ ಸೋರಿಕೆಯಾಗಿದೆ.

203
00:10:17,000 --> 00:10:20,000
ಪರೋಕ್ಷವಾಗಿ ಕಳೆದುಕೊಂಡರು - ಈ ರಾಶಿ ನಿಯೋಜಿಸಲಾದ ಮೆಮೊರಿ ಹೊಂದಿದೆ

204
00:10:20,000 --> 00:10:24,000
ಅದು ಮಾತ್ರ ಪಾಯಿಂಟರ್ಗಳನ್ನು ಸಹ ಕಳೆದುಹೋಗಿವೆ ಗೆ.

205
00:10:24,000 --> 00:10:27,000
ಉದಾಹರಣೆಗೆ, ನೀವು ಒಂದು ಲಿಂಕ್ ಪಟ್ಟಿಯಲ್ಲಿ ಮೊದಲ ನೋಡ್ ನಿಮ್ಮ ಪಾಯಿಂಟರ್ ಸೋತರೆ,

206
00:10:27,000 --> 00:10:30,000
ನಂತರ ಮೊದಲ ನೋಡ್ ಸ್ವತಃ ಖಂಡಿತವಾಗಿ, ಕಳೆದು ಎಂದು

207
00:10:30,000 --> 00:10:34,000
ಯಾವುದೇ ನಂತರದ ಗ್ರಂಥಿಗಳು ಪರೋಕ್ಷವಾಗಿ ಕಳೆದು ಹೇಳಿದರು.

208
00:10:34,000 --> 00:10:37,000
ಪ್ರಾಯಶಃ ಕಳೆದು - ಈ ರಾಶಿ ನಿಯೋಜಿಸಲಾದ ಮೆಮೊರಿ ಹೊಂದಿದೆ

209
00:10:37,000 --> 00:10:41,000
ಇದು Valgrind ಒಂದು ಪಾಯಿಂಟರ್ ಅಥವಾ ಇಲ್ಲ ಎಂದು ಖಚಿತವಾಗಿ ಇರುವಂತಿಲ್ಲ.

210
00:10:41,000 --> 00:10:44,000
ಇನ್ನೂ ತಲುಪಬಹುದಾದ ರಾಶಿ ನಿಯೋಜಿಸಲಾದ ಮೆಮೊರಿ ಹೊಂದಿದೆ

211
00:10:44,000 --> 00:10:47,000
ಪ್ರೋಗ್ರಾಂ ಇನ್ನೂ ನಿರ್ಗಮನ ಒಂದು ಪಾಯಿಂಟರ್ ಇದು ಗೆ,

212
00:10:47,000 --> 00:10:50,000
ಇದು ವಿಶಿಷ್ಟವಾಗಿ ಎಂದರೆ ಇದು ಒಂದು ಜಾಗತಿಕ ವೇರಿಯಬಲ್ ಅಂಕಗಳನ್ನು.

213
00:10:50,000 --> 00:10:53,000
ಈ ಸೋರಿಕೆಯನ್ನು ಪರಿಶೀಲಿಸಲು, ನೀವು ಆಯ್ಕೆಯನ್ನು ಸೇರಿಸಲು ಸಾಧ್ಯವಿದೆ

214
00:10:53,000 --> 00:10:55,000
- ಇನ್ನೂ ತಲುಪಬಹುದಾದ = ಹೌದು

215
00:10:55,000 --> 00:10:58,000
Valgrind ನಿಮ್ಮ ಕೋರಿಕೆಯನ್ನು ರಲ್ಲಿ.

216
00:10:58,000 --> 00:11:01,000
>> ಈ ವಿವಿಧ ಸಂದರ್ಭಗಳಲ್ಲಿ, ಅದನ್ನು ಸ್ವಚ್ಛಗೊಳಿಸಲು ವಿವಿಧ ಕಾರ್ಯತಂತ್ರಗಳನ್ನು ಬಯಸುತ್ತವೆ

217
00:11:01,000 --> 00:11:05,000
ಆದರೆ ಸೋರಿಕೆಯನ್ನು ಹೊರಹಾಕಬೇಕು.

218
00:11:05,000 --> 00:11:08,000
ದುರದೃಷ್ಟವಶಾತ್, ಸೋರಿಕೆಯನ್ನು ಸರಿಪಡಿಸಿತು ಮಾಡಲು ಕಷ್ಟ

219
00:11:08,000 --> 00:11:11,000
ಉಚಿತ ತಪ್ಪು ಕರೆಗಳನ್ನು ನಿಮ್ಮ ಪ್ರೋಗ್ರಾಂ ಸ್ಫೋಟಿಸುವ ಏಕೆಂದರೆ.

220
00:11:11,000 --> 00:11:14,000
ಉದಾಹರಣೆಗೆ, ನಾವು invalid_free.c ನೋಡಿದರೆ,

221
00:11:14,000 --> 00:11:18,000
ನಾವು ಕೆಟ್ಟ ಮೆಮೊರಿ deallocation ಉದಾಹರಣೆ ನೋಡಿ.

222
00:11:18,000 --> 00:11:21,000
ಸಂಪೂರ್ಣ ಬ್ಲಾಕ್ ಮುಕ್ತಗೊಳಿಸಲು ಒಂದು ಕರೆ ಏನಾಗಿರಬೇಕೆಂದು

223
00:11:21,000 --> 00:11:24,000
ಮೆಮೊರಿ, int_block ಮೂಲಕ ತೋರಿಸಿದರು

224
00:11:24,000 --> 00:11:27,000
ಬದಲಾಗಿ ಪ್ರತಿ ಇಂಟ್ ಗಾತ್ರದ ವಿಭಾಗ ಮುಕ್ತಗೊಳಿಸಲು ಪ್ರಯತ್ನದಲ್ಲಿ ಮಾರ್ಪಟ್ಟಿದೆ

225
00:11:27,000 --> 00:11:29,000
ಪ್ರತ್ಯೇಕವಾಗಿ ಮೆಮೊರಿಯ.

226
00:11:29,000 --> 00:11:32,000
ಈ ಪೂರ್ತಿ ವಿಫಲಗೊಳ್ಳುತ್ತದೆ.

227
00:11:32,000 --> 00:11:34,000
ಬೂಮ್! ಯಾವ ದೋಷ.

228
00:11:34,000 --> 00:11:36,000
ಈ ಖಂಡಿತವಾಗಿ ಉತ್ತಮ ಅಲ್ಲ.

229
00:11:36,000 --> 00:11:39,000
ನೀವು ದೋಷ ಈ ರೀತಿಯ ಸಿಕ್ಕಿಕೊಂಡುಬಿಟ್ಟಿರುತ್ತೇವೆ, ಆದರೂ, ಮತ್ತು ನೀವು, ಅಲ್ಲಿ ನೋಡಲು ಗೊತ್ತಿಲ್ಲ ವೇಳೆ

230
00:11:39,000 --> 00:11:41,000
ನಿಮ್ಮ ಹೊಸ ಉತ್ತಮ ಗೆಳೆಯನನ್ನು ಹಿಂದೆ ಬೀಳುತ್ತವೆ.

231
00:11:41,000 --> 00:11:44,000
ನೀವು ಊಹಿಸಿದಂತೆ - Valgrind.

232
00:11:44,000 --> 00:11:47,000
Valgrind, ಎಂದು ಯಾವಾಗಲೂ ಅಪ್, ನಿಖರವಾಗಿ ತಿಳಿದಿಲ್ಲ.

233
00:11:47,000 --> 00:11:50,000
alloc ಮತ್ತು ಉಚಿತ ಎಣಿಕೆಗಳು ಅಪ್ ಹೊಂದುತ್ತಿಲ್ಲ.

234
00:11:50,000 --> 00:11:52,000
ನಾವು 1 alloc ಮತ್ತು 4 ಫ್ರೀಸ್ ಮಾಡಲೇಬೇಕು.

235
00:11:52,000 --> 00:11:55,000
ಮತ್ತು Valgrind ಸಹ ಅಲ್ಲಿ ಮೊದಲ ಕೆಟ್ಟ ಉಚಿತ ಕರೆ ನಮಗೆ ಹೇಳುತ್ತದೆ -

236
00:11:55,000 --> 00:11:58,000
ಹಿಗ್ಗಿದ ಕಾರಣವಾಯಿತು ಒಂದು - ಬರುವ ಇದೆ -

237
00:11:58,000 --> 00:12:00,000
ಸಾಲು 16.

238
00:12:00,000 --> 00:12:03,000
ನೀವು ನೋಡಿ ಎಂದು, ಮುಕ್ತಗೊಳಿಸಲು ಕೆಟ್ಟ ಕರೆಗಳು, ನಿಜವಾಗಿಯೂ ಕೆಟ್ಟ

239
00:12:03,000 --> 00:12:05,000
ಆದ್ದರಿಂದ ನಿಮ್ಮ ಪ್ರೋಗ್ರಾಂ ಸೋರಿಕೆಗೆ ಅವಕಾಶ ಶಿಫಾರಸು

240
00:12:05,000 --> 00:12:08,000
ನೀವು ಕಾರ್ಯವನ್ನು ಸರಿಯಾದ ಪಡೆಯುವಲ್ಲಿ ಕೆಲಸ ಮಾಡುತ್ತಲೇ.

241
00:12:08,000 --> 00:12:12,000
ನಿಮ್ಮ ಪ್ರೋಗ್ರಾಂ ಸರಿಯಾಗಿ ಕೆಲಸ ಮಾತ್ರ ನಂತರ ಸೋರಿಕೆಯನ್ನು ನಿರೀಕ್ಷಿಸಲು ಆರಂಭಿಸುವಂತೆ,

242
00:12:12,000 --> 00:12:14,000
ಯಾವುದೇ ದೋಷಗಳು ಇಲ್ಲದೆ.

243
00:12:14,000 --> 00:12:16,000
>> ಮತ್ತು ನಾವು ಈ ವೀಡಿಯೊ ಪಡೆದಿರುವಿರಿ ಅಷ್ಟೆ.

244
00:12:16,000 --> 00:12:18,000
ಈಗ ನೀವು ಕಾಯುವ?

245
00:12:18,000 --> 00:12:21,000
ಇದೀಗ ನಿಮ್ಮ ಕಾರ್ಯಕ್ರಮಗಳಲ್ಲಿ Valgrind ರನ್ ಹೋಗಿ.

246
00:12:21,000 --> 00:12:25,000
ನನ್ನ ಹೆಸರು ನೇಟ್ Hardison ಹೊಂದಿದೆ. ಈ CS50 ಹೊಂದಿದೆ. [CS50.TV]