一道计算奖金的编程题--三种不同的解法

题目：

利润分级，奖金的比例不同，例如10万以内比例10%，10万到20万比例是5%

解法一：

比较简单的方案就是利用if-else，效率也是最高，这里就不写这部分代码了

解法二：

利用数据结构来处理，直接上代码static BonusCalcLevel Level[] = {{100000.0, 0.10},
{200000.0-100000.0,0.05},
{400000.0-200000.0, 0.03},
{600000.0-400000.0, 0.015},
{1000000.0-600000.0, 0.007},
{0.0, 0.003}};
void BonusCalcSwitchTestDrive()
{
double income, bonus = 0;
std::cin >> income;
for (int i = 0; i < sizeof(Level)/sizeof(Level[0]); i++)
{
if (income > Level[i].income_th)
{
bonus += Level[i].income_th * Level[i].factor;
income -= Level[i].income_th;
}
else
{
bonus += income * Level[i].factor;
break;
}
}
std::cout << bonus << std::endl;
}将不同的阶段的奖金求和，在每次计算的过程中加入了判断的代码，增加了开销
解法三：

祭出设计模式中的装饰者模式，每一个部分就是求和

class Bonus {
public:
Bonus() : bonus(0.0) {}
virtual ~Bonus() {}
virtual double getBonus() { return bonus; }
private:
double bonus;
};
class BonusCalc : public Bonus {
public:
BonusCalc(double income, double x, Bonus *pB):_income(income),_factor(x),_pB(pB) {}
virtual ~BonusCalc()
{
}
virtual double getBonus();
private:
double _factor;
double _income;
Bonus *_pB;
};
double BonusCalc::getBonus()
{
return _pB->getBonus() + _income*_factor;
}
struct BonusCalcLevel {
double income_th;
double factor;
};

void BonusCalcTestDrive()
{
double income;
std::cin >> income;
Bonus *pB = new Bonus();
Bonus *pBC = pB;
std::list<Bonus*> container;
for (int i = 0; i < sizeof(Level)/sizeof(Level[0]); i++)
{
if (income > Level[i].income_th)
{
pBC = new BonusCalc(Level[i].income_th, Level[i].factor, pBC);

}
else if (income > 0)
{
pBC = new BonusCalc(income, Level[i].factor, pBC);
}
else
{

break;
}
container.push_back(pBC);
income -= Level[i].income_th;
}
std::cout << pBC->getBonus() << std::endl;
for (std::list<Bonus*>::iterator it = container.begin(); it != container.end(); it++)
{
Bonus *tmp = *it;
delete tmp;
}
delete pB;
}
效率的降低来源于对virtual function的访问，增加了一次指针的访问

trade-off：程序的结构优势与函数性能优势之间的权衡，程序中20%的代码影响着效率，核心的算法部分理应用最直接的方式