1
00:00:00,000 --> 00:00:00,410

2
00:00:00,410 --> 00:00:03,130
>> ಡೇವಿಡ್ ಜೆ MALAN: ಆದ್ದರಿಂದ ಇದು ತಿರುಗಿದರೆ ಎಂದು
ಸ್ಟ್ರಿಂಗ್ ನಕಲು ಸುಮಾರು ಅಲ್ಲ

3
00:00:03,130 --> 00:00:05,750
ಒಂದು ಆದಿಮ ನಕಲು ಸರಳ
ಒಂದು ಇಂಟ್ ಅಥವಾ ಫ್ಲೋಟ್ ಹಾಗೆ.

4
00:00:05,750 --> 00:00:09,190
ಎಲ್ಲಾ ನಂತರ, HOOD ಕೆಳಗೆ ಸ್ಟ್ರಿಂಗ್
ಅನುಕ್ರಮ ಅಕ್ಷರಗಳು.

5
00:00:09,190 --> 00:00:13,130
ಆದ್ದರಿಂದ ಒಂದು ಸಾಲನ್ನು ನಕಲು ಆದ್ದರಿಂದ, ಹೊಂದಿದೆ
ಇಡೀ ಸರಣಿಯ ನಕಲು ಒಳಗೊಂಡಿರುತ್ತವೆ

6
00:00:13,130 --> 00:00:14,240
ಪಾತ್ರಗಳು.

7
00:00:14,240 --> 00:00:17,470
>> ನ ಮತ್ತೆ ನಮ್ಮ ಗಮನ ತಿರುಗಿ ಲೆಟ್
ಕಳೆದ ಅನುಷ್ಠಾನ ಮತ್ತು ಈ ನಕಲು ಮಾಡ

8
00:00:17,470 --> 00:00:21,470
ಲೈನ್, ಸ್ಟ್ರಿಂಗ್ ಟಿ, ರು ಸಮಾನವಾಗಿದೆ
ಸ್ಪಷ್ಟವಾಗಿ ಸಾಕಷ್ಟು ಅಲ್ಲ.

9
00:00:21,470 --> 00:00:24,440
ತಂದೆಯ ಲೈನ್ ಅದನ್ನು ಬದಲಾಯಿಸಲು ಅವಕಾಶ
ಈ ರೀತಿಯ, ಬದಲಿಗೆ, ಕಾಣುತ್ತದೆ.

10
00:00:24,440 --> 00:00:34,020
ಸ್ಟ್ರಿಂಗ್ ಟಿ ಸ್ಟ್ರಿಂಗ್ ಉದ್ದದ ಆಫ್, malloc ಪಡೆಯುತ್ತದೆ
ಒಂದು ಚಾರ್ ಎಸ್ ಪ್ಲಸ್ 1 ಬಾರಿ ಗಾತ್ರ.

11
00:00:34,020 --> 00:00:36,320
>> ಈಗ ಹೋಗುವ ಸ್ವಲ್ಪ ಉಲ್ಲೇಖ ಇಲ್ಲ
ಕೋಡ್ ಈ ಸಾಲಿನಲ್ಲಿ ಮೇಲೆ.

12
00:00:36,320 --> 00:00:39,330
ಮೊದಲ,, malloc, ಸಣ್ಣ ಮೆಮೊರಿ
ಹಂಚಿಕೆ, ಮತ್ತು

13
00:00:39,330 --> 00:00:40,700
ಕಾರ್ಯವನ್ನು ಕೇವಲ ಮಾಡುತ್ತದೆ.

14
00:00:40,700 --> 00:00:44,740
ಒಂದು ಪೂರ್ಣಾಂಕ ನೀಡಲಾಗಿದೆ, ಇದು ನೀವು ಹಿಂದಿರುಗುತ್ತಾನೆ
ಮೆಮೊರಿ ಒಂದು ಚಂಕ್ ವಿಳಾಸವನ್ನು

15
00:00:44,740 --> 00:00:45,960
ಅನೇಕ ಬೈಟ್ಗಳು.

16
00:00:45,960 --> 00:00:50,090
ಏತನ್ಮಧ್ಯೆ, ಸ್ಟ್ರಿಂಗ್ ರು ಉದ್ದ ಜೊತೆಗೆ 1
ನಾವು ಬಯಸುವ ಸೂಚಿಸುತ್ತದೆ ಅರ್ಥ ಇದೆ

17
00:00:50,090 --> 00:00:54,690
ಗಳು ಈಗಾಗಲೇ ಆಕ್ರಮಿಸಿದೆ ಅನೇಕ ಬೈಟ್ಗಳು,
ಅದರ ಶೂನ್ಯ ಟರ್ಮಿನೇಟರ್, ಸೇರಿದಂತೆ

18
00:00:54,690 --> 00:00:57,050
ಒಂದು ಸ್ಟ್ರಿಂಗ್ ಕೊನೆಯಲ್ಲಿ ಬ್ಯಾಕ್ಸ್ಲ್ಯಾಷ್ 0.

19
00:00:57,050 --> 00:01:00,170
>> ಏತನ್ಮಧ್ಯೆ, ನಾನು ಅಗತ್ಯವಾಗಿ ನೆನಪಿರುವುದಿಲ್ಲ
ಚಾರ್ ಸಹ, ಎಷ್ಟು ದೊಡ್ಡ

20
00:01:00,170 --> 00:01:04,340
ಹೆಚ್ಚಿನ ವ್ಯವಸ್ಥೆಗಳಲ್ಲಿ ಇದು ಕೇವಲ 1 ಆದರೂ
ಬೈಟ್, ಆದ್ದರಿಂದ ನಾನು ಚಾರ್ ಗಾತ್ರ ಕರೆ ಮಾಡುತ್ತೇವೆ

21
00:01:04,340 --> 00:01:08,210
ಕ್ರಿಯಾತ್ಮಕವಾಗಿ ಲೆಕ್ಕಾಚಾರ ಹೇಗೆ ದೊಡ್ಡ
ವ್ಯಕ್ತಿಯ ಪಾತ್ರ.

22
00:01:08,210 --> 00:01:12,550
ಒಮ್ಮೆ ಒಟ್ಟಿಗೆ ಗುಣಿಸಿದಾಗ, ನಾನು ಹಿಂದೆ
ನಾನು ಅಗತ್ಯವಿರುವ ಬೈಟ್ಗಳು ಒಟ್ಟು ಸಂಖ್ಯೆಯ.

23
00:01:12,550 --> 00:01:14,680
>> ಆದರೆ malloc ಏನು ವಿಫಲವಾದಲ್ಲಿ
ನಾವು ಅಗತ್ಯವಿದೆ ಮೆಮೊರಿ ಮರಳಲು?

24
00:01:14,680 --> 00:01:16,730
ಕೆಳಗಿನಂತೆ ನಾನು ಉತ್ತಮ ಎಂದು ಪರಿಶೀಲಿಸಿ ಬಯಸುವ.

25
00:01:16,730 --> 00:01:23,330
ಟಿ ಶೂನ್ಯ ಸಮನಾಗಿರುತ್ತದೆ ವೇಳೆ, ನಂತರ ನಾನು ಮೊದಲ ಪಡೆಯಲಿದ್ದೇನೆ
ಉಚಿತ ರು ಮೆಮೊರಿ ಪಡೆಯಲು ಮೂಲಕ ಮರಳಿದರು

26
00:01:23,330 --> 00:01:27,120
ಸ್ಟ್ರಿಂಗ್, ಮತ್ತು ನಂತರ ನಾನು ಪಡೆಯಲಿದ್ದೇನೆ
ದೋಷ ಸೂಚಿಸುವುದಕ್ಕಾಗಿ, 1 ಹಿಂತಿರುಗಿ.

27
00:01:27,120 --> 00:01:30,360
>> ಎಲ್ಲಾ ಚೆನ್ನಾಗಿ ಆದರೆ, ನಾನು ಮುಂದುವರಿಯಲು ಪಡೆಯಲಿದ್ದೇನೆ
ನಾಲ್ಕು ಲೂಪ್ ಅನ್ನು ಮತ್ತು ತಿರುಗಿ

28
00:01:30,360 --> 00:01:31,110
ಕೆಳಗಿನಂತೆ.

29
00:01:31,110 --> 00:01:36,000
ಇಂಟ್ ನಾನು 0, N ಸಮ ಪಡೆಯಲು
ರು ಸ್ಟ್ರಿಂಗ್ ಉದ್ದ.

30
00:01:36,000 --> 00:01:40,350
ನಾನು ಬಹಳ ನಾನು ಎಂದು ಈ ಮಾಡಲು ಪಡೆಯಲಿದ್ದೇನೆ
ಕಡಿಮೆ ಅಥವಾ N ಸಮಾನವಾಗಿರುತ್ತದೆ ಆದ್ದರಿಂದ ನಾನು

31
00:01:40,350 --> 00:01:44,460
ಮೂಲಕ ಸೇರಿದಂತೆ ತಿರುಗಿ
ರು ಶೂನ್ಯ ಕೊನೆಗೊಳಿಸುವ ಪಾತ್ರ.

32
00:01:44,460 --> 00:01:47,450
>> ಮತ್ತು ಪ್ರತಿಯೊಂದು ಪುನರಾವರ್ತನೆ ಮೇಲೆ, ನಾನು
ನಾನು ಹೆಚ್ಚಿಸಲು ಹೋಗುವ.

33
00:01:47,450 --> 00:01:52,496
ಏತನ್ಮಧ್ಯೆ, ಈ ಲೂಪ್ ಒಳಗೆ, ನಕಲಿಸಿ
ಟಿ ನ I-ನೇ ಒಳಗೆ ಗಳು ನ I-ನೇ ಅಕ್ಷರ

34
00:01:52,496 --> 00:01:59,310
ಸ್ಥಳ, ಇದು ಟಿ ಮಾಡುವುದು ಸಾಕು
ಬ್ರಾಕೆಟ್ ನಾನು ಗಳು ಬ್ರಾಕೆಟ್ ನಾನು ಪಡೆಯುತ್ತದೆ.

41
00:01:59,320 --> 00:02:02,750
>> ಈಗ, ಉಳಿಸಲು ಕಂಪೈಲ್ ಲೆಟ್, ಮತ್ತು
ಈ ಹೊಸ ಪ್ರೋಗ್ರಾಂ.

42
00:02:02,750 --> 00:02:06,690
ಪ್ರತಿಯನ್ನು 1 ಡಾಟ್ ಕತ್ತರಿಸಿ ಪ್ರತಿಯನ್ನು 1 ಮಾಡಿ.

43
00:02:06,690 --> 00:02:09,460
ನಾನು ಏನೋ ಹೇಳುವ ಮಾಡುತ್ತೇವೆ
ಹಲೋ ಎಲ್ಲಾ ಸಣ್ಣ ರಲ್ಲಿ.

44
00:02:09,460 --> 00:02:12,280
ಮತ್ತು Thankfully, ಈ ಬಾರಿ ನನ್ನ
ಮೂಲ ಬದಲಾಗದೇ ಉಳಿದಿದೆ.

45
00:02:12,280 --> 00:02:13,660
ಹಲೋ ಎಲ್ಲಾ ಸಣ್ಣ ರಲ್ಲಿ.

46
00:02:13,660 --> 00:02:15,540
ಆದರೆ ಪ್ರತಿಯನ್ನು, ವಾಸ್ತವವಾಗಿ, ದೊಡ್ಡಕ್ಷರವಾಗಿ.

47
00:02:37,120 --> 00:02:38,963