cpp-클래스-분석 함수

개술

분석 함수 특징:

함수 이름은'~클래스'로 분석 함수를 표시하고 식별하는 데 사용된다

반환값이 없다. 분석 함수는 자신의 소각 행위이고 반환값은 의미가 없다. 반환값이 없는 수신자

인삼 목록이 비어 있기 때문에 분석 함수는 다시 불러오지 않았습니다. 유일한

구조 함수 VS 분석 함수:

구조 함수는 자신의 초기화, 생성 (정의) 대상 시 자동 호출

분석 함수는 자신의 소각, 소각 대상을 자동으로 호출

보조류

class CAnimal
{
public:
    CAnimal() : mGroup(0)
    {
        cout << "CAnimal()" << endl;
    }
    
    CAnimal(int group) : mGroup(group)
    {
        cout << "CAnimal(" << group << ")" << endl;
    }
    
    CAnimal(const CAnimal &other) : mGroup(other.mGroup)
    {
        cout << "CAnimal(const CAnimal &other)" << endl;
    }
    
    ~CAnimal()
    {
        cout << "~CAnimal()" << endl;
    }
    
private:
    int mGroup;
};

class CDog : public CAnimal
{
public:
    CDog() : mLoyal(10)
    {
        cout << "CDog()" << endl;
    }
    
    CDog(int loyal) : CAnimal(1), mLoyal(loyal)
    {
        cout << "CDog(" << loyal << ")" << endl;
    }
    
    CDog(const CDog &other) : CAnimal(other), mLoyal(other.mLoyal)
    {
        cout << "CDog(const CDog &other)" << endl;
    }
    
    ~CDog()
    {
        cout << "~CDog()" << endl;
    }
    
private:
    int mLoyal;
};

class CCat : public CAnimal
{
public:
    CCat() : mCute(20)
    {
        cout << "CCat()" << endl;
    }
    
    CCat(int cute) : CAnimal(2), mCute(cute)
    {
        cout << "CCat(" << cute << ")" << endl;
    }
    
    CCat(const CCat &other) : CAnimal(other), mCute(other.mCute)
    {
        cout << "CCat(const CCat &other)" << endl;
    }
    
    ~CCat()
    {
        cout << "~CCat()" << endl;
    }
    
private:
    int mCute;
};

class CPig : public CAnimal
{
public:
    CPig() : mWeight(30)
    {
        cout << "CPig()" << endl;
    }
    
    CPig(int weight) : CAnimal(3), mWeight(weight)
    {
        cout << "CPig(" << weight << ")" << endl;
    }
    
    CPig(const CPig &other) : CAnimal(other), mWeight(other.mWeight)
    {
        cout << "CPig(const CPig &other)" << endl;
    }
    
    ~CPig()
    {
        cout << "~CPig()" << endl;
    }
    
private:
    int mWeight;
};

class CDonkey : public CAnimal
{
public:
    CDonkey() : mStrength(40)
    {
        cout << "CDonkey()" << endl;
    }
    
    CDonkey(int strength) : CAnimal(4), mStrength(strength)
    {
        cout << "CDonkey(" << strength << ")" << endl;
    }
    
    CDonkey(const CDonkey &other) : CAnimal(other), mStrength(other.mStrength)
    {
        cout << "CDonkey(const CDonkey &other)" << endl;
    }
    
    ~CDonkey()
    {
        cout << "~CDonkey()" << endl;
    }
    
private:
    int mStrength;
};

class CHorse : public CAnimal
{
public:
    CHorse() : mSpeed(50)
    {
        cout << "CHorse()" << endl;
    }
    
    CHorse(int speed) : CAnimal(5), mSpeed(speed)
    {
        cout << "CHorse(" << speed << ")" << endl;
    }
    
    CHorse(const CHorse &other) : CAnimal(other), mSpeed(other.mSpeed)
    {
        cout << "CHorse(const CHorse &other)" << endl;
    }
    
    ~CHorse()
    {
        cout << "~CHorse()" << endl;
    }
    
private:
    int mSpeed;
};

class CFarmLand
{
public:
    CFarmLand() : mArea(5000)
    {
        cout << "CFarmLand()" << endl;
    }
    
    CFarmLand(int area) : mArea(area)
    {
        cout << "CFarmLand(" << area << ")" << endl;
    }
    
    CFarmLand(const CFarmLand &other) : mArea(other.mArea)
    {
        cout << "CFarmLand(const CFarmLand &other)" << endl;
    }
    
    ~CFarmLand()
    {
        cout << "~CFarmLand()" << endl;
    }
    
private:
    int mArea;
};

class CFarm : public CFarmLand
{
public:
    CFarm() : mCapacity(1000)
    {
        cout << "CFarm()" << endl;
    }
    
    CFarm(int capacity) : mCapacity(capacity), mDog(20), mCat(30), mPig(40), CFarmLand(8000)
    {
        cout << "CFarm(" << capacity << ")" << endl;
    }
    
    CFarm(const CFarm &other) : mCapacity(other.mCapacity), mDog(other.mDog), mCat(other.mCat), mPig(other.mPig), CFarmLand(other)
    {
        cout << "CFarm(const CFarm &other)" << endl;
    }
    
    ~CFarm()
    {
        cout << "~CFarm()" << endl;
    }
    
private:
    int mCapacity;
    
private:
    CPig mPig;
    CDog mDog;
    CCat mCat;
};

분석 순서

void destruct()
{
    cout << "-----construct-----" << endl;
    CFarm farm;
    cout << "-----destruct-----" << endl;
}

output:

-----construct-----
CFarmLand()
CAnimal()
CPig()
CAnimal()
CDog()
CAnimal()
CCat()
CFarm()
-----destruct-----
~CFarm()
~CCat()
~CAnimal()
~CDog()
~CAnimal()
~CPig()
~CAnimal()
~CFarmLand()

결론:

클래스 계승 체계에서 구조 함수 순서: 부류 구조 함수(초기화 목록->함수체)->부류 구조 함수(초기화 목록->함수체), 분석 함수 순서와 구조 함수 순서가 정반대: 부류 분석 함수(함수체->데이터 구성원)->부류 분석 함수(함수체->데이터 구성원)

데이터 구성원의 초기화 순서는 데이터 구성원이 클래스에서 정의한 순서와 일치하고 초기화 목록에서 초기화 순서와 무관하며 데이터 구성원의 분석 순서는 데이터 구성원의 초기화 순서와 정반대이다. 즉, 데이터 구성원이 클래스에서 정의한 순서와 정반대이다

자류는 부류 데이터 구성원을 인용할 수 있지만 반대로 부류는 자류 데이터 구성원을 인용할 수 없다. 이 논리에서 자류 분석이 부류 분석보다 먼저 나올 수 있다. 그렇지 않으면 부류 분석이 자류 분석보다 먼저 나오면 자류 분석 함수는 불법 부류 데이터 구성원(이미 분석)에 접근한다

합성 분석 함수

만약에 현식 정의 분석 함수가 없다면 컴파일러는 분석 함수를 합성할 것이다. 일단 현식 정의 분석 함수(실현되지 않았더라도)가 있으면 컴파일러는 분석 함수를 합성하지 않는다. 컴파일러는 개발자가 분석 대상을 어떻게 분석하는지 알고 컴파일러의 도움을 필요로 하지 않는다고 생각한다.
합성 분석 함수 함수체는 비어 있고 다른 것은 현식 정의의 분석 함수와 다를 것이 없으며, 순서대로 클래스 유형 구성원 분석 함수와 부류 분석 함수를 호출한다

class CAdvanceFarm : public CFarm
{
private:
    CHorse mHorse;
    CDonkey mDonkey;
};

CAdvanceFarm에는 명시적으로 정의된 분석 함수가 없으며 컴파일러가 분석 함수를 작성합니다. 작성 분석 함수는 다음과 같습니다.

~CAdvanceFarm() {}

void destruct()
{
    cout << "-----construct-----" << endl;
    CAdvanceFarm farm;
    cout << "-----destruct-----" << endl;
}

output:

-----construct-----
CFarmLand()
CAnimal()
CPig()
CAnimal()
CDog()
CAnimal()
CCat()
CFarm()
CAnimal()
CHorse()
CAnimal()
CDonkey()
-----destruct-----
~CDonkey()
~CAnimal()
~CHorse()
~CAnimal()
~CFarm()
~CCat()
~CAnimal()
~CDog()
~CAnimal()
~CPig()
~CAnimal()
~CFarmLand()