1
00:00:00,000 --> 00:00:00,499

2
00:00:00,499 --> 00:00:01,395
[ಸಂಗೀತ]

3
00:00:01,395 --> 00:00:05,590

4
00:00:05,590 --> 00:00:07,940
>> ಡೌಗ್ LLOYD: ಸರಿ ಸಲಹೆ
ಇಲ್ಲಿ ಪ್ರಾರಂಭಿಸುವ ಮೊದಲು.

5
00:00:07,940 --> 00:00:11,660
ನೀವು ವೀಡಿಯೊ ವೀಕ್ಷಿಸಿದ ಇದ್ದರೆ
ನೀವು ಮೊದಲ ಮಾಡಲು ಬಯಸಬಹುದು ಕಚೇರಿ.

6
00:00:11,660 --> 00:00:15,860
ಈ ವೀಡಿಯೊ ಏಕೆಂದರೆ ಮತ್ತೊಂದು
ಪಾಯಿಂಟರ್ಸ್ ಕೆಲಸ ರೀತಿಯಲ್ಲಿ.

7
00:00:15,860 --> 00:00:17,574
>> ಆದ್ದರಿಂದ ಮಾತನಾಡಲು ಹೋಗುವುದಿಲ್ಲ
ಕೆಲವು ವಿಚಾರಗಳನ್ನು ಕುರಿತು

8
00:00:17,574 --> 00:00:19,490
ನಾವು ಆವರಿಸುವ
ವೀಡಿಯೊ ಪಾಯಿಂಟರ್ಸ್, ಮತ್ತು ನಾವು ನೀವು

9
00:00:19,490 --> 00:00:21,948
ಈಗ ಅವುಗಳನ್ನು ಮೇಲೆ ಟಿಪ್ಪಣಿ ಹೋಗುವ,
ಅವರು ಈಗಾಗಲೇ ಎಂಬುದನ್ನು ಊಹಿಸಿಕೊಂಡು

10
00:00:21,948 --> 00:00:23,090
ರೀತಿಯ ಅರ್ಥ.

11
00:00:23,090 --> 00:00:25,440
ಇದರಿಂದ ಕೇವಲ ನಿಮ್ಮ ನ್ಯಾಯೋಚಿತ ಎಚ್ಚರಿಕೆ ಇಲ್ಲಿದೆ
ನೀವು ಈ ವೀಡಿಯೊ ನೋಡಿದ ಬಳಸುತ್ತಿದ್ದರೆ

12
00:00:25,440 --> 00:00:27,814
ಮತ್ತು ನೀವು ನೋಡಿಲ್ಲ
ಪಾಯಿಂಟರ್ಸ್ ವೀಡಿಯೊ, ಇದು ಬಹುಶಃ ರೀತಿಯ

13
00:00:27,814 --> 00:00:29,610
ನಿಮ್ಮ ತಲೆಯ ಮೇಲೆ ಸ್ವಲ್ಪ ಹಾರುತ್ತವೆ.

14
00:00:29,610 --> 00:00:32,080
ಮತ್ತು ಆದ್ದರಿಂದ ಇದು ಉತ್ತಮ ಇರಬಹುದು
ಆ ದೃಷ್ಟಿಯಿಂದ ಇದು ವೀಕ್ಷಿಸಲು.

15
00:00:32,080 --> 00:00:34,710
>> ನಾವು ಈಗಾಗಲೇ ಒಂದು ನೋಡಿದ್ದೇವೆ
ರೀತಿಯಲ್ಲಿ, ಪಾಯಿಂಟರ್ಸ್ ಕೆಲಸ

16
00:00:34,710 --> 00:00:37,810
ಇದು ನಾವು ಒಂದು ಘೋಷಿಸಲು ಆಗಿದೆ
ವೇರಿಯಬಲ್, ಮತ್ತು ನಂತರ ನಾವು

17
00:00:37,810 --> 00:00:42,160
ಒಂದು ಪಾಯಿಂಟರ್ ಇನ್ನೊಂದು ವೇರಿಯೇಬಲ್ ಘೋಷಿಸಲು
ವೇರಿಯಬಲ್, ಅದು ಸೂಚಿತವಾಗಿರುತ್ತದೆ.

18
00:00:42,160 --> 00:00:44,870
ನಾವು ರಚಿಸಿದ
ಒಂದು ಹೆಸರಿನೊಂದಿಗೆ ವೇರಿಯಬಲ್, ನಾವು

19
00:00:44,870 --> 00:00:48,480
, ಒಂದು ಹೆಸರಿನ ಎರಡನೇ ವೇರಿಯಬಲ್ ದಾಖಲಿಸಿದವರು
ಮತ್ತು ನಾವು ಎರಡನೇ ವೇರಿಯಬಲ್ ಎಂದು ಸೂಚಿಸುತ್ತಾರೆ

20
00:00:48,480 --> 00:00:50,220
ಮೊದಲಿಗೆ.

21
00:00:50,220 --> 00:00:52,370
ಈ ರೀತಿಯ ಒಂದು
ಸಮಸ್ಯೆ ಆದರೂ, ಇದು ಏಕೆಂದರೆ

22
00:00:52,370 --> 00:00:54,650
ನಿಖರವಾಗಿ ತಿಳಿಯಲು ನಮಗೆ ಅಗತ್ಯವಿದೆ
ಎಷ್ಟು ಮೆಮೊರಿ ನಾವು ಆರ್

23
00:00:54,650 --> 00:00:57,600
ಕ್ಷಣ ಅಗತ್ಯವಿದೆ ಹೋಗುವ
ನಮ್ಮ ಕಾರ್ಯಕ್ರಮದಲ್ಲಿ ಸಂಕಲನ ಇದೆ.

24
00:00:57,600 --> 00:00:58,220
>> ಏಕೆ ಎಂದು?

25
00:00:58,220 --> 00:01:03,338
ನಾವು ಹೆಸರಿಸಲು ಸಮರ್ಥರಾಗಿರಬೇಕು ಏಕೆಂದರೆ ಅಥವಾ
ಸಾಧ್ಯ ಅಸ್ಥಿರ ಎಲ್ಲಾ ಗುರುತಿಸಲು

26
00:01:03,338 --> 00:01:04,129
ನಾವು ಎದುರಿಸಬೇಕಾಗುತ್ತದೆ.

27
00:01:04,129 --> 00:01:07,910
ನಾವು ನೀಡಬಹುದಾದ ಒಂದು ಶ್ರೇಣಿಯನ್ನು ಹೊಂದಿರಬಹುದು
ಮಾಹಿತಿ ಬಹಳಷ್ಟು ಹಿಡಿದಿಟ್ಟುಕೊಳ್ಳಬಲ್ಲ,

28
00:01:07,910 --> 00:01:10,110
ಆದರೆ ಇದು ಇನ್ನೂ ಅಲ್ಲ
ಸಾಕಷ್ಟು ನಿಖರವಾಗಿ ನಿಖರ.

29
00:01:10,110 --> 00:01:12,640
ನಾವು ಗೊತ್ತಿಲ್ಲ,
ನಾವು ಯಾವುದೇ ಕಲ್ಪನೆ ಇದ್ದರೆ

30
00:01:12,640 --> 00:01:14,370
ಎಷ್ಟು ನಾವು ಕಂಪೈಲ್ ಸಮಯದಲ್ಲಿ ಅಗತ್ಯವಿದೆ?

31
00:01:14,370 --> 00:01:17,020
ಅಥವಾ ನಮ್ಮ ಕಾರ್ಯಕ್ರಮದ ವೇಳೆ
ನಿಜವಾಗಿಯೂ ಬಹಳ ಸಮಯ ರನ್,

32
00:01:17,020 --> 00:01:19,810
ವಿವಿಧ ಬಳಕೆದಾರ ಸ್ವೀಕರಿಸುವ
ಡೇಟಾ, ನಾವೇಕೆ ಸಾಧಿಸಲಾಗಲಿಲ್ಲ ನಿಜವಾಗಿಯೂ

33
00:01:19,810 --> 00:01:23,170
ನಾವು ಎಂಬುದನ್ನು ಅಂದಾಜು
1,000 ಘಟಕಗಳು ಅಗತ್ಯ ಹೋಗುವ?

34
00:01:23,170 --> 00:01:26,060
>> ನಾವು ಇಷ್ಟ ಅಲ್ಲ
ಆಜ್ಞಾ ಸಾಲಿನಲ್ಲಿ ಹೇಳುತ್ತಾರೆ

35
00:01:26,060 --> 00:01:28,040
ಎಷ್ಟು ಐಟಂಗಳನ್ನು ನಮೂದಿಸಿ
ನೀವು ಅಗತ್ಯವಿದೆ ಭಾವಿಸುತ್ತೇನೆ.

36
00:01:28,040 --> 00:01:31,100
ಸರಿ ಊಹೆ ತಪ್ಪು ಏನು ವೇಳೆ?

37
00:01:31,100 --> 00:01:34,300
ಕ್ರಿಯಾಶೀಲ ಸ್ಮರಣೆ ಹಂಚಿಕೆ
ರೀತಿಯ ನಮಗೆ ರೀತಿಯಲ್ಲಿ ಅನುಮತಿಸುತ್ತದೆ

38
00:01:34,300 --> 00:01:36,867
ಈ ನಿರ್ದಿಷ್ಟ ಸಮಸ್ಯೆಗೆ ಪರಿಹಾರ.

39
00:01:36,867 --> 00:01:38,700
ಮತ್ತು ರೀತಿಯಲ್ಲಿ ಅದು
ಪಾಯಿಂಟರ್ಸ್ ಬಳಸಲ್ಪಡುತ್ತದೆ.

40
00:01:38,700 --> 00:01:42,140
>> ನಾವು ಪಾಯಿಂಟರ್ಸ್ ಬಳಸಬಹುದಾದ
ಸಕ್ರಿಯವಾಗಿ ಪಡೆದುಕೊಳ್ಳಬಹುದಾಗಿದೆ

41
00:01:42,140 --> 00:01:45,710
ಎಂದು ನಿಯೋಜಿಸಲಾದ ಮೆಮೊರಿ, ಮೆಮೊರಿ
ನಿಮ್ಮ ಪ್ರೋಗ್ರಾಂ ಹಂಚಿಕೆ ಚಾಲನೆಯಲ್ಲಿದೆ.

42
00:01:45,710 --> 00:01:48,290
ಇದು ಕಂಪೈಲ್ ಸಮಯದಲ್ಲಿ ನಿಯೋಜಿತವಾದ ಅಲ್ಲ.

43
00:01:48,290 --> 00:01:51,570
ನೀವು ಸಕ್ರಿಯವಾಗಿ ನಿಯೋಜಿಸಿ
ಮೆಮೊರಿ ಇದು ಕೊಳದ ಬರುತ್ತದೆ

44
00:01:51,570 --> 00:01:53,795
ಮೆಮೊರಿ ರಾಶಿ ಎಂದು ಕರೆಯಲಾಗುತ್ತದೆ.

45
00:01:53,795 --> 00:01:56,420
ನಾವು ಮಾಡಿದ ಹಿಂದೆ ಎಲ್ಲಾ ಮೆಮೊರಿ
ಹಾದಿಯಲ್ಲಿ ಕೆಲಸ

46
00:01:56,420 --> 00:01:59,920
ಒಂದು ಗುಂಪಿನಿಂದ ಬರುತ್ತಿದ್ದಾರೆ
ಮೆಮೊರಿ ಸ್ಟಾಕ್ ಎಂದು ಕರೆಯಲಾಗುತ್ತದೆ.

47
00:01:59,920 --> 00:02:02,470
ಉತ್ತಮ ರೀತಿಯಲ್ಲಿ ಸಾಮಾನ್ಯವಾಗಿ
mind-- ಮತ್ತು ಈ ನಿಯಮವನ್ನು ಇರಿಸಿಕೊಳ್ಳಲು

48
00:02:02,470 --> 00:02:04,720
ಯಾವಾಗಲೂ ಅನ್ವಯಿಸಲೇಬೇಕೆಂದೇನಿಲ್ಲ
ಆದರೆ ಬಹುಮಟ್ಟಿಗೆ ಸುಮಾರು

49
00:02:04,720 --> 00:02:09,940
ಯಾವಾಗಲೂ true-- ಯಾವುದೇ ಎಂದು ಹೊಂದಿದೆ
ಸಮಯ ನೀವು ಒಂದು ವೇರಿಯೇಬಲ್ ಹೆಸರು ನೀಡಲು

50
00:02:09,940 --> 00:02:12,090
ಬಹುಶಃ ಸ್ಟಾಕ್ ವಾಸಿಸುತ್ತಾನೆ.

51
00:02:12,090 --> 00:02:14,650
ಮತ್ತು ಯಾವುದೇ ಸಮಯದಲ್ಲಿ ನೀವು
ವೇರಿಯಬಲ್ ಹೆಸರನ್ನು

52
00:02:14,650 --> 00:02:19,160
ನೀವು ಕ್ರಿಯಾತ್ಮಕ ಮೆಮೊರಿ ಮಾಡಬಹುದು
ಹಂಚಿಕೆ, ಅದನ್ನು ರಾಶಿ ವಾಸಿಸುತ್ತಾರೆ.

53
00:02:19,160 --> 00:02:22,190
>> ಈಗ ನಾನು ರೀತಿಯ ಈ ನೀಡುವ ನಾನು
ಮೆಮೊರಿ ಈ ಎರಡು ಕೆರೆ ಇಲ್ಲ ವೇಳೆ.

54
00:02:22,190 --> 00:02:24,740
ಆದರೆ ನೀವು ನೋಡಬಹುದು
ಸಾಮಾನ್ಯವಾಗಿ ಇದು ರೇಖಾಚಿತ್ರ,

55
00:02:24,740 --> 00:02:27,290
ಪ್ರತಿನಿಧಿಸುತ್ತದೆ
ಏನು ಮೆಮೊರಿ ತೋರುತ್ತಿದೆ

56
00:02:27,290 --> 00:02:30,373
ಮತ್ತು ನಾವು ಎಲ್ಲಾ ರಕ್ಷಣೆ ಹೋಗುತ್ತಿಲ್ಲ
ಮೇಲ್ಭಾಗ ಮತ್ತು ಕೆಳಭಾಗದಲ್ಲಿ ಸ್ಟಫ್.

57
00:02:30,373 --> 00:02:33,580
ನಾವು ಕಾಳಜಿವಹಿಸುವ ಈ ಭಾಗವಾಗಿದೆ
ಇಲ್ಲಿ ಮಧ್ಯಮ, ರಾಶಿ ಮತ್ತು ಸ್ಟಾಕ್.

58
00:02:33,580 --> 00:02:35,570
ನೀವು ನೋಡಬಹುದು ಎಂದು
ಈ ಚಿತ್ರದಲ್ಲಿ ನೋಡುವ,

59
00:02:35,570 --> 00:02:38,390
ಈ ವಾಸ್ತವವಾಗಿ ಎರಡು ಅಲ್ಲ
ಮೆಮೊರಿ ಪ್ರತ್ಯೇಕ ಕೆರೆ.

60
00:02:38,390 --> 00:02:42,757
ಇದು ಮೆಮೊರಿ ಒಂದು ಹಂಚಿಕೆಯ ಕೊಳದ
ಅಲ್ಲಿ ಈ ದೃಶ್ಯ ರಲ್ಲಿ, ಆರಂಭಿಸಲು

61
00:02:42,757 --> 00:02:44,590
ನೀವು ಕೆಳಗೆ ಆರಂಭಿಸಲು
ಮತ್ತು ಭರ್ತಿ ಆರಂಭಿಸಲು

62
00:02:44,590 --> 00:02:48,040
ಸ್ಟಾಕ್ ಕೆಳಭಾಗದಲ್ಲಿ, ಮತ್ತು ನೀವು
ಮೇಲ್ಭಾಗದಿಂದ ಆರಂಭಗೊಳ್ಳುತ್ತದೆ ಮತ್ತು ಭರ್ತಿ ಆರಂಭಿಸಲು

63
00:02:48,040 --> 00:02:50,072
ಹೀಪ್ ಕೆಳಕ್ಕೆ.

64
00:02:50,072 --> 00:02:51,780
ಆದರೆ ಇದು ನಿಜವಾಗಿಯೂ ಹೊಂದಿದೆ
ಅದೇ ಸ್ನೂಕರ್, ಅದು ಕೇವಲ

65
00:02:51,780 --> 00:02:56,050
ವಿವಿಧ ತಾಣಗಳು, ವಿವಿಧ ಸ್ಥಳಗಳಲ್ಲಿ
ನೆನಪಿಗಾಗಿ ಹಂಚಿಕೆ ಎಂದು.

66
00:02:56,050 --> 00:02:59,060
ಮತ್ತು ನೀವು ರನ್ ಔಟ್ ಮಾಡಬಹುದು
ಎರಡೂ ಹೊಂದುವ ಮೂಲಕ ಮೆಮೊರಿ

67
00:02:59,060 --> 00:03:01,240
ರಾಶಿ ಎಲ್ಲಾ ರೀತಿಯಲ್ಲಿ ಹೋಗಿ
ಕೆಳಗೆ, ಅಥವಾ

68
00:03:01,240 --> 00:03:05,440
ಸ್ಟಾಕ್ ಮೇಲಕ್ಕೆ ಎಲ್ಲಾ ರೀತಿಯಲ್ಲಿ ಹೋಗಿ
ಅಥವಾ ರಾಶಿ ಮತ್ತು ಸ್ಟಾಕ್ ಹೊಂದಿರುವ

69
00:03:05,440 --> 00:03:06,740
ಪರಸ್ಪರ ವಿರುದ್ಧ ಭೇಟಿ.

70
00:03:06,740 --> 00:03:09,500
ಆ ಎಲ್ಲಾ ಪರಿಸ್ಥಿತಿಗಳು ಮಾಡಬಹುದು
ನಿಮ್ಮ ಪ್ರೋಗ್ರಾಂ ದುರುದ್ದೇಶಪೂರಿತ

71
00:03:09,500 --> 00:03:11,030
ಮೆಮೊರಿ ರನ್ ಔಟ್.

72
00:03:11,030 --> 00:03:11,952
ಆದ್ದರಿಂದ ಮನಸ್ಸಿನಲ್ಲಿ ಆ ಇರಿಸಿಕೊಳ್ಳಲು.

73
00:03:11,952 --> 00:03:13,660
ನಾವು ಬಗ್ಗೆ ಮಾತನಾಡಿ
ರಾಶಿ ಮತ್ತು ಸ್ಟಾಕ್

74
00:03:13,660 --> 00:03:17,880
ನಾವು ಬಗ್ಗೆ ಮಾತನಾಡುತ್ತಿದ್ದೇವೆ
ಮೆಮೊರಿ ಅದೇ ಸಾಮಾನ್ಯ ಪಡೆ, ಕೇವಲ

75
00:03:17,880 --> 00:03:21,930
ಮೆಮೊರಿ ವಿವಿಧ ಭಾಗಗಳನ್ನು.

76
00:03:21,930 --> 00:03:24,910
>> ಆದ್ದರಿಂದ ನಾವು ಸಕ್ರಿಯವಾಗಿ ಹೇಗೆ ಪಡೆಯಬಲ್ಲೆ
ಮೊದಲ ಸ್ಥಾನದಲ್ಲಿ ಮೆಮೊರಿ ಹಂಚಿಕೆ?

77
00:03:24,910 --> 00:03:27,740
ನಮ್ಮ ಕಾರ್ಯಕ್ರಮದಲ್ಲಿ ಪಡೆಯಲು ಹೇಗೆ
ಇದು ಚಾಲನೆಯಲ್ಲಿರುವ ಎಂದು ಮೆಮೊರಿ?

78
00:03:27,740 --> 00:03:32,660
ಹಾಗೂ ಸಿ ಎಂಬ ಕಾರ್ಯ ಒದಗಿಸುತ್ತದೆ
malloc, ಮೆಮೊರಿ ನಿಯೋಜಕವನ್ನು, ಇದು

79
00:03:32,660 --> 00:03:36,810
ನೀವು ಕರೆ ಮಾಡಲು, ಮತ್ತು ನೀವು ಹಾದು
ನೀವು ಎಷ್ಟು ಬಯಸುತ್ತೀರಿ ಮೆಮೊರಿ ಬೈಟ್ಗಳು.

80
00:03:36,810 --> 00:03:39,940
ನಿಮ್ಮ ಪ್ರೋಗ್ರಾಂ ಚಲಿಸುತ್ತಿದ್ದರೆ ಆದ್ದರಿಂದ
ಮತ್ತು ನೀವು ಒಂದು ಪೂರ್ಣಾಂಕ ರನ್ಟೈಮ್ ಬಯಸುವ,

81
00:03:39,940 --> 00:03:46,040
ನೀವು ನಾಲ್ಕು ಬೈಟ್ಗಳು ಮೆಲ್ಲಾಕ್ ಇರಬಹುದು
ಮೆಮೊರಿ, malloc ನಾಲ್ಕು ಆವರಣ.

82
00:03:46,040 --> 00:03:48,540
>> ಮೆಲ್ಲಾಕ್ ಮೂಲಕ ಹೋಗುತ್ತದೆ
ರಾಶಿ ಮೂಲಕ ಹುಡುಕುತ್ತಿರುವ,

83
00:03:48,540 --> 00:03:50,750
ನಾವು ಸಕ್ರಿಯವಾಗಿ ಏಕೆಂದರೆ
ಮೆಮೊರಿ ಹಂಚುತ್ತಾರೆ,

84
00:03:50,750 --> 00:03:53,500
ಮತ್ತು ಇದು ನೀವು ಹಿಂದಿರುಗುವ
ಎಂದು ಮೆಮೊರಿ ಒಂದು ಪಾಯಿಂಟರ್.

85
00:03:53,500 --> 00:03:56,180
ಇದು ಆ ಮೆಮೊರಿ ನೀಡುವುದಿಲ್ಲ
ಇದು ಒಂದು ಹೆಸರನ್ನು ನೀಡುವುದಿಲ್ಲ,

86
00:03:56,180 --> 00:03:57,950
ನೀವು ಒಂದು ಪಾಯಿಂಟರ್ ನೀಡುತ್ತದೆ.

87
00:03:57,950 --> 00:04:00,780
ಮತ್ತೆ ನಾನು ಹೇಳಿದರು ಏಕೆ ಆ ನ
ಇದು ಬಹುಶಃ ಮುಖ್ಯ ಎಂದು

88
00:04:00,780 --> 00:04:03,770
ಪಾಯಿಂಟರ್ಸ್ ವೀಡಿಯೊ ವೀಕ್ಷಿಸಿದ
ನಾವು ಈ ಕೂಡ ದೂರದ ಪಡೆಯಲು ಮೊದಲು.

89
00:04:03,770 --> 00:04:05,940
ಆದ್ದರಿಂದ malloc ವಿಶೇಷವೇನು
ಒಂದು ಪಾಯಿಂಟರ್ ನೀವು ಮತ್ತೆ ನೀಡಿ.

90
00:04:05,940 --> 00:04:08,950
>> ಮೆಲ್ಲಾಕ್ ನೀವು ಯಾವುದೇ ನೀಡಲು ಆಗದಿದ್ದರೆ
ಮೆಮೊರಿ ನೀವು ರನ್ ಔಟ್ ಮಾಡಿದ ಕಾರಣ,

91
00:04:08,950 --> 00:04:10,645
ಇದು ಒಂದು ಶೂನ್ಯ ಪಾಯಿಂಟರ್ ನೀವು ನೀಡುತ್ತೇನೆ.

92
00:04:10,645 --> 00:04:15,282
ನೀವು ನಾವು ಏನಾಗುತ್ತದೆ ನೆನಪಿದೆಯೇ
ಪ್ರಯತ್ನಿಸಿ ಮತ್ತು dereference ಒಂದು ಶೂನ್ಯ ಪಾಯಿಂಟರ್?

93
00:04:15,282 --> 00:04:17,019
ನಾವು, ಒಂದು seg ತಪ್ಪು ಸಹಿಸಲಿ

94
00:04:17,019 --> 00:04:18,060
ಎಂದು ಬಹುಶಃ ಉತ್ತಮ ಅಲ್ಲ.

95
00:04:18,060 --> 00:04:21,579
>> ಆದ್ದರಿಂದ ಪ್ರತಿ ಬಾರಿ ಕರೆ ಮಾಡಿ
ಯಾವಾಗಲೂ, ಯಾವಾಗಲೂ ನೀವು malloc

96
00:04:21,579 --> 00:04:25,270
ಪರಿಶೀಲಿಸಬೇಕು ಎಂದು ಅಥವಾ
ಇದು ನೀವು ಶೂನ್ಯ ನೀಡಿದರು ಪಾಯಿಂಟರ್.

97
00:04:25,270 --> 00:04:28,800
ಇದು ಇದ್ದರೆ, ನಿಮ್ಮ ಪ್ರೋಗ್ರಾಂ ಅಂತ್ಯಗೊಳಿಸಲು ಅಗತ್ಯ
ನೀವು dereference ಪ್ರಯತ್ನಿಸಿ ಮತ್ತು ಏಕೆಂದರೆ

98
00:04:28,800 --> 00:04:31,360
ನೀನು ಶೂನ್ಯ ಪಾಯಿಂಟರ್
ಒಂದು ಸೆಗ್ಮೆಂಟೇಶನ್ ದೋಷಕ್ಕೆ ಬಳಲುತ್ತಿದ್ದಾರೆ

99
00:04:31,360 --> 00:04:34,380
ನಿಮ್ಮ ಕಾರ್ಯಕ್ರಮ
ಹೇಗಾದರೂ ಕುಸಿತಕ್ಕೆ ಹೋಗುತ್ತದೆ.

100
00:04:34,380 --> 00:04:37,190
ಆದ್ದರಿಂದ ಹೇಗೆ ಜಡವಾಗಿ ನಾವು
ಒಂದು ಪೂರ್ಣಾಂಕ ಪಡೆಯಲು?

101
00:04:37,190 --> 00:04:37,730
>> ಇಂಟ್ X.

102
00:04:37,730 --> 00:04:40,010
ನಾವು ಬಹುಶಃ ಮಾಡಿದ
ಬಾರಿ ಗುಂಪೇ, ಬಲ?

103
00:04:40,010 --> 00:04:43,480
ಈ ಎಂಬ ಮಾರ್ಪಡಿಸಬಹುದಾದ ಸೃಷ್ಟಿಸುತ್ತದೆ
ಸ್ಟಾಕ್ ಮೇಲೆ ಜೀವಿಸುವ ಎಕ್ಸ್.

104
00:04:43,480 --> 00:04:46,190
ಹೇಗೆ ನಾವು ಸಕ್ರಿಯವಾಗಿ ಒಂದು ಪೂರ್ಣಾಂಕ ಪಡೆಯಲು ಇಲ್ಲ?

105
00:04:46,190 --> 00:04:50,010
ಇಂಟ್ ಸ್ಟಾರ್ px malloc 4 ಸಮನಾಗಿರುತ್ತದೆ.

106
00:04:50,010 --> 00:04:53,050
>> ಅಥವಾ ಹೆಚ್ಚು ಸೂಕ್ತವಾಗಿ
ನಾವು ಇಂಟ್ ಸ್ಟಾರ್ px ಹೇಳುವೆನು

107
00:04:53,050 --> 00:04:57,680
ಇಂಟ್ malloc ಗಾತ್ರ ಸಮನಾಗಿರುತ್ತದೆ
ಕೇವಲ ಕೆಲವು ಕಡಿಮೆ ಎಸೆಯಲು

108
00:04:57,680 --> 00:04:59,740
ನಮ್ಮ ಕಾರ್ಯಕ್ರಮದಲ್ಲಿ ಸುಮಾರು ಮ್ಯಾಜಿಕ್ ಸಂಖ್ಯೆಗಳು.

109
00:04:59,740 --> 00:05:04,140
ಇದು ನಮಗೆ ಪಡೆಯಲು ಹೋಗುತ್ತದೆ
ರಾಶಿ ಮೆಮೊರಿ ನಾಲ್ಕು ಬೈಟ್ಗಳು,

110
00:05:04,140 --> 00:05:06,720
ಮತ್ತು ಪಾಯಿಂಟರ್ ನಾವು ಪಡೆಯಲು
ಮರಳಿ px ಕರೆಯಲಾಗುತ್ತದೆ.

111
00:05:06,720 --> 00:05:08,430
ನಂತರ ನಾವು ಮಾಡಿದ ಕೇವಲ
ನಾವು ಹಿಂದೆ ಮಾಡಿದ

112
00:05:08,430 --> 00:05:13,966
ಮಾಡಬಹುದು px ಆಗಿರುತ್ತದೆ, dereference
ಮೆಮೊರಿ ಪ್ರವೇಶಿಸಲು.

113
00:05:13,966 --> 00:05:15,590
ಹೇಗೆ ನಾವು ಬಳಕೆದಾರ ಒಂದು ಪೂರ್ಣಾಂಕ ಪಡೆಯಲು ಇಲ್ಲ?

114
00:05:15,590 --> 00:05:17,970
ನಾವು ಇಂಟ್ X ಇಂಟ್ ಪಡೆಯಲು ಸಮನಾಗಿರುತ್ತದೆ ಹೇಳಬಹುದು.

115
00:05:17,970 --> 00:05:19,930
ಆ ಬಹಳ ಸರಳ ಇಲ್ಲಿದೆ.

116
00:05:19,930 --> 00:05:24,030
ನಾವು ಒಂದು ಶ್ರೇಣಿಯನ್ನು ರಚಿಸಲು ಬಯಸಿದರೆ ಏನು
ಸ್ಟಾಕ್ ಜೀವಿಸುವ ಫ್ಲೋಟ್ಗಳು x?

117
00:05:24,030 --> 00:05:28,210
ಆ ಹೆಸರು stack_array-- ಚಲಿಸುವಂತೆ
ನಮ್ಮ ಸರಣಿ ಚದರ ಬ್ರಾಕೆಟ್ಗಳನ್ನು x ನ.

118
00:05:28,210 --> 00:05:32,419
ಅದು ನಮಗೆ ಒಂದು ಶ್ರೇಣಿಯನ್ನು ರಚಿಸುತ್ತದೆ
ಸ್ಟಾಕ್ ಜೀವಿಸುವ ಫ್ಲೋಟ್ಗಳು x.

119
00:05:32,419 --> 00:05:34,960
ನಾವು ಫ್ಲೋಟ್ಗಳು ಒಂದು ಶ್ರೇಣಿಯನ್ನು ರಚಿಸಬಹುದು
ಅದೂ, ರಾಶಿ ವಾಸಿಸುತ್ತಾನೆ.

120
00:05:34,960 --> 00:05:37,330
ವಾಕ್ಯ ಕಂಡುಬರುವಂತಹ
, ಹೆಚ್ಚು ತೊಡಕಿನ ಸ್ವಲ್ಪ

121
00:05:37,330 --> 00:05:41,740
ಆದರೆ ನಾವು ಫ್ಲೋಟ್ ಹೇಳಬಹುದು
ಸ್ಟಾರ್ heap_array ಸಮನಾಗಿರುತ್ತದೆ

122
00:05:41,740 --> 00:05:44,360
malloc X ಬಾರಿ ಫ್ಲೋಟ್ ಗಾತ್ರ.

123
00:05:44,360 --> 00:05:48,160
ನಾನು ಹಿಡಿದಿಡಲು ಸಾಕಷ್ಟು ಕೊಠಡಿ ಅಗತ್ಯವಿದೆ
ಎಕ್ಸ್ ಫ್ಲೋಟಿಂಗ್ ಪಾಯಿಂಟ್ ಮೌಲ್ಯಗಳ.

124
00:05:48,160 --> 00:05:51,560
ಹಾಗಾಗಿ 100 ಅಗತ್ಯವಿದೆ ಹೇಳುತ್ತಾರೆ
ಫ್ಲೋಟ್ಗಳು, ಅಥವಾ 1,000 ಫ್ಲೋಟ್ಗಳು.

125
00:05:51,560 --> 00:05:54,810
ಆ ಸಂದರ್ಭದಲ್ಲಿ ಇದು ಎಂದು
100 ಫ್ಲೋಟ್ಗಳು 400 ಬೈಟ್ಗಳು,

126
00:05:54,810 --> 00:05:59,080
ಅಥವಾ 1,000 ಫ್ಲೋಟ್ಗಳು 4,000 ಬೈಟ್ಗಳು,
ಪ್ರತಿ ಫ್ಲೋಟ್ ತೆಗೆದುಕೊಳ್ಳುತ್ತದೆ ಏಕೆಂದರೆ

127
00:05:59,080 --> 00:06:01,230
ಜಾಗವನ್ನು ನಾಲ್ಕು ಬೈಟ್ಗಳು.

128
00:06:01,230 --> 00:06:05,110
>> ಈ ನಡೆಸಿದ ನಂತರ ನಾನು ಬಳಸಬಹುದು
heap_array ಮೇಲೆ ಚೌಕಾಕಾರದ ಬ್ರಾಕೆಟ್ ವಾಕ್ಯ.

129
00:06:05,110 --> 00:06:08,970
ನಾನು stack_array ಮೇಲೆ ಎಂದು, ನಾನು
ಅದರ ಪ್ರತ್ಯೇಕ ಘಟಕಗಳು ಪ್ರವೇಶಿಸಬಹುದು

130
00:06:08,970 --> 00:06:11,590
ಬಳಸಿಕೊಂಡು heap_array ಶೂನ್ಯ heap_array ಒಂದು.

131
00:06:11,590 --> 00:06:15,800
ಆದರೆ ನಾವು ಹಾಗೆ ಕಾರಣ ಮರುಪಡೆಯಲು
ಏಕೆಂದರೆ ಸಿ ಒಂದು ರಚನೆಯ ಹೆಸರು

132
00:06:15,800 --> 00:06:19,990
ನಿಜವಾಗಿಯೂ ಒಂದು ಪಾಯಿಂಟರ್
ರಚನೆಯ ಮೊದಲ ಅಂಶ.

133
00:06:19,990 --> 00:06:23,480
ನಾವು ಘೋಷಿಸುವ ನೀವು ವಾಸ್ತವವಾಗಿ ಆದ್ದರಿಂದ
ಇಲ್ಲಿ ಸ್ಟಾಕ್ ಫ್ಲೋಟ್ಗಳು ಶ್ರೇಣಿಯನ್ನು

134
00:06:23,480 --> 00:06:24,810
ವಾಸ್ತವವಾಗಿ ಒಂದು ಬಿಟ್ ತಪ್ಪು.

135
00:06:24,810 --> 00:06:27,600
ನಾವು ನಿಜವಾಗಿಯೂ ಇವೆ
ಅಲ್ಲಿ ಕೋಡ್ ಎರಡನೇ ಸಾಲಿನಲ್ಲಿ

136
00:06:27,600 --> 00:06:32,360
ಸಹ ಒಂದು ಪಾಲನ್ನು ಒಂದು ಪಾಯಿಂಟರ್ ರಚಿಸುವ
ನಾವು ನಂತರ ಕೆಲವು ಕೆಲಸ ಮಾಡುವ ಮೆಮೊರಿ.

137
00:06:32,360 --> 00:06:35,620
>> ಇಲ್ಲಿ ದೊಡ್ಡ ಸಮಸ್ಯೆ ಇಲ್ಲಿದೆ
ಸಕ್ರಿಯವಾಗಿ ಆದರೂ ಮೆಮೊರಿ ಹಂಚಿಕೆ,

138
00:06:35,620 --> 00:06:38,360
ಇದು ನಿಜವಾಗಿಯೂ ಏಕೆ ಇದು
ಕೆಲವು ಉತ್ತಮ ಪದ್ಧತಿ ಅಭಿವೃದ್ಧಿ ಮುಖ್ಯ

139
00:06:38,360 --> 00:06:39,800
ನೀವು ಇದು ಕೆಲಸ ಮಾಡುತ್ತಿದ್ದೇವೆ.

140
00:06:39,800 --> 00:06:43,060
ಜಡವಾಗಿ ಘೋಷಿಸಿದರು ಭಿನ್ನವಾಗಿ
ಮೆಮೊರಿ ನಿಮ್ಮ ಮೆಮೊರಿ

141
00:06:43,060 --> 00:06:46,790
ಸ್ವಯಂಚಾಲಿತವಾಗಿ ಹಿಂದಿರುಗುವುದಿಲ್ಲ
ನಿಮ್ಮ ಕಾರ್ಯವನ್ನು ಮಾಡಲಾಗುತ್ತದೆ ಗಣಕವು.

142
00:06:46,790 --> 00:06:49,280
ನಾವು ಮುಖ್ಯ, ಮತ್ತು ಆದ್ದರಿಂದ
ಮುಖ್ಯ ಕಾರ್ಯ ಕರೆಗಳನ್ನು

143
00:06:49,280 --> 00:06:53,860
ಎಫ್, ಪೂರ್ಣಗೊಳಿಸುವಿಕೆ ಎಫ್ ಮಾಡಿದಾಗ ಮಾಡುತ್ತಿದ್ದಾರೆ ಯಾವುದೇ
ಮತ್ತು ಕಾರ್ಯಕ್ರಮದ ನಿಯಂತ್ರಣ ಹಿಂದಿರುಗಿಸುತ್ತದೆ

144
00:06:53,860 --> 00:06:58,810
ಮತ್ತೆ, ಪ್ರಮುಖ ಎಲ್ಲಾ ಮೆಮೊರಿ
ಬಳಸಿದ ಎಫ್ ಮತ್ತೆ ನೀಡಲಾಗಿದೆ.

145
00:06:58,810 --> 00:07:01,250
ಇದು ಮತ್ತೆ ಬಳಸಬಹುದು
ಕೆಲವು ಕಾರ್ಯಕ್ರಮದಲ್ಲಿ ಮೂಲಕ

146
00:07:01,250 --> 00:07:04,250
ಅಥವಾ ಕೆಲವು ಇತರ ಕಾರ್ಯ ಎಂದು
ಮುಖ್ಯ ನಂತರ ಎಂದು ಸಿಗುತ್ತದೆ.

147
00:07:04,250 --> 00:07:06,970
ಮತ್ತೆ ಅದೇ ಮೆಮೊರಿ ಮೇಲೆ ಬಳಸಬಹುದು.

148
00:07:06,970 --> 00:07:09,620
>> ನೀವು ಸಕ್ರಿಯವಾಗಿ
ಆದರೂ ಮೆಮೊರಿ ನಿಯೋಜಿಸಿ

149
00:07:09,620 --> 00:07:14,380
ನೀವು ಸ್ಪಷ್ಟವಾಗಿ ಹೇಳಲು ಹೊಂದಿವೆ
ನೀವು ಪೂರೈಸಿದ ವ್ಯವಸ್ಥೆ.

150
00:07:14,380 --> 00:07:18,370
ಇದು ಇದು ಸಾಧ್ಯವೋ, ನೀವು ಅದನ್ನು ಹಿಡಿದುಕೊಳ್ಳಲು ಮಾಡುತ್ತೇವೆ
ನೀವು ಖಾಲಿಯಾಯ್ತು ಸಮಸ್ಯೆ ಕಾರಣವಾಗಬಹುದು

151
00:07:18,370 --> 00:07:19,290
ಮೆಮೊರಿಯ.

152
00:07:19,290 --> 00:07:22,179
ಮತ್ತು ವಾಸ್ತವವಾಗಿ ನಾವು ಕೆಲವೊಮ್ಮೆ ನೋಡಿ
ಒಂದು ಮೆಮೊರಿ ಸೋರಿಕೆಯಾದಲ್ಲಿ ಈ ಗೆ.

153
00:07:22,179 --> 00:07:24,970
ಮತ್ತು ಕೆಲವೊಮ್ಮೆ ಈ ಮೆಮೊರಿ ಸೋರುವಿಕೆ
ವಾಸ್ತವವಾಗಿ ನಿಜವಾಗಿಯೂ ವಿಧ್ವಂಸಕ ಮಾಡಬಹುದು

154
00:07:24,970 --> 00:07:27,020
ಕಾರ್ಯವೈಖರಿಯನ್ನು ಫಾರ್.

155
00:07:27,020 --> 00:07:31,120
>> ನೀವು ಆಗಾಗ ಇಂಟರ್ನೆಟ್ ಬಳಕೆದಾರರಾಗಿದ್ದಲ್ಲಿ
ನೀವು ಕೆಲವು ವೆಬ್ ಬ್ರೌಸರ್ ಬಳಸಬಹುದು

156
00:07:31,120 --> 00:07:35,630
ಮತ್ತು ನಾನು ಇಲ್ಲಿ ಹೆಸರನ್ನು, ಆದರೆ
ಕೆಲವೊಂದು ವೆಬ್ ಬ್ರೌಸರ್ಗಳು ಇವೆ

157
00:07:35,630 --> 00:07:39,150
ವಾಸ್ತವವಾಗಿ ಹೊಂದಿರುವ ಕುಖ್ಯಾತ ಎಂದು
ಸ್ಥಿರ ಇರುವುದಿಲ್ಲ ಮೆಮೊರಿ ಸೋರುವಿಕೆ.

158
00:07:39,150 --> 00:07:44,570
ಮತ್ತು ನೀವು ನಿಮ್ಮ ಬ್ರೌಸರ್ ತೆರೆಯಿರಿ ಬಿಟ್ಟಲ್ಲಿ
ಸಮಯ ಬಹಳ ದೀರ್ಘ ಕಾಲ, ದಿನಗಳ

159
00:07:44,570 --> 00:07:48,060
ಮತ್ತು ದಿನಗಳು ಅಥವಾ ವಾರಗಳ, ನೀವು ಕೆಲವೊಮ್ಮೆ
ನಿಮ್ಮ ವ್ಯವಸ್ಥೆಯ ಅಂಶವನ್ನು ಗಮನಿಸಬಹುದು

160
00:07:48,060 --> 00:07:49,790
ನಿಜವಾಗಿಯೂ ನಿಧಾನವಾಗಿ, ನಿಜವಾಗಿಯೂ ಚಾಲನೆಯಲ್ಲಿದೆ.

161
00:07:49,790 --> 00:07:54,640
ಮತ್ತು ಆ ಕಾರಣಕ್ಕಾಗಿ ಎಂಬುದು
ಬ್ರೌಸರ್, ಮೆಮೊರಿ ಹಂಚಿಕೆ ಮಾಡಿದೆ

162
00:07:54,640 --> 00:07:57,320
ಆದರೆ ವ್ಯವಸ್ಥೆಯ ಹೇಳಲಿಲ್ಲ
ಅದು ಇದು ನಿಲ್ಲಿಸುವುದಾಗಿ ಅವನು.

163
00:07:57,320 --> 00:08:01,000
ಮತ್ತು ಆದ್ದರಿಂದ ಕಡಿಮೆ ಮೆಮೊರಿ ಎಲೆಗಳು
ನಿಮ್ಮ ಇತರ ಕಾರ್ಯಕ್ರಮಗಳನ್ನು ಎಲ್ಲಾ ಲಭ್ಯವಿದೆ

164
00:08:01,000 --> 00:08:04,480
ನೀವು ಏಕೆಂದರೆ, ಹಂಚಿಕೊಳ್ಳಲು ಹೊಂದಿವೆ
ವೆಬ್ ಬ್ರೌಸರ್ leaking--

165
00:08:04,480 --> 00:08:06,755
ಪ್ರೋಗ್ರಾಂ ಮೆಮೊರಿ ಸೋರಿಕೆ ಇದೆ.

166
00:08:06,755 --> 00:08:08,880
ನಾವು ಮತ್ತೆ ಮೆಮೊರಿ ನೀಡಲು ಇಲ್ಲ
ನಾವು ಪೂರೈಸಿದ?

167
00:08:08,880 --> 00:08:10,838
ಸರಿ ಅದೃಷ್ಟವಶಾತ್ ಒಂದು ಇಲ್ಲಿದೆ
ಇದನ್ನು ಮಾಡಲು ಬಹಳ ಸುಲಭ ರೀತಿಯಲ್ಲಿ.

168
00:08:10,838 --> 00:08:11,710
ನಾವು ಅದನ್ನು ಮುಕ್ತಗೊಳಿಸಲು.

169
00:08:11,710 --> 00:08:15,020
ಉಚಿತ ಎಂಬ ಕಾರ್ಯ ಇಲ್ಲ,
ಇದು, ಮೆಮೊರಿ ಒಂದು ಪಾಯಿಂಟರ್ ಸ್ವೀಕರಿಸುತ್ತದೆ

170
00:08:15,020 --> 00:08:16,010
ಮತ್ತು ನಾವು ಹೋಗಲು ಉತ್ತಮ ಆರ್.

171
00:08:16,010 --> 00:08:18,310
>> ಆದ್ದರಿಂದ ನಾವು ಮಾಡುತ್ತೇವೆ ಹೇಳುತ್ತಾರೆ
ನಮ್ಮ ಕಾರ್ಯಕ್ರಮದ ಮಧ್ಯದಲ್ಲಿ,

172
00:08:18,310 --> 00:08:21,970
ನಾವು 50 ಪಾತ್ರಗಳು malloc ಬಯಸುವ.

173
00:08:21,970 --> 00:08:25,710
ನಾವು ಒಂದು ರಚನೆ malloc ಬಯಸುವ
50 ಪಾತ್ರಗಳು ಹಿಡಿದಿಟ್ಟುಕೊಳ್ಳುವ ಸಾಮರ್ಥ್ಯವನ್ನು.

174
00:08:25,710 --> 00:08:29,109
ಮತ್ತು ನಾವು ಮತ್ತೆ ಒಂದು ಪಾಯಿಂಟರ್ ಪಡೆದಾಗ
ಆ ಪಾಯಿಂಟರ್ ಹೆಸರು ಪದ.

175
00:08:29,109 --> 00:08:30,900
ನಾವು ನೀವು ಏನೇ ಮಾಡಲು
ಪದ ಮಾಡಲು ಹೋಗುವ,

176
00:08:30,900 --> 00:08:33,440
ಮತ್ತು ನಾವು ಇರುವಾಗ
ನಾವು ಅದನ್ನು ಮುಕ್ತಗೊಳಿಸಲು ಮಾಡಲಾಗುತ್ತದೆ.

177
00:08:33,440 --> 00:08:37,460
ಮತ್ತು ಈಗ ನಾವು ಆ 50 ಹಿಂದಿರುಗಿವೆ
ಮತ್ತೆ ವ್ಯವಸ್ಥೆಗೆ ಮೆಮೊರಿ ಬೈಟ್ಗಳು.

178
00:08:37,460 --> 00:08:40,147
ಕೆಲವು ಇತರ ಕಾರ್ಯ ಅವುಗಳನ್ನು ಬಳಸಬಹುದು.

179
00:08:40,147 --> 00:08:43,480
ನಾವು ಒಂದು ಬಳಲುತ್ತಿರುವ ಬಗ್ಗೆ ಚಿಂತೆ ಇಲ್ಲ
ಮೆಮೊರಿ ಸೋರಿಕೆಯಾದಲ್ಲಿ ನಾವು ಪದ ಬಿಡುಗಡೆ ಏಕೆಂದರೆ.

180
00:08:43,480 --> 00:08:46,639
ನಾವು ಮತ್ತೆ ಮೆಮೊರಿ ನೀಡಿದ್ದೇನೆ,
ಆದ್ದರಿಂದ ನಾವು ಅದನ್ನು ಕೆಲಸ ಮುಗಿಸಿದ್ದೀರಿ.

181
00:08:46,639 --> 00:08:48,430
ಆದ್ದರಿಂದ ಮೂರು ಇವೆ
ಎಂದು ಮಾಡಬೇಕು ಗೋಲ್ಡನ್ ನಿಯಮಗಳು

182
00:08:48,430 --> 00:08:51,700
ನೀವು ಬಂದ ಮನದಲ್ಲಿಟ್ಟುಕೊಂಡಿರಬೇಕು
ಸಕ್ರಿಯವಾಗಿ ಮೆಮೊರಿ ಹಂಚುತ್ತಾರೆ

183
00:08:51,700 --> 00:08:52,990
malloc ಜೊತೆ.

184
00:08:52,990 --> 00:08:56,480
ಮೆಮೊರಿ ಪ್ರತಿ ಬ್ಲಾಕ್ ಎಂದು
ನೀವು malloc ಬಿಡುಗಡೆ ಮಾಡಬೇಕು

185
00:08:56,480 --> 00:08:58,430
ನಿಮ್ಮ ಪ್ರೋಗ್ರಾಂ ಮೊದಲು ಚಲಿಸುತ್ತಿರುವ ಮುಗಿಸಿದ.

186
00:08:58,430 --> 00:09:02,029
ಈಗ ಮತ್ತೆ, ಉಪಕರಣಗಳಲ್ಲಿರುವ ಅಥವಾ
ಐಡಿಇ ಈ ರೀತಿಯ ಹೇಗಾದರೂ ನೀವು ನಡೆಯುತ್ತದೆ

187
00:09:02,029 --> 00:09:04,820
you-- ಈ ಹೇಗಾದರೂ ಸಂಭವಿಸುತ್ತದೆ
ನಿಮ್ಮ ಪ್ರೋಗ್ರಾಂ ಸ್ಥಗಿತಗೊಳಿಸಿದರೆ, ಅದು ಬಳಸುತ್ತಿದ್ದ

188
00:09:04,820 --> 00:09:06,880
ಎಲ್ಲಾ ಮೆಮೊರಿ ಬಿಡುಗಡೆಯಾಗಲಿದೆ.

189
00:09:06,880 --> 00:09:10,750
ಆದರೆ ಸಾಮಾನ್ಯವಾಗಿ ಉತ್ತಮ ಕೋಡಿಂಗ್ ಇಲ್ಲಿದೆ
ಅಭ್ಯಾಸ ಯಾವಾಗಲೂ, ನೀವು ಪೂರೈಸಿದಾಗ,

190
00:09:10,750 --> 00:09:13,810
ನೀವು mallocd ಏನು ಮುಕ್ತಗೊಳಿಸಲು.

191
00:09:13,810 --> 00:09:16,690
>> ಎಂದು, ಕೇವಲ ವಿಷಯಗಳನ್ನು
ನೀವು mallocd ಬಿಡುಗಡೆ ಮಾಡಬೇಕು ಬಂದಿದೆ.

192
00:09:16,690 --> 00:09:19,880
ನೀವು ಜಡವಾಗಿ ಘೋಷಿಸಿದ ವೇಳೆ ಒಂದು
ಪೂರ್ಣಾಂಕ, ಇಂಟ್ X ಅರೆ ಕೊಲೊನ್,

193
00:09:19,880 --> 00:09:23,500
ಸ್ಟಾಕ್ ವಾಸಿಸುತ್ತಾನೆ, ನೀವು
ಆಗ x ಮುಕ್ತಗೊಳಿಸಲು ಬಯಸುವುದಿಲ್ಲ.

194
00:09:23,500 --> 00:09:25,970
ನೀವು ಬಂದಿದೆ ಆದ್ದರಿಂದ ಕೇವಲ ವಿಷಯಗಳನ್ನು
mallocd ಬಿಡುಗಡೆ ಮಾಡಬೇಕು.

195
00:09:25,970 --> 00:09:28,960
>> ಮತ್ತು ಕೊನೆಯದಾಗಿ, ಎರಡು ಬಾರಿ ಉಚಿತವಾಗಿ ಏನಾದರೂ.

196
00:09:28,960 --> 00:09:31,170
ಆ ಕಾರಣವಾಗಬಹುದು
ಮತ್ತೊಂದು ವಿಲಕ್ಷಣ ಪರಿಸ್ಥಿತಿ.

197
00:09:31,170 --> 00:09:33,530
ನೀವು ಮಾಡಿದ ಎಂದು ಆದ್ದರಿಂದ ಎಲ್ಲವೂ
mallocd ಬಿಡುಗಡೆ ಮಾಡಬೇಕು.

198
00:09:33,530 --> 00:09:36,000
ನೀವು ಬಂದಿದೆ ಮಾತ್ರ ವಸ್ತುಗಳು
malloc ಬಿಡುಗಡೆ ಮಾಡಬೇಕು.

199
00:09:36,000 --> 00:09:38,730
ಮತ್ತು ಎರಡು ಬಾರಿ ಉಚಿತವಾಗಿ ಏನಾದರೂ.

200
00:09:38,730 --> 00:09:43,660
>> ಆದ್ದರಿಂದ ಇಲ್ಲಿ ಒಂದು ಉದಾಹರಣೆಗೆ ಮೂಲಕ ಹೋಗಲು ಅವಕಾಶ
ಕೆಲವು ಕ್ರಿಯಾತ್ಮಕವಾಗಿ ನಿಯೋಜಿತವಾದ ಏನು

201
00:09:43,660 --> 00:09:46,122
ಮೆಮೊರಿ ಮಿಶ್ರ ರೀತಿ ಇರಬಹುದು
ಕೆಲವು ಸ್ಥಿರ ಮೆಮೊರಿ ರಲ್ಲಿ.

202
00:09:46,122 --> 00:09:47,080
ಇಲ್ಲಿ ಏನು ಆಗಬಹುದೆಂದು?

203
00:09:47,080 --> 00:09:48,913
ನೀವು ಅನುಸರಿಸಬಹುದು ನೋಡಲು
ಜೊತೆಗೆ ಮತ್ತು ಇಲ್ಲಿದೆ ಊಹೆ

204
00:09:48,913 --> 00:09:51,720
ನಾವು ಹೋಗಿ ಎಂದು ಸಂಭವಿಸಿ ಹೋಗಿ
ಕೋಡ್ ಎಲ್ಲಾ ಈ ಸಾಲುಗಳ ಮೂಲಕ.

205
00:09:51,720 --> 00:09:53,980
>> ನಾವು ಇಂಟ್ ಮೀ ಹೇಳುತ್ತಾರೆ.

206
00:09:53,980 --> 00:09:54,840
ಇಲ್ಲಿಗೆ ಯಾವ ನಡೆಯುತ್ತದೆ?

207
00:09:54,840 --> 00:09:56,339
ಈ ಸಾಕಷ್ಟು ನೇರವಾಗಿರುತ್ತದೆ.

208
00:09:56,339 --> 00:09:59,650
ನಾನು ಮೀ ಎಂಬ ಪೂರ್ಣಾಂಕ ವೇರಿಯಬಲ್ ರಚಿಸಲು.

209
00:09:59,650 --> 00:10:01,400
ನಾನು ಹಸಿರು ಬಣ್ಣ
ಆ ಬಣ್ಣ ಏಕೆಂದರೆ

210
00:10:01,400 --> 00:10:03,730
ನಾನು ಬಾಗುತ್ತೇನೆ ನಾನು ಬಳಸುವ
ಬಗ್ಗೆ ಪೂರ್ಣಾಂಕ ಅಸ್ಥಿರ.

211
00:10:03,730 --> 00:10:05,160
ಇದು ಒಂದು ಬಾಕ್ಸ್ ಇಲ್ಲಿದೆ.

212
00:10:05,160 --> 00:10:08,400
ನೀವು ಮಾಡಬಹುದು ಮೀ ಎಂದು, ಮತ್ತು ವಿಶೇಷವೇನು
ಅದರ ಒಳಗೆ ಅಂಗಡಿ ಪೂರ್ಣಾಂಕಗಳ.

213
00:10:08,400 --> 00:10:12,400
>> ನಾನು ನಂತರ ಇಂಟ್ ನಕ್ಷತ್ರ ಏನು ಹೇಳಬಹುದು ವೇಳೆ?

214
00:10:12,400 --> 00:10:13,530
ಸರಿ ಸಾಕಷ್ಟು ಹೋಲುವ ಇಲ್ಲಿದೆ.

215
00:10:13,530 --> 00:10:15,780
ನಾನು ಬಾಕ್ಸ್ ಎಂಬ ರಚಿಸಲು ನಾನು.

216
00:10:15,780 --> 00:10:19,100
ಹಿಡಿದಿರುವುದು ಇಂಟ್ ಸಾಮರ್ಥ್ಯವನ್ನು
ನಕ್ಷತ್ರಗಳು, ಪೂರ್ಣಾಂಕಗಳ ಪಾಯಿಂಟರ್ಸ್.

217
00:10:19,100 --> 00:10:21,570
ಆದ್ದರಿಂದ ನಾನು ಸಹ ಹಸಿರು ರೀತಿಯಲ್ಲಿ ಬಣ್ಣ ಬಾಗುತ್ತೇನೆ.

218
00:10:21,570 --> 00:10:24,140
>> ನಾನು ಏನೋ ಹೊಂದಿದೆ ತಿಳಿಯಲು
ಒಂದು ಪೂರ್ಣಾಂಕ ಮಾಡಲು,

219
00:10:24,140 --> 00:10:25,852
ಆದರೆ ಇದು ಒಂದು ಪೂರ್ಣಾಂಕ ಅಲ್ಲ ಸ್ವತಃ ಇಲ್ಲಿದೆ.

220
00:10:25,852 --> 00:10:27,310
ಆದರೆ ಅದು ಬಹುಮಟ್ಟಿಗೆ ಇದೇ ಉಪಾಯ.

221
00:10:27,310 --> 00:10:28,101
ನಾನು ಬಾಕ್ಸ್ ರಚಿಸಿದ.

222
00:10:28,101 --> 00:10:30,070
ಈ ಬಲ ಎರಡೂ
ಈಗ ಸ್ಟಾಕ್ ವಾಸಿಸುತ್ತಿದ್ದಾರೆ.

223
00:10:30,070 --> 00:10:32,520
ನಾನು ಅವರನ್ನು ಎರಡೂ ಹೆಸರುಗಳು ನೀಡಿದ್ದೇನೆ.

224
00:10:32,520 --> 00:10:36,750
>> ಇಂಟ್ ನಕ್ಷತ್ರ ಬಿ ಇಂಟ್ malloc ಗಾತ್ರ ಸಮನಾಗಿರುತ್ತದೆ.

225
00:10:36,750 --> 00:10:38,560
ಈ ಒಂದು ಸ್ವಲ್ಪ ಟ್ರಿಕಿ ಇರಬಹುದು.

226
00:10:38,560 --> 00:10:44,110
ಎರಡನೇ ಟೇಕ್ ಮತ್ತು ನೀವು ಏನು ಆಲೋಚಿಸುತ್ತೀರಿ
ಈ ರೇಖಾಚಿತ್ರದಲ್ಲಿ ಏನಾಗುವುದು ನಿರೀಕ್ಷಿಸಬಹುದು.

227
00:10:44,110 --> 00:10:50,210
ಇಂಟ್ ನಕ್ಷತ್ರ ಬಿ ಇಂಟ್ malloc ಗಾತ್ರ ಸಮನಾಗಿರುತ್ತದೆ.

228
00:10:50,210 --> 00:10:51,940
>> ಈ ಕೇವಲ ಒಂದು ಬಾಕ್ಸ್ ರಚಿಸಲು ಇಲ್ಲ.

229
00:10:51,940 --> 00:10:53,800
ಈ ವಾಸ್ತವವಾಗಿ ಎರಡು ಪೆಟ್ಟಿಗೆಗಳು ಸೃಷ್ಟಿಸುತ್ತದೆ.

230
00:10:53,800 --> 00:10:58,670
ಮತ್ತು ಇದು ಇದು ಸ್ಥಾಪಿಸುತ್ತದೆ, ಕಟ್ಟುತ್ತಾನೆ
ಸಂಬಂಧ ಒಂದು ಪಾಯಿಂಟ್.

231
00:10:58,670 --> 00:11:02,240
ನಾವು ಒಂದು ಬ್ಲಾಕ್ ಮಂಜೂರು ಮಾಡಿದ
ರಾಶಿ ಮೆಮೊರಿಯ.

232
00:11:02,240 --> 00:11:05,940
ಗಮನಿಸಿ ಬಲ ಟಾಪ್ ಬಾಕ್ಸ್
ಒಂದು ಹೆಸರು ಅಲ್ಲಿ ಹೊಂದಿಲ್ಲ.

233
00:11:05,940 --> 00:11:06,760
>> ನಾವು ಇದು mallocd.

234
00:11:06,760 --> 00:11:08,050
ಅದನ್ನು ರಾಶಿ ಅಸ್ತಿತ್ವದಲ್ಲಿದೆ.

235
00:11:08,050 --> 00:11:10,090
ಆದರೆ ಬಿ ಹೆಸರನ್ನು ಹೊಂದಿದೆ.

236
00:11:10,090 --> 00:11:11,950
ಇದು ಬಿ ಎಂಬ ಪಾಯಿಂಟರ್ ವೇರಿಯೇಬಲ್ ನ.

237
00:11:11,950 --> 00:11:13,910
ಸ್ಟಾಕ್ ವಾಸಿಸುತ್ತಾನೆ.

238
00:11:13,910 --> 00:11:18,250
>> ಆದ್ದರಿಂದ ಮೆಮೊರಿಯ ಒಂದು ತುಣುಕು ಇಲ್ಲಿದೆ
ಮತ್ತೊಂದು ಒಂದು ಸೂಚಿತವಾಗಿರುತ್ತದೆ.

239
00:11:18,250 --> 00:11:21,840
ಬಿ ವಿಳಾಸವನ್ನು ಹೊಂದಿರುತ್ತದೆ
ಮೆಮೊರಿ ಬ್ಲಾಕ್.

240
00:11:21,840 --> 00:11:23,757
ಇಲ್ಲವಾದಲ್ಲಿ ಒಂದು ಹೆಸರನ್ನು ಹೊಂದಿಲ್ಲ.

241
00:11:23,757 --> 00:11:24,590
ಆದರೆ ಇದು ಸೂಚಿತವಾಗಿರುತ್ತದೆ.

242
00:11:24,590 --> 00:11:29,760
ಆದ್ದರಿಂದ ನಾವು ಇಂಟ್ ಸ್ಟಾರ್ ಬಿ ಸಮನಾಗಿರುತ್ತದೆ ಹೇಳಬೇಕಾದಾಗ
ಇಂಟ್ malloc ಗಾತ್ರ, ಅಲ್ಲಿಯೇ,

243
00:11:29,760 --> 00:11:33,490
ಮೇಲೆ ತುಂಬಿವೆ ಎಂದು ಬಾಣದ
ಅಲ್ಲಿ ಬಲಭಾಗದ ಎಂದು ಇಡೀ ವಿಷಯ,

244
00:11:33,490 --> 00:11:36,740
ನಾನು ಕಾಣಿಸಿಕೊಳ್ಳುತ್ತವೆ ಮಾಡುತ್ತೇವೆ
ಮತ್ತೆ, ಹಾಗೆಯೇ ಆಗುತ್ತದೆ.

245
00:11:36,740 --> 00:11:39,341
ಆ ಎಲ್ಲಾ ಸಂಭವಿಸುತ್ತದೆ
ಕೋಡ್ ಆ ಸಾಲಿನ.

246
00:11:39,341 --> 00:11:41,340
ಈಗ ನಾವು ಸ್ವಲ್ಪ ಹೆಚ್ಚು ಪಡೆಯುತ್ತೀರಿ
ಮತ್ತೆ ನೇರ.

247
00:11:41,340 --> 00:11:43,330
ಒಂದು ವನ್ನಾಗಲಿ ಮೀ ಸಮನಾಗಿರುತ್ತದೆ.

248
00:11:43,330 --> 00:11:46,280
ನೀವು ಏನು ಒಂದು ನೆನಪಿದೆಯೇ
ವನ್ನಾಗಲಿ ಮೀ ಸಮ?

249
00:11:46,280 --> 00:11:48,920
ಸರಿ ಒಂದು ಮೀ ವಿಳಾಸ ಪಡೆಯುತ್ತದೆ.

250
00:11:48,920 --> 00:11:54,150
ಅಥವಾ, ಹೆಚ್ಚು ರೇಖಾಚಿತ್ರವಾಗಿ ಪುಟ್
ಮೀ ಅಂಕಗಳನ್ನು.

251
00:11:54,150 --> 00:11:56,360
>> ಒಂದು ಬಿ ಸಮನಾಗಿರುತ್ತದೆ.

252
00:11:56,360 --> 00:11:57,560
ಸರಿ ಇಲ್ಲಿ ಇನ್ನೊಂದು ಒಂದು ಇಲ್ಲಿದೆ.

253
00:11:57,560 --> 00:11:59,230
ಒಬ್ಬ ಬಿ ಸಮನಾಗಿರುತ್ತದೆ.

254
00:11:59,230 --> 00:12:02,260
ಏನು ತೀರುತ್ತದೆ
ರೇಖಾಚಿತ್ರ ಈ ಬಾರಿ?

255
00:12:02,260 --> 00:12:04,330
>> ಸರಿ ಸ್ಮರಿಸುತ್ತಾರೆ
ಹುದ್ದೆ ಆಯೋಜಕರು ಕೃತಿಗಳು

256
00:12:04,330 --> 00:12:08,960
ಮೇಲೆ ಮೌಲ್ಯ ನಿಯೋಜಿಸುವ ಮೂಲಕ
ಬಲ ಎಡ ಮೌಲ್ಯಕ್ಕೆ.

257
00:12:08,960 --> 00:12:14,820
ಮೀ ಆದ್ದರಿಂದ ಬದಲಿಗೆ ಒಂದು ತೋರುಗಡ್ಡಿ, ಈಗ
ಬಿ ಅಂಕಗಳನ್ನು ಅದೇ ಸ್ಥಳದಲ್ಲಿ ಸೂಚಿತವಾಗಿರುತ್ತದೆ.

258
00:12:14,820 --> 00:12:18,900
ಒಂದು, ಒಂದು B ಬಿಂದುವಿನವರೆಗೆ ಇಲ್ಲ
ಅಲ್ಲಿ ಬೌ ಅಂಕಗಳನ್ನು ಸೂಚಿಸುತ್ತದೆ.

259
00:12:18,900 --> 00:12:25,280
>> ಚೂಪಾದ ಎಂದು ಬೌ ವೇಳೆ ಎಂದು
ಒಂದು ವನ್ನಾಗಲಿ ಬಿ ಸಮನಾಗಿರುತ್ತದೆ ಎಂದು.

260
00:12:25,280 --> 00:12:28,150
ಬದಲಿಗೆ ಒಂದು ಬೌ ಮೇಲೆ ಕೇವಲ ಸಮನಾಗಿರುತ್ತದೆ
ಅರ್ಥ ಮತ್ತು ಬಿ ಈಗ

261
00:12:28,150 --> 00:12:31,770
, ಒಂದೇ ವಿಳಾಸ ಏಕೆಂದರೆ ಸೂಚಿಸುವ
ಬಿ ಒಳಗೆ ಕೇವಲ ಒಂದು ವಿಳಾಸ.

262
00:12:31,770 --> 00:12:35,004
ಈಗ ಒಂದು ಒಳಗೆ ಅದೇ ವಿಳಾಸ.

263
00:12:35,004 --> 00:12:37,170
ಮೀ ಬಹುಶಃ = 10
ಹೆಚ್ಚಿನ ನೇರ ವಿಷಯ

264
00:12:37,170 --> 00:12:38,690
ನಾವು ಸ್ವಲ್ಪ ಮಾಡಿದ.

265
00:12:38,690 --> 00:12:40,460
ಬಾಕ್ಸ್ 10 ಹಾಕಿ.

266
00:12:40,460 --> 00:12:45,640
ಸ್ಟಾರ್ ಬೌ ಮೀ ಸಮನಾಗಿರುತ್ತದೆ ಜೊತೆಗೆ 2, ಮರುಪಡೆಯಲು
ನಮ್ಮ ಪಾಯಿಂಟರ್ಸ್ ವೀಡಿಯೊ ಏನು ಸ್ಟಾರ್ ಬಿ ಅರ್ಥ.

267
00:12:45,640 --> 00:12:50,230
ನಾವು dereference ಬಿ ಮತ್ತು ಹಾಕಲು ನೀನು
ಮೆಮೊರಿ ಸ್ಥಳ ಕೆಲವು ಮೌಲ್ಯವನ್ನು.

268
00:12:50,230 --> 00:12:51,860
ಈ ಸಂದರ್ಭದಲ್ಲಿ 12 ರಲ್ಲಿ.

269
00:12:51,860 --> 00:12:55,300
>> ಆದ್ದರಿಂದ ನಾವು ಒಂದು ಪಾಯಿಂಟ್ dereference
ನಾವು ಬಾಣದ ಕೆಳಗೆ ಪ್ರಯಾಣ ನೆನಪಿಸಿಕೊಳ್ಳುತ್ತಾರೆ.

270
00:12:55,300 --> 00:12:58,205
ಅಥವಾ ಇನ್ನೊಂದು ರೀತಿಯಲ್ಲಿ ಹೇಳುವುದಾದರೆ, ನಾವು
ಮೆಮೊರಿ ವಿಳಾಸಕ್ಕೆ ಹೋಗಿ

271
00:12:58,205 --> 00:12:59,580
ಮತ್ತು ನಾವು ಕೆಲವು ರೀತಿಯಲ್ಲಿ ಕುಶಲತೆಯಿಂದ.

272
00:12:59,580 --> 00:13:00,830
ನಾವು ಅಲ್ಲಿ ಕೆಲವು ಮೌಲ್ಯವನ್ನು ಪುಟ್.

273
00:13:00,830 --> 00:13:03,960
ಈ ಸಂದರ್ಭದಲ್ಲಿ ಸ್ಟಾರ್ ಬಿ
ಮೀ ಸಮನಾಗಿರುತ್ತದೆ ಜೊತೆಗೆ 2 ಕೇವಲ

274
00:13:03,960 --> 00:13:08,230
ವೇರಿಯಬಲ್ ಹೋಗಿ, ಬಿ ಮೂಲಕ ತೋರಿಸಿದರು
ಮೆಮೊರಿ ಹೋಗಿ, ಬಿ ಮೂಲಕ ತೋರಿಸಿದರು

275
00:13:08,230 --> 00:13:11,750
ಮತ್ತು 12, ಹಾಗಾದರೆ ಮೀ ಜೊತೆಗೆ 2 ಪುಟ್.

276
00:13:11,750 --> 00:13:14,970
>> ಈಗ ನಾನು ಬಿ ಫ್ರೀ.

277
00:13:14,970 --> 00:13:16,490
ನಾನು ಬಿ ಫ್ರೀ ಏನಾಗುತ್ತದೆ?

278
00:13:16,490 --> 00:13:18,800
ನಾನು ಮುಕ್ತ ಎಂದರೆ ಏನು ಹೇಳಿದರು ನೆನಪಿಡಿ.

279
00:13:18,800 --> 00:13:21,920
ನಾನು ಬಿ ಫ್ರೀ ನಾನು ಹೇಳುತ್ತಿರುವುದು?

280
00:13:21,920 --> 00:13:23,410
>> ನಾನು ಕೆಲಸ ಇದನ್ನು ಬಾಗುತ್ತೇನೆ?

281
00:13:23,410 --> 00:13:25,702
ನಾನು ಮೂಲಭೂತವಾಗಿ ಮೆಮೊರಿ ಬಿಟ್ಟುಕೊಡಲು.

282
00:13:25,702 --> 00:13:26,910
ನಾನು ವ್ಯವಸ್ಥೆಗೆ ಇದು ಮತ್ತೆ ನೀಡಿ.

283
00:13:26,910 --> 00:13:33,010
ನಾನು ಈ ಎಲ್ಲಿಯೂ ಅಗತ್ಯವಿಲ್ಲ
ನಾನು ಅದರಲ್ಲಿ ಹೇಳುವ ನಾನು?

284
00:13:33,010 --> 00:13:37,390
>> ಈಗ ನಾನು ಹೇಳಲು ಸ್ಟಾರ್
11 ನೀವು ಬಹುಶಃ ಮಾಡಬಹುದು ಸಮನಾಗಿರುತ್ತದೆ

285
00:13:37,390 --> 00:13:40,460
ಈಗಾಗಲೇ ಕೆಟ್ಟ ಏನೋ ಹೇಳಲು
ಇಲ್ಲಿಗೆ ಯಾವ ಸಂಭವಿಸಿ ಹೋಗುವ ಇದೆ?

286
00:13:40,460 --> 00:13:44,160
ಮತ್ತು ನಾನು ಬಹುಶಃ ಪ್ರಯತ್ನಿಸಿದರು ನಿಜಕ್ಕೂ
ಒಂದು ಸೆಗ್ಮೆಂಟೇಶನ್ ದೋಷಕ್ಕೆ ತೊಂದರೆಯಾಗಬಹುದು.

287
00:13:44,160 --> 00:13:47,140
ಈಗ ಏಕೆಂದರೆ, ಆದರೂ
ಮೆಮೊರಿ ಹಿಂದೆ ಪಡೆ

288
00:13:47,140 --> 00:13:50,220
ನಾನು ಹೊಂದಿತ್ತು ಏನೋ
ಈ ಹಂತದಲ್ಲಿ ಪ್ರವೇಶವನ್ನು,

289
00:13:50,220 --> 00:13:54,590
ಈಗ ನಾನು ಮೆಮೊರಿ ಪ್ರವೇಶಿಸುವ ಬಾಗುತ್ತೇನೆ
ನನಗೆ ಪ್ರವೇಶಿಸಲು ಕಾನೂನು ಅಲ್ಲ.

290
00:13:54,590 --> 00:13:57,330
>> ಮತ್ತು ನಾವು ಬಹುಶಃ
ನಾವು ಮೆಮೊರಿ ಪ್ರವೇಶಿಸುವಾಗ, ಮರುಪಡೆಯಲು

291
00:13:57,330 --> 00:14:00,000
ನಾವು ಸ್ಪರ್ಶಕ್ಕೆ ಭಾವಿಸಲಾದ ಇಲ್ಲ ಎಂದು,
ಸಾಮಾನ್ಯ ಕಾರಣ ಇಲ್ಲಿದೆ

292
00:14:00,000 --> 00:14:01,860
ಒಂದು ಸೆಗ್ಮೆಂಟೇಶನ್ ಆಫ್
ತಪ್ಪು. ಆದ್ದರಿಂದ ನನ್ನ ಪ್ರೋಗ್ರಾಂ

293
00:14:01,860 --> 00:14:05,170
ನಾನು ಈ ಮಾಡಲು ಯತ್ನಿಸಿದರೆ ಹಾನಿಯಾಗುತ್ತಿತ್ತು.

294
00:14:05,170 --> 00:14:09,910
ಆದ್ದರಿಂದ ಮತ್ತೆ ಉತ್ತಮ ಪಡೆಯಲು ಒಳ್ಳೆಯದು
ಅಭ್ಯಾಸ ಮತ್ತು ಉತ್ತಮ ಆಹಾರ ಬೇರುಬಿಟ್ಟ

295
00:14:09,910 --> 00:14:12,920
malloc ಮತ್ತು ಉಚಿತ ಕೆಲಸ ಮಾಡುವಾಗ,
ಆದ್ದರಿಂದ ನೀವು ವಿಭಜನೆ ಬಳಲುತ್ತಿದ್ದಾರೆ ಎಂದು

296
00:14:12,920 --> 00:14:15,310
ನೀವು ಬಳಸಲು, ಮತ್ತು ದೋಷಗಳು
ನಿಮ್ಮ ಕ್ರಿಯಾತ್ಮಕವಾಗಿ ನಿಯೋಜಿತವಾದ

297
00:14:15,310 --> 00:14:17,370
ಮೆಮೊರಿ ಜವಾಬ್ದಾರಿಯುತವಾಗಿ.

298
00:14:17,370 --> 00:14:20,300
>> ನಾನು ಡೌಗ್ ಲಾಯ್ಡ್ ಮನುಷ್ಯ ಈ CS50 ಹೊಂದಿದೆ.

299
00:14:20,300 --> 00:14:21,947