๐Ÿ“ ๋™์  & ์ •์  ํ• ๋‹น

Ohyuchanยท2023๋…„ 11์›” 1์ผ
0

๐Ÿง‘๐Ÿปโ€๐Ÿ’ป C Language

๋ชฉ๋ก ๋ณด๊ธฐ
17/18
post-thumbnail

์ด๋ฒˆ ํฌ์ŠคํŒ…์—์„œ๋Š” ๋™์ ๊ณผ ์ •์ ์— ๋Œ€ํ•ด์„œ ์ž‘์„ฑํ•ด๋ณด๋ ค๊ณ  ํ•ฉ๋‹ˆ๋‹ค.

๐Ÿค” ์ •์ /๋™์  ๊ตฌ๋ถ„ ๊ธฐ์ค€


์†Œ์Šค ์ฝ”๋“œ๋ฅผ ๋Œ๋ฆด ๋•Œ ํ†ตํ•ฉ๊ฐœ๋ฐœํ™˜๊ฒฝ์€ ์ปดํŒŒ์ผ๊ณผ ์‹คํ–‰์„ ๊ฑฐ์นœ๋‹ค.
์ปดํŒŒ์ผ ๊ณผ์ •์—์„œ ์šฐ๋ฆฌ๊ฐ€ ์ง  ์†Œ์Šค ์ฝ”๋“œ๊ฐ€ ์ œ๋Œ€๋กœ ๋˜์—ˆ๋Š”์ง€ ์‚ดํŽด๋ณด๊ณ 
์ด์ƒ์ด ์—†์œผ๋ฉด ์‹คํ–‰ ๋‹จ๊ณ„๋กœ ๋„˜์–ด๊ฐ„๋‹ค. ์—ฌ๊ธฐ์„œ๋„ ์˜ค๋ฅ˜๊ฐ€ ์—†์œผ๋ฉด ์ฝ˜์†” ์ฐฝ์— ์‹คํ–‰
๊ฒฐ๊ณผ๋ฅผ ์ถœ๋ ฅํ•ด์ค€๋‹ค.

์ •์ (Static), ๋™์ (Dynamic) ํ• ๋‹น์„ ๊ตฌ๋ถ„ํ•˜๋Š” ๊ธฐ์ค€์€ 'ํ”„๋กœ๊ทธ๋žจ ์‹คํ–‰ ์ค‘์—
๋ฉ”๋ชจ๋ฆฌ ๊ณต๊ฐ„์„ ํ• ๋‹นํ•˜๋Š”๊ฐ€?' ์ด๋‹ค. ์ •์  ํ• ๋‹น์€ ์ปดํŒŒ์ผ ๋‹จ๊ณ„์—์„œ ํ•„์š”ํ•œ ๋ฉ”๋ชจ๋ฆฌ
๊ณต๊ฐ„์„ ํ• ๋‹นํ•˜๊ณ , ๋™์  ํ• ๋‹น์€ ์‹คํ–‰ ๋‹จ๊ณ„์—์„œ ๊ณต๊ฐ„์„ ํ• ๋‹นํ•ด์ฃผ๋Š” ๊ฒƒ์ด๋‹ค.

๐Ÿ“„ ๋ฉ”๋กœ๋ฆฌ ์˜์—ญ


์ง€๊ธˆ๊นŒ์ง€๋Š” ๋ฉ”๋ชจ๋ฆฌ๋ฅผ ๊ทธ๋ƒฅ ๋ชฝ๋šฑ๊ทธ๋ ค '๋ณ€์ˆ˜๋ฅผ ์ €์žฅํ•˜๋Š” ๊ณต๊ฐ„. ๋ฐฉ ํ•˜๋‚˜ํ•˜๋‚˜๋งˆ๋‹ค ์ฃผ์†Œ๊ฐ€ ์žˆ๋‹ค'
์ •๋„๋กœ ๋‹ค๋ฃจ์—ˆ๋‹ค. ํ•˜์ง€๋งŒ ๋ฉ”๋ชจ๋ฆฌ๋Š” ๊ทธ ํ™œ์šฉ๊ณผ ๊ธฐ๋Šฅ์— ๋”ฐ๋ผ ํฌ๊ฒŒ 4๊ฐ€์ง€ ์ข…๋ฅ˜๋กœ ๊ตฌ๋ถ„๋œ๋‹ค.

Code/Data/Stack/Heap

โ‡ฒ Code ์˜์—ญ์€?

-> ํ•จ์ˆ˜, ์ƒ์ˆ˜ ์ €์žฅ

ํ•จ์ˆ˜์™€ ์ƒ์ˆ˜, ์‹คํ–‰ํ•œ ํ”„๋กœ๊ทธ๋žจ์˜ ์ฝ”๋“œ๊ฐ€ ์ €์žฅ๋˜๋Š” ๊ณต๊ฐ„์ด๋‹ค.
ํ•จ์ˆ˜๋‚˜ ์ƒ์ˆ˜๋Š” ์ปดํŒŒ์ผ ๋‹จ๊ณ„์—์„œ ๊ฒ€์‚ฌ๋ฅผ ๋งˆ์น˜๊ณ  ์ €์žฅ๋˜๋ฏ€๋กœ ์ด ๊ณณ์€ ์ •์  ๋ฉ”๋ชจ๋ฆฌ์ด๋‹ค.

โ‡ฒ Data ์˜์—ญ์€?

-> ์ „์—ญ/์ •์  ๋ณ€์ˆ˜ ์ €์žฅ

์ „์—ญ ๋ณ€์ˆ˜์™€ ์ •์ (Static) ๋ณ€์ˆ˜๊ฐ€ ์ €์žฅ๋˜๋Š” ์˜์—ญ์ด๋‹ค.
Code ์˜์—ญ๊ณผ ๋งˆ์ฐฌ๊ฐ€์ง€๋กœ ์ปดํŒŒ์ผ ๋‹จ๊ณ„์—์„œ ๊ฒ€์‚ฌ๋ฅผ ๋๋งˆ์น˜๊ณ  ๋ฉ”๋ชจ๋ฆฌ ํ• ๋‹น์ด ์ด๋ฃจ์–ด์ง„๋‹ค.

์ถ”๊ฐ€์ ์œผ๋กœ C,C++์—์„œ ์ „์—ญ ๋ณ€์ˆ˜์™€ ์ •์  ๋ณ€์ˆ˜๋ฅผ ์„ ์–ธํ•˜๊ฒŒ ๋˜๋ฉด ๋”ฐ๋กœ ์ดˆ๊ธฐํ™”ํ•˜์ง€ ์•Š์•„๋„ 0์œผ๋กœ
์ž๋™ ์ดˆ๊ธฐํ™” ๋˜์–ด ์žˆ๋‹ค๋Š” ์‚ฌ์‹ค์„ ๋ฐœ๊ฒฌํ•  ์ˆ˜ ์žˆ๋‹ค. ์ด๋Š” Stack ์˜์—ญ์— ์ €์žฅ๋˜๋Š” ์ง€์—ญ ๋ณ€์ˆ˜๋‚˜ ๋งค๊ฐœ ๋ณ€์ˆ˜์™€ ๋‹ฌ๋ฆฌ ์ „์—ญ ๋ณ€์ˆ˜์™€ ์ •์  ๋ณ€์ˆ˜๋Š” Data ์˜์—ญ์— ์ €์žฅ๋˜๊ธฐ ๋•Œ๋ฌธ์ด๋‹ค.

โ‡ฒ Stack ์˜์—ญ์€

-> ์ง€์—ญ/๋งค๊ฐœ ๋ณ€์ˆ˜ ์ €์žฅ

์ง€์—ญ ๋ณ€์ˆ˜์™€ ๋งค๊ฐœ๋ณ€์ˆ˜๊ฐ€ ์ €์žฅ๋˜๋Š” ๊ณณ์ด๋‹ค. ์ฆ‰ ํ†ต์ƒ์ ์œผ๋กœ ์šฐ๋ฆฌ๊ฐ€ ๋ณ€์ˆ˜๋ผ๊ณ  ๋ถ€๋ฅด๋Š” ๊ฒƒ๋“ค์„
์„ ์–ธํ•˜๋ฉด ์ด ์˜์—ญ์—์„œ ๊ณต๊ฐ„์„ ํ• ๋‹นํ•ด์ค€๋‹ค.

๐Ÿค” ์™œ ๋™์  ๋ฉ”๋ชจ๋ฆฌ์ผ๊นŒ?
์ง€์—ญ ๋ณ€์ˆ˜์™€ ๋งค๊ฐœ ๋ณ€์ˆ˜๋Š” ์„ ์–ธ๋œ ํ•จ์ˆ˜ ๋‚ด์—์„œ๋งŒ ์‚ฌ์šฉ ๊ฐ€๋Šฅํ•˜๋‹ค.
๊ทธ ํ•จ์ˆ˜๋ฅผ ๋ฒ—์–ด๋‚˜๋ฉด ํ• ๋‹น๋œ ๊ณต๊ฐ„์„ ๋ฐ˜๋‚ฉํ•˜๊ณ  ์‚ฌ๋ผ์ ธ์•ผ ํ•œ๋‹ค.
ํ”„๋กœ๊ทธ๋žจ ์‹คํ–‰ ๊ณผ์ •์—์„œ ์ด๋Ÿฐ ์ผ์€ ํ•จ์ˆ˜ ํ•˜๋‚˜๊ฐ€ ์‚ฌ๋ผ์งˆ ๋•Œ๋งˆ๋‹ค ๋นˆ๋ฒˆํ•˜๊ฒŒ ์ผ์–ด๋‚œ๋‹ค.
๊ฐ€์žฅ ํ™œ๋ฐœํ•˜๊ฒŒ ๊ณต๊ฐ„์ด ์ฐจ๊ณ  ๋น„์›Œ์ง€๋Š” ๊ณณ์ธ ์…ˆ์ด๋‹ค.

โ‡ฒ Heap ์˜์—ญ์€

๋™์  ํ• ๋‹น์„ ๋ฐ›์•„์˜ค๋Š” ์žฅ์†Œ๋‹ค. ๋™์  ํ• ๋‹น ๋ฐ›์€ ๊ณต๊ฐ„์€ ์šฐ๋ฆฌ๊ฐ€ ๋ณ„๋„์˜ ๋ช…๋ น์–ด(C๋ผ๋ฉด free(), C++์ด๋ผ๋ฉด Delete())๋ฅผ ์ด์šฉํ•ด ํ•ด์ œํ•ด์ฃผ๊ธฐ ์ „๊นŒ์ง€๋Š” ์‚ฌ๋ผ์ง€์ง€ ์•Š๋Š”๋‹ค.
๋™์  ํ• ๋‹น์€ ํ”„๋กœ๊ทธ๋žจ ์‹คํ–‰ ์ค‘์— ๋ฐœ์ƒํ•˜๋ฏ€๋กœ Heap์€ ๋™์  ๋ฉ”๋ชจ๋ฆฌ์ด๋‹ค.

โœจ ์ •์  ๋ฉ”๋ชจ๋ฆฌ ํ• ๋‹น


๋ฉ”๋ชจ๋ฆฌ์˜ ์˜์—ญ์— ๋Œ€ํ•ด์„œ ์ •๋ฆฌํ•˜๋Š๋ผ ์ด์•ผ๊ธฐ๊ฐ€ ๊ธธ์–ด์กŒ๋Š”๋ฐ ์ด์ œ ์ •์  ํ• ๋‹น์— ๋Œ€ํ•ด์„œ ์ •๋ฆฌํ•ด๋ณด๋ ค๊ณ  ํ•œ๋‹ค
์ •์  ํ• ๋‹น์€ ์•„๊นŒ ์œ„์—์„œ๋„ ์ž‘์„ฑํ–ˆ์ง€๋งŒ ์ปดํŒŒ์ผ ๋‹จ๊ณ„์—์„œ ๋ฉ”๋ชจ๋ฆฌ ๊ณต๊ฐ„์„ ํ• ๋‹น๋ฐ›๋Š” ๊ฒƒ์ด๋‹ค.
๋Œ€ํ‘œ์ ์ธ ์˜ˆ์‹œ๋กœ๋Š” ๋ณ€์ˆ˜๋‚˜ ๋ฐฐ์—ด์„ ์„ ์–ธํ•˜๋Š” ๊ฒƒ์„ ๋“ค ์ˆ˜ ์žˆ๋‹ค.
ํ•œ ๋ฒˆ ์ปดํŒŒ์ผ์„ ์‹œ์ž‘ํ•˜๋ฉด ๊ทธ๋•Œ๋ถ€ํ„ฐ๋Š” ๋‘ ์ด์ƒ ์ถ”๊ฐ€์ ์œผ๋กœ ๋ฐฐ์—ด์„ ์„ ์–ธํ•  ์ˆ˜ ์—†๋‹ค.

๐Ÿ’ป ์†Œ์Šค ์ฝ”๋“œ

int i, j;
int buffer [100];
char name[] = "data structure";

โœจ ๋™์  ๋ฉ”๋ชจ๋ฆฌ ํ• ๋‹น


ํ”„๋กœ๊ทธ๋žจ ์‹คํ–‰ ๋„์ค‘์— ๋™์ ์œผ๋กœ ๋ฉ”๋ชจ๋ฆฌ๋ฅผ ํ• ๋‹นํ•˜๋ฉฐ ์ปดํŒŒ์ผ ํ•  ๋•Œ ๋ฏธ๋ฆฌ ์ •ํ•ด์ง€๋Š” ๊ฒƒ์ด ์•„๋‹Œ
์‹คํ–‰ ๋‹จ๊ณ„์—์„œ ๊ณต๊ฐ„์ด ์ •ํ•ด์ง€๋Š” ๊ธฐ๋Šฅ์„ ๊ฐ€์ง€๊ณ  ์žˆ์œผ๋ฉฐ ๋งค์šฐ ํšจ์œจ์ ์ด๋‹ค.

์ปดํŒŒ์ผ ํ•  ๋•Œ ๋ฏธ๋ฆฌ ์•ˆ์ •ํ•ด์ง„๋‹ค๋Š” ํšจ์œจ์ ์ด๋ผ๋Š” ์žฅ์ ์„ ๊ฐ€์ง€๊ณ  ์žˆ์œผ๋‚˜ ์†Œ์Šค์ฝ”๋“œ๊ฐ€ ๋งค์šฐ ๋ณต์žกํ•˜๋‹ค๋Š” ๋‹จ์ ์„ ๊ฐ€์ง€๊ณ  ์žˆ๋‹ค.

๐Ÿ’ป ์†Œ์Šค ์ฝ”๋“œ

#include <stdlib.h> //๋™์  ๋ฉ”๋ชจ๋ฆฌ ๊ด€๋ จ ํ•จ์ˆ˜ ๋ถˆ๋Ÿฌ์˜ค๊ธฐ

...
int *ptr = NULL;
int size = 100;

ptr = (int*) malloc (sizeof(int)*size); // malloc() ๋ฉ”๋ชจ๋ฆฌ ํ• ๋‹น
...

free ( ptr ); // ๋ฉ”๋ชจ๋ฆฌ ํ•ด์ œ

โŒจ๏ธ ํ•จ์ˆ˜


โ‡ฒ malloc() ํ•จ์ˆ˜

#include <stdlib.h> ํ—ค๋” ์•ˆ์— ์žˆ๋Š” ํ•จ์ˆ˜์ด๋ฉฐ malloc ํ•จ์ˆ˜๋Š” ๋ฐ”์ดํŠธ ๋‹จ์œ„๋กœ ๋ฉ”๋ชจ๋ฆฌ๋ฅผ ํ• ๋‹นํ•ฉ๋‹ˆ๋‹ค.
๋ฉ”๋ชจ๋ฆฌ ๋ธ”๋Ÿญ์˜ ์ฒซ ๋ฒˆ์งธ ๋ฐ”์ดํŠธ์— ๋Œ€ํ•œ ์ฃผ์†Œ๋ฅผ ๋ฐ˜ํ™˜ํ•˜๋Š”๋ฐ, ์š”์ฒญ ๊ฐ’์ด ์—†์œผ๋ฉด NULL์„ ๋ฐ˜ํ™˜ํ•ฉ๋‹ˆ๋‹ค.

intํ˜• ๋ฐ์ดํ„ฐ ์ €์žฅ์„ ์œ„ํ•œ ๋ฉ”๋ชจ๋ฆฌ ๊ณต๊ฐ„์„ ์œ„ํ•ด์„œ๋Š”

int *p;
p = (int*) malloc(sizeof(int));

charํ˜• ๋ฐ์ดํ„ฐ ์ €์žฅ์„ ์œ„ํ•œ ๋ฉ”๋ชจ๋ฆฌ ๊ณต๊ฐ„์„ ์œ„ํ•ด์„œ๋Š”

char *p;
p = (char*) malloc( sizeof(char));

โ‡ฒ free() ํ•จ์ˆ˜

void free(void *ptr);

์œ„์™€ ๊ฐ™์€ ํ˜•ํƒœ๋กœ ptr์— ํ• ๋‹น๋˜์—ˆ๋˜ ๋ฉ”๋ชจ๋ฆฌ ๋ธ”๋ก์„ ์‹œ์Šคํ…œ์— ๋ฐ˜๋‚ฉํ•œ๋‹ค.
๋ฐ˜๋‚ฉํ• ๋•Œ๋Š” value๋ฅผ ์จ์ค˜์•ผํ•˜๊ธฐ ๋•Œ๋ฌธ์— *๋ฅผ ๋ถ™์ธ๋‹ค.

์‹ค์ œ๋กœ๋Š” ๋‹ค์Œ๊ณผ ๊ฐ™์ด ์‚ฌ์šฉ๋œ๋‹ค.

int *p;
p = (int*) malloc(sizeof(int));
free(p);

โœจ ํฌ์ธํ„ฐ๋ฅผ ์ด์šฉํ•œ ๋ฉ”๋ชจ๋ฆฌ ํ• ๋‹น


์ด๋ ‡๋“ฏ ๋™์  ๋ฉ”๋ชจ๋ฆฌ ํ• ๋‹น์€ 'ํฌ์ธํ„ฐ'๋กœ ์ด๋ฃจ์–ด์ง„๋‹ค.
ํฌ์ธํ„ฐ๊ฐ€ ๊ฐ’์ด ํ• ๋‹น๋œ ์ฃผ์†Œ๋ฅผ ๊ฐ€๋ฆฌํ‚ค๋‹ˆ ํฌ์ธํ„ฐ๋ฅผ ํ™œ์šฉํ•˜๋Š” ๊ฒƒ์€ ๋‹น์—ฐํ•˜๋ฉฐ ๋™์  ๋ฉ”๋ชจ๋ฆฌ๊ฐ€ ์‚ฌ์šฉ๋˜๊ณ  ๋‹ค์‹œ ๋ฐ˜๋‚ฉ๋˜๋Š” ๊ณผ์ •์„ ๋ณด๋„๋ก ํ•˜์ž

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

int main(void) {
int *pi = NULL; char *pc = NULL;

    pi = (int *) malloc ( sizeof(int) ); // ๋™์  ๋ฉ”๋ชจ๋ฆฌ ํ• ๋‹น
    if ( pi == NULL ) { printf("๋™์  ๋ฉ”๋ชจ๋ฆฌ ํ• ๋‹น ์˜ค๋ฅ˜\n"); exit(1); }
      *pi = 100; // ๋™์  ๋ฉ”๋ชจ๋ฆฌ ์‚ฌ์šฉ
      printf("%d\n", *pi);
    free(pi); // ๋™์  ๋ฉ”๋ชจ๋ฆฌ ๋ฐ˜๋‚ฉ

    pc = (char *) malloc ( sizeof(char) ); // ๋™์  ๋ฉ”๋ชจ๋ฆฌ ํ• ๋‹น
    if ( pc == NULL ) { printf("๋™์  ๋ฉ”๋ชจ๋ฆฌ ํ• ๋‹น ์˜ค๋ฅ˜\n" ); exit(1); }
      *pc = 'm'; // ๋™์  ๋ฉ”๋ชจ๋ฆฌ ์‚ฌ์šฉ
      printf("%c\n", *pc);
    free(pc); // ๋™์  ๋ฉ”๋ชจ๋ฆฌ ๋ฐ˜๋‚ฉ

  return 0;
}

์‹ค์ œ ๊ฐ’์„ ์ง€์ •ํ•˜์ง€ ์•Š๊ณ  pi, pc๋งŒ์„ ๊ฐ€์ •ํ•œ๋‹ค. mallocํ•จ์ˆ˜๋กœ ๋™์  ๋ฉ”๋ชจ๋ฆฌ๋ฅผ ํ• ๋‹นํ•˜๊ณ  ์‹ค์ œ๋กœ ์‚ฌ์šฉํ•œ๋‹ค.

๊ทธ๋ฆฌ๊ณ  ๋งˆ์ง€๋ง‰์œผ๋กœ freeํ•จ์ˆ˜๋กœ ๋™์  ๋ฉ”๋ชจ๋ฆฌ๋ฅผ ๋ฐ˜๋‚ฉํ•œ๋‹ค!!

ํฌ์ธํ„ฐ๋กœ ๋ฐฐ์—ด์„ ์ง€๋ชฉํ•˜๋Š” ๋ฐฉ๋ฒ•๋„ ์–ด๋ ต์ง€ ์•Š๋‹ค.

#include <stdio.h>
#include <malloc.h>
int main(void) {
    int i, size=5;
    int *arr;

    arr = (int*) malloc ( sizeof(int) * size );

    for ( i=0; i<size; i++ ) {
        arr[i] = i;
    }
    for ( i=0; i<size; i++ ) {
    	printf("%d\n", *(arr+i));
    }
    free (arr);
    return 0;
}

๊ทธ ์™ธ์˜ ๋™์  ๋ฉ”๋ชจ๋ฆฌ ํ•จ์ˆ˜๋“ค

calloc()

void *calloc(size_t n, size_t size);
0์œผ๋กœ ์ดˆ๊ธฐํ™”๋œ ๋ฉ”๋ชจ๋ฆฌ๋ฅผ ํ• ๋‹นํ•˜๋Š” ํ•จ์ˆ˜๋‹ค.

realloc()

void *realloc(void *memblock, size_t size);
ํ• ๋‹นํ•˜์˜€๋˜ ๋ฉ”๋ชจ๋ฆฌ ๋ธ”๋ก์˜ ํฌ๊ธฐ๋ฅผ ๋ณ€๊ฒฝํ•˜๋Š” ๊ฒƒ์ด๋‹ค.
malloc์—์„œ ์ง€์ •ํ•ด์คฌ๋˜ ์‚ฌ์ด์ฆˆ๋ฅผ ๋‹ค์‹œ ํ‚ค์šฐ๊ฑฐ๋‚˜ ์ค„์ด๋Š” ์ž‘์—…์ด ํ•„์š”ํ•  ๋•Œ ์“ด๋‹ค.

int *p;
p = (int*) malloc (5 * sizeof(int));
p = (int*) realloc (p, 7 * sizeof(int));
profile
์•ˆ๋…•ํ•˜์„ธ์š”

0๊ฐœ์˜ ๋Œ“๊ธ€