분석 함수 관리 포인터 구성원

분석 함수는 바로 이러한 특수 함수로 필요한 자원 회수를 완성하고 클래스 구조 함수의 보충 취소 클래스 대상으로 삼을 수 있다
분석 함수를 자동으로 호출합니다
 
동적 할당된 객체는 해당 객체를 가리키는 포인터가 삭제된 경우에만 취소됩니다.
 
대상의 인용이나 포인터가 작용역을 초과할 때 분석 함수를 실행하지 않고 동적 분배 대상을 가리키는 포인터나 실제 쌍만 삭제합니다
대상의 인용이 아닌 상이 작용역을 초과할 때 분석 함수를 실행합니다
 
용기를 취소할 때 (표준 라이브러리 용기든 내장 수조든) 용기의 클래스 형식 요소의 분석 함수를 실행합니다.
용기의 원소는 항상 역순으로 취소됩니다. 먼저 사이즈 () - 1로 표시된 원소를 취소하고, 그 다음에 사이즈 () - 2로 표시된 원소를 취소합니다.
원소...마지막으로 [0]로 표시된 원소를 취소합니다
 
분석 함수는 일반적으로 구조 함수나 대상의 생명기 내에 얻은 자원을 방출하는 데 쓰인다
만약 클래스가 분석 함수를 필요로 한다면, 그것도 부수 조작부호와 복제 구조 함수를 필요로 한다. 이것은 유용한 경험 법칙이고, 이 규칙이다
흔히 삼법칙이라고 하는데, 만약 분석 함수가 필요하다면, 이 세 개의 복제 제어 구성원이 모두 필요하다는 것을 가리킨다
 
분석 함수는 자원을 방출하는 데 한정된 것이 아니다. 일반적으로 분석 함수는 임의의 조작을 수행할 수 있는데 이 조작은 클래스 디자이너가 원하는 것이다
이 클래스 대상의 사용이 끝난 후에 실행된
 
복제 구조 함수나 값 부여 조작부호와 달리 컴파일러는 항상 우리를 위해 분석 함수를 합성한다
 
합성 분석 함수는 대상이 만들어졌을 때의 역순으로 모든 비static 구성원을 취소합니다. 따라서 구성원이 클래스에서 설명하는 역순으로
구성원을 취소하고 클래스 유형의 모든 구성원에 대해 합성 분석 함수를 이 구성원의 분석 함수로 호출하여 대상을 취소합니다
 
내장 형식 구성원이나 복합 형식의 구성원을 취소하는 것은 아무런 영향이 없다. 특히 합성 분석 함수는 바늘 구성원이 가리키는
대상
 
분석 함수는 구성원 함수로, 클래스 이름 앞에 대자호 (~) 를 붙이는 이름이며, 반환값이 없고, 형삼이 없다
, 어떤 형삼도 지정할 수 없기 때문에 분석 함수를 다시 불러올 수 없습니다. 한 클래스에 여러 개의 구조 함수를 정의할 수 있지만 제시할 수 있습니다.
클래스의 모든 대상에 적용되는 분석 함수를 제공합니다
 
분석 함수와 복제 구조 함수나 부수 조작부호 간의 중요한 차이점은 우리가 자신의 분석 함수를 작성하더라도
분석 함수 여전히 실행
 
포인터를 포함하는 클래스는 포인터를 복제할 때 포인터의 주소만 복제하고 포인터가 가리키는 방향은 복제하지 않기 때문에 복사 제어에 특히 주의해야 한다
대상
 
대부분의 C++ 클래스는 다음 세 가지 방법 중 하나로 포인터 구성원을 관리합니다. 1.포인터 멤버는 일반적인 포인터 동작을 취합니다.이런 종류는 지침의 모든 결함을 가지고 있지만 특별한 복제 제어가 필요 없다.클래스는 이른바'스마트 포인터'행위를 실현할 수 있다. 포인터가 가리키는 대상은 공유되지만 클래스는 현수 포인터를 방지할 수 있다.클래스는 값형 행위를 취하고 바늘이 가리키는 대상은 유일하며 각 클래스 대상이 독립적으로 관리한다
 
포인터 구성원이 있고 기본 합성 복제 구조 함수를 사용하는 클래스는 일반 포인터의 모든 결함을 가진다. 특히 클래스 자체는 피할 수 없다.
현수 지침
 
권장: 포인터 멤버에 포인터 멤버가 있는 객체를 관리하려면 일반적으로 복제 제어 멤버를 정의해야 하며, 작성된 버전에 의존하는 경우 클래스 사용자에게 부담을 주고
구성원이 가리키는 대상이 존재하도록 보증해야 하며, 대상이 이 대상을 가리키기만 하면
 
바늘 구성원이 있는 클래스를 관리하기 위해서는 복제 제어 구성원 세 개를 정의해야 한다. 복제 구조 함수, 값 부여 조작부호와 분석 함수이다.
이러한 구성원은 포인터 구성원의 포인터 또는 값 동작을 정의할 수 있습니다.
 

#include <iostream>
#include <string>
#include <vector>
using namespace std;

class Apple{
    int i;    
public:
    Apple(int n):i(n){}
    ~Apple(){
        cout << "Aapple No." << i << " destructed" << endl;       
    }  
}; 


// class that has a pointer member that behaves like a plain pointer
class HasPtr {
public:
    // copy of the values we're given
    HasPtr(int *p, int i): ptr(p), val(i) { }
    
    // const members to return the value of the indicated data member
    int *get_ptr() const { return ptr; }
    int get_int() const { return val; }
    
    // non const members to change the indicated data member
    void set_ptr(int *p) { ptr = p; }
    void set_int(int i) { val = i; }
    
    // return or change the value pointed to, so ok for const objects
    int get_ptr_val() const { return *ptr; }
    void set_ptr_val(int val) const { *ptr = val; }

private:
    int *ptr;
    int val;
};


int main()
{
    Apple a(0);   // 
    
    {             // new scope
        Apple a1(1);
    }             //exit local scope; destructor called on a1
    
    Apple *a2 = 0;
    {
        a2 = new Apple(2);
    }             //thouth exit local scope ,destructor not called 
    cout << "Apple a2 still exist " << endl;
    delete a2;    //ok  destructor called on a2
    
    cout << "===========================" << endl; 
    Apple a3(3);
    Apple a4(4);
    Apple a5(5);
    {
          Apple as[3] = {a3,a4,a5};  
    }             //destruct order: a5 a4 a3
    
    int obj = 0;
    HasPtr ptr1(&obj, 42); // int* member points to obj, val is 42
    HasPtr ptr2(ptr1);     // int* member points to obj, val is 42

    ptr1.set_int(0); // changes val member only in ptr1
    cout << ptr2.get_int() << endl;  // returns 42
    cout << ptr1.get_int() << endl;  // returns 0

    ptr1.set_ptr_val(42); // sets object to which both ptr1 and ptr2 point
    cout << ptr2.get_ptr_val() << endl;   // returns 42

    int *ip = new int(42); // dynamically allocated int initialized to 42
    HasPtr ptr(ip, 10);    // Has Ptr points to same object as ip does
    delete ip;             // object pointed to by ip is freed
    ptr.set_ptr_val(0);    // disaster: The object to which Has Ptr points was freed!
    cout << ptr.get_ptr_val() << endl;

    int i = 42;
    HasPtr p1(&i, 42);
    HasPtr p2 = p1;
    cout << p2.get_ptr_val() << endl;
    p1.set_ptr_val(0);
    cout << p2.get_ptr_val() << endl;
     
    return 0;   
}