简单工厂模式的有关问题求各位指点！ 以下代码中的singlecoreA和singlecoreB的析构函数如何析构，程序运行出来的结果没有打印这两个的析构
简单工厂模式的问题求各位指点！！！！ 以下代码中的singlecoreA和singlecoreB的析构函数怎么析构，程序运行出来的结果没有打印这两个的析构，
求各位指点！！！！
以下代码中的singlecoreA和singlecoreB的析构函数怎么析构，程序运行出来的结果没有打印这两个的析构
------解决方案--------------------
必须虚析构函数，才能析构子类对象。
析构时，只能析构父类对象。
任何有虚函数的类，最好都要有虚析构函数。
这样delete 父类指针，才能够析构子类对象；
不论，有没有虚析构函数，父类对象总是能够析构的，只要子类析构了，就不会有问题。
------解决方案--------------------
virtual ~SingleCore()
求各位指点！！！！
以下代码中的singlecoreA和singlecoreB的析构函数怎么析构，程序运行出来的结果没有打印这两个的析构
Simple Factory.h
#ifndef SIMPLE FACTORY_H
#define SIMPLE FACTORY_H
#include <iostream>
using namespace std;
//enum CTYPE{CoreA, CoreB};
class SingleCore//处理器
{
public:
SingleCore()
{
cout<<" Constructed SingleCore "<<endl;
}
~SingleCore()
{
cout<<" Destructed SingleCore "<<endl;
}
virtual void show() = 0;
};
class SingleCoreA : public SingleCore//A处理器
{
public:
SingleCoreA()
{
cout<<" Constructed SingleCore A "<<endl;
}
~SingleCoreA()
{
cout<<" Destructed SingleCore A "<<endl;
}
void show()
{
cout<<" SingleCore A "<<endl;
}
};
class SingleCoreB : public SingleCore//B处理器
{
public:
SingleCoreB()
{
cout<<" Constructed SingleCore B "<<endl;
}
~SingleCoreB()
{
cout<<" Destructed SingleCore B "<<endl;
}
void show()
{
cout<<" SingleCore B "<<endl;
}
};
//这两种处理器由唯一的一个工厂来生产
//在内部判断该生产哪一种
class Factory
{
public:
Factory()
{
cout<<" Constructed Factory "<<endl;
}
~Factory()
{
cout<<" Destructed Factory "<<endl;
}
//根据类型判断产生哪一个类的实例
SingleCore *CreateSingleCore(int type)
{
switch(type)
{
case 1:
return new SingleCoreA();
break;
case 2:
return new SingleCoreB();
break;
default:
cout<<"No type of the core"<<endl;
}
}
};
#endif
main.cpp
#include <iostream>
using namespace std;
#include "Simple Factory.h"
int main()
{
int type;
cout<<"Input a type of SingleCore: ";
cin>>type;
if(type == 1 || type == 2)
{
Factory *factory = new Factory();
SingleCore *singlecore = factory->CreateSingleCore(type);
singlecore->show();
delete singlecore;
delete factory;
}
else
cout<<"no creating object"<<endl;
cout<<endl;
return 0;
}
------解决方案--------------------
必须虚析构函数，才能析构子类对象。
析构时，只能析构父类对象。
任何有虚函数的类，最好都要有虚析构函数。
这样delete 父类指针，才能够析构子类对象；
不论，有没有虚析构函数，父类对象总是能够析构的，只要子类析构了，就不会有问题。
------解决方案--------------------
virtual ~SingleCore()