C++ 포인터 데이터 멤버 : 누가 삭제해야합니까?

Question

그래서 나는이 같은 클래스가 있다고 가정 :

사람이 같은 생성자를 사용하는 경우

class A { 
    public: 
     A(SomeHugeClass* huge_object) 
      : m_huge_object(huge_object) {} 
    private: 
     SomeHugeClass* m_huge_object;   
}; 

:

A* foo = new A(new SomeHugeClass()); 

누구의 책임은 생성자에서 newed 개체에 삭제를 호출하는 것입니다? 이 경우 SomeHugeClass가 익명이므로 A 생성자가 호출 된 범위는 foo 만 삭제할 수 있습니다.

그러나 누군가 이러한 생성자를 사용한다면 어떻게 될까요?

SomeHugeClass* hugeObj = new SomeHugeClass(); 
A* foo = new A(hugeObj); 

그런 다음 호출자는 거시 오 삭제를 특정 시점에서 호출 할 수 있습니까?

파괴시 누수 메모리가 구현됩니까?

저는 많은 방법으로이 작업을 수행하는 프로젝트에서 작업하고 있습니다. 스마트 포인터를 사용하기를 좋아하기 때문에 이전 코드를 사용하여 이전 코드를 활용하는 방법에 대해 이야기해야합니다. 저 할 수 있어요.

Answer 1

: new를 호출하는 일뿐만 아니라 delete를 호출해야합니다. 그렇지 않으면 코드가 너무 지저분 해져서 삭제 된 항목과 삭제 된 항목을 추적 할 수 없습니다.

A :: A가 포인터를 받으면 삭제하지 말아야합니다. 이 간단한 경우를 생각해 :

SomeHugeClass* hugeObj = new SomeHugeClass(); 
A * a1 = new A(hugeObj); 
A * a2 = new A(hugeObj); 

클래스 A가 포인터를 사용하는 다른을 모르는 수 있습니다!

클래스 A가 포인터를 처리하도록하려면 포인터 자체를 만들어야합니다.

은 물론, 당신은 두 경우 모두 처리 할 수 ​​있지만,이 같은 잔인한, 뭔가 수 있습니다 :

A::A() : own_huge_object(true) { 
    m_huge_object = new SomeHugeClass(); 
} 
A::A(SomeHugeClass * huge_object) : own_huge_object(false) { 
    m_huge_object = huge_object; 
} 
A::~A() { if(own_huge_object) delete m_huge_object; } 

Answer 2

호출자는 huge_object을 삭제해야합니다. 생성자가 예외를 throw하고 A의 소멸자가 호출되지 않을 수 있기 때문입니다. 아무도 delete을 호출하지 않기 때문에 구현시 메모리 누수가 발생합니다. 다음과 같이

당신은 shared_ptr을 사용할 수

class A { 
    public: 
     A(shared_ptr<SomeHugeClass> huge_object) 
      : m_huge_object(huge_object) {} 
    private: 
     shared_ptr<SomeHugeClass> m_huge_object;   
}; 

당신이 SomeHugeClass 삭제에 대해 신경 안이 경우. 메모리 누수가 발생할 수

A* foo = new A(new SomeHugeClass()); 

하지 아래에이 줄을 위해서는

Answer 3

, 당신은 무료로 메모리에 있는지 클래스 A의 소멸자 m_huge_object에 의해 지시 할 수

클래스 A의 정의는 다음과 같습니다.

class A { 
    public: 
    A(SomeHugeClass* huge_object) 
     : m_huge_object(huge_object) {} 
    ~A() { delete m_huge_object; } 
    private: 
    SomeHugeClass* m_huge_object;   
}; 

나는 위의 것에 대해 마음에 들지 않는다. 나는 누구든지 기억을 할당하는 사람이 그 기억을 해방시킬 책임이있는 사람이어야한다는 점을 선호한다. 또한 Kirill이 지적한 문제가 있습니다. 그래서 클래스 A의 당신의 정의를 유지하고, 같은 코드는 간단 할 수있다 : 가능 때마다 나는이 간단한 규칙을 따르도록하려고

SomeHugeClass* hugeObj = new SomeHugeClass(); 
A* foo = new A(hugeObj); 
//some code 
delete hugeObj; 
delete foo; 

Answer 4

이것은 더 많은 설계 문제. 전통적으로 const가 아닌 포인터를 생성자에 전달하면 객체가 포인터를 해제해야합니다. 복사본을 보관하려면 const 참조를 전달하십시오. SomeHugeClass는 일반적으로 그 거대한 아니라, 대량의 메모리 소유 (예를 들면 포인터를.) :

대체 디자인이 라인을 따라 뭔가 SomeHugeClass가 효율적으로 구현하는 경우

class A 
{ 
    SomeHugeClass m_; 

public: 
    A(SomeHugeClass x) { m_.swap(x); } 
}; 

이 디자인이 가능을 스왑 (포인터 교환). 생성자는 m_으로 바꾸기 전에 x 복사본을 만들고 생성자에 임시 개체를 전달하면 해당 복사본이 컴파일러에 의해 생략 될 수 있습니다.

SomeHugeClass는 smart_pointer<SomeHugeClass>으로 대체 할 수 있습니다. 임시 식별자이므로 smart_pointer (new SomeHugeClass())를 생성자에 전달할 때 원하는 의미를 부여합니다.

EDIT (명확성을 위해 ...) : 최종 코드는

class A 
{ 
    smart_ptr<SHC> m_; 

public: 
    A(smart_ptr<SHC> x) { m_.swap(x); } 
}; 

당신이 A(new SHC(...)) (NO 복사, A는 파괴됩니다 삭제)를 호출 할 때 필요한 동작을 가지고

, 그리고 때를 같이 보일 수 있습니다 A(smart_ptr<SHC>(a)) (a 사본이 수행되고 A가 소멸되면 해제됩니다).