代码:
void CMy2_0Dlg::OnBnChickedOk()
{
// TODO: Add your control notification handler code here
UINT valA=GetDlgItemInt(IDC_EDIT1,NULL,FALSE);
UINT valB=GetDlgItemInt(IDC_EDIT2,NULL,FALSE);
SetDlgItemInt(IDC_EDIT3,valA*,valB,FALSE);
}
void CMy2_0Dlg::OnBnChickedCancel()
{
// TODO: Add your control notification handler code here
SetDlgItemInt(IDC_EDIT1 ,0,FALSE);
SetDlgItemInt(IDC_EDIT2 ,0,FALSE);
SetDlgItemInt(IDC_EDIT3 ,0,FALSE);
}
面向对象,并不是类越多越好,类的划分是为了封装,但分类的基础是抽象,具有相同的属性和功能的抽象集合才是类。
#include <iostream>
#include<string>
using std::cout;
using std::cin;
using std::endl;
//基类
class CashSuper
{
public:
virtual double AccepCash(double money)=0;
};
class CashNormal : public CashSuper
{
public:
double AccepCash(double money)
{
return money;
}
};
class CashRebate : public CashSuper
{
public:
CashRebate(double rebate):m_moneyRebate(1.0)
{
m_moneyRebate=rebate;
}
double AccepCash(double money)
{
return money*m_moneyRebate;
}
private:
double m_moneyRebate;
};
class CashReturn : public CashSuper
{
public:
CashReturn(double returnMoney,double condition):m_moneyReturn(0.0),m_moneyCondition(0.0)
{
m_moneyReturn=returnMoney;
m_moneyCondition=condition;
}
double AccepCash(double money)
{
double resultMoney=money;
if (money>m_moneyCondition)
{
resultMoney=money-(money/m_moneyCondition)*m_moneyReturn;
}
return resultMoney;
}
private:
double m_moneyReturn;
double m_moneyCondition;
};
typedef enum _Type
{
eNormal = 0,//正常收费
e80Discount,
e70Discount,
e50Discount,
eReturn //满300减100
}MyDiscount;
//工厂设计模式
class CashFactory
{
public:
static CashSuper* CreateCashAccept(MyDiscount type)
{
CashSuper* cs = NULL;
switch (type)
{
case eNormal:
cs = new CashNormal();
break;
case e80Discount:
cs = new CashRebate(0.8);
break;
case e70Discount:
cs = new CashRebate(0.7);
break;
case e50Discount:
cs = new CashRebate(0.5);
break;
case eReturn:
cs = new CashReturn(100,300);
break;
default:
cs = new CashNormal();
break;
}
return cs;
}
};
void main()
{
double Price;
double Num;
int selectedIndex;
cout << "please Input you Price: " << endl;
cin >> Price;
cout << "please Input you Num: " << endl;
cin >> Num;
cout << "please Input you Discount: "
<< "0:正常收费, 1:8折, 2:7折, 3:5折, 4:满300减100" << endl;
cin >> selectedIndex;
CashSuper* cash = CashFactory::CreateCashAccept((MyDiscount)selectedIndex);
cout << "The total Price is "<< cash->AccepCash(Price * Num) << endl;
}
简单工厂设计模式解决对象创建问题,由工厂本身包括所有的收费方式,商场可能改进收费方式。
对于算法的时常变动,要用策略模式;策略模式定义了算法家族,分别封装起来,让他们之间相互替换,让算法的变化不影响使用算法的用户。
策略模式
本题的策略模式
代码:
#include <iostream>
#include<string>
using std::cout;
using std::cin;
using std::endl;
//基类
class CashSuper
{
public:
virtual double AccepCash(double money)=0;
};
class CashNormal : public CashSuper
{
public:
double AccepCash(double money)
{
return money;
}
};
class CashRebate : public CashSuper
{
public:
CashRebate(double rebate):m_moneyRebate(1.0)
{
m_moneyRebate=rebate;
}
double AccepCash(double money)
{
return money*m_moneyRebate;
}
private:
double m_moneyRebate;
};
class CashReturn : public CashSuper
{
public:
CashReturn(double returnMoney,double condition):m_moneyReturn(0.0),m_moneyCondition(0.0)
{
m_moneyReturn=returnMoney;
m_moneyCondition=condition;
}
double AccepCash(double money)
{
double resultMoney=money;
if (money>m_moneyCondition)
{
resultMoney=money-(money/m_moneyCondition)*m_moneyReturn;
}
return resultMoney;
}
private:
double m_moneyReturn;
double m_moneyCondition;
};
//策略模式
class Context
{
public:
void SetContext(CashSuper* cashsuper)
{
m_pCashSuper = cashsuper;
};
double GetResult(double money)
{
return m_pCashSuper->AccepCash(money);
};
~Context()
{
if (m_pCashSuper != NULL)
{
delete m_pCashSuper;
m_pCashSuper = NULL;
}
};
private:
CashSuper* m_pCashSuper;
};
typedef enum _Type
{
eNormal = 0,//正常收费
e80Discount,
e70Discount,
e50Discount,
eReturn //满300减100
}MyDiscount;
void main()
{
double Price;
double Num;
int selectedIndex;
//Price
cout << "please Input you Price: " << endl;
cin >> Price;
//Num
cout << "please Input you Num: " << endl;
cin >> Num;
//Discount
cout << "please Input you Discount: "
<< "0:正常收费, 1:8折, 2:7折, 3:5折, 4:满300减100" << endl;
cin >> selectedIndex;
Context context;
switch (selectedIndex)
{
case eNormal:
context.SetContext( new CashNormal());
break;
case e80Discount:
context.SetContext( new CashRebate(0.8));
break;
case e70Discount:
context.SetContext( new CashRebate(0.7));
break;
case e50Discount:
context.SetContext( new CashRebate(0.5));
break;
case eReturn:
context.SetContext( new CashReturn(100, 300));
break;
default:
context.SetContext( new CashNormal());
break;
}
cout << "The total Price is "<< context.GetResult(Num * Price) << endl;
}
简单工厂设计模式可以将客户端的算法转移;
简单工厂模式需要让客户端认识两个类,CashSuper和CashFactory,而策略模式与简单工厂结合的用法,客户端就只需要认识一个类CashContext就可以了,耦合更加降低了。
策略模式与简单工厂模式结合
#include <iostream>
#include<string>
using std::cout;
using std::cin;
using std::endl;
//基类
class CashSuper
{
public:
virtual double AccepCash(double money)=0;
};
class CashNormal : public CashSuper
{
public:
double AccepCash(double money)
{
return money;
}
};
class CashRebate : public CashSuper
{
public:
CashRebate(double rebate):m_moneyRebate(1.0)
{
m_moneyRebate=rebate;
}
double AccepCash(double money)
{
return money*m_moneyRebate;
}
private:
double m_moneyRebate;
};
class CashReturn : public CashSuper
{
public:
CashReturn(double returnMoney,double condition):m_moneyReturn(0.0),m_moneyCondition(0.0)
{
m_moneyReturn=returnMoney;
m_moneyCondition=condition;
}
double AccepCash(double money)
{
double resultMoney=money;
if (money>m_moneyCondition)
{
resultMoney=money-(money/m_moneyCondition)*m_moneyReturn;
}
return resultMoney;
}
private:
double m_moneyReturn;
double m_moneyCondition;
};
typedef enum _Type
{
eNormal = 0,//正常收费
e80Discount,
e70Discount,
e50Discount,
eReturn //满300减100
}MyDiscount;
class CashContext
{
public:
CashContext(MyDiscount discount)
:m_pCashSuper(NULL)
{
switch (discount)
{
case eNormal:
m_pCashSuper = new CashNormal();
break;
case e80Discount:
m_pCashSuper = new CashRebate(0.8);
break;
case e70Discount:
m_pCashSuper = new CashRebate(0.7);
break;
case e50Discount:
m_pCashSuper = new CashRebate(0.5);
break;
case eReturn:
m_pCashSuper = new CashReturn(100, 300);
break;
default:
m_pCashSuper = new CashNormal();
break;
}
};
double GetResult(double money)
{
return m_pCashSuper->AccepCash(money);
};
~CashContext()
{
if (m_pCashSuper != NULL)
{
delete m_pCashSuper;
m_pCashSuper = NULL;
}
};
private:
CashSuper* m_pCashSuper;
};
void main()
{
double Price;
double Num;
int selectedIndex;
cout << "please Input you Price: " << endl;
cin >> Price;
cout << "please Input you Num: " << endl;
cin >> Num;
cout << "please Input you Discount: "
<< "0:正常收费, 1:8折, 2:7折, 3:5折, 4:满300减100" << endl;
cin >> selectedIndex;
CashContext cash((MyDiscount)selectedIndex);
cout << "The total Price is "<< cash.GetResult(Price * Num) << endl;
}
策略模式解析:
一:策略模式是一种定义一系列算法的方法,从概念上看,所有的这些算法完成的都是相同的工作,只是实现不同,他可以以相同的方式调用所有的算法,减少了各种算法类与使用算法类之间的耦合
二:策略模式的 Strategy 类层次为 Context 定义了一系列的可供重用的算发或行为。集成有助于析去出这些算法中的公共功能。
三:策略模式简化了单元测试,因为每一个算法都有自己的类,可以通过自己的接口单独测试。
四:当不同的行为堆砌在一个类中时,就很难避免使用条件语句来选择合适的行为。将这些行为封装在一个个独立的Strategy 类中,可以在使用这些行为的类中消除条件语句。
五:策略模式就是来封装算法的,但在实践中,我们发现可以用它来封装几乎任何类型的规则,只是在分析过程中听到需要在不同的时间应用不同的业务规则,就可以考虑用策略模式处理这些变化的可能性。
六:具体的实现本应由客户实现,将其转移给策略模式Context对象。
七:任何需求的变化都需要成本。