设计模式之代理模式

个人初步理解：这个模式是对父子类再一次封装。

父类

#pragma once
class Subject
{
public:
    virtual ~Subject();

    virtual void Request() = 0;

protected:
    Subject();
};

#include "Subject.h"


Subject::Subject()
{
}


Subject::~Subject()
{
}

 

派生类：子类

#pragma once
#include "Subject.h"
class ConcreateSubject :
    public Subject
{
public:
    ConcreateSubject();
    ~ConcreateSubject();

    void Request();
};

#include "ConcreateSubject.h"
#include <iostream>


ConcreateSubject::ConcreateSubject()
{
}


ConcreateSubject::~ConcreateSubject()
{
}

void ConcreateSubject::Request()
{
    std::cout << "ConcreateSubject::request..." << std::endl;
}

 

代理类

#pragma once
#include "ConcreateSubject.h"

class Proxy
{
public:
    Proxy();
    ~Proxy();

    Proxy(Subject *sub);

    void Request();

private:
    Subject *m_sub;
};

#include "Proxy.h"
#include <iostream>


Proxy::Proxy()
{
}


Proxy::~Proxy()
{
// 类内的指针是否需要delete
/*
    if (m_sub)
    {
        delete m_sub;
        m_sub = NULL;
    }
*/
}

Proxy::Proxy(Subject *sub)
{
    m_sub = sub;
}

void Proxy::Request()
{
    std::cout << "Proxy::request..." << std::endl;

    m_sub->Request();
}

 

测试

#include <iostream>
#include "Proxy.h"

int main()
{
    Subject *sub = new ConcreateSubject();

    Proxy *p = new Proxy(sub);

    p->Request();

    if (sub)
    {
        delete sub;
        sub = NULL;
    }

    if (p)
    {
        delete p;
        p = NULL;
    }
    std::cout << "Hello World!\n"; 
}

 

这里有一个问题，对于类内的指针是否需要delete，并指NULL处理。提出的原因是有时会new classA(new classB), 这种方式。后续如果碰到再说这个。