设计模式之装饰模式(C++实现)

最新推荐文章于 2017-07-16 18:28:00 发布

Manketon

最新推荐文章于 2017-07-16 18:28:00 发布

阅读量589

点赞数

分类专栏： C/C++学习笔记

本文链接：https://blog.csdn.net/Manketon/article/details/37659387

版权

C/C++学习笔记专栏收录该内容

33 篇文章 0 订阅

订阅专栏

#define _CRTDBG_MAP_ALLOC  
#ifdef  _DEBUG  
#include <crtdbg.h> //
#include <iostream>//这两个头文件也必须放在#ifdef #endif 之间
#define new   new(_NORMAL_BLOCK, __FILE__, __LINE__)   //必须这么写才能看到内存泄漏处的文件名和行号
#endif  
#include <vector>
#include <string> //这两个可以随便放


using namespace std;

// base class
class Beverage
{
public:
	virtual string getDescription() = 0;
	virtual float cost() = 0;
	virtual ~Beverage()  //凡是涉及到多态，父类虚函数必须为virtual
	{
		cout <<"调用Beverage的虚析构函数" << endl;
	}
};

// base class of condiment, also a base decorator class
class CondimentDecorator : public Beverage
{
	public:
	Beverage *m_coffee;

	CondimentDecorator()
	{
		m_coffee = NULL;  //这步很重要
	}

	~CondimentDecorator()   //此时它为virtual，尽管没显示声明
	{
		cout << "调用CondimentDecorator的析构函数" << endl;
		delete m_coffee;
		m_coffee = NULL;


	}
};

// coffee DarkRoast
class DarkRoast: public Beverage
{
public:
	string getDescription()
	{
		return "Darkroast";
	}
	float cost()
	{
		return 5.0f;
	}
	~DarkRoast()  //此时它为virtual，尽管没显示声明
	{
		cout << "调用DarkRoast的析构函数" << endl;
	}
};

// coffee Espresso
class Espresso:  public Beverage
{
public:
	string getDescription()
	{
		return "Espresso";
	}
	float cost()
	{
		return 6.5f;
	}
	~Espresso()  //此时它为virtual，尽管没显示声明
	{
		cout << "调用Espresso的析构函数" << endl;
	}
};

// condiment milk
class Milk:  public CondimentDecorator
{
public:
	Milk() {}
	Milk(Beverage *coffee)
	{
		m_coffee = coffee;
	}
	 ~Milk()   //此时它为virtual，尽管没显示声明
	{
		cout << "调用Milk的析构函数" << endl;
		delete m_coffee;
	    m_coffee = NULL;

	}
	string getDescription()
	{
		return m_coffee->getDescription() + ", Milk";
	}
	float cost()
	{
		return m_coffee->cost() + 1.0f;
	}
};

// condiment mocha
class Mocha:  public CondimentDecorator
{
public:
	Mocha()
	{}
	Mocha(Beverage *coffee)
	{
		m_coffee = coffee;
	}
	~Mocha()//此时它为virtual，尽管没显示声明
	{
		cout << "调用Mocha的析构函数" << endl;
        delete m_coffee;
	    m_coffee = NULL;

	}
	string getDescription()
	{
		return m_coffee->getDescription() + ", Mocha";
	}
	float cost()
	{
		return m_coffee->cost() + 0.5f;
	}
};

class DMilk: public Milk
{
public:
	DMilk()
	{
		cout << "调用DMilk构造函数" << endl;
	}
	~DMilk()  //此时它为virtual，尽管没显示声明
	{
		cout << "调用DMilk析构函数" << endl;
	}
};

int main()
{

	Beverage *coffee = new Espresso;
 	coffee = new Milk(coffee);
 	coffee = new Mocha(coffee);
	cout<<coffee->getDescription()<<" $"<<coffee->cost() << endl;
	delete coffee;	
	coffee = NULL;

	Milk *milk = new DMilk;
	delete milk;
	milk = NULL;
	_CrtSetDbgFlag(_CRTDBG_LEAK_CHECK_DF | _CRTDBG_ALLOC_MEM_DF);
	_CrtDumpMemoryLeaks();
	return 0;
}

一个类维护一个虚函数相关的表--vtable(__vfptr指向它)，函数声明前面包含关键字“virtual”的函数，就会创建一个指向该函数的指针（函数指针）被存入vtable中。

虚函数表的作用是用来实现多态，但同时也带来了执行效率和额外内存空间的增加。

再来看虚析构函数，它所存在的意义：基类的指针指向派生类对象，用基类的指针删除派生类对象。

#include <iostream>
using namespace std;

class A
{
public:
    A()
    {
        cout <<"A..."<<endl;
    }
    ~A()
    {
        cout <<"~A..."<<endl;    
    }
};

class B :public A
{
public :
    B()
    {
        cout <<"B..."<<endl;
    }
    ~B()
    {
        cout <<"~B..."<<endl;
        
    }    
};

int main()
{
    A *a = new B();
    delete a;

    return 0 ;
}

输出:

A…

B…

~A…

派生类的析构函数未被调用，为什么呢？

派生类继承自基类，那么基类就只会存在于派生类中，直到派生类调用析构函数后。

假定：基类的析构函数调用比派生类要早，会造成的一种情况就是类成员不存在了，而类本身却还在，但是类存在的情况下，类成员应该还存在。所以这就矛盾了，所以派生类的析构函数会先被调用，基类的析构函数再被调用。

修改一下代码：

#include <iostream>
using namespace std;

class A
{
public:
    A()
    {
        cout <<"A..."<<endl;
    }
    virtual ~A()
    {
        cout <<"~A..."<<endl;    
    }
};

class B :public A
{
public :
    B()
    {
        cout <<"B..."<<endl;
    }
    ~B()
    {
        cout <<"~B..."<<endl;
        
    }    
};

int main()
{
    A *a = new B();
    delete a;

    return 0 ;
}