1.7 以函数对象取代函数

【1】源代码

// 重构前
class Account
{
public:
    // 以下函数没有实际意义，为了演示使用过多的局部变量
    int gamma(int inputVal, int quantity, int yearTodate);
    {
        int importantValue1 = (inputVal * quantity) + delta();
        int importantValue2 = (inputVal * yearToDate) + 100;
        if ((yearToDate - importantValue1) > 100)
            importantValue2 -= 20;

        int importantValue3 = importantValue2 * 7;
        // do something....
        return importantValue3 - 2 * importantValue1;
    }

    int delta() const { return 100; }
};

【2】以函数对象取代函数

// 以函数对象取代函数
class Account
{
public:
    int gamma(int inputVal, int quantity, int yearTodate);
    int delta() const
    {
        return 100;
    }
};

// 修改Account类中的旧函数
int Account::gamma(int inputVal, int quantity, int yearToDate)
{
    Gamma gm(this, inputVal, quantity, yearToDate);
    return gm.compute();
}

// 1.声明一个新类，提供一个const字段用以保存源对象
// 2.原函数的每一个参数和每一个临时变量分别以一个字段保存
// 3.加一个构造函数
class Gamma
{
public:
    Gamma(Account* src, int inputVal, int quantity, int yearToDate)
        : m_pAccount(src)
        , m_nInputVal(inputVal)
        , m_nQuantity(quantity)
        , m_nYearToDate(yearToDate)
    {}

    int compute()
    {
        m_nImportantValue1 = (m_nInputVal * m_nQuantity) + m_pAccount->delta(); // 调用源对象的delta()
        m_nImportantValue2 = (m_nInputVal * m_nYearToDate) + 100;
        if ((m_nYearToDate - m_nImportantValue1) > 100)
        {
            m_nImportantValue2 -= 20;
        }

        m_nImportantValue3 = m_nImportantValue2 * 7;
        // do something....
        return m_nImportantValue3 - 2 * m_nImportantValue1;
    }

private:
    const Account* m_pAccount;

    int m_nInputVal;
    int m_nQuantity;
    int m_nYearToDate;
    int m_nImportantValue1;
    int m_nImportantValue2;
    int m_nImportantValue3;
};

【3】总结

有一个大型函数，其中对局部变量的使用使你无法采用[1.1提炼函数]。

将这个函数放进一个单独对象中，如此一来局部变量就成了对象内的字段。

然后，你可以在同一个对象中将这个大型函数分解为多个小型函数。

Good Good Study, Day Day Up.

顺序 选择 循环 总结