Module ā§§ā§Ē ¡ Dynamic memory
Dynamic memory āĻā§āύ: āϝ⧠āĻŽāĻžāĻĒāĻāĻž āĻāĻā§ āĻĨā§āĻā§ āĻāĻžāύāĻž āύā§āĻ
āĻāĻ lesson-āĻ āϝāĻž āĻļāĻŋāĻāĻŦā§
- āĻŦāϞāϤ⧠āĻĒāĻžāϰāĻŦā§, āϝ⧠āĻŽāĻžāĻĒ āĻļā§āϧ⧠program āĻāϞāĻžāϰ āϏāĻŽāϝāĻŧ āĻāĻžāύāĻž āϝāĻžāϝāĻŧ āϤāĻžāϰ āĻāύā§āϝ dynamic memory āĻā§āύ āϞāĻžāĻā§, āĻāϰ capacity constant āĻŦāĻž āĻŦāĻŋāĻļāĻžāϞ static array-āϰ āĻāϰāĻāĻāĻž āĻā§āĻĨāĻžāϝāĻŧāĨ¤
malloc(n * sizeof *marks)āϞāĻŋāĻāϤ⧠āĻĒāĻžāϰāĻŦā§, āĻĢāϞāĻžāĻĢāϞāĻāĻžNULLāĻāĻŋ āύāĻž check āĻāϰāϤ⧠āĻĒāĻžāϰāĻŦā§, block-āĻāĻž array-āϰ āĻŽāϤ⧠āĻŦā§āϝāĻŦāĻšāĻžāϰ āĻāϰā§freeāĻĻāĻŋāϝāĻŧā§ āĻĢā§āϰāϤ āĻĻāĻŋāϤ⧠āĻĒāĻžāϰāĻŦā§āĨ¤- Memory-āϰ āĻāĻŦāĻŋāϤ⧠heap āĻā§āĻĨāĻžāϝāĻŧ āĻĻā§āĻāĻžāϤ⧠āĻĒāĻžāϰāĻŦā§, āĻāϰ āĻŦāϞāϤ⧠āĻĒāĻžāϰāĻŦā§ Playground-āĻ allocation fail āĻāϰāϞ⧠āĻā§āĻŽāύ āĻĻā§āĻāĻžāϝāĻŧāĨ¤
Module 9-āĻāϰ project-āĻ Amara-āϰ marks report āĻĒā§āϰ⧠āĻā§āϞāĻžāϏāĻāĻž āϰāĻžāĻāϤ int marks[MAX_S][MAX_M]-āĻ, āĻāϰ MAX_S āĻāĻŋāϞ 100āĨ¤ 101 āĻāύ āĻāĻžāϤā§āϰā§āϰ āĻāĻāĻāĻž sheet āĻĻāĻŋāϞ⧠āĻĢā§āϰāϤ āĻāϏāϤ āĻŽāĻžāϤā§āϰ āĻĻā§āĻāĻāĻž āĻļāĻŦā§āĻĻ: invalid sizeāĨ¤
āĻāĻŦāĻžāϰ āĻ āĻĢāĻŋāϏ āĻŦāϞāĻā§ āύāĻž āĻā§āϞāĻžāϏ⧠āĻāϤāĻāύāĨ¤ Sheet-āĻāϰ āĻĒā§āϰāĻĨāĻŽ āϞāĻžāĻāύ⧠āϏāĻāĻā§āϝāĻžāĻāĻž āĻĨāĻžāĻāĻŦā§, āĻāϰ āϏā§āĻāĻž 12-āĻ āĻšāϤ⧠āĻĒāĻžāϰā§, 3,000-āĻ āĻšāϤ⧠āĻĒāĻžāϰā§āĨ¤
Array-āϰ āĻŽāĻžāĻĒ āĻ āĻŋāĻ āĻšāϝāĻŧā§ āϝāĻžāϝāĻŧ program compile āĻšāĻāϝāĻŧāĻžāϰ āĻāĻā§āĻ, āĻ āĻĨāĻ āĻāĻ āϏāĻāĻā§āϝāĻžāĻāĻž āĻāϏ⧠input-āĻāϰ āϏāĻžāĻĨā§āĨ¤ āĻāĻ lesson āϏāĻāĻā§āϝāĻžāĻāĻž āĻāĻžāύāĻžāϰ āĻĒāϰā§āĻ āĻŦāĻžāĻā§āϏāĻā§āϞ⧠āĻā§āϝāĻŧā§ āύā§āϝāĻŧāĨ¤
āϝ⧠āĻŽāĻžāĻĒ āĻāĻā§ āĻĨā§āĻā§ āĻāĻžāύāĻž āύā§āĻ, āϤāĻžāϰ āϤāĻŋāύāĻāĻž āĻāϤā§āϤāϰ
āĻĒā§āϰāĻĨāĻŽ āĻĻā§āĻāĻāĻž āĻāϤā§āϤāϰ Module 9-āĻāϰ, āϤā§āϤā§āϝāĻŧāĻāĻž āĻāĻ module-āĻāϰāĨ¤
| āĻāϤā§āϤāϰ | Code-āĻ | āĻāϰāĻāĻāĻž āĻā§ |
|---|---|---|
| āĻāĻāĻāĻž capacity constant | #define MAX_S 100, āϤāĻžāϰāĻĒāϰ int marks[MAX_S]; | āĻāĻāĻĻāĻŋāύ āĻā§āĻ āĻĒāĻĄāĻŧāĻŦā§āĻ: 101 āύāĻŽā§āĻŦāϰ āĻāĻžāϤā§āϰ āĻĒāĻžāϝāĻŧ invalid size |
āĻŦāĻŋāĻļāĻžāϞ āĻāĻāĻāĻž static array | static int marks[1000000]; | āĻāĻžāĻĻ āϤāĻŦā§āĻ āĻāĻā§, āĻāϰ āϤā§āϰāĻŋāĻļāĻāύāĻā§ āϰāĻžāĻāϤ⧠code āĻĻāĻžāĻŦāĻŋ āĻāϰ⧠āĻĻāĻļ āϞāĻžāĻ āĻāĻžāϤā§āϰā§āϰ āĻāĻĨāĻž |
| āĻāϞāĻžāϰ āϏāĻŽāϝāĻŧ āĻā§āϝāĻŧā§ āύā§āĻāϝāĻŧāĻž | malloc(n * sizeof *marks) | āĻ āĻŋāĻ n-āĻāĻž āĻŦāĻžāĻā§āϏ; āĻāϤā§āϤāϰāĻāĻž check āĻāϰāϤ⧠āĻšāϝāĻŧ, āĻāϰ block-āĻāĻž āĻĢā§āϰāϤ āĻĻāĻŋāϤ⧠āĻšāϝāĻŧ |
Constant āύāĻŋāĻā§āϰ āϏā§āĻŽāĻž āύāĻŋāϝāĻŧā§ āϏā§, āĻāϰ āϏāĻŽāϏā§āϝāĻžāĻāĻž āĻāĻ āϏā§āĻŽāĻžāϤā§āĻāĨ¤ āϝā§āĻĻāĻŋāύ āϏā§āĻā§āϞ āĻĻā§āĻāĻāĻž āĻā§āϞāĻžāϏ āĻāĻ āĻāϰ⧠āĻĻā§āĻŦā§, āϏā§āĻĻāĻŋāύ program āĻāϏāϞ data-āĻ āĻĢāĻŋāϰāĻŋāϝāĻŧā§ āĻĻā§āĻŦā§āĨ¤
āĻŦāĻŋāĻļāĻžāϞ static array-āϰ āĻāϰāĻ āĻĻā§āĻāϤ⧠āϝāϤāĻāĻž, āĻāϏāϞ⧠āϤāϤāĻāĻž āύāĻžāĨ¤ Module 9-āĻāϰ lesson 3 Playground-āĻ 280 MB-āϰ āĻāĻāĻāĻž static array āĻŽā§āĻĒā§āĻāĻŋāϞ, āĻāϰ āϏā§āĻāĻž pass āĻāϰā§āĻāĻŋāϞ āĻŽāĻžāϤā§āϰ 416 KB āĻāϰāĻ āĻāϰā§āĨ¤ Operating system memory āĻĻā§āϝāĻŧ 4,096 byte-āĻāϰ āĻāĻ āĻāĻāĻāĻž page āϧāϰā§, āĻāϰ āĻāĻāĻāĻž page āĻā§āύ⧠āϤāĻāύāĻ, āϝāĻāύ program āĻĒā§āϰāĻĨāĻŽāĻŦāĻžāϰ āĻāĻāĻž āĻā§āĻāϝāĻŧāĨ¤ āϤāĻžāĻ āĻāϏāϞ āĻāϰāĻ āĻšāϞ⧠āĻĨā§āĻā§ āϝāĻžāĻāϝāĻŧāĻž āĻāĻžāĻĻāĻāĻž, āĻāϰ āĻāĻŽāύ āĻāĻāĻāĻž program, āϝā§āĻāĻž "āϝāϤāĻāύāĻ āĻšā§āĻ" āĻŦā§āĻāĻžāϤ⧠āϞā§āĻā§ "āĻĻāĻļ āϞāĻžāĻ"āĨ¤
malloc n read āĻāϰāĻžāϰ āĻĒāϰ⧠āĻ āĻŋāĻ n-āĻāĻž āĻŦāĻžāĻā§āϏ āĻāĻžāϝāĻŧ, code-āĻ āĻā§āύ⧠āĻāĻžāĻĻ āϞā§āĻāĻž āĻĨāĻžāĻā§ āύāĻžāĨ¤ āĻŦāĻĻāϞ⧠āĻāϏ⧠āĻĻā§āĻāĻāĻž āύāϤā§āύ āĻĻāĻžāϝāĻŧāĻŋāϤā§āĻŦ: āϝāĻž āĻĢā§āϰāϤ āĻāϞ āϏā§āĻāĻž check āĻāϰāĻž, āĻāϰ āĻāĻžāĻ āĻļā§āώ⧠block-āĻāĻž āĻĢā§āϰāϤ āĻĻā§āĻāϝāĻŧāĻžāĨ¤
āϤāĻžāĻ constant āĻāϰ static array āĻĻā§āĻā§āĻ āĻāĻžāĻĻāĻāĻž āĻŦā§āĻāϧ⧠āĻĻā§āϝāĻŧ compile-āĻāϰ āϏāĻŽāϝāĻŧ, āĻāϰ malloc āĻŽāĻžāĻĒāĻāĻž āĻ āĻŋāĻ āĻāϰ⧠program āĻāϞāĻžāϰ āϏāĻŽāϝāĻŧāĨ¤
Heap: Module 11 āϝ⧠box-āĻāĻž dashed āĻāĻāĻā§āĻāĻŋāϞ
Module 7-āĻāϰ lesson 5 memory-āϰ āϤā§āϤā§āϝāĻŧ āĻāĻāĻāĻž āĻāĻžāϝāĻŧāĻāĻžāϰ āĻāĻĨāĻž āĻĻāĻŋāϝāĻŧā§āĻāĻŋāϞ, āĻāϰ Module 11-āĻāϰ lesson 1 āĻāĻāĻž āĻāĻāĻā§āĻāĻŋāϞ dashed āĻāĻāĻāĻž box āĻšāĻŋāϏā§āĻŦā§, āĻāĻžāϝāĻŧā§ āϞā§āĻāĻž Module 14āĨ¤ āĻāĻāĻžāĻ heap: memory-āϰ āĻāĻāĻāĻž āĻāϞāĻžāĻāĻž, āϝā§āĻāĻžāύ āĻĨā§āĻā§ program āĻāϞāĻžāϰ āϏāĻŽāϝāĻŧ āĻā§āĻāϰ⧠āĻā§āĻāϰ⧠āĻāϰ⧠āĻāĻžāϝāĻŧāĻāĻž āĻā§āϝāĻŧā§ āύā§āϝāĻŧāĨ¤
āĻā§āϝāĻŧā§ āύā§āĻāϝāĻŧāĻžāĻā§ āĻŦāϞ⧠allocate āĻāϰāĻž, āĻāϰ āĻāĻāĻāĻž āĻā§āĻāϰā§āĻā§ āĻŦāϞ⧠block: āĻĒāĻžāĻļāĻžāĻĒāĻžāĻļāĻŋ āĻŦāϏāĻžāύ⧠āĻāĻŋāĻā§ byte, āύāĻžāĻŽ āĻāĻžāĻĄāĻŧāĻž āĻāĻāĻāĻž array-āϰ āĻŽāϤā§āĨ¤ āĻāĻāĻžāĻŦā§ āϏāĻžāĻŽāϞāĻžāύ⧠memory-āĻā§ āĻŦāϞ⧠dynamic memory, āĻāĻžāϰāĻŖ āĻāϰ āĻŽāĻžāĻĒ āĻāϰ āĻāϝāĻŧā§ āĻĻā§āĻā§āĻ āĻ āĻŋāĻ āĻšāϝāĻŧ program āĻāϞāĻžāϰ āϏāĻŽāϝāĻŧāĨ¤
āĻāĻāĻāĻž block-āĻ āĻĒā§āĻāĻāĻžāĻ āĻāĻāĻāĻž pointer āĻĻāĻŋāϝāĻŧā§, āϝā§āĻāĻž āĻāϰ address āϧāϰ⧠āϰāĻžāĻā§, āĻāϰ āĻāĻ pointer āĻāĻāĻāĻž āϏāĻžāϧāĻžāϰāĻŖ localāĨ¤ āĻāĻŦāĻŋāϤ⧠marks āĻŦāϏ⧠āĻāĻā§ stack-āĻ, main-āĻāϰ frame-āĻ, āĻāϰ āĻ āϝ⧠āĻĒāĻžāĻāĻāĻāĻž āĻŦāĻžāĻā§āϏ āĻĻā§āĻāĻžāĻā§āĻā§ āϏā§āĻā§āϞ⧠āĻāĻā§ heap-āĻāĨ¤
Program āϝāϤ āĻāĻžāϝāĻŧ, heap āϤāϤ āĻāĻĒāϰā§āϰ āĻĻāĻŋāĻā§ āĻŦāĻžāĻĄāĻŧā§, āĻāϰ stack āĻŦāĻžāĻĄāĻŧā§ āύāĻŋāĻā§āϰ āĻĻāĻŋāĻā§ (Module 8-āĻāϰ lesson 2)āĨ¤ C library heap-āĻāĻž āĻā§āĻāĻžāĻŦā§ āĻŦāĻĄāĻŧ āĻāϰā§, āϏā§āĻāĻž āĻĻā§āĻāĻžāĻŦā§ lesson 6āĨ¤
āĻāĻāĻāĻž local āĻŽāĻžāϰāĻž āϝāĻžāϝāĻŧ āĻāϰ function-āĻāϰ closing brace-āĻāĨ¤ āĻāĻāĻāĻž block āĻĨāĻžāĻā§ āϝāϤāĻā§āώāĻŖ āύāĻž program āĻāĻāĻžāϰ āĻāĻĒāϰ free call āĻāϰā§, āϤāĻžāĻ āĻāĻāĻāĻž function block allocate āĻāϰ⧠āĻāϰ address return āĻāϰāϤ⧠āĻĒāĻžāϰā§āĨ¤ Example 2 āĻ āĻŋāĻ āĻāĻāĻžāĻ āĻāϰā§āĨ¤
āϤāĻžāĻ pointer-āĻāĻž stack-āĻāϰ āĻāĻāĻāĻž local, āĻāϰ āĻ āϝ⧠āĻŦāĻžāĻā§āϏāĻā§āϞ⧠āĻĻā§āĻāĻžāϝāĻŧ āϏā§āĻā§āϞ⧠heap-āĻ āĻĨāĻžāĻā§, āϝāϤāĻā§āώāĻŖ āύāĻž āϤā§āĻŽāĻŋ free āĻāϰā§āĨ¤
malloc, āĻ āĻāĻļ āϧāϰ⧠āϧāϰ⧠āĻĒāĻĄāĻŧāĻž
malloc ("memory allocate"-āĻāϰ āĻā§āĻ āϰā§āĻĒ) āĻāϏ⧠<stdlib.h> āĻĨā§āĻā§āĨ¤ āĻ āύā§āϝāĻŧ āĻāϝāĻŧ byte āϞāĻžāĻāĻŦā§, āĻāϰ return āĻāϰ⧠āĻāĻāĻāĻž āύāϤā§āύ block-āĻāϰ āĻĒā§āϰāĻĨāĻŽ byte-āĻāϰ addressāĨ¤ Block āĻĻāĻŋāϤ⧠āύāĻž āĻĒāĻžāϰāϞ⧠return āĻāϰ⧠NULLāĨ¤
n-āĻāĻž āĻŦāĻžāĻā§āϏ āĻāĻžāĻāϝāĻŧāĻž
int *marks = malloc(n * sizeof *marks);
- File-āĻāϰ āĻŽāĻžāĻĨāĻžāϝāĻŧ
#include <stdlib.h>āĻĨāĻžāĻāϞā§mallocāĻāϰfreedeclare āĻšāϝāĻŧāĨ¤ āĻāĻāĻž āύāĻž āĻĨāĻžāĻāϞ⧠āĻā§ āĻšāϝāĻŧ, āĻĻā§āĻāĻžāĻŦā§ āĻā§āϞ 1āĨ¤ malloc(...)āύā§āϝāĻŧ byte-āĻ āĻāĻāĻāĻž āĻŽāĻžāĻĒ, āĻŽāĻžāύ⧠āĻāĻāĻāĻžsize_t, āĻāϰ return āĻāϰ⧠āĻāĻāĻāĻžvoid *: C-āϰ āϏāĻžāϧāĻžāϰāĻŖ address type (Module 11-āĻāϰ lesson 1)āĨ¤int *marks =āĻāĻ address-āĻāĻž āϰā§āĻā§ āĻĻā§āϝāĻŧāĨ¤ C āύāĻŋāĻā§āĻvoid *-āĻā§int *āĻŦāĻžāύāĻŋāϝāĻŧā§ āύā§āϝāĻŧ, āϤāĻžāĻ cast āϞāĻžāĻā§ āύāĻžāĨ¤sizeof *marksāĻšāϞā§marksāϝ⧠āĻŦāĻžāĻā§āϏ āĻĻā§āĻāĻžāϝāĻŧ, āϤāĻžāϰ āĻāĻāĻāĻžāϰ āĻŽāĻžāĻĒ: āĻāĻāĻāĻžint-āĻāϰ āĻāύā§āϝ 4 byteāĨ¤ āĻāϤ⧠āĻŦāύā§āϧāύ⧠āϞāĻžāĻā§ āύāĻž, āϝā§āĻŽāύ Module 13 āϞāĻŋāĻā§āĻāĻŋāϞsizeof lineāĨ¤n *āĻšāϞ⧠āĻā§āύāϤāĻŋāĨ¤ āĻāĻā§ āĻā§āύāϤāĻŋ, āϤāĻžāϰāĻĒāϰ āĻāĻāĻāĻž āĻŦāĻžāĻā§āϏā§āϰ āĻŽāĻžāĻĒ: 4 byte āĻāϰ⧠n-āĻāĻž āĻŦāĻžāĻā§āϏāĨ¤
sizeof(int) āĻā§āύ āύāĻž? āĻāĻāĻžāύ⧠āĻĻā§āĻā§āĻ 4 āĻĻā§āϝāĻŧāĨ¤ āĻāĻŋāύā§āϤ⧠āĻĒāϰ⧠marks āϝāĻĻāĻŋ long long * āĻšāϝāĻŧā§ āϝāĻžāϝāĻŧ, sizeof *marks āύāĻŋāĻā§ āĻĨā§āĻā§āĻ 8 āĻšāϝāĻŧā§ āϝāĻžāĻŦā§āĨ¤ sizeof(int) āĻĨā§āĻā§ āϝāĻžāĻŦā§ 4, āĻāϰ block āĻšāĻŦā§ āĻĻāϰāĻāĻžāϰā§āϰ āĻ
āϰā§āϧā§āĻāĨ¤ āĻŦāύā§āϧāύ⧠āϞāĻžāĻā§ āĻļā§āϧ⧠type-āĻāϰ āύāĻžāĻŽā§āϰ āĻāĻžāϰāĻĒāĻžāĻļā§āĨ¤
āĻĒā§āϰ⧠idiom-āĻāĻž āĻĻā§āĻā§ Amara-āϰ program-āĻ, āϝā§āĻāĻž āĻĒā§āϰāĻĨāĻŽ āĻāϰ āĻļā§āώ āύāĻŽā§āĻŦāϰāĻāĻž print āĻāϰā§āĨ¤
#include <stdio.h>
#include <stdlib.h>
int main(void)
{
int n = 0;
int *marks = NULL;
if (scanf("%d", &n) != 1 || n < 1) {
printf("no marks\n");
return 0;
}
marks = malloc(n * sizeof *marks);
if (marks == NULL) {
fprintf(stderr, "out of memory\n");
return 1;
}
for (int i = 0; i < n; i++) {
scanf("%d", &marks[i]);
}
printf("students: %d\n", n);
printf("first mark: %d, last mark: %d\n", marks[0], marks[n - 1]);
free(marks);
return 0;
}
students: 5
first mark: 90, last mark: 51
āĻāĻ output-āĻāĻž input 5, āϤāĻžāϰāĻĒāϰ 90 72 64 88 51-āĻāϰ āĻāύā§āϝāĨ¤ n = 5 āĻšāϞ⧠call-āĻāĻž āĻāĻžāϝāĻŧ 5 à 4 = 20 byteāĨ¤ āĻā§āύ⧠command line-āĻāĻ āĻā§āύ⧠āĻŦāĻžāϰā§āϤāĻž āύā§āĻ: Playground, -Wall āĻāϰ -Wall -Wextra, āϏāĻŦāĻžāĻ āĻā§āĻĒāĨ¤
āϤāĻžāĻ malloc(n * sizeof *marks) āĻā§āϰ⧠āĻĒāĻĄāĻŧāϞ⧠āĻĻāĻžāĻāĻĄāĻŧāĻžāϝāĻŧ: "n-āĻāĻž āĻŦāĻžāĻā§āϏ, āĻĒā§āϰāϤāĻŋāĻāĻž marks āϝ⧠āĻŦāĻžāĻā§āϏ āĻĻā§āĻāĻžāϝāĻŧ āϤāĻžāϰ āĻŽāĻžāĻĒā§āϰāĨ¤"
āĻāϤā§āϤāϰāĻāĻž check āĻāϰā§: NULL, āĻāϰ Playground-āĻ āĻā§ fail āĻāϰā§
malloc block āĻĻāĻŋāϤ⧠āύāĻž āĻĒāĻžāϰāϞ⧠return āĻāϰ⧠NULL, āϏā§āĻ pointer āϝā§āĻāĻž āĻā§āĻĨāĻžāĻ āĻĻā§āĻāĻžāϝāĻŧ āύāĻž (Module 11-āĻāϰ lesson 2)āĨ¤ NULL āĻĻāĻŋāϝāĻŧā§ write āĻāϰāĻž undefined behaviour, āϤāĻžāĻ āĻāĻ track āĻĒā§āϰāϤāĻŋāĻāĻž allocation-āĻāϰ āĻ āĻŋāĻ āĻĒāϰā§āϰ āϞāĻžāĻāύā§āĻ check āĻāϰā§āĨ¤ main-āĻ check-āĻāĻž stderr-āĻ out of memory print āĻāϰ⧠1 return āĻāϰā§āĨ¤
āĻāĻŽāύāĻāĻž āĻāϤ āĻāύ āĻāύ āĻšāϝāĻŧ? āϤā§āĻŽāĻŋ āϝāĻž āĻāĻžāĻŦāĻ āϤāĻžāϰ āĻā§āϝāĻŧā§ āĻāĻŽāĨ¤ Live Playground-āĻ āĻŽā§āĻĒā§ āĻĻā§āĻāĻž āĻā§āĻā§, āϝā§āĻāĻžāύ⧠memory limit 256,000 KB:
| Program āϝāĻž āĻāϰā§āĻā§ | Playground āϝāĻž āĻĻā§āĻāĻŋāϝāĻŧā§āĻā§ |
|---|---|
malloc āĻĻāĻŋāϝāĻŧā§ 1,024 MB, āĻāĻŋāĻā§āĻ āϞā§āĻāĻž āĻšāϝāĻŧāύāĻŋ | āĻāĻāĻāĻž pointer, NULL āύāĻž |
malloc āĻĻāĻŋāϝāĻŧā§ 5 GB, āĻāĻŋāĻā§āĻ āϞā§āĻāĻž āĻšāϝāĻŧāύāĻŋ | āĻāĻāĻāĻž pointer, āĻāϰ āĻĒā§āϰ⧠run-āĻ āĻāϰāĻ 384 KB |
malloc āĻĻāĻŋāϝāĻŧā§ 6 GB | NULL |
| 240 MB allocate, āĻĒā§āϰāϤāĻŋāĻāĻž page-āĻ āĻāĻ byte āϞā§āĻāĻž | Success, Memory: 246,564 KB |
| 300 MB allocate, āĻĒā§āϰāϤāĻŋāĻāĻž page-āĻ āĻāĻ byte āϞā§āĻāĻž | Memory limit exceeded, āĻāϰ āĻā§āύ⧠output-āĻ āύā§āĻ |
āĻŦāĻžāĻāϞāĻž page-āĻ āĻāĻ āĻĻā§āĻāĻāĻž badge āĻŦāĻžāĻāϞāĻžāϝāĻŧ āϞā§āĻāĻž āĻĨāĻžāĻā§āĨ¤
āϤāĻžāĻ malloc āĻĻā§āϝāĻŧ address-āĻāϰ āĻāĻžāϝāĻŧāĻāĻž, memory āύāĻžāĨ¤ Limit āĻļā§āϧ⧠āϏā§āĻ page-āĻā§āϞ⧠āĻā§āύ⧠āϝā§āĻā§āϞ⧠program āĻā§āĻāϝāĻŧ, āĻ āĻŋāĻ āϝ⧠āύāĻŋāϝāĻŧāĻŽā§ Module 9-āĻāϰ static array pass āĻāϰā§āĻāĻŋāϞāĨ¤ Limit-āĻāϰ āĻ
āύā§āĻ āĻŦā§āĻļāĻŋ āĻāĻžāĻāϞā§āĻ pointer āĻĒāĻžāĻāϝāĻŧāĻž āϝāĻžāϝāĻŧ, āĻāϰ run āĻĨāĻžāĻŽā§ āϤāĻāύ, āϝāĻāύ program āĻŦā§āĻļāĻŋ āĻāĻžāϝāĻŧāĻāĻžāϝāĻŧ āϞāĻŋāĻā§ āĻĢā§āϞā§āĨ¤ NULL āĻāϏā§āĻā§ āĻļā§āϧ⧠āϏā§āĻ request-āĻ, āϝā§āĻāĻž āĻŽā§āĻļāĻŋāύ āϏā§āĻāĻž āύāĻž āĻāϰ⧠āĻĻāĻŋāϝāĻŧā§āĻā§; āϏā§āĻŽāĻžāĻāĻž āĻŽā§āĻļāĻŋāύāĻā§āĻĻā§ āϏāϰ⧠āϝāĻžāϝāĻŧ, āϝā§āĻŽāύ Compiler Explorer-āĻ 12 GB-āϤ⧠pointer āĻāϏā§āĻā§, āĻāϰ 16 GB-āϤ⧠NULLāĨ¤
āϤāĻžāĻšāϞ⧠check āĻā§āύ? āĻāĻžāϰāĻŖ āĻāĻŋāĻā§ request āϏāϤā§āϝāĻŋāĻ fail āĻāϰā§, āĻāϰ āϤāĻžāϰ āĻāĻāĻāĻž āĻā§āϞ āĻāϰ⧠āĻŦāĻžāύāĻŋāϝāĻŧā§ āĻĢā§āϞāĻž āĻā§āĻŦ āϏāĻšāĻāĨ¤ Zara āĻ
āĻĻā§āĻā§āϤ input āĻĻāĻŋāϝāĻŧā§āĻ āĻāĻā§ test āĻāϰā§, āϤāĻžāĻ āĻ āĻāĻ program-āĻā§ āĻĻā§āϝāĻŧ -1āĨ¤
#include <stdio.h>
#include <stdlib.h>
int main(void)
{
int n = 0;
int *marks = NULL;
if (scanf("%d", &n) != 1) {
return 1;
}
marks = malloc(n * sizeof *marks);
if (marks == NULL) {
printf("malloc returned NULL for n = %d\n", n);
return 1;
}
printf("got a block for n = %d\n", n);
free(marks);
return 0;
}
āĻā§āύ⧠command line-āĻāĻ āĻā§āύ⧠āĻŦāĻžāϰā§āϤāĻž āύā§āĻāĨ¤ Live Playground-āĻ āĻŽā§āĻĒā§ āĻĻā§āĻāĻž āĻā§āĻā§, run print āĻāϰā§āĻā§ malloc returned NULL for n = -1, āĻāϰ return 1; āĻĻā§āĻāĻŋāϝāĻŧā§āĻā§ Runtime error (āĻŦāĻžāĻāϞāĻž page-āĻ badge-āĻāĻž āĻŦāĻžāĻāϞāĻžāϝāĻŧ āϞā§āĻāĻž āĻĨāĻžāĻā§), āϏāĻžāĻĨā§ Exit: 1āĨ¤ sizeof āĻĻā§āϝāĻŧ unsigned āĻāĻāĻāĻž size_t, āϤāĻžāĻ -1 āĻā§āϰ⧠āĻāĻŋāϝāĻŧā§ āĻšāϝāĻŧā§ āϝāĻžāϝāĻŧ āϏāĻŦāĻā§āϝāĻŧā§ āĻŦāĻĄāĻŧ size_tāĨ¤ 4 āĻĻāĻŋāϝāĻŧā§ āĻā§āĻŖ āĻāϰāϞ⧠āϏā§āĻāĻž 18,446,744,073,709,551,612 byteāĨ¤
-1-āĻāĻž āϝāĻĻāĻŋ input āĻĨā§āĻā§ āύāĻž āĻāϏ⧠program-āĻāĻ āϞā§āĻāĻž āĻĨāĻžāĻā§, GCC 12 compile āĻāϰāĻžāϰ āϏāĻŽāϝāĻŧāĻ āĻŽāĻžāĻĒāĻāĻž āĻĻā§āĻāϤ⧠āĻĒāĻžāϝāĻŧāĨ¤ Playground āϏā§āĻāĻž āĻĻā§āĻāĻžāϝāĻŧ amber āϰāĻā§āϰ Compile output tab-āĻ: warning: argument 1 value '18446744073709551612' exceeds maximum object size 9223372036854775807 [-Walloc-size-larger-than=]āĨ¤ Input āĻĨā§āĻā§ read āĻāϰāϞ⧠āĻāĻāĻ āĻā§āϞ⧠āĻā§āύ⧠āϏāĻžāĻĄāĻŧāĻžāĻļāĻŦā§āĻĻ āύā§āĻ, āϤāĻžāĻ n check āĻāϰāĻžāϰ āĻĻāĻžāϝāĻŧāĻŋāϤā§āĻŦ program-āĻāϰ āύāĻŋāĻā§āϰāĨ¤
āĻāĻāύā§āϝāĻ āĻāĻĒāϰā§āϰ Amara-āϰ program āĻāĻā§ n < 1 āĻĒāϰā§āĻā§āώāĻž āĻāϰā§: -1 āĻŦāĻž 0 āĻĒā§āϞ⧠āĻ print āĻāϰ⧠no marks, āĻāϰ malloc call-āĻ āĻāϰ⧠āύāĻžāĨ¤ NULL check-āĻāĻžāĻ āĻĨāĻžāĻā§, āĻāĻŽ āĻāĻžāϝāĻŧāĻāĻžāϰ āĻŽā§āĻļāĻŋāύā§āϰ āĻāύā§āϝ, āĻāϰ āĻŽāĻžāϏā§āϰ āĻĒāϰ āĻŽāĻžāϏ āϧāϰ⧠āĻāĻžāĻāϤ⧠āĻĨāĻžāĻāĻž program-āĻāϰ āĻāύā§āϝāĨ¤ āϝ⧠program āϧāϰ⧠āύā§āϝāĻŧ malloc āĻāĻāύ⧠fail āĻāϰ⧠āύāĻž, āϏ⧠āĻāĻāύ⧠Zara-āϰ āĻĒāĻžāϞā§āϞāĻžāϝāĻŧ āĻĒāĻĄāĻŧā§āύāĻŋāĨ¤
āϤāĻžāĻ allocate āĻāϰāĻžāϰ āĻāĻā§ n check āĻāϰā§, āĻāϰ āĻĒāϰ⧠pointer-āĻāĻžāĨ¤
Block-āĻāĻž array-āϰ āĻŽāϤ⧠āĻŦā§āϝāĻŦāĻšāĻžāϰ āĻāϰā§, āϤāĻžāϰāĻĒāϰ free āĻāϰā§
Check āĻĒāĻžāϰ āĻšāϞ⧠block-āĻāĻž āĻ āĻŋāĻ āĻāĻāĻāĻž array-āϰ āĻŽāϤā§āĻ āĻŦā§āϝāĻŦāĻšāĻžāϰ āĻšāϝāĻŧāĨ¤ marks[i] āĻŽāĻžāύ⧠*(marks + i) (Module 11-āĻāϰ lesson 3): block-āĻāϰ address āĻĨā§āĻā§ āĻļā§āϰ⧠āĻāϰā§, i āĻŦāĻžāĻā§āϏ āĻāĻā§āĻ, āĻāϰ āϏā§āĻāĻžāύāĻāĻžāϰ āĻŦāĻžāĻā§āϏāĻāĻž āĻŦā§āϝāĻŦāĻšāĻžāϰ āĻāϰā§āĨ¤ Index āĻāϞ⧠0 āĻĨā§āĻā§ n - 1 āĻĒāϰā§āϝāύā§āϤ, āϝā§āĻā§āύ⧠array-āϰ āĻŽāϤā§āĻ, āĻāϰ āĻā§āĻ āϤā§āĻŽāĻžāϰ āĻšāϝāĻŧā§ āϏā§āĻāĻž check āĻāϰ⧠āύāĻžāĨ¤
āĻāĻžāĻ āĻļā§āώ āĻšāϞ⧠free(marks) block-āĻāĻž āĻĢā§āϰāϤ āĻĻā§āϝāĻŧ allocator-āĻā§, āĻŽāĻžāύ⧠C library-āϰ āϏā§āĻ āĻ
āĻāĻļāĻā§ āϝā§āĻāĻž block āĻŦāĻŋāϞāĻŋ āĻāϰā§āĨ¤ āĻāϰāĻĒāϰ marks āĻāĻāĻāĻž dangling pointer (Module 11-āĻāϰ lesson 7): āĻāϤ⧠āĻāĻāĻāĻž address āĻāĻā§ āĻ āĻŋāĻāĻ, āĻāĻŋāύā§āϤ⧠block-āĻāĻž āĻāϰ āϤā§āĻŽāĻžāϰ āύāĻžāĨ¤ āϝ⧠pointer āĻĒāϰā§āĻ āĻŦā§āϝāĻŦāĻšāĻžāϰ āĻšāĻŦā§, āϤāĻžāϰ āĻāύā§āϝ lesson 2 āϝā§āĻ āĻāϰāĻŦā§ marks = NULL;; āĻ āĻŋāĻ return-āĻāϰ āĻāĻā§ āĻļā§āϧ⧠free-āĻ āϝāĻĨā§āώā§āĻāĨ¤
āϝ⧠block-āĻā§ āĻāϰ āĻā§āĻ āĻĻā§āĻāĻžāϝāĻŧ āύāĻž, āĻ
āĻĨāĻ āĻāĻāύ⧠free āĻāϰāĻž āĻšāϝāĻŧāύāĻŋ, āϏā§āĻāĻž āĻāĻāĻāĻž leakāĨ¤ Leak output-āĻ āĻāĻŋāĻā§āĻ āĻŦāĻĻāϞāĻžāϝāĻŧ āύāĻžāĨ¤ Program āĻļā§āώ āĻšāϞ⧠operating system āĻāϰ āϏāĻŦ page āĻĢā§āϰāϤ āύāĻŋāϝāĻŧā§ āύā§āϝāĻŧāĨ¤ āϤāĻžāĻ Playground-āĻ āĻāĻāĻāĻž free āĻŦāĻžāĻĻ āĻĒāĻĄāĻŧāϞ⧠āĻā§āĻā§ āĻĒāĻĄāĻŧāĻžāϰ āĻŽāϤ⧠āĻā§āύ⧠āĻā§āώāϤāĻŋ āĻšāϝāĻŧ āύāĻžāĨ¤
āϤāĻŦā§āĻ āĻ
āĻā§āϝāĻžāϏāĻāĻž āĻāϰā§āϰāĻŋ, āĻāĻžāϰāĻŖ āϏāĻŦ program āĻļā§āώ āĻšāϝāĻŧ āύāĻžāĨ¤ āĻāĻāĻāĻž web server āĻŽāĻžāϏā§āϰ āĻĒāϰ āĻŽāĻžāϏ āĻāϞā§, āĻāϰ āĻĒā§āϰāϤāĻŋāĻāĻž request-āĻāϰ āĻāύā§āϝ allocate āĻāϰā§āĨ¤ āĻĒā§āϰāϤāĻŋāĻāĻž request āϝāĻĻāĻŋ āĻāĻāĻāĻž āĻāϰ⧠block leak āĻāϰā§, āĻāϰ memory āĻŦāĻžāĻĄāĻŧāϤā§āĻ āĻĨāĻžāĻā§, āϝāϤāĻā§āώāĻŖ āύāĻž āĻŽā§āĻļāĻŋāύ āĻāϰ āĻĻāĻŋāϤ⧠āϰāĻžāĻāĻŋ āĻšāϝāĻŧ; āĻāĻŽāύ āĻāĻāĻāĻž leak āĻŽā§āĻĒā§ āĻĻā§āĻāĻžāĻŦā§ lesson 5āĨ¤ āϤāĻžāĻ āĻāĻ track āĻĒā§āϰāϤāĻŋāĻāĻž block free āĻāϰ⧠āĻĒā§āϰāϤāĻŋāĻāĻž āĻĒāĻĨā§, āĻāĻā§āĻāĻžāĻā§ return āĻāϰāĻž āĻĒāĻĨāĻā§āϞā§āϏāĻšāĨ¤
āϤāĻžāĻ block-āĻāĻž array-āϰ āĻŽāϤ⧠index āĻāϰā§, āĻāϰ program āĻĨā§āĻā§ āĻŦā§āϰ āĻšāĻāϝāĻŧāĻžāϰ āĻĒā§āϰāϤāĻŋāĻāĻž āĻĒāĻĨā§ free āĻāϰā§āĨ¤
Heap āĻŦā§āϝāĻŦāĻšāĻžāϰā§āϰ āϏāĻŦāĻā§āϝāĻŧā§ āĻā§āĻ āĻĒā§āϰā§āĻŖ āĻāĻĻāĻžāĻšāϰāĻŖāĨ¤ Kenji-āϰ game āĻāϰ āĻļā§āώ āϤāĻŋāύāĻāĻž score āϰāĻžāĻā§ āϤāĻŋāύ āĻŦāĻžāĻā§āϏā§āϰ āĻāĻāĻāĻž block-āĻ, āϤāĻžāϰāĻĒāϰ print āĻāϰā§āĨ¤
#include <stdio.h>
#include <stdlib.h>
int main(void)
{
int *scores = malloc(3 * sizeof *scores);
if (scores == NULL) {
fprintf(stderr, "out of memory\n");
return 1;
}
scores[0] = 70;
scores[1] = 85;
scores[2] = 91;
printf("Kenji's scores: %d %d %d\n", scores[0], scores[1], scores[2]);
free(scores);
return 0;
}
Kenji's scores: 70 85 91
āĻā§āύ⧠command line-āĻāĻ āĻā§āύ⧠āĻŦāĻžāϰā§āϤāĻž āύā§āĻāĨ¤ āĻŽāĻžāĻĒ āĻāĻā§ āĻĨā§āĻā§ āĻāĻžāύāĻž āĻĨāĻžāĻāϞ⧠āϏāĻžāϧāĻžāϰāĻŖ āĻāĻāĻāĻž array-āĻ āĻāϞāϤ; āĻāĻāĻž āĻļā§āϧ⧠āĻāĻžāϰāĻāĻž āϧāĻžāĻĒ āĻāϞāĻžāĻĻāĻž āĻāϰ⧠āĻĻā§āĻāĻžāϝāĻŧ: allocate, check, āĻŦā§āϝāĻŦāĻšāĻžāϰ, freeāĨ¤
Run in CompilerAmara-āϰ report āĻāĻāύ āϝā§āĻā§āύ⧠āĻŽāĻžāĻĒā§āϰ āĻā§āϞāĻžāϏ āύā§āϝāĻŧāĨ¤ read_marks block allocate āĻāϰā§, āĻāϰā§, āĻāϰ āĻāϰ address return āĻāϰā§āĨ¤ āĻāĻāĻāĻž local array āĻāĻāĻžāĻŦā§ return āĻāϰāĻž āϝā§āϤ āύāĻž, āĻāĻžāϰāĻŖ function-āĻāϰ closing brace-āĻāĻ āĻāĻāĻž āĻŽāĻžāϰāĻž āϝāĻžāϝāĻŧāĨ¤ Report pass-āĻāϰ āϏāĻāĻā§āϝāĻž āĻā§āύā§, āĻāϰ 40-āĻāϰ āύāĻŋāĻā§āϰ āĻĒā§āϰāϤāĻŋāĻāĻž āύāĻŽā§āĻŦāϰ āĻāϞāĻžāĻĻāĻž āϞāĻžāĻāύ⧠āĻĻā§āĻāĻžāϝāĻŧāĨ¤
#include <stdio.h>
#include <stdlib.h>
#define PASS_MARK 40
int *read_marks(int n);
int count_passed(const int *marks, int n);
int main(void)
{
int n = 0;
int *marks = NULL;
if (scanf("%d", &n) != 1 || n < 1) {
printf("no marks\n");
return 0;
}
marks = read_marks(n);
if (marks == NULL) {
fprintf(stderr, "out of memory\n");
return 1;
}
printf("passed: %d of %d\n", count_passed(marks, n), n);
for (int i = 0; i < n; i++) {
if (marks[i] < PASS_MARK) {
printf("needs help: student %d with %d\n", i + 1, marks[i]);
}
}
free(marks);
return 0;
}
int *read_marks(int n)
{
int *marks = malloc(n * sizeof *marks);
if (marks == NULL) {
return NULL;
}
for (int i = 0; i < n; i++) {
scanf("%d", &marks[i]);
}
return marks;
}
int count_passed(const int *marks, int n)
{
int passed = 0;
for (int i = 0; i < n; i++) {
if (marks[i] >= PASS_MARK) {
passed = passed + 1;
}
}
return passed;
}
passed: 4 of 6
needs help: student 2 with 35
needs help: student 6 with 22
āĻāĻ output-āĻāĻž input 6, āϤāĻžāϰāĻĒāϰ 72 35 90 41 64 22-āĻāϰ āĻāύā§āϝāĨ¤ malloc fail āĻāϰāϞ⧠read_marks return āĻāϰ⧠NULL, āĻāϰ āĻāĻŦāϰāĻāĻž āĻĻā§āϝāĻŧ main; helper āĻāĻāύ⧠āύāĻŋāĻā§ program āĻĨāĻžāĻŽāĻžāϝāĻŧ āύāĻžāĨ¤ count_passed āĻļā§āϧ⧠read āĻāϰā§, āϤāĻžāĻ āύā§āϝāĻŧ āĻāĻāĻāĻž const int * (Module 11-āĻāϰ lesson 5)āĨ¤
Maria-āϰ receipt total-āĻāĻž print āĻāϰ⧠item-āĻā§āϞā§āϰ āĻāĻĒāϰā§, āϤāĻžāĻ āϏāĻŦ āĻĻāĻžāĻŽ read āύāĻž āĻšāĻāϝāĻŧāĻž āĻĒāϰā§āϝāύā§āϤ āĻĒā§āϰāϤāĻŋāĻāĻž āĻĻāĻžāĻŽ āϰā§āĻā§ āĻĻāĻŋāϤ⧠āĻšāϝāĻŧāĨ¤ āĻāϰ item-āĻāϰ āϏāĻāĻā§āϝāĻž āĻŦāĻĻāϞāĻžāϝāĻŧ āĻĒā§āϰāϤāĻŋāĻāĻž āĻāĻĻā§āĻĻā§āϰā§āϰ āϏāĻžāĻĨā§āĨ¤ āύāϤā§āύ āĻā§āĻ āĻĒā§āϰāĻĨāĻŽā§ āĻ āĻŋāĻ āĻāĻ program-āĻāĻžāĻ āϞā§āĻā§, āĻĒā§āϰā§āĻāĻž main-āĻāĨ¤
#include <stdio.h>
#include <stdlib.h>
int main(void)
{
int n = 0;
int *prices = NULL;
int total = 0;
if (scanf("%d", &n) != 1 || n < 1) {
printf("empty receipt\n");
return 0;
}
prices = malloc(n * sizeof *prices);
if (prices == NULL) {
fprintf(stderr, "out of memory\n");
return 1;
}
for (int i = 0; i < n; i++) {
scanf("%d", &prices[i]);
total = total + prices[i];
}
printf("receipt: %d items, total %d\n", n, total);
for (int i = 0; i < n; i++) {
printf(" item %d: %d\n", i + 1, prices[i]);
}
free(prices);
return 0;
}
receipt: 3 items, total 285
item 1: 65
item 2: 180
item 3: 40
āĻāĻ output-āĻāĻž input 3, āϤāĻžāϰāĻĒāϰ 65 180 40-āĻāϰ āĻāύā§āϝāĨ¤ 0 āĻĻāĻŋāϞ⧠print āĻāϰ⧠empty receipt, āĻāĻŋāĻā§āĻ allocate āĻāϰ⧠āύāĻžāĨ¤ main āĻĨā§āĻā§ āĻŦā§āϰ āĻšāĻāϝāĻŧāĻžāϰ āĻĒā§āϰāϤāĻŋāĻāĻž āĻĒāĻĨ āĻšāϝāĻŧ block free āĻāϰā§, āύāϝāĻŧāϤ⧠āĻāĻāύ⧠block āĻĒāĻžāϝāĻŧāĻāύāĻŋāĨ¤
āĻāĻāĻž āĻā§āĻĨāĻžāϝāĻŧ āĻāĻžāĻā§ āϞāĻžāĻā§
- Text editorāĨ¤ GNU Emacs āĻĒā§āϰāϤāĻŋāĻāĻž open file-āĻāϰ āϞā§āĻāĻž āϰāĻžāĻā§ āĻāĻāĻāĻž buffer-āĻāĨ¤ File open āĻāϰāĻžāϰ āϏāĻŽāϝāĻŧ file-āĻāϰ āĻŽāĻžāĻĒ āĻŽāĻŋāϞāĻŋāϝāĻŧā§ buffer-āĻāĻž allocate āĻāϰā§, āĻāϰ āϤā§āĻŽāĻŋ type āĻāϰāϤ⧠āĻĨāĻžāĻāϞ⧠āϏā§āĻāĻž āĻŦāĻĄāĻŧ āĻāϰā§āĨ¤
- Web serverāĨ¤ nginx āĻĒā§āϰāϤāĻŋāĻāĻž request-āĻā§ āĻĻā§āϝāĻŧ āĻāϰ āύāĻŋāĻā§āϰ āĻāĻāĻāĻž memory pool: request āĻāϞ⧠allocate āĻšāϝāĻŧ, āĻāϰ request āĻļā§āώ āĻšāϞ⧠āĻāĻāĻŦāĻžāϰ⧠āĻĒā§āϰā§āĻāĻž free āĻšāϝāĻŧāĨ¤
- GameāĨ¤ Doom-āĻāϰ source code āĻĒā§āϰāϤāĻŋāĻāĻž monster āĻāϰ missile allocate āĻāϰ⧠āĻāĻāĻž āĻĻā§āĻāĻž āĻĻā§āĻāϝāĻŧāĻžāϰ āĻŽā§āĻšā§āϰā§āϤā§, āύāĻŋāĻā§āϰ allocator
Z_MallocāĻĻāĻŋāϝāĻŧā§āĨ¤ āĻā§āύ⧠level āĻāĻā§ āĻĨā§āĻā§ āĻŦāϞ⧠āĻĻā§āϝāĻŧ āύāĻž āĻāϝāĻŧāĻāĻž āĻāϏāĻŦā§āĨ¤ - CompilerāĨ¤ Clang āĻĒā§āϰāϤāĻŋāĻāĻž source file-āĻā§ āĻŦāĻžāύāĻžāϝāĻŧ āĻāĻāĻāĻž syntax tree: āĻĒā§āϰāϤāĻŋāĻāĻž declaration, statement āĻāϰ expression-āĻāϰ āĻāύā§āϝ āĻāĻāĻāĻž āĻāϰ⧠node, file read āĻāϰāϤ⧠āĻāϰāϤā§āĻ allocate āĻāϰāĻžāĨ¤
āϝ⧠āĻā§āϞāĻā§āϞ⧠āϏāĻŦāĻžāĻ āĻāϰā§
ā§§. stdlib.h-āĻāϰ #include āύā§āĻāĨ¤
#include <stdio.h>
int main(void)
{
int n = 5;
int *marks = malloc(n * sizeof *marks);
āĻĒā§āϰāϤāĻŋāĻāĻž command line-āĻ āĻĻā§āĻāĻāĻž warning, Playground-āϏāĻš, āĻāϰ Compile output tab-āĻ: warning: implicit declaration of function 'malloc' [-Wimplicit-function-declaration], āϏāĻžāĻĨā§ note: include '<stdlib.h>' or provide a declaration of 'malloc', āϤāĻžāϰāĻĒāϰ warning: incompatible implicit declaration of built-in function 'malloc' [-Wbuiltin-declaration-mismatch]āĨ¤ free-āĻāϰ āĻāύā§āϝāĻ āĻ āĻŋāĻ āĻāĻ āĻĻā§āĻāĻāĻž āĻāϏā§āĨ¤ Run āϤāĻŦā§āĻ 90 print āĻāϰā§āĻā§, āĻāĻŋāύā§āϤ⧠GCC 14-āĻ āĻĒā§āϰāĻĨāĻŽāĻāĻž āϏā§āĻāĻž errorāĨ¤ #include <stdlib.h> āϝā§āĻ āĻāϰā§āĨ¤ āĻāĻāĻž āĻā§āϞāĻŦā§, āĻāĻžāϰāĻŖ Module 1 āĻĨā§āĻā§ āĻāϤāĻĻāĻŋāύ <stdio.h>-āĻ āϝāĻĨā§āώā§āĻ āĻāĻŋāϞāĨ¤
⧍. malloc(n): āĻŦāĻžāĻā§āϏ āύāĻž, byteāĨ¤
marks = malloc(n);
if (marks == NULL) {
fprintf(stderr, "out of memory\n");
return 1;
}
āĻā§āύ⧠command line-āĻāĻ āĻā§āύ⧠āĻŦāĻžāϰā§āϤāĻž āύā§āĻāĨ¤ āĻāĻ block-āĻ āĻāĻā§ n byte, āύāĻŽā§āĻŦāϰāĻā§āϞā§āϰ āĻāĻžāϰ āĻāĻžāĻā§āϰ āĻāĻ āĻāĻžāĻā§āϰ āĻāĻžāϝāĻŧāĻāĻžāĨ¤ 5āĻāĻž āύāĻŽā§āĻŦāϰ āĻĻāĻŋāϝāĻŧā§ Compiler Explorer-āĻāϰ GCC 12-āĻ Amara-āϰ āĻĒā§āϰ⧠program āĻāĻāĻŦāĻžāϰ run āĻāϰāϞ⧠āϤāĻŦā§āĻ āĻ āĻŋāĻ āĻāϤā§āϤāϰ print āĻšāϝāĻŧā§āĻā§āĨ¤ glibc āĻā§āĻ request-āĻā§ āĻāĻāĻā§ āĻŦāĻĄāĻŧ āĻāϰ⧠āĻĻā§āϝāĻŧ (lesson 6), āĻāϰ 20 byte āĻāĻĒāĻžāϞāĻā§āϰ⧠āĻāĻāĻā§ āĻā§āĻā§āĨ¤ 100,000āĻāĻž āύāĻŽā§āĻŦāϰ āĻĻāĻŋāϞ⧠run āĻŽāĻžāϰāĻž āĻā§āĻā§ Program terminated with signal SIGSEGV (11) āĻĻā§āĻāĻŋāϝāĻŧā§āĨ¤ Lesson 5-āĻāϰ āĻĒāϰā§āĻā§āώāĻžāϰ tool AddressSanitizer āĻĻā§āĻŦāĻŋāϤā§āϝāĻŧ āύāĻŽā§āĻŦāϰā§āĻ āĻĨāĻžāĻŽāĻŋāϝāĻŧā§ āĻĻā§āϝāĻŧ: ERROR: AddressSanitizer: heap-buffer-overflow, 0 bytes to the right of 5-byte regionāĨ¤ āϞā§āĻā§ malloc(n * sizeof *marks)āĨ¤ āĻā§āϞāĻāĻž āĻšāĻŦā§, āĻāĻžāϰāĻŖ āϤā§āĻŽāĻŋ āĻā§āύ⧠āύāĻŽā§āĻŦāϰ, āĻāϰ malloc āĻā§āύ⧠byteāĨ¤
ā§Š. Bob-āĻāϰ loop n āĻĒāϰā§āϝāύā§āϤ āĻāϞā§āĨ¤
for (int i = 0; i <= n; i++) {
total = total + prices[i];
}
āĻā§āύ⧠command line-āĻāĻ āĻā§āύ⧠āĻŦāĻžāϰā§āϤāĻž āύā§āĻāĨ¤ āĻļā§āώ āĻĒāĻžāĻ read āĻāϰ⧠prices[n], block-āĻāϰ āĻāĻ āĻŦāĻžāĻā§āϏ āĻŦāĻžāĻāϰā§: undefined behaviourāĨ¤ Compiler Explorer-āĻāϰ GCC 12-āĻ Bob-āĻāϰ āĻĒā§āϰ⧠program āĻāĻāĻŦāĻžāϰ run āĻāϰāϞā§, input 3, āϤāĻžāϰāĻĒāϰ 65 180 40 āĻĻāĻŋāϝāĻŧā§, print āĻšāϝāĻŧā§āĻā§ total 285āĨ¤ āĻ āĻŋāĻ āĻšāϝāĻŧā§āĻā§ āϏā§āϰā§āĻĢ āĻāĻĒāĻžāϞāĻā§āϰā§āĨ¤ AddressSanitizer āĻŦāϞ⧠READ of size 4 āĻāϰ 0 bytes to the right of 12-byte region, āĻŽāĻžāύ⧠āϤāĻŋāύāĻāĻž āĻŦāĻžāĻā§āϏā§āϰ āĻ āĻŋāĻ āĻĒāϰā§āϰ āĻŦāĻžāĻā§āϏāĨ¤ āϞā§āĻā§ i < nāĨ¤ Bob <= āϞā§āĻā§, āĻāĻžāϰāĻŖ "n āĻĒāϰā§āϝāύā§āϤ" āĻļā§āύāϤ⧠āĻ āĻŋāĻāĻ āϞāĻžāĻā§āĨ¤
āĻāĻŦāĻžāϰā§āϰ āĻāĻžāϰā§āĻŽā§ Amara-āϰ āĻā§āϞāĻžāϏ⧠āĻāϤāĻāύ āĻāĻžāϤā§āϰ, āĻā§āĻ āĻāĻžāύ⧠āύāĻžāĨ¤ int *read_marks(int n) āϞā§āĻā§āĨ¤ āĻ malloc āĻĻāĻŋāϝāĻŧā§ āĻ āĻŋāĻ n-āĻāĻž āĻŦāĻžāĻā§āϏ allocate āĻāϰāĻŦā§, āĻāϤā§āϤāϰāĻāĻž NULL āĻāĻŋ āύāĻž check āĻāϰāĻŦā§, āĻŦāĻžāĻā§āϏāĻā§āϞā§āϤ⧠n-āĻāĻž āύāĻŽā§āĻŦāϰ read āĻāϰāĻŦā§, āĻāϰ block-āĻāĻž return āĻāϰāĻŦā§āĨ¤ āϤāĻžāϰāĻĒāϰ āϞā§āĻā§ void print_report(const int *marks, int n)āĨ¤ Judge āĻļā§āϧ⧠output āĻĻā§āĻā§, āϤāĻžāĻ āϤā§āĻŽāĻžāϰ block-āĻ āĻ āĻŋāĻ n-āĻāĻž āĻŦāĻžāĻā§āϏ āĻāĻā§ āĻāĻŋ āύāĻž, āϏā§āĻāĻž āĻ āĻĻā§āĻāϤ⧠āĻĒāĻžāϝāĻŧ āύāĻžāĨ¤
Input. āĻāĻ āϞāĻžāĻāύ⧠n, āϤāĻžāϰāĻĒāϰ space āĻĻāĻŋāϝāĻŧā§ āĻāϞāĻžāĻĻāĻž āĻāϰāĻž n-āĻāĻž āύāĻŽā§āĻŦāϰāĨ¤
Output. āĻĻā§āĻ āϞāĻžāĻāύ⧠mean: X.XX, āĻĻāĻļāĻŽāĻŋāĻā§āϰ āĻĒāϰ⧠āĻĻā§āĻ āĻāϰ, āĻāϰ max: MāĨ¤ n āϝāĻĻāĻŋ 0 āĻšāϝāĻŧ, āĻļā§āϧ⧠āĻāĻāĻāĻž āϞāĻžāĻāύ no marksāĨ¤
Constraints. 0 <= n <= 100000; 0 <= āĻĒā§āϰāϤāĻŋāĻāĻž āύāĻŽā§āĻŦāϰ <= 100āĨ¤
Sample. Input 3, āϤāĻžāϰāĻĒāϰ 90 92 92 āĻĻāĻŋāϞ⧠āĻĻā§āĻ āϞāĻžāĻāύ⧠āĻāϏ⧠mean: 91.33 āĻāϰ max: 92āĨ¤ āύāĻŽā§āĻŦāϰāĻā§āϞā§āϰ āϝā§āĻāĻĢāϞ 274, āĻāϰ 274 / 3 āĻšāϞ⧠91.333..., āϝā§āĻāĻž āĻĻā§āĻ āĻāϰ āĻĒāϰā§āϝāύā§āϤ print āĻšāϝāĻŧāĨ¤
#include <stdio.h>
#include <stdlib.h>
int *read_marks(int n);
void print_report(const int *marks, int n);
int main(void)
{
int n = 0;
int *marks = NULL;
scanf("%d", &n);
marks = read_marks(n);
if (n > 0 && marks == NULL) {
fprintf(stderr, "out of memory\n");
return 1;
}
print_report(marks, n);
free(marks);
return 0;
}
int *read_marks(int n)
{
/* Ask malloc for exactly n boxes, check the answer for NULL,
read n marks into the boxes and return the block. */
return NULL;
}
void print_report(const int *marks, int n)
{
/* Print "mean: X.XX" and "max: M" on two lines, or "no marks" when n is 0. */
}
mean-max āύāĻžāĻŽā§ āĻā§āϰā§āĻĄ āĻšāϝāĻŧāĨ¤ Hidden test-āĻ āĻāĻā§ n = 0, āĻāϰ 100,000 āĻāύā§āϰ āĻāĻāĻāĻž āĻā§āϞāĻžāϏ, āϝā§āĻāĻžāύ⧠n byte-āĻāϰ block āĻāĻā§āĻŦāĻžāϰā§āĻ āϝāĻĨā§āώā§āĻ āύāĻžāĨ¤
Zara-āϰ puzzle game-āĻāϰ āĻĻāϰāĻāĻžāϰ āĻĒā§āϰāĻĨāĻŽ n-āĻāĻž āĻŦāϰā§āĻāϏāĻāĻā§āϝāĻž, memory-āϤ⧠āϰāĻžāĻāĻž āĻ
āĻŦāϏā§āĻĨāĻžāϝāĻŧāĨ¤ long long *make_squares(int n) āϞā§āĻā§āĨ¤ n = 0 āĻšāϞ⧠āĻ āĻāĻŋāĻā§āĻ allocate āĻāϰ⧠āύāĻž, return āĻāϰ⧠NULLāĨ¤ āύāĻāϞ⧠malloc āĻĻāĻŋāϝāĻŧā§ āĻ āĻŋāĻ n-āĻāĻž long long āĻŦāĻžāĻā§āϏ allocate āĻāϰā§, āĻāϤā§āϤāϰāĻāĻž check āĻāϰā§, āĻāϰ i āύāĻŽā§āĻŦāϰ āĻŦāĻžāĻā§āϏ⧠āϰāĻžāĻā§ (i + 1)-āĻāϰ āĻŦāϰā§āĻāĨ¤ main-āĻ āĻĒā§āϰāϤāĻŋāĻāĻž āĻŦāĻžāĻā§āϏ print āĻāϰā§, āĻāϰ āϝā§āĻāĻĢāϞ⧠āϝā§āĻ āĻāϰā§āĨ¤
Input. āĻāĻāĻāĻž integer nāĨ¤
Output. n-āĻāĻž āĻŦāϰā§āĻāϏāĻāĻā§āϝāĻž, āĻĒā§āϰāϤāĻŋ āϞāĻžāĻāύ⧠āĻāĻāĻāĻž, 1 āĻĨā§āĻā§ āĻļā§āϰ⧠āĻāϰā§, āϤāĻžāϰāĻĒāϰ sum: SāĨ¤ n āϝāĻĻāĻŋ 0 āĻšāϝāĻŧ, āĻļā§āϧ⧠sum: 0āĨ¤
Constraints. 0 <= n <= 100000āĨ¤ āĻŦāĻžāĻā§āϏāĻā§āϞ⧠long long, āĻāĻžāϰāĻŖ 100,000-āĻāϰ āĻŦāϰā§āĻ 10,000,000,000, āϝā§āĻāĻž āϏāĻŦāĻā§āϝāĻŧā§ āĻŦāĻĄāĻŧ int-āĻāϰ āĻ
āύā§āĻ āĻŦāĻžāĻāϰā§āĨ¤
Sample. Input 3 āĻĻāĻŋāϞ⧠āĻāϏ⧠1, 4, 9 āĻāϰ sum: 14, āĻĒā§āϰāϤāĻŋ āϞāĻžāĻāύ⧠āĻāĻāĻāĻžāĨ¤
#include <stdio.h>
#include <stdlib.h>
long long *make_squares(int n);
int main(void)
{
int n = 0;
long long *squares = NULL;
long long sum = 0;
scanf("%d", &n);
squares = make_squares(n);
if (n > 0 && squares == NULL) {
fprintf(stderr, "out of memory\n");
return 1;
}
/* Print box 0 to box n - 1, one per line, and add each one to sum. */
printf("sum: %lld\n", sum);
free(squares);
return 0;
}
long long *make_squares(int n)
{
/* For n = 0, allocate nothing and return NULL. Otherwise ask malloc
for exactly n boxes, check for NULL, and put (i + 1) squared in box i. */
return NULL;
}
āĻāϞāĻžāĻĻāĻž āĻāϰ⧠āĻā§āϰā§āĻĄ āĻšāϝāĻŧ āύāĻžāĨ¤ Output āύāĻŋāϰā§āĻāϰ āĻāϰ⧠āĻļā§āϧ⧠n-āĻāϰ āĻāĻĒāϰ, āϤāĻžāĻ āĻā§āύ⧠block āĻāĻžāĻĄāĻŧāĻž āϞā§āĻāĻž program-āĻ āĻĒā§āϰāϤāĻŋāĻāĻž test pass āĻāϰ⧠āϝā§āϤāĨ¤
Run in CompilerāϏāĻāϰāĻžāĻāϰ āϝ⧠āĻĒā§āϰāĻļā§āύāĻā§āϞ⧠āĻāϏā§
n read āĻāϰ⧠āϤāĻžāϰāĻĒāϰ int marks[n]; āϞāĻŋāĻāϞ⧠āϏāĻŽāϏā§āϝāĻž āĻā§?
āĻāĻāĻž variable length array, āϝā§āĻāĻž Module 9-āĻāϰ lesson 1 āĻŦāĻžāĻĻ āĻĻāĻŋāϝāĻŧā§āĻāĻŋāϞ: C11 compiler-āĻĻā§āϰ āĻāύā§āϝ āĻāĻāĻž āĻāĻā§āĻāĻŋāĻ āĻāϰ⧠āĻĻāĻŋāϝāĻŧā§āĻā§āĨ¤ āĻāĻāĻž āĻĨāĻžāĻā§ function-āĻāϰ frame-āĻ, stack-āĻāĨ¤ āĻāĻžāϝāĻŧāĻāĻž āύāĻž āĻĨāĻžāĻāϞ⧠check āĻāϰāĻžāϰ āĻŽāϤ⧠āĻā§āύā§
NULLāύā§āĻ: program āϏā§āĻāĻž āĻŽāĻžāϰāĻž āϝāĻžāϝāĻŧāĨ¤ Closing brace-āĻ āĻāĻāĻžāĻ āĻŽāĻžāϰāĻž āϝāĻžāϝāĻŧ, āϤāĻžāĻ āĻā§āύ⧠function āĻāĻāĻž return āĻāϰāϤ⧠āĻĒāĻžāϰ⧠āύāĻžāĨ¤sizeof *marks āĻāĻŋ āĻāĻŽāύ āĻāĻāĻāĻž pointer āĻĻāĻŋāϝāĻŧā§ read āĻāϰā§, āϝā§āĻāĻž āĻāĻāύ⧠āĻā§āĻĨāĻžāĻ āĻĻā§āĻāĻžāϝāĻŧ āύāĻž?
āύāĻžāĨ¤ Variable length array āĻāĻžāĻĄāĻŧāĻž
sizeofāĻāϰ operand āĻāĻāύ⧠evaluate āĻāϰ⧠āύāĻž (C17 section 6.5.3.4)āĨ¤ āĻ āĻļā§āϧā§*marks-āĻāϰ type āĻĻā§āĻā§, āϝā§āĻāĻžintāĨ¤ āϤāĻžāĻmarksāĻāĻāύā§NULLāĻĨāĻžāĻāϞā§āĻmalloc(n * sizeof *marks)āύāĻŋāϰāĻžāĻĒāĻĻāĨ¤āĻĢāϞāĻžāĻĢāϞāĻāĻž āĻāĻŋ cast āĻāϰāĻŦ, āϝā§āĻŽāύ (int *)malloc(...)?
C-āϤ⧠āύāĻž, āĻāĻžāϰāĻŖ C āύāĻŋāĻā§āĻ
void *-āĻā§ āϝā§āĻā§āύ⧠object pointer-āĻ āĻŦāĻĻāϞ⧠āύā§āϝāĻŧāĨ¤ āĻĒā§āϰāύ⧠āĻŦāĻāϝāĻŧā§ āĻāϰ C++-āĻ cast-āĻāĻž āĻĻā§āĻāĻŦā§, C++-āĻ āĻāĻāĻž āϞāĻžāĻā§āĻāĨ¤ C-āϤ⧠āĻāĻāĻž āĻāĻŋāĻā§āĻ āϝā§āĻ āĻāϰ⧠āύāĻž, āϤāĻžāĻ āĻāĻ track āĻāĻāĻž āĻŦāĻžāĻĻ āϰāĻžāĻā§āĨ¤malloc-āĻāϰ āĻŦāĻžāĻā§āϏāĻā§āϞ⧠āĻāĻŋ āĻļā§āϰā§āϤ⧠āĻļā§āύā§āϝ āĻĨāĻžāĻā§?
C āĻā§āύ⧠āĻāĻĨāĻž āĻĻā§āϝāĻŧ āύāĻžāĨ¤ āύāϤā§āύ block āĻĒā§āϰāĻžāϝāĻŧāĻ āĻļā§āύā§āϝ āĻĒāĻĄāĻŧā§, āĻāĻŦāĻžāϰ āĻŦā§āϝāĻŦāĻšāĻžāϰ āĻšāĻāϝāĻŧāĻž block āĻĒāĻĄāĻŧā§ āύāĻž; lesson 2 āĻĻā§āĻā§āĻ āĻŽā§āĻĒā§ āĻĻā§āĻāĻžāĻŦā§, āĻāϰ āĻĒāϰāĻŋāĻāϝāĻŧ āĻāϰāĻžāĻŦā§
calloc-āĻāϰ āϏāĻžāĻĨā§, āϝā§āĻāĻž āĻļā§āύā§āϝā§āϰ āĻāĻĨāĻž āĻĻā§āϝāĻŧāĨ¤ āĻā§āύ⧠āĻŦāĻžāĻā§āϏ read āĻāϰāĻžāϰ āĻāĻā§ āĻāϤ⧠āϞā§āĻā§āĨ¤
āĻŽā§āϞ āĻāĻĨāĻž
- Capacity constant āĻāĻāĻĻāĻŋāύ āĻā§āĻ āĻĒāĻĄāĻŧāĻŦā§āĻ, āĻāϰ āĻŦāĻŋāĻļāĻžāϞ static array-āϰāĻ āĻāĻāĻāĻž āĻāĻžāĻĻ āĻĨāĻžāĻā§āĨ¤ n āĻāĻžāύāĻžāϰ āĻĒāϰā§
mallocāĻ āĻŋāĻ n-āĻāĻž āĻŦāĻžāĻā§āϏ āĻāĻžāϝāĻŧāĨ¤ - Program āĻāϞāĻžāϰ āϏāĻŽāϝāĻŧ āϝ⧠block-āĻā§āϞ⧠allocate āĻāϰā§, āϏā§āĻā§āϞ⧠āĻĨāĻžāĻā§ heap-āĻāĨ¤ Pointer-āĻāĻž stack-āĻāϰ āĻāĻāĻāĻž local, āĻāϰ block āĻā§āĻā§
freeāĻĒāϰā§āϝāύā§āϤāĨ¤ malloc(n * sizeof *marks), āϝā§āĻāĻž āĻāϏā§<stdlib.h>āĻĨā§āĻā§, āĻŽāĻžāύ⧠āĻā§āύāϤāĻŋ āĻā§āĻŖ āĻāĻāĻāĻž āĻŦāĻžāĻā§āϏā§āϰ āĻŽāĻžāĻĒ, āĻā§āύ⧠cast āĻāĻžāĻĄāĻŧāĻžāĨ¤malloc-āĻāϰ āĻāĻā§ncheck āĻāϰā§, āĻāϰ āĻĒāϰ⧠pointer: -1 āĻā§āϝāĻŧā§ āĻŦāϏ⧠18,446,744,073,709,551,612 byte, āĻāϰ āĻĒāĻžāϝāĻŧNULLāĨ¤- Playground-āĻ āĻŦāĻŋāĻļāĻžāϞ request-āĻ pointer āĻĒāĻžāϝāĻŧ; 256,000 KB-āϰ āĻŦā§āĻļāĻŋ āĻā§āĻāϞ⧠run āĻĨāĻžāĻŽā§ Memory limit exceeded āύāĻŋāϝāĻŧā§āĨ¤
- Block-āĻāĻž array-āϰ āĻŽāϤ⧠index āĻāϰā§, āĻāϰ āĻĒā§āϰāϤāĻŋāĻāĻž āĻĒāĻĨā§ free āĻāϰā§āĨ¤ āĻŽāĻžāϏā§āϰ āĻĒāϰ āĻŽāĻžāϏ āĻāϞāĻž program āĻĢā§āϰāϤ āύāĻž āĻĻā§āĻāϝāĻŧāĻž āĻĒā§āϰāϤāĻŋāĻāĻž block āĻļā§āώ āĻĒāϰā§āϝāύā§āϤ āϧāϰ⧠āϰāĻžāĻā§āĨ¤
āĻāϰāĻĒāϰ Bob āĻāĻāĻāĻž block āĻŦāĻĄāĻŧ āĻāϰāϤ⧠āϝāĻžāϝāĻŧ, āĻāϰ āϝ⧠āĻāĻāĻāĻž run-āĻ realloc āύāĻž āĻŦāϞ⧠āĻĻā§āϝāĻŧ, āĻ āĻŋāĻ āϏā§āĻāĻžāύā§āĻ block-āĻāĻž āĻšāĻžāϰāĻžāϝāĻŧāĨ¤ Lesson 2 āĻā§āϞ⧠āĻāĻžāϰāĻāĻž call, malloc, calloc, realloc āĻāϰ free, āĻāϰ āĻŽā§āĻĒā§ āĻĻā§āĻāĻžāϝāĻŧ āĻā§āύāĻāĻž āĻā§ āĻāĻĨāĻž āĻĻā§āϝāĻŧāĨ¤
lesson ā§§ āĻļā§āώ
āĻļā§āώ āĻšāϞ⧠āĻāĻŋāĻšā§āύ āĻĻāĻŋāύ, āĻ āĻā§āϰāĻāϤāĻŋ āĻāĻĒāύāĻžāϰ āϏāĻžāĻĨā§ āĻĨāĻžāĻāĻŦā§āĨ¤
āĻĒāϰā§āϰāĻāĻž: malloc, calloc, realloc āĻāϰ free