λ³Έλ¬Έ λ°”λ‘œκ°€κΈ°
μΉ΄ν…Œκ³ λ¦¬ μ—†μŒ

λ©”λͺ¨λ¦¬ 동적 ν• λ‹Ή (new, delete)

by 5566 2023. 9. 19.

1. λ©”λͺ¨λ¦¬ 동적 ν• λ‹Ήμ˜ κ°œλ… 이해

λ©”λͺ¨λ¦¬ 동적 할당은 ν”„λ‘œκ·Έλž¨ μ‹€ν–‰ 쀑에 ν•„μš”ν•œ λ©”λͺ¨λ¦¬ 곡간을 ν• λ‹Ήν•˜κ³  μ‚¬μš©ν•˜λŠ” κΈ°μˆ μž…λ‹ˆλ‹€. 정적 ν• λ‹Ήκ³ΌλŠ” 달리, ν”„λ‘œκ·Έλž¨μ΄ μ‹€ν–‰λ˜λŠ” λ™μ•ˆμ— λ™μ μœΌλ‘œ ν•„μš”ν•œ 만큼의 λ©”λͺ¨λ¦¬λ₯Ό ν• λ‹Ήν•˜κ³  ν•΄μ œν•  수 μžˆμŠ΅λ‹ˆλ‹€. μ΄λŠ” ν”„λ‘œκ·Έλž¨μ˜ μœ μ—°μ„±κ³Ό νš¨μœ¨μ„±μ„ λ†’μ΄λŠ”λ° 도움을 μ€λ‹ˆλ‹€.

λ©”λͺ¨λ¦¬ 동적 할당은 주둜 'new'와 'delete' μ—°μ‚°μžλ₯Ό μ΄μš©ν•˜μ—¬ μˆ˜ν–‰λ©λ‹ˆλ‹€. 'new' μ—°μ‚°μžλŠ” λ©”λͺ¨λ¦¬λ₯Ό ν• λ‹Ήν•˜κ³ , 'delete' μ—°μ‚°μžλŠ” ν• λ‹Ήλœ λ©”λͺ¨λ¦¬λ₯Ό ν•΄μ œν•˜λŠ” 역할을 ν•©λ‹ˆλ‹€. λ©”λͺ¨λ¦¬ 동적 할당을 μ‚¬μš©ν•˜λŠ” μ£Όμš” μ΄μœ λŠ” λ‹€μŒκ³Ό κ°™μŠ΅λ‹ˆλ‹€:

  • ν•„μš”ν•œ 만큼의 λ©”λͺ¨λ¦¬ 곡간을 λ™μ μœΌλ‘œ ν• λ‹Ήν•˜μ—¬ μžμ›μ„ 효율적으둜 관리할 수 μžˆμŠ΅λ‹ˆλ‹€.
  • ν”„λ‘œκ·Έλž¨μ˜ μ‹€ν–‰ 쀑에 ν•„μš”ν•œ λ©”λͺ¨λ¦¬μ˜ 크기와 생λͺ…μ£ΌκΈ°λ₯Ό λ™μ μœΌλ‘œ μ‘°μ ˆν•  수 μžˆμŠ΅λ‹ˆλ‹€.
  • μ€‘λ³΅λœ μ½”λ“œμ˜ 생성을 λ°©μ§€ν•˜μ—¬ μ½”λ“œμ˜ μž¬μ‚¬μš©μ„±κ³Ό 가독성을 높일 수 μžˆμŠ΅λ‹ˆλ‹€.

λ©”λͺ¨λ¦¬ 동적 할당은 ν”„λ‘œκ·Έλž¨ κ°œλ°œν•  λ•Œ 많이 μ‚¬μš©λ˜λ©°, 특히 데이터 ꡬ쑰와 κ΄€λ ¨λœ μž‘μ—…μ—μ„œ μœ μš©ν•©λ‹ˆλ‹€. ν•˜μ§€λ§Œ λΆ€μ μ ˆν•˜κ²Œ μ‚¬μš©ν•˜κ±°λ‚˜ κ΄€λ¦¬ν•˜μ§€ μ•Šμ„ 경우 λ©”λͺ¨λ¦¬ λˆ„μˆ˜(memory leak)와 같은 λ¬Έμ œκ°€ λ°œμƒν•  수 μžˆμœΌλ―€λ‘œ 쑰심해야 ν•©λ‹ˆλ‹€. 이에 λŒ€ν•œ μžμ„Έν•œ λ‚΄μš©μ€ 이후 ν•­λͺ©μ—μ„œ 닀루도둝 ν•˜κ² μŠ΅λ‹ˆλ‹€.

2. 동적 할당을 μœ„ν•œ 'new' μ—°μ‚°μž

λ©”λͺ¨λ¦¬ 동적 할당을 μœ„ν•΄ C++μ—μ„œλŠ” 'new' μ—°μ‚°μžλ₯Ό μ œκ³΅ν•©λ‹ˆλ‹€. 'new' μ—°μ‚°μžλŠ” νž™(heap)μ΄λΌλŠ” λ©”λͺ¨λ¦¬ μ˜μ—­μ—μ„œ λ™μ μœΌλ‘œ λ©”λͺ¨λ¦¬λ₯Ό ν• λ‹Ήν•΄μ€λ‹ˆλ‹€.

λ™μ μœΌλ‘œ ν• λ‹Ήλœ λ©”λͺ¨λ¦¬λŠ” λ‹€μŒκ³Ό 같은 ν˜•μ‹μœΌλ‘œ μ‚¬μš©λ©λ‹ˆλ‹€:

포인터_μžλ£Œν˜• λ³€μˆ˜_이름 = new μžλ£Œν˜•;

μœ„μ˜ λ¬Έλ²•μ—μ„œ 포인터_μžλ£Œν˜•μ€ λ™μ μœΌλ‘œ ν• λ‹Ήλœ λ©”λͺ¨λ¦¬μ˜ μ£Όμ†Œλ₯Ό μ €μž₯ν•˜λŠ” λ³€μˆ˜μ˜ μžλ£Œν˜•μ„ μ˜λ―Έν•©λ‹ˆλ‹€. λ³€μˆ˜_이름은 ν•΄λ‹Ή λ³€μˆ˜λ₯Ό μ‹λ³„ν•˜κΈ° μœ„ν•œ 이름을 μ§€μ •ν•˜λ©°, μžλ£Œν˜•μ€ ν• λ‹Ήλœ λ©”λͺ¨λ¦¬ κ³΅κ°„μ˜ μžλ£Œν˜•μ„ μ§€μ •ν•©λ‹ˆλ‹€.

예λ₯Ό λ“€μ–΄, μ •μˆ˜ν˜• λ³€μˆ˜μ˜ λ©”λͺ¨λ¦¬λ₯Ό λ™μ μœΌλ‘œ ν• λ‹Ήν•˜λ €λ©΄ λ‹€μŒκ³Ό 같이 μž‘μ„±ν•  수 μžˆμŠ΅λ‹ˆλ‹€:

int* ptr = new int;

μœ„μ˜ μ˜ˆμ œμ—μ„œλŠ” 'new int'λ₯Ό 톡해 μ •μˆ˜ν˜• 크기의 λ©”λͺ¨λ¦¬λ₯Ό λ™μ μœΌλ‘œ ν• λ‹Ήν•˜κ³ , κ·Έ μ£Όμ†Œλ₯Ό ptr λ³€μˆ˜μ— μ €μž₯ν•˜μ˜€μŠ΅λ‹ˆλ‹€.

ν• λ‹Ήλœ λ©”λͺ¨λ¦¬λŠ” ν•΄λ‹Ή 포인터 λ³€μˆ˜λ₯Ό 톡해 μ ‘κ·Όν•  수 μžˆμŠ΅λ‹ˆλ‹€. 이λ₯Ό 톡해 값을 ν• λ‹Ήν•˜κ±°λ‚˜ λ©”λͺ¨λ¦¬μ— μ ‘κ·Όν•  수 μžˆμŠ΅λ‹ˆλ‹€.

*ptr = 10; // λ©”λͺ¨λ¦¬μ— 10을 ν• λ‹Ή
cout << *ptr; // λ©”λͺ¨λ¦¬μ˜ 값을 좜λ ₯ (좜λ ₯ κ²°κ³Ό: 10)

λ™μ μœΌλ‘œ ν• λ‹Ήν•œ λ©”λͺ¨λ¦¬λŠ” 더 이상 μ‚¬μš©ν•˜μ§€ μ•Šμ„ λ•Œ ν•΄μ œν•΄μ£Όμ–΄μ•Ό ν•©λ‹ˆλ‹€. ν•΄μ œλŠ” 'delete' μ—°μ‚°μžλ₯Ό 톡해 μ΄λ£¨μ–΄μ§‘λ‹ˆλ‹€.

delete λ³€μˆ˜_이름;

μœ„μ˜ μ˜ˆμ œμ—μ„œλŠ” λ‹€μŒκ³Ό 같이 μž‘μ„±λ©λ‹ˆλ‹€:

delete ptr; // λ©”λͺ¨λ¦¬ ν•΄μ œ

'malloc' ν•¨μˆ˜μ™€ 달리 'new' μ—°μ‚°μžλŠ” μžλ£Œν˜•μ˜ 크기λ₯Ό κ³ λ €ν•˜μ—¬ λ©”λͺ¨λ¦¬λ₯Ό ν• λ‹Ήν•˜λ―€λ‘œ, ν• λ‹Ήλœ λ©”λͺ¨λ¦¬μ— λŒ€ν•œ ν˜•λ³€ν™˜ μž‘μ—…μ„ λ”°λ‘œ μˆ˜ν–‰ν•  ν•„μš”κ°€ μ—†μŠ΅λ‹ˆλ‹€. λ˜ν•œ, 'new' μ—°μ‚°μžλ₯Ό μ΄μš©ν•œ 동적 할당은 μžλ™μœΌλ‘œ ν• λ‹Ήλœ λ©”λͺ¨λ¦¬μ˜ μƒμ„±μž(constructor)λ₯Ό ν˜ΈμΆœν•˜κ³ , ν•΄μ œ μ‹œ μ†Œλ©Έμž(destructor)λ₯Ό ν˜ΈμΆœν•˜λ―€λ‘œ 객체 지ν–₯적인 ν”„λ‘œκ·Έλž˜λ°μ—μ„œ μœ μš©ν•˜κ²Œ μ‚¬μš©λ©λ‹ˆλ‹€.

3. 동적 ν• λ‹Ήλœ λ©”λͺ¨λ¦¬μ˜ μ‚¬μš©κ³Ό ν•΄μ œ

λ™μ μœΌλ‘œ ν• λ‹Ήλœ λ©”λͺ¨λ¦¬λŠ” 'new' μ—°μ‚°μžλ₯Ό 톡해 얻을 수 있으며, ν•„μš”ν•œ 만큼의 곡간을 ν• λ‹Ή 받을 수 μžˆμŠ΅λ‹ˆλ‹€. μ—¬κΈ°μ„œλŠ” 동적 ν• λ‹Ήλœ λ©”λͺ¨λ¦¬μ˜ μ‚¬μš©κ³Ό ν•΄μ œμ— λŒ€ν•΄ μžμ„Ένžˆ μ•Œμ•„λ³΄κ² μŠ΅λ‹ˆλ‹€.

λ©”λͺ¨λ¦¬ μ‚¬μš©ν•˜κΈ°

λ™μ μœΌλ‘œ ν• λ‹Ήλœ λ©”λͺ¨λ¦¬λŠ” 포인터 λ³€μˆ˜λ₯Ό μ΄μš©ν•˜μ—¬ μ ‘κ·Όν•  수 μžˆμŠ΅λ‹ˆλ‹€. 포인터 λ³€μˆ˜λ₯Ό 톡해 ν•΄λ‹Ή λ©”λͺ¨λ¦¬ μ£Όμ†Œμ— 값을 ν• λ‹Ήν•˜κ±°λ‚˜ 값을 읽을 수 μžˆμŠ΅λ‹ˆλ‹€.

int* ptr = new int; // λ™μ μœΌλ‘œ μ •μˆ˜ν˜• λ©”λͺ¨λ¦¬ ν• λ‹Ή
*ptr = 10; // λ©”λͺ¨λ¦¬μ— 10 ν• λ‹Ή
cout << *ptr; // λ©”λͺ¨λ¦¬ κ°’ 좜λ ₯ (좜λ ₯ κ²°κ³Ό: 10)

μœ„μ˜ μ˜ˆμ œμ—μ„œλŠ” 'new int'λ₯Ό 톡해 μ •μˆ˜ν˜• 크기의 λ©”λͺ¨λ¦¬λ₯Ό λ™μ μœΌλ‘œ ν• λ‹Ήν•˜κ³ , κ·Έ μ£Όμ†Œλ₯Ό ptr λ³€μˆ˜μ— μ €μž₯ν–ˆμŠ΅λ‹ˆλ‹€. 그리고 포인터 '*'λ₯Ό μ΄μš©ν•˜μ—¬ λ©”λͺ¨λ¦¬μ— κ°’ 10을 ν• λ‹Ήν•˜κ³ , 이λ₯Ό 좜λ ₯ν•˜μ˜€μŠ΅λ‹ˆλ‹€.

λ™μ μœΌλ‘œ ν• λ‹Ήν•œ λ©”λͺ¨λ¦¬λŠ” λ³€μˆ˜κ°€ 블둝(scope)을 λ²—μ–΄λ‚˜λ”λΌλ„ μœ μ§€λ©λ‹ˆλ‹€. 즉, ν•¨μˆ˜κ°€ μ’…λ£Œλ˜λ”λΌλ„ ν• λ‹Ήλœ λ©”λͺ¨λ¦¬λŠ” κ·ΈλŒ€λ‘œ μœ μ§€λ©λ‹ˆλ‹€. μ΄λŠ” 정적 λ³€μˆ˜μ™€λŠ” 달리 λ™μ μœΌλ‘œ ν• λ‹Ήλœ λ©”λͺ¨λ¦¬μ˜ 생λͺ…μ£ΌκΈ°κ°€ ν•¨μˆ˜ λ‚΄μ—μ„œλ§Œ μœ νš¨ν•˜λ‹€λŠ” 것을 μ˜λ―Έν•©λ‹ˆλ‹€.

λ©”λͺ¨λ¦¬ ν•΄μ œν•˜κΈ°

λ™μ μœΌλ‘œ ν• λ‹Ήλœ λ©”λͺ¨λ¦¬λŠ” μ‚¬μš©μ΄ μ™„λ£Œλ˜λ©΄ ν•΄μ œλ˜μ–΄μ•Ό ν•©λ‹ˆλ‹€. ν•΄μ œλ˜μ§€ μ•Šμ€ 동적 λ©”λͺ¨λ¦¬λŠ” λ©”λͺ¨λ¦¬ λˆ„μˆ˜(memory leak)λ₯Ό λ°œμƒμ‹œν‚¬ 수 있으며, μ΄λŠ” μ‹œμŠ€ν…œ μžμ›μ„ κ³ κ°ˆμ‹œν‚¬ 수 μžˆμŠ΅λ‹ˆλ‹€.

λ©”λͺ¨λ¦¬μ˜ ν•΄μ œλŠ” 'delete' μ—°μ‚°μžλ₯Ό 톡해 μ΄λ£¨μ–΄μ§‘λ‹ˆλ‹€.

delete ptr; // λ©”λͺ¨λ¦¬ ν•΄μ œ

μœ„μ˜ μ˜ˆμ œμ—μ„œλŠ” 'ptr' λ³€μˆ˜μ— ν• λ‹Ήλœ λ©”λͺ¨λ¦¬λ₯Ό 'delete' μ—°μ‚°μžλ₯Ό μ‚¬μš©ν•˜μ—¬ ν•΄μ œν•˜μ˜€μŠ΅λ‹ˆλ‹€.

λ©”λͺ¨λ¦¬κ°€ ν•΄μ œλœ ν›„μ—λŠ” ν•΄λ‹Ή λ©”λͺ¨λ¦¬λ₯Ό λ‹€μ‹œ μ ‘κ·Όν•΄μ„œλŠ” μ•ˆλ©λ‹ˆλ‹€. ν•΄μ œλœ λ©”λͺ¨λ¦¬μ— μ ‘κ·Όν•˜λ©΄ 예기치 μ•Šμ€ λ™μž‘μ΄ λ°œμƒν•  수 μžˆμŠ΅λ‹ˆλ‹€. λ”°λΌμ„œ λ©”λͺ¨λ¦¬λ₯Ό ν•΄μ œν•œ ν›„μ—λŠ” ν•΄λ‹Ή 포인터 λ³€μˆ˜λ₯Ό 잘 관리해야 ν•©λ‹ˆλ‹€. 일반적으둜 ν• λ‹Ήλœ λ©”λͺ¨λ¦¬λ₯Ό ν•΄μ œν•œ ν›„μ—λŠ” 포인터 λ³€μˆ˜λ₯Ό 'nullptr'둜 μ΄ˆκΈ°ν™”ν•˜λŠ” 것이 μ’‹μŠ΅λ‹ˆλ‹€.

delete ptr; // λ©”λͺ¨λ¦¬ ν•΄μ œ
ptr = nullptr; // 포인터 μ΄ˆκΈ°ν™”

λ©”λͺ¨λ¦¬ ν•΄μ œλŠ” ν•΄λ‹Ή λ©”λͺ¨λ¦¬λ₯Ό λ™μ μœΌλ‘œ ν• λ‹Ήν•œ λ‹€μŒ 'delete' μ—°μ‚°μžλ₯Ό μ‚¬μš©ν•˜μ—¬ ν•΄μ œν•΄μ•Ό ν•©λ‹ˆλ‹€. μ •μ μœΌλ‘œ ν• λ‹Ήλœ λ©”λͺ¨λ¦¬λ‚˜ μŠ€νƒμ˜ λ³€μˆ˜λŠ” 'delete' μ—°μ‚°μžλ‘œ ν•΄μ œν•˜λ©΄ μ•ˆλ©λ‹ˆλ‹€. λ˜ν•œ, λ™μΌν•œ λ©”λͺ¨λ¦¬λ₯Ό 두 번 이상 ν•΄μ œν•˜κ±°λ‚˜ λ‹€λ₯Έ ν¬μΈν„°λ‘œ ν•΄μ œν•˜λŠ” 것도 문제λ₯Ό λ°œμƒμ‹œν‚¬ 수 μžˆμœΌλ―€λ‘œ μ£Όμ˜ν•΄μ•Ό ν•©λ‹ˆλ‹€.

4. λ©”λͺ¨λ¦¬ 동적 ν• λ‹Ήμ˜ ν™œμš© μ˜ˆμ‹œμ™€ μž₯단점

λ©”λͺ¨λ¦¬ 동적 할당은 ν•„μš”ν•œ 만큼의 λ©”λͺ¨λ¦¬ 곡간을 ν• λ‹Ήν•˜μ—¬ ν”„λ‘œκ·Έλž¨μ„ 효율적으둜 관리할 수 있게 ν•΄μ€λ‹ˆλ‹€. μ΄λ²ˆμ—λŠ” λ©”λͺ¨λ¦¬ 동적 ν• λ‹Ήμ˜ ν™œμš© μ˜ˆμ‹œμ™€ μž₯단점에 λŒ€ν•΄ μ•Œμ•„λ³΄κ² μŠ΅λ‹ˆλ‹€.

ν™œμš© μ˜ˆμ‹œ

λ©”λͺ¨λ¦¬ 동적 할당은 ν”„λ‘œκ·Έλž¨μ—μ„œ 가변적인 크기의 데이터λ₯Ό λ‹€λ£° λ•Œ 특히 μœ μš©ν•©λ‹ˆλ‹€. 예λ₯Ό λ“€μ–΄, μ‚¬μš©μžλ‘œλΆ€ν„° μž…λ ₯ 받은 μ •μˆ˜μ˜ κ°œμˆ˜μ— 따라 배열을 λ™μ μœΌλ‘œ ν• λ‹Ήν•˜μ—¬ μ²˜λ¦¬ν•˜λŠ” 경우λ₯Ό μ‚΄νŽ΄λ΄…μ‹œλ‹€.

int num;
cout << "λ°°μ—΄μ˜ 크기λ₯Ό μž…λ ₯ν•˜μ„Έμš”: ";
cin >> num;

int* arr = new int[num]; // μ‚¬μš©μžλ‘œλΆ€ν„° μž…λ ₯ 받은 크기둜 배열을 동적 ν• λ‹Ή

for (int i = 0; i < num; i++) {
    cout << "μ •μˆ˜λ₯Ό μž…λ ₯ν•˜μ„Έμš”: ";
    cin >> arr[i];
}

for (int i = 0; i < num; i++) {
    cout << arr[i] << " ";
}

delete[] arr; // λ°°μ—΄ λ©”λͺ¨λ¦¬ ν•΄μ œ

μœ„μ˜ μ˜ˆμ œμ—μ„œλŠ” μ‚¬μš©μžλ‘œλΆ€ν„° λ°°μ—΄μ˜ 크기λ₯Ό μž…λ ₯λ°›κ³ , κ·Έ 크기둜 μ •μˆ˜ν˜• 배열을 λ™μ μœΌλ‘œ ν• λ‹Ήν•©λ‹ˆλ‹€. μ‚¬μš©μžλŠ” μž…λ ₯ν•œ 크기만큼 μ •μˆ˜λ₯Ό μž…λ ₯ν•˜κ³ , μž…λ ₯ν•œ 값듀을 좜λ ₯ν•©λ‹ˆλ‹€. λ§ˆμ§€λ§‰μœΌλ‘œ λ°°μ—΄ λ©”λͺ¨λ¦¬λ₯Ό ν•΄μ œν•©λ‹ˆλ‹€.

λ©”λͺ¨λ¦¬ 동적 할당은 λ°°μ—΄ 뿐만 μ•„λ‹ˆλΌ 객체 지ν–₯적인 ν”„λ‘œκ·Έλž˜λ°μ—μ„œλ„ μœ μš©ν•˜κ²Œ μ‚¬μš©λ©λ‹ˆλ‹€. 클래슀의 동적 생성과 ν•΄μ œλŠ” 객체의 수λͺ…을 λ™μ μœΌλ‘œ μ œμ–΄ν•  수 있게 ν•΄μ£Όλ©°, 볡사 μƒμ„±μžμ™€ λŒ€μž… μ—°μ‚°μžλ₯Ό 적절히 μ •μ˜ν•¨μœΌλ‘œμ¨ 얕은 볡사(shallow copy)와 λ©”λͺ¨λ¦¬ λˆ„μˆ˜λ₯Ό ν”Όν•  수 μžˆμŠ΅λ‹ˆλ‹€.

μž₯단점

λ©”λͺ¨λ¦¬ 동적 ν• λ‹Ήμ˜ μž₯점은 λ‹€μŒκ³Ό κ°™μŠ΅λ‹ˆλ‹€:

  • λ©”λͺ¨λ¦¬μ˜ μœ μ—°ν•œ μ‚¬μš©: 동적 할당을 톡해 ν•„μš”ν•œ 만큼의 λ©”λͺ¨λ¦¬λ₯Ό λ™μ μœΌλ‘œ ν• λ‹Ήν•˜μ—¬ λ©”λͺ¨λ¦¬ 곡간을 효율적으둜 μ‚¬μš©ν•  수 μžˆμŠ΅λ‹ˆλ‹€.
  • 가변적인 데이터 크기 처리: λ°μ΄ν„°μ˜ 크기가 μ‹€ν–‰ μ‹œκ°„μ— κ²°μ •λ˜λŠ” 경우, 동적 할당을 톡해 ν•„μš”ν•œ 크기의 데이터λ₯Ό μ²˜λ¦¬ν•  수 μžˆμŠ΅λ‹ˆλ‹€.
  • 객체 지ν–₯적 ν”„λ‘œκ·Έλž˜λ°μ—μ„œμ˜ ν™œμš©: 동적 할당은 객체의 생성과 μ†Œλ©Έμ„ λ™μ μœΌλ‘œ μ œμ–΄ν•  수 μžˆμ–΄ 객체 지ν–₯적인 ν”„λ‘œκ·Έλž˜λ°μ— μ ν•©ν•©λ‹ˆλ‹€.

ν•˜μ§€λ§Œ λ©”λͺ¨λ¦¬ 동적 할당은 λ‹€μŒκ³Ό 같은 단점도 κ°–κ³  μžˆμŠ΅λ‹ˆλ‹€:

  • λ©”λͺ¨λ¦¬ λˆ„μˆ˜ κ°€λŠ₯μ„±: λ©”λͺ¨λ¦¬ ν•΄μ œλ₯Ό μžŠκ±°λ‚˜, μ‚¬μš©ν•˜μ§€ μ•ŠλŠ”λ°λ„ κ³„μ†ν•΄μ„œ ν• λ‹Ήλœ λ©”λͺ¨λ¦¬λ₯Ό μœ μ§€ν•˜λŠ” 경우 λ©”λͺ¨λ¦¬ λˆ„μˆ˜κ°€ λ°œμƒν•  수 μžˆμŠ΅λ‹ˆλ‹€.
  • μ˜€λ²„ν—€λ“œ: 동적 할당은 λ©”λͺ¨λ¦¬ 관리λ₯Ό μœ„ν•΄ 좔가적인 μ˜€λ²„ν—€λ“œκ°€ λ°œμƒν•˜λ―€λ‘œ, 정적 할당에 λΉ„ν•΄ μ•½κ°„μ˜ μ„±λŠ₯ μ €ν•˜κ°€ μžˆμ„ 수 μžˆμŠ΅λ‹ˆλ‹€.
  • λ³΅μž‘μ„±: ν¬μΈν„°μ˜ μ‚¬μš©μ„±μ„ λ–¨μ–΄λœ¨λ¦΄ 수 있으며, λ©”λͺ¨λ¦¬ ν•΄μ œλ₯Ό μžŠλŠ” 경우 문제λ₯Ό μ•ΌκΈ°ν•  수 μžˆμŠ΅λ‹ˆλ‹€.

λ©”λͺ¨λ¦¬ 동적 할당은 ν•„μš”ν•œ κ²½μš°μ— 적절히 ν™œμš©ν•˜μ—¬ λ©”λͺ¨λ¦¬ 관리λ₯Ό 효과적으둜 μˆ˜ν–‰ν•  수 μžˆμŠ΅λ‹ˆλ‹€. κ·ΈλŸ¬λ‚˜ ν• λ‹Ήλœ λ©”λͺ¨λ¦¬μ˜ ν•΄μ œλ₯Ό μžŠκ±°λ‚˜, μ μ ˆν•œ μ˜ˆμ™Έ 처리λ₯Ό ν•˜μ§€ μ•ŠμœΌλ©΄ λ©”λͺ¨λ¦¬ λˆ„μˆ˜λ‚˜ λ‹€λ₯Έ λ¬Έμ œκ°€ λ°œμƒν•  수 μžˆμœΌλ―€λ‘œ μ£Όμ˜κ°€ ν•„μš”ν•©λ‹ˆλ‹€.

5. 동적 ν• λ‹Ή μ‹œ λ°œμƒν•  수 μžˆλŠ” λ¬Έμ œμ™€ μ˜ˆμ™Έ 처리 방법

동적 할당은 λ©”λͺ¨λ¦¬λ₯Ό 효율적으둜 μ‚¬μš©ν•˜κΈ° μœ„ν•œ κ°•λ ₯ν•œ κΈ°λŠ₯μ΄μ§€λ§Œ, 잘λͺ» μ‚¬μš©ν•˜κ±°λ‚˜ μ μ ˆν•œ μ˜ˆμ™Έ 처리λ₯Ό ν•˜μ§€ μ•ŠμœΌλ©΄ λ‹€μ–‘ν•œ 문제λ₯Ό λ°œμƒμ‹œν‚¬ 수 μžˆμŠ΅λ‹ˆλ‹€. μ΄λ²ˆμ—λŠ” 동적 ν• λ‹Ή μ‹œ λ°œμƒν•  수 μžˆλŠ” λ¬Έμ œμ™€ μ˜ˆμ™Έ 처리 방법에 λŒ€ν•΄ μ•Œμ•„λ³΄κ² μŠ΅λ‹ˆλ‹€.

문제점

  1. λ©”λͺ¨λ¦¬ λˆ„μˆ˜ (Memory Leak): ν• λ‹Ή 받은 λ©”λͺ¨λ¦¬λ₯Ό ν•΄μ œν•˜μ§€ μ•Šκ³  μžŠμ–΄λ²„λ¦¬λŠ” 경우, ν•΄λ‹Ή λ©”λͺ¨λ¦¬λ₯Ό μ‚¬μš©ν•  수 μ—†κ²Œ λ˜λ©΄μ„œ λ©”λͺ¨λ¦¬ λˆ„μˆ˜κ°€ λ°œμƒν•©λ‹ˆλ‹€. μ΄λŠ” μ‹œμŠ€ν…œ μžμ› 고갈둜 μ΄μ–΄μ§ˆ 수 μžˆμŠ΅λ‹ˆλ‹€.

  2. λŒ•κΈ€λ§ 포인터 (Dangling Pointer): λ©”λͺ¨λ¦¬λ₯Ό ν•΄μ œν•œ 이후에도 ν•΄λ‹Ή λ©”λͺ¨λ¦¬λ₯Ό μ°Έμ‘°ν•  수 있게 되면, λŒ•κΈ€λ§ 포인터가 λ°œμƒν•©λ‹ˆλ‹€. λŒ•κΈ€λ§ ν¬μΈν„°λ‘œ 인해 μ˜ˆμΈ‘ν•  수 μ—†λŠ” λ™μž‘μ΄ λ°œμƒν•  수 μžˆμŠ΅λ‹ˆλ‹€.

  3. 잘λͺ»λœ λ©”λͺ¨λ¦¬ μ°Έμ‘° (Invalid Memory Access): ν• λ‹Ήλœ λ©”λͺ¨λ¦¬ μ˜μ—­μ„ λ²—μ–΄λ‚˜κ±°λ‚˜ 이미 ν•΄μ œλœ λ©”λͺ¨λ¦¬λ₯Ό μ°Έμ‘°ν•˜λŠ” 경우, 잘λͺ»λœ λ©”λͺ¨λ¦¬ μ°Έμ‘°κ°€ λ°œμƒν•©λ‹ˆλ‹€. μ΄λŠ” ν”„λ‘œκ·Έλž¨μ˜ 비정상적인 λ™μž‘μ„ μ•ΌκΈ°ν•  수 μžˆμŠ΅λ‹ˆλ‹€.

μ˜ˆμ™Έ 처리 방법

  1. λ©”λͺ¨λ¦¬ ν•΄μ œ (Memory Deallocation): 동적 ν• λ‹Ήν•œ λ©”λͺ¨λ¦¬λŠ” μ‚¬μš©μ΄ λλ‚˜λ©΄ ν•΄μ œν•΄μ£Όμ–΄μ•Ό ν•©λ‹ˆλ‹€. 'delete' μ—°μ‚°μžλ₯Ό μ‚¬μš©ν•˜μ—¬ ν•΄λ‹Ή λ©”λͺ¨λ¦¬λ₯Ό ν•΄μ œν•˜κ³ , 포인터λ₯Ό 'nullptr'둜 μ΄ˆκΈ°ν™”ν•˜λ©΄ λ©”λͺ¨λ¦¬ λˆ„μˆ˜λ₯Ό 방지할 수 μžˆμŠ΅λ‹ˆλ‹€.
int* ptr = new int;
// ptr을 μ‚¬μš©ν•˜λŠ” μ½”λ“œ...
delete ptr;
ptr = nullptr;
  1. ν• λ‹Ή 였λ₯˜ 처리: 동적 ν• λ‹Ή μ‹œ λ©”λͺ¨λ¦¬ 할당이 μ‹€νŒ¨ν•  수 μžˆμœΌλ―€λ‘œ, 이에 λŒ€ν•œ μ˜ˆμ™Έ 처리λ₯Ό ν•΄μ£Όμ–΄μ•Ό ν•©λ‹ˆλ‹€. 'new' μ—°μ‚°μžλ₯Ό μ‚¬μš©ν•˜μ—¬ λ©”λͺ¨λ¦¬λ₯Ό ν• λ‹Ήν•  λ•Œ 'bad_alloc' μ˜ˆμ™Έκ°€ λ°œμƒν•  수 μžˆμœΌλ―€λ‘œ, 이λ₯Ό 적절히 μ²˜λ¦¬ν•΄μ•Ό ν•©λ‹ˆλ‹€.
try {
    int* ptr = new int;
    // ptr을 μ‚¬μš©ν•˜λŠ” μ½”λ“œ...
    delete ptr;
    ptr = nullptr;
} catch (bad_alloc& e) {
    cout << "λ©”λͺ¨λ¦¬ ν• λ‹Ή 였λ₯˜: " << e.what() << endl;
    // 였λ₯˜ 처리 μ½”λ“œ...
}
  1. μ˜¬λ°”λ₯Έ λ©”λͺ¨λ¦¬ μ°Έμ‘°: λ™μ μœΌλ‘œ ν• λ‹Ήν•œ λ©”λͺ¨λ¦¬λ₯Ό μ‚¬μš©ν•˜λŠ” λ™μ•ˆμ—λŠ” ν•΄λ‹Ή λ©”λͺ¨λ¦¬λ₯Ό μ •μƒμ μœΌλ‘œ μ°Έμ‘°ν•΄μ•Ό ν•©λ‹ˆλ‹€. λ©”λͺ¨λ¦¬λ₯Ό ν•΄μ œν•œ λ’€μ—λŠ” ν•΄λ‹Ή λ©”λͺ¨λ¦¬λ₯Ό 더 이상 μ°Έμ‘°ν•˜μ§€ μ•Šμ•„μ•Ό ν•©λ‹ˆλ‹€. λ˜ν•œ, 포인터 λ³€μˆ˜λ₯Ό λ‹€λ₯Έ λ³€μˆ˜μ— ν• λ‹Ήν•˜λŠ” λ“±μ˜ λ™μž‘μ„ 톡해 λŒ•κΈ€λ§ 포인터 문제λ₯Ό 방지해야 ν•©λ‹ˆλ‹€.
int* ptr = new int;
// ptr을 μ‚¬μš©ν•˜λŠ” μ½”λ“œ...
int* newPtr = ptr; // 동적 ν• λ‹Ήλœ λ©”λͺ¨λ¦¬λ₯Ό λ‹€λ₯Έ 포인터 λ³€μˆ˜μ— ν• λ‹Ή
delete ptr; // λ©”λͺ¨λ¦¬ ν•΄μ œ
ptr = nullptr;
// newPtr을 μ‚¬μš©ν•˜λŠ” μ½”λ“œ...

μ˜¬λ°”λ₯Έ μ˜ˆμ™Έ μ²˜λ¦¬μ™€ μ μ ˆν•œ λ©”λͺ¨λ¦¬ κ΄€λ¦¬λŠ” 동적 할당을 μ•ˆμ „ν•˜κ²Œ μ‚¬μš©ν•˜κΈ° μœ„ν•΄ μ€‘μš”ν•œ μš”μ†Œμž…λ‹ˆλ‹€. 이λ₯Ό 톡해 λ©”λͺ¨λ¦¬ λˆ„μˆ˜, λŒ•κΈ€λ§ 포인터, 잘λͺ»λœ λ©”λͺ¨λ¦¬ 참쑰와 같은 문제λ₯Ό 방지할 수 μžˆμŠ΅λ‹ˆλ‹€.

λŒ“κΈ€