신입 개발자 기술면접 C++ : 스마트 포인터 (🆚GC)

📌RAII 패턴 이란?

RAII (Resource Acquisition Is Initialization)는 C++에서 자주 사용되는 프로그래밍 기법으로, 객체의 생명주기와 자원 관리를 관련짓는 방법론입니다. 이 패턴의 핵심 아이디어는 자원의 할당과 초기화를 객체의 생성과 결부시키고, 자원의 해제를 객체의 소멸과 연결하는 것입니다.

 

RAII는 C++의 스마트 포인터 와 같은 표준 라이브러리 구성 요소에서 널리 사용됩니다. 이들 스마트 포인터는 자동으로 메모리를 관리하여 개발자가 수동으로 new와 delete를 사용하여 메모리를 관리하는 복잡성을 줄여줍니다.

 

📌스마트 포인터란?

#include <memory> 헤더로 사용이 가능하다.

C++ 프로그램에서 new 키워드를 사용하면, delete로 해제할 수 있다.

 

C++은 메모리 릭으로부터 안전하기 위해 스마트 포인터를 사용할 수 있는데, 포인터처럼 동작하는 클래스 템플릿으로 사용이 끝난 메모리를 자동으로 해제해주는 기능을 한다. RAII 패턴의 좋은 예시입니다.

 

📌스마트 포인터의 종류

`unique_ptr`

• unique_ptr 는 하나의 스마트 포인터만이 특정 객체에 대한 단일 소유권을 가집니다. 
• std::move 를 통해서 소유권을 다른 unique_ptr 로 이전할 수 있고, 이 과정에서 원래의 unique_ptr는 null 상태가 됩니다.
• 또한 스마트 포인터가 객체의 소유권을 가지고 있을 때에만 소멸자가 해당 객체를 삭제할 수 있게 합니다. (자동 소멸)
• 스마트 포인터가 소멸될 때 소유한 객체도 자동으로 삭제됩니다.
  • unique_ptr에서 객체를 삭제하는 과정은 자동으로 이루어집니다. unique_ptr이 소멸되면 (예를 들어, 스코프를 벗어나거나 reset 메서드가 호출되었을 때), unique_ptr에 의해 관리되는 객체에 대한 소멸자가 호출되고, 객체가 메모리에서 해제됩니다.
  • unique_ptr의 reset 메소드는 unique_ptr가 현재 가리키고 있는 객체를 삭제하고, 선택적으로 새로운 객체로 소유권을 변경하는 역할을 합니다.
  • 아래 코드에서 첫 번째 reset() 호출은 ptr이 가리키는 int 객체를 삭제하고, ptr을 nullptr로 설정합니다. 두 번째 reset(new int(20)) 호출은 ptr에 새로운 int 객체의 소유권을 부여합니다.

std::unique_ptr<int> ptr(new int(10));

// ptr이 현재 가리키고 있는 객체를 해제하고, nullptr로 설정
ptr.reset();

// ptr에 새로운 객체의 소유권을 부여
ptr.reset(new int(20));

////// 소유권 이전 ////// 
#include <memory>
#include <iostream>

void uniquePtrExample() {
    std::unique_ptr<int> ptr1(new int(10));
    // std::unique_ptr<int> ptr2 = ptr1; // 이 코드는 컴파일 오류를 발생시킵니다.
    std::unique_ptr<int> ptr2 = std::move(ptr1); // ptr1에서 ptr2로 소유권 이전

    if (ptr1 == nullptr) {
        std::cout << "ptr1 is nullptr after move." << std::endl;
    }
}

 

`shared_ptr`

• shared_ptr는 하나의 객체를 여러 스마트 포인터가 공유할 수 있게 합니다.
• 내부적으로 참조 카운트(ref count)를 유지하여, 마지막 shared_ptr가 소멸될 때 객체를 삭제합니다. 즉 참조 횟수가 0이 되면 delete 키워드를 이용하여 해제됩니다. 

`weak_ptr`

• shared_ptr가 가리키는 객체에 대한 약한 참조(weak reference)를 제공합니다.
• weak_ptr는 객체의 소유권을 가지지 않으며, 참조 카운트를 증가시키지 않습니다.
• 순환 참조 문제를 해결하는 데 사용됩니다.
• 즉 shared_ptr 인스턴스가 소유하는 객체에 대한 접근을 제공하지만, 소유자의 수는 포함되지 않는 스마트 포인터로 shared_ptr에서 순환 참조가 일어나는 것을 제거하기 위해 사용한다.

📌사용 방법

기본적으로 new 키워드를 사용하여 기본 포인터가 실제 메모리를 가리키도록 한 후에 기본포인터를 스마트 포인터에 대입하여 사용합니다.

정의된 스마트포인터의 수명이 다하면 소멸자에서 delete키워드를 사용하여 할당된 메모리를 자동으로 해제합니다.

이를 사용하게 되면 따로 메모리를 해제할 필요가 없습니다.

 

📌가비지 컬렉터와 스마트 포인터의 다른 점은?

가비지컬렉터의 경우 메모리를 할당한 변수들을 전부 돌면서 확인하는 꽤 큰 비용의 과정을 거치지만

C++의 스마트포인터는 내가 지정한 변수들에 대해서만 검사를 진행할 수 있다는 큰 강점을 가지고 있다고 생각합니다.

 

성능 오버헤드: 특히, 가비지 컬렉터가 실행될 때 메모리를 스캔하고 청소하는 과정에서 일시적인 성능 저하가 발생할 수 있습니다. 스마트 포인터는 오버헤드가 매우 적거나 없으며, 프로그램 성능에 미치는 영향이 거의 없습니다.

 

GPT 차이점: 가비지 컬렉터는 자동으로 실행되며 전체 메모리를 관리하는 반면, 스마트 포인터는 개발자가 명시적으로 관리할 메모리에만 적용됩니다. 스마트 포인터는 성능에 미치는 영향이 적지만, 가비지 컬렉터는 때때로 성능 저하를 일으킬 수 있습니다.

 

GPT 공통점: 두 방법 모두 메모리 관리를 자동화하여 메모리 누수를 방지하고 프로그램의 안정성을 높이는 데 도움을 줍니다.

 

GPT 우위:

• C++에서는 성능이 중요하고 메모리 관리가 명확해야 하는 상황에서 스마트 포인터가 더 적합할 수 있습니다.
• 반면, 자동 메모리 관리가 필요하고 프로그램의 복잡성을 줄이고자 하는 환경에서는 가비지 컬렉터가 더 적합할 수 있습니다.

최종적으로, 선택은 프로그램의 요구 사항, 성능 기대치, 개발 환경에 따라 다릅니다.

 

📌일반 포인터와 스마트 포인터의 다른 점은? 

일반 포인터는 객체에 접근 가능한 주소를 보관하는 개념이지만

스마트 포인터의 경우 객체의 소유권을 증명하는 개념

 

📌언리얼에서 사용했을 때 장점?

메모리 누수 방지, 스마트 포인터들은 더 이상 공유된 레퍼런스가 없으면 오브젝트 자동 소멸

명확한 의도, 오브젝트의 소유자를 쉽게 분별할 수 있다

댕글링 포인터 방지, 삭제된 오브젝트를 참조하는 댕글링 포인터를 방지한다.

 

내일 면접 잘보자! 화이팅 :)

 

출처 https://drag0n.tistory.com/19

---

shared_ptr는 C++11에서 도입된 스마트 포인터로, 참조 카운팅을 사용하여 자동으로 메모리를 관리합니다. 여기에 대한 자세한 설명과 관련 기능들을 설명드리겠습니다:

1. std::shared_ptr: 자동으로 참조 카운트를 관리하여, 더 이상 해당 객체를 참조하는 shared_ptr가 없을 때 객체를 자동으로 삭제합니다. 이는 <memory> 헤더에 정의되어 있습니다.
2. 참조 카운팅(Reference Counting): shared_ptr 인스턴스 간에 공유되는 내부 메커니즘으로, 하나의 객체에 대한 shared_ptr의 수를 추적합니다. 참조 카운트가 0이 되면 관련된 객체는 자동으로 소멸됩니다.
3. std::make_shared: 객체를 생성하고 해당 객체를 가리키는 shared_ptr를 반환하는 함수입니다. 이 방식은 객체와 참조 카운트를 위한 메모리 할당을 최적화합니다.
   1. std::shared_ptr<MyClass> sharedPtr1(new MyClass());와 std::make_shared<MyClass>()를 사용하여 std::shared_ptr를 생성하는 방법은 유사한 결과를 가져오지만, 몇 가지 중요한 차이점이 있습니다.
   2. std::shared_ptr<MyClass> sharedPtr1(new MyClass()); 으로 직접 생성 시, 먼저 객체를 위한 메모리 할당이 이루어지고, 그 다음에 shared_ptr의 제어 블록(control block, 참조 카운트를 관리하는 메모리)을 위한 별도의 메모리 할당이 이루어집니다. 예외 안전성에 약간의 문제가 있을 수 있습니다. new MyClass()와 std::shared_ptr 생성자 사이에 예외가 발생하면, new로 할당된 메모리가 해제되지 않을 수 있습니다.
   3. 이와 달리 make_shared 로 만들면 객체와 제어 블록을 위한 메모리를 하나의 할당 단계로 처리해서, 메모리 할당 횟수를 줄이고 성능을 향상시킬 수 있습니다. 또한 make_shared는 예외 안전성을 갖추고 있습니다. 객체 생성 중 예외가 발생하면, 할당된 메모리가 자동으로 해제됩니다.
4. std::allocate_shared: 사용자 정의 메모리 할당자와 함께 shared_ptr를 생성할 때 사용됩니다. 이는 make_shared와 유사하지만, 메모리 할당 방식을 사용자가 커스터마이징할 수 있습니다.
   std::allocate_shared는 std::shared_ptr를 생성할 때 사용자 정의 메모리 할당자를 사용하고자 할 때 활용됩니다. 이 함수는 특히 메모리 할당과 관련하여 성능 최적화가 필요하거나, 특수한 메모리 관리 요구사항이 있는 경우에 유용합니다. 예를 들어, 메모리 풀에서 객체를 할당하고자 할 때 allocate_shared를 사용할 수 있습니다. 메모리 풀은 미리 할당된 메모리 블록을 관리하며, 객체가 필요할 때마다 이 풀에서 메모리를 할당하고 반환하는 방식으로 작동합니다. 이는 힙 할당과 관련된 오버헤드를 줄이고 성능을 향상시키는 데 도움을 줄 수 있습니다.
5. std::weak_ptr: shared_ptr에 대한 비소유 참조를 제공합니다. weak_ptr는 객체의 생명주기에 영향을 주지 않고, 순환 참조를 방지하는 데 유용합니다.
6. std::owner_less: shared_ptr 또는 weak_ptr 인스턴스를 비교하는 데 사용됩니다. 이것은 소유권을 기반으로 포인터들을 비교하며, 정렬이나 컨테이너에 저장하는 데 유용합니다.
7. std::enable_shared_from_this: 클래스 내에서 this 포인터를 사용하여 shared_ptr를 안전하게 생성할 수 있도록 합니다.
8. std::shared_from_this: enable_shared_from_this를 상속받은 객체에서 호출되며, 객체 자신에 대한 shared_ptr를 반환합니다.
9. std::static_pointer_cast, std::dynamic_pointer_cast, std::const_pointer_cast: 이들은 shared_ptr의 캐스팅을 위한 함수들로, 각각 static_cast, dynamic_cast, const_cast와 유사하게 동작합니다.
10. std::get_deleter: shared_ptr에 연결된 삭제자(deleter)를 검색하는 함수입니다. shared_ptr가 사용자 정의 삭제자를 가질 수 있는데, 이 함수를 사용해 해당 삭제자에 접근할 수 있습니다.
11. 삭제자(Deleter): shared_ptr를 생성할 때 사용자 정의 삭제 함수를 제공할 수 있으며, 이는 shared_ptr에 의해 관리되는 객체가 삭제될 때 호출됩니다.
12. 스레드 안전(Thread Safety): shared_ptr는 다중 스레드 환경에서도 참조 카운트의 변경이 안전하도록 설계되었습니다. 그러나 여러 스레드에서 동일한 shared_ptr 인스턴스를 동시에 읽고 쓰는 것은 여전히 스레드 안전하지 않습니다.
13. 사용자 정의 메모리 관리: shared_ptr는 표준 삭제자 외에 사용자 정의 메모리 할당자 또는 삭제자를 사용하여 객체의 할당과 해제 방식을 사용자가 정의할 수 있도록 합니다.

순환 참조(Circular References): shared_ptr 간에 순환 참조가 발생하면, 참조 카운트가 영원히 0이 되지 않아 메모리 누수가 발생할 수 있습니다. 이를 방지하기 위해 weak_ptr를 사용하여 순환 참조를 끊을 수 있습니다.

 

make_shared<this>를 사용하는 것은 C++에서 문제가 될 수 있다. 이유는 몇 가지가 있다

1. 잘못된 사용: std::make_shared 함수는 타입을 템플릿 인자로 받아 새로운 객체를 생성하는데, this 포인터는 이미 존재하는 객체를 가리키기 때문에, make_shared<this>는 문법적으로 잘못됐어.
2. 중복된 소유권 문제: 만약 make_shared<this>가 작동한다고 하더라도, 이는 같은 객체에 대해 두 개의 별도 shared_ptr 인스턴스를 생성하는 것이 되고, 이는 중복된 소유권과 관련된 문제를 야기해.
3. 메모리 누수: 각 shared_ptr는 참조 카운트를 관리해. 만약 한 객체에 대해 두 개의 shared_ptr가 생성되면, 각각의 참조 카운트가 독립적으로 작동해. 이는 객체가 적절하게 해제되지 않는 메모리 누수로 이어질 수 있어.
4. 예기치 않은 소멸: 한 shared_ptr가 소멸되면 관리하는 객체도 같이 소멸할 수 있어. 만약 다른 shared_ptr도 같은 객체를 가리킨다면, 이는 예기치 않은 객체 소멸로 이어질 수 있어.
5. this 포인터와의 충돌: this 포인터는 현재 객체에 대한 포인터야. make_shared를 사용해 this를 가리키는 새 shared_ptr를 생성하려 하면, 원래 객체와 새로운 shared_ptr 간에 충돌이 발생할 수 있어.
6. 스레드 안전성 문제: 동일 객체에 대한 여러 shared_ptr 인스턴스가 있을 때, 참조 카운트의 조정은 스레드 안전하지 않을 수 있어. 이는 데이터 무결성 문제로 이어질 수 있어.
7. 설계 문제: this를 사용하여 shared_ptr를 생성하는 것은 일반적인 객체 소유권의 원칙에 어긋나. 이는 객체의 생명주기 관리와 소유권에 대한 혼란을 초래할 수 있어.
8. 대안의 부재: enable_shared_from_this를 사용하면 현재 객체에 대한 안전한 shared_ptr을 생성할 수 있어, make_shared<this> 같은 잘못된 사용을 피할 수 있어.
9. 디버깅 어려움: 이런 문제들은 디버깅을 어렵게 만들어. 어떤 shared_ptr가 객체를 소멸시켰는지 추적하기가 어려워져.
10. 설계 가이드 위반: shared_ptr와 같은 스마트 포인터는 객체의 소유권과 생명주기를 명확하게 관리하기 위해 설계됐는데, make_shared<this> 사용은 이러한 설계 가이드를 무시하는 것이 되어.

결론적으로, this 포인터를 사용하여 shared_ptr를 생성하는 것은 많은 문제를 야기할 수 있으며, 올바른 사용법이 아니야. 대신, enable_shared_from_this를 사용하는 것이 더 안전하고 일반적인 방법이야.

 

 

C 캐스팅과 C++ 캐스팅의 차이를 간단히 요약하면 이렇습니다

1. C 캐스팅: C에서는 기본적으로 (type) 형식의 캐스팅을 사용해요. 이 방식은 간단하지만 타입 안전성이나 명확성이 부족해요.
2. C++ 캐스팅: C++에서는 static_cast, dynamic_cast, const_cast, reinterpret_cast와 같이 다양한 캐스팅 연산자를 제공해요. 이들은 각각 특정한 사용 목적과 타입 안전성을 가지고 있어요.
3. 타입 안전성: C++의 캐스팅 연산자들은 C보다 더 타입 안전성을 제공해요. 예를 들어, dynamic_cast는 런타임에 타입 체크를 수행하죠.

 

 

`static_pointer_cast`, `dynamic_pointer_cast`, `const_pointer_cast`는 `shared_ptr`에 대한 캐스팅 연산을 수행하는 C++ 표준 라이브러리 함수들입니다. 이들은 각각 C++의 기본 캐스팅 연산자인 `static_cast`, `dynamic_cast`, `const_cast`와 유사하게 동작합니다. `reinterpret_cast`는 `shared_ptr`에 대응되는 별도의 캐스팅 함수가 없습니다.

 

예시 코드

1. `static_pointer_cast`

   ```cpp
   class Base {};
   class Derived : public Base {};

   shared_ptr<Base> basePtr = make_shared<Derived>();
   shared_ptr<Derived> derivedPtr = static_pointer_cast<Derived>(basePtr);
   ```

`static_pointer_cast`는 컴파일 시간에 타입 캐스팅이 유효한지 검사합니다. 일반적으로 업캐스팅과 다운캐스팅에 사용됩니다.

2. `dynamic_pointer_cast`

   ```cpp
   class Base { virtual void foo() {} };
   class Derived : public Base {};

   shared_ptr<Base> basePtr = make_shared<Derived>();
   shared_ptr<Derived> derivedPtr = dynamic_pointer_cast<Derived>(basePtr);
   ```

 

`dynamic_pointer_cast`는 런타임에 타입 안전성을 확인합니다. 주로 다형성을 사용하는 클래스에서 다운캐스팅에 사용됩니다.

3. `const_pointer_cast`

   ```cpp
   shared_ptr<const int> constIntPtr = make_shared<const int>(10);
   shared_ptr<int> intPtr = const_pointer_cast<int>(constIntPtr);
   ```

`const_pointer_cast`는 객체의 `const` 또는 `volatile` 속성을 추가하거나 제거할 때 사용됩니다.

C++ 캐스팅 연산자 비교

1. `static_cast`

   컴파일 시간에 타입 캐스팅의 유효성을 확인합니다. 관련 타입 간의 변환에 사용되며, 다운캐스팅과 업캐스팅 모두 가능합니다.

2. `dynamic_cast`

   런타임에 타입 안전성을 검사합니다. 주로 다형성을 가진 클래스에서의 다운캐스팅에 사용되며, RTTI(Run-Time Type Information)을 필요로 합니다.

3. `const_cast`

   객체의 `const` 또는 `volatile` 속성을 추가하거나 제거하는데 사용됩니다. 주로 `const` 메서드에서 내부 데이터를 수정할 필요가 있을 때 사용됩니다.

4. `reinterpret_cast`

   저수준 캐스팅으로, 포인터 타입을 완전히 다른 타입으로 변환합니다. 타입 안전성이 보장되지 않으며, 사용 시 주의가 필요합니다.

`static_pointer_cast`, `dynamic_pointer_cast`, `const_pointer_cast`는 이러한 기본 캐스팅 연산자의 기능을 `shared_ptr`에 적용한 것으로, 각각의 목적과 사용법은 기본 캐스팅 연산자와 유사합니다.