Learn C Programming

lesson ā§§ / ⧝ ¡ Dynamic memory

Module ā§§ā§Ē ¡ Dynamic memory

Dynamic memory āϕ⧇āύ: āϝ⧇ āĻŽāĻžāĻĒāϟāĻž āφāϗ⧇ āĻĨ⧇āϕ⧇ āϜāĻžāύāĻž āύ⧇āχ

FreeāĻĒāĻĄāĻŧāĻž

āĻāχ 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 arraystatic 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-āĻāĨ¤

Heap-āϏāĻš āĻāĻ•āϟāĻž program-āĻāϰ memory: stack-āĻāϰ marks āĻĻ⧇āĻ–āĻžāϝāĻŧ heap-āĻāϰ āĻāĻ•āϟāĻž block āĻāĻ•āϟāĻž program-āĻāϰ memory, āϏāĻŦāĻšā§‡āϝāĻŧ⧇ āύāĻŋāϚ⧁ address āύāĻŋāĻšā§‡ āωāρāϚ⧁ āύāĻŋāϚ⧁ main-āĻāϰ frame n: 5 marks āύāĻŋāĻšā§‡ āĻŦāĻžāĻĄāĻŧ⧇ āĻŦāĻŋāĻļāĻžāϞ āĻĢāĻžāρāĻ•āĻž āϜāĻžāϝāĻŧāĻ—āĻž āωāĻĒāϰ⧇ āĻŦāĻžāĻĄāĻŧ⧇ 90 72 64 88 51 malloc-āĻāϰ āĻĻ⧇āĻ“āϝāĻŧāĻž block: 5āϟāĻž int static area code stack āϚāϞāĻŽāĻžāύ āĻĒā§āϰāϤāĻŋāϟāĻž call-āĻāϰ āĻāĻ•āϟāĻž frame marks āϧāϰ⧇ āϰāĻžāϖ⧇ āĻāĻ•āϟāĻž address heap āϚāϞāĻžāϰ āϏāĻŽāϝāĻŧ āĻšā§‡āϝāĻŧ⧇ āύ⧇āĻ“āϝāĻŧāĻž block āĻĒā§āϰāϤāĻŋāϟāĻž āĻĨāĻžāϕ⧇ free āĻĒāĻ°ā§āϝāĻ¨ā§āϤ global āφāϰ static program-āĻāϰ instruction marks āĻšāϞ⧋ stack-āĻāϰ āĻāĻ•āϟāĻž local; āĻ“ āϝ⧇ āĻĒāĻžāρāϚāϟāĻž āĻŦāĻžāĻ•ā§āϏ āĻĻ⧇āĻ–āĻžāϝāĻŧ, āϏ⧇āϗ⧁āϞ⧋ āĻĨāĻžāϕ⧇ 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 āφāϰ free declare āĻšāϝāĻŧāĨ¤ āĻāϟāĻž āύāĻž āĻĨāĻžāĻ•āϞ⧇ āϕ⧀ āĻšāϝāĻŧ, āĻĻ⧇āĻ–āĻžāĻŦ⧇ āϭ⧁āϞ 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 GBNULL
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 āĻ•āϰ⧋āĨ¤

Example 1: Kenji-āϰ āϤāĻŋāύāϟāĻž score, heap-āĻ

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 Compiler
Example 2: Amara-āϰ āĻ•ā§āϞāĻžāϏ, āĻāĻ•āϟāĻž function āĻĻāĻŋāϝāĻŧ⧇ read āĻ•āϰāĻž

Amara-āϰ 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)āĨ¤

Run in Compiler
Example 3: Maria-āϰ āϝ⧇āϕ⧋āύ⧋ āĻĻ⧈āĻ°ā§āĻ˜ā§āϝ⧇āϰ receipt

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 āĻĒāĻžāϝāĻŧāχāύāĻŋāĨ¤

Run in Compiler

āĻāϟāĻž āϕ⧋āĻĨāĻžāϝāĻŧ āĻ•āĻžāĻœā§‡ āϞāĻžāϗ⧇

  • 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 āĻĒāĻ°ā§āϝāĻ¨ā§āϤ" āĻļ⧁āύāϤ⧇ āĻ āĻŋāĻ•āχ āϞāĻžāϗ⧇āĨ¤

āĻŽāĻžāĻĨāĻž āĻ–āĻžāϟāĻžāĻ“

Zara āϏāĻŦāĻžāϰ āφāϗ⧇ 0 āĻĻāĻŋāϝāĻŧ⧇ āĻĻ⧇āϖ⧇āĨ¤ āϧāϰ⧋ āĻāĻ•āϟāĻž program n < 1 āĻĒāϰ⧀āĻ•ā§āώāĻžāϟāĻž āĻŦāĻžāĻĻ āĻĻāĻŋāϝāĻŧ⧇ āĻļā§‚āĻ¨ā§āϝāϟāĻž āĻŦāĻžāĻ•ā§āϏ āϚāĻžāχāϞāĨ¤

#include <stdio.h>
#include <stdlib.h>

int main(void)
{
    int *marks = malloc(0);

    if (marks == NULL) {
        printf("malloc(0) gave NULL\n");
    } else {
        printf("malloc(0) gave a pointer\n");
    }
    free(marks);
    return 0;
}

Playground āϕ⧋āύ āϞāĻžāχāύāϟāĻž print āĻ•āϰ⧇? āĻĻ⧁āχ āωāĻ¤ā§āϤāϰ⧇āϰ āϝ⧇āϕ⧋āύ⧋āϟāĻžāϰ āĻĒāϰ⧇ āĻ•āĻŋ free(marks) āύāĻŋāϰāĻžāĻĒāĻĻ? āϤāĻžāϰāĻĒāϰ āĻ•āĻ āĻŋāύ āĻ…āĻ‚āĻļ: program āĻ•āĻŋ marks[0]-āĻ āĻāĻ•āϟāĻž āύāĻŽā§āĻŦāϰ āϰāĻžāĻ–āϤ⧇ āĻĒāĻžāϰ⧇?

C17 malloc(0)-āϕ⧇ āĻĻ⧁āχ āϰāĻ•āĻŽ āωāĻ¤ā§āϤāϰ āĻĻ⧇āĻ“āϝāĻŧāĻžāϰ āĻ…āύ⧁āĻŽāϤāĻŋ āĻĻ⧇āϝāĻŧ (section 7.22.3)āĨ¤ glibc āϕ⧋āύāϟāĻž āĻĻ⧇āϝāĻŧ āϖ⧁āρāĻœā§‡ āĻŦ⧇āϰ āĻ•āϰ⧋, āϤāĻžāϰāĻĒāϰ āĻ­āĻžāĻŦā§‹, āĻļā§‚āĻ¨ā§āϝ byte-āĻāϰ āĻāĻ•āϟāĻž block-āĻ āĻ•āϝāĻŧ byte āϧāϰ⧇āĨ¤

āĻ…āύ⧁āĻļā§€āϞāύ ā§§āϏāĻšāϜ

āĻāĻŦāĻžāϰ⧇āϰ āϟāĻžāĻ°ā§āĻŽā§‡ 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 āĻāϕ⧇āĻŦāĻžāϰ⧇āχ āϝāĻĨ⧇āĻˇā§āϟ āύāĻžāĨ¤

Run in Compiler
āĻ…āύ⧁āĻļā§€āϞāύ ⧍āĻŽāĻžāĻāĻžāϰāĻŋ

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-āĻāϰ āφāϗ⧇ n check āĻ•āϰ⧋, āφāϰ āĻĒāϰ⧇ 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